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