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