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