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