util.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2006 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@cse.unsw.edu.au>
  23  *    Paper: Neil Brown
  24  *           School of Computer Science and Engineering
  25  *           The University of New South Wales
  26  *           Sydney, 2052
  27  *           Australia
  28  */
  29
  30 #include        "mdadm.h"
  31 #include        "md_p.h"
  32 #include        <sys/utsname.h>
  33 #include        <ctype.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 /*
  69  * Parse a 128 bit uuid in 4 integers
  70  * format is 32 hexx nibbles with options :.<space> separator
  71  * If not exactly 32 hex digits are found, return 0
  72  * else return 1
  73  */
  74 int parse_uuid(char *str, int uuid[4])
  75 {
  76     int hit = 0; /* number of Hex digIT */
  77     int i;
  78     char c;
  79     for (i=0; i<4; i++) uuid[i]=0;
  80
  81     while ((c= *str++)) {
  82         int n;
  83         if (c>='0' && c<='9')
  84             n = c-'0';
  85         else if (c>='a' && c <= 'f')
  86             n = 10 + c - 'a';
  87         else if (c>='A' && c <= 'F')
  88             n = 10 + c - 'A';
  89         else if (strchr(":. -", c))
  90             continue;
  91         else return 0;
  92
  93         if (hit<32) {
  94             uuid[hit/8] <<= 4;
  95             uuid[hit/8] += n;
  96         }
  97         hit++;
  98     }
  99     if (hit == 32)
 100         return 1;
 101     return 0;
 102
 103 }
 104
 105
 106 /*
 107  * Get the md version number.
 108  * We use the RAID_VERSION ioctl if it is supported
 109  * If not, but we have a block device with major '9', we assume
 110  * 0.36.0
 111  *
 112  * Return version number as 24 but number - assume version parts
 113  * always < 255
 114  */
 115
 116 int md_get_version(int fd)
 117 {
 118     struct stat stb;
 119     mdu_version_t vers;
 120
 121     if (fstat(fd, &stb)<0)
 122         return -1;
 123     if ((S_IFMT&stb.st_mode) != S_IFBLK)
 124         return -1;
 125
 126     if (ioctl(fd, RAID_VERSION, &vers) == 0)
 127         return  (vers.major*10000) + (vers.minor*100) + vers.patchlevel;
 128     if (errno == EACCES)
 129             return -1;
 130     if (major(stb.st_rdev) == MD_MAJOR)
 131         return (3600);
 132     return -1;
 133 }
 134
 135
 136 int get_linux_version()
 137 {
 138         struct utsname name;
 139         char *cp;
 140         int a,b,c;
 141         if (uname(&name) <0)
 142                 return -1;
 143
 144         cp = name.release;
 145         a = strtoul(cp, &cp, 10);
 146         if (*cp != '.') return -1;
 147         b = strtoul(cp+1, &cp, 10);
 148         if (*cp != '.') return -1;
 149         c = strtoul(cp+1, NULL, 10);
 150
 151         return (a*1000000)+(b*1000)+c;
 152 }
 153
 154 void remove_partitions(int fd)
 155 {
 156         /* remove partitions from this block devices.
 157          * This is used for components added to an array
 158          */
 159 #ifdef BLKPG_DEL_PARTITION
 160         struct blkpg_ioctl_arg a;
 161         struct blkpg_partition p;
 162
 163         a.op = BLKPG_DEL_PARTITION;
 164         a.data = (void*)&p;
 165         a.datalen = sizeof(p);
 166         a.flags = 0;
 167         memset(a.data, 0, a.datalen);
 168         for (p.pno=0; p.pno < 16; p.pno++)
 169                 ioctl(fd, BLKPG, &a);
 170 #endif
 171 }
 172
 173 int enough(int level, int raid_disks, int layout,
 174            char *avail, int avail_disks)
 175 {
 176         int copies, first;
 177         switch (level) {
 178         case 10:
 179                 /* This is the tricky one - we need to check
 180                  * which actual disks are present.
 181                  */
 182                 copies = (layout&255)* (layout>>8);
 183                 first=0;
 184                 do {
 185                         /* there must be one of the 'copies' form 'first' */
 186                         int n = copies;
 187                         int cnt=0;
 188                         while (n--) {
 189                                 if (avail[first])
 190                                         cnt++;
 191                                 first = (first+1) % raid_disks;
 192                         }
 193                         if (cnt == 0)
 194                                 return 0;
 195
 196                 } while (first != 0);
 197                 return 1;
 198
 199         case -4:
 200                 return avail_disks>= 1;
 201         case -1:
 202         case 0:
 203                 return avail_disks == raid_disks;
 204         case 1:
 205                 return avail_disks >= 1;
 206         case 4:
 207         case 5:
 208                 return avail_disks >= raid_disks-1;
 209         case 6:
 210                 return avail_disks >= raid_disks-2;
 211         default:
 212                 return 0;
 213         }
 214 }
 215
 216 int same_uuid(int a[4], int b[4], int swapuuid)
 217 {
 218         if (swapuuid) {
 219                 /* parse uuids are hostendian.
 220                  * uuid's from some superblocks are big-ending
 221                  * if there is a difference, we need to swap..
 222                  */
 223                 unsigned char *ac = (unsigned char *)a;
 224                 unsigned char *bc = (unsigned char *)b;
 225                 int i;
 226                 for (i=0; i<16; i+= 4) {
 227                         if (ac[i+0] != bc[i+3] ||
 228                             ac[i+1] != bc[i+2] ||
 229                             ac[i+2] != bc[i+1] ||
 230                             ac[i+3] != bc[i+0])
 231                                 return 0;
 232                 }
 233                 return 1;
 234         } else {
 235                 if (a[0]==b[0] &&
 236                     a[1]==b[1] &&
 237                     a[2]==b[2] &&
 238                     a[3]==b[3])
 239                         return 1;
 240                 return 0;
 241         }
 242 }
 243
 244 int check_ext2(int fd, char *name)
 245 {
 246         /*
 247          * Check for an ext2fs file system.
 248          * Superblock is always 1K at 1K offset
 249          *
 250          * s_magic is le16 at 56 == 0xEF53
 251          * report mtime - le32 at 44
 252          * blocks - le32 at 4
 253          * logblksize - le32 at 24
 254          */
 255         unsigned char sb[1024];
 256         time_t mtime;
 257         int size, bsize;
 258         if (lseek(fd, 1024,0)!= 1024)
 259                 return 0;
 260         if (read(fd, sb, 1024)!= 1024)
 261                 return 0;
 262         if (sb[56] != 0x53 || sb[57] != 0xef)
 263                 return 0;
 264
 265         mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
 266         bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
 267         size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
 268         fprintf(stderr, Name ": %s appears to contain an ext2fs file system\n",
 269                 name);
 270         fprintf(stderr,"    size=%dK  mtime=%s",
 271                 size*(1<<bsize), ctime(&mtime));
 272         return 1;
 273 }
 274
 275 int check_reiser(int fd, char *name)
 276 {
 277         /*
 278          * superblock is at 64K
 279          * size is 1024;
 280          * Magic string "ReIsErFs" or "ReIsEr2Fs" at 52
 281          *
 282          */
 283         unsigned char sb[1024];
 284         unsigned long size;
 285         if (lseek(fd, 64*1024, 0) != 64*1024)
 286                 return 0;
 287         if (read(fd, sb, 1024) != 1024)
 288                 return 0;
 289         if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
 290             strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
 291                 return 0;
 292         fprintf(stderr, Name ": %s appears to contain a reiserfs file system\n",name);
 293         size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
 294         fprintf(stderr, "    size = %luK\n", size*4);
 295
 296         return 1;
 297 }
 298
 299 int check_raid(int fd, char *name)
 300 {
 301         void *super;
 302         struct mdinfo info;
 303         time_t crtime;
 304         char *level;
 305         struct supertype *st = guess_super(fd);
 306
 307         if (!st) return 0;
 308         st->ss->load_super(st, fd, &super, name);
 309         /* Looks like a raid array .. */
 310         fprintf(stderr, Name ": %s appears to be part of a raid array:\n",
 311                 name);
 312         st->ss->getinfo_super(&info, super);
 313         free(super);
 314         crtime = info.array.ctime;
 315         level = map_num(pers, info.array.level);
 316         if (!level) level = "-unknown-";
 317         fprintf(stderr, "    level=%s devices=%d ctime=%s",
 318                 level, info.array.raid_disks, ctime(&crtime));
 319         return 1;
 320 }
 321
 322 int ask(char *mesg)
 323 {
 324         char *add = "";
 325         int i;
 326         for (i=0; i<5; i++) {
 327                 char buf[100];
 328                 fprintf(stderr, "%s%s", mesg, add);
 329                 fflush(stderr);
 330                 if (fgets(buf, 100, stdin)==NULL)
 331                         return 0;
 332                 if (buf[0]=='y' || buf[0]=='Y')
 333                         return 1;
 334                 if (buf[0]=='n' || buf[0]=='N')
 335                         return 0;
 336                 add = "(y/n) ";
 337         }
 338         fprintf(stderr, Name ": assuming 'no'\n");
 339         return 0;
 340 }
 341
 342 char *map_num(mapping_t *map, int num)
 343 {
 344         while (map->name) {
 345                 if (map->num == num)
 346                         return map->name;
 347                 map++;
 348         }
 349         return NULL;
 350 }
 351
 352 int map_name(mapping_t *map, char *name)
 353 {
 354         while (map->name) {
 355                 if (strcmp(map->name, name)==0)
 356                         return map->num;
 357                 map++;
 358         }
 359         return UnSet;
 360 }
 361
 362
 363 int is_standard(char *dev, int *nump)
 364 {
 365         /* tests if dev is a "standard" md dev name.
 366          * i.e if the last component is "/dNN" or "/mdNN",
 367          * where NN is a string of digits
 368          */
 369         char *d = strrchr(dev, '/');
 370         int type=0;
 371         int num;
 372         if (!d)
 373                 return 0;
 374         if (strncmp(d, "/d",2)==0)
 375                 d += 2, type=1; /* /dev/md/dN{pM} */
 376         else if (strncmp(d, "/md_d", 5)==0)
 377                 d += 5, type=1; /* /dev/md_dNpM */
 378         else if (strncmp(d, "/md", 3)==0)
 379                 d += 3, type=-1; /* /dev/mdN */
 380         else if (d-dev > 3 && strncmp(d-2, "md/", 3)==0)
 381                 d += 1, type=-1; /* /dev/md/N */
 382         else
 383                 return 0;
 384         if (!*d)
 385                 return 0;
 386         num = atoi(d);
 387         while (isdigit(*d))
 388                 d++;
 389         if (*d)
 390                 return 0;
 391         if (nump) *nump = num;
 392
 393         return type;
 394 }
 395
 396
 397 /*
 398  * convert a major/minor pair for a block device into a name in /dev, if possible.
 399  * On the first call, walk /dev collecting name.
 400  * Put them in a simple linked listfor now.
 401  */
 402 struct devmap {
 403     int major, minor;
 404     char *name;
 405     struct devmap *next;
 406 } *devlist = NULL;
 407 int devlist_ready = 0;
 408
 409 int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
 410 {
 411         struct stat st;
 412         if (S_ISLNK(stb->st_mode)) {
 413                 stat(name, &st);
 414                 stb = &st;
 415         }
 416
 417         if ((stb->st_mode&S_IFMT)== S_IFBLK) {
 418                 char *n = strdup(name);
 419                 struct devmap *dm = malloc(sizeof(*dm));
 420                 if (strncmp(n, "/dev/./", 7)==0)
 421                         strcpy(n+4, name+6);
 422                 if (dm) {
 423                         dm->major = major(stb->st_rdev);
 424                         dm->minor = minor(stb->st_rdev);
 425                         dm->name = n;
 426                         dm->next = devlist;
 427                         devlist = dm;
 428                 }
 429         }
 430         return 0;
 431 }
 432
 433 #ifndef HAVE_NFTW
 434 #ifdef HAVE_FTW
 435 int add_dev_1(const char *name, const struct stat *stb, int flag)
 436 {
 437         return add_dev(name, stb, flag, NULL);
 438 }
 439 int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
 440 {
 441         return ftw(path, add_dev_1, nopenfd);
 442 }
 443 #else
 444 int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
 445 {
 446         return 0;
 447 }
 448 int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
 449 {
 450         return 0;
 451 }
 452 #endif /* HAVE_FTW */
 453 #endif /* HAVE_NFTW */
 454
 455 /*
 456  * Find a block device with the right major/minor number.
 457  * If we find multiple names, choose the shortest.
 458  * If we find a non-standard name, it is probably there
 459  * deliberately so prefer it over a standard name.
 460  * This applies only to names for MD devices.
 461  */
 462 char *map_dev(int major, int minor, int create)
 463 {
 464         struct devmap *p;
 465         char *std = NULL, *nonstd=NULL;
 466         int did_check = 0;
 467
 468         if (major == 0 && minor == 0)
 469                         return NULL;
 470
 471  retry:
 472         if (!devlist_ready) {
 473                 char *dev = "/dev";
 474                 struct stat stb;
 475                 while(devlist) {
 476                         struct devmap *d = devlist;
 477                         devlist = d->next;
 478                         free(d->name);
 479                         free(d);
 480                 }
 481                 if (lstat(dev, &stb)==0 &&
 482                     S_ISLNK(stb.st_mode))
 483                         dev = "/dev/.";
 484                 nftw(dev, add_dev, 10, FTW_PHYS);
 485                 devlist_ready=1;
 486                 did_check = 1;
 487         }
 488
 489         for (p=devlist; p; p=p->next)
 490                 if (p->major == major &&
 491                     p->minor == minor) {
 492                         if (is_standard(p->name, NULL)) {
 493                                 if (std == NULL ||
 494                                     strlen(p->name) < strlen(std))
 495                                         std = p->name;
 496                         } else {
 497                                 if (nonstd == NULL ||
 498                                     strlen(p->name) < strlen(nonstd))
 499                                         nonstd = p->name;
 500                         }
 501                 }
 502         if (!std && !nonstd && !did_check) {
 503                 devlist_ready = 0;
 504                 goto retry;
 505         }
 506         if (create && !std && !nonstd) {
 507                 static char buf[30];
 508                 snprintf(buf, sizeof(buf), "%d:%d", major, minor);
 509                 nonstd = buf;
 510         }
 511
 512         return nonstd ? nonstd : std;
 513 }
 514
 515 unsigned long calc_csum(void *super, int bytes)
 516 {
 517         unsigned long long newcsum = 0;
 518         int i;
 519         unsigned int csum;
 520         unsigned int *superc = (unsigned int*) super;
 521
 522         for(i=0; i<bytes/4; i++)
 523                 newcsum+= superc[i];
 524         csum = (newcsum& 0xffffffff) + (newcsum>>32);
 525 #ifdef __alpha__
 526 /* The in-kernel checksum calculation is always 16bit on
 527  * the alpha, though it is 32 bit on i386...
 528  * I wonder what it is elsewhere... (it uses and API in
 529  * a way that it shouldn't).
 530  */
 531         csum = (csum & 0xffff) + (csum >> 16);
 532         csum = (csum & 0xffff) + (csum >> 16);
 533 #endif
 534         return csum;
 535 }
 536
 537 char *human_size(long long bytes)
 538 {
 539         static char buf[30];
 540
 541         /* We convert bytes to either centi-M{ega,ibi}bytes or
 542          * centi-G{igi,ibi}bytes, with appropriate rounding,
 543          * and then print 1/100th of those as a decimal.
 544          * We allow upto 2048Megabytes before converting to
 545          * gigabytes, as that shows more precision and isn't
 546          * too large a number.
 547          * Terrabytes are not yet handled.
 548          */
 549
 550         if (bytes < 5000*1024)
 551                 buf[0]=0;
 552         else if (bytes < 2*1024LL*1024LL*1024LL) {
 553                 long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2;
 554                 long cMB  = (bytes / ( 1000000LL / 200LL ) +1) /2;
 555                 snprintf(buf, sizeof(buf), " (%ld.%02ld MiB %ld.%02ld MB)",
 556                         cMiB/100 , cMiB % 100,
 557                         cMB/100, cMB % 100);
 558         } else {
 559                 long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2;
 560                 long cGB  = (bytes / (1000000000LL/200LL ) +1) /2;
 561                 snprintf(buf, sizeof(buf), " (%ld.%02ld GiB %ld.%02ld GB)",
 562                         cGiB/100 , cGiB % 100,
 563                         cGB/100, cGB % 100);
 564         }
 565         return buf;
 566 }
 567
 568 char *human_size_brief(long long bytes)
 569 {
 570         static char buf[30];
 571
 572
 573         if (bytes < 5000*1024)
 574                 snprintf(buf, sizeof(buf), "%ld.%02ldKiB",
 575                         (long)(bytes>>10), (long)(((bytes&1023)*100+512)/1024)
 576                         );
 577         else if (bytes < 2*1024LL*1024LL*1024LL)
 578                 snprintf(buf, sizeof(buf), "%ld.%02ldMiB",
 579                         (long)(bytes>>20),
 580                         (long)((bytes&0xfffff)+0x100000/200)/(0x100000/100)
 581                         );
 582         else
 583                 snprintf(buf, sizeof(buf), "%ld.%02ldGiB",
 584                         (long)(bytes>>30),
 585                         (long)(((bytes>>10)&0xfffff)+0x100000/200)/(0x100000/100)
 586                         );
 587         return buf;
 588 }
 589
 590 int get_mdp_major(void)
 591 {
 592 static int mdp_major = -1;
 593         FILE *fl;
 594         char *w;
 595         int have_block = 0;
 596         int have_devices = 0;
 597         int last_num = -1;
 598
 599         if (mdp_major != -1)
 600                 return mdp_major;
 601         fl = fopen("/proc/devices", "r");
 602         if (!fl)
 603                 return -1;
 604         while ((w = conf_word(fl, 1))) {
 605                 if (have_block && strcmp(w, "devices:")==0)
 606                         have_devices = 1;
 607                 have_block =  (strcmp(w, "Block")==0);
 608                 if (isdigit(w[0]))
 609                         last_num = atoi(w);
 610                 if (have_devices && strcmp(w, "mdp")==0)
 611                         mdp_major = last_num;
 612                 free(w);
 613         }
 614         fclose(fl);
 615         return mdp_major;
 616 }
 617
 618
 619
 620 char *get_md_name(int dev)
 621 {
 622         /* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
 623         /* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
 624         static char devname[50];
 625         struct stat stb;
 626         dev_t rdev;
 627         char *dn;
 628
 629         if (dev < 0) {
 630                 int mdp =  get_mdp_major();
 631                 if (mdp < 0) return NULL;
 632                 rdev = makedev(mdp, (-1-dev)<<6);
 633                 snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev);
 634                 if (stat(devname, &stb) == 0
 635                     && (S_IFMT&stb.st_mode) == S_IFBLK
 636                     && (stb.st_rdev == rdev))
 637                         return devname;
 638         } else {
 639                 rdev = makedev(MD_MAJOR, dev);
 640                 snprintf(devname, sizeof(devname), "/dev/md%d", dev);
 641                 if (stat(devname, &stb) == 0
 642                     && (S_IFMT&stb.st_mode) == S_IFBLK
 643                     && (stb.st_rdev == rdev))
 644                         return devname;
 645
 646                 snprintf(devname, sizeof(devname), "/dev/md/%d", dev);
 647                 if (stat(devname, &stb) == 0
 648                     && (S_IFMT&stb.st_mode) == S_IFBLK
 649                     && (stb.st_rdev == rdev))
 650                         return devname;
 651         }
 652         dn = map_dev(major(rdev), minor(rdev), 0);
 653         if (dn)
 654                 return dn;
 655         snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev);
 656         if (mknod(devname, S_IFBLK | 0600, rdev) == -1)
 657                 if (errno != EEXIST)
 658                         return NULL;
 659
 660         if (stat(devname, &stb) == 0
 661             && (S_IFMT&stb.st_mode) == S_IFBLK
 662             && (stb.st_rdev == rdev))
 663                 return devname;
 664         unlink(devname);
 665         return NULL;
 666 }
 667
 668 void put_md_name(char *name)
 669 {
 670         if (strncmp(name, "/dev/.tmp.md", 12)==0)
 671                 unlink(name);
 672 }
 673
 674 int dev_open(char *dev, int flags)
 675 {
 676         /* like 'open', but if 'dev' matches %d:%d, create a temp
 677          * block device and open that
 678          */
 679         char *e;
 680         int fd = -1;
 681         char devname[32];
 682         int major;
 683         int minor;
 684
 685         if (!dev) return -1;
 686
 687         major = strtoul(dev, &e, 0);
 688         if (e > dev && *e == ':' && e[1] &&
 689             (minor = strtoul(e+1, &e, 0)) >= 0 &&
 690             *e == 0) {
 691                 snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d", major, minor);
 692                 if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) {
 693                         fd = open(devname, flags);
 694                         unlink(devname);
 695                 }
 696         } else
 697                 fd = open(dev, flags);
 698         return fd;
 699 }
 700
 701 struct superswitch *superlist[] = { &super0, &super1, NULL };
 702
 703 struct supertype *super_by_version(int vers, int minor)
 704 {
 705         struct supertype *st = malloc(sizeof(*st));
 706         if (!st) return st;
 707         if (vers == 0) {
 708                 st->ss = &super0;
 709                 st->max_devs = MD_SB_DISKS;
 710         }
 711
 712         if (vers == 1) {
 713                 st->ss = &super1;
 714                 st->max_devs = 384;
 715         }
 716         st->minor_version = minor;
 717         return st;
 718 }
 719
 720 struct supertype *guess_super(int fd)
 721 {
 722         /* try each load_super to find the best match,
 723          * and return the best superswitch
 724          */
 725         struct superswitch  *ss;
 726         struct supertype *st;
 727         unsigned long besttime = 0;
 728         int bestsuper = -1;
 729
 730         void *sbp = NULL;
 731         int i;
 732
 733         st = malloc(sizeof(*st));
 734         memset(st, 0, sizeof(*st));
 735         for (i=0 ; superlist[i]; i++) {
 736                 int rv;
 737                 ss = superlist[i];
 738                 st->ss = NULL;
 739                 rv = ss->load_super(st, fd, &sbp, NULL);
 740                 if (rv == 0) {
 741                         struct mdinfo info;
 742                         ss->getinfo_super(&info, sbp);
 743                         if (bestsuper == -1 ||
 744                             besttime < info.array.ctime) {
 745                                 bestsuper = i;
 746                                 besttime = info.array.ctime;
 747                         }
 748                         free(sbp);
 749                 }
 750         }
 751         if (bestsuper != -1) {
 752                 int rv;
 753                 st->ss = NULL;
 754                 rv = superlist[bestsuper]->load_super(st, fd, &sbp, NULL);
 755                 if (rv == 0) {
 756                         free(sbp);
 757                         return st;
 758                 }
 759         }
 760         free(st);
 761         return NULL;
 762 }
 763
 764
 765 #ifdef __TINYC__
 766 /* tinyc doesn't optimize this check in ioctl.h out ... */
 767 unsigned int __invalid_size_argument_for_IOC = 0;
 768 #endif
 769