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 #ifndef MDASSEMBLE
 164 int mdadm_version(char *version)
 165 {
 166         int a, b, c;
 167         char *cp;
 168
 169         if (!version)
 170                 version = Version;
 171
 172         cp = strchr(version, '-');
 173         if (!cp || *(cp+1) != ' ' || *(cp+2) != 'v')
 174                 return -1;
 175         cp += 3;
 176         a = strtoul(cp, &cp, 10);
 177         if (*cp != '.')
 178                 return -1;
 179         b = strtoul(cp+1, &cp, 10);
 180         if (*cp == '.')
 181                 c = strtoul(cp+1, &cp, 10);
 182         else
 183                 c = 0;
 184         if (*cp != ' ' && *cp != '-')
 185                 return -1;
 186         return (a*1000000)+(b*1000)+c;
 187 }
 188
 189 long long parse_size(char *size)
 190 {
 191         /* parse 'size' which should be a number optionally
 192          * followed by 'K', 'M', or 'G'.
 193          * Without a suffix, K is assumed.
 194          * Number returned is in sectors (half-K)
 195          */
 196         char *c;
 197         long long s = strtoll(size, &c, 10);
 198         if (s > 0) {
 199                 switch (*c) {
 200                 case 'K':
 201                         c++;
 202                 default:
 203                         s *= 2;
 204                         break;
 205                 case 'M':
 206                         c++;
 207                         s *= 1024 * 2;
 208                         break;
 209                 case 'G':
 210                         c++;
 211                         s *= 1024 * 1024 * 2;
 212                         break;
 213                 }
 214         }
 215         if (*c)
 216                 s = 0;
 217         return s;
 218 }
 219
 220 int parse_layout_10(char *layout)
 221 {
 222         int copies, rv;
 223         char *cp;
 224         /* Parse the layout string for raid10 */
 225         /* 'f', 'o' or 'n' followed by a number <= raid_disks */
 226         if ((layout[0] !=  'n' && layout[0] != 'f' && layout[0] != 'o') ||
 227             (copies = strtoul(layout+1, &cp, 10)) < 1 ||
 228             copies > 200 ||
 229             *cp)
 230                 return -1;
 231         if (layout[0] == 'n')
 232                 rv = 256 + copies;
 233         else if (layout[0] == 'o')
 234                 rv = 0x10000 + (copies<<8) + 1;
 235         else
 236                 rv = 1 + (copies<<8);
 237         return rv;
 238 }
 239
 240 int parse_layout_faulty(char *layout)
 241 {
 242         /* Parse the layout string for 'faulty' */
 243         int ln = strcspn(layout, "0123456789");
 244         char *m = strdup(layout);
 245         int mode;
 246         m[ln] = 0;
 247         mode = map_name(faultylayout, m);
 248         if (mode == UnSet)
 249                 return -1;
 250
 251         return mode | (atoi(layout+ln)<< ModeShift);
 252 }
 253 #endif
 254
 255 void remove_partitions(int fd)
 256 {
 257         /* remove partitions from this block devices.
 258          * This is used for components added to an array
 259          */
 260 #ifdef BLKPG_DEL_PARTITION
 261         struct blkpg_ioctl_arg a;
 262         struct blkpg_partition p;
 263
 264         a.op = BLKPG_DEL_PARTITION;
 265         a.data = (void*)&p;
 266         a.datalen = sizeof(p);
 267         a.flags = 0;
 268         memset(a.data, 0, a.datalen);
 269         for (p.pno=0; p.pno < 16; p.pno++)
 270                 ioctl(fd, BLKPG, &a);
 271 #endif
 272 }
 273
 274 int test_partition(int fd)
 275 {
 276         /* Check if fd is a whole-disk or a partition.
 277          * BLKPG will return EINVAL on a partition, and BLKPG_DEL_PARTITION
 278          * will return ENXIO on an invalid partition number.
 279          */
 280         struct blkpg_ioctl_arg a;
 281         struct blkpg_partition p;
 282         a.op = BLKPG_DEL_PARTITION;
 283         a.data = (void*)&p;
 284         a.datalen = sizeof(p);
 285         a.flags = 0;
 286         memset(a.data, 0, a.datalen);
 287         p.pno = 1<<30;
 288         if (ioctl(fd, BLKPG, &a) == 0)
 289                 /* Very unlikely, but not a partition */
 290                 return 0;
 291         if (errno == ENXIO)
 292                 /* not a partition */
 293                 return 0;
 294
 295         return 1;
 296 }
 297
 298 int test_partition_from_id(dev_t id)
 299 {
 300         char buf[20];
 301         int fd, rv;
 302
 303         sprintf(buf, "%d:%d", major(id), minor(id));
 304         fd = dev_open(buf, O_RDONLY);
 305         if (fd < 0)
 306                 return -1;
 307         rv = test_partition(fd);
 308         close(fd);
 309         return rv;
 310 }
 311
 312 int enough(int level, int raid_disks, int layout, int clean,
 313            char *avail, int avail_disks)
 314 {
 315         int copies, first;
 316         switch (level) {
 317         case 10:
 318                 /* This is the tricky one - we need to check
 319                  * which actual disks are present.
 320                  */
 321                 copies = (layout&255)* ((layout>>8) & 255);
 322                 first=0;
 323                 do {
 324                         /* there must be one of the 'copies' form 'first' */
 325                         int n = copies;
 326                         int cnt=0;
 327                         while (n--) {
 328                                 if (avail[first])
 329                                         cnt++;
 330                                 first = (first+1) % raid_disks;
 331                         }
 332                         if (cnt == 0)
 333                                 return 0;
 334
 335                 } while (first != 0);
 336                 return 1;
 337
 338         case LEVEL_MULTIPATH:
 339                 return avail_disks>= 1;
 340         case LEVEL_LINEAR:
 341         case 0:
 342                 return avail_disks == raid_disks;
 343         case 1:
 344                 return avail_disks >= 1;
 345         case 4:
 346         case 5:
 347                 if (clean)
 348                         return avail_disks >= raid_disks-1;
 349                 else
 350                         return avail_disks >= raid_disks;
 351         case 6:
 352                 if (clean)
 353                         return avail_disks >= raid_disks-2;
 354                 else
 355                         return avail_disks >= raid_disks;
 356         default:
 357                 return 0;
 358         }
 359 }
 360
 361 int enough_fd(int fd)
 362 {
 363         struct mdu_array_info_s array;
 364         struct mdu_disk_info_s disk;
 365         int avail_disks = 0;
 366         int i;
 367         char *avail;
 368
 369         if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 ||
 370             array.raid_disks <= 0)
 371                 return 0;
 372         avail = calloc(array.raid_disks, 1);
 373         for (i=0; i<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_flags(int devnum, int flags)
1002 {
1003         char buf[20];
1004
1005         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
1006         return dev_open(buf, flags);
1007 }
1008
1009 int open_dev(int devnum)
1010 {
1011         return open_dev_flags(devnum, O_RDONLY);
1012 }
1013
1014 int open_dev_excl(int devnum)
1015 {
1016         char buf[20];
1017         int i;
1018
1019         sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
1020         for (i=0 ; i<25 ; i++) {
1021                 int fd = dev_open(buf, O_RDWR|O_EXCL);
1022                 if (fd >= 0)
1023                         return fd;
1024                 if (errno != EBUSY)
1025                         return fd;
1026                 usleep(200000);
1027         }
1028         return -1;
1029 }
1030
1031 int same_dev(char *one, char *two)
1032 {
1033         struct stat st1, st2;
1034         if (stat(one, &st1) != 0)
1035                 return 0;
1036         if (stat(two, &st2) != 0)
1037                 return 0;
1038         if ((st1.st_mode & S_IFMT) != S_IFBLK)
1039                 return 0;
1040         if ((st2.st_mode & S_IFMT) != S_IFBLK)
1041                 return 0;
1042         return st1.st_rdev == st2.st_rdev;
1043 }
1044
1045 void wait_for(char *dev, int fd)
1046 {
1047         int i;
1048         struct stat stb_want;
1049
1050         if (fstat(fd, &stb_want) != 0 ||
1051             (stb_want.st_mode & S_IFMT) != S_IFBLK)
1052                 return;
1053
1054         for (i=0 ; i<25 ; i++) {
1055                 struct stat stb;
1056                 if (stat(dev, &stb) == 0 &&
1057                     (stb.st_mode & S_IFMT) == S_IFBLK &&
1058                     (stb.st_rdev == stb_want.st_rdev))
1059                         return;
1060                 usleep(200000);
1061         }
1062         if (i == 25)
1063                 dprintf("%s: timeout waiting for %s\n", __func__, dev);
1064 }
1065
1066 struct superswitch *superlist[] =
1067 {
1068         &super0, &super1,
1069         &super_ddf, &super_imsm,
1070         &mbr, &gpt,
1071         NULL };
1072
1073 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
1074
1075 struct supertype *super_by_fd(int fd, char **subarrayp)
1076 {
1077         mdu_array_info_t array;
1078         int vers;
1079         int minor;
1080         struct supertype *st = NULL;
1081         struct mdinfo *sra;
1082         char *verstr;
1083         char version[20];
1084         int i;
1085         char *subarray = NULL;
1086         int container = NoMdDev;
1087
1088         sra = sysfs_read(fd, 0, GET_VERSION);
1089
1090         if (sra) {
1091                 vers = sra->array.major_version;
1092                 minor = sra->array.minor_version;
1093                 verstr = sra->text_version;
1094         } else {
1095                 if (ioctl(fd, GET_ARRAY_INFO, &array))
1096                         array.major_version = array.minor_version = 0;
1097                 vers = array.major_version;
1098                 minor = array.minor_version;
1099                 verstr = "";
1100         }
1101
1102         if (vers != -1) {
1103                 sprintf(version, "%d.%d", vers, minor);
1104                 verstr = version;
1105         }
1106         if (minor == -2 && is_subarray(verstr)) {
1107                 char *dev = verstr+1;
1108
1109                 subarray = strchr(dev, '/');
1110                 if (subarray)
1111                         *subarray++ = '\0';
1112                 subarray = strdup(subarray);
1113                 container = devname2devnum(dev);
1114                 if (sra)
1115                         sysfs_free(sra);
1116                 sra = sysfs_read(-1, container, GET_VERSION);
1117                 if (sra && sra->text_version[0])
1118                         verstr = sra->text_version;
1119                 else
1120                         verstr = "-no-metadata-";
1121         }
1122
1123         for (i = 0; st == NULL && superlist[i] ; i++)
1124                 st = superlist[i]->match_metadata_desc(verstr);
1125
1126         if (sra)
1127                 sysfs_free(sra);
1128         if (st) {
1129                 st->sb = NULL;
1130                 if (subarrayp)
1131                         *subarrayp = subarray;
1132                 st->container_dev = container;
1133                 st->devnum = fd2devnum(fd);
1134         } else
1135                 free(subarray);
1136
1137         return st;
1138 }
1139 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
1140
1141 int dev_size_from_id(dev_t id, unsigned long long *size)
1142 {
1143         char buf[20];
1144         int fd;
1145
1146         sprintf(buf, "%d:%d", major(id), minor(id));
1147         fd = dev_open(buf, O_RDONLY);
1148         if (fd < 0)
1149                 return 0;
1150         if (get_dev_size(fd, NULL, size)) {
1151                 close(fd);
1152                 return 1;
1153         }
1154         close(fd);
1155         return 0;
1156 }
1157
1158 struct supertype *dup_super(struct supertype *orig)
1159 {
1160         struct supertype *st;
1161
1162         if (!orig)
1163                 return orig;
1164         st = malloc(sizeof(*st));
1165         if (!st)
1166                 return st;
1167         memset(st, 0, sizeof(*st));
1168         st->ss = orig->ss;
1169         st->max_devs = orig->max_devs;
1170         st->minor_version = orig->minor_version;
1171         st->sb = NULL;
1172         st->info = NULL;
1173         return st;
1174 }
1175
1176 struct supertype *guess_super_type(int fd, enum guess_types guess_type)
1177 {
1178         /* try each load_super to find the best match,
1179          * and return the best superswitch
1180          */
1181         struct superswitch  *ss;
1182         struct supertype *st;
1183         time_t besttime = 0;
1184         int bestsuper = -1;
1185         int i;
1186
1187         st = malloc(sizeof(*st));
1188         memset(st, 0, sizeof(*st));
1189         st->container_dev = NoMdDev;
1190
1191         for (i=0 ; superlist[i]; i++) {
1192                 int rv;
1193                 ss = superlist[i];
1194                 if (guess_type == guess_array && ss->add_to_super == NULL)
1195                         continue;
1196                 if (guess_type == guess_partitions && ss->add_to_super != NULL)
1197                         continue;
1198                 memset(st, 0, sizeof(*st));
1199                 st->ignore_hw_compat = 1;
1200                 rv = ss->load_super(st, fd, NULL);
1201                 if (rv == 0) {
1202                         struct mdinfo info;
1203                         st->ss->getinfo_super(st, &info, NULL);
1204                         if (bestsuper == -1 ||
1205                             besttime < info.array.ctime) {
1206                                 bestsuper = i;
1207                                 besttime = info.array.ctime;
1208                         }
1209                         ss->free_super(st);
1210                 }
1211         }
1212         if (bestsuper != -1) {
1213                 int rv;
1214                 memset(st, 0, sizeof(*st));
1215                 st->ignore_hw_compat = 1;
1216                 rv = superlist[bestsuper]->load_super(st, fd, NULL);
1217                 if (rv == 0) {
1218                         superlist[bestsuper]->free_super(st);
1219                         st->ignore_hw_compat = 0;
1220                         return st;
1221                 }
1222         }
1223         free(st);
1224         return NULL;
1225 }
1226
1227 /* Return size of device in bytes */
1228 int get_dev_size(int fd, char *dname, unsigned long long *sizep)
1229 {
1230         unsigned long long ldsize;
1231         struct stat st;
1232
1233         if (fstat(fd, &st) != -1 && S_ISREG(st.st_mode))
1234                 ldsize = (unsigned long long)st.st_size;
1235         else
1236 #ifdef BLKGETSIZE64
1237         if (ioctl(fd, BLKGETSIZE64, &ldsize) != 0)
1238 #endif
1239         {
1240                 unsigned long dsize;
1241                 if (ioctl(fd, BLKGETSIZE, &dsize) == 0) {
1242                         ldsize = dsize;
1243                         ldsize <<= 9;
1244                 } else {
1245                         if (dname)
1246                                 fprintf(stderr, Name ": Cannot get size of %s: %s\b",
1247                                         dname, strerror(errno));
1248                         return 0;
1249                 }
1250         }
1251         *sizep = ldsize;
1252         return 1;
1253 }
1254
1255 /* Return true if this can only be a container, not a member device.
1256  * i.e. is and md device and size is zero
1257  */
1258 int must_be_container(int fd)
1259 {
1260         unsigned long long size;
1261         if (md_get_version(fd) < 0)
1262                 return 0;
1263         if (get_dev_size(fd, NULL, &size) == 0)
1264                 return 1;
1265         if (size == 0)
1266                 return 1;
1267         return 0;
1268 }
1269
1270 /* Sets endofpart parameter to the last block used by the last GPT partition on the device.
1271  * Returns: 1 if successful
1272  *         -1 for unknown partition type
1273  *          0 for other errors
1274  */
1275 static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
1276 {
1277         struct GPT gpt;
1278         unsigned char buf[512];
1279         unsigned char empty_gpt_entry[16]= {0};
1280         struct GPT_part_entry *part;
1281         unsigned long long curr_part_end;
1282         unsigned all_partitions, entry_size;
1283         unsigned part_nr;
1284
1285         *endofpart = 0;
1286
1287         BUILD_BUG_ON(sizeof(gpt) != 512);
1288         /* read GPT header */
1289         lseek(fd, 512, SEEK_SET);
1290         if (read(fd, &gpt, 512) != 512)
1291                 return 0;
1292
1293         /* get the number of partition entries and the entry size */
1294         all_partitions = __le32_to_cpu(gpt.part_cnt);
1295         entry_size = __le32_to_cpu(gpt.part_size);
1296
1297         /* Check GPT signature*/
1298         if (gpt.magic != GPT_SIGNATURE_MAGIC)
1299                 return -1;
1300
1301         /* sanity checks */
1302         if (all_partitions > 1024 ||
1303             entry_size > 512)
1304                 return -1;
1305
1306         /* read first GPT partition entries */
1307         if (read(fd, buf, 512) != 512)
1308                 return 0;
1309
1310         part = (struct GPT_part_entry*)buf;
1311
1312         for (part_nr=0; part_nr < all_partitions; part_nr++) {
1313                 /* is this valid partition? */
1314                 if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
1315                         /* check the last lba for the current partition */
1316                         curr_part_end = __le64_to_cpu(part->ending_lba);
1317                         if (curr_part_end > *endofpart)
1318                                 *endofpart = curr_part_end;
1319                 }
1320
1321                 part = (struct GPT_part_entry*)((unsigned char*)part + entry_size);
1322
1323                 if ((unsigned char *)part >= buf + 512) {
1324                         if (read(fd, buf, 512) != 512)
1325                                 return 0;
1326                         part = (struct GPT_part_entry*)buf;
1327                 }
1328         }
1329         return 1;
1330 }
1331
1332 /* Sets endofpart parameter to the last block used by the last partition on the device.
1333  * Returns: 1 if successful
1334  *         -1 for unknown partition type
1335  *          0 for other errors
1336  */
1337 static int get_last_partition_end(int fd, unsigned long long *endofpart)
1338 {
1339         struct MBR boot_sect;
1340         struct MBR_part_record *part;
1341         unsigned long long curr_part_end;
1342         unsigned part_nr;
1343         int retval = 0;
1344
1345         *endofpart = 0;
1346
1347         BUILD_BUG_ON(sizeof(boot_sect) != 512);
1348         /* read MBR */
1349         lseek(fd, 0, 0);
1350         if (read(fd, &boot_sect, 512) != 512)
1351                 goto abort;
1352
1353         /* check MBP signature */
1354         if (boot_sect.magic == MBR_SIGNATURE_MAGIC) {
1355                 retval = 1;
1356                 /* found the correct signature */
1357                 part = boot_sect.parts;
1358
1359                 for (part_nr=0; part_nr < MBR_PARTITIONS; part_nr++) {
1360                         /* check for GPT type */
1361                         if (part->part_type == MBR_GPT_PARTITION_TYPE) {
1362                                 retval = get_gpt_last_partition_end(fd, endofpart);
1363                                 break;
1364                         }
1365                         /* check the last used lba for the current partition  */
1366                         curr_part_end = __le32_to_cpu(part->first_sect_lba) +
1367                                 __le32_to_cpu(part->blocks_num);
1368                         if (curr_part_end > *endofpart)
1369                                 *endofpart = curr_part_end;
1370
1371                         part++;
1372                 }
1373         } else {
1374                 /* Unknown partition table */
1375                 retval = -1;
1376         }
1377  abort:
1378         return retval;
1379 }
1380
1381 int check_partitions(int fd, char *dname, unsigned long long freesize,
1382                         unsigned long long size)
1383 {
1384         /*
1385          * Check where the last partition ends
1386          */
1387         unsigned long long endofpart;
1388         int ret;
1389
1390         if ((ret = get_last_partition_end(fd, &endofpart)) > 0) {
1391                 /* There appears to be a partition table here */
1392                 if (freesize == 0) {
1393                         /* partitions will not be visible in new device */
1394                         fprintf(stderr,
1395                                 Name ": partition table exists on %s but will be lost or\n"
1396                                 "       meaningless after creating array\n",
1397                                 dname);
1398                         return 1;
1399                 } else if (endofpart > freesize) {
1400                         /* last partition overlaps metadata */
1401                         fprintf(stderr,
1402                                 Name ": metadata will over-write last partition on %s.\n",
1403                                 dname);
1404                         return 1;
1405                 } else if (size && endofpart > size) {
1406                         /* partitions will be truncated in new device */
1407                         fprintf(stderr,
1408                                 Name ": array size is too small to cover all partitions on %s.\n",
1409                                 dname);
1410                         return 1;
1411                 }
1412         }
1413         return 0;
1414 }
1415
1416 void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk)
1417 {
1418         int d;
1419         ioctl(mdfd, GET_ARRAY_INFO, ainf);
1420         for (d = 0 ; d < ainf->raid_disks + ainf->nr_disks ; d++)
1421                 if (ioctl(mdfd, GET_DISK_INFO, disk) == 0)
1422                         return;
1423 }
1424
1425 int open_container(int fd)
1426 {
1427         /* 'fd' is a block device.  Find out if it is in use
1428          * by a container, and return an open fd on that container.
1429          */
1430         char path[256];
1431         char *e;
1432         DIR *dir;
1433         struct dirent *de;
1434         int dfd, n;
1435         char buf[200];
1436         int major, minor;
1437         struct stat st;
1438
1439         if (fstat(fd, &st) != 0)
1440                 return -1;
1441         sprintf(path, "/sys/dev/block/%d:%d/holders",
1442                 (int)major(st.st_rdev), (int)minor(st.st_rdev));
1443         e = path + strlen(path);
1444
1445         dir = opendir(path);
1446         if (!dir)
1447                 return -1;
1448         while ((de = readdir(dir))) {
1449                 if (de->d_ino == 0)
1450                         continue;
1451                 if (de->d_name[0] == '.')
1452                         continue;
1453                 sprintf(e, "/%s/dev", de->d_name);
1454                 dfd = open(path, O_RDONLY);
1455                 if (dfd < 0)
1456                         continue;
1457                 n = read(dfd, buf, sizeof(buf));
1458                 close(dfd);
1459                 if (n <= 0 || (unsigned)n >= sizeof(buf))
1460                         continue;
1461                 buf[n] = 0;
1462                 if (sscanf(buf, "%d:%d", &major, &minor) != 2)
1463                         continue;
1464                 sprintf(buf, "%d:%d", major, minor);
1465                 dfd = dev_open(buf, O_RDONLY);
1466                 if (dfd >= 0) {
1467                         closedir(dir);
1468                         return dfd;
1469                 }
1470         }
1471         closedir(dir);
1472         return -1;
1473 }
1474
1475 struct superswitch *version_to_superswitch(char *vers)
1476 {
1477         int i;
1478
1479         for (i = 0; superlist[i]; i++) {
1480                 struct superswitch *ss = superlist[i];
1481
1482                 if (strcmp(vers, ss->name) == 0)
1483                         return ss;
1484         }
1485
1486         return NULL;
1487 }
1488
1489 int is_container_member(struct mdstat_ent *mdstat, char *container)
1490 {
1491         if (mdstat->metadata_version == NULL ||
1492             strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
1493             !is_subarray(mdstat->metadata_version+9) ||
1494             strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 ||
1495             mdstat->metadata_version[10+strlen(container)] != '/')
1496                 return 0;
1497
1498         return 1;
1499 }
1500
1501 int is_subarray_active(char *subarray, char *container)
1502 {
1503         struct mdstat_ent *mdstat = mdstat_read(0, 0);
1504         struct mdstat_ent *ent;
1505
1506         for (ent = mdstat; ent; ent = ent->next)
1507                 if (is_container_member(ent, container))
1508                         if (strcmp(to_subarray(ent, container), subarray) == 0)
1509                                 break;
1510
1511         free_mdstat(mdstat);
1512
1513         return ent != NULL;
1514 }
1515
1516 /* open_subarray - opens a subarray in a container
1517  * @dev: container device name
1518  * @st: empty supertype
1519  * @quiet: block reporting errors flag
1520  *
1521  * On success returns an fd to a container and fills in *st
1522  */
1523 int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet)
1524 {
1525         struct mdinfo *mdi;
1526         struct mdinfo *info;
1527         int fd, err = 1;
1528
1529         fd = open(dev, O_RDWR|O_EXCL);
1530         if (fd < 0) {
1531                 if (!quiet)
1532                         fprintf(stderr, Name ": Couldn't open %s, aborting\n",
1533                                 dev);
1534                 return 2;
1535         }
1536
1537         st->devnum = fd2devnum(fd);
1538         if (st->devnum == NoMdDev) {
1539                 if (!quiet)
1540                         fprintf(stderr,
1541                                 Name ": Failed to determine device number for %s\n",
1542                                 dev);
1543                 goto close_fd;
1544         }
1545
1546         mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
1547         if (!mdi) {
1548                 if (!quiet)
1549                         fprintf(stderr, Name ": Failed to read sysfs for %s\n",
1550                                 dev);
1551                 goto close_fd;
1552         }
1553
1554         if (mdi->array.level != UnSet) {
1555                 if (!quiet)
1556                         fprintf(stderr, Name ": %s is not a container\n", dev);
1557                 goto free_sysfs;
1558         }
1559
1560         st->ss = version_to_superswitch(mdi->text_version);
1561         if (!st->ss) {
1562                 if (!quiet)
1563                         fprintf(stderr,
1564                                 Name ": Operation not supported for %s metadata\n",
1565                                 mdi->text_version);
1566                 goto free_sysfs;
1567         }
1568
1569         st->devname = devnum2devname(st->devnum);
1570         if (!st->devname) {
1571                 if (!quiet)
1572                         fprintf(stderr, Name ": Failed to allocate device name\n");
1573                 goto free_sysfs;
1574         }
1575
1576         if (!st->ss->load_container) {
1577                 if (!quiet)
1578                         fprintf(stderr, Name ": %s is not a container\n", dev);
1579                 goto free_name;
1580         }
1581
1582         if (st->ss->load_container(st, fd, NULL)) {
1583                 if (!quiet)
1584                         fprintf(stderr, Name ": Failed to load metadata for %s\n",
1585                                 dev);
1586                 goto free_name;
1587         }
1588
1589         info = st->ss->container_content(st, subarray);
1590         if (!info) {
1591                 if (!quiet)
1592                         fprintf(stderr, Name ": Failed to find subarray-%s in %s\n",
1593                                 subarray, dev);
1594                 goto free_super;
1595         }
1596         free(info);
1597
1598         err = 0;
1599
1600  free_super:
1601         if (err)
1602                 st->ss->free_super(st);
1603  free_name:
1604         if (err)
1605                 free(st->devname);
1606  free_sysfs:
1607         sysfs_free(mdi);
1608  close_fd:
1609         if (err)
1610                 close(fd);
1611
1612         if (err)
1613                 return -1;
1614         else
1615                 return fd;
1616 }
1617
1618 int add_disk(int mdfd, struct supertype *st,
1619              struct mdinfo *sra, struct mdinfo *info)
1620 {
1621         /* Add a device to an array, in one of 2 ways. */
1622         int rv;
1623 #ifndef MDASSEMBLE
1624         if (st->ss->external) {
1625                 if (info->disk.state & (1<<MD_DISK_SYNC))
1626                         info->recovery_start = MaxSector;
1627                 else
1628                         info->recovery_start = 0;
1629                 rv = sysfs_add_disk(sra, info, 0);
1630                 if (! rv) {
1631                         struct mdinfo *sd2;
1632                         for (sd2 = sra->devs; sd2; sd2=sd2->next)
1633                                 if (sd2 == info)
1634                                         break;
1635                         if (sd2 == NULL) {
1636                                 sd2 = malloc(sizeof(*sd2));
1637                                 *sd2 = *info;
1638                                 sd2->next = sra->devs;
1639                                 sra->devs = sd2;
1640                         }
1641                 }
1642         } else
1643 #endif
1644                 rv = ioctl(mdfd, ADD_NEW_DISK, &info->disk);
1645         return rv;
1646 }
1647
1648 int remove_disk(int mdfd, struct supertype *st,
1649                 struct mdinfo *sra, struct mdinfo *info)
1650 {
1651         int rv;
1652         /* Remove the disk given by 'info' from the array */
1653 #ifndef MDASSEMBLE
1654         if (st->ss->external)
1655                 rv = sysfs_set_str(sra, info, "slot", "none");
1656         else
1657 #endif
1658                 rv = ioctl(mdfd, HOT_REMOVE_DISK, makedev(info->disk.major,
1659                                                           info->disk.minor));
1660         return rv;
1661 }
1662
1663 int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info)
1664 {
1665         /* Initialise kernel's knowledge of array.
1666          * This varies between externally managed arrays
1667          * and older kernels
1668          */
1669         int vers = md_get_version(mdfd);
1670         int rv;
1671
1672 #ifndef MDASSEMBLE
1673         if (st->ss->external)
1674                 rv = sysfs_set_array(info, vers);
1675         else
1676 #endif
1677                 if ((vers % 100) >= 1) { /* can use different versions */
1678                 mdu_array_info_t inf;
1679                 memset(&inf, 0, sizeof(inf));
1680                 inf.major_version = info->array.major_version;
1681                 inf.minor_version = info->array.minor_version;
1682                 rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
1683         } else
1684                 rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
1685         return rv;
1686 }
1687
1688 unsigned long long min_recovery_start(struct mdinfo *array)
1689 {
1690         /* find the minimum recovery_start in an array for metadata
1691          * formats that only record per-array recovery progress instead
1692          * of per-device
1693          */
1694         unsigned long long recovery_start = MaxSector;
1695         struct mdinfo *d;
1696
1697         for (d = array->devs; d; d = d->next)
1698                 recovery_start = min(recovery_start, d->recovery_start);
1699
1700         return recovery_start;
1701 }
1702
1703 void fmt_devname(char *name, int num)
1704 {
1705         if (num >= 0)
1706                 sprintf(name, "md%d", num);
1707         else
1708                 sprintf(name, "md_d%d", -1-num);
1709 }
1710
1711 char *devnum2devname(int num)
1712 {
1713         char name[100];
1714         fmt_devname(name,num);
1715         return strdup(name);
1716 }
1717
1718 int devname2devnum(char *name)
1719 {
1720         char *ep;
1721         int num;
1722         if (strncmp(name, "md_d", 4)==0)
1723                 num = -1-strtoul(name+4, &ep, 10);
1724         else
1725                 num = strtoul(name+2, &ep, 10);
1726         return num;
1727 }
1728
1729 int stat2devnum(struct stat *st)
1730 {
1731         char path[30];
1732         char link[200];
1733         char *cp;
1734         int n;
1735
1736         if ((S_IFMT & st->st_mode) == S_IFBLK) {
1737                 if (major(st->st_rdev) == MD_MAJOR)
1738                         return minor(st->st_rdev);
1739                 else if (major(st->st_rdev) == (unsigned)get_mdp_major())
1740                         return -1- (minor(st->st_rdev)>>MdpMinorShift);
1741
1742                 /* must be an extended-minor partition. Look at the
1743                  * /sys/dev/block/%d:%d link which must look like
1744                  * ../../block/mdXXX/mdXXXpYY
1745                  */
1746                 sprintf(path, "/sys/dev/block/%d:%d", major(st->st_rdev),
1747                         minor(st->st_rdev));
1748                 n = readlink(path, link, sizeof(link)-1);
1749                 if (n <= 0)
1750                         return NoMdDev;
1751                 link[n] = 0;
1752                 cp = strrchr(link, '/');
1753                 if (cp) *cp = 0;
1754                 cp = strrchr(link, '/');
1755                 if (cp && strncmp(cp, "/md", 3) == 0)
1756                         return devname2devnum(cp+1);
1757         }
1758         return NoMdDev;
1759
1760 }
1761
1762 int fd2devnum(int fd)
1763 {
1764         struct stat stb;
1765         if (fstat(fd, &stb) == 0)
1766                 return stat2devnum(&stb);
1767         return NoMdDev;
1768 }
1769
1770 int mdmon_pid(int devnum)
1771 {
1772         char path[100];
1773         char pid[10];
1774         int fd;
1775         int n;
1776         char *devname = devnum2devname(devnum);
1777
1778         sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
1779         free(devname);
1780
1781         fd = open(path, O_RDONLY | O_NOATIME, 0);
1782
1783         if (fd < 0)
1784                 return -1;
1785         n = read(fd, pid, 9);
1786         close(fd);
1787         if (n <= 0)
1788                 return -1;
1789         return atoi(pid);
1790 }
1791
1792 int mdmon_running(int devnum)
1793 {
1794         int pid = mdmon_pid(devnum);
1795         if (pid <= 0)
1796                 return 0;
1797         if (kill(pid, 0) == 0)
1798                 return 1;
1799         return 0;
1800 }
1801
1802 int start_mdmon(int devnum)
1803 {
1804         int i;
1805         int len;
1806         pid_t pid;
1807         int status;
1808         char pathbuf[1024];
1809         char *paths[4] = {
1810                 pathbuf,
1811                 "/sbin/mdmon",
1812                 "mdmon",
1813                 NULL
1814         };
1815
1816         if (check_env("MDADM_NO_MDMON"))
1817                 return 0;
1818
1819         len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf));
1820         if (len > 0) {
1821                 char *sl;
1822                 pathbuf[len] = 0;
1823                 sl = strrchr(pathbuf, '/');
1824                 if (sl)
1825                         sl++;
1826                 else
1827                         sl = pathbuf;
1828                 strcpy(sl, "mdmon");
1829         } else
1830                 pathbuf[0] = '\0';
1831
1832         switch(fork()) {
1833         case 0:
1834                 /* FIXME yuk. CLOSE_EXEC?? */
1835                 for (i=3; i < 100; i++)
1836                         close(i);
1837                 for (i=0; paths[i]; i++)
1838                         if (paths[i][0])
1839                                 execl(paths[i], "mdmon",
1840                                       devnum2devname(devnum),
1841                                       NULL);
1842                 exit(1);
1843         case -1: fprintf(stderr, Name ": cannot run mdmon. "
1844                          "Array remains readonly\n");
1845                 return -1;
1846         default: /* parent - good */
1847                 pid = wait(&status);
1848                 if (pid < 0 || status != 0)
1849                         return -1;
1850         }
1851         return 0;
1852 }
1853
1854 int check_env(char *name)
1855 {
1856         char *val = getenv(name);
1857
1858         if (val && atoi(val) == 1)
1859                 return 1;
1860
1861         return 0;
1862 }
1863
1864 __u32 random32(void)
1865 {
1866         __u32 rv;
1867         int rfd = open("/dev/urandom", O_RDONLY);
1868         if (rfd < 0 || read(rfd, &rv, 4) != 4)
1869                 rv = random();
1870         if (rfd >= 0)
1871                 close(rfd);
1872         return rv;
1873 }
1874
1875 #ifndef MDASSEMBLE
1876 int flush_metadata_updates(struct supertype *st)
1877 {
1878         int sfd;
1879         if (!st->updates) {
1880                 st->update_tail = NULL;
1881                 return -1;
1882         }
1883
1884         sfd = connect_monitor(devnum2devname(st->container_dev));
1885         if (sfd < 0)
1886                 return -1;
1887
1888         while (st->updates) {
1889                 struct metadata_update *mu = st->updates;
1890                 st->updates = mu->next;
1891
1892                 send_message(sfd, mu, 0);
1893                 wait_reply(sfd, 0);
1894                 free(mu->buf);
1895                 free(mu);
1896         }
1897         ack(sfd, 0);
1898         wait_reply(sfd, 0);
1899         close(sfd);
1900         st->update_tail = NULL;
1901         return 0;
1902 }
1903
1904 void append_metadata_update(struct supertype *st, void *buf, int len)
1905 {
1906
1907         struct metadata_update *mu = malloc(sizeof(*mu));
1908
1909         mu->buf = buf;
1910         mu->len = len;
1911         mu->space = NULL;
1912         mu->space_list = NULL;
1913         mu->next = NULL;
1914         *st->update_tail = mu;
1915         st->update_tail = &mu->next;
1916 }
1917 #endif /* MDASSEMBLE */
1918
1919 #ifdef __TINYC__
1920 /* tinyc doesn't optimize this check in ioctl.h out ... */
1921 unsigned int __invalid_size_argument_for_IOC = 0;
1922 #endif
1923
1924 int experimental(void)
1925 {
1926         if (check_env("MDADM_EXPERIMENTAL"))
1927                 return 1;
1928         else {
1929                 fprintf(stderr, Name ": To use this feature MDADM_EXPERIMENTAL enviroment variable has to defined.\n");
1930                 return 0;
1931         }
1932 }
1933
1934 /* Pick all spares matching given criteria from a container
1935  * if min_size == 0 do not check size
1936  * if domlist == NULL do not check domains
1937  * if spare_group given add it to domains of each spare
1938  * metadata allows to test domains using metadata of destination array */
1939 struct mdinfo *container_choose_spares(struct supertype *st,
1940                                        unsigned long long min_size,
1941                                        struct domainlist *domlist,
1942                                        char *spare_group,
1943                                        const char *metadata, int get_one)
1944 {
1945         struct mdinfo *d, **dp, *disks = NULL;
1946
1947         /* get list of all disks in container */
1948         if (st->ss->getinfo_super_disks)
1949                 disks = st->ss->getinfo_super_disks(st);
1950
1951         if (!disks)
1952                 return disks;
1953         /* find spare devices on the list */
1954         dp = &disks->devs;
1955         disks->array.spare_disks = 0;
1956         while (*dp) {
1957                 int found = 0;
1958                 d = *dp;
1959                 if (d->disk.state == 0) {
1960                         /* check if size is acceptable */
1961                         unsigned long long dev_size;
1962                         dev_t dev = makedev(d->disk.major,d->disk.minor);
1963
1964                         if (!min_size ||
1965                            (dev_size_from_id(dev,  &dev_size) &&
1966                             dev_size >= min_size))
1967                                 found = 1;
1968                         /* check if domain matches */
1969                         if (found && domlist) {
1970                                 struct dev_policy *pol = devnum_policy(dev);
1971                                 if (spare_group)
1972                                         pol_add(&pol, pol_domain,
1973                                                 spare_group, NULL);
1974                                 if (domain_test(domlist, pol, metadata) != 1)
1975                                         found = 0;
1976                                 dev_policy_free(pol);
1977                         }
1978                 }
1979                 if (found) {
1980                         dp = &d->next;
1981                         disks->array.spare_disks++;
1982                         if (get_one) {
1983                                 sysfs_free(*dp);
1984                                 d->next = NULL;
1985                         }
1986                 } else {
1987                         *dp = d->next;
1988                         d->next = NULL;
1989                         sysfs_free(d);
1990                 }
1991         }
1992         return disks;
1993 }