]> git.ipfire.org Git - thirdparty/mdadm.git/blame_incremental - mdadm.h
projects / thirdparty / mdadm.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
imsm: add spares to --examine output.
[thirdparty/mdadm.git] / mdadm.h
... / ...
CommitLineData
1/*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neilb@suse.de>
23 */
24
25#define _GNU_SOURCE
26#define _FILE_OFFSET_BITS 64
27#include <unistd.h>
28#if !defined(__dietlibc__) && !defined(__KLIBC__)
29extern __off64_t lseek64 __P ((int __fd, __off64_t __offset, int __whence));
30#else
31# if defined(__NO_STAT64) || __WORDSIZE != 32
32# define lseek64 lseek
33# endif
34#endif
35
36#include <sys/types.h>
37#include <sys/stat.h>
38#include <stdlib.h>
39#include <time.h>
40#include <sys/time.h>
41#include <getopt.h>
42#include <fcntl.h>
43#include <stdio.h>
44#include <errno.h>
45#include <string.h>
46#include <syslog.h>
47#ifdef __dietlibc__
48#include <strings.h>
49/* dietlibc has deprecated random and srandom!! */
50#define random rand
51#define srandom srand
52#endif
53
54
55#include <linux/kdev_t.h>
56/*#include <linux/fs.h> */
57#include <sys/mount.h>
58#include <asm/types.h>
59#include <sys/ioctl.h>
60#define MD_MAJOR 9
61#define MdpMinorShift 6
62
63#ifndef BLKGETSIZE64
64#define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size in bytes (u64 *arg) */
65#endif
66
67#define DEFAULT_BITMAP_CHUNK 4096
68#define DEFAULT_BITMAP_DELAY 5
69#define DEFAULT_MAX_WRITE_BEHIND 256
70
71/* MAP_DIR should be somewhere that persists across the pivotroot
72 * from early boot to late boot.
73 * Currently /dev seems to be the only option on most distros.
74 */
75#ifndef MAP_DIR
76#define MAP_DIR "/dev/.mdadm"
77#endif /* MAP_DIR */
78/* MAP_FILE is what we name the map file we put in MAP_DIR, in case you
79 * want something other than the default of "map"
80 */
81#ifndef MAP_FILE
82#define MAP_FILE "map"
83#endif /* MAP_FILE */
84/* MDMON_DIR is where pid and socket files used for communicating
85 * with mdmon normally live. It *should* be /var/run, but when
86 * mdmon is needed at early boot then it needs to write there prior
87 * to /var/run being mounted read/write, and it also then needs to
88 * persist beyond when /var/run is mounter read-only. So, to be
89 * safe, the default is somewhere that is read/write early in the
90 * boot process and stays up as long as possible during shutdown.
91 */
92#ifndef MDMON_DIR
93#define MDMON_DIR "/dev/.mdadm/"
94#endif /* MDMON_DIR */
95
96/* FAILED_SLOTS is where to save files storing recent removal of array
97 * member in order to allow future reuse of disk inserted in the same
98 * slot for array recovery
99 */
100#ifndef FAILED_SLOTS_DIR
101#define FAILED_SLOTS_DIR "/dev/.mdadm/failed-slots"
102#endif /* FAILED_SLOTS */
103
104#include "md_u.h"
105#include "md_p.h"
106#include "bitmap.h"
107#include "msg.h"
108
109#include <endian.h>
110/* Redhat don't like to #include <asm/byteorder.h>, and
111 * some time include <linux/byteorder/xxx_endian.h> isn't enough,
112 * and there is no standard conversion function so... */
113/* And dietlibc doesn't think byteswap is ok, so.. */
114/* #include <byteswap.h> */
115#define bswap_16(x) (((x) & 0x00ffU) << 8 | \
116 ((x) & 0xff00U) >> 8)
117#define bswap_32(x) (((x) & 0x000000ffU) << 24 | \
118 ((x) & 0xff000000U) >> 24 | \
119 ((x) & 0x0000ff00U) << 8 | \
120 ((x) & 0x00ff0000U) >> 8)
121#define bswap_64(x) (((x) & 0x00000000000000ffULL) << 56 | \
122 ((x) & 0xff00000000000000ULL) >> 56 | \
123 ((x) & 0x000000000000ff00ULL) << 40 | \
124 ((x) & 0x00ff000000000000ULL) >> 40 | \
125 ((x) & 0x0000000000ff0000ULL) << 24 | \
126 ((x) & 0x0000ff0000000000ULL) >> 24 | \
127 ((x) & 0x00000000ff000000ULL) << 8 | \
128 ((x) & 0x000000ff00000000ULL) >> 8)
129
130#if !defined(__KLIBC__)
131#if BYTE_ORDER == LITTLE_ENDIAN
132#define __cpu_to_le16(_x) (_x)
133#define __cpu_to_le32(_x) (_x)
134#define __cpu_to_le64(_x) (_x)
135#define __le16_to_cpu(_x) (_x)
136#define __le32_to_cpu(_x) (_x)
137#define __le64_to_cpu(_x) (_x)
138
139#define __cpu_to_be16(_x) bswap_16(_x)
140#define __cpu_to_be32(_x) bswap_32(_x)
141#define __cpu_to_be64(_x) bswap_64(_x)
142#define __be16_to_cpu(_x) bswap_16(_x)
143#define __be32_to_cpu(_x) bswap_32(_x)
144#define __be64_to_cpu(_x) bswap_64(_x)
145#elif BYTE_ORDER == BIG_ENDIAN
146#define __cpu_to_le16(_x) bswap_16(_x)
147#define __cpu_to_le32(_x) bswap_32(_x)
148#define __cpu_to_le64(_x) bswap_64(_x)
149#define __le16_to_cpu(_x) bswap_16(_x)
150#define __le32_to_cpu(_x) bswap_32(_x)
151#define __le64_to_cpu(_x) bswap_64(_x)
152
153#define __cpu_to_be16(_x) (_x)
154#define __cpu_to_be32(_x) (_x)
155#define __cpu_to_be64(_x) (_x)
156#define __be16_to_cpu(_x) (_x)
157#define __be32_to_cpu(_x) (_x)
158#define __be64_to_cpu(_x) (_x)
159#else
160# error "unknown endianness."
161#endif
162#endif /* __KLIBC__ */
163
164
165/*
166 * min()/max()/clamp() macros that also do
167 * strict type-checking.. See the
168 * "unnecessary" pointer comparison.
169 */
170#define min(x, y) ({ \
171 typeof(x) _min1 = (x); \
172 typeof(y) _min2 = (y); \
173 (void) (&_min1 == &_min2); \
174 _min1 < _min2 ? _min1 : _min2; })
175
176#define max(x, y) ({ \
177 typeof(x) _max1 = (x); \
178 typeof(y) _max2 = (y); \
179 (void) (&_max1 == &_max2); \
180 _max1 > _max2 ? _max1 : _max2; })
181
182/* general information that might be extracted from a superblock */
183struct mdinfo {
184 mdu_array_info_t array;
185 mdu_disk_info_t disk;
186 __u64 events;
187 int uuid[4];
188 char name[33];
189 unsigned long long data_offset;
190 unsigned long long component_size; /* same as array.size, except in
191 * sectors and up to 64bits.
192 */
193 unsigned long long custom_array_size; /* size for non-default sized
194 * arrays (in sectors)
195 */
196 int reshape_active;
197 unsigned long long reshape_progress;
198 union {
199 unsigned long long resync_start; /* per-array resync position */
200 unsigned long long recovery_start; /* per-device rebuild position */
201 #define MaxSector (~0ULL) /* resync/recovery complete position */
202 };
203 unsigned long safe_mode_delay; /* ms delay to mark clean */
204 int new_level, delta_disks, new_layout, new_chunk;
205 int errors;
206 unsigned long cache_size; /* size of raid456 stripe cache*/
207 int mismatch_cnt;
208 char text_version[50];
209 void *update_private; /* for passing metadata-format
210 * specific update data
211 * between successive calls to
212 * update_super()
213 */
214
215 int container_member; /* for assembling external-metatdata arrays
216 * This is to be used internally by metadata
217 * handler only */
218 int container_enough; /* flag external handlers can set to
219 * indicate that subarrays have not enough (-1),
220 * enough to start (0), or all expected disks (1) */
221 char sys_name[20];
222 struct mdinfo *devs;
223 struct mdinfo *next;
224
225 /* Device info for mdmon: */
226 int recovery_fd;
227 int state_fd;
228 #define DS_FAULTY 1
229 #define DS_INSYNC 2
230 #define DS_WRITE_MOSTLY 4
231 #define DS_SPARE 8
232 #define DS_BLOCKED 16
233 #define DS_REMOVE 1024
234 #define DS_UNBLOCK 2048
235 int prev_state, curr_state, next_state;
236
237};
238
239struct createinfo {
240 int uid;
241 int gid;
242 int autof;
243 int mode;
244 int symlinks;
245 struct supertype *supertype;
246};
247
248#define Name "mdadm"
249
250enum mode {
251 ASSEMBLE=1,
252 BUILD,
253 CREATE,
254 MANAGE,
255 MISC,
256 MONITOR,
257 GROW,
258 INCREMENTAL,
259 AUTODETECT,
260};
261
262extern char short_options[];
263extern char short_bitmap_options[];
264extern char short_bitmap_auto_options[];
265extern struct option long_options[];
266extern char Version[], Usage[], Help[], OptionHelp[],
267 Help_create[], Help_build[], Help_assemble[], Help_grow[],
268 Help_incr[],
269 Help_manage[], Help_misc[], Help_monitor[], Help_config[];
270
271/* for option that don't have short equivilents, we assign arbitrary
272 * numbers later than any 'short' character option.
273 */
274enum special_options {
275 AssumeClean = 300,
276 BitmapChunk,
277 WriteBehind,
278 ReAdd,
279 NoDegraded,
280 Sparc22,
281 BackupFile,
282 HomeHost,
283 AutoHomeHost,
284 Symlinks,
285 AutoDetect,
286 Waitclean,
287 DetailPlatform,
288 KillSubarray,
289 UpdateSubarray,
290 IncrementalPath,
291 NoSharing,
292 HelpOptions,
293 Brief,
294 ManageOpt,
295 Add,
296 Remove,
297 Fail,
298 MiscOpt,
299 WaitOpt,
300 ConfigFile,
301 ChunkSize,
302 WriteMostly,
303 Layout,
304 Auto,
305 Force,
306 SuperMinor,
307 EMail,
308 ProgramOpt,
309 Increment,
310 Fork,
311 Bitmap,
312 RebuildMapOpt,
313 InvalidBackup,
314};
315
316/* structures read from config file */
317/* List of mddevice names and identifiers
318 * Identifiers can be:
319 * uuid=128-hex-uuid
320 * super-minor=decimal-minor-number-from-superblock
321 * devices=comma,separated,list,of,device,names,with,wildcards
322 *
323 * If multiple fields are present, the intersection of all matching
324 * devices is considered
325 */
326#define UnSet (0xfffe)
327struct mddev_ident {
328 char *devname;
329
330 int uuid_set;
331 int uuid[4];
332 char name[33];
333
334 int super_minor;
335
336 char *devices; /* comma separated list of device
337 * names with wild cards
338 */
339 int level;
340 int raid_disks;
341 int spare_disks;
342 struct supertype *st;
343 int autof; /* 1 for normal, 2 for partitioned */
344 char *spare_group;
345 char *bitmap_file;
346 int bitmap_fd;
347
348 char *container; /* /dev/whatever name of container, or
349 * uuid of container. You would expect
350 * this to be the 'devname' or UUID
351 * of some other entry.
352 */
353 char *member; /* subarray within a container */
354
355 struct mddev_ident *next;
356 union {
357 /* fields needed by different users of this structure */
358 int assembled; /* set when assembly succeeds */
359 };
360};
361
362/* List of device names - wildcards expanded */
363struct mddev_dev {
364 char *devname;
365 int disposition; /* 'a' for add, 'r' for remove, 'f' for fail.
366 * Not set for names read from .config
367 */
368 char writemostly; /* 1 for 'set writemostly', 2 for 'clear writemostly' */
369 char re_add;
370 char used; /* set when used */
371 struct mddev_dev *next;
372};
373
374typedef struct mapping {
375 char *name;
376 int num;
377} mapping_t;
378
379
380struct mdstat_ent {
381 char *dev;
382 int devnum;
383 int active;
384 char *level;
385 char *pattern; /* U or up, _ for down */
386 int percent; /* -1 if no resync */
387 int resync; /* 3 if check, 2 if reshape, 1 if resync, 0 if recovery */
388 int devcnt;
389 int raid_disks;
390 char * metadata_version;
391 struct dev_member {
392 char *name;
393 struct dev_member *next;
394 } *members;
395 struct mdstat_ent *next;
396};
397
398extern struct mdstat_ent *mdstat_read(int hold, int start);
399extern void free_mdstat(struct mdstat_ent *ms);
400extern void mdstat_wait(int seconds);
401extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);
402extern int mddev_busy(int devnum);
403extern struct mdstat_ent *mdstat_by_component(char *name);
404
405struct map_ent {
406 struct map_ent *next;
407 int devnum;
408 char metadata[20];
409 int uuid[4];
410 int bad;
411 char *path;
412};
413extern int map_update(struct map_ent **mpp, int devnum, char *metadata,
414 int uuid[4], char *path);
415extern void map_remove(struct map_ent **map, int devnum);
416extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
417extern struct map_ent *map_by_devnum(struct map_ent **map, int devnum);
418extern struct map_ent *map_by_name(struct map_ent **map, char *name);
419extern void map_read(struct map_ent **melp);
420extern int map_write(struct map_ent *mel);
421extern void map_delete(struct map_ent **mapp, int devnum);
422extern void map_free(struct map_ent *map);
423extern void map_add(struct map_ent **melp,
424 int devnum, char *metadata, int uuid[4], char *path);
425extern int map_lock(struct map_ent **melp);
426extern void map_unlock(struct map_ent **melp);
427
428/* various details can be requested */
429enum sysfs_read_flags {
430 GET_LEVEL = (1 << 0),
431 GET_LAYOUT = (1 << 1),
432 GET_COMPONENT = (1 << 2),
433 GET_CHUNK = (1 << 3),
434 GET_CACHE = (1 << 4),
435 GET_MISMATCH = (1 << 5),
436 GET_VERSION = (1 << 6),
437 GET_DISKS = (1 << 7),
438 GET_DEGRADED = (1 << 8),
439 GET_SAFEMODE = (1 << 9),
440 GET_DEVS = (1 << 10), /* gets role, major, minor */
441 GET_OFFSET = (1 << 11),
442 GET_SIZE = (1 << 12),
443 GET_STATE = (1 << 13),
444 GET_ERROR = (1 << 14),
445};
446
447/* If fd >= 0, get the array it is open on,
448 * else use devnum. >=0 -> major9. <0.....
449 */
450extern int sysfs_open(int devnum, char *devname, char *attr);
451extern void sysfs_init(struct mdinfo *mdi, int fd, int devnum);
452extern void sysfs_free(struct mdinfo *sra);
453extern struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options);
454extern int sysfs_attr_match(const char *attr, const char *str);
455extern int sysfs_match_word(const char *word, char **list);
456extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
457 char *name, char *val);
458extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
459 char *name, unsigned long long val);
460extern int sysfs_uevent(struct mdinfo *sra, char *event);
461extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
462 char *name);
463extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
464extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
465 char *name, unsigned long long *val);
466extern int sysfs_fd_get_str(int fd, char *val, int size);
467extern int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev,
468 char *name);
469extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
470 char *name, char *val, int size);
471extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
472extern int sysfs_set_array(struct mdinfo *info, int vers);
473extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
474extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
475extern int sysfs_unique_holder(int devnum, long rdev);
476extern int sysfs_freeze_array(struct mdinfo *sra);
477extern int load_sys(char *path, char *buf);
478extern int reshape_prepare_fdlist(char *devname,
479 struct mdinfo *sra,
480 int raid_disks,
481 int nrdisks,
482 unsigned long blocks,
483 char *backup_file,
484 int *fdlist,
485 unsigned long long *offsets);
486extern void reshape_free_fdlist(int *fdlist,
487 unsigned long long *offsets,
488 int size);
489extern int reshape_open_backup_file(char *backup,
490 int fd,
491 char *devname,
492 long blocks,
493 int *fdlist,
494 unsigned long long *offsets);
495extern unsigned long compute_backup_blocks(int nchunk, int ochunk,
496 unsigned int ndata, unsigned int odata);
497
498extern int save_stripes(int *source, unsigned long long *offsets,
499 int raid_disks, int chunk_size, int level, int layout,
500 int nwrites, int *dest,
501 unsigned long long start, unsigned long long length,
502 char *buf);
503extern int restore_stripes(int *dest, unsigned long long *offsets,
504 int raid_disks, int chunk_size, int level, int layout,
505 int source, unsigned long long read_offset,
506 unsigned long long start, unsigned long long length);
507
508#ifndef Sendmail
509#define Sendmail "/usr/lib/sendmail -t"
510#endif
511
512#define SYSLOG_FACILITY LOG_DAEMON
513
514extern char *map_num(mapping_t *map, int num);
515extern int map_name(mapping_t *map, char *name);
516extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
517
518extern char *map_dev(int major, int minor, int create);
519
520struct active_array;
521struct metadata_update;
522
523/* A superswitch provides entry point the a metadata handler.
524 *
525 * The super_switch primarily operates on some "metadata" that
526 * is accessed via the 'supertype'.
527 * This metadata has one of three possible sources.
528 * 1/ It is read from a single device. In this case it may not completely
529 * describe the array or arrays as some information might be on other
530 * devices.
531 * 2/ It is read from all devices in a container. In this case all
532 * information is present.
533 * 3/ It is created by ->init_super / ->add_to_super. In this case it will
534 * be complete once enough ->add_to_super calls have completed.
535 *
536 * When creating an array inside a container, the metadata will be
537 * formed by a combination of 2 and 3. The metadata or the array is read,
538 * then new information is added.
539 *
540 * The metadata must sometimes have a concept of a 'current' array
541 * and a 'current' device.
542 * The 'current' array is set by init_super to be the newly created array,
543 * or is set by super_by_fd when it finds it is looking at an array inside
544 * a container.
545 *
546 * The 'current' device is either the device that the metadata was read from
547 * in case 1, or the last device added by add_to_super in case 3.
548 * Case 2 does not identify a 'current' device.
549 */
550extern struct superswitch {
551
552 /* Used to report details of metadata read from a component
553 * device. ->load_super has been called.
554 */
555 void (*examine_super)(struct supertype *st, char *homehost);
556 void (*brief_examine_super)(struct supertype *st, int verbose);
557 void (*brief_examine_subarrays)(struct supertype *st, int verbose);
558 void (*export_examine_super)(struct supertype *st);
559
560 /* Used to report details of an active array.
561 * ->load_super was possibly given a 'component' string.
562 */
563 void (*detail_super)(struct supertype *st, char *homehost);
564 void (*brief_detail_super)(struct supertype *st);
565 void (*export_detail_super)(struct supertype *st);
566
567 /* Optional: platform hardware / firmware details */
568 int (*detail_platform)(int verbose, int enumerate_only);
569
570 /* Used:
571 * to get uuid to storing in bitmap metadata
572 * and 'reshape' backup-data metadata
573 * To see if a device is being re-added to an array it was part of.
574 */
575 void (*uuid_from_super)(struct supertype *st, int uuid[4]);
576
577 /* Extract generic details from metadata. This could be details about
578 * the container, or about an individual array within the container.
579 * The determination is made either by:
580 * load_super being given a 'component' string.
581 * validate_geometry determining what to create.
582 * The info includes both array information and device information.
583 * The particular device should be:
584 * The last device added by add_to_super
585 * The device the metadata was loaded from by load_super
586 * If 'map' is present, then it is an array raid_disks long
587 * (raid_disk must already be set and correct) and it is filled
588 * with 1 for slots that are thought to be active and 0 for slots which
589 * appear to be failed/missing.
590 */
591 void (*getinfo_super)(struct supertype *st, struct mdinfo *info, char *map);
592 struct mdinfo *(*getinfo_super_disks)(struct supertype *st);
593 /* Check if the given metadata is flagged as belonging to "this"
594 * host. 0 for 'no', 1 for 'yes', -1 for "Don't record homehost"
595 */
596 int (*match_home)(struct supertype *st, char *homehost);
597
598 /* Make one of several generic modifications to metadata
599 * prior to assembly (or other times).
600 * sparc2.2 - first bug in early 0.90 metadata
601 * super-minor - change name of 0.90 metadata
602 * summaries - 'correct' any redundant data
603 * resync - mark array as dirty to trigger a resync.
604 * uuid - set new uuid - only 0.90 or 1.x
605 * name - change the name of the array (where supported)
606 * homehost - change which host this array is tied to.
607 * devicesize - If metadata is at start of device, change recorded
608 * device size to match actual device size
609 * byteorder - swap bytes for 0.90 metadata
610 *
611 * force-one - mark that device as uptodate, not old or failed.
612 * force-array - mark array as clean if it would not otherwise
613 * assemble
614 * assemble - not sure how this is different from force-one...
615 * linear-grow-new - add a new device to a linear array, but don't
616 * change the size: so superblock still matches
617 * linear-grow-update - now change the size of the array.
618 */
619 int (*update_super)(struct supertype *st, struct mdinfo *info,
620 char *update,
621 char *devname, int verbose,
622 int uuid_set, char *homehost);
623
624 /* Create new metadata for new array as described. This could
625 * be a new container, or an array in a pre-existing container.
626 * Also used to zero metadata prior to writing it to invalidate old
627 * metadata.
628 */
629 int (*init_super)(struct supertype *st, mdu_array_info_t *info,
630 unsigned long long size, char *name,
631 char *homehost, int *uuid);
632
633 /* update the metadata to include new device, either at create or
634 * when hot-adding a spare.
635 */
636 int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
637 int fd, char *devname);
638 /* update the metadata to delete a device,
639 * when hot-removing.
640 */
641 int (*remove_from_super)(struct supertype *st, mdu_disk_info_t *dinfo);
642
643 /* Write metadata to one device when fixing problems or adding
644 * a new device.
645 */
646 int (*store_super)(struct supertype *st, int fd);
647
648 /* Write all metadata for this array.
649 */
650 int (*write_init_super)(struct supertype *st);
651 int (*compare_super)(struct supertype *st, struct supertype *tst);
652 int (*load_super)(struct supertype *st, int fd, char *devname);
653 int (*load_container)(struct supertype *st, int fd, char *devname);
654 struct supertype * (*match_metadata_desc)(char *arg);
655 __u64 (*avail_size)(struct supertype *st, __u64 size);
656 unsigned long long (*min_acceptable_spare_size)(struct supertype *st);
657 int (*add_internal_bitmap)(struct supertype *st, int *chunkp,
658 int delay, int write_behind,
659 unsigned long long size, int may_change, int major);
660 void (*locate_bitmap)(struct supertype *st, int fd);
661 int (*write_bitmap)(struct supertype *st, int fd);
662 void (*free_super)(struct supertype *st);
663
664 /* validate_geometry is called with an st returned by
665 * match_metadata_desc.
666 * It should check that the geometry described in compatible with
667 * the metadata type. It will be called repeatedly as devices
668 * added to validate changing size and new devices. If there are
669 * inter-device dependencies, it should record sufficient details
670 * so these can be validated.
671 * Both 'size' and '*freesize' are in sectors. chunk is KiB.
672 */
673 int (*validate_geometry)(struct supertype *st, int level, int layout,
674 int raiddisks,
675 int chunk, unsigned long long size,
676 char *subdev, unsigned long long *freesize,
677 int verbose);
678
679 struct mdinfo *(*container_content)(struct supertype *st, char *subarray);
680 /* query the supertype for default geometry */
681 void (*default_geometry)(struct supertype *st, int *level, int *layout, int *chunk); /* optional */
682 /* Permit subarray's to be deleted from inactive containers */
683 int (*kill_subarray)(struct supertype *st); /* optional */
684 /* Permit subarray's to be modified */
685 int (*update_subarray)(struct supertype *st, char *subarray,
686 char *update, struct mddev_ident *ident); /* optional */
687 /* Check if reshape is supported for this external format.
688 * st is obtained from super_by_fd() where st->subarray[0] is
689 * initialized to indicate if reshape is being performed at the
690 * container or subarray level
691 */
692 int (*reshape_super)(struct supertype *st, long long size, int level,
693 int layout, int chunksize, int raid_disks,
694 char *backup, char *dev, int verbose); /* optional */
695 int (*manage_reshape)(struct supertype *st, char *backup); /* optional */
696
697/* for mdmon */
698 int (*open_new)(struct supertype *c, struct active_array *a,
699 char *inst);
700
701 /* Tell the metadata handler the current state of the array.
702 * This covers whether it is known to be consistent (no pending writes)
703 * and how far along a resync is known to have progressed
704 * (in a->resync_start).
705 * resync status is really irrelevant if the array is not consistent,
706 * but some metadata (DDF!) have a place to record the distinction.
707 * If 'consistent' is '2', then the array can mark it dirty if a
708 * resync/recovery/whatever is required, or leave it clean if not.
709 * Return value is 0 dirty (not consistent) and 1 if clean.
710 * it is only really important if consistent is passed in as '2'.
711 */
712 int (*set_array_state)(struct active_array *a, int consistent);
713
714 /* When the state of a device might have changed, we call set_disk to
715 * tell the metadata what the current state is.
716 * Typically this happens on spare->in_sync and (spare|in_sync)->faulty
717 * transitions.
718 * set_disk might be called when the state of the particular disk has
719 * not in fact changed.
720 */
721 void (*set_disk)(struct active_array *a, int n, int state);
722 void (*sync_metadata)(struct supertype *st);
723 void (*process_update)(struct supertype *st,
724 struct metadata_update *update);
725 void (*prepare_update)(struct supertype *st,
726 struct metadata_update *update);
727
728 /* activate_spare will check if the array is degraded and, if it
729 * is, try to find some spare space in the container.
730 * On success, it add appropriate updates (For process_update) to
731 * to the 'updates' list and returns a list of 'mdinfo' identifying
732 * the device, or devices as there might be multiple missing
733 * devices and multiple spares available.
734 */
735 struct mdinfo *(*activate_spare)(struct active_array *a,
736 struct metadata_update **updates);
737 /*
738 * Return statically allocated string that represents metadata specific
739 * controller domain of the disk. The domain is used in disk domain
740 * matching functions. Disks belong to the same domain if the they have
741 * the same domain from mdadm.conf and belong the same metadata domain.
742 * Returning NULL or not providing this handler means that metadata
743 * does not distinguish the differences between disks that belong to
744 * different controllers. They are in the domain specified by
745 * configuration file (mdadm.conf).
746 * In case when the metadata has the notion of domains based on disk
747 * it shall return NULL for disks that do not belong to the controller
748 * the supported domains. Such disks will form another domain and won't
749 * be mixed with supported ones.
750 */
751 const char *(*get_disk_controller_domain)(const char *path);
752
753 int swapuuid; /* true if uuid is bigending rather than hostendian */
754 int external;
755 const char *name; /* canonical metadata name */
756} *superlist[];
757
758extern struct superswitch super0, super1;
759extern struct superswitch super_imsm, super_ddf;
760extern struct superswitch mbr, gpt;
761
762struct metadata_update {
763 int len;
764 char *buf;
765 void *space; /* allocated space that monitor will use */
766 struct metadata_update *next;
767};
768
769/* A supertype holds a particular collection of metadata.
770 * It identifies the metadata type by the superswitch, and the particular
771 * sub-version of that metadata type.
772 * metadata read in or created is stored in 'sb' and 'info'.
773 * There are also fields used by mdmon to track containers.
774 *
775 * A supertype may refer to:
776 * Just an array, possibly in a container
777 * A container, not identifying any particular array
778 * Info read from just one device, not yet fully describing the array/container.
779 *
780 *
781 * A supertype is created by:
782 * super_by_fd
783 * guess_super
784 * dup_super
785 */
786struct supertype {
787 struct superswitch *ss;
788 int minor_version;
789 int max_devs;
790 int container_dev; /* devnum of container */
791 void *sb;
792 void *info;
793
794 struct metadata_update *updates;
795 struct metadata_update **update_tail;
796
797 /* extra stuff used by mdmon */
798 struct active_array *arrays;
799 int sock; /* listen to external programs */
800 int devnum;
801 char *devname; /* e.g. md0. This appears in metadata_verison:
802 * external:/md0/12
803 */
804 int devcnt;
805
806 struct mdinfo *devs;
807
808};
809
810extern struct supertype *super_by_fd(int fd, char **subarray);
811enum guess_types { guess_any, guess_array, guess_partitions };
812extern struct supertype *guess_super_type(int fd, enum guess_types guess_type);
813static inline struct supertype *guess_super(int fd) {
814 return guess_super_type(fd, guess_any);
815}
816extern struct supertype *dup_super(struct supertype *st);
817extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
818extern int must_be_container(int fd);
819extern int dev_size_from_id(dev_t id, unsigned long long *size);
820extern void get_one_disk(int mdfd, mdu_array_info_t *ainf,
821 mdu_disk_info_t *disk);
822void wait_for(char *dev, int fd);
823
824/*
825 * Data structures for policy management.
826 * Each device can have a policy structure that lists
827 * various name/value pairs each possibly with a metadata associated.
828 * The policy list is sorted by name/value/metadata
829 */
830struct dev_policy {
831 struct dev_policy *next;
832 char *name; /* None of these strings are allocated. They are
833 * all just references to strings which are known
834 * to exist elsewhere.
835 * name and metadata can be compared by address equality.
836 */
837 const char *metadata;
838 const char *value;
839};
840
841extern char pol_act[], pol_domain[], pol_metadata[], pol_auto[];
842
843/* iterate over the sublist starting at list, having the same
844 * 'name' as 'list', and matching the given metadata (Where
845 * NULL matches anything
846 */
847#define pol_for_each(item, list, _metadata) \
848 for (item = list; \
849 item && item->name == list->name; \
850 item = item->next) \
851 if (!(!_metadata || !item->metadata || _metadata == item->metadata)) \
852 ; else
853
854/*
855 * policy records read from mdadm are largely just name-value pairs.
856 * The names are constants, not strdupped
857 */
858struct pol_rule {
859 struct pol_rule *next;
860 char *type; /* rule_policy or rule_part */
861 struct rule {
862 struct rule *next;
863 char *name;
864 char *value;
865 char *dups; /* duplicates of 'value' with a partNN appended */
866 } *rule;
867};
868
869extern char rule_policy[], rule_part[];
870extern char rule_path[], rule_type[];
871extern char type_part[], type_disk[];
872
873extern void policyline(char *line, char *type);
874extern void policy_add(char *type, ...);
875extern void policy_free(void);
876
877extern struct dev_policy *path_policy(char *path, char *type);
878extern struct dev_policy *disk_policy(struct mdinfo *disk);
879extern struct dev_policy *devnum_policy(int dev);
880extern void dev_policy_free(struct dev_policy *p);
881
882//extern void pol_new(struct dev_policy **pol, char *name, char *val, char *metadata);
883extern void pol_add(struct dev_policy **pol, char *name, char *val, char *metadata);
884extern struct dev_policy *pol_find(struct dev_policy *pol, char *name);
885
886enum policy_action {
887 act_default,
888 act_include,
889 act_re_add,
890 act_spare, /* This only applies to bare devices */
891 act_spare_same_slot, /* this allows non-bare devices,
892 * but only if recent removal */
893 act_force_spare, /* this allow non-bare devices in any case */
894 act_err
895};
896
897extern int policy_action_allows(struct dev_policy *plist, const char *metadata,
898 enum policy_action want);
899extern int disk_action_allows(struct mdinfo *disk, const char *metadata,
900 enum policy_action want);
901
902struct domainlist {
903 struct domainlist *next;
904 const char *dom;
905};
906
907extern int domain_test(struct domainlist *dom, struct dev_policy *pol,
908 const char *metadata);
909extern struct domainlist *domain_from_array(struct mdinfo *mdi,
910 const char *metadata);
911extern void domainlist_add_dev(struct domainlist **dom, int devnum,
912 const char *metadata);
913extern void domain_free(struct domainlist *dl);
914extern void domain_merge(struct domainlist **domp, struct dev_policy *pol,
915 const char *metadata);
916void domain_add(struct domainlist **domp, char *domain);
917
918extern void policy_save_path(char *id_path, struct map_ent *array);
919extern int policy_check_path(struct mdinfo *disk, struct map_ent *array);
920
921#if __GNUC__ < 3
922struct stat64;
923#endif
924
925#define HAVE_NFTW we assume
926#define HAVE_FTW
927
928#ifdef __UCLIBC__
929# include <features.h>
930# ifndef __UCLIBC_HAS_LFS__
931# define lseek64 lseek
932# endif
933# ifndef __UCLIBC_HAS_FTW__
934# undef HAVE_FTW
935# undef HAVE_NFTW
936# endif
937#endif
938
939#ifdef __dietlibc__
940# undef HAVE_NFTW
941#endif
942
943#if defined(__KLIBC__)
944# undef HAVE_NFTW
945# undef HAVE_FTW
946#endif
947
948#ifndef HAVE_NFTW
949# define FTW_PHYS 1
950# ifndef HAVE_FTW
951 struct FTW {};
952# endif
953#endif
954
955#ifdef HAVE_FTW
956# include <ftw.h>
957#endif
958
959extern int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s);
960
961
962extern int Manage_ro(char *devname, int fd, int readonly);
963extern int Manage_runstop(char *devname, int fd, int runstop, int quiet);
964extern int Manage_resize(char *devname, int fd, long long size, int raid_disks);
965extern int Manage_subdevs(char *devname, int fd,
966 struct mddev_dev *devlist, int verbose, int test,
967 char *update);
968extern int autodetect(void);
969extern int Grow_Add_device(char *devname, int fd, char *newdev);
970extern int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force);
971extern int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
972 long long size,
973 int level, char *layout_str, int chunksize, int raid_disks,
974 int force);
975extern int Grow_restart(struct supertype *st, struct mdinfo *info,
976 int *fdlist, int cnt, char *backup_file, int verbose);
977extern int Grow_continue(int mdfd, struct supertype *st,
978 struct mdinfo *info, char *backup_file);
979
980extern int Assemble(struct supertype *st, char *mddev,
981 struct mddev_ident *ident,
982 struct mddev_dev *devlist,
983 char *backup_file, int invalid_backup,
984 int readonly, int runstop,
985 char *update, char *homehost, int require_homehost,
986 int verbose, int force);
987
988extern int Build(char *mddev, int chunk, int level, int layout,
989 int raiddisks, struct mddev_dev *devlist, int assume_clean,
990 char *bitmap_file, int bitmap_chunk, int write_behind,
991 int delay, int verbose, int autof, unsigned long long size);
992
993
994extern int Create(struct supertype *st, char *mddev,
995 int chunk, int level, int layout, unsigned long long size, int raiddisks, int sparedisks,
996 char *name, char *homehost, int *uuid,
997 int subdevs, struct mddev_dev *devlist,
998 int runstop, int verbose, int force, int assume_clean,
999 char *bitmap_file, int bitmap_chunk, int write_behind, int delay, int autof);
1000
1001extern int Detail(char *dev, int brief, int export, int test, char *homehost);
1002extern int Detail_Platform(struct superswitch *ss, int scan, int verbose);
1003extern int Query(char *dev);
1004extern int Examine(struct mddev_dev *devlist, int brief, int export, int scan,
1005 int SparcAdjust, struct supertype *forcest, char *homehost);
1006extern int Monitor(struct mddev_dev *devlist,
1007 char *mailaddr, char *alert_cmd,
1008 int period, int daemonise, int scan, int oneshot,
1009 int dosyslog, int test, char *pidfile, int increments,
1010 int share);
1011
1012extern int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl);
1013extern int Kill_subarray(char *dev, char *subarray, int quiet);
1014extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
1015extern int Wait(char *dev);
1016extern int WaitClean(char *dev, int sock, int verbose);
1017
1018extern int Incremental(char *devname, int verbose, int runstop,
1019 struct supertype *st, char *homehost, int require_homehost,
1020 int autof);
1021extern void RebuildMap(void);
1022extern int IncrementalScan(int verbose);
1023extern int IncrementalRemove(char *devname, char *path, int verbose);
1024extern int CreateBitmap(char *filename, int force, char uuid[16],
1025 unsigned long chunksize, unsigned long daemon_sleep,
1026 unsigned long write_behind,
1027 unsigned long long array_size,
1028 int major);
1029extern int ExamineBitmap(char *filename, int brief, struct supertype *st);
1030extern int bitmap_update_uuid(int fd, int *uuid, int swap);
1031extern unsigned long bitmap_sectors(struct bitmap_super_s *bsb);
1032
1033extern int md_get_version(int fd);
1034extern int get_linux_version(void);
1035extern int mdadm_version(char *version);
1036extern long long parse_size(char *size);
1037extern int parse_uuid(char *str, int uuid[4]);
1038extern int parse_layout_10(char *layout);
1039extern int parse_layout_faulty(char *layout);
1040extern int check_ext2(int fd, char *name);
1041extern int check_reiser(int fd, char *name);
1042extern int check_raid(int fd, char *name);
1043extern int check_partitions(int fd, char *dname, unsigned long long freesize);
1044
1045extern int get_mdp_major(void);
1046extern int dev_open(char *dev, int flags);
1047extern int open_dev(int devnum);
1048extern int open_dev_excl(int devnum);
1049extern int is_standard(char *dev, int *nump);
1050extern int same_dev(char *one, char *two);
1051
1052extern int parse_auto(char *str, char *msg, int config);
1053extern struct mddev_ident *conf_get_ident(char *dev);
1054extern struct mddev_dev *conf_get_devs(void);
1055extern int conf_test_dev(char *devname);
1056extern int conf_test_metadata(const char *version, struct dev_policy *pol, int is_homehost);
1057extern struct createinfo *conf_get_create_info(void);
1058extern void set_conffile(char *file);
1059extern char *conf_get_mailaddr(void);
1060extern char *conf_get_mailfrom(void);
1061extern char *conf_get_program(void);
1062extern char *conf_get_homehost(int *require_homehostp);
1063extern char *conf_line(FILE *file);
1064extern char *conf_word(FILE *file, int allow_key);
1065extern int conf_name_is_free(char *name);
1066extern int devname_matches(char *name, char *match);
1067extern struct mddev_ident *conf_match(struct mdinfo *info, struct supertype *st);
1068extern int experimental(void);
1069
1070extern void free_line(char *line);
1071extern int match_oneof(char *devices, char *devname);
1072extern void uuid_from_super(int uuid[4], mdp_super_t *super);
1073extern const int uuid_match_any[4];
1074extern int same_uuid(int a[4], int b[4], int swapuuid);
1075extern void copy_uuid(void *a, int b[4], int swapuuid);
1076extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
1077extern char *fname_from_uuid(struct supertype *st,
1078 struct mdinfo *info, char *buf, char sep);
1079extern unsigned long calc_csum(void *super, int bytes);
1080extern int enough(int level, int raid_disks, int layout, int clean,
1081 char *avail, int avail_disks);
1082extern int enough_fd(int fd);
1083extern int ask(char *mesg);
1084extern unsigned long long get_component_size(int fd);
1085extern void remove_partitions(int fd);
1086extern int test_partition(int fd);
1087extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
1088 int chunksize, unsigned long long devsize);
1089extern int flush_metadata_updates(struct supertype *st);
1090extern void append_metadata_update(struct supertype *st, void *buf, int len);
1091extern int assemble_container_content(struct supertype *st, int mdfd,
1092 struct mdinfo *content, int runstop,
1093 char *chosen_name, int verbose);
1094
1095extern int add_disk(int mdfd, struct supertype *st,
1096 struct mdinfo *sra, struct mdinfo *info);
1097extern int remove_disk(int mdfd, struct supertype *st,
1098 struct mdinfo *sra, struct mdinfo *info);
1099extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
1100unsigned long long min_recovery_start(struct mdinfo *array);
1101
1102extern char *human_size(long long bytes);
1103extern char *human_size_brief(long long bytes);
1104extern void print_r10_layout(int layout);
1105
1106#define NoMdDev (1<<23)
1107extern int find_free_devnum(int use_partitions);
1108
1109extern void put_md_name(char *name);
1110extern char *get_md_name(int dev);
1111
1112extern char DefaultConfFile[];
1113
1114extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
1115 char *chosen);
1116/* values for 'trustworthy' */
1117#define LOCAL 1
1118#define LOCAL_ANY 10
1119#define FOREIGN 2
1120#define METADATA 3
1121extern int open_mddev(char *dev, int report_errors);
1122extern int open_container(int fd);
1123extern int is_container_member(struct mdstat_ent *ent, char *devname);
1124extern int is_subarray_active(char *subarray, char *devname);
1125int is_container_active(char *devname);
1126extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet);
1127extern struct superswitch *version_to_superswitch(char *vers);
1128
1129extern int mdmon_running(int devnum);
1130extern int mdmon_pid(int devnum);
1131extern int check_env(char *name);
1132extern __u32 random32(void);
1133extern int start_mdmon(int devnum);
1134
1135extern char *devnum2devname(int num);
1136extern void fmt_devname(char *name, int num);
1137extern int devname2devnum(char *name);
1138extern int stat2devnum(struct stat *st);
1139extern int fd2devnum(int fd);
1140
1141static inline int dev2major(int d)
1142{
1143 if (d >= 0)
1144 return MD_MAJOR;
1145 else
1146 return get_mdp_major();
1147}
1148
1149static inline int dev2minor(int d)
1150{
1151 if (d >= 0)
1152 return d;
1153 return (-1-d) << MdpMinorShift;
1154}
1155
1156static inline int ROUND_UP(int a, int base)
1157{
1158 return ((a+base-1)/base)*base;
1159}
1160
1161static inline int is_subarray(char *vers)
1162{
1163 /* The version string for a 'subarray' (an array in a container)
1164 * is
1165 * /containername/componentname for normal read-write arrays
1166 * -containername/componentname for arrays which mdmon must not
1167 * reconfigure. They might be read-only
1168 * or might be undergoing reshape etc.
1169 * containername is e.g. md0, md_d1
1170 * componentname is dependant on the metadata. e.g. '1' 'S1' ...
1171 */
1172 return (*vers == '/' || *vers == '-');
1173}
1174
1175static inline char *to_subarray(struct mdstat_ent *ent, char *container)
1176{
1177 return &ent->metadata_version[10+strlen(container)+1];
1178}
1179
1180#ifdef DEBUG
1181#define dprintf(fmt, arg...) \
1182 fprintf(stderr, fmt, ##arg)
1183#else
1184#define dprintf(fmt, arg...) \
1185 ({ if (0) fprintf(stderr, fmt, ##arg); 0; })
1186#endif
1187#include <assert.h>
1188#include <stdarg.h>
1189static inline int xasprintf(char **strp, const char *fmt, ...) {
1190 va_list ap;
1191 int ret;
1192 va_start(ap, fmt);
1193 ret = vasprintf(strp, fmt, ap);
1194 va_end(ap);
1195 assert(ret >= 0);
1196 return ret;
1197}
1198
1199#define LEVEL_MULTIPATH (-4)
1200#define LEVEL_LINEAR (-1)
1201#define LEVEL_FAULTY (-5)
1202
1203/* kernel module doesn't know about these */
1204#define LEVEL_CONTAINER (-100)
1205#define LEVEL_UNSUPPORTED (-200)
1206
1207
1208/* faulty stuff */
1209
1210#define WriteTransient 0
1211#define ReadTransient 1
1212#define WritePersistent 2
1213#define ReadPersistent 3
1214#define WriteAll 4 /* doesn't go to device */
1215#define ReadFixable 5
1216#define Modes 6
1217
1218#define ClearErrors 31
1219#define ClearFaults 30
1220
1221#define AllPersist 100 /* internal use only */
1222#define NoPersist 101
1223
1224#define ModeMask 0x1f
1225#define ModeShift 5
1226
1227
1228#ifdef __TINYC__
1229#undef minor
1230#undef major
1231#undef makedev
1232#define minor(x) ((x)&0xff)
1233#define major(x) (((x)>>8)&0xff)
1234#define makedev(M,m) (((M)<<8) | (m))
1235#endif
1236
1237/* for raid4/5/6 */
1238#define ALGORITHM_LEFT_ASYMMETRIC 0
1239#define ALGORITHM_RIGHT_ASYMMETRIC 1
1240#define ALGORITHM_LEFT_SYMMETRIC 2
1241#define ALGORITHM_RIGHT_SYMMETRIC 3
1242
1243/* Define non-rotating (raid4) algorithms. These allow
1244 * conversion of raid4 to raid5.
1245 */
1246#define ALGORITHM_PARITY_0 4 /* P or P,Q are initial devices */
1247#define ALGORITHM_PARITY_N 5 /* P or P,Q are final devices. */
1248
1249/* DDF RAID6 layouts differ from md/raid6 layouts in two ways.
1250 * Firstly, the exact positioning of the parity block is slightly
1251 * different between the 'LEFT_*' modes of md and the "_N_*" modes
1252 * of DDF.
1253 * Secondly, or order of datablocks over which the Q syndrome is computed
1254 * is different.
1255 * Consequently we have different layouts for DDF/raid6 than md/raid6.
1256 * These layouts are from the DDFv1.2 spec.
1257 * Interestingly DDFv1.2-Errata-A does not specify N_CONTINUE but
1258 * leaves RLQ=3 as 'Vendor Specific'
1259 */
1260
1261#define ALGORITHM_ROTATING_ZERO_RESTART 8 /* DDF PRL=6 RLQ=1 */
1262#define ALGORITHM_ROTATING_N_RESTART 9 /* DDF PRL=6 RLQ=2 */
1263#define ALGORITHM_ROTATING_N_CONTINUE 10 /*DDF PRL=6 RLQ=3 */
1264
1265
1266/* For every RAID5 algorithm we define a RAID6 algorithm
1267 * with exactly the same layout for data and parity, and
1268 * with the Q block always on the last device (N-1).
1269 * This allows trivial conversion from RAID5 to RAID6
1270 */
1271#define ALGORITHM_LEFT_ASYMMETRIC_6 16
1272#define ALGORITHM_RIGHT_ASYMMETRIC_6 17
1273#define ALGORITHM_LEFT_SYMMETRIC_6 18
1274#define ALGORITHM_RIGHT_SYMMETRIC_6 19
1275#define ALGORITHM_PARITY_0_6 20
1276#define ALGORITHM_PARITY_N_6 ALGORITHM_PARITY_N
1277
1278/* Define PATH_MAX in case we don't use glibc or standard library does
1279 * not have PATH_MAX defined. Assume max path length is 4K characters.
1280 */
1281#ifndef PATH_MAX
1282#define PATH_MAX 4096
1283#endif
1284
Unnamed repository; edit this file 'description' to name the repository.