mdadm.h

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