mdadm: improve the dlm locking mechanism for clustered raid
[thirdparty/mdadm.git] / mdadm.h
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 #ifdef __GLIBC__
29 extern __off64_t lseek64 __P ((int __fd, __off64_t __offset, int __whence));
30 #elif !defined(lseek64)
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        <stdint.h>
39 #include        <stdlib.h>
40 #include        <time.h>
41 #include        <sys/time.h>
42 #include        <getopt.h>
43 #include        <fcntl.h>
44 #include        <stdio.h>
45 #include        <errno.h>
46 #include        <string.h>
47 #include        <syslog.h>
48 #ifdef __GLIBC__
49 /* Newer glibc requires sys/sysmacros.h directly for makedev() */
50 #include        <sys/sysmacros.h>
51 #endif
52 #ifdef __dietlibc__
53 #include        <strings.h>
54 /* dietlibc has deprecated random and srandom!! */
55 #define random rand
56 #define srandom srand
57 #endif
58
59 #ifdef NO_COROSYNC
60 #define CS_OK 1
61 typedef uint64_t cmap_handle_t;
62 #else
63 #include        <corosync/cmap.h>
64 #endif
65
66 #ifndef NO_DLM
67 #include        <libdlm.h>
68 #include        <errno.h>
69 #else
70 #define LKF_NOQUEUE     0x00000001
71 #define LKM_PWMODE      4
72 #define EUNLOCK         0x10002
73
74 typedef void *dlm_lshandle_t;
75
76 struct dlm_lksb {
77         int sb_status;
78         uint32_t sb_lkid;
79         char sb_flags;
80         char *sb_lvbptr;
81 };
82 #endif
83
84 #include        <linux/kdev_t.h>
85 /*#include      <linux/fs.h> */
86 #include        <sys/mount.h>
87 #include        <asm/types.h>
88 #include        <sys/ioctl.h>
89 #define MD_MAJOR 9
90 #define MdpMinorShift 6
91
92 #ifndef BLKGETSIZE64
93 #define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size in bytes (u64 *arg) */
94 #endif
95
96 #define DEFAULT_CHUNK 512
97 #define DEFAULT_BITMAP_CHUNK 4096
98 #define DEFAULT_BITMAP_DELAY 5
99 #define DEFAULT_MAX_WRITE_BEHIND 256
100
101 /* MAP_DIR should be somewhere that persists across the pivotroot
102  * from early boot to late boot.
103  * /run  seems to have emerged as the best standard.
104  */
105 #ifndef MAP_DIR
106 #define MAP_DIR "/run/mdadm"
107 #endif /* MAP_DIR */
108 /* MAP_FILE is what we name the map file we put in MAP_DIR, in case you
109  * want something other than the default of "map"
110  */
111 #ifndef MAP_FILE
112 #define MAP_FILE "map"
113 #endif /* MAP_FILE */
114 /* MDMON_DIR is where pid and socket files used for communicating
115  * with mdmon normally live.  Best is /var/run/mdadm as
116  * mdmon is needed at early boot then it needs to write there prior
117  * to /var/run being mounted read/write, and it also then needs to
118  * persist beyond when /var/run is mounter read-only.  So, to be
119  * safe, the default is somewhere that is read/write early in the
120  * boot process and stays up as long as possible during shutdown.
121  */
122 #ifndef MDMON_DIR
123 #define MDMON_DIR "/run/mdadm"
124 #endif /* MDMON_DIR */
125
126 /* FAILED_SLOTS is where to save files storing recent removal of array
127  * member in order to allow future reuse of disk inserted in the same
128  * slot for array recovery
129  */
130 #ifndef FAILED_SLOTS_DIR
131 #define FAILED_SLOTS_DIR "/run/mdadm/failed-slots"
132 #endif /* FAILED_SLOTS */
133
134 #include        "md_u.h"
135 #include        "md_p.h"
136 #include        "bitmap.h"
137 #include        "msg.h"
138
139 #include <endian.h>
140 /* Redhat don't like to #include <asm/byteorder.h>, and
141  * some time include <linux/byteorder/xxx_endian.h> isn't enough,
142  * and there is no standard conversion function so... */
143 /* And dietlibc doesn't think byteswap is ok, so.. */
144 /*  #include <byteswap.h> */
145 #define __mdadm_bswap_16(x) (((x) & 0x00ffU) << 8 | \
146                              ((x) & 0xff00U) >> 8)
147 #define __mdadm_bswap_32(x) (((x) & 0x000000ffU) << 24 | \
148                              ((x) & 0xff000000U) >> 24 | \
149                              ((x) & 0x0000ff00U) << 8  | \
150                              ((x) & 0x00ff0000U) >> 8)
151 #define __mdadm_bswap_64(x) (((x) & 0x00000000000000ffULL) << 56 | \
152                              ((x) & 0xff00000000000000ULL) >> 56 | \
153                              ((x) & 0x000000000000ff00ULL) << 40 | \
154                              ((x) & 0x00ff000000000000ULL) >> 40 | \
155                              ((x) & 0x0000000000ff0000ULL) << 24 | \
156                              ((x) & 0x0000ff0000000000ULL) >> 24 | \
157                              ((x) & 0x00000000ff000000ULL) << 8 |  \
158                              ((x) & 0x000000ff00000000ULL) >> 8)
159
160 #if !defined(__KLIBC__)
161 #if BYTE_ORDER == LITTLE_ENDIAN
162 #define __cpu_to_le16(_x) (unsigned int)(_x)
163 #define __cpu_to_le32(_x) (unsigned int)(_x)
164 #define __cpu_to_le64(_x) (unsigned long long)(_x)
165 #define __le16_to_cpu(_x) (unsigned int)(_x)
166 #define __le32_to_cpu(_x) (unsigned int)(_x)
167 #define __le64_to_cpu(_x) (unsigned long long)(_x)
168
169 #define __cpu_to_be16(_x) __mdadm_bswap_16(_x)
170 #define __cpu_to_be32(_x) __mdadm_bswap_32(_x)
171 #define __cpu_to_be64(_x) __mdadm_bswap_64(_x)
172 #define __be16_to_cpu(_x) __mdadm_bswap_16(_x)
173 #define __be32_to_cpu(_x) __mdadm_bswap_32(_x)
174 #define __be64_to_cpu(_x) __mdadm_bswap_64(_x)
175 #elif BYTE_ORDER == BIG_ENDIAN
176 #define __cpu_to_le16(_x) __mdadm_bswap_16(_x)
177 #define __cpu_to_le32(_x) __mdadm_bswap_32(_x)
178 #define __cpu_to_le64(_x) __mdadm_bswap_64(_x)
179 #define __le16_to_cpu(_x) __mdadm_bswap_16(_x)
180 #define __le32_to_cpu(_x) __mdadm_bswap_32(_x)
181 #define __le64_to_cpu(_x) __mdadm_bswap_64(_x)
182
183 #define __cpu_to_be16(_x) (unsigned int)(_x)
184 #define __cpu_to_be32(_x) (unsigned int)(_x)
185 #define __cpu_to_be64(_x) (unsigned long long)(_x)
186 #define __be16_to_cpu(_x) (unsigned int)(_x)
187 #define __be32_to_cpu(_x) (unsigned int)(_x)
188 #define __be64_to_cpu(_x) (unsigned long long)(_x)
189 #else
190 #  error "unknown endianness."
191 #endif
192 #endif /* __KLIBC__ */
193
194 /*
195   * Check at compile time that something is of a particular type.
196   * Always evaluates to 1 so you may use it easily in comparisons.
197 */
198
199 #define typecheck(type,x) \
200 ({         type __dummy; \
201            typeof(x) __dummy2; \
202            (void)(&__dummy == &__dummy2); \
203            1; \
204 })
205
206 /*
207  *  These inlines deal with timer wrapping correctly.
208  *
209  * time_after(a,b) returns true if the time a is after time b.
210 */
211
212 #define time_after(a,b) \
213         (typecheck(unsigned int, a) && \
214          typecheck(unsigned int, b) && \
215          ((int)((b) - (a)) < 0))
216
217 #define time_before(a,b)        time_after(b,a)
218
219 /*
220  * min()/max()/clamp() macros that also do
221  * strict type-checking.. See the
222  * "unnecessary" pointer comparison.
223  */
224 #define min(x, y) ({                            \
225         typeof(x) _min1 = (x);                  \
226         typeof(y) _min2 = (y);                  \
227         (void) (&_min1 == &_min2);              \
228         _min1 < _min2 ? _min1 : _min2; })
229
230 #define max(x, y) ({                            \
231         typeof(x) _max1 = (x);                  \
232         typeof(y) _max2 = (y);                  \
233         (void) (&_max1 == &_max2);              \
234         _max1 > _max2 ? _max1 : _max2; })
235
236 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
237
238 extern const char Name[];
239
240 struct md_bb_entry {
241         unsigned long long sector;
242         int length;
243 };
244
245 struct md_bb {
246         int supported;
247         int count;
248         struct md_bb_entry *entries;
249 };
250
251 /* general information that might be extracted from a superblock */
252 struct mdinfo {
253         mdu_array_info_t        array;
254         mdu_disk_info_t         disk;
255         __u64                   events;
256         int                     uuid[4];
257         char                    name[33];
258         unsigned long long      data_offset;
259         unsigned long long      new_data_offset;
260         unsigned long long      component_size; /* same as array.size, except in
261                                                  * sectors and up to 64bits.
262                                                  */
263         unsigned long long      custom_array_size; /* size for non-default sized
264                                                     * arrays (in sectors)
265                                                     */
266 #define NO_RESHAPE              0
267 #define VOLUME_RESHAPE          1
268 #define CONTAINER_RESHAPE       2
269 #define RESHAPE_NO_BACKUP       16 /* Mask 'or'ed in */
270         int                     reshape_active;
271         unsigned long long      reshape_progress;
272         int                     recovery_blocked; /* for external metadata it
273                                                    * indicates that there is
274                                                    * reshape in progress in
275                                                    * container,
276                                                    * for native metadata it is
277                                                    * reshape_active field mirror
278                                                    */
279         int journal_device_required;
280         int journal_clean;
281
282         enum {
283                 CONSISTENCY_POLICY_UNKNOWN,
284                 CONSISTENCY_POLICY_NONE,
285                 CONSISTENCY_POLICY_RESYNC,
286                 CONSISTENCY_POLICY_BITMAP,
287                 CONSISTENCY_POLICY_JOURNAL,
288                 CONSISTENCY_POLICY_PPL,
289         } consistency_policy;
290
291         /* During reshape we can sometimes change the data_offset to avoid
292          * over-writing still-valid data.  We need to know if there is space.
293          * So getinfo_super will fill in space_before and space_after in sectors.
294          * data_offset can be increased or decreased by this amount.
295          */
296         unsigned long long      space_before, space_after;
297         union {
298                 unsigned long long resync_start; /* per-array resync position */
299                 unsigned long long recovery_start; /* per-device rebuild position */
300                 #define MaxSector  (~0ULL) /* resync/recovery complete position */
301         };
302         long                    bitmap_offset;  /* 0 == none, 1 == a file */
303         unsigned int            ppl_size;
304         int                     ppl_offset;
305         unsigned long long      ppl_sector;
306         unsigned long           safe_mode_delay; /* ms delay to mark clean */
307         int                     new_level, delta_disks, new_layout, new_chunk;
308         int                     errors;
309         unsigned long           cache_size; /* size of raid456 stripe cache*/
310         int                     mismatch_cnt;
311         char                    text_version[50];
312
313         int container_member; /* for assembling external-metatdata arrays
314                                * This is to be used internally by metadata
315                                * handler only */
316         int container_enough; /* flag external handlers can set to
317                                * indicate that subarrays have not enough (-1),
318                                * enough to start (0), or all expected disks (1) */
319         char            sys_name[32];
320         struct mdinfo *devs;
321         struct mdinfo *next;
322
323         /* Device info for mdmon: */
324         int recovery_fd;
325         int state_fd;
326         int bb_fd;
327         int ubb_fd;
328         #define DS_FAULTY       1
329         #define DS_INSYNC       2
330         #define DS_WRITE_MOSTLY 4
331         #define DS_SPARE        8
332         #define DS_BLOCKED      16
333         #define DS_REMOVE       1024
334         #define DS_UNBLOCK      2048
335         int prev_state, curr_state, next_state;
336
337         /* info read from sysfs */
338         enum {
339                 ARRAY_CLEAR,
340                 ARRAY_INACTIVE,
341                 ARRAY_SUSPENDED,
342                 ARRAY_READONLY,
343                 ARRAY_READ_AUTO,
344                 ARRAY_CLEAN,
345                 ARRAY_ACTIVE,
346                 ARRAY_WRITE_PENDING,
347                 ARRAY_ACTIVE_IDLE,
348                 ARRAY_UNKNOWN_STATE,
349         } array_state;
350         struct md_bb bb;
351 };
352
353 struct createinfo {
354         int     uid;
355         int     gid;
356         int     autof;
357         int     mode;
358         int     symlinks;
359         int     names;
360         int     bblist;
361         struct supertype *supertype;
362 };
363
364 struct spare_criteria {
365         unsigned long long min_size;
366         unsigned int sector_size;
367 };
368
369 enum mode {
370         ASSEMBLE=1,
371         BUILD,
372         CREATE,
373         MANAGE,
374         MISC,
375         MONITOR,
376         GROW,
377         INCREMENTAL,
378         AUTODETECT,
379         mode_count
380 };
381
382 extern char short_options[];
383 extern char short_bitmap_options[];
384 extern char short_bitmap_auto_options[];
385 extern struct option long_options[];
386 extern char Version[], Usage[], Help[], OptionHelp[],
387         *mode_help[],
388         Help_create[], Help_build[], Help_assemble[], Help_grow[],
389         Help_incr[],
390         Help_manage[], Help_misc[], Help_monitor[], Help_config[];
391
392 /* for option that don't have short equivilents, we assign arbitrary
393  * numbers later than any 'short' character option.
394  */
395 enum special_options {
396         AssumeClean = 300,
397         BitmapChunk,
398         WriteBehind,
399         ReAdd,
400         NoDegraded,
401         Sparc22,
402         BackupFile,
403         HomeHost,
404         AutoHomeHost,
405         Symlinks,
406         AutoDetect,
407         Waitclean,
408         DetailPlatform,
409         KillSubarray,
410         UpdateSubarray,
411         IncrementalPath,
412         NoSharing,
413         HelpOptions,
414         Brief,
415         ManageOpt,
416         Add,
417         AddSpare,
418         AddJournal,
419         Remove,
420         Fail,
421         Replace,
422         With,
423         MiscOpt,
424         WaitOpt,
425         ConfigFile,
426         ChunkSize,
427         WriteMostly,
428         FailFast,
429         NoFailFast,
430         Layout,
431         Auto,
432         Force,
433         SuperMinor,
434         EMail,
435         ProgramOpt,
436         Increment,
437         Fork,
438         Bitmap,
439         RebuildMapOpt,
440         InvalidBackup,
441         UdevRules,
442         FreezeReshape,
443         Continue,
444         OffRootOpt,
445         Prefer,
446         KillOpt,
447         DataOffset,
448         ExamineBB,
449         Dump,
450         Restore,
451         Action,
452         Nodes,
453         ClusterName,
454         ClusterConfirm,
455         WriteJournal,
456         ConsistencyPolicy,
457 };
458
459 enum prefix_standard {
460         JEDEC,
461         IEC
462 };
463
464 enum bitmap_update {
465     NoUpdate,
466     NameUpdate,
467     NodeNumUpdate,
468 };
469
470 enum flag_mode {
471         FlagDefault, FlagSet, FlagClear,
472 };
473
474 /* structures read from config file */
475 /* List of mddevice names and identifiers
476  * Identifiers can be:
477  *    uuid=128-hex-uuid
478  *    super-minor=decimal-minor-number-from-superblock
479  *    devices=comma,separated,list,of,device,names,with,wildcards
480  *
481  * If multiple fields are present, the intersection of all matching
482  * devices is considered
483  */
484 #define UnSet (0xfffe)
485 struct mddev_ident {
486         char    *devname;
487
488         int     uuid_set;
489         int     uuid[4];
490         char    name[33];
491
492         int super_minor;
493
494         char    *devices;       /* comma separated list of device
495                                  * names with wild cards
496                                  */
497         int     level;
498         int raid_disks;
499         int spare_disks;
500         struct supertype *st;
501         int     autof;          /* 1 for normal, 2 for partitioned */
502         char    *spare_group;
503         char    *bitmap_file;
504         int     bitmap_fd;
505
506         char    *container;     /* /dev/whatever name of container, or
507                                  * uuid of container.  You would expect
508                                  * this to be the 'devname' or UUID
509                                  * of some other entry.
510                                  */
511         char    *member;        /* subarray within a container */
512
513         struct mddev_ident *next;
514         union {
515                 /* fields needed by different users of this structure */
516                 int assembled;  /* set when assembly succeeds */
517         };
518 };
519
520 struct context {
521         int     readonly;
522         int     runstop;
523         int     verbose;
524         int     brief;
525         int     force;
526         char    *homehost;
527         int     require_homehost;
528         char    *prefer;
529         int     export;
530         int     test;
531         char    *subarray;
532         char    *update;
533         int     scan;
534         int     SparcAdjust;
535         int     autof;
536         int     delay;
537         int     freeze_reshape;
538         char    *backup_file;
539         int     invalid_backup;
540         char    *action;
541         int     nodes;
542         char    *homecluster;
543 };
544
545 struct shape {
546         int     raiddisks;
547         int     sparedisks;
548         int     journaldisks;
549         int     level;
550         int     layout;
551         char    *layout_str;
552         int     chunk;
553         int     bitmap_chunk;
554         char    *bitmap_file;
555         int     assume_clean;
556         int     write_behind;
557         unsigned long long size;
558         int     consistency_policy;
559 };
560
561 /* List of device names - wildcards expanded */
562 struct mddev_dev {
563         char *devname;
564         int disposition;        /* 'a' for add, 'r' for remove, 'f' for fail,
565                                  * 'A' for re_add.
566                                  * Not set for names read from .config
567                                  */
568         enum flag_mode writemostly;
569         enum flag_mode failfast;
570         int used;               /* set when used */
571         long long data_offset;
572         struct mddev_dev *next;
573 };
574
575 typedef struct mapping {
576         char *name;
577         int num;
578 } mapping_t;
579
580 struct mdstat_ent {
581         char            devnm[32];
582         int             active;
583         char            *level;
584         char            *pattern; /* U for up, _ for down */
585         int             percent; /* -1 if no resync */
586         int             resync; /* 3 if check, 2 if reshape, 1 if resync, 0 if recovery */
587         int             devcnt;
588         int             raid_disks;
589         char *          metadata_version;
590         struct dev_member {
591                 char                    *name;
592                 struct dev_member       *next;
593         }               *members;
594         struct mdstat_ent *next;
595 };
596
597 extern struct mdstat_ent *mdstat_read(int hold, int start);
598 extern void mdstat_close(void);
599 extern void free_mdstat(struct mdstat_ent *ms);
600 extern void mdstat_wait(int seconds);
601 extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);
602 extern int mddev_busy(char *devnm);
603 extern struct mdstat_ent *mdstat_by_component(char *name);
604 extern struct mdstat_ent *mdstat_by_subdev(char *subdev, char *container);
605
606 struct map_ent {
607         struct map_ent *next;
608         char    devnm[32];
609         char    metadata[20];
610         int     uuid[4];
611         int     bad;
612         char    *path;
613 };
614 extern int map_update(struct map_ent **mpp, char *devnm, char *metadata,
615                       int uuid[4], char *path);
616 extern void map_remove(struct map_ent **map, char *devnm);
617 extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
618 extern struct map_ent *map_by_devnm(struct map_ent **map, char *devnm);
619 extern void map_free(struct map_ent *map);
620 extern struct map_ent *map_by_name(struct map_ent **map, char *name);
621 extern void map_read(struct map_ent **melp);
622 extern int map_write(struct map_ent *mel);
623 extern void map_delete(struct map_ent **mapp, char *devnm);
624 extern void map_add(struct map_ent **melp,
625                     char *devnm, char *metadata, int uuid[4], char *path);
626 extern int map_lock(struct map_ent **melp);
627 extern void map_unlock(struct map_ent **melp);
628 extern void map_fork(void);
629
630 /* various details can be requested */
631 enum sysfs_read_flags {
632         GET_LEVEL       = (1 << 0),
633         GET_LAYOUT      = (1 << 1),
634         GET_COMPONENT   = (1 << 2),
635         GET_CHUNK       = (1 << 3),
636         GET_CACHE       = (1 << 4),
637         GET_MISMATCH    = (1 << 5),
638         GET_VERSION     = (1 << 6),
639         GET_DISKS       = (1 << 7),
640         GET_SAFEMODE    = (1 << 9),
641         GET_BITMAP_LOCATION = (1 << 10),
642
643         GET_DEVS        = (1 << 20), /* gets role, major, minor */
644         GET_OFFSET      = (1 << 21),
645         GET_SIZE        = (1 << 22),
646         GET_STATE       = (1 << 23),
647         GET_ERROR       = (1 << 24),
648         GET_ARRAY_STATE = (1 << 25),
649         GET_CONSISTENCY_POLICY  = (1 << 26),
650 };
651
652 /* If fd >= 0, get the array it is open on,
653  * else use devnm.
654  */
655 extern int sysfs_open(char *devnm, char *devname, char *attr);
656 extern int sysfs_init(struct mdinfo *mdi, int fd, char *devnm);
657 extern void sysfs_init_dev(struct mdinfo *mdi, dev_t devid);
658 extern void sysfs_free(struct mdinfo *sra);
659 extern struct mdinfo *sysfs_read(int fd, char *devnm, unsigned long options);
660 extern int sysfs_attr_match(const char *attr, const char *str);
661 extern int sysfs_match_word(const char *word, char **list);
662 extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
663                          char *name, char *val);
664 extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
665                          char *name, unsigned long long val);
666 extern int sysfs_set_num_signed(struct mdinfo *sra, struct mdinfo *dev,
667                                 char *name, long long val);
668 extern int sysfs_uevent(struct mdinfo *sra, char *event);
669 extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
670                         char *name);
671 extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
672 extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
673                         char *name, unsigned long long *val);
674 extern int sysfs_fd_get_two(int fd, unsigned long long *v1, unsigned long long *v2);
675 extern int sysfs_get_two(struct mdinfo *sra, struct mdinfo *dev,
676                          char *name, unsigned long long *v1, unsigned long long *v2);
677 extern int sysfs_fd_get_str(int fd, char *val, int size);
678 extern int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev,
679                                      char *name);
680 extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
681                          char *name, char *val, int size);
682 extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
683 extern int sysfs_set_array(struct mdinfo *info, int vers);
684 extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
685 extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
686 extern int sysfs_unique_holder(char *devnm, long rdev);
687 extern int sysfs_freeze_array(struct mdinfo *sra);
688 extern int sysfs_wait(int fd, int *msec);
689 extern int load_sys(char *path, char *buf, int len);
690 extern int zero_disk_range(int fd, unsigned long long sector, size_t count);
691 extern int reshape_prepare_fdlist(char *devname,
692                                   struct mdinfo *sra,
693                                   int raid_disks,
694                                   int nrdisks,
695                                   unsigned long blocks,
696                                   char *backup_file,
697                                   int *fdlist,
698                                   unsigned long long *offsets);
699 extern void reshape_free_fdlist(int *fdlist,
700                                 unsigned long long *offsets,
701                                 int size);
702 extern int reshape_open_backup_file(char *backup,
703                                     int fd,
704                                     char *devname,
705                                     long blocks,
706                                     int *fdlist,
707                                     unsigned long long *offsets,
708                                     char *sysfs_name,
709                                     int restart);
710 extern unsigned long compute_backup_blocks(int nchunk, int ochunk,
711                                            unsigned int ndata, unsigned int odata);
712 extern char *locate_backup(char *name);
713 extern char *make_backup(char *name);
714
715 extern int save_stripes(int *source, unsigned long long *offsets,
716                         int raid_disks, int chunk_size, int level, int layout,
717                         int nwrites, int *dest,
718                         unsigned long long start, unsigned long long length,
719                         char *buf);
720 extern int restore_stripes(int *dest, unsigned long long *offsets,
721                            int raid_disks, int chunk_size, int level, int layout,
722                            int source, unsigned long long read_offset,
723                            unsigned long long start, unsigned long long length,
724                            char *src_buf);
725
726 #ifndef Sendmail
727 #define Sendmail "/usr/lib/sendmail -t"
728 #endif
729
730 #define SYSLOG_FACILITY LOG_DAEMON
731
732 extern char *map_num(mapping_t *map, int num);
733 extern int map_name(mapping_t *map, char *name);
734 extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
735 extern mapping_t consistency_policies[], sysfs_array_states[];
736
737 extern char *map_dev_preferred(int major, int minor, int create,
738                                char *prefer);
739 static inline char *map_dev(int major, int minor, int create)
740 {
741         return map_dev_preferred(major, minor, create, NULL);
742 }
743
744 struct active_array;
745 struct metadata_update;
746
747 /* 'struct reshape' records the intermediate states of
748  * a general reshape.
749  * The starting geometry is converted to the 'before' geometry
750  * by at most an atomic level change. They could be the same.
751  * Similarly the 'after' geometry is converted to the final
752  * geometry by at most a level change.
753  * Note that 'before' and 'after' must have the same level.
754  * 'blocks' is the minimum number of sectors for a reshape unit.
755  * This will be a multiple of the stripe size in each of the
756  * 'before' and 'after' geometries.
757  * If 'blocks' is 0, no restriping is necessary.
758  * 'min_offset_change' is the minimum change to data_offset to
759  * allow the reshape to happen.  It is at least the larger of
760  * the old  and new chunk sizes, and typically the same as 'blocks'
761  * divided by number of data disks.
762  */
763 struct reshape {
764         int level;
765         int parity; /* number of parity blocks/devices */
766         struct {
767                 int layout;
768                 int data_disks;
769         } before, after;
770         unsigned long long backup_blocks;
771         unsigned long long min_offset_change;
772         unsigned long long stripes; /* number of old stripes that comprise 'blocks'*/
773         unsigned long long new_size; /* New size of array in sectors */
774 };
775
776 /* A superswitch provides entry point to a metadata handler.
777  *
778  * The superswitch primarily operates on some "metadata" that
779  * is accessed via the 'supertype'.
780  * This metadata has one of three possible sources.
781  * 1/ It is read from a single device.  In this case it may not completely
782  *    describe the array or arrays as some information might be on other
783  *    devices.
784  * 2/ It is read from all devices in a container.  In this case all
785  *    information is present.
786  * 3/ It is created by ->init_super / ->add_to_super.  In this case it will
787  *    be complete once enough ->add_to_super calls have completed.
788  *
789  * When creating an array inside a container, the metadata will be
790  * formed by a combination of 2 and 3.  The metadata or the array is read,
791  * then new information is added.
792  *
793  * The metadata must sometimes have a concept of a 'current' array
794  * and a 'current' device.
795  * The 'current' array is set by init_super to be the newly created array,
796  * or is set by super_by_fd when it finds it is looking at an array inside
797  * a container.
798  *
799  * The 'current' device is either the device that the metadata was read from
800  * in case 1, or the last device added by add_to_super in case 3.
801  * Case 2 does not identify a 'current' device.
802  */
803 extern struct superswitch {
804
805         /* Used to report details of metadata read from a component
806          * device. ->load_super has been called.
807          */
808         void (*examine_super)(struct supertype *st, char *homehost);
809         void (*brief_examine_super)(struct supertype *st, int verbose);
810         void (*brief_examine_subarrays)(struct supertype *st, int verbose);
811         void (*export_examine_super)(struct supertype *st);
812         int (*examine_badblocks)(struct supertype *st, int fd, char *devname);
813         int (*copy_metadata)(struct supertype *st, int from, int to);
814
815         /* Used to report details of an active array.
816          * ->load_super was possibly given a 'component' string.
817          */
818         void (*detail_super)(struct supertype *st, char *homehost);
819         void (*brief_detail_super)(struct supertype *st);
820         void (*export_detail_super)(struct supertype *st);
821
822         /* Optional: platform hardware / firmware details */
823         int (*detail_platform)(int verbose, int enumerate_only, char *controller_path);
824         int (*export_detail_platform)(int verbose, char *controller_path);
825
826         /* Used:
827          *   to get uuid to storing in bitmap metadata
828          *   and 'reshape' backup-data metadata
829          *   To see if a device is being re-added to an array it was part of.
830          */
831         void (*uuid_from_super)(struct supertype *st, int uuid[4]);
832
833         /* Extract generic details from metadata.  This could be details about
834          * the container, or about an individual array within the container.
835          * The determination is made either by:
836          *   load_super being given a 'component' string.
837          *   validate_geometry determining what to create.
838          * The info includes both array information and device information.
839          * The particular device should be:
840          *   The last device added by add_to_super
841          *   The device the metadata was loaded from by load_super
842          * If 'map' is present, then it is an array raid_disks long
843          * (raid_disk must already be set and correct) and it is filled
844          * with 1 for slots that are thought to be active and 0 for slots which
845          * appear to be failed/missing.
846          * *info is zeroed out before data is added.
847          */
848         void (*getinfo_super)(struct supertype *st, struct mdinfo *info, char *map);
849         struct mdinfo *(*getinfo_super_disks)(struct supertype *st);
850         /* Check if the given metadata is flagged as belonging to "this"
851          * host.  0 for 'no', 1 for 'yes', -1 for "Don't record homehost"
852          */
853         int (*match_home)(struct supertype *st, char *homehost);
854
855         /* Make one of several generic modifications to metadata
856          * prior to assembly (or other times).
857          *   sparc2.2  - first bug in early 0.90 metadata
858          *   super-minor - change name of 0.90 metadata
859          *   summaries - 'correct' any redundant data
860          *   resync - mark array as dirty to trigger a resync.
861          *   uuid - set new uuid - only 0.90 or 1.x
862          *   name - change the name of the array (where supported)
863          *   homehost - change which host this array is tied to.
864          *   devicesize - If metadata is at start of device, change recorded
865          *               device size to match actual device size
866          *   byteorder - swap bytes for 0.90 metadata
867          *
868          *   force-one  - mark that device as uptodate, not old or failed.
869          *   force-array - mark array as clean if it would not otherwise
870          *               assemble
871          *   assemble   - not sure how this is different from force-one...
872          *   linear-grow-new - add a new device to a linear array, but don't
873          *                   change the size: so superblock still matches
874          *   linear-grow-update - now change the size of the array.
875          *   writemostly - set the WriteMostly1 bit in the superblock devflags
876          *   readwrite - clear the WriteMostly1 bit in the superblock devflags
877          *   failfast - set the FailFast1 bit in the superblock
878          *   nofailfast - clear the FailFast1 bit
879          *   no-bitmap - clear any record that a bitmap is present.
880          *   bbl       - add a bad-block-log if possible
881          *   no-bbl    - remove any bad-block-log is it is empty.
882          *   force-no-bbl - remove any bad-block-log even if empty.
883          *   revert-reshape - If a reshape is in progress, modify metadata so
884          *                    it will resume going in the opposite direction.
885          */
886         int (*update_super)(struct supertype *st, struct mdinfo *info,
887                             char *update,
888                             char *devname, int verbose,
889                             int uuid_set, char *homehost);
890
891         /* Create new metadata for new array as described.  This could
892          * be a new container, or an array in a pre-existing container.
893          * Also used to zero metadata prior to writing it to invalidate old
894          * metadata.
895          */
896         int (*init_super)(struct supertype *st, mdu_array_info_t *info,
897                           struct shape *s, char *name,
898                           char *homehost, int *uuid,
899                           unsigned long long data_offset);
900
901         /* update the metadata to include new device, either at create or
902          * when hot-adding a spare.
903          */
904         int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
905                             int fd, char *devname,
906                             unsigned long long data_offset);
907         /* update the metadata to delete a device,
908          * when hot-removing.
909          */
910         int (*remove_from_super)(struct supertype *st, mdu_disk_info_t *dinfo);
911
912         /* Write metadata to one device when fixing problems or adding
913          * a new device.
914          */
915         int (*store_super)(struct supertype *st, int fd);
916
917         /*  Write all metadata for this array.
918          */
919         int (*write_init_super)(struct supertype *st);
920         /* Check if metadata read from one device is compatible with an array,
921          * used when assembling an array, or pseudo-assembling was with
922          * "--examine --brief"
923          * If "st" has not yet been loaded the superblock from, "tst" is
924          * moved in, otherwise the superblock in 'st' is compared with
925          * 'tst'.
926          */
927         int (*compare_super)(struct supertype *st, struct supertype *tst);
928         /* Load metadata from a single device.  If 'devname' is not NULL
929          * print error messages as appropriate */
930         int (*load_super)(struct supertype *st, int fd, char *devname);
931         /* 'fd' is a 'container' md array - load array metadata from the
932          * whole container.
933          */
934         int (*load_container)(struct supertype *st, int fd, char *devname);
935         /* If 'arg' is a valid name of this metadata type, allocate and
936          * return a 'supertype' for the particular minor version */
937         struct supertype * (*match_metadata_desc)(char *arg);
938         /* If a device has the given size, and the data_offset has been
939          * requested - work out how much space is available for data.
940          * This involves adjusting for reserved space (e.g. bitmaps)
941          * and for any rounding.
942          * 'mdadm' only calls this for existing arrays where a possible
943          * spare is being added.  However some super-handlers call it
944          * internally from validate_geometry when creating an array.
945          */
946         __u64 (*avail_size)(struct supertype *st, __u64 size,
947                             unsigned long long data_offset);
948         /*
949          * Return spare criteria for array:
950          * - minimum disk size can be used in array;
951          * - sector size can be used in array.
952          * Return values: 0 - for success and -EINVAL on error.
953          */
954         int (*get_spare_criteria)(struct supertype *st,
955                                   struct spare_criteria *sc);
956         /* Find somewhere to put a bitmap - possibly auto-size it - and
957          * update the metadata to record this.  The array may be newly
958          * created, in which case data_size may be updated, or it might
959          * already exist.  Metadata handler can know if init_super
960          * has been called, but not write_init_super.
961          *  0:     Success
962          * -Exxxx: On error
963          */
964         int (*add_internal_bitmap)(struct supertype *st, int *chunkp,
965                                    int delay, int write_behind,
966                                    unsigned long long size, int may_change, int major);
967         /* Seek 'fd' to start of write-intent-bitmap.  Must be an
968          * md-native format bitmap
969          */
970         int (*locate_bitmap)(struct supertype *st, int fd, int node_num);
971         /* if add_internal_bitmap succeeded for existing array, this
972          * writes it out.
973          */
974         int (*write_bitmap)(struct supertype *st, int fd, enum bitmap_update update);
975         /* Free the superblock and any other allocated data */
976         void (*free_super)(struct supertype *st);
977
978         /* validate_geometry is called with an st returned by
979          * match_metadata_desc.
980          * It should check that the geometry described is compatible with
981          * the metadata type.  It will be called repeatedly as devices
982          * added to validate changing size and new devices.  If there are
983          * inter-device dependencies, it should record sufficient details
984          * so these can be validated.
985          * Both 'size' and '*freesize' are in sectors.  chunk is KiB.
986          * Return value is:
987          *  1: everything is OK
988          *  0: not OK for some reason - if 'verbose', then error was reported.
989          * -1: st->sb was NULL, 'subdev' is a member of a container of this
990          *     type, but array is not acceptable for some reason
991          *     message was reported even if verbose is 0.
992          */
993         int (*validate_geometry)(struct supertype *st, int level, int layout,
994                                  int raiddisks,
995                                  int *chunk, unsigned long long size,
996                                  unsigned long long data_offset,
997                                  char *subdev, unsigned long long *freesize,
998                                  int consistency_policy, int verbose);
999
1000         /* Return a linked list of 'mdinfo' structures for all arrays
1001          * in the container.  For non-containers, it is like
1002          * getinfo_super with an allocated mdinfo.*/
1003         struct mdinfo *(*container_content)(struct supertype *st, char *subarray);
1004         /* query the supertype for default geometry */
1005         void (*default_geometry)(struct supertype *st, int *level, int *layout, int *chunk); /* optional */
1006         /* Permit subarray's to be deleted from inactive containers */
1007         int (*kill_subarray)(struct supertype *st); /* optional */
1008         /* Permit subarray's to be modified */
1009         int (*update_subarray)(struct supertype *st, char *subarray,
1010                                char *update, struct mddev_ident *ident); /* optional */
1011         /* Check if reshape is supported for this external format.
1012          * st is obtained from super_by_fd() where st->subarray[0] is
1013          * initialized to indicate if reshape is being performed at the
1014          * container or subarray level
1015          */
1016 #define APPLY_METADATA_CHANGES          1
1017 #define ROLLBACK_METADATA_CHANGES       0
1018
1019         int (*reshape_super)(struct supertype *st,
1020                              unsigned long long size, int level,
1021                              int layout, int chunksize, int raid_disks,
1022                              int delta_disks, char *backup, char *dev,
1023                              int direction,
1024                              int verbose); /* optional */
1025         int (*manage_reshape)( /* optional */
1026                 int afd, struct mdinfo *sra, struct reshape *reshape,
1027                 struct supertype *st, unsigned long blocks,
1028                 int *fds, unsigned long long *offsets,
1029                 int dests, int *destfd, unsigned long long *destoffsets);
1030
1031 /* for mdmon */
1032         int (*open_new)(struct supertype *c, struct active_array *a,
1033                         char *inst);
1034
1035         /* Tell the metadata handler the current state of the array.
1036          * This covers whether it is known to be consistent (no pending writes)
1037          * and how far along a resync is known to have progressed
1038          * (in a->resync_start).
1039          * resync status is really irrelevant if the array is not consistent,
1040          * but some metadata (DDF!) have a place to record the distinction.
1041          * If 'consistent' is '2', then the array can mark it dirty if a
1042          * resync/recovery/whatever is required, or leave it clean if not.
1043          * Return value is 0 dirty (not consistent) and 1 if clean.
1044          * it is only really important if consistent is passed in as '2'.
1045          */
1046         int (*set_array_state)(struct active_array *a, int consistent);
1047
1048         /* When the state of a device might have changed, we call set_disk to
1049          * tell the metadata what the current state is.
1050          * Typically this happens on spare->in_sync and (spare|in_sync)->faulty
1051          * transitions.
1052          * set_disk might be called when the state of the particular disk has
1053          * not in fact changed.
1054          */
1055         void (*set_disk)(struct active_array *a, int n, int state);
1056         void (*sync_metadata)(struct supertype *st);
1057         void (*process_update)(struct supertype *st,
1058                                struct metadata_update *update);
1059         /* Prepare updates allocates extra memory that might be
1060          * needed.  If the update cannot be understood,  return 0.
1061          */
1062         int (*prepare_update)(struct supertype *st,
1063                                struct metadata_update *update);
1064
1065         /* activate_spare will check if the array is degraded and, if it
1066          * is, try to find some spare space in the container.
1067          * On success, it add appropriate updates (For process_update) to
1068          * to the 'updates' list and returns a list of 'mdinfo' identifying
1069          * the device, or devices as there might be multiple missing
1070          * devices and multiple spares available.
1071          */
1072         struct mdinfo *(*activate_spare)(struct active_array *a,
1073                                          struct metadata_update **updates);
1074         /*
1075          * Return statically allocated string that represents metadata specific
1076          * controller domain of the disk. The domain is used in disk domain
1077          * matching functions. Disks belong to the same domain if the they have
1078          * the same domain from mdadm.conf and belong the same metadata domain.
1079          * Returning NULL or not providing this handler means that metadata
1080          * does not distinguish the differences between disks that belong to
1081          * different controllers. They are in the domain specified by
1082          * configuration file (mdadm.conf).
1083          * In case when the metadata has the notion of domains based on disk
1084          * it shall return NULL for disks that do not belong to the controller
1085          * the supported domains. Such disks will form another domain and won't
1086          * be mixed with supported ones.
1087          */
1088         const char *(*get_disk_controller_domain)(const char *path);
1089
1090         /* for external backup area */
1091         int (*recover_backup)(struct supertype *st, struct mdinfo *info);
1092
1093         /* validate container after assemble */
1094         int (*validate_container)(struct mdinfo *info);
1095
1096         /* write initial empty PPL on device */
1097         int (*write_init_ppl)(struct supertype *st, struct mdinfo *info, int fd);
1098
1099         /* validate ppl before assemble */
1100         int (*validate_ppl)(struct supertype *st, struct mdinfo *info,
1101                             struct mdinfo *disk);
1102
1103         /* records new bad block in metadata */
1104         int (*record_bad_block)(struct active_array *a, int n,
1105                                         unsigned long long sector, int length);
1106
1107         /* clears bad block from metadata */
1108         int (*clear_bad_block)(struct active_array *a, int n,
1109                                         unsigned long long sector, int length);
1110
1111         /* get list of bad blocks from metadata */
1112         struct md_bb *(*get_bad_blocks)(struct active_array *a, int n);
1113
1114         int swapuuid; /* true if uuid is bigending rather than hostendian */
1115         int external;
1116         const char *name; /* canonical metadata name */
1117 } *superlist[];
1118
1119 extern struct superswitch super0, super1;
1120 extern struct superswitch super_imsm, super_ddf;
1121 extern struct superswitch mbr, gpt;
1122
1123 struct metadata_update {
1124         int     len;
1125         char    *buf;
1126         void    *space; /* allocated space that monitor will use */
1127         void    **space_list; /* list of allocated spaces that monitor can
1128                                * use or that it returned.
1129                                */
1130         struct metadata_update *next;
1131 };
1132
1133 /* A supertype holds a particular collection of metadata.
1134  * It identifies the metadata type by the superswitch, and the particular
1135  * sub-version of that metadata type.
1136  * metadata read in or created is stored in 'sb' and 'info'.
1137  * There are also fields used by mdmon to track containers.
1138  *
1139  * A supertype may refer to:
1140  *   Just an array, possibly in a container
1141  *   A container, not identifying any particular array
1142  *   Info read from just one device, not yet fully describing the array/container.
1143  *
1144  *
1145  * A supertype is created by:
1146  *   super_by_fd
1147  *   guess_super
1148  *   dup_super
1149  */
1150 struct supertype {
1151         struct superswitch *ss;
1152         int minor_version;
1153         int max_devs;
1154         char container_devnm[32];    /* devnm of container */
1155         void *sb;
1156         void *info;
1157         void *other; /* Hack used to convert v0.90 to v1.0 */
1158         unsigned long long devsize;
1159         unsigned long long data_offset; /* used by v1.x only */
1160         int ignore_hw_compat; /* used to inform metadata handlers that it should ignore
1161                                  HW/firmware related incompatability to load metadata.
1162                                  Used when examining metadata to display content of disk
1163                                  when user has no hw/firmare compatible system.
1164                               */
1165         struct metadata_update *updates;
1166         struct metadata_update **update_tail;
1167
1168         /* extra stuff used by mdmon */
1169         struct active_array *arrays;
1170         int sock; /* listen to external programs */
1171         char devnm[32]; /* e.g. md0.  This appears in metadata_version:
1172                          *  external:/md0/12
1173                          */
1174         int devcnt;
1175         int retry_soon;
1176         int nodes;
1177         char *cluster_name;
1178
1179         struct mdinfo *devs;
1180
1181 };
1182
1183 extern struct supertype *super_by_fd(int fd, char **subarray);
1184 enum guess_types { guess_any, guess_array, guess_partitions };
1185 extern struct supertype *guess_super_type(int fd, enum guess_types guess_type);
1186 static inline struct supertype *guess_super(int fd) {
1187         return guess_super_type(fd, guess_any);
1188 }
1189 extern struct supertype *dup_super(struct supertype *st);
1190 extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
1191 extern int get_dev_sector_size(int fd, char *dname, unsigned int *sectsizep);
1192 extern int must_be_container(int fd);
1193 extern int dev_size_from_id(dev_t id, unsigned long long *size);
1194 extern int dev_sector_size_from_id(dev_t id, unsigned int *size);
1195 void wait_for(char *dev, int fd);
1196
1197 /*
1198  * Data structures for policy management.
1199  * Each device can have a policy structure that lists
1200  * various name/value pairs each possibly with a metadata associated.
1201  * The policy list is sorted by name/value/metadata
1202  */
1203 struct dev_policy {
1204         struct dev_policy *next;
1205         char *name;     /* None of these strings are allocated.  They are
1206                          * all just references to strings which are known
1207                          * to exist elsewhere.
1208                          * name and metadata can be compared by address equality.
1209                          */
1210         const char *metadata;
1211         const char *value;
1212 };
1213
1214 extern char pol_act[], pol_domain[], pol_metadata[], pol_auto[];
1215
1216 /* iterate over the sublist starting at list, having the same
1217  * 'name' as 'list', and matching the given metadata (Where
1218  * NULL matches anything
1219  */
1220 #define pol_for_each(item, list, _metadata)                             \
1221         for (item = list;                                               \
1222              item && item->name == list->name;                          \
1223              item = item->next)                                         \
1224                 if (!(!_metadata || !item->metadata || _metadata == item->metadata)) \
1225                         ; else
1226
1227 /*
1228  * policy records read from mdadm are largely just name-value pairs.
1229  * The names are constants, not strdupped
1230  */
1231 struct pol_rule {
1232         struct pol_rule *next;
1233         char *type;     /* rule_policy or rule_part */
1234         struct rule {
1235                 struct rule *next;
1236                 char *name;
1237                 char *value;
1238                 char *dups; /* duplicates of 'value' with a partNN appended */
1239         } *rule;
1240 };
1241
1242 extern char rule_policy[], rule_part[];
1243 extern char rule_path[], rule_type[];
1244 extern char type_part[], type_disk[];
1245
1246 extern void policyline(char *line, char *type);
1247 extern void policy_add(char *type, ...);
1248 extern void policy_free(void);
1249
1250 extern struct dev_policy *path_policy(char *path, char *type);
1251 extern struct dev_policy *disk_policy(struct mdinfo *disk);
1252 extern struct dev_policy *devid_policy(int devid);
1253 extern void dev_policy_free(struct dev_policy *p);
1254
1255 //extern void pol_new(struct dev_policy **pol, char *name, char *val, char *metadata);
1256 extern void pol_add(struct dev_policy **pol, char *name, char *val, char *metadata);
1257 extern struct dev_policy *pol_find(struct dev_policy *pol, char *name);
1258
1259 enum policy_action {
1260         act_default,
1261         act_include,
1262         act_re_add,
1263         act_spare,      /* This only applies to bare devices */
1264         act_spare_same_slot, /* this allows non-bare devices,
1265                               * but only if recent removal */
1266         act_force_spare, /* this allow non-bare devices in any case */
1267         act_err
1268 };
1269
1270 extern int policy_action_allows(struct dev_policy *plist, const char *metadata,
1271                                 enum policy_action want);
1272 extern int disk_action_allows(struct mdinfo *disk, const char *metadata,
1273                               enum policy_action want);
1274
1275 struct domainlist {
1276         struct domainlist *next;
1277         const char *dom;
1278 };
1279
1280 extern int domain_test(struct domainlist *dom, struct dev_policy *pol,
1281                        const char *metadata);
1282 extern struct domainlist *domain_from_array(struct mdinfo *mdi,
1283                                             const char *metadata);
1284 extern void domainlist_add_dev(struct domainlist **dom, int devid,
1285                                const char *metadata);
1286 extern void domain_free(struct domainlist *dl);
1287 extern void domain_merge(struct domainlist **domp, struct dev_policy *pol,
1288                          const char *metadata);
1289 void domain_add(struct domainlist **domp, char *domain);
1290
1291 extern void policy_save_path(char *id_path, struct map_ent *array);
1292 extern int policy_check_path(struct mdinfo *disk, struct map_ent *array);
1293
1294 #if __GNUC__ < 3
1295 struct stat64;
1296 #endif
1297
1298 #define HAVE_NFTW  we assume
1299 #define HAVE_FTW
1300
1301 #ifdef __UCLIBC__
1302 # include <features.h>
1303 # ifndef __UCLIBC_HAS_LFS__
1304 #  define lseek64 lseek
1305 # endif
1306 # ifndef  __UCLIBC_HAS_FTW__
1307 #  undef HAVE_FTW
1308 #  undef HAVE_NFTW
1309 # endif
1310 #endif
1311
1312 #ifdef __dietlibc__
1313 # undef HAVE_NFTW
1314 #endif
1315
1316 #if defined(__KLIBC__)
1317 # undef HAVE_NFTW
1318 # undef HAVE_FTW
1319 #endif
1320
1321 #ifndef HAVE_NFTW
1322 # define FTW_PHYS 1
1323 # ifndef HAVE_FTW
1324   struct FTW {};
1325 # endif
1326 #endif
1327
1328 #ifdef HAVE_FTW
1329 # include <ftw.h>
1330 #endif
1331
1332 extern int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s);
1333
1334 extern int Manage_ro(char *devname, int fd, int readonly);
1335 extern int Manage_run(char *devname, int fd, struct context *c);
1336 extern int Manage_stop(char *devname, int fd, int quiet,
1337                        int will_retry);
1338 extern int Manage_subdevs(char *devname, int fd,
1339                           struct mddev_dev *devlist, int verbose, int test,
1340                           char *update, int force);
1341 extern int autodetect(void);
1342 extern int Grow_Add_device(char *devname, int fd, char *newdev);
1343 extern int Grow_addbitmap(char *devname, int fd,
1344                           struct context *c, struct shape *s);
1345 extern int Grow_reshape(char *devname, int fd,
1346                         struct mddev_dev *devlist,
1347                         unsigned long long data_offset,
1348                         struct context *c, struct shape *s);
1349 extern int Grow_restart(struct supertype *st, struct mdinfo *info,
1350                         int *fdlist, int cnt, char *backup_file, int verbose);
1351 extern int Grow_continue(int mdfd, struct supertype *st,
1352                          struct mdinfo *info, char *backup_file,
1353                          int forked, int freeze_reshape);
1354 extern int Grow_consistency_policy(char *devname, int fd,
1355                                    struct context *c, struct shape *s);
1356
1357 extern int restore_backup(struct supertype *st,
1358                           struct mdinfo *content,
1359                           int working_disks,
1360                           int spares,
1361                           char **backup_filep,
1362                           int verbose);
1363 extern int Grow_continue_command(char *devname, int fd,
1364                                  char *backup_file, int verbose);
1365
1366 extern int Assemble(struct supertype *st, char *mddev,
1367                     struct mddev_ident *ident,
1368                     struct mddev_dev *devlist,
1369                     struct context *c);
1370
1371 extern int Build(char *mddev, struct mddev_dev *devlist,
1372                  struct shape *s, struct context *c);
1373
1374 extern int Create(struct supertype *st, char *mddev,
1375                   char *name, int *uuid,
1376                   int subdevs, struct mddev_dev *devlist,
1377                   struct shape *s,
1378                   struct context *c,
1379                   unsigned long long data_offset);
1380
1381 extern int Detail(char *dev, struct context *c);
1382 extern int Detail_Platform(struct superswitch *ss, int scan, int verbose, int export, char *controller_path);
1383 extern int Query(char *dev);
1384 extern int ExamineBadblocks(char *devname, int brief, struct supertype *forcest);
1385 extern int Examine(struct mddev_dev *devlist, struct context *c,
1386                    struct supertype *forcest);
1387 extern int Monitor(struct mddev_dev *devlist,
1388                    char *mailaddr, char *alert_cmd,
1389                    struct context *c,
1390                    int daemonise, int oneshot,
1391                    int dosyslog, char *pidfile, int increments,
1392                    int share);
1393
1394 extern int Kill(char *dev, struct supertype *st, int force, int verbose, int noexcl);
1395 extern int Kill_subarray(char *dev, char *subarray, int verbose);
1396 extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
1397 extern int Wait(char *dev);
1398 extern int WaitClean(char *dev, int verbose);
1399 extern int SetAction(char *dev, char *action);
1400
1401 extern int Incremental(struct mddev_dev *devlist, struct context *c,
1402                        struct supertype *st);
1403 extern void RebuildMap(void);
1404 extern int IncrementalScan(struct context *c, char *devnm);
1405 extern int IncrementalRemove(char *devname, char *path, int verbose);
1406 extern int CreateBitmap(char *filename, int force, char uuid[16],
1407                         unsigned long chunksize, unsigned long daemon_sleep,
1408                         unsigned long write_behind,
1409                         unsigned long long array_size,
1410                         int major);
1411 extern int ExamineBitmap(char *filename, int brief, struct supertype *st);
1412 extern int Write_rules(char *rule_name);
1413 extern int bitmap_update_uuid(int fd, int *uuid, int swap);
1414
1415 /* calculate the size of the bitmap given the array size and bitmap chunksize */
1416 static inline unsigned long long
1417 bitmap_bits(unsigned long long array_size, unsigned long chunksize)
1418 {
1419         return (array_size * 512 + chunksize - 1) / chunksize;
1420 }
1421
1422 extern int Dump_metadata(char *dev, char *dir, struct context *c,
1423                          struct supertype *st);
1424 extern int Restore_metadata(char *dev, char *dir, struct context *c,
1425                             struct supertype *st, int only);
1426
1427 int md_array_valid(int fd);
1428 int md_array_active(int fd);
1429 int md_array_is_active(struct mdinfo *info);
1430 int md_get_array_info(int fd, struct mdu_array_info_s *array);
1431 int md_set_array_info(int fd, struct mdu_array_info_s *array);
1432 int md_get_disk_info(int fd, struct mdu_disk_info_s *disk);
1433 extern int get_linux_version(void);
1434 extern int mdadm_version(char *version);
1435 extern unsigned long long parse_size(char *size);
1436 extern int parse_uuid(char *str, int uuid[4]);
1437 extern int is_near_layout_10(int layout);
1438 extern int parse_layout_10(char *layout);
1439 extern int parse_layout_faulty(char *layout);
1440 extern long parse_num(char *num);
1441 extern int parse_cluster_confirm_arg(char *inp, char **devname, int *slot);
1442 extern int check_ext2(int fd, char *name);
1443 extern int check_reiser(int fd, char *name);
1444 extern int check_raid(int fd, char *name);
1445 extern int check_partitions(int fd, char *dname,
1446                             unsigned long long freesize,
1447                             unsigned long long size);
1448 extern int fstat_is_blkdev(int fd, char *devname, dev_t *rdev);
1449 extern int stat_is_blkdev(char *devname, dev_t *rdev);
1450
1451 extern int get_mdp_major(void);
1452 extern int get_maj_min(char *dev, int *major, int *minor);
1453 extern int dev_open(char *dev, int flags);
1454 extern int open_dev(char *devnm);
1455 extern void reopen_mddev(int mdfd);
1456 extern int open_dev_flags(char *devnm, int flags);
1457 extern int open_dev_excl(char *devnm);
1458 extern int is_standard(char *dev, int *nump);
1459 extern int same_dev(char *one, char *two);
1460 extern int compare_paths (char* path1,char* path2);
1461 extern void enable_fds(int devices);
1462
1463 extern int parse_auto(char *str, char *msg, int config);
1464 extern struct mddev_ident *conf_get_ident(char *dev);
1465 extern struct mddev_dev *conf_get_devs(void);
1466 extern int conf_test_dev(char *devname);
1467 extern int conf_test_metadata(const char *version, struct dev_policy *pol, int is_homehost);
1468 extern struct createinfo *conf_get_create_info(void);
1469 extern void set_conffile(char *file);
1470 extern char *conf_get_mailaddr(void);
1471 extern char *conf_get_mailfrom(void);
1472 extern char *conf_get_program(void);
1473 extern char *conf_get_homehost(int *require_homehostp);
1474 extern char *conf_get_homecluster(void);
1475 extern char *conf_line(FILE *file);
1476 extern char *conf_word(FILE *file, int allow_key);
1477 extern void print_quoted(char *str);
1478 extern void print_escape(char *str);
1479 extern int use_udev(void);
1480 extern unsigned long GCD(unsigned long a, unsigned long b);
1481 extern int conf_name_is_free(char *name);
1482 extern int conf_verify_devnames(struct mddev_ident *array_list);
1483 extern int devname_matches(char *name, char *match);
1484 extern struct mddev_ident *conf_match(struct supertype *st,
1485                                       struct mdinfo *info,
1486                                       char *devname,
1487                                       int verbose, int *rvp);
1488 extern int experimental(void);
1489
1490 extern void free_line(char *line);
1491 extern int match_oneof(char *devices, char *devname);
1492 extern void uuid_from_super(int uuid[4], mdp_super_t *super);
1493 extern const int uuid_zero[4];
1494 extern int same_uuid(int a[4], int b[4], int swapuuid);
1495 extern void copy_uuid(void *a, int b[4], int swapuuid);
1496 extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
1497 extern char *fname_from_uuid(struct supertype *st,
1498                              struct mdinfo *info, char *buf, char sep);
1499 extern unsigned long calc_csum(void *super, int bytes);
1500 extern int enough(int level, int raid_disks, int layout, int clean,
1501                    char *avail);
1502 extern int ask(char *mesg);
1503 extern unsigned long long get_component_size(int fd);
1504 extern void remove_partitions(int fd);
1505 extern int test_partition(int fd);
1506 extern int test_partition_from_id(dev_t id);
1507 extern int get_data_disks(int level, int layout, int raid_disks);
1508 extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
1509                                    int chunksize, unsigned long long devsize);
1510 extern int flush_metadata_updates(struct supertype *st);
1511 extern void append_metadata_update(struct supertype *st, void *buf, int len);
1512 extern int assemble_container_content(struct supertype *st, int mdfd,
1513                                       struct mdinfo *content,
1514                                       struct context *c,
1515                                       char *chosen_name, int *result);
1516 #define INCR_NO         1
1517 #define INCR_UNSAFE     2
1518 #define INCR_ALREADY    4
1519 #define INCR_YES        8
1520 extern struct mdinfo *container_choose_spares(struct supertype *st,
1521                                               struct spare_criteria *criteria,
1522                                               struct domainlist *domlist,
1523                                               char *spare_group,
1524                                               const char *metadata, int get_one);
1525 extern int move_spare(char *from_devname, char *to_devname, dev_t devid);
1526 extern int add_disk(int mdfd, struct supertype *st,
1527                     struct mdinfo *sra, struct mdinfo *info);
1528 extern int remove_disk(int mdfd, struct supertype *st,
1529                        struct mdinfo *sra, struct mdinfo *info);
1530 extern int hot_remove_disk(int mdfd, unsigned long dev, int force);
1531 extern int sys_hot_remove_disk(int statefd, int force);
1532 extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
1533 unsigned long long min_recovery_start(struct mdinfo *array);
1534
1535 extern char *human_size(long long bytes);
1536 extern char *human_size_brief(long long bytes, int prefix);
1537 extern void print_r10_layout(int layout);
1538
1539 extern char *find_free_devnm(int use_partitions);
1540
1541 extern void put_md_name(char *name);
1542 extern char *devid2kname(dev_t devid);
1543 extern char *devid2devnm(dev_t devid);
1544 extern dev_t devnm2devid(char *devnm);
1545 extern char *get_md_name(char *devnm);
1546
1547 extern char DefaultConfFile[];
1548
1549 extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
1550                         char *chosen, int block_udev);
1551 /* values for 'trustworthy' */
1552 #define LOCAL   1
1553 #define LOCAL_ANY 10
1554 #define FOREIGN 2
1555 #define METADATA 3
1556 extern int open_mddev(char *dev, int report_errors);
1557 extern int open_container(int fd);
1558 extern int metadata_container_matches(char *metadata, char *devnm);
1559 extern int metadata_subdev_matches(char *metadata, char *devnm);
1560 extern int is_container_member(struct mdstat_ent *ent, char *devname);
1561 extern int is_subarray_active(char *subarray, char *devname);
1562 extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet);
1563 extern struct superswitch *version_to_superswitch(char *vers);
1564
1565 extern int mdmon_running(char *devnm);
1566 extern int mdmon_pid(char *devnm);
1567 extern int check_env(char *name);
1568 extern __u32 random32(void);
1569 extern void random_uuid(__u8 *buf);
1570 extern int start_mdmon(char *devnm);
1571
1572 extern int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
1573                          struct supertype *st, unsigned long stripes,
1574                          int *fds, unsigned long long *offsets,
1575                          int dests, int *destfd, unsigned long long *destoffsets);
1576 void abort_reshape(struct mdinfo *sra);
1577
1578 void *super1_make_v0(struct supertype *st, struct mdinfo *info, mdp_super_t *sb0);
1579
1580 extern char *stat2kname(struct stat *st);
1581 extern char *fd2kname(int fd);
1582 extern char *stat2devnm(struct stat *st);
1583 extern char *fd2devnm(int fd);
1584 extern void udev_block(char *devnm);
1585 extern void udev_unblock(void);
1586
1587 extern int in_initrd(void);
1588
1589 struct cmap_hooks {
1590         void *cmap_handle;      /* corosync lib related */
1591
1592         int (*initialize)(cmap_handle_t *handle);
1593         int (*get_string)(cmap_handle_t handle,
1594                           const char *string,
1595                           char **name);
1596         int (*finalize)(cmap_handle_t handle);
1597 };
1598
1599 extern void set_cmap_hooks(void);
1600 extern void set_hooks(void);
1601
1602 struct dlm_hooks {
1603         void *dlm_handle;       /* dlm lib related */
1604
1605         dlm_lshandle_t (*create_lockspace)(const char *name,
1606                                            unsigned int mode);
1607         dlm_lshandle_t (*open_lockspace)(const char *name);
1608         int (*release_lockspace)(const char *name, dlm_lshandle_t ls,
1609                                  int force);
1610         int (*ls_lock)(dlm_lshandle_t lockspace, uint32_t mode,
1611                        struct dlm_lksb *lksb, uint32_t flags,
1612                        const void *name, unsigned int namelen,
1613                        uint32_t parent, void (*astaddr) (void *astarg),
1614                        void *astarg, void (*bastaddr) (void *astarg),
1615                        void *range);
1616         int (*ls_unlock_wait)(dlm_lshandle_t lockspace, uint32_t lkid,
1617                               uint32_t flags, struct dlm_lksb *lksb);
1618         int (*ls_get_fd)(dlm_lshandle_t ls);
1619         int (*dispatch)(int fd);
1620 };
1621
1622 extern int get_cluster_name(char **name);
1623 extern int dlm_funs_ready(void);
1624 extern int cluster_get_dlmlock(void);
1625 extern int cluster_release_dlmlock(void);
1626 extern void set_dlm_hooks(void);
1627
1628 #define _ROUND_UP(val, base)    (((val) + (base) - 1) & ~(base - 1))
1629 #define ROUND_UP(val, base)     _ROUND_UP(val, (typeof(val))(base))
1630 #define ROUND_UP_PTR(ptr, base) ((typeof(ptr)) \
1631                                  (ROUND_UP((unsigned long)(ptr), base)))
1632
1633 static inline int is_subarray(char *vers)
1634 {
1635         /* The version string for a 'subarray' (an array in a container)
1636          * is
1637          *    /containername/componentname    for normal read-write arrays
1638          *    -containername/componentname    for arrays which mdmon must not
1639          *                                    reconfigure.  They might be read-only
1640          *                                    or might be undergoing reshape etc.
1641          * containername is e.g. md0, md_d1
1642          * componentname is dependant on the metadata. e.g. '1' 'S1' ...
1643          */
1644         return (*vers == '/' || *vers == '-');
1645 }
1646
1647 static inline char *to_subarray(struct mdstat_ent *ent, char *container)
1648 {
1649         return &ent->metadata_version[10+strlen(container)+1];
1650 }
1651
1652 #ifdef DEBUG
1653 #define dprintf(fmt, arg...) \
1654         fprintf(stderr, "%s: %s: "fmt, Name, __func__, ##arg)
1655 #define dprintf_cont(fmt, arg...) \
1656         fprintf(stderr, fmt, ##arg)
1657 #else
1658 #define dprintf(fmt, arg...) \
1659         ({ if (0) fprintf(stderr, "%s: %s: " fmt, Name, __func__, ##arg); 0; })
1660 #define dprintf_cont(fmt, arg...) \
1661         ({ if (0) fprintf(stderr, fmt, ##arg); 0; })
1662 #endif
1663 #include <assert.h>
1664 #include <stdarg.h>
1665 static inline int xasprintf(char **strp, const char *fmt, ...) {
1666         va_list ap;
1667         int ret;
1668         va_start(ap, fmt);
1669         ret = vasprintf(strp, fmt, ap);
1670         va_end(ap);
1671         assert(ret >= 0);
1672         return ret;
1673 }
1674
1675 #ifdef DEBUG
1676 #define pr_err(fmt, args...) fprintf(stderr, "%s: %s: "fmt, Name, __func__, ##args)
1677 #else
1678 #define pr_err(fmt, args...) fprintf(stderr, "%s: "fmt, Name, ##args)
1679 #endif
1680 #define cont_err(fmt ...) fprintf(stderr, "       " fmt)
1681
1682 void *xmalloc(size_t len);
1683 void *xrealloc(void *ptr, size_t len);
1684 void *xcalloc(size_t num, size_t size);
1685 char *xstrdup(const char *str);
1686
1687 #define LEVEL_MULTIPATH         (-4)
1688 #define LEVEL_LINEAR            (-1)
1689 #define LEVEL_FAULTY            (-5)
1690
1691 /* kernel module doesn't know about these */
1692 #define LEVEL_CONTAINER         (-100)
1693 #define LEVEL_UNSUPPORTED       (-200)
1694
1695 /* the kernel does know about this one ... */
1696 #define LEVEL_NONE              (-1000000)
1697
1698 /* faulty stuff */
1699
1700 #define WriteTransient  0
1701 #define ReadTransient   1
1702 #define WritePersistent 2
1703 #define ReadPersistent  3
1704 #define WriteAll        4 /* doesn't go to device */
1705 #define ReadFixable     5
1706 #define Modes   6
1707
1708 #define ClearErrors     31
1709 #define ClearFaults     30
1710
1711 #define AllPersist      100 /* internal use only */
1712 #define NoPersist       101
1713
1714 #define ModeMask        0x1f
1715 #define ModeShift       5
1716
1717 #ifdef __TINYC__
1718 #undef minor
1719 #undef major
1720 #undef makedev
1721 #define minor(x) ((x)&0xff)
1722 #define major(x) (((x)>>8)&0xff)
1723 #define makedev(M,m) (((M)<<8) | (m))
1724 #endif
1725
1726 /* for raid4/5/6 */
1727 #define ALGORITHM_LEFT_ASYMMETRIC       0
1728 #define ALGORITHM_RIGHT_ASYMMETRIC      1
1729 #define ALGORITHM_LEFT_SYMMETRIC        2
1730 #define ALGORITHM_RIGHT_SYMMETRIC       3
1731
1732 /* Define non-rotating (raid4) algorithms.  These allow
1733  * conversion of raid4 to raid5.
1734  */
1735 #define ALGORITHM_PARITY_0              4 /* P or P,Q are initial devices */
1736 #define ALGORITHM_PARITY_N              5 /* P or P,Q are final devices. */
1737
1738 /* DDF RAID6 layouts differ from md/raid6 layouts in two ways.
1739  * Firstly, the exact positioning of the parity block is slightly
1740  * different between the 'LEFT_*' modes of md and the "_N_*" modes
1741  * of DDF.
1742  * Secondly, or order of datablocks over which the Q syndrome is computed
1743  * is different.
1744  * Consequently we have different layouts for DDF/raid6 than md/raid6.
1745  * These layouts are from the DDFv1.2 spec.
1746  * Interestingly DDFv1.2-Errata-A does not specify N_CONTINUE but
1747  * leaves RLQ=3 as 'Vendor Specific'
1748  */
1749
1750 #define ALGORITHM_ROTATING_ZERO_RESTART 8 /* DDF PRL=6 RLQ=1 */
1751 #define ALGORITHM_ROTATING_N_RESTART    9 /* DDF PRL=6 RLQ=2 */
1752 #define ALGORITHM_ROTATING_N_CONTINUE   10 /*DDF PRL=6 RLQ=3 */
1753
1754 /* For every RAID5 algorithm we define a RAID6 algorithm
1755  * with exactly the same layout for data and parity, and
1756  * with the Q block always on the last device (N-1).
1757  * This allows trivial conversion from RAID5 to RAID6
1758  */
1759 #define ALGORITHM_LEFT_ASYMMETRIC_6     16
1760 #define ALGORITHM_RIGHT_ASYMMETRIC_6    17
1761 #define ALGORITHM_LEFT_SYMMETRIC_6      18
1762 #define ALGORITHM_RIGHT_SYMMETRIC_6     19
1763 #define ALGORITHM_PARITY_0_6            20
1764 #define ALGORITHM_PARITY_N_6            ALGORITHM_PARITY_N
1765
1766 /* Define PATH_MAX in case we don't use glibc or standard library does
1767  * not have PATH_MAX defined. Assume max path length is 4K characters.
1768  */
1769 #ifndef PATH_MAX
1770 #define PATH_MAX        4096
1771 #endif
1772
1773 #define RESYNC_NONE -1
1774 #define RESYNC_DELAYED -2
1775 #define RESYNC_PENDING -3
1776 #define RESYNC_UNKNOWN -4
1777
1778 /* When using "GET_DISK_INFO" it isn't certain how high
1779  * we need to check.  So we impose an absolute limit of
1780  * MAX_DISKS.  This needs to be much more than the largest
1781  * number of devices any metadata can support.  Currently
1782  * v1.x can support 1920
1783  */
1784 #define MAX_DISKS       4096
1785
1786 /* Sometimes the 'size' value passed needs to mean "Maximum".
1787  * In those cases with use MAX_SIZE
1788  */
1789 #define MAX_SIZE        1
1790
1791 /* We want to use unsigned numbers for sector counts, but need
1792  * a value for 'invalid'.  Use '1'.
1793  */
1794 #define INVALID_SECTORS 1
1795 /* And another special number needed for --data_offset=variable */
1796 #define VARIABLE_OFFSET 3