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