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