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