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