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