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