mdadm.h

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