util.c

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