util.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2012 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 #include        "mdadm.h"
  26 #include        "md_p.h"
  27 #include        <sys/socket.h>
  28 #include        <sys/utsname.h>
  29 #include        <sys/wait.h>
  30 #include        <sys/un.h>
  31 #include        <ctype.h>
  32 #include        <dirent.h>
  33 #include        <signal.h>
  34
  35 int __offroot;
  36
  37 /*
  38  * following taken from linux/blkpg.h because they aren't
  39  * anywhere else and it isn't safe to #include linux/ * stuff.
  40  */
  41
  42 #define BLKPG      _IO(0x12,105)
  43
  44 /* The argument structure */
  45 struct blkpg_ioctl_arg {
  46         int op;
  47         int flags;
  48         int datalen;
  49         void *data;
  50 };
  51
  52 /* The subfunctions (for the op field) */
  53 #define BLKPG_ADD_PARTITION     1
  54 #define BLKPG_DEL_PARTITION     2
  55
  56 /* Sizes of name fields. Unused at present. */
  57 #define BLKPG_DEVNAMELTH        64
  58 #define BLKPG_VOLNAMELTH        64
  59
  60 /* The data structure for ADD_PARTITION and DEL_PARTITION */
  61 struct blkpg_partition {
  62         long long start;                /* starting offset in bytes */
  63         long long length;               /* length in bytes */
  64         int pno;                        /* partition number */
  65         char devname[BLKPG_DEVNAMELTH]; /* partition name, like sda5 or c0d1p2,
  66                                            to be used in kernel messages */
  67         char volname[BLKPG_VOLNAMELTH]; /* volume label */
  68 };
  69
  70 #include "part.h"
  71
  72 /* Force a compilation error if condition is true */
  73 #define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition))
  74
  75 /* Force a compilation error if condition is true, but also produce a
  76    result (of value 0 and type size_t), so the expression can be used
  77    e.g. in a structure initializer (or where-ever else comma expressions
  78    aren't permitted). */
  79 #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
  80
  81 /*
  82  * Parse a 128 bit uuid in 4 integers
  83  * format is 32 hexx nibbles with options :.<space> separator
  84  * If not exactly 32 hex digits are found, return 0
  85  * else return 1
  86  */
  87 int parse_uuid(char *str, int uuid[4])
  88 {
  89         int hit = 0; /* number of Hex digIT */
  90         int i;
  91         char c;
  92         for (i = 0; i < 4; i++)
  93                 uuid[i] = 0;
  94
  95         while ((c = *str++) != 0) {
  96                 int n;
  97                 if (c >= '0' && c <= '9')
  98                         n = c-'0';
  99                 else if (c >= 'a' && c <= 'f')
 100                         n = 10 + c - 'a';
 101                 else if (c >= 'A' && c <= 'F')
 102                         n = 10 + c - 'A';
 103                 else if (strchr(":. -", c))
 104                         continue;
 105                 else return 0;
 106
 107                 if (hit<32) {
 108                         uuid[hit/8] <<= 4;
 109                         uuid[hit/8] += n;
 110                 }
 111                 hit++;
 112         }
 113         if (hit == 32)
 114                 return 1;
 115         return 0;
 116 }
 117
 118 /*
 119  * Get the md version number.
 120  * We use the RAID_VERSION ioctl if it is supported
 121  * If not, but we have a block device with major '9', we assume
 122  * 0.36.0
 123  *
 124  * Return version number as 24 but number - assume version parts
 125  * always < 255
 126  */
 127
 128 int md_get_version(int fd)
 129 {
 130     struct stat stb;
 131     mdu_version_t vers;
 132
 133     if (fstat(fd, &stb)<0)
 134         return -1;
 135     if ((S_IFMT&stb.st_mode) != S_IFBLK)
 136         return -1;
 137
 138     if (ioctl(fd, RAID_VERSION, &vers) == 0)
 139         return  (vers.major*10000) + (vers.minor*100) + vers.patchlevel;
 140     if (errno == EACCES)
 141             return -1;
 142     if (major(stb.st_rdev) == MD_MAJOR)
 143         return (3600);
 144     return -1;
 145 }
 146
 147 int get_linux_version()
 148 {
 149         struct utsname name;
 150         char *cp;
 151         int a = 0, b = 0,c = 0;
 152         if (uname(&name) <0)
 153                 return -1;
 154
 155         cp = name.release;
 156         a = strtoul(cp, &cp, 10);
 157         if (*cp == '.')
 158                 b = strtoul(cp+1, &cp, 10);
 159         if (*cp == '.')
 160                 c = strtoul(cp+1, &cp, 10);
 161
 162         return (a*1000000)+(b*1000)+c;
 163 }
 164
 165 #ifndef MDASSEMBLE
 166 int mdadm_version(char *version)
 167 {
 168         int a, b, c;
 169         char *cp;
 170
 171         if (!version)
 172                 version = Version;
 173
 174         cp = strchr(version, '-');
 175         if (!cp || *(cp+1) != ' ' || *(cp+2) != 'v')
 176                 return -1;
 177         cp += 3;
 178         a = strtoul(cp, &cp, 10);
 179         if (*cp != '.')
 180                 return -1;
 181         b = strtoul(cp+1, &cp, 10);
 182         if (*cp == '.')
 183                 c = strtoul(cp+1, &cp, 10);
 184         else
 185                 c = 0;
 186         if (*cp != ' ' && *cp != '-')
 187                 return -1;
 188         return (a*1000000)+(b*1000)+c;
 189 }
 190
 191 unsigned long long parse_size(char *size)
 192 {
 193         /* parse 'size' which should be a number optionally
 194          * followed by 'K', 'M', or 'G'.
 195          * Without a suffix, K is assumed.
 196          * Number returned is in sectors (half-K)
 197          * 0 returned on error.
 198          */
 199         char *c;
 200         long long s = strtoll(size, &c, 10);
 201         if (s > 0) {
 202                 switch (*c) {
 203                 case 'K':
 204                         c++;
 205                 default:
 206                         s *= 2;
 207                         break;
 208                 case 'M':
 209                         c++;
 210                         s *= 1024 * 2;
 211                         break;
 212                 case 'G':
 213                         c++;
 214                         s *= 1024 * 1024 * 2;
 215                         break;
 216                 }
 217         } else
 218                 s = 0;
 219         if (*c)
 220                 s = 0;
 221         return s;
 222 }
 223
 224 int parse_layout_10(char *layout)
 225 {
 226         int copies, rv;
 227         char *cp;
 228         /* Parse the layout string for raid10 */
 229         /* 'f', 'o' or 'n' followed by a number <= raid_disks */
 230         if ((layout[0] !=  'n' && layout[0] != 'f' && layout[0] != 'o') ||
 231             (copies = strtoul(layout+1, &cp, 10)) < 1 ||
 232             copies > 200 ||
 233             *cp)
 234                 return -1;
 235         if (layout[0] == 'n')
 236                 rv = 256 + copies;
 237         else if (layout[0] == 'o')
 238                 rv = 0x10000 + (copies<<8) + 1;
 239         else
 240                 rv = 1 + (copies<<8);
 241         return rv;
 242 }
 243
 244 int parse_layout_faulty(char *layout)
 245 {
 246         /* Parse the layout string for 'faulty' */
 247         int ln = strcspn(layout, "0123456789");
 248         char *m = xstrdup(layout);
 249         int mode;
 250         m[ln] = 0;
 251         mode = map_name(faultylayout, m);
 252         if (mode == UnSet)
 253                 return -1;
 254
 255         return mode | (atoi(layout+ln)<< ModeShift);
 256 }
 257
 258 long parse_num(char *num)
 259 {
 260         /* Either return a valid number, or -1 */
 261         char *c;
 262         long rv = strtol(num, &c, 10);
 263         if (rv < 0 || *c || !num[0])
 264                 return -1;
 265         else
 266                 return rv;
 267 }
 268 #endif
 269
 270 void remove_partitions(int fd)
 271 {
 272         /* remove partitions from this block devices.
 273          * This is used for components added to an array
 274          */
 275 #ifdef BLKPG_DEL_PARTITION
 276         struct blkpg_ioctl_arg a;
 277         struct blkpg_partition p;
 278
 279         a.op = BLKPG_DEL_PARTITION;
 280         a.data = (void*)&p;
 281         a.datalen = sizeof(p);
 282         a.flags = 0;
 283         memset(a.data, 0, a.datalen);
 284         for (p.pno = 0; p.pno < 16; p.pno++)
 285                 ioctl(fd, BLKPG, &a);
 286 #endif
 287 }
 288
 289 int test_partition(int fd)
 290 {
 291         /* Check if fd is a whole-disk or a partition.
 292          * BLKPG will return EINVAL on a partition, and BLKPG_DEL_PARTITION
 293          * will return ENXIO on an invalid partition number.
 294          */
 295         struct blkpg_ioctl_arg a;
 296         struct blkpg_partition p;
 297         a.op = BLKPG_DEL_PARTITION;
 298         a.data = (void*)&p;
 299         a.datalen = sizeof(p);
 300         a.flags = 0;
 301         memset(a.data, 0, a.datalen);
 302         p.pno = 1<<30;
 303         if (ioctl(fd, BLKPG, &a) == 0)
 304                 /* Very unlikely, but not a partition */
 305                 return 0;
 306         if (errno == ENXIO)
 307                 /* not a partition */
 308                 return 0;
 309
 310         return 1;
 311 }
 312
 313 int test_partition_from_id(dev_t id)
 314 {
 315         char buf[20];
 316         int fd, rv;
 317
 318         sprintf(buf, "%d:%d", major(id), minor(id));
 319         fd = dev_open(buf, O_RDONLY);
 320         if (fd < 0)
 321                 return -1;
 322         rv = test_partition(fd);
 323         close(fd);
 324         return rv;
 325 }
 326
 327 int enough(int level, int raid_disks, int layout, int clean, char *avail)
 328 {
 329         int copies, first;
 330         int i;
 331         int avail_disks = 0;
 332
 333         for (i = 0; i < raid_disks; i++)
 334                 avail_disks += !!avail[i];
 335
 336         switch (level) {
 337         case 10:
 338                 /* This is the tricky one - we need to check
 339                  * which actual disks are present.
 340                  */
 341                 copies = (layout&255)* ((layout>>8) & 255);
 342                 first = 0;
 343                 do {
 344                         /* there must be one of the 'copies' form 'first' */
 345                         int n = copies;
 346                         int cnt = 0;
 347                         while (n--) {
 348                                 if (avail[first])
 349                                         cnt++;
 350                                 first = (first+1) % raid_disks;
 351                         }
 352                         if (cnt == 0)
 353                                 return 0;
 354
 355                 } while (first != 0);
 356                 return 1;
 357
 358         case LEVEL_MULTIPATH:
 359                 return avail_disks>= 1;
 360         case LEVEL_LINEAR:
 361         case 0:
 362                 return avail_disks == raid_disks;
 363         case 1:
 364                 return avail_disks >= 1;
 365         case 4:
 366         case 5:
 367                 if (clean)
 368                         return avail_disks >= raid_disks-1;
 369                 else
 370                         return avail_disks >= raid_disks;
 371         case 6:
 372                 if (clean)
 373                         return avail_disks >= raid_disks-2;
 374                 else
 375                         return avail_disks >= raid_disks;
 376         default:
 377                 return 0;
 378         }
 379 }
 380
 381 int enough_fd(int fd)
 382 {
 383         struct mdu_array_info_s array;
 384         struct mdu_disk_info_s disk;
 385         int avail_disks = 0;
 386         int i, rv;
 387         char *avail;
 388
 389         if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 ||
 390             array.raid_disks <= 0)
 391                 return 0;
 392         avail = xcalloc(array.raid_disks, 1);
 393         for (i = 0; i < MAX_DISKS && array.nr_disks > 0; i++) {
 394                 disk.number = i;
 395                 if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
 396                         continue;
 397                 if (disk.major == 0 && disk.minor == 0)
 398                         continue;
 399                 array.nr_disks--;
 400
 401                 if (! (disk.state & (1<<MD_DISK_SYNC)))
 402                         continue;
 403                 if (disk.raid_disk < 0 || disk.raid_disk >= array.raid_disks)
 404                         continue;
 405                 avail_disks++;
 406                 avail[disk.raid_disk] = 1;
 407         }
 408         /* This is used on an active array, so assume it is clean */
 409         rv = enough(array.level, array.raid_disks, array.layout,
 410                     1, avail);
 411         free(avail);
 412         return rv;
 413 }
 414
 415 const int uuid_zero[4] = { 0, 0, 0, 0 };
 416
 417 int same_uuid(int a[4], int b[4], int swapuuid)
 418 {
 419         if (swapuuid) {
 420                 /* parse uuids are hostendian.
 421                  * uuid's from some superblocks are big-ending
 422                  * if there is a difference, we need to swap..
 423                  */
 424                 unsigned char *ac = (unsigned char *)a;
 425                 unsigned char *bc = (unsigned char *)b;
 426                 int i;
 427                 for (i = 0; i < 16; i += 4) {
 428                         if (ac[i+0] != bc[i+3] ||
 429                             ac[i+1] != bc[i+2] ||
 430                             ac[i+2] != bc[i+1] ||
 431                             ac[i+3] != bc[i+0])
 432                                 return 0;
 433                 }
 434                 return 1;
 435         } else {
 436                 if (a[0]==b[0] &&
 437                     a[1]==b[1] &&
 438                     a[2]==b[2] &&
 439                     a[3]==b[3])
 440                         return 1;
 441                 return 0;
 442         }
 443 }
 444
 445 void copy_uuid(void *a, int b[4], int swapuuid)
 446 {
 447         if (swapuuid) {
 448                 /* parse uuids are hostendian.
 449                  * uuid's from some superblocks are big-ending
 450                  * if there is a difference, we need to swap..
 451                  */
 452                 unsigned char *ac = (unsigned char *)a;
 453                 unsigned char *bc = (unsigned char *)b;
 454                 int i;
 455                 for (i = 0; i < 16; i += 4) {
 456                         ac[i+0] = bc[i+3];
 457                         ac[i+1] = bc[i+2];
 458                         ac[i+2] = bc[i+1];
 459                         ac[i+3] = bc[i+0];
 460                 }
 461         } else
 462                 memcpy(a, b, 16);
 463 }
 464
 465 char *__fname_from_uuid(int id[4], int swap, char *buf, char sep)
 466 {
 467         int i, j;
 468         char uuid[16];
 469         char *c = buf;
 470         strcpy(c, "UUID-");
 471         c += strlen(c);
 472         copy_uuid(uuid, id, swap);
 473         for (i = 0; i < 4; i++) {
 474                 if (i)
 475                         *c++ = sep;
 476                 for (j = 3; j >= 0; j--) {
 477                         sprintf(c,"%02x", (unsigned char) uuid[j+4*i]);
 478                         c+= 2;
 479                 }
 480         }
 481         return buf;
 482
 483 }
 484
 485 char *fname_from_uuid(struct supertype *st, struct mdinfo *info, char *buf, char sep)
 486 {
 487         // dirty hack to work around an issue with super1 superblocks...
 488         // super1 superblocks need swapuuid set in order for assembly to
 489         // work, but can't have it set if we want this printout to match
 490         // all the other uuid printouts in super1.c, so we force swapuuid
 491         // to 1 to make our printout match the rest of super1
 492         return __fname_from_uuid(info->uuid, (st->ss == &super1) ? 1 : st->ss->swapuuid, buf, sep);
 493 }
 494
 495 #ifndef MDASSEMBLE
 496 int check_ext2(int fd, char *name)
 497 {
 498         /*
 499          * Check for an ext2fs file system.
 500          * Superblock is always 1K at 1K offset
 501          *
 502          * s_magic is le16 at 56 == 0xEF53
 503          * report mtime - le32 at 44
 504          * blocks - le32 at 4
 505          * logblksize - le32 at 24
 506          */
 507         unsigned char sb[1024];
 508         time_t mtime;
 509         int size, bsize;
 510         if (lseek(fd, 1024,0)!= 1024)
 511                 return 0;
 512         if (read(fd, sb, 1024)!= 1024)
 513                 return 0;
 514         if (sb[56] != 0x53 || sb[57] != 0xef)
 515                 return 0;
 516
 517         mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
 518         bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
 519         size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
 520         pr_err("%s appears to contain an ext2fs file system\n",
 521                 name);
 522         fprintf(stderr,"    size=%dK  mtime=%s",
 523                 size*(1<<bsize), ctime(&mtime));
 524         return 1;
 525 }
 526
 527 int check_reiser(int fd, char *name)
 528 {
 529         /*
 530          * superblock is at 64K
 531          * size is 1024;
 532          * Magic string "ReIsErFs" or "ReIsEr2Fs" at 52
 533          *
 534          */
 535         unsigned char sb[1024];
 536         unsigned long size;
 537         if (lseek(fd, 64*1024, 0) != 64*1024)
 538                 return 0;
 539         if (read(fd, sb, 1024) != 1024)
 540                 return 0;
 541         if (strncmp((char*)sb+52, "ReIsErFs",8) != 0 &&
 542             strncmp((char*)sb+52, "ReIsEr2Fs",9) != 0)
 543                 return 0;
 544         pr_err("%s appears to contain a reiserfs file system\n",name);
 545         size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
 546         fprintf(stderr, "    size = %luK\n", size*4);
 547
 548         return 1;
 549 }
 550
 551 int check_raid(int fd, char *name)
 552 {
 553         struct mdinfo info;
 554         time_t crtime;
 555         char *level;
 556         struct supertype *st = guess_super(fd);
 557
 558         if (!st) return 0;
 559         st->ignore_hw_compat = 1;
 560         st->ss->load_super(st, fd, name);
 561         /* Looks like a raid array .. */
 562         pr_err("%s appears to be part of a raid array:\n",
 563                 name);
 564         st->ss->getinfo_super(st, &info, NULL);
 565         st->ss->free_super(st);
 566         crtime = info.array.ctime;
 567         level = map_num(pers, info.array.level);
 568         if (!level) level = "-unknown-";
 569         fprintf(stderr, "    level=%s devices=%d ctime=%s",
 570                 level, info.array.raid_disks, ctime(&crtime));
 571         return 1;
 572 }
 573
 574 int ask(char *mesg)
 575 {
 576         char *add = "";
 577         int i;
 578         for (i = 0; i < 5; i++) {
 579                 char buf[100];
 580                 fprintf(stderr, "%s%s", mesg, add);
 581                 fflush(stderr);
 582                 if (fgets(buf, 100, stdin)==NULL)
 583                         return 0;
 584                 if (buf[0]=='y' || buf[0]=='Y')
 585                         return 1;
 586                 if (buf[0]=='n' || buf[0]=='N')
 587                         return 0;
 588                 add = "(y/n) ";
 589         }
 590         pr_err("assuming 'no'\n");
 591         return 0;
 592 }
 593 #endif /* MDASSEMBLE */
 594
 595 int is_standard(char *dev, int *nump)
 596 {
 597         /* tests if dev is a "standard" md dev name.
 598          * i.e if the last component is "/dNN" or "/mdNN",
 599          * where NN is a string of digits
 600          * Returns 1 if a partitionable standard,
 601          *   -1 if non-partitonable,
 602          *   0 if not a standard name.
 603          */
 604         char *d = strrchr(dev, '/');
 605         int type = 0;
 606         int num;
 607         if (!d)
 608                 return 0;
 609         if (strncmp(d, "/d",2) == 0)
 610                 d += 2, type = 1; /* /dev/md/dN{pM} */
 611         else if (strncmp(d, "/md_d", 5) == 0)
 612                 d += 5, type = 1; /* /dev/md_dN{pM} */
 613         else if (strncmp(d, "/md", 3) == 0)
 614                 d += 3, type = -1; /* /dev/mdN */
 615         else if (d-dev > 3 && strncmp(d-2, "md/", 3) == 0)
 616                 d += 1, type = -1; /* /dev/md/N */
 617         else
 618                 return 0;
 619         if (!*d)
 620                 return 0;
 621         num = atoi(d);
 622         while (isdigit(*d))
 623                 d++;
 624         if (*d)
 625                 return 0;
 626         if (nump) *nump = num;
 627
 628         return type;
 629 }
 630
 631 unsigned long calc_csum(void *super, int bytes)
 632 {
 633         unsigned long long newcsum = 0;
 634         int i;
 635         unsigned int csum;
 636         unsigned int *superc = (unsigned int*) super;
 637
 638         for(i = 0; i < bytes/4; i++)
 639                 newcsum += superc[i];
 640         csum = (newcsum& 0xffffffff) + (newcsum>>32);
 641 #ifdef __alpha__
 642 /* The in-kernel checksum calculation is always 16bit on
 643  * the alpha, though it is 32 bit on i386...
 644  * I wonder what it is elsewhere... (it uses an API in
 645  * a way that it shouldn't).
 646  */
 647         csum = (csum & 0xffff) + (csum >> 16);
 648         csum = (csum & 0xffff) + (csum >> 16);
 649 #endif
 650         return csum;
 651 }
 652
 653 #ifndef MDASSEMBLE
 654 char *human_size(long long bytes)
 655 {
 656         static char buf[30];
 657
 658         /* We convert bytes to either centi-M{ega,ibi}bytes or
 659          * centi-G{igi,ibi}bytes, with appropriate rounding,
 660          * and then print 1/100th of those as a decimal.
 661          * We allow upto 2048Megabytes before converting to
 662          * gigabytes, as that shows more precision and isn't
 663          * too large a number.
 664          * Terabytes are not yet handled.
 665          */
 666
 667         if (bytes < 5000*1024)
 668                 buf[0] = 0;
 669         else if (bytes < 2*1024LL*1024LL*1024LL) {
 670                 long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2;
 671                 long cMB  = (bytes / ( 1000000LL / 200LL ) +1) /2;
 672                 snprintf(buf, sizeof(buf), " (%ld.%02ld MiB %ld.%02ld MB)",
 673                         cMiB/100 , cMiB % 100,
 674                         cMB/100, cMB % 100);
 675         } else {
 676                 long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2;
 677                 long cGB  = (bytes / (1000000000LL/200LL ) +1) /2;
 678                 snprintf(buf, sizeof(buf), " (%ld.%02ld GiB %ld.%02ld GB)",
 679                         cGiB/100 , cGiB % 100,
 680                         cGB/100, cGB % 100);
 681         }
 682         return buf;
 683 }
 684
 685 char *human_size_brief(long long bytes)
 686 {
 687         static char buf[30];
 688
 689         /* We convert bytes to either centi-M{ega,ibi}bytes or
 690          * centi-G{igi,ibi}bytes, with appropriate rounding,
 691          * and then print 1/100th of those as a decimal.
 692          * We allow upto 2048Megabytes before converting to
 693          * gigabytes, as that shows more precision and isn't
 694          * too large a number.
 695          * Terabytes are not yet handled.
 696          */
 697
 698         if (bytes < 5000*1024)
 699                 buf[0] = 0;
 700         else if (bytes < 2*1024LL*1024LL*1024LL) {
 701                 long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2;
 702                 snprintf(buf, sizeof(buf), " (%ld.%02ldMiB)",
 703                         cMiB/100 , cMiB % 100);
 704         } else {
 705                 long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2;
 706                 snprintf(buf, sizeof(buf), " (%ld.%02ldGiB)",
 707                                 cGiB/100 , cGiB % 100);
 708         }
 709
 710         return buf;
 711 }
 712
 713 void print_r10_layout(int layout)
 714 {
 715         int near = layout & 255;
 716         int far = (layout >> 8) & 255;
 717         int offset = (layout&0x10000);
 718         char *sep = "";
 719
 720         if (near != 1) {
 721                 printf("%s near=%d", sep, near);
 722                 sep = ",";
 723         }
 724         if (far != 1)
 725                 printf("%s %s=%d", sep, offset?"offset":"far", far);
 726         if (near*far == 1)
 727                 printf("NO REDUNDANCY");
 728 }
 729 #endif
 730
 731 unsigned long long calc_array_size(int level, int raid_disks, int layout,
 732                                    int chunksize, unsigned long long devsize)
 733 {
 734         if (level == 1)
 735                 return devsize;
 736         devsize &= ~(unsigned long long)((chunksize>>9)-1);
 737         return get_data_disks(level, layout, raid_disks) * devsize;
 738 }
 739
 740 int get_data_disks(int level, int layout, int raid_disks)
 741 {
 742         int data_disks = 0;
 743         switch (level) {
 744         case 0: data_disks = raid_disks;
 745                 break;
 746         case 1: data_disks = 1;
 747                 break;
 748         case 4:
 749         case 5: data_disks = raid_disks - 1;
 750                 break;
 751         case 6: data_disks = raid_disks - 2;
 752                 break;
 753         case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255);
 754                 break;
 755         }
 756
 757         return data_disks;
 758 }
 759
 760 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 761 char *get_md_name(int dev)
 762 {
 763         /* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
 764         /* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
 765         static char devname[50];
 766         struct stat stb;
 767         dev_t rdev;
 768         char *dn;
 769
 770         if (dev < 0) {
 771                 int mdp =  get_mdp_major();
 772                 if (mdp < 0) return NULL;
 773                 rdev = makedev(mdp, (-1-dev)<<6);
 774                 snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev);
 775                 if (stat(devname, &stb) == 0
 776                     && (S_IFMT&stb.st_mode) == S_IFBLK
 777                     && (stb.st_rdev == rdev))
 778                         return devname;
 779         } else {
 780                 rdev = makedev(MD_MAJOR, dev);
 781                 snprintf(devname, sizeof(devname), "/dev/md%d", dev);
 782                 if (stat(devname, &stb) == 0
 783                     && (S_IFMT&stb.st_mode) == S_IFBLK
 784                     && (stb.st_rdev == rdev))
 785                         return devname;
 786
 787                 snprintf(devname, sizeof(devname), "/dev/md/%d", dev);
 788                 if (stat(devname, &stb) == 0
 789                     && (S_IFMT&stb.st_mode) == S_IFBLK
 790                     && (stb.st_rdev == rdev))
 791                         return devname;
 792         }
 793         dn = map_dev(major(rdev), minor(rdev), 0);
 794         if (dn)
 795                 return dn;
 796         snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev);
 797         if (mknod(devname, S_IFBLK | 0600, rdev) == -1)
 798                 if (errno != EEXIST)
 799                         return NULL;
 800
 801         if (stat(devname, &stb) == 0
 802             && (S_IFMT&stb.st_mode) == S_IFBLK
 803             && (stb.st_rdev == rdev))
 804                 return devname;
 805         unlink(devname);
 806         return NULL;
 807 }
 808
 809 void put_md_name(char *name)
 810 {
 811         if (strncmp(name, "/dev/.tmp.md", 12) == 0)
 812                 unlink(name);
 813 }
 814
 815 int find_free_devnum(int use_partitions)
 816 {
 817         int devnum;
 818         for (devnum = 127; devnum != 128;
 819              devnum = devnum ? devnum-1 : (1<<20)-1) {
 820                 char *dn;
 821                 int _devnum;
 822                 char nbuf[50];
 823
 824                 _devnum = use_partitions ? (-1-devnum) : devnum;
 825                 if (mddev_busy(_devnum))
 826                         continue;
 827                 sprintf(nbuf, "%s%d", use_partitions?"mdp":"md", devnum);
 828                 if (!conf_name_is_free(nbuf))
 829                         continue;
 830                 /* make sure it is new to /dev too, at least as a
 831                  * non-standard */
 832                 dn = map_dev(dev2major(_devnum), dev2minor(_devnum), 0);
 833                 if (dn && ! is_standard(dn, NULL))
 834                         continue;
 835                 break;
 836         }
 837         if (devnum == 128)
 838                 return NoMdDev;
 839         return use_partitions ? (-1-devnum) : devnum;
 840 }
 841 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
 842
 843 int dev_open(char *dev, int flags)
 844 {
 845         /* like 'open', but if 'dev' matches %d:%d, create a temp
 846          * block device and open that
 847          */
 848         char *e;
 849         int fd = -1;
 850         char devname[32];
 851         int major;
 852         int minor;
 853
 854         if (!dev) return -1;
 855         flags |= O_DIRECT;
 856
 857         major = strtoul(dev, &e, 0);
 858         if (e > dev && *e == ':' && e[1] &&
 859             (minor = strtoul(e+1, &e, 0)) >= 0 &&
 860             *e == 0) {
 861                 char *path = map_dev(major, minor, 0);
 862                 if (path)
 863                         fd = open(path, flags);
 864                 if (fd < 0) {
 865                         snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d",
 866                                  (int)getpid(), major, minor);
 867                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
 868                                 fd = open(devname, flags);
 869                                 unlink(devname);
 870                         }
 871                 }
 872                 if (fd < 0) {
 873                         snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d",
 874                                  (int)getpid(), major, minor);
 875                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
 876                                 fd = open(devname, flags);
 877                                 unlink(devname);
 878                         }
 879                 }
 880         } else
 881                 fd = open(dev, flags);
 882         return fd;
 883 }
 884
 885 int open_dev_flags(int devnum, int flags)
 886 {
 887         char buf[20];
 888
 889         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
 890         return dev_open(buf, flags);
 891 }
 892
 893 int open_dev(int devnum)
 894 {
 895         return open_dev_flags(devnum, O_RDONLY);
 896 }
 897
 898 int open_dev_excl(int devnum)
 899 {
 900         char buf[20];
 901         int i;
 902         int flags = O_RDWR;
 903
 904         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
 905         for (i = 0 ; i < 25 ; i++) {
 906                 int fd = dev_open(buf, flags|O_EXCL);
 907                 if (fd >= 0)
 908                         return fd;
 909                 if (errno == EACCES && flags == O_RDWR) {
 910                         flags = O_RDONLY;
 911                         continue;
 912                 }
 913                 if (errno != EBUSY)
 914                         return fd;
 915                 usleep(200000);
 916         }
 917         return -1;
 918 }
 919
 920 int same_dev(char *one, char *two)
 921 {
 922         struct stat st1, st2;
 923         if (stat(one, &st1) != 0)
 924                 return 0;
 925         if (stat(two, &st2) != 0)
 926                 return 0;
 927         if ((st1.st_mode & S_IFMT) != S_IFBLK)
 928                 return 0;
 929         if ((st2.st_mode & S_IFMT) != S_IFBLK)
 930                 return 0;
 931         return st1.st_rdev == st2.st_rdev;
 932 }
 933
 934 void wait_for(char *dev, int fd)
 935 {
 936         int i;
 937         struct stat stb_want;
 938
 939         if (fstat(fd, &stb_want) != 0 ||
 940             (stb_want.st_mode & S_IFMT) != S_IFBLK)
 941                 return;
 942
 943         for (i = 0 ; i < 25 ; i++) {
 944                 struct stat stb;
 945                 if (stat(dev, &stb) == 0 &&
 946                     (stb.st_mode & S_IFMT) == S_IFBLK &&
 947                     (stb.st_rdev == stb_want.st_rdev))
 948                         return;
 949                 usleep(200000);
 950         }
 951         if (i == 25)
 952                 dprintf("%s: timeout waiting for %s\n", __func__, dev);
 953 }
 954
 955 struct superswitch *superlist[] =
 956 {
 957         &super0, &super1,
 958         &super_ddf, &super_imsm,
 959         &mbr, &gpt,
 960         NULL };
 961
 962 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 963
 964 struct supertype *super_by_fd(int fd, char **subarrayp)
 965 {
 966         mdu_array_info_t array;
 967         int vers;
 968         int minor;
 969         struct supertype *st = NULL;
 970         struct mdinfo *sra;
 971         char *verstr;
 972         char version[20];
 973         int i;
 974         char *subarray = NULL;
 975         int container = NoMdDev;
 976
 977         sra = sysfs_read(fd, 0, GET_VERSION);
 978
 979         if (sra) {
 980                 vers = sra->array.major_version;
 981                 minor = sra->array.minor_version;
 982                 verstr = sra->text_version;
 983         } else {
 984                 if (ioctl(fd, GET_ARRAY_INFO, &array))
 985                         array.major_version = array.minor_version = 0;
 986                 vers = array.major_version;
 987                 minor = array.minor_version;
 988                 verstr = "";
 989         }
 990
 991         if (vers != -1) {
 992                 sprintf(version, "%d.%d", vers, minor);
 993                 verstr = version;
 994         }
 995         if (minor == -2 && is_subarray(verstr)) {
 996                 char *dev = verstr+1;
 997
 998                 subarray = strchr(dev, '/');
 999                 if (subarray) {
1000                         *subarray++ = '\0';
1001                         subarray = xstrdup(subarray);
1002                 }
1003                 container = devname2devnum(dev);
1004                 if (sra)
1005                         sysfs_free(sra);
1006                 sra = sysfs_read(-1, container, GET_VERSION);
1007                 if (sra && sra->text_version[0])
1008                         verstr = sra->text_version;
1009                 else
1010                         verstr = "-no-metadata-";
1011         }
1012
1013         for (i = 0; st == NULL && superlist[i] ; i++)
1014                 st = superlist[i]->match_metadata_desc(verstr);
1015
1016         if (sra)
1017                 sysfs_free(sra);
1018         if (st) {
1019                 st->sb = NULL;
1020                 if (subarrayp)
1021                         *subarrayp = subarray;
1022                 st->container_dev = container;
1023                 st->devnum = fd2devnum(fd);
1024         } else
1025                 free(subarray);
1026
1027         return st;
1028 }
1029 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
1030
1031 int dev_size_from_id(dev_t id, unsigned long long *size)
1032 {
1033         char buf[20];
1034         int fd;
1035
1036         sprintf(buf, "%d:%d", major(id), minor(id));
1037         fd = dev_open(buf, O_RDONLY);
1038         if (fd < 0)
1039                 return 0;
1040         if (get_dev_size(fd, NULL, size)) {
1041                 close(fd);
1042                 return 1;
1043         }
1044         close(fd);
1045         return 0;
1046 }
1047
1048 struct supertype *dup_super(struct supertype *orig)
1049 {
1050         struct supertype *st;
1051
1052         if (!orig)
1053                 return orig;
1054         st = xcalloc(1, sizeof(*st));
1055         st->ss = orig->ss;
1056         st->max_devs = orig->max_devs;
1057         st->minor_version = orig->minor_version;
1058         st->sb = NULL;
1059         st->info = NULL;
1060         return st;
1061 }
1062
1063 struct supertype *guess_super_type(int fd, enum guess_types guess_type)
1064 {
1065         /* try each load_super to find the best match,
1066          * and return the best superswitch
1067          */
1068         struct superswitch  *ss;
1069         struct supertype *st;
1070         time_t besttime = 0;
1071         int bestsuper = -1;
1072         int i;
1073
1074         st = xcalloc(1, sizeof(*st));
1075         st->container_dev = NoMdDev;
1076
1077         for (i = 0 ; superlist[i]; i++) {
1078                 int rv;
1079                 ss = superlist[i];
1080                 if (guess_type == guess_array && ss->add_to_super == NULL)
1081                         continue;
1082                 if (guess_type == guess_partitions && ss->add_to_super != NULL)
1083                         continue;
1084                 memset(st, 0, sizeof(*st));
1085                 st->ignore_hw_compat = 1;
1086                 rv = ss->load_super(st, fd, NULL);
1087                 if (rv == 0) {
1088                         struct mdinfo info;
1089                         st->ss->getinfo_super(st, &info, NULL);
1090                         if (bestsuper == -1 ||
1091                             besttime < info.array.ctime) {
1092                                 bestsuper = i;
1093                                 besttime = info.array.ctime;
1094                         }
1095                         ss->free_super(st);
1096                 }
1097         }
1098         if (bestsuper != -1) {
1099                 int rv;
1100                 memset(st, 0, sizeof(*st));
1101                 st->ignore_hw_compat = 1;
1102                 rv = superlist[bestsuper]->load_super(st, fd, NULL);
1103                 if (rv == 0) {
1104                         superlist[bestsuper]->free_super(st);
1105                         st->ignore_hw_compat = 0;
1106                         return st;
1107                 }
1108         }
1109         free(st);
1110         return NULL;
1111 }
1112
1113 /* Return size of device in bytes */
1114 int get_dev_size(int fd, char *dname, unsigned long long *sizep)
1115 {
1116         unsigned long long ldsize;
1117         struct stat st;
1118
1119         if (fstat(fd, &st) != -1 && S_ISREG(st.st_mode))
1120                 ldsize = (unsigned long long)st.st_size;
1121         else
1122 #ifdef BLKGETSIZE64
1123         if (ioctl(fd, BLKGETSIZE64, &ldsize) != 0)
1124 #endif
1125         {
1126                 unsigned long dsize;
1127                 if (ioctl(fd, BLKGETSIZE, &dsize) == 0) {
1128                         ldsize = dsize;
1129                         ldsize <<= 9;
1130                 } else {
1131                         if (dname)
1132                                 pr_err("Cannot get size of %s: %s\b",
1133                                         dname, strerror(errno));
1134                         return 0;
1135                 }
1136         }
1137         *sizep = ldsize;
1138         return 1;
1139 }
1140
1141 /* Return true if this can only be a container, not a member device.
1142  * i.e. is and md device and size is zero
1143  */
1144 int must_be_container(int fd)
1145 {
1146         unsigned long long size;
1147         if (md_get_version(fd) < 0)
1148                 return 0;
1149         if (get_dev_size(fd, NULL, &size) == 0)
1150                 return 1;
1151         if (size == 0)
1152                 return 1;
1153         return 0;
1154 }
1155
1156 /* Sets endofpart parameter to the last block used by the last GPT partition on the device.
1157  * Returns: 1 if successful
1158  *         -1 for unknown partition type
1159  *          0 for other errors
1160  */
1161 static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
1162 {
1163         struct GPT gpt;
1164         unsigned char empty_gpt_entry[16]= {0};
1165         struct GPT_part_entry *part;
1166         char buf[512];
1167         unsigned long long curr_part_end;
1168         unsigned all_partitions, entry_size;
1169         unsigned part_nr;
1170
1171         *endofpart = 0;
1172
1173         BUILD_BUG_ON(sizeof(gpt) != 512);
1174         /* skip protective MBR */
1175         lseek(fd, 512, SEEK_SET);
1176         /* read GPT header */
1177         if (read(fd, &gpt, 512) != 512)
1178                 return 0;
1179
1180         /* get the number of partition entries and the entry size */
1181         all_partitions = __le32_to_cpu(gpt.part_cnt);
1182         entry_size = __le32_to_cpu(gpt.part_size);
1183
1184         /* Check GPT signature*/
1185         if (gpt.magic != GPT_SIGNATURE_MAGIC)
1186                 return -1;
1187
1188         /* sanity checks */
1189         if (all_partitions > 1024 ||
1190             entry_size > sizeof(buf))
1191                 return -1;
1192
1193         part = (struct GPT_part_entry *)buf;
1194
1195         for (part_nr = 0; part_nr < all_partitions; part_nr++) {
1196                 /* read partition entry */
1197                 if (read(fd, buf, entry_size) != (ssize_t)entry_size)
1198                         return 0;
1199
1200                 /* is this valid partition? */
1201                 if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
1202                         /* check the last lba for the current partition */
1203                         curr_part_end = __le64_to_cpu(part->ending_lba);
1204                         if (curr_part_end > *endofpart)
1205                                 *endofpart = curr_part_end;
1206                 }
1207
1208         }
1209         return 1;
1210 }
1211
1212 /* Sets endofpart parameter to the last block used by the last partition on the device.
1213  * Returns: 1 if successful
1214  *         -1 for unknown partition type
1215  *          0 for other errors
1216  */
1217 static int get_last_partition_end(int fd, unsigned long long *endofpart)
1218 {
1219         struct MBR boot_sect;
1220         struct MBR_part_record *part;
1221         unsigned long long curr_part_end;
1222         unsigned part_nr;
1223         int retval = 0;
1224
1225         *endofpart = 0;
1226
1227         BUILD_BUG_ON(sizeof(boot_sect) != 512);
1228         /* read MBR */
1229         lseek(fd, 0, 0);
1230         if (read(fd, &boot_sect, 512) != 512)
1231                 goto abort;
1232
1233         /* check MBP signature */
1234         if (boot_sect.magic == MBR_SIGNATURE_MAGIC) {
1235                 retval = 1;
1236                 /* found the correct signature */
1237                 part = boot_sect.parts;
1238
1239                 for (part_nr = 0; part_nr < MBR_PARTITIONS; part_nr++) {
1240                         /* check for GPT type */
1241                         if (part->part_type == MBR_GPT_PARTITION_TYPE) {
1242                                 retval = get_gpt_last_partition_end(fd, endofpart);
1243                                 break;
1244                         }
1245                         /* check the last used lba for the current partition  */
1246                         curr_part_end = __le32_to_cpu(part->first_sect_lba) +
1247                                 __le32_to_cpu(part->blocks_num);
1248                         if (curr_part_end > *endofpart)
1249                                 *endofpart = curr_part_end;
1250
1251                         part++;
1252                 }
1253         } else {
1254                 /* Unknown partition table */
1255                 retval = -1;
1256         }
1257  abort:
1258         return retval;
1259 }
1260
1261 int check_partitions(int fd, char *dname, unsigned long long freesize,
1262                         unsigned long long size)
1263 {
1264         /*
1265          * Check where the last partition ends
1266          */
1267         unsigned long long endofpart;
1268         int ret;
1269
1270         if ((ret = get_last_partition_end(fd, &endofpart)) > 0) {
1271                 /* There appears to be a partition table here */
1272                 if (freesize == 0) {
1273                         /* partitions will not be visible in new device */
1274                         pr_err("partition table exists on %s but will be lost or\n"
1275                                "       meaningless after creating array\n",
1276                                dname);
1277                         return 1;
1278                 } else if (endofpart > freesize) {
1279                         /* last partition overlaps metadata */
1280                         pr_err("metadata will over-write last partition on %s.\n",
1281                                dname);
1282                         return 1;
1283                 } else if (size && endofpart > size) {
1284                         /* partitions will be truncated in new device */
1285                         pr_err("array size is too small to cover all partitions on %s.\n",
1286                                dname);
1287                         return 1;
1288                 }
1289         }
1290         return 0;
1291 }
1292
1293 void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk)
1294 {
1295         int d;
1296
1297         ioctl(mdfd, GET_ARRAY_INFO, ainf);
1298         for (d = 0 ; d < MAX_DISKS ; d++) {
1299                 if (ioctl(mdfd, GET_DISK_INFO, disk) == 0 &&
1300                     (disk->major || disk->minor))
1301                         return;
1302         }
1303 }
1304
1305 int open_container(int fd)
1306 {
1307         /* 'fd' is a block device.  Find out if it is in use
1308          * by a container, and return an open fd on that container.
1309          */
1310         char path[256];
1311         char *e;
1312         DIR *dir;
1313         struct dirent *de;
1314         int dfd, n;
1315         char buf[200];
1316         int major, minor;
1317         struct stat st;
1318
1319         if (fstat(fd, &st) != 0)
1320                 return -1;
1321         sprintf(path, "/sys/dev/block/%d:%d/holders",
1322                 (int)major(st.st_rdev), (int)minor(st.st_rdev));
1323         e = path + strlen(path);
1324
1325         dir = opendir(path);
1326         if (!dir)
1327                 return -1;
1328         while ((de = readdir(dir))) {
1329                 if (de->d_ino == 0)
1330                         continue;
1331                 if (de->d_name[0] == '.')
1332                         continue;
1333                 sprintf(e, "/%s/dev", de->d_name);
1334                 dfd = open(path, O_RDONLY);
1335                 if (dfd < 0)
1336                         continue;
1337                 n = read(dfd, buf, sizeof(buf));
1338                 close(dfd);
1339                 if (n <= 0 || (unsigned)n >= sizeof(buf))
1340                         continue;
1341                 buf[n] = 0;
1342                 if (sscanf(buf, "%d:%d", &major, &minor) != 2)
1343                         continue;
1344                 sprintf(buf, "%d:%d", major, minor);
1345                 dfd = dev_open(buf, O_RDONLY);
1346                 if (dfd >= 0) {
1347                         closedir(dir);
1348                         return dfd;
1349                 }
1350         }
1351         closedir(dir);
1352         return -1;
1353 }
1354
1355 struct superswitch *version_to_superswitch(char *vers)
1356 {
1357         int i;
1358
1359         for (i = 0; superlist[i]; i++) {
1360                 struct superswitch *ss = superlist[i];
1361
1362                 if (strcmp(vers, ss->name) == 0)
1363                         return ss;
1364         }
1365
1366         return NULL;
1367 }
1368
1369 int is_container_member(struct mdstat_ent *mdstat, char *container)
1370 {
1371         if (mdstat->metadata_version == NULL ||
1372             strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
1373             !is_subarray(mdstat->metadata_version+9) ||
1374             strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 ||
1375             mdstat->metadata_version[10+strlen(container)] != '/')
1376                 return 0;
1377
1378         return 1;
1379 }
1380
1381 int is_subarray_active(char *subarray, char *container)
1382 {
1383         struct mdstat_ent *mdstat = mdstat_read(0, 0);
1384         struct mdstat_ent *ent;
1385
1386         for (ent = mdstat; ent; ent = ent->next)
1387                 if (is_container_member(ent, container))
1388                         if (strcmp(to_subarray(ent, container), subarray) == 0)
1389                                 break;
1390
1391         free_mdstat(mdstat);
1392
1393         return ent != NULL;
1394 }
1395
1396 /* open_subarray - opens a subarray in a container
1397  * @dev: container device name
1398  * @st: empty supertype
1399  * @quiet: block reporting errors flag
1400  *
1401  * On success returns an fd to a container and fills in *st
1402  */
1403 int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet)
1404 {
1405         struct mdinfo *mdi;
1406         struct mdinfo *info;
1407         int fd, err = 1;
1408
1409         fd = open(dev, O_RDWR|O_EXCL);
1410         if (fd < 0) {
1411                 if (!quiet)
1412                         pr_err("Couldn't open %s, aborting\n",
1413                                 dev);
1414                 return -1;
1415         }
1416
1417         st->devnum = fd2devnum(fd);
1418         if (st->devnum == NoMdDev) {
1419                 if (!quiet)
1420                         pr_err("Failed to determine device number for %s\n",
1421                                dev);
1422                 goto close_fd;
1423         }
1424
1425         mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
1426         if (!mdi) {
1427                 if (!quiet)
1428                         pr_err("Failed to read sysfs for %s\n",
1429                                 dev);
1430                 goto close_fd;
1431         }
1432
1433         if (mdi->array.level != UnSet) {
1434                 if (!quiet)
1435                         pr_err("%s is not a container\n", dev);
1436                 goto free_sysfs;
1437         }
1438
1439         st->ss = version_to_superswitch(mdi->text_version);
1440         if (!st->ss) {
1441                 if (!quiet)
1442                         pr_err("Operation not supported for %s metadata\n",
1443                                mdi->text_version);
1444                 goto free_sysfs;
1445         }
1446
1447         st->devname = devnum2devname(st->devnum);
1448         if (!st->devname) {
1449                 if (!quiet)
1450                         pr_err("Failed to allocate device name\n");
1451                 goto free_sysfs;
1452         }
1453
1454         if (!st->ss->load_container) {
1455                 if (!quiet)
1456                         pr_err("%s is not a container\n", dev);
1457                 goto free_name;
1458         }
1459
1460         if (st->ss->load_container(st, fd, NULL)) {
1461                 if (!quiet)
1462                         pr_err("Failed to load metadata for %s\n",
1463                                 dev);
1464                 goto free_name;
1465         }
1466
1467         info = st->ss->container_content(st, subarray);
1468         if (!info) {
1469                 if (!quiet)
1470                         pr_err("Failed to find subarray-%s in %s\n",
1471                                 subarray, dev);
1472                 goto free_super;
1473         }
1474         free(info);
1475
1476         err = 0;
1477
1478  free_super:
1479         if (err)
1480                 st->ss->free_super(st);
1481  free_name:
1482         if (err)
1483                 free(st->devname);
1484  free_sysfs:
1485         sysfs_free(mdi);
1486  close_fd:
1487         if (err)
1488                 close(fd);
1489
1490         if (err)
1491                 return -1;
1492         else
1493                 return fd;
1494 }
1495
1496 int add_disk(int mdfd, struct supertype *st,
1497              struct mdinfo *sra, struct mdinfo *info)
1498 {
1499         /* Add a device to an array, in one of 2 ways. */
1500         int rv;
1501 #ifndef MDASSEMBLE
1502         if (st->ss->external) {
1503                 if (info->disk.state & (1<<MD_DISK_SYNC))
1504                         info->recovery_start = MaxSector;
1505                 else
1506                         info->recovery_start = 0;
1507                 rv = sysfs_add_disk(sra, info, 0);
1508                 if (! rv) {
1509                         struct mdinfo *sd2;
1510                         for (sd2 = sra->devs; sd2; sd2=sd2->next)
1511                                 if (sd2 == info)
1512                                         break;
1513                         if (sd2 == NULL) {
1514                                 sd2 = xmalloc(sizeof(*sd2));
1515                                 *sd2 = *info;
1516                                 sd2->next = sra->devs;
1517                                 sra->devs = sd2;
1518                         }
1519                 }
1520         } else
1521 #endif
1522                 rv = ioctl(mdfd, ADD_NEW_DISK, &info->disk);
1523         return rv;
1524 }
1525
1526 int remove_disk(int mdfd, struct supertype *st,
1527                 struct mdinfo *sra, struct mdinfo *info)
1528 {
1529         int rv;
1530         /* Remove the disk given by 'info' from the array */
1531 #ifndef MDASSEMBLE
1532         if (st->ss->external)
1533                 rv = sysfs_set_str(sra, info, "slot", "none");
1534         else
1535 #endif
1536                 rv = ioctl(mdfd, HOT_REMOVE_DISK, makedev(info->disk.major,
1537                                                           info->disk.minor));
1538         return rv;
1539 }
1540
1541 int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info)
1542 {
1543         /* Initialise kernel's knowledge of array.
1544          * This varies between externally managed arrays
1545          * and older kernels
1546          */
1547         int vers = md_get_version(mdfd);
1548         int rv;
1549
1550 #ifndef MDASSEMBLE
1551         if (st->ss->external)
1552                 rv = sysfs_set_array(info, vers);
1553         else
1554 #endif
1555                 if ((vers % 100) >= 1) { /* can use different versions */
1556                 mdu_array_info_t inf;
1557                 memset(&inf, 0, sizeof(inf));
1558                 inf.major_version = info->array.major_version;
1559                 inf.minor_version = info->array.minor_version;
1560                 rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
1561         } else
1562                 rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
1563         return rv;
1564 }
1565
1566 unsigned long long min_recovery_start(struct mdinfo *array)
1567 {
1568         /* find the minimum recovery_start in an array for metadata
1569          * formats that only record per-array recovery progress instead
1570          * of per-device
1571          */
1572         unsigned long long recovery_start = MaxSector;
1573         struct mdinfo *d;
1574
1575         for (d = array->devs; d; d = d->next)
1576                 recovery_start = min(recovery_start, d->recovery_start);
1577
1578         return recovery_start;
1579 }
1580
1581 int mdmon_pid(int devnum)
1582 {
1583         char path[100];
1584         char pid[10];
1585         int fd;
1586         int n;
1587         char *devname = devnum2devname(devnum);
1588
1589         sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
1590         free(devname);
1591
1592         fd = open(path, O_RDONLY | O_NOATIME, 0);
1593
1594         if (fd < 0)
1595                 return -1;
1596         n = read(fd, pid, 9);
1597         close(fd);
1598         if (n <= 0)
1599                 return -1;
1600         return atoi(pid);
1601 }
1602
1603 int mdmon_running(int devnum)
1604 {
1605         int pid = mdmon_pid(devnum);
1606         if (pid <= 0)
1607                 return 0;
1608         if (kill(pid, 0) == 0)
1609                 return 1;
1610         return 0;
1611 }
1612
1613 int start_mdmon(int devnum)
1614 {
1615         int i, skipped;
1616         int len;
1617         pid_t pid;
1618         int status;
1619         char pathbuf[1024];
1620         char *paths[4] = {
1621                 pathbuf,
1622                 "/sbin/mdmon",
1623                 "mdmon",
1624                 NULL
1625         };
1626
1627         if (check_env("MDADM_NO_MDMON"))
1628                 return 0;
1629
1630         len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf)-1);
1631         if (len > 0) {
1632                 char *sl;
1633                 pathbuf[len] = 0;
1634                 sl = strrchr(pathbuf, '/');
1635                 if (sl)
1636                         sl++;
1637                 else
1638                         sl = pathbuf;
1639                 strcpy(sl, "mdmon");
1640         } else
1641                 pathbuf[0] = '\0';
1642
1643         switch(fork()) {
1644         case 0:
1645                 /* FIXME yuk. CLOSE_EXEC?? */
1646                 skipped = 0;
1647                 for (i = 3; skipped < 20; i++)
1648                         if (close(i) < 0)
1649                                 skipped++;
1650                         else
1651                                 skipped = 0;
1652
1653                 for (i = 0; paths[i]; i++)
1654                         if (paths[i][0]) {
1655                                 if (__offroot) {
1656                                         execl(paths[i], "mdmon", "--offroot",
1657                                               devnum2devname(devnum),
1658                                               NULL);
1659                                 } else {
1660                                         execl(paths[i], "mdmon",
1661                                               devnum2devname(devnum),
1662                                               NULL);
1663                                 }
1664                         }
1665                 exit(1);
1666         case -1: pr_err("cannot run mdmon. "
1667                          "Array remains readonly\n");
1668                 return -1;
1669         default: /* parent - good */
1670                 pid = wait(&status);
1671                 if (pid < 0 || status != 0)
1672                         return -1;
1673         }
1674         return 0;
1675 }
1676
1677 int check_env(char *name)
1678 {
1679         char *val = getenv(name);
1680
1681         if (val && atoi(val) == 1)
1682                 return 1;
1683
1684         return 0;
1685 }
1686
1687 __u32 random32(void)
1688 {
1689         __u32 rv;
1690         int rfd = open("/dev/urandom", O_RDONLY);
1691         if (rfd < 0 || read(rfd, &rv, 4) != 4)
1692                 rv = random();
1693         if (rfd >= 0)
1694                 close(rfd);
1695         return rv;
1696 }
1697
1698 #ifndef MDASSEMBLE
1699 int flush_metadata_updates(struct supertype *st)
1700 {
1701         int sfd;
1702         if (!st->updates) {
1703                 st->update_tail = NULL;
1704                 return -1;
1705         }
1706
1707         sfd = connect_monitor(devnum2devname(st->container_dev));
1708         if (sfd < 0)
1709                 return -1;
1710
1711         while (st->updates) {
1712                 struct metadata_update *mu = st->updates;
1713                 st->updates = mu->next;
1714
1715                 send_message(sfd, mu, 0);
1716                 wait_reply(sfd, 0);
1717                 free(mu->buf);
1718                 free(mu);
1719         }
1720         ack(sfd, 0);
1721         wait_reply(sfd, 0);
1722         close(sfd);
1723         st->update_tail = NULL;
1724         return 0;
1725 }
1726
1727 void append_metadata_update(struct supertype *st, void *buf, int len)
1728 {
1729
1730         struct metadata_update *mu = xmalloc(sizeof(*mu));
1731
1732         mu->buf = buf;
1733         mu->len = len;
1734         mu->space = NULL;
1735         mu->space_list = NULL;
1736         mu->next = NULL;
1737         *st->update_tail = mu;
1738         st->update_tail = &mu->next;
1739 }
1740 #endif /* MDASSEMBLE */
1741
1742 #ifdef __TINYC__
1743 /* tinyc doesn't optimize this check in ioctl.h out ... */
1744 unsigned int __invalid_size_argument_for_IOC = 0;
1745 #endif
1746
1747 int experimental(void)
1748 {
1749         if (check_env("MDADM_EXPERIMENTAL"))
1750                 return 1;
1751         else {
1752                 pr_err("To use this feature MDADM_EXPERIMENTAL"
1753                                 " environment variable has to be defined.\n");
1754                 return 0;
1755         }
1756 }
1757
1758 /* Pick all spares matching given criteria from a container
1759  * if min_size == 0 do not check size
1760  * if domlist == NULL do not check domains
1761  * if spare_group given add it to domains of each spare
1762  * metadata allows to test domains using metadata of destination array */
1763 struct mdinfo *container_choose_spares(struct supertype *st,
1764                                        unsigned long long min_size,
1765                                        struct domainlist *domlist,
1766                                        char *spare_group,
1767                                        const char *metadata, int get_one)
1768 {
1769         struct mdinfo *d, **dp, *disks = NULL;
1770
1771         /* get list of all disks in container */
1772         if (st->ss->getinfo_super_disks)
1773                 disks = st->ss->getinfo_super_disks(st);
1774
1775         if (!disks)
1776                 return disks;
1777         /* find spare devices on the list */
1778         dp = &disks->devs;
1779         disks->array.spare_disks = 0;
1780         while (*dp) {
1781                 int found = 0;
1782                 d = *dp;
1783                 if (d->disk.state == 0) {
1784                         /* check if size is acceptable */
1785                         unsigned long long dev_size;
1786                         dev_t dev = makedev(d->disk.major,d->disk.minor);
1787
1788                         if (!min_size ||
1789                            (dev_size_from_id(dev,  &dev_size) &&
1790                             dev_size >= min_size))
1791                                 found = 1;
1792                         /* check if domain matches */
1793                         if (found && domlist) {
1794                                 struct dev_policy *pol = devnum_policy(dev);
1795                                 if (spare_group)
1796                                         pol_add(&pol, pol_domain,
1797                                                 spare_group, NULL);
1798                                 if (domain_test(domlist, pol, metadata) != 1)
1799                                         found = 0;
1800                                 dev_policy_free(pol);
1801                         }
1802                 }
1803                 if (found) {
1804                         dp = &d->next;
1805                         disks->array.spare_disks++;
1806                         if (get_one) {
1807                                 sysfs_free(*dp);
1808                                 d->next = NULL;
1809                         }
1810                 } else {
1811                         *dp = d->next;
1812                         d->next = NULL;
1813                         sysfs_free(d);
1814                 }
1815         }
1816         return disks;
1817 }