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