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         if (bytes < 5000*1024)
 690                 snprintf(buf, sizeof(buf), "%ld.%02ldKiB",
 691                         (long)(bytes>>10), (long)(((bytes&1023)*100+512)/1024)
 692                         );
 693         else if (bytes < 2*1024LL*1024LL*1024LL)
 694                 snprintf(buf, sizeof(buf), "%ld.%02ldMiB",
 695                         (long)(bytes>>20),
 696                         (long)((bytes&0xfffff)+0x100000/200)/(0x100000/100)
 697                         );
 698         else
 699                 snprintf(buf, sizeof(buf), "%ld.%02ldGiB",
 700                         (long)(bytes>>30),
 701                         (long)(((bytes>>10)&0xfffff)+0x100000/200)/(0x100000/100)
 702                         );
 703         return buf;
 704 }
 705
 706 void print_r10_layout(int layout)
 707 {
 708         int near = layout & 255;
 709         int far = (layout >> 8) & 255;
 710         int offset = (layout&0x10000);
 711         char *sep = "";
 712
 713         if (near != 1) {
 714                 printf("%s near=%d", sep, near);
 715                 sep = ",";
 716         }
 717         if (far != 1)
 718                 printf("%s %s=%d", sep, offset?"offset":"far", far);
 719         if (near*far == 1)
 720                 printf("NO REDUNDANCY");
 721 }
 722 #endif
 723
 724 unsigned long long calc_array_size(int level, int raid_disks, int layout,
 725                                    int chunksize, unsigned long long devsize)
 726 {
 727         if (level == 1)
 728                 return devsize;
 729         devsize &= ~(unsigned long long)((chunksize>>9)-1);
 730         return get_data_disks(level, layout, raid_disks) * devsize;
 731 }
 732
 733 int get_data_disks(int level, int layout, int raid_disks)
 734 {
 735         int data_disks = 0;
 736         switch (level) {
 737         case 0: data_disks = raid_disks;
 738                 break;
 739         case 1: data_disks = 1;
 740                 break;
 741         case 4:
 742         case 5: data_disks = raid_disks - 1;
 743                 break;
 744         case 6: data_disks = raid_disks - 2;
 745                 break;
 746         case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255);
 747                 break;
 748         }
 749
 750         return data_disks;
 751 }
 752
 753 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 754 char *get_md_name(int dev)
 755 {
 756         /* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
 757         /* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
 758         static char devname[50];
 759         struct stat stb;
 760         dev_t rdev;
 761         char *dn;
 762
 763         if (dev < 0) {
 764                 int mdp =  get_mdp_major();
 765                 if (mdp < 0) return NULL;
 766                 rdev = makedev(mdp, (-1-dev)<<6);
 767                 snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev);
 768                 if (stat(devname, &stb) == 0
 769                     && (S_IFMT&stb.st_mode) == S_IFBLK
 770                     && (stb.st_rdev == rdev))
 771                         return devname;
 772         } else {
 773                 rdev = makedev(MD_MAJOR, dev);
 774                 snprintf(devname, sizeof(devname), "/dev/md%d", dev);
 775                 if (stat(devname, &stb) == 0
 776                     && (S_IFMT&stb.st_mode) == S_IFBLK
 777                     && (stb.st_rdev == rdev))
 778                         return devname;
 779
 780                 snprintf(devname, sizeof(devname), "/dev/md/%d", dev);
 781                 if (stat(devname, &stb) == 0
 782                     && (S_IFMT&stb.st_mode) == S_IFBLK
 783                     && (stb.st_rdev == rdev))
 784                         return devname;
 785         }
 786         dn = map_dev(major(rdev), minor(rdev), 0);
 787         if (dn)
 788                 return dn;
 789         snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev);
 790         if (mknod(devname, S_IFBLK | 0600, rdev) == -1)
 791                 if (errno != EEXIST)
 792                         return NULL;
 793
 794         if (stat(devname, &stb) == 0
 795             && (S_IFMT&stb.st_mode) == S_IFBLK
 796             && (stb.st_rdev == rdev))
 797                 return devname;
 798         unlink(devname);
 799         return NULL;
 800 }
 801
 802 void put_md_name(char *name)
 803 {
 804         if (strncmp(name, "/dev/.tmp.md", 12) == 0)
 805                 unlink(name);
 806 }
 807
 808 int find_free_devnum(int use_partitions)
 809 {
 810         int devnum;
 811         for (devnum = 127; devnum != 128;
 812              devnum = devnum ? devnum-1 : (1<<20)-1) {
 813                 char *dn;
 814                 int _devnum;
 815                 char nbuf[50];
 816
 817                 _devnum = use_partitions ? (-1-devnum) : devnum;
 818                 if (mddev_busy(_devnum))
 819                         continue;
 820                 sprintf(nbuf, "%s%d", use_partitions?"mdp":"md", devnum);
 821                 if (!conf_name_is_free(nbuf))
 822                         continue;
 823                 /* make sure it is new to /dev too, at least as a
 824                  * non-standard */
 825                 dn = map_dev(dev2major(_devnum), dev2minor(_devnum), 0);
 826                 if (dn && ! is_standard(dn, NULL))
 827                         continue;
 828                 break;
 829         }
 830         if (devnum == 128)
 831                 return NoMdDev;
 832         return use_partitions ? (-1-devnum) : devnum;
 833 }
 834 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
 835
 836 int dev_open(char *dev, int flags)
 837 {
 838         /* like 'open', but if 'dev' matches %d:%d, create a temp
 839          * block device and open that
 840          */
 841         char *e;
 842         int fd = -1;
 843         char devname[32];
 844         int major;
 845         int minor;
 846
 847         if (!dev) return -1;
 848         flags |= O_DIRECT;
 849
 850         major = strtoul(dev, &e, 0);
 851         if (e > dev && *e == ':' && e[1] &&
 852             (minor = strtoul(e+1, &e, 0)) >= 0 &&
 853             *e == 0) {
 854                 char *path = map_dev(major, minor, 0);
 855                 if (path)
 856                         fd = open(path, flags);
 857                 if (fd < 0) {
 858                         snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d",
 859                                  (int)getpid(), major, minor);
 860                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
 861                                 fd = open(devname, flags);
 862                                 unlink(devname);
 863                         }
 864                 }
 865                 if (fd < 0) {
 866                         snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d",
 867                                  (int)getpid(), major, minor);
 868                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
 869                                 fd = open(devname, flags);
 870                                 unlink(devname);
 871                         }
 872                 }
 873         } else
 874                 fd = open(dev, flags);
 875         return fd;
 876 }
 877
 878 int open_dev_flags(int devnum, int flags)
 879 {
 880         char buf[20];
 881
 882         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
 883         return dev_open(buf, flags);
 884 }
 885
 886 int open_dev(int devnum)
 887 {
 888         return open_dev_flags(devnum, O_RDONLY);
 889 }
 890
 891 int open_dev_excl(int devnum)
 892 {
 893         char buf[20];
 894         int i;
 895         int flags = O_RDWR;
 896
 897         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
 898         for (i = 0 ; i < 25 ; i++) {
 899                 int fd = dev_open(buf, flags|O_EXCL);
 900                 if (fd >= 0)
 901                         return fd;
 902                 if (errno == EACCES && flags == O_RDWR) {
 903                         flags = O_RDONLY;
 904                         continue;
 905                 }
 906                 if (errno != EBUSY)
 907                         return fd;
 908                 usleep(200000);
 909         }
 910         return -1;
 911 }
 912
 913 int same_dev(char *one, char *two)
 914 {
 915         struct stat st1, st2;
 916         if (stat(one, &st1) != 0)
 917                 return 0;
 918         if (stat(two, &st2) != 0)
 919                 return 0;
 920         if ((st1.st_mode & S_IFMT) != S_IFBLK)
 921                 return 0;
 922         if ((st2.st_mode & S_IFMT) != S_IFBLK)
 923                 return 0;
 924         return st1.st_rdev == st2.st_rdev;
 925 }
 926
 927 void wait_for(char *dev, int fd)
 928 {
 929         int i;
 930         struct stat stb_want;
 931
 932         if (fstat(fd, &stb_want) != 0 ||
 933             (stb_want.st_mode & S_IFMT) != S_IFBLK)
 934                 return;
 935
 936         for (i = 0 ; i < 25 ; i++) {
 937                 struct stat stb;
 938                 if (stat(dev, &stb) == 0 &&
 939                     (stb.st_mode & S_IFMT) == S_IFBLK &&
 940                     (stb.st_rdev == stb_want.st_rdev))
 941                         return;
 942                 usleep(200000);
 943         }
 944         if (i == 25)
 945                 dprintf("%s: timeout waiting for %s\n", __func__, dev);
 946 }
 947
 948 struct superswitch *superlist[] =
 949 {
 950         &super0, &super1,
 951         &super_ddf, &super_imsm,
 952         &mbr, &gpt,
 953         NULL };
 954
 955 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 956
 957 struct supertype *super_by_fd(int fd, char **subarrayp)
 958 {
 959         mdu_array_info_t array;
 960         int vers;
 961         int minor;
 962         struct supertype *st = NULL;
 963         struct mdinfo *sra;
 964         char *verstr;
 965         char version[20];
 966         int i;
 967         char *subarray = NULL;
 968         int container = NoMdDev;
 969
 970         sra = sysfs_read(fd, 0, GET_VERSION);
 971
 972         if (sra) {
 973                 vers = sra->array.major_version;
 974                 minor = sra->array.minor_version;
 975                 verstr = sra->text_version;
 976         } else {
 977                 if (ioctl(fd, GET_ARRAY_INFO, &array))
 978                         array.major_version = array.minor_version = 0;
 979                 vers = array.major_version;
 980                 minor = array.minor_version;
 981                 verstr = "";
 982         }
 983
 984         if (vers != -1) {
 985                 sprintf(version, "%d.%d", vers, minor);
 986                 verstr = version;
 987         }
 988         if (minor == -2 && is_subarray(verstr)) {
 989                 char *dev = verstr+1;
 990
 991                 subarray = strchr(dev, '/');
 992                 if (subarray) {
 993                         *subarray++ = '\0';
 994                         subarray = xstrdup(subarray);
 995                 }
 996                 container = devname2devnum(dev);
 997                 if (sra)
 998                         sysfs_free(sra);
 999                 sra = sysfs_read(-1, container, GET_VERSION);
1000                 if (sra && sra->text_version[0])
1001                         verstr = sra->text_version;
1002                 else
1003                         verstr = "-no-metadata-";
1004         }
1005
1006         for (i = 0; st == NULL && superlist[i] ; i++)
1007                 st = superlist[i]->match_metadata_desc(verstr);
1008
1009         if (sra)
1010                 sysfs_free(sra);
1011         if (st) {
1012                 st->sb = NULL;
1013                 if (subarrayp)
1014                         *subarrayp = subarray;
1015                 st->container_dev = container;
1016                 st->devnum = fd2devnum(fd);
1017         } else
1018                 free(subarray);
1019
1020         return st;
1021 }
1022 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
1023
1024 int dev_size_from_id(dev_t id, unsigned long long *size)
1025 {
1026         char buf[20];
1027         int fd;
1028
1029         sprintf(buf, "%d:%d", major(id), minor(id));
1030         fd = dev_open(buf, O_RDONLY);
1031         if (fd < 0)
1032                 return 0;
1033         if (get_dev_size(fd, NULL, size)) {
1034                 close(fd);
1035                 return 1;
1036         }
1037         close(fd);
1038         return 0;
1039 }
1040
1041 struct supertype *dup_super(struct supertype *orig)
1042 {
1043         struct supertype *st;
1044
1045         if (!orig)
1046                 return orig;
1047         st = xcalloc(1, sizeof(*st));
1048         st->ss = orig->ss;
1049         st->max_devs = orig->max_devs;
1050         st->minor_version = orig->minor_version;
1051         st->sb = NULL;
1052         st->info = NULL;
1053         return st;
1054 }
1055
1056 struct supertype *guess_super_type(int fd, enum guess_types guess_type)
1057 {
1058         /* try each load_super to find the best match,
1059          * and return the best superswitch
1060          */
1061         struct superswitch  *ss;
1062         struct supertype *st;
1063         time_t besttime = 0;
1064         int bestsuper = -1;
1065         int i;
1066
1067         st = xcalloc(1, sizeof(*st));
1068         st->container_dev = NoMdDev;
1069
1070         for (i = 0 ; superlist[i]; i++) {
1071                 int rv;
1072                 ss = superlist[i];
1073                 if (guess_type == guess_array && ss->add_to_super == NULL)
1074                         continue;
1075                 if (guess_type == guess_partitions && ss->add_to_super != NULL)
1076                         continue;
1077                 memset(st, 0, sizeof(*st));
1078                 st->ignore_hw_compat = 1;
1079                 rv = ss->load_super(st, fd, NULL);
1080                 if (rv == 0) {
1081                         struct mdinfo info;
1082                         st->ss->getinfo_super(st, &info, NULL);
1083                         if (bestsuper == -1 ||
1084                             besttime < info.array.ctime) {
1085                                 bestsuper = i;
1086                                 besttime = info.array.ctime;
1087                         }
1088                         ss->free_super(st);
1089                 }
1090         }
1091         if (bestsuper != -1) {
1092                 int rv;
1093                 memset(st, 0, sizeof(*st));
1094                 st->ignore_hw_compat = 1;
1095                 rv = superlist[bestsuper]->load_super(st, fd, NULL);
1096                 if (rv == 0) {
1097                         superlist[bestsuper]->free_super(st);
1098                         st->ignore_hw_compat = 0;
1099                         return st;
1100                 }
1101         }
1102         free(st);
1103         return NULL;
1104 }
1105
1106 /* Return size of device in bytes */
1107 int get_dev_size(int fd, char *dname, unsigned long long *sizep)
1108 {
1109         unsigned long long ldsize;
1110         struct stat st;
1111
1112         if (fstat(fd, &st) != -1 && S_ISREG(st.st_mode))
1113                 ldsize = (unsigned long long)st.st_size;
1114         else
1115 #ifdef BLKGETSIZE64
1116         if (ioctl(fd, BLKGETSIZE64, &ldsize) != 0)
1117 #endif
1118         {
1119                 unsigned long dsize;
1120                 if (ioctl(fd, BLKGETSIZE, &dsize) == 0) {
1121                         ldsize = dsize;
1122                         ldsize <<= 9;
1123                 } else {
1124                         if (dname)
1125                                 pr_err("Cannot get size of %s: %s\b",
1126                                         dname, strerror(errno));
1127                         return 0;
1128                 }
1129         }
1130         *sizep = ldsize;
1131         return 1;
1132 }
1133
1134 /* Return true if this can only be a container, not a member device.
1135  * i.e. is and md device and size is zero
1136  */
1137 int must_be_container(int fd)
1138 {
1139         unsigned long long size;
1140         if (md_get_version(fd) < 0)
1141                 return 0;
1142         if (get_dev_size(fd, NULL, &size) == 0)
1143                 return 1;
1144         if (size == 0)
1145                 return 1;
1146         return 0;
1147 }
1148
1149 /* Sets endofpart parameter to the last block used by the last GPT partition on the device.
1150  * Returns: 1 if successful
1151  *         -1 for unknown partition type
1152  *          0 for other errors
1153  */
1154 static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
1155 {
1156         struct GPT gpt;
1157         unsigned char empty_gpt_entry[16]= {0};
1158         struct GPT_part_entry *part;
1159         char buf[512];
1160         unsigned long long curr_part_end;
1161         unsigned all_partitions, entry_size;
1162         unsigned part_nr;
1163
1164         *endofpart = 0;
1165
1166         BUILD_BUG_ON(sizeof(gpt) != 512);
1167         /* skip protective MBR */
1168         lseek(fd, 512, SEEK_SET);
1169         /* read GPT header */
1170         if (read(fd, &gpt, 512) != 512)
1171                 return 0;
1172
1173         /* get the number of partition entries and the entry size */
1174         all_partitions = __le32_to_cpu(gpt.part_cnt);
1175         entry_size = __le32_to_cpu(gpt.part_size);
1176
1177         /* Check GPT signature*/
1178         if (gpt.magic != GPT_SIGNATURE_MAGIC)
1179                 return -1;
1180
1181         /* sanity checks */
1182         if (all_partitions > 1024 ||
1183             entry_size > sizeof(buf))
1184                 return -1;
1185
1186         part = (struct GPT_part_entry *)buf;
1187
1188         for (part_nr = 0; part_nr < all_partitions; part_nr++) {
1189                 /* read partition entry */
1190                 if (read(fd, buf, entry_size) != (ssize_t)entry_size)
1191                         return 0;
1192
1193                 /* is this valid partition? */
1194                 if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
1195                         /* check the last lba for the current partition */
1196                         curr_part_end = __le64_to_cpu(part->ending_lba);
1197                         if (curr_part_end > *endofpart)
1198                                 *endofpart = curr_part_end;
1199                 }
1200
1201         }
1202         return 1;
1203 }
1204
1205 /* Sets endofpart parameter to the last block used by the last partition on the device.
1206  * Returns: 1 if successful
1207  *         -1 for unknown partition type
1208  *          0 for other errors
1209  */
1210 static int get_last_partition_end(int fd, unsigned long long *endofpart)
1211 {
1212         struct MBR boot_sect;
1213         struct MBR_part_record *part;
1214         unsigned long long curr_part_end;
1215         unsigned part_nr;
1216         int retval = 0;
1217
1218         *endofpart = 0;
1219
1220         BUILD_BUG_ON(sizeof(boot_sect) != 512);
1221         /* read MBR */
1222         lseek(fd, 0, 0);
1223         if (read(fd, &boot_sect, 512) != 512)
1224                 goto abort;
1225
1226         /* check MBP signature */
1227         if (boot_sect.magic == MBR_SIGNATURE_MAGIC) {
1228                 retval = 1;
1229                 /* found the correct signature */
1230                 part = boot_sect.parts;
1231
1232                 for (part_nr = 0; part_nr < MBR_PARTITIONS; part_nr++) {
1233                         /* check for GPT type */
1234                         if (part->part_type == MBR_GPT_PARTITION_TYPE) {
1235                                 retval = get_gpt_last_partition_end(fd, endofpart);
1236                                 break;
1237                         }
1238                         /* check the last used lba for the current partition  */
1239                         curr_part_end = __le32_to_cpu(part->first_sect_lba) +
1240                                 __le32_to_cpu(part->blocks_num);
1241                         if (curr_part_end > *endofpart)
1242                                 *endofpart = curr_part_end;
1243
1244                         part++;
1245                 }
1246         } else {
1247                 /* Unknown partition table */
1248                 retval = -1;
1249         }
1250  abort:
1251         return retval;
1252 }
1253
1254 int check_partitions(int fd, char *dname, unsigned long long freesize,
1255                         unsigned long long size)
1256 {
1257         /*
1258          * Check where the last partition ends
1259          */
1260         unsigned long long endofpart;
1261         int ret;
1262
1263         if ((ret = get_last_partition_end(fd, &endofpart)) > 0) {
1264                 /* There appears to be a partition table here */
1265                 if (freesize == 0) {
1266                         /* partitions will not be visible in new device */
1267                         pr_err("partition table exists on %s but will be lost or\n"
1268                                "       meaningless after creating array\n",
1269                                dname);
1270                         return 1;
1271                 } else if (endofpart > freesize) {
1272                         /* last partition overlaps metadata */
1273                         pr_err("metadata will over-write last partition on %s.\n",
1274                                dname);
1275                         return 1;
1276                 } else if (size && endofpart > size) {
1277                         /* partitions will be truncated in new device */
1278                         pr_err("array size is too small to cover all partitions on %s.\n",
1279                                dname);
1280                         return 1;
1281                 }
1282         }
1283         return 0;
1284 }
1285
1286 void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk)
1287 {
1288         int d;
1289
1290         ioctl(mdfd, GET_ARRAY_INFO, ainf);
1291         for (d = 0 ; d < MAX_DISKS ; d++) {
1292                 if (ioctl(mdfd, GET_DISK_INFO, disk) == 0 &&
1293                     (disk->major || disk->minor))
1294                         return;
1295         }
1296 }
1297
1298 int open_container(int fd)
1299 {
1300         /* 'fd' is a block device.  Find out if it is in use
1301          * by a container, and return an open fd on that container.
1302          */
1303         char path[256];
1304         char *e;
1305         DIR *dir;
1306         struct dirent *de;
1307         int dfd, n;
1308         char buf[200];
1309         int major, minor;
1310         struct stat st;
1311
1312         if (fstat(fd, &st) != 0)
1313                 return -1;
1314         sprintf(path, "/sys/dev/block/%d:%d/holders",
1315                 (int)major(st.st_rdev), (int)minor(st.st_rdev));
1316         e = path + strlen(path);
1317
1318         dir = opendir(path);
1319         if (!dir)
1320                 return -1;
1321         while ((de = readdir(dir))) {
1322                 if (de->d_ino == 0)
1323                         continue;
1324                 if (de->d_name[0] == '.')
1325                         continue;
1326                 sprintf(e, "/%s/dev", de->d_name);
1327                 dfd = open(path, O_RDONLY);
1328                 if (dfd < 0)
1329                         continue;
1330                 n = read(dfd, buf, sizeof(buf));
1331                 close(dfd);
1332                 if (n <= 0 || (unsigned)n >= sizeof(buf))
1333                         continue;
1334                 buf[n] = 0;
1335                 if (sscanf(buf, "%d:%d", &major, &minor) != 2)
1336                         continue;
1337                 sprintf(buf, "%d:%d", major, minor);
1338                 dfd = dev_open(buf, O_RDONLY);
1339                 if (dfd >= 0) {
1340                         closedir(dir);
1341                         return dfd;
1342                 }
1343         }
1344         closedir(dir);
1345         return -1;
1346 }
1347
1348 struct superswitch *version_to_superswitch(char *vers)
1349 {
1350         int i;
1351
1352         for (i = 0; superlist[i]; i++) {
1353                 struct superswitch *ss = superlist[i];
1354
1355                 if (strcmp(vers, ss->name) == 0)
1356                         return ss;
1357         }
1358
1359         return NULL;
1360 }
1361
1362 int is_container_member(struct mdstat_ent *mdstat, char *container)
1363 {
1364         if (mdstat->metadata_version == NULL ||
1365             strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
1366             !is_subarray(mdstat->metadata_version+9) ||
1367             strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 ||
1368             mdstat->metadata_version[10+strlen(container)] != '/')
1369                 return 0;
1370
1371         return 1;
1372 }
1373
1374 int is_subarray_active(char *subarray, char *container)
1375 {
1376         struct mdstat_ent *mdstat = mdstat_read(0, 0);
1377         struct mdstat_ent *ent;
1378
1379         for (ent = mdstat; ent; ent = ent->next)
1380                 if (is_container_member(ent, container))
1381                         if (strcmp(to_subarray(ent, container), subarray) == 0)
1382                                 break;
1383
1384         free_mdstat(mdstat);
1385
1386         return ent != NULL;
1387 }
1388
1389 /* open_subarray - opens a subarray in a container
1390  * @dev: container device name
1391  * @st: empty supertype
1392  * @quiet: block reporting errors flag
1393  *
1394  * On success returns an fd to a container and fills in *st
1395  */
1396 int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet)
1397 {
1398         struct mdinfo *mdi;
1399         struct mdinfo *info;
1400         int fd, err = 1;
1401
1402         fd = open(dev, O_RDWR|O_EXCL);
1403         if (fd < 0) {
1404                 if (!quiet)
1405                         pr_err("Couldn't open %s, aborting\n",
1406                                 dev);
1407                 return -1;
1408         }
1409
1410         st->devnum = fd2devnum(fd);
1411         if (st->devnum == NoMdDev) {
1412                 if (!quiet)
1413                         pr_err("Failed to determine device number for %s\n",
1414                                dev);
1415                 goto close_fd;
1416         }
1417
1418         mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
1419         if (!mdi) {
1420                 if (!quiet)
1421                         pr_err("Failed to read sysfs for %s\n",
1422                                 dev);
1423                 goto close_fd;
1424         }
1425
1426         if (mdi->array.level != UnSet) {
1427                 if (!quiet)
1428                         pr_err("%s is not a container\n", dev);
1429                 goto free_sysfs;
1430         }
1431
1432         st->ss = version_to_superswitch(mdi->text_version);
1433         if (!st->ss) {
1434                 if (!quiet)
1435                         pr_err("Operation not supported for %s metadata\n",
1436                                mdi->text_version);
1437                 goto free_sysfs;
1438         }
1439
1440         st->devname = devnum2devname(st->devnum);
1441         if (!st->devname) {
1442                 if (!quiet)
1443                         pr_err("Failed to allocate device name\n");
1444                 goto free_sysfs;
1445         }
1446
1447         if (!st->ss->load_container) {
1448                 if (!quiet)
1449                         pr_err("%s is not a container\n", dev);
1450                 goto free_name;
1451         }
1452
1453         if (st->ss->load_container(st, fd, NULL)) {
1454                 if (!quiet)
1455                         pr_err("Failed to load metadata for %s\n",
1456                                 dev);
1457                 goto free_name;
1458         }
1459
1460         info = st->ss->container_content(st, subarray);
1461         if (!info) {
1462                 if (!quiet)
1463                         pr_err("Failed to find subarray-%s in %s\n",
1464                                 subarray, dev);
1465                 goto free_super;
1466         }
1467         free(info);
1468
1469         err = 0;
1470
1471  free_super:
1472         if (err)
1473                 st->ss->free_super(st);
1474  free_name:
1475         if (err)
1476                 free(st->devname);
1477  free_sysfs:
1478         sysfs_free(mdi);
1479  close_fd:
1480         if (err)
1481                 close(fd);
1482
1483         if (err)
1484                 return -1;
1485         else
1486                 return fd;
1487 }
1488
1489 int add_disk(int mdfd, struct supertype *st,
1490              struct mdinfo *sra, struct mdinfo *info)
1491 {
1492         /* Add a device to an array, in one of 2 ways. */
1493         int rv;
1494 #ifndef MDASSEMBLE
1495         if (st->ss->external) {
1496                 if (info->disk.state & (1<<MD_DISK_SYNC))
1497                         info->recovery_start = MaxSector;
1498                 else
1499                         info->recovery_start = 0;
1500                 rv = sysfs_add_disk(sra, info, 0);
1501                 if (! rv) {
1502                         struct mdinfo *sd2;
1503                         for (sd2 = sra->devs; sd2; sd2=sd2->next)
1504                                 if (sd2 == info)
1505                                         break;
1506                         if (sd2 == NULL) {
1507                                 sd2 = xmalloc(sizeof(*sd2));
1508                                 *sd2 = *info;
1509                                 sd2->next = sra->devs;
1510                                 sra->devs = sd2;
1511                         }
1512                 }
1513         } else
1514 #endif
1515                 rv = ioctl(mdfd, ADD_NEW_DISK, &info->disk);
1516         return rv;
1517 }
1518
1519 int remove_disk(int mdfd, struct supertype *st,
1520                 struct mdinfo *sra, struct mdinfo *info)
1521 {
1522         int rv;
1523         /* Remove the disk given by 'info' from the array */
1524 #ifndef MDASSEMBLE
1525         if (st->ss->external)
1526                 rv = sysfs_set_str(sra, info, "slot", "none");
1527         else
1528 #endif
1529                 rv = ioctl(mdfd, HOT_REMOVE_DISK, makedev(info->disk.major,
1530                                                           info->disk.minor));
1531         return rv;
1532 }
1533
1534 int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info)
1535 {
1536         /* Initialise kernel's knowledge of array.
1537          * This varies between externally managed arrays
1538          * and older kernels
1539          */
1540         int vers = md_get_version(mdfd);
1541         int rv;
1542
1543 #ifndef MDASSEMBLE
1544         if (st->ss->external)
1545                 rv = sysfs_set_array(info, vers);
1546         else
1547 #endif
1548                 if ((vers % 100) >= 1) { /* can use different versions */
1549                 mdu_array_info_t inf;
1550                 memset(&inf, 0, sizeof(inf));
1551                 inf.major_version = info->array.major_version;
1552                 inf.minor_version = info->array.minor_version;
1553                 rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
1554         } else
1555                 rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
1556         return rv;
1557 }
1558
1559 unsigned long long min_recovery_start(struct mdinfo *array)
1560 {
1561         /* find the minimum recovery_start in an array for metadata
1562          * formats that only record per-array recovery progress instead
1563          * of per-device
1564          */
1565         unsigned long long recovery_start = MaxSector;
1566         struct mdinfo *d;
1567
1568         for (d = array->devs; d; d = d->next)
1569                 recovery_start = min(recovery_start, d->recovery_start);
1570
1571         return recovery_start;
1572 }
1573
1574 int mdmon_pid(int devnum)
1575 {
1576         char path[100];
1577         char pid[10];
1578         int fd;
1579         int n;
1580         char *devname = devnum2devname(devnum);
1581
1582         sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
1583         free(devname);
1584
1585         fd = open(path, O_RDONLY | O_NOATIME, 0);
1586
1587         if (fd < 0)
1588                 return -1;
1589         n = read(fd, pid, 9);
1590         close(fd);
1591         if (n <= 0)
1592                 return -1;
1593         return atoi(pid);
1594 }
1595
1596 int mdmon_running(int devnum)
1597 {
1598         int pid = mdmon_pid(devnum);
1599         if (pid <= 0)
1600                 return 0;
1601         if (kill(pid, 0) == 0)
1602                 return 1;
1603         return 0;
1604 }
1605
1606 int start_mdmon(int devnum)
1607 {
1608         int i, skipped;
1609         int len;
1610         pid_t pid;
1611         int status;
1612         char pathbuf[1024];
1613         char *paths[4] = {
1614                 pathbuf,
1615                 "/sbin/mdmon",
1616                 "mdmon",
1617                 NULL
1618         };
1619
1620         if (check_env("MDADM_NO_MDMON"))
1621                 return 0;
1622
1623         len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf)-1);
1624         if (len > 0) {
1625                 char *sl;
1626                 pathbuf[len] = 0;
1627                 sl = strrchr(pathbuf, '/');
1628                 if (sl)
1629                         sl++;
1630                 else
1631                         sl = pathbuf;
1632                 strcpy(sl, "mdmon");
1633         } else
1634                 pathbuf[0] = '\0';
1635
1636         switch(fork()) {
1637         case 0:
1638                 /* FIXME yuk. CLOSE_EXEC?? */
1639                 skipped = 0;
1640                 for (i = 3; skipped < 20; i++)
1641                         if (close(i) < 0)
1642                                 skipped++;
1643                         else
1644                                 skipped = 0;
1645
1646                 for (i = 0; paths[i]; i++)
1647                         if (paths[i][0]) {
1648                                 if (__offroot) {
1649                                         execl(paths[i], "mdmon", "--offroot",
1650                                               devnum2devname(devnum),
1651                                               NULL);
1652                                 } else {
1653                                         execl(paths[i], "mdmon",
1654                                               devnum2devname(devnum),
1655                                               NULL);
1656                                 }
1657                         }
1658                 exit(1);
1659         case -1: pr_err("cannot run mdmon. "
1660                          "Array remains readonly\n");
1661                 return -1;
1662         default: /* parent - good */
1663                 pid = wait(&status);
1664                 if (pid < 0 || status != 0)
1665                         return -1;
1666         }
1667         return 0;
1668 }
1669
1670 int check_env(char *name)
1671 {
1672         char *val = getenv(name);
1673
1674         if (val && atoi(val) == 1)
1675                 return 1;
1676
1677         return 0;
1678 }
1679
1680 __u32 random32(void)
1681 {
1682         __u32 rv;
1683         int rfd = open("/dev/urandom", O_RDONLY);
1684         if (rfd < 0 || read(rfd, &rv, 4) != 4)
1685                 rv = random();
1686         if (rfd >= 0)
1687                 close(rfd);
1688         return rv;
1689 }
1690
1691 #ifndef MDASSEMBLE
1692 int flush_metadata_updates(struct supertype *st)
1693 {
1694         int sfd;
1695         if (!st->updates) {
1696                 st->update_tail = NULL;
1697                 return -1;
1698         }
1699
1700         sfd = connect_monitor(devnum2devname(st->container_dev));
1701         if (sfd < 0)
1702                 return -1;
1703
1704         while (st->updates) {
1705                 struct metadata_update *mu = st->updates;
1706                 st->updates = mu->next;
1707
1708                 send_message(sfd, mu, 0);
1709                 wait_reply(sfd, 0);
1710                 free(mu->buf);
1711                 free(mu);
1712         }
1713         ack(sfd, 0);
1714         wait_reply(sfd, 0);
1715         close(sfd);
1716         st->update_tail = NULL;
1717         return 0;
1718 }
1719
1720 void append_metadata_update(struct supertype *st, void *buf, int len)
1721 {
1722
1723         struct metadata_update *mu = xmalloc(sizeof(*mu));
1724
1725         mu->buf = buf;
1726         mu->len = len;
1727         mu->space = NULL;
1728         mu->space_list = NULL;
1729         mu->next = NULL;
1730         *st->update_tail = mu;
1731         st->update_tail = &mu->next;
1732 }
1733 #endif /* MDASSEMBLE */
1734
1735 #ifdef __TINYC__
1736 /* tinyc doesn't optimize this check in ioctl.h out ... */
1737 unsigned int __invalid_size_argument_for_IOC = 0;
1738 #endif
1739
1740 int experimental(void)
1741 {
1742         if (check_env("MDADM_EXPERIMENTAL"))
1743                 return 1;
1744         else {
1745                 pr_err("To use this feature MDADM_EXPERIMENTAL"
1746                                 " environment variable has to be defined.\n");
1747                 return 0;
1748         }
1749 }
1750
1751 /* Pick all spares matching given criteria from a container
1752  * if min_size == 0 do not check size
1753  * if domlist == NULL do not check domains
1754  * if spare_group given add it to domains of each spare
1755  * metadata allows to test domains using metadata of destination array */
1756 struct mdinfo *container_choose_spares(struct supertype *st,
1757                                        unsigned long long min_size,
1758                                        struct domainlist *domlist,
1759                                        char *spare_group,
1760                                        const char *metadata, int get_one)
1761 {
1762         struct mdinfo *d, **dp, *disks = NULL;
1763
1764         /* get list of all disks in container */
1765         if (st->ss->getinfo_super_disks)
1766                 disks = st->ss->getinfo_super_disks(st);
1767
1768         if (!disks)
1769                 return disks;
1770         /* find spare devices on the list */
1771         dp = &disks->devs;
1772         disks->array.spare_disks = 0;
1773         while (*dp) {
1774                 int found = 0;
1775                 d = *dp;
1776                 if (d->disk.state == 0) {
1777                         /* check if size is acceptable */
1778                         unsigned long long dev_size;
1779                         dev_t dev = makedev(d->disk.major,d->disk.minor);
1780
1781                         if (!min_size ||
1782                            (dev_size_from_id(dev,  &dev_size) &&
1783                             dev_size >= min_size))
1784                                 found = 1;
1785                         /* check if domain matches */
1786                         if (found && domlist) {
1787                                 struct dev_policy *pol = devnum_policy(dev);
1788                                 if (spare_group)
1789                                         pol_add(&pol, pol_domain,
1790                                                 spare_group, NULL);
1791                                 if (domain_test(domlist, pol, metadata) != 1)
1792                                         found = 0;
1793                                 dev_policy_free(pol);
1794                         }
1795                 }
1796                 if (found) {
1797                         dp = &d->next;
1798                         disks->array.spare_disks++;
1799                         if (get_one) {
1800                                 sysfs_free(*dp);
1801                                 d->next = NULL;
1802                         }
1803                 } else {
1804                         *dp = d->next;
1805                         d->next = NULL;
1806                         sysfs_free(d);
1807                 }
1808         }
1809         return disks;
1810 }