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