]> 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: Prepare reshape_update in mdadm
[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);
404extern struct mdstat_ent *mdstat_by_subdev(char *subdev, int container);
405
406struct map_ent {
407 struct map_ent *next;
408 int devnum;
409 char metadata[20];
410 int uuid[4];
411 int bad;
412 char *path;
413};
414extern int map_update(struct map_ent **mpp, int devnum, char *metadata,
415 int uuid[4], char *path);
416extern void map_remove(struct map_ent **map, int devnum);
417extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
418extern struct map_ent *map_by_devnum(struct map_ent **map, int devnum);
419extern struct map_ent *map_by_name(struct map_ent **map, char *name);
420extern void map_read(struct map_ent **melp);
421extern int map_write(struct map_ent *mel);
422extern void map_delete(struct map_ent **mapp, int devnum);
423extern void map_free(struct map_ent *map);
424extern void map_add(struct map_ent **melp,
425 int devnum, char *metadata, int uuid[4], char *path);
426extern int map_lock(struct map_ent **melp);
427extern void map_unlock(struct map_ent **melp);
428
429/* various details can be requested */
430enum sysfs_read_flags {
431 GET_LEVEL = (1 << 0),
432 GET_LAYOUT = (1 << 1),
433 GET_COMPONENT = (1 << 2),
434 GET_CHUNK = (1 << 3),
435 GET_CACHE = (1 << 4),
436 GET_MISMATCH = (1 << 5),
437 GET_VERSION = (1 << 6),
438 GET_DISKS = (1 << 7),
439 GET_DEGRADED = (1 << 8),
440 GET_SAFEMODE = (1 << 9),
441 GET_DEVS = (1 << 10), /* gets role, major, minor */
442 GET_OFFSET = (1 << 11),
443 GET_SIZE = (1 << 12),
444 GET_STATE = (1 << 13),
445 GET_ERROR = (1 << 14),
446};
447
448/* If fd >= 0, get the array it is open on,
449 * else use devnum. >=0 -> major9. <0.....
450 */
451extern int sysfs_open(int devnum, char *devname, char *attr);
452extern void sysfs_init(struct mdinfo *mdi, int fd, int devnum);
453extern void sysfs_free(struct mdinfo *sra);
454extern struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options);
455extern int sysfs_attr_match(const char *attr, const char *str);
456extern int sysfs_match_word(const char *word, char **list);
457extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
458 char *name, char *val);
459extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
460 char *name, unsigned long long val);
461extern int sysfs_uevent(struct mdinfo *sra, char *event);
462extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
463 char *name);
464extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
465extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
466 char *name, unsigned long long *val);
467extern int sysfs_fd_get_str(int fd, char *val, int size);
468extern int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev,
469 char *name);
470extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
471 char *name, char *val, int size);
472extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
473extern int sysfs_set_array(struct mdinfo *info, int vers);
474extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
475extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
476extern int sysfs_unique_holder(int devnum, long rdev);
477extern int sysfs_freeze_array(struct mdinfo *sra);
478extern int load_sys(char *path, char *buf);
479extern int reshape_prepare_fdlist(char *devname,
480 struct mdinfo *sra,
481 int raid_disks,
482 int nrdisks,
483 unsigned long blocks,
484 char *backup_file,
485 int *fdlist,
486 unsigned long long *offsets);
487extern void reshape_free_fdlist(int *fdlist,
488 unsigned long long *offsets,
489 int size);
490extern int reshape_open_backup_file(char *backup,
491 int fd,
492 char *devname,
493 long blocks,
494 int *fdlist,
495 unsigned long long *offsets);
496extern unsigned long compute_backup_blocks(int nchunk, int ochunk,
497 unsigned int ndata, unsigned int odata);
498
499extern int save_stripes(int *source, unsigned long long *offsets,
500 int raid_disks, int chunk_size, int level, int layout,
501 int nwrites, int *dest,
502 unsigned long long start, unsigned long long length,
503 char *buf);
504extern int restore_stripes(int *dest, unsigned long long *offsets,
505 int raid_disks, int chunk_size, int level, int layout,
506 int source, unsigned long long read_offset,
507 unsigned long long start, unsigned long long length);
508
509#ifndef Sendmail
510#define Sendmail "/usr/lib/sendmail -t"
511#endif
512
513#define SYSLOG_FACILITY LOG_DAEMON
514
515extern char *map_num(mapping_t *map, int num);
516extern int map_name(mapping_t *map, char *name);
517extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
518
519extern char *map_dev(int major, int minor, int create);
520
521struct active_array;
522struct metadata_update;
523
524/* A superswitch provides entry point the a metadata handler.
525 *
526 * The super_switch primarily operates on some "metadata" that
527 * is accessed via the 'supertype'.
528 * This metadata has one of three possible sources.
529 * 1/ It is read from a single device. In this case it may not completely
530 * describe the array or arrays as some information might be on other
531 * devices.
532 * 2/ It is read from all devices in a container. In this case all
533 * information is present.
534 * 3/ It is created by ->init_super / ->add_to_super. In this case it will
535 * be complete once enough ->add_to_super calls have completed.
536 *
537 * When creating an array inside a container, the metadata will be
538 * formed by a combination of 2 and 3. The metadata or the array is read,
539 * then new information is added.
540 *
541 * The metadata must sometimes have a concept of a 'current' array
542 * and a 'current' device.
543 * The 'current' array is set by init_super to be the newly created array,
544 * or is set by super_by_fd when it finds it is looking at an array inside
545 * a container.
546 *
547 * The 'current' device is either the device that the metadata was read from
548 * in case 1, or the last device added by add_to_super in case 3.
549 * Case 2 does not identify a 'current' device.
550 */
551extern struct superswitch {
552
553 /* Used to report details of metadata read from a component
554 * device. ->load_super has been called.
555 */
556 void (*examine_super)(struct supertype *st, char *homehost);
557 void (*brief_examine_super)(struct supertype *st, int verbose);
558 void (*brief_examine_subarrays)(struct supertype *st, int verbose);
559 void (*export_examine_super)(struct supertype *st);
560
561 /* Used to report details of an active array.
562 * ->load_super was possibly given a 'component' string.
563 */
564 void (*detail_super)(struct supertype *st, char *homehost);
565 void (*brief_detail_super)(struct supertype *st);
566 void (*export_detail_super)(struct supertype *st);
567
568 /* Optional: platform hardware / firmware details */
569 int (*detail_platform)(int verbose, int enumerate_only);
570
571 /* Used:
572 * to get uuid to storing in bitmap metadata
573 * and 'reshape' backup-data metadata
574 * To see if a device is being re-added to an array it was part of.
575 */
576 void (*uuid_from_super)(struct supertype *st, int uuid[4]);
577
578 /* Extract generic details from metadata. This could be details about
579 * the container, or about an individual array within the container.
580 * The determination is made either by:
581 * load_super being given a 'component' string.
582 * validate_geometry determining what to create.
583 * The info includes both array information and device information.
584 * The particular device should be:
585 * The last device added by add_to_super
586 * The device the metadata was loaded from by load_super
587 * If 'map' is present, then it is an array raid_disks long
588 * (raid_disk must already be set and correct) and it is filled
589 * with 1 for slots that are thought to be active and 0 for slots which
590 * appear to be failed/missing.
591 */
592 void (*getinfo_super)(struct supertype *st, struct mdinfo *info, char *map);
593 struct mdinfo *(*getinfo_super_disks)(struct supertype *st);
594 /* Check if the given metadata is flagged as belonging to "this"
595 * host. 0 for 'no', 1 for 'yes', -1 for "Don't record homehost"
596 */
597 int (*match_home)(struct supertype *st, char *homehost);
598
599 /* Make one of several generic modifications to metadata
600 * prior to assembly (or other times).
601 * sparc2.2 - first bug in early 0.90 metadata
602 * super-minor - change name of 0.90 metadata
603 * summaries - 'correct' any redundant data
604 * resync - mark array as dirty to trigger a resync.
605 * uuid - set new uuid - only 0.90 or 1.x
606 * name - change the name of the array (where supported)
607 * homehost - change which host this array is tied to.
608 * devicesize - If metadata is at start of device, change recorded
609 * device size to match actual device size
610 * byteorder - swap bytes for 0.90 metadata
611 *
612 * force-one - mark that device as uptodate, not old or failed.
613 * force-array - mark array as clean if it would not otherwise
614 * assemble
615 * assemble - not sure how this is different from force-one...
616 * linear-grow-new - add a new device to a linear array, but don't
617 * change the size: so superblock still matches
618 * linear-grow-update - now change the size of the array.
619 */
620 int (*update_super)(struct supertype *st, struct mdinfo *info,
621 char *update,
622 char *devname, int verbose,
623 int uuid_set, char *homehost);
624
625 /* Create new metadata for new array as described. This could
626 * be a new container, or an array in a pre-existing container.
627 * Also used to zero metadata prior to writing it to invalidate old
628 * metadata.
629 */
630 int (*init_super)(struct supertype *st, mdu_array_info_t *info,
631 unsigned long long size, char *name,
632 char *homehost, int *uuid);
633
634 /* update the metadata to include new device, either at create or
635 * when hot-adding a spare.
636 */
637 int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
638 int fd, char *devname);
639 /* update the metadata to delete a device,
640 * when hot-removing.
641 */
642 int (*remove_from_super)(struct supertype *st, mdu_disk_info_t *dinfo);
643
644 /* Write metadata to one device when fixing problems or adding
645 * a new device.
646 */
647 int (*store_super)(struct supertype *st, int fd);
648
649 /* Write all metadata for this array.
650 */
651 int (*write_init_super)(struct supertype *st);
652 int (*compare_super)(struct supertype *st, struct supertype *tst);
653 int (*load_super)(struct supertype *st, int fd, char *devname);
654 int (*load_container)(struct supertype *st, int fd, char *devname);
655 struct supertype * (*match_metadata_desc)(char *arg);
656 __u64 (*avail_size)(struct supertype *st, __u64 size);
657 unsigned long long (*min_acceptable_spare_size)(struct supertype *st);
658 int (*add_internal_bitmap)(struct supertype *st, int *chunkp,
659 int delay, int write_behind,
660 unsigned long long size, int may_change, int major);
661 void (*locate_bitmap)(struct supertype *st, int fd);
662 int (*write_bitmap)(struct supertype *st, int fd);
663 void (*free_super)(struct supertype *st);
664
665 /* validate_geometry is called with an st returned by
666 * match_metadata_desc.
667 * It should check that the geometry described in compatible with
668 * the metadata type. It will be called repeatedly as devices
669 * added to validate changing size and new devices. If there are
670 * inter-device dependencies, it should record sufficient details
671 * so these can be validated.
672 * Both 'size' and '*freesize' are in sectors. chunk is KiB.
673 */
674 int (*validate_geometry)(struct supertype *st, int level, int layout,
675 int raiddisks,
676 int chunk, unsigned long long size,
677 char *subdev, unsigned long long *freesize,
678 int verbose);
679
680 struct mdinfo *(*container_content)(struct supertype *st, char *subarray);
681 /* query the supertype for default geometry */
682 void (*default_geometry)(struct supertype *st, int *level, int *layout, int *chunk); /* optional */
683 /* Permit subarray's to be deleted from inactive containers */
684 int (*kill_subarray)(struct supertype *st); /* optional */
685 /* Permit subarray's to be modified */
686 int (*update_subarray)(struct supertype *st, char *subarray,
687 char *update, struct mddev_ident *ident); /* optional */
688 /* Check if reshape is supported for this external format.
689 * st is obtained from super_by_fd() where st->subarray[0] is
690 * initialized to indicate if reshape is being performed at the
691 * container or subarray level
692 */
693 int (*reshape_super)(struct supertype *st, long long size, int level,
694 int layout, int chunksize, int raid_disks,
695 char *backup, char *dev, int verbose); /* optional */
696 int (*manage_reshape)(struct supertype *st, char *backup); /* optional */
697
698/* for mdmon */
699 int (*open_new)(struct supertype *c, struct active_array *a,
700 char *inst);
701
702 /* Tell the metadata handler the current state of the array.
703 * This covers whether it is known to be consistent (no pending writes)
704 * and how far along a resync is known to have progressed
705 * (in a->resync_start).
706 * resync status is really irrelevant if the array is not consistent,
707 * but some metadata (DDF!) have a place to record the distinction.
708 * If 'consistent' is '2', then the array can mark it dirty if a
709 * resync/recovery/whatever is required, or leave it clean if not.
710 * Return value is 0 dirty (not consistent) and 1 if clean.
711 * it is only really important if consistent is passed in as '2'.
712 */
713 int (*set_array_state)(struct active_array *a, int consistent);
714
715 /* When the state of a device might have changed, we call set_disk to
716 * tell the metadata what the current state is.
717 * Typically this happens on spare->in_sync and (spare|in_sync)->faulty
718 * transitions.
719 * set_disk might be called when the state of the particular disk has
720 * not in fact changed.
721 */
722 void (*set_disk)(struct active_array *a, int n, int state);
723 void (*sync_metadata)(struct supertype *st);
724 void (*process_update)(struct supertype *st,
725 struct metadata_update *update);
726 void (*prepare_update)(struct supertype *st,
727 struct metadata_update *update);
728
729 /* activate_spare will check if the array is degraded and, if it
730 * is, try to find some spare space in the container.
731 * On success, it add appropriate updates (For process_update) to
732 * to the 'updates' list and returns a list of 'mdinfo' identifying
733 * the device, or devices as there might be multiple missing
734 * devices and multiple spares available.
735 */
736 struct mdinfo *(*activate_spare)(struct active_array *a,
737 struct metadata_update **updates);
738 /*
739 * Return statically allocated string that represents metadata specific
740 * controller domain of the disk. The domain is used in disk domain
741 * matching functions. Disks belong to the same domain if the they have
742 * the same domain from mdadm.conf and belong the same metadata domain.
743 * Returning NULL or not providing this handler means that metadata
744 * does not distinguish the differences between disks that belong to
745 * different controllers. They are in the domain specified by
746 * configuration file (mdadm.conf).
747 * In case when the metadata has the notion of domains based on disk
748 * it shall return NULL for disks that do not belong to the controller
749 * the supported domains. Such disks will form another domain and won't
750 * be mixed with supported ones.
751 */
752 const char *(*get_disk_controller_domain)(const char *path);
753
754 int swapuuid; /* true if uuid is bigending rather than hostendian */
755 int external;
756 const char *name; /* canonical metadata name */
757} *superlist[];
758
759extern struct superswitch super0, super1;
760extern struct superswitch super_imsm, super_ddf;
761extern struct superswitch mbr, gpt;
762
763struct metadata_update {
764 int len;
765 char *buf;
766 void *space; /* allocated space that monitor will use */
767 struct metadata_update *next;
768};
769
770/* A supertype holds a particular collection of metadata.
771 * It identifies the metadata type by the superswitch, and the particular
772 * sub-version of that metadata type.
773 * metadata read in or created is stored in 'sb' and 'info'.
774 * There are also fields used by mdmon to track containers.
775 *
776 * A supertype may refer to:
777 * Just an array, possibly in a container
778 * A container, not identifying any particular array
779 * Info read from just one device, not yet fully describing the array/container.
780 *
781 *
782 * A supertype is created by:
783 * super_by_fd
784 * guess_super
785 * dup_super
786 */
787struct supertype {
788 struct superswitch *ss;
789 int minor_version;
790 int max_devs;
791 int container_dev; /* devnum of container */
792 void *sb;
793 void *info;
794
795 struct metadata_update *updates;
796 struct metadata_update **update_tail;
797
798 /* extra stuff used by mdmon */
799 struct active_array *arrays;
800 int sock; /* listen to external programs */
801 int devnum;
802 char *devname; /* e.g. md0. This appears in metadata_verison:
803 * external:/md0/12
804 */
805 int devcnt;
806
807 struct mdinfo *devs;
808
809};
810
811extern struct supertype *super_by_fd(int fd, char **subarray);
812enum guess_types { guess_any, guess_array, guess_partitions };
813extern struct supertype *guess_super_type(int fd, enum guess_types guess_type);
814static inline struct supertype *guess_super(int fd) {
815 return guess_super_type(fd, guess_any);
816}
817extern struct supertype *dup_super(struct supertype *st);
818extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
819extern int must_be_container(int fd);
820extern int dev_size_from_id(dev_t id, unsigned long long *size);
821extern void get_one_disk(int mdfd, mdu_array_info_t *ainf,
822 mdu_disk_info_t *disk);
823void wait_for(char *dev, int fd);
824
825/*
826 * Data structures for policy management.
827 * Each device can have a policy structure that lists
828 * various name/value pairs each possibly with a metadata associated.
829 * The policy list is sorted by name/value/metadata
830 */
831struct dev_policy {
832 struct dev_policy *next;
833 char *name; /* None of these strings are allocated. They are
834 * all just references to strings which are known
835 * to exist elsewhere.
836 * name and metadata can be compared by address equality.
837 */
838 const char *metadata;
839 const char *value;
840};
841
842extern char pol_act[], pol_domain[], pol_metadata[], pol_auto[];
843
844/* iterate over the sublist starting at list, having the same
845 * 'name' as 'list', and matching the given metadata (Where
846 * NULL matches anything
847 */
848#define pol_for_each(item, list, _metadata) \
849 for (item = list; \
850 item && item->name == list->name; \
851 item = item->next) \
852 if (!(!_metadata || !item->metadata || _metadata == item->metadata)) \
853 ; else
854
855/*
856 * policy records read from mdadm are largely just name-value pairs.
857 * The names are constants, not strdupped
858 */
859struct pol_rule {
860 struct pol_rule *next;
861 char *type; /* rule_policy or rule_part */
862 struct rule {
863 struct rule *next;
864 char *name;
865 char *value;
866 char *dups; /* duplicates of 'value' with a partNN appended */
867 } *rule;
868};
869
870extern char rule_policy[], rule_part[];
871extern char rule_path[], rule_type[];
872extern char type_part[], type_disk[];
873
874extern void policyline(char *line, char *type);
875extern void policy_add(char *type, ...);
876extern void policy_free(void);
877
878extern struct dev_policy *path_policy(char *path, char *type);
879extern struct dev_policy *disk_policy(struct mdinfo *disk);
880extern struct dev_policy *devnum_policy(int dev);
881extern void dev_policy_free(struct dev_policy *p);
882
883//extern void pol_new(struct dev_policy **pol, char *name, char *val, char *metadata);
884extern void pol_add(struct dev_policy **pol, char *name, char *val, char *metadata);
885extern struct dev_policy *pol_find(struct dev_policy *pol, char *name);
886
887enum policy_action {
888 act_default,
889 act_include,
890 act_re_add,
891 act_spare, /* This only applies to bare devices */
892 act_spare_same_slot, /* this allows non-bare devices,
893 * but only if recent removal */
894 act_force_spare, /* this allow non-bare devices in any case */
895 act_err
896};
897
898extern int policy_action_allows(struct dev_policy *plist, const char *metadata,
899 enum policy_action want);
900extern int disk_action_allows(struct mdinfo *disk, const char *metadata,
901 enum policy_action want);
902
903struct domainlist {
904 struct domainlist *next;
905 const char *dom;
906};
907
908extern int domain_test(struct domainlist *dom, struct dev_policy *pol,
909 const char *metadata);
910extern struct domainlist *domain_from_array(struct mdinfo *mdi,
911 const char *metadata);
912extern void domainlist_add_dev(struct domainlist **dom, int devnum,
913 const char *metadata);
914extern void domain_free(struct domainlist *dl);
915extern void domain_merge(struct domainlist **domp, struct dev_policy *pol,
916 const char *metadata);
917void domain_add(struct domainlist **domp, char *domain);
918
919extern void policy_save_path(char *id_path, struct map_ent *array);
920extern int policy_check_path(struct mdinfo *disk, struct map_ent *array);
921
922#if __GNUC__ < 3
923struct stat64;
924#endif
925
926#define HAVE_NFTW we assume
927#define HAVE_FTW
928
929#ifdef __UCLIBC__
930# include <features.h>
931# ifndef __UCLIBC_HAS_LFS__
932# define lseek64 lseek
933# endif
934# ifndef __UCLIBC_HAS_FTW__
935# undef HAVE_FTW
936# undef HAVE_NFTW
937# endif
938#endif
939
940#ifdef __dietlibc__
941# undef HAVE_NFTW
942#endif
943
944#if defined(__KLIBC__)
945# undef HAVE_NFTW
946# undef HAVE_FTW
947#endif
948
949#ifndef HAVE_NFTW
950# define FTW_PHYS 1
951# ifndef HAVE_FTW
952 struct FTW {};
953# endif
954#endif
955
956#ifdef HAVE_FTW
957# include <ftw.h>
958#endif
959
960extern int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s);
961
962
963extern int Manage_ro(char *devname, int fd, int readonly);
964extern int Manage_runstop(char *devname, int fd, int runstop, int quiet);
965extern int Manage_resize(char *devname, int fd, long long size, int raid_disks);
966extern int Manage_subdevs(char *devname, int fd,
967 struct mddev_dev *devlist, int verbose, int test,
968 char *update);
969extern int autodetect(void);
970extern int Grow_Add_device(char *devname, int fd, char *newdev);
971extern int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force);
972extern int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
973 long long size,
974 int level, char *layout_str, int chunksize, int raid_disks,
975 int force);
976extern int Grow_restart(struct supertype *st, struct mdinfo *info,
977 int *fdlist, int cnt, char *backup_file, int verbose);
978extern int Grow_continue(int mdfd, struct supertype *st,
979 struct mdinfo *info, char *backup_file);
980
981extern int Assemble(struct supertype *st, char *mddev,
982 struct mddev_ident *ident,
983 struct mddev_dev *devlist,
984 char *backup_file, int invalid_backup,
985 int readonly, int runstop,
986 char *update, char *homehost, int require_homehost,
987 int verbose, int force);
988
989extern int Build(char *mddev, int chunk, int level, int layout,
990 int raiddisks, struct mddev_dev *devlist, int assume_clean,
991 char *bitmap_file, int bitmap_chunk, int write_behind,
992 int delay, int verbose, int autof, unsigned long long size);
993
994
995extern int Create(struct supertype *st, char *mddev,
996 int chunk, int level, int layout, unsigned long long size, int raiddisks, int sparedisks,
997 char *name, char *homehost, int *uuid,
998 int subdevs, struct mddev_dev *devlist,
999 int runstop, int verbose, int force, int assume_clean,
1000 char *bitmap_file, int bitmap_chunk, int write_behind, int delay, int autof);
1001
1002extern int Detail(char *dev, int brief, int export, int test, char *homehost);
1003extern int Detail_Platform(struct superswitch *ss, int scan, int verbose);
1004extern int Query(char *dev);
1005extern int Examine(struct mddev_dev *devlist, int brief, int export, int scan,
1006 int SparcAdjust, struct supertype *forcest, char *homehost);
1007extern int Monitor(struct mddev_dev *devlist,
1008 char *mailaddr, char *alert_cmd,
1009 int period, int daemonise, int scan, int oneshot,
1010 int dosyslog, int test, char *pidfile, int increments,
1011 int share);
1012
1013extern int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl);
1014extern int Kill_subarray(char *dev, char *subarray, int quiet);
1015extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
1016extern int Wait(char *dev);
1017extern int WaitClean(char *dev, int sock, int verbose);
1018
1019extern int Incremental(char *devname, int verbose, int runstop,
1020 struct supertype *st, char *homehost, int require_homehost,
1021 int autof);
1022extern void RebuildMap(void);
1023extern int IncrementalScan(int verbose);
1024extern int IncrementalRemove(char *devname, char *path, int verbose);
1025extern int CreateBitmap(char *filename, int force, char uuid[16],
1026 unsigned long chunksize, unsigned long daemon_sleep,
1027 unsigned long write_behind,
1028 unsigned long long array_size,
1029 int major);
1030extern int ExamineBitmap(char *filename, int brief, struct supertype *st);
1031extern int bitmap_update_uuid(int fd, int *uuid, int swap);
1032extern unsigned long bitmap_sectors(struct bitmap_super_s *bsb);
1033
1034extern int md_get_version(int fd);
1035extern int get_linux_version(void);
1036extern int mdadm_version(char *version);
1037extern long long parse_size(char *size);
1038extern int parse_uuid(char *str, int uuid[4]);
1039extern int parse_layout_10(char *layout);
1040extern int parse_layout_faulty(char *layout);
1041extern int check_ext2(int fd, char *name);
1042extern int check_reiser(int fd, char *name);
1043extern int check_raid(int fd, char *name);
1044extern int check_partitions(int fd, char *dname, unsigned long long freesize);
1045
1046extern int get_mdp_major(void);
1047extern int dev_open(char *dev, int flags);
1048extern int open_dev(int devnum);
1049extern int open_dev_excl(int devnum);
1050extern int is_standard(char *dev, int *nump);
1051extern int same_dev(char *one, char *two);
1052
1053extern int parse_auto(char *str, char *msg, int config);
1054extern struct mddev_ident *conf_get_ident(char *dev);
1055extern struct mddev_dev *conf_get_devs(void);
1056extern int conf_test_dev(char *devname);
1057extern int conf_test_metadata(const char *version, struct dev_policy *pol, int is_homehost);
1058extern struct createinfo *conf_get_create_info(void);
1059extern void set_conffile(char *file);
1060extern char *conf_get_mailaddr(void);
1061extern char *conf_get_mailfrom(void);
1062extern char *conf_get_program(void);
1063extern char *conf_get_homehost(int *require_homehostp);
1064extern char *conf_line(FILE *file);
1065extern char *conf_word(FILE *file, int allow_key);
1066extern int conf_name_is_free(char *name);
1067extern int devname_matches(char *name, char *match);
1068extern struct mddev_ident *conf_match(struct mdinfo *info, struct supertype *st);
1069extern int experimental(void);
1070
1071extern void free_line(char *line);
1072extern int match_oneof(char *devices, char *devname);
1073extern void uuid_from_super(int uuid[4], mdp_super_t *super);
1074extern const int uuid_match_any[4];
1075extern int same_uuid(int a[4], int b[4], int swapuuid);
1076extern void copy_uuid(void *a, int b[4], int swapuuid);
1077extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
1078extern char *fname_from_uuid(struct supertype *st,
1079 struct mdinfo *info, char *buf, char sep);
1080extern unsigned long calc_csum(void *super, int bytes);
1081extern int enough(int level, int raid_disks, int layout, int clean,
1082 char *avail, int avail_disks);
1083extern int enough_fd(int fd);
1084extern int ask(char *mesg);
1085extern unsigned long long get_component_size(int fd);
1086extern void remove_partitions(int fd);
1087extern int test_partition(int fd);
1088extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
1089 int chunksize, unsigned long long devsize);
1090extern int flush_metadata_updates(struct supertype *st);
1091extern void append_metadata_update(struct supertype *st, void *buf, int len);
1092extern int assemble_container_content(struct supertype *st, int mdfd,
1093 struct mdinfo *content, int runstop,
1094 char *chosen_name, int verbose);
1095
1096extern int add_disk(int mdfd, struct supertype *st,
1097 struct mdinfo *sra, struct mdinfo *info);
1098extern int remove_disk(int mdfd, struct supertype *st,
1099 struct mdinfo *sra, struct mdinfo *info);
1100extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
1101unsigned long long min_recovery_start(struct mdinfo *array);
1102
1103extern char *human_size(long long bytes);
1104extern char *human_size_brief(long long bytes);
1105extern void print_r10_layout(int layout);
1106
1107#define NoMdDev (1<<23)
1108extern int find_free_devnum(int use_partitions);
1109
1110extern void put_md_name(char *name);
1111extern char *get_md_name(int dev);
1112
1113extern char DefaultConfFile[];
1114
1115extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
1116 char *chosen);
1117/* values for 'trustworthy' */
1118#define LOCAL 1
1119#define LOCAL_ANY 10
1120#define FOREIGN 2
1121#define METADATA 3
1122extern int open_mddev(char *dev, int report_errors);
1123extern int open_container(int fd);
1124extern int is_container_member(struct mdstat_ent *ent, char *devname);
1125extern int is_subarray_active(char *subarray, char *devname);
1126int is_container_active(char *devname);
1127extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet);
1128extern struct superswitch *version_to_superswitch(char *vers);
1129
1130extern int mdmon_running(int devnum);
1131extern int mdmon_pid(int devnum);
1132extern int check_env(char *name);
1133extern __u32 random32(void);
1134extern int start_mdmon(int devnum);
1135
1136extern char *devnum2devname(int num);
1137extern void fmt_devname(char *name, int num);
1138extern int devname2devnum(char *name);
1139extern int stat2devnum(struct stat *st);
1140extern int fd2devnum(int fd);
1141
1142static inline int dev2major(int d)
1143{
1144 if (d >= 0)
1145 return MD_MAJOR;
1146 else
1147 return get_mdp_major();
1148}
1149
1150static inline int dev2minor(int d)
1151{
1152 if (d >= 0)
1153 return d;
1154 return (-1-d) << MdpMinorShift;
1155}
1156
1157static inline int ROUND_UP(int a, int base)
1158{
1159 return ((a+base-1)/base)*base;
1160}
1161
1162static inline int is_subarray(char *vers)
1163{
1164 /* The version string for a 'subarray' (an array in a container)
1165 * is
1166 * /containername/componentname for normal read-write arrays
1167 * -containername/componentname for arrays which mdmon must not
1168 * reconfigure. They might be read-only
1169 * or might be undergoing reshape etc.
1170 * containername is e.g. md0, md_d1
1171 * componentname is dependant on the metadata. e.g. '1' 'S1' ...
1172 */
1173 return (*vers == '/' || *vers == '-');
1174}
1175
1176static inline char *to_subarray(struct mdstat_ent *ent, char *container)
1177{
1178 return &ent->metadata_version[10+strlen(container)+1];
1179}
1180
1181#ifdef DEBUG
1182#define dprintf(fmt, arg...) \
1183 fprintf(stderr, fmt, ##arg)
1184#else
1185#define dprintf(fmt, arg...) \
1186 ({ if (0) fprintf(stderr, fmt, ##arg); 0; })
1187#endif
1188#include <assert.h>
1189#include <stdarg.h>
1190static inline int xasprintf(char **strp, const char *fmt, ...) {
1191 va_list ap;
1192 int ret;
1193 va_start(ap, fmt);
1194 ret = vasprintf(strp, fmt, ap);
1195 va_end(ap);
1196 assert(ret >= 0);
1197 return ret;
1198}
1199
1200#define LEVEL_MULTIPATH (-4)
1201#define LEVEL_LINEAR (-1)
1202#define LEVEL_FAULTY (-5)
1203
1204/* kernel module doesn't know about these */
1205#define LEVEL_CONTAINER (-100)
1206#define LEVEL_UNSUPPORTED (-200)
1207
1208
1209/* faulty stuff */
1210
1211#define WriteTransient 0
1212#define ReadTransient 1
1213#define WritePersistent 2
1214#define ReadPersistent 3
1215#define WriteAll 4 /* doesn't go to device */
1216#define ReadFixable 5
1217#define Modes 6
1218
1219#define ClearErrors 31
1220#define ClearFaults 30
1221
1222#define AllPersist 100 /* internal use only */
1223#define NoPersist 101
1224
1225#define ModeMask 0x1f
1226#define ModeShift 5
1227
1228
1229#ifdef __TINYC__
1230#undef minor
1231#undef major
1232#undef makedev
1233#define minor(x) ((x)&0xff)
1234#define major(x) (((x)>>8)&0xff)
1235#define makedev(M,m) (((M)<<8) | (m))
1236#endif
1237
1238/* for raid4/5/6 */
1239#define ALGORITHM_LEFT_ASYMMETRIC 0
1240#define ALGORITHM_RIGHT_ASYMMETRIC 1
1241#define ALGORITHM_LEFT_SYMMETRIC 2
1242#define ALGORITHM_RIGHT_SYMMETRIC 3
1243
1244/* Define non-rotating (raid4) algorithms. These allow
1245 * conversion of raid4 to raid5.
1246 */
1247#define ALGORITHM_PARITY_0 4 /* P or P,Q are initial devices */
1248#define ALGORITHM_PARITY_N 5 /* P or P,Q are final devices. */
1249
1250/* DDF RAID6 layouts differ from md/raid6 layouts in two ways.
1251 * Firstly, the exact positioning of the parity block is slightly
1252 * different between the 'LEFT_*' modes of md and the "_N_*" modes
1253 * of DDF.
1254 * Secondly, or order of datablocks over which the Q syndrome is computed
1255 * is different.
1256 * Consequently we have different layouts for DDF/raid6 than md/raid6.
1257 * These layouts are from the DDFv1.2 spec.
1258 * Interestingly DDFv1.2-Errata-A does not specify N_CONTINUE but
1259 * leaves RLQ=3 as 'Vendor Specific'
1260 */
1261
1262#define ALGORITHM_ROTATING_ZERO_RESTART 8 /* DDF PRL=6 RLQ=1 */
1263#define ALGORITHM_ROTATING_N_RESTART 9 /* DDF PRL=6 RLQ=2 */
1264#define ALGORITHM_ROTATING_N_CONTINUE 10 /*DDF PRL=6 RLQ=3 */
1265
1266
1267/* For every RAID5 algorithm we define a RAID6 algorithm
1268 * with exactly the same layout for data and parity, and
1269 * with the Q block always on the last device (N-1).
1270 * This allows trivial conversion from RAID5 to RAID6
1271 */
1272#define ALGORITHM_LEFT_ASYMMETRIC_6 16
1273#define ALGORITHM_RIGHT_ASYMMETRIC_6 17
1274#define ALGORITHM_LEFT_SYMMETRIC_6 18
1275#define ALGORITHM_RIGHT_SYMMETRIC_6 19
1276#define ALGORITHM_PARITY_0_6 20
1277#define ALGORITHM_PARITY_N_6 ALGORITHM_PARITY_N
1278
1279/* Define PATH_MAX in case we don't use glibc or standard library does
1280 * not have PATH_MAX defined. Assume max path length is 4K characters.
1281 */
1282#ifndef PATH_MAX
1283#define PATH_MAX 4096
1284#endif
1285
Unnamed repository; edit this file 'description' to name the repository.