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