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