Create.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2013 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_u.h"
  27 #include        "md_p.h"
  28 #include        <ctype.h>
  29
  30 static int default_layout(struct supertype *st, int level, int verbose)
  31 {
  32         int layout = UnSet;
  33
  34         if (st && st->ss->default_geometry)
  35                 st->ss->default_geometry(st, &level, &layout, NULL);
  36
  37         if (layout == UnSet)
  38                 switch(level) {
  39                 default: /* no layout */
  40                         layout = 0;
  41                         break;
  42                 case 10:
  43                         layout = 0x102; /* near=2, far=1 */
  44                         if (verbose > 0)
  45                                 pr_err("layout defaults to n2\n");
  46                         break;
  47                 case 5:
  48                 case 6:
  49                         layout = map_name(r5layout, "default");
  50                         if (verbose > 0)
  51                                 pr_err("layout defaults to %s\n", map_num(r5layout, layout));
  52                         break;
  53                 case LEVEL_FAULTY:
  54                         layout = map_name(faultylayout, "default");
  55
  56                         if (verbose > 0)
  57                                 pr_err("layout defaults to %s\n", map_num(faultylayout, layout));
  58                         break;
  59                 }
  60
  61         return layout;
  62 }
  63
  64 int Create(struct supertype *st, char *mddev,
  65            char *name, int *uuid,
  66            int subdevs, struct mddev_dev *devlist,
  67            struct shape *s,
  68            struct context *c, unsigned long long data_offset)
  69 {
  70         /*
  71          * Create a new raid array.
  72          *
  73          * First check that necessary details are available
  74          * (i.e. level, raid-disks)
  75          *
  76          * Then check each disk to see what might be on it
  77          * and report anything interesting.
  78          *
  79          * If anything looks odd, and runstop not set,
  80          * abort.
  81          *
  82          * SET_ARRAY_INFO and ADD_NEW_DISK, and
  83          * if runstop==run, or raiddisks disks were used,
  84          * RUN_ARRAY
  85          */
  86         int mdfd;
  87         unsigned long long minsize=0, maxsize=0;
  88         char *mindisc = NULL;
  89         char *maxdisc = NULL;
  90         int dnum, raid_disk_num;
  91         struct mddev_dev *dv;
  92         int fail=0, warn=0;
  93         struct stat stb;
  94         int first_missing = subdevs * 2;
  95         int second_missing = subdevs * 2;
  96         int missing_disks = 0;
  97         int insert_point = subdevs * 2; /* where to insert a missing drive */
  98         int total_slots;
  99         int pass;
 100         int vers;
 101         int rv;
 102         int bitmap_fd;
 103         int have_container = 0;
 104         int container_fd = -1;
 105         int need_mdmon = 0;
 106         unsigned long long bitmapsize;
 107         struct mdinfo info, *infos;
 108         int did_default = 0;
 109         int do_default_layout = 0;
 110         int do_default_chunk = 0;
 111         unsigned long safe_mode_delay = 0;
 112         char chosen_name[1024];
 113         struct map_ent *map = NULL;
 114         unsigned long long newsize;
 115
 116         int major_num = BITMAP_MAJOR_HI;
 117         if (s->bitmap_file && strcmp(s->bitmap_file, "clustered") == 0) {
 118                 major_num = BITMAP_MAJOR_CLUSTERED;
 119                 if (c->nodes <= 1) {
 120                         pr_err("At least 2 nodes are needed for cluster-md\n");
 121                         return 1;
 122                 }
 123         }
 124
 125         memset(&info, 0, sizeof(info));
 126         if (s->level == UnSet && st && st->ss->default_geometry)
 127                 st->ss->default_geometry(st, &s->level, NULL, NULL);
 128         if (s->level == UnSet) {
 129                 pr_err("a RAID level is needed to create an array.\n");
 130                 return 1;
 131         }
 132         if (s->raiddisks < 4 && s->level == 6) {
 133                 pr_err("at least 4 raid-devices needed for level 6\n");
 134                 return 1;
 135         }
 136         if (s->raiddisks > 256 && s->level == 6) {
 137                 pr_err("no more than 256 raid-devices supported for level 6\n");
 138                 return 1;
 139         }
 140         if (s->raiddisks < 2 && s->level >= 4) {
 141                 pr_err("at least 2 raid-devices needed for level 4 or 5\n");
 142                 return 1;
 143         }
 144         if (s->level <= 0 && s->sparedisks) {
 145                 pr_err("This level does not support spare devices\n");
 146                 return 1;
 147         }
 148
 149         if (subdevs == 1 && strcmp(devlist->devname, "missing") != 0) {
 150                 /* If given a single device, it might be a container, and we can
 151                  * extract a device list from there
 152                  */
 153                 mdu_array_info_t inf;
 154                 int fd;
 155
 156                 memset(&inf, 0, sizeof(inf));
 157                 fd = open(devlist->devname, O_RDONLY);
 158                 if (fd >= 0 &&
 159                     ioctl(fd, GET_ARRAY_INFO, &inf) == 0 &&
 160                     inf.raid_disks == 0) {
 161                         /* yep, looks like a container */
 162                         if (st) {
 163                                 rv = st->ss->load_container(st, fd,
 164                                                             devlist->devname);
 165                                 if (rv == 0)
 166                                         have_container = 1;
 167                         } else {
 168                                 st = super_by_fd(fd, NULL);
 169                                 if (st && !(rv = st->ss->
 170                                             load_container(st, fd,
 171                                                            devlist->devname)))
 172                                         have_container = 1;
 173                                 else
 174                                         st = NULL;
 175                         }
 176                         if (have_container) {
 177                                 subdevs = s->raiddisks;
 178                                 first_missing = subdevs * 2;
 179                                 second_missing = subdevs * 2;
 180                                 insert_point = subdevs * 2;
 181                         }
 182                 }
 183                 if (fd >= 0)
 184                         close(fd);
 185         }
 186         if (st && st->ss->external && s->sparedisks) {
 187                 pr_err("This metadata type does not support spare disks at create time\n");
 188                 return 1;
 189         }
 190         if (subdevs > s->raiddisks+s->sparedisks+s->journaldisks) {
 191                 pr_err("You have listed more devices (%d) than are in the array(%d)!\n", subdevs, s->raiddisks+s->sparedisks);
 192                 return 1;
 193         }
 194         if (!have_container && subdevs < s->raiddisks+s->sparedisks+s->journaldisks) {
 195                 pr_err("You haven't given enough devices (real or missing) to create this array\n");
 196                 return 1;
 197         }
 198         if (s->bitmap_file && s->level <= 0) {
 199                 pr_err("bitmaps not meaningful with level %s\n",
 200                         map_num(pers, s->level)?:"given");
 201                 return 1;
 202         }
 203
 204         /* now set some defaults */
 205
 206         if (s->layout == UnSet) {
 207                 do_default_layout = 1;
 208                 s->layout = default_layout(st, s->level, c->verbose);
 209         }
 210
 211         if (s->level == 10)
 212                 /* check layout fits in array*/
 213                 if ((s->layout&255) * ((s->layout>>8)&255) > s->raiddisks) {
 214                         pr_err("that layout requires at least %d devices\n",
 215                                 (s->layout&255) * ((s->layout>>8)&255));
 216                         return 1;
 217                 }
 218
 219         switch(s->level) {
 220         case 4:
 221         case 5:
 222         case 10:
 223         case 6:
 224         case 0:
 225                 if (s->chunk == 0 || s->chunk == UnSet) {
 226                         s->chunk = UnSet;
 227                         do_default_chunk = 1;
 228                         /* chunk will be set later */
 229                 }
 230                 break;
 231         case LEVEL_LINEAR:
 232                 /* a chunksize of zero 0s perfectly valid (and preferred) since 2.6.16 */
 233                 if (get_linux_version() < 2006016 && s->chunk == 0) {
 234                         s->chunk = 64;
 235                         if (c->verbose > 0)
 236                                 pr_err("chunk size defaults to 64K\n");
 237                 }
 238                 break;
 239         case 1:
 240         case LEVEL_FAULTY:
 241         case LEVEL_MULTIPATH:
 242         case LEVEL_CONTAINER:
 243                 if (s->chunk) {
 244                         s->chunk = 0;
 245                         if (c->verbose > 0)
 246                                 pr_err("chunk size ignored for this level\n");
 247                 }
 248                 break;
 249         default:
 250                 pr_err("unknown level %d\n", s->level);
 251                 return 1;
 252         }
 253         if (s->size == MAX_SIZE)
 254                 /* use '0' to mean 'max' now... */
 255                 s->size = 0;
 256         if (s->size && s->chunk && s->chunk != UnSet)
 257                 s->size &= ~(unsigned long long)(s->chunk - 1);
 258         newsize = s->size * 2;
 259         if (st && ! st->ss->validate_geometry(st, s->level, s->layout, s->raiddisks,
 260                                               &s->chunk, s->size*2,
 261                                               data_offset, NULL,
 262                                               &newsize, c->verbose>=0))
 263                 return 1;
 264
 265         if (s->chunk && s->chunk != UnSet) {
 266                 newsize &= ~(unsigned long long)(s->chunk*2 - 1);
 267                 if (do_default_chunk) {
 268                         /* default chunk was just set */
 269                         if (c->verbose > 0)
 270                                 pr_err("chunk size defaults to %dK\n", s->chunk);
 271                         s->size &= ~(unsigned long long)(s->chunk - 1);
 272                         do_default_chunk = 0;
 273                 }
 274         }
 275
 276         if (s->size == 0) {
 277                 s->size = newsize / 2;
 278                 if (s->level == 1)
 279                         /* If this is ever reshaped to RAID5, we will
 280                          * need a chunksize.  So round it off a bit
 281                          * now just to be safe
 282                          */
 283                         s->size &= ~(64ULL-1);
 284
 285                 if (s->size && c->verbose > 0)
 286                         pr_err("setting size to %lluK\n", s->size);
 287         }
 288
 289         /* now look at the subdevs */
 290         info.array.active_disks = 0;
 291         info.array.working_disks = 0;
 292         dnum = 0;
 293         for (dv = devlist; dv ; dv = dv->next)
 294                 if (data_offset == VARIABLE_OFFSET)
 295                         dv->data_offset = INVALID_SECTORS;
 296                 else
 297                         dv->data_offset = data_offset;
 298
 299         for (dv=devlist; dv && !have_container; dv=dv->next, dnum++) {
 300                 char *dname = dv->devname;
 301                 unsigned long long freesize;
 302                 int dfd;
 303                 char *doff;
 304
 305                 if (strcasecmp(dname, "missing")==0) {
 306                         if (first_missing > dnum)
 307                                 first_missing = dnum;
 308                         if (second_missing > dnum && dnum > first_missing)
 309                                 second_missing = dnum;
 310                         missing_disks ++;
 311                         continue;
 312                 }
 313                 if (data_offset == VARIABLE_OFFSET) {
 314                         doff = strchr(dname, ':');
 315                         if (doff) {
 316                                 *doff++ = 0;
 317                                 dv->data_offset = parse_size(doff);
 318                         } else
 319                                 dv->data_offset = INVALID_SECTORS;
 320                 } else
 321                         dv->data_offset = data_offset;
 322
 323                 dfd = open(dname, O_RDONLY);
 324                 if (dfd < 0) {
 325                         pr_err("cannot open %s: %s\n",
 326                                 dname, strerror(errno));
 327                         exit(2);
 328                 }
 329                 if (fstat(dfd, &stb) != 0 ||
 330                     (stb.st_mode & S_IFMT) != S_IFBLK) {
 331                         close(dfd);
 332                         pr_err("%s is not a block device\n",
 333                                 dname);
 334                         exit(2);
 335                 }
 336                 close(dfd);
 337                 info.array.working_disks++;
 338                 if (dnum < s->raiddisks && dv->disposition != 'j')
 339                         info.array.active_disks++;
 340                 if (st == NULL) {
 341                         struct createinfo *ci = conf_get_create_info();
 342                         if (ci)
 343                                 st = ci->supertype;
 344                 }
 345                 if (st == NULL) {
 346                         /* Need to choose a default metadata, which is different
 347                          * depending on geometry of array.
 348                          */
 349                         int i;
 350                         char *name = "default";
 351                         for(i=0; !st && superlist[i]; i++) {
 352                                 st = superlist[i]->match_metadata_desc(name);
 353                                 if (!st)
 354                                         continue;
 355                                 if (do_default_layout)
 356                                         s->layout = default_layout(st, s->level, c->verbose);
 357                                 switch (st->ss->validate_geometry(
 358                                                 st, s->level, s->layout, s->raiddisks,
 359                                                 &s->chunk, s->size*2,
 360                                                 dv->data_offset, dname,
 361                                                 &freesize, c->verbose > 0)) {
 362                                 case -1: /* Not valid, message printed, and not
 363                                           * worth checking any further */
 364                                         exit(2);
 365                                         break;
 366                                 case 0: /* Geometry not valid */
 367                                         free(st);
 368                                         st = NULL;
 369                                         s->chunk = do_default_chunk ? UnSet : s->chunk;
 370                                         break;
 371                                 case 1: /* All happy */
 372                                         break;
 373                                 }
 374                         }
 375
 376                         if (!st) {
 377                                 int dfd = open(dname, O_RDONLY|O_EXCL);
 378                                 if (dfd < 0) {
 379                                         pr_err("cannot open %s: %s\n",
 380                                                 dname, strerror(errno));
 381                                         exit(2);
 382                                 }
 383                                 pr_err("device %s not suitable for any style of array\n",
 384                                         dname);
 385                                 exit(2);
 386                         }
 387                         if (st->ss != &super0 ||
 388                             st->minor_version != 90)
 389                                 did_default = 1;
 390                 } else {
 391                         if (do_default_layout)
 392                                 s->layout = default_layout(st, s->level, 0);
 393                         if (!st->ss->validate_geometry(st, s->level, s->layout,
 394                                                        s->raiddisks,
 395                                                        &s->chunk, s->size*2,
 396                                                        dv->data_offset,
 397                                                        dname, &freesize,
 398                                                        c->verbose >= 0)) {
 399
 400                                 pr_err("%s is not suitable for this array.\n",
 401                                        dname);
 402                                 fail = 1;
 403                                 continue;
 404                         }
 405                 }
 406
 407                 if (dv->disposition == 'j')
 408                         goto skip_size_check;  /* skip write journal for size check */
 409
 410                 freesize /= 2; /* convert to K */
 411                 if (s->chunk && s->chunk != UnSet) {
 412                         /* round to chunk size */
 413                         freesize = freesize & ~(s->chunk-1);
 414                         if (do_default_chunk) {
 415                                 /* default chunk was just set */
 416                                 if (c->verbose > 0)
 417                                         pr_err("chunk size defaults to %dK\n", s->chunk);
 418                                 s->size &= ~(unsigned long long)(s->chunk - 1);
 419                                 do_default_chunk = 0;
 420                         }
 421                 }
 422                 if (!freesize) {
 423                         pr_err("no free space left on %s\n", dname);
 424                         fail = 1;
 425                         continue;
 426                 }
 427
 428                 if (s->size && freesize < s->size) {
 429                         pr_err("%s is smaller than given size. %lluK < %lluK + metadata\n",
 430                                 dname, freesize, s->size);
 431                         fail = 1;
 432                         continue;
 433                 }
 434                 if (maxdisc == NULL || (maxdisc && freesize > maxsize)) {
 435                         maxdisc = dname;
 436                         maxsize = freesize;
 437                 }
 438                 if (mindisc ==NULL || (mindisc && freesize < minsize)) {
 439                         mindisc = dname;
 440                         minsize = freesize;
 441                 }
 442         skip_size_check:
 443                 if (c->runstop != 1 || c->verbose >= 0) {
 444                         int fd = open(dname, O_RDONLY);
 445                         if (fd <0 ) {
 446                                 pr_err("Cannot open %s: %s\n",
 447                                         dname, strerror(errno));
 448                                 fail=1;
 449                                 continue;
 450                         }
 451                         warn |= check_ext2(fd, dname);
 452                         warn |= check_reiser(fd, dname);
 453                         warn |= check_raid(fd, dname);
 454                         if (strcmp(st->ss->name, "1.x") == 0 &&
 455                             st->minor_version >= 1)
 456                                 /* metadata at front */
 457                                 warn |= check_partitions(fd, dname, 0, 0);
 458                         else if (s->level == 1 || s->level == LEVEL_CONTAINER
 459                                     || (s->level == 0 && s->raiddisks == 1))
 460                                 /* partitions could be meaningful */
 461                                 warn |= check_partitions(fd, dname, freesize*2, s->size*2);
 462                         else
 463                                 /* partitions cannot be meaningful */
 464                                 warn |= check_partitions(fd, dname, 0, 0);
 465                         if (strcmp(st->ss->name, "1.x") == 0 &&
 466                             st->minor_version >= 1 &&
 467                             did_default &&
 468                             s->level == 1 &&
 469                             (warn & 1024) == 0) {
 470                                 warn |= 1024;
 471                                 pr_err("Note: this array has metadata at the start and\n"
 472                                         "    may not be suitable as a boot device.  If you plan to\n"
 473                                         "    store '/boot' on this device please ensure that\n"
 474                                         "    your boot-loader understands md/v1.x metadata, or use\n"
 475                                         "    --metadata=0.90\n");
 476                         }
 477                         close(fd);
 478                 }
 479         }
 480         if (s->raiddisks + s->sparedisks > st->max_devs) {
 481                 pr_err("Too many devices: %s metadata only supports %d\n",
 482                         st->ss->name, st->max_devs);
 483                 return 1;
 484         }
 485         if (have_container)
 486                 info.array.working_disks = s->raiddisks;
 487         if (fail) {
 488                 pr_err("create aborted\n");
 489                 return 1;
 490         }
 491         if (s->size == 0) {
 492                 if (mindisc == NULL && !have_container) {
 493                         pr_err("no size and no drives given - aborting create.\n");
 494                         return 1;
 495                 }
 496                 if (s->level > 0 || s->level == LEVEL_MULTIPATH
 497                     || s->level == LEVEL_FAULTY
 498                     || st->ss->external ) {
 499                         /* size is meaningful */
 500                         if (!st->ss->validate_geometry(st, s->level, s->layout,
 501                                                        s->raiddisks,
 502                                                        &s->chunk, minsize*2,
 503                                                        data_offset,
 504                                                        NULL, NULL, 0)) {
 505                                 pr_err("devices too large for RAID level %d\n", s->level);
 506                                 return 1;
 507                         }
 508                         s->size = minsize;
 509                         if (s->level == 1)
 510                                 /* If this is ever reshaped to RAID5, we will
 511                                  * need a chunksize.  So round it off a bit
 512                                  * now just to be safe
 513                                  */
 514                                 s->size &= ~(64ULL-1);
 515                         if (c->verbose > 0)
 516                                 pr_err("size set to %lluK\n", s->size);
 517                 }
 518         }
 519
 520         if (!s->bitmap_file &&
 521             s->level >= 1 &&
 522             st->ss->add_internal_bitmap &&
 523             (s->write_behind || s->size > 100*1024*1024ULL)) {
 524                 if (c->verbose > 0)
 525                         pr_err("automatically enabling write-intent bitmap on large array\n");
 526                 s->bitmap_file = "internal";
 527         }
 528         if (s->bitmap_file && strcmp(s->bitmap_file, "none") == 0)
 529                 s->bitmap_file = NULL;
 530
 531         if (!have_container && s->level > 0 && ((maxsize-s->size)*100 > maxsize)) {
 532                 if (c->runstop != 1 || c->verbose >= 0)
 533                         pr_err("largest drive (%s) exceeds size (%lluK) by more than 1%%\n",
 534                                 maxdisc, s->size);
 535                 warn = 1;
 536         }
 537
 538         if (st->ss->detail_platform && st->ss->detail_platform(0, 1, NULL) != 0) {
 539                 if (c->runstop != 1 || c->verbose >= 0)
 540                         pr_err("%s unable to enumerate platform support\n"
 541                                 "    array may not be compatible with hardware/firmware\n",
 542                                 st->ss->name);
 543                 warn = 1;
 544         }
 545         st->nodes = c->nodes;
 546         st->cluster_name = c->homecluster;
 547
 548         if (warn) {
 549                 if (c->runstop!= 1) {
 550                         if (!ask("Continue creating array? ")) {
 551                                 pr_err("create aborted.\n");
 552                                 return 1;
 553                         }
 554                 } else {
 555                         if (c->verbose > 0)
 556                                 pr_err("creation continuing despite oddities due to --run\n");
 557                 }
 558         }
 559
 560         /* If this is raid4/5, we want to configure the last active slot
 561          * as missing, so that a reconstruct happens (faster than re-parity)
 562          * FIX: Can we do this for raid6 as well?
 563          */
 564         if (st->ss->external == 0 &&
 565             s->assume_clean==0 && c->force == 0 && first_missing >= s->raiddisks) {
 566                 switch ( s->level ) {
 567                 case 4:
 568                 case 5:
 569                         insert_point = s->raiddisks-1;
 570                         s->sparedisks++;
 571                         info.array.active_disks--;
 572                         missing_disks++;
 573                         break;
 574                 default:
 575                         break;
 576                 }
 577         }
 578         /* For raid6, if creating with 1 missing drive, make a good drive
 579          * into a spare, else the create will fail
 580          */
 581         if (s->assume_clean == 0 && c->force == 0 && first_missing < s->raiddisks &&
 582             st->ss->external == 0 &&
 583             second_missing >= s->raiddisks && s->level == 6) {
 584                 insert_point = s->raiddisks - 1;
 585                 if (insert_point == first_missing)
 586                         insert_point--;
 587                 s->sparedisks ++;
 588                 info.array.active_disks--;
 589                 missing_disks++;
 590         }
 591
 592         if (s->level <= 0 && first_missing < subdevs * 2) {
 593                 pr_err("This level does not support missing devices\n");
 594                 return 1;
 595         }
 596
 597         /* We need to create the device */
 598         map_lock(&map);
 599         mdfd = create_mddev(mddev, name, c->autof, LOCAL, chosen_name);
 600         if (mdfd < 0) {
 601                 map_unlock(&map);
 602                 return 1;
 603         }
 604         /* verify if chosen_name is not in use,
 605          * it could be in conflict with already existing device
 606          * e.g. container, array
 607          */
 608         if (strncmp(chosen_name, "/dev/md/", 8) == 0
 609             && map_by_name(&map, chosen_name+8) != NULL) {
 610                 pr_err("Array name %s is in use already.\n",
 611                         chosen_name);
 612                 close(mdfd);
 613                 map_unlock(&map);
 614                 return 1;
 615         }
 616         mddev = chosen_name;
 617
 618         vers = md_get_version(mdfd);
 619         if (vers < 9000) {
 620                 pr_err("Create requires md driver version 0.90.0 or later\n");
 621                 goto abort_locked;
 622         } else {
 623                 mdu_array_info_t inf;
 624                 memset(&inf, 0, sizeof(inf));
 625                 ioctl(mdfd, GET_ARRAY_INFO, &inf);
 626                 if (inf.working_disks != 0) {
 627                         pr_err("another array by this name is already running.\n");
 628                         goto abort_locked;
 629                 }
 630         }
 631
 632         /* Ok, lets try some ioctls */
 633
 634         info.array.level = s->level;
 635         info.array.size = s->size;
 636         info.array.raid_disks = s->raiddisks;
 637         /* The kernel should *know* what md_minor we are dealing
 638          * with, but it chooses to trust me instead. Sigh
 639          */
 640         info.array.md_minor = 0;
 641         if (fstat(mdfd, &stb)==0)
 642                 info.array.md_minor = minor(stb.st_rdev);
 643         info.array.not_persistent = 0;
 644
 645         if ( ( (s->level == 4 || s->level == 5) &&
 646                (insert_point < s->raiddisks || first_missing < s->raiddisks) )
 647              ||
 648              ( s->level == 6 && (insert_point < s->raiddisks
 649                               || second_missing < s->raiddisks))
 650              ||
 651              ( s->level <= 0 )
 652              ||
 653              s->assume_clean
 654                 ) {
 655                 info.array.state = 1; /* clean, but one+ drive will be missing*/
 656                 info.resync_start = MaxSector;
 657         } else {
 658                 info.array.state = 0; /* not clean, but no errors */
 659                 info.resync_start = 0;
 660         }
 661         if (s->level == 10) {
 662                 /* for raid10, the bitmap size is the capacity of the array,
 663                  * which is array.size * raid_disks / ncopies;
 664                  * .. but convert to sectors.
 665                  */
 666                 int ncopies = ((s->layout>>8) & 255) * (s->layout & 255);
 667                 bitmapsize = s->size * s->raiddisks / ncopies * 2;
 668 /*              printf("bms=%llu as=%d rd=%d nc=%d\n", bitmapsize, s->size, s->raiddisks, ncopies);*/
 669         } else
 670                 bitmapsize = s->size * 2;
 671
 672         /* There is lots of redundancy in these disk counts,
 673          * raid_disks is the most meaningful value
 674          *          it describes the geometry of the array
 675          *          it is constant
 676          * nr_disks is total number of used slots.
 677          *          it should be raid_disks+spare_disks
 678          * spare_disks is the number of extra disks present
 679          *          see above
 680          * active_disks is the number of working disks in
 681          *          active slots. (With raid_disks)
 682          * working_disks is the total number of working disks,
 683          *          including spares
 684          * failed_disks is the number of disks marked failed
 685          *
 686          * Ideally, the kernel would keep these (except raid_disks)
 687          * up-to-date as we ADD_NEW_DISK, but it doesn't (yet).
 688          * So for now, we assume that all raid and spare
 689          * devices will be given.
 690          */
 691         info.array.spare_disks=s->sparedisks;
 692         info.array.failed_disks=missing_disks;
 693         info.array.nr_disks = info.array.working_disks
 694                 + info.array.failed_disks;
 695         info.array.layout = s->layout;
 696         info.array.chunk_size = s->chunk*1024;
 697
 698         if (name == NULL || *name == 0) {
 699                 /* base name on mddev */
 700                 /*  /dev/md0 -> 0
 701                  *  /dev/md_d0 -> d0
 702                  *  /dev/md_foo -> foo
 703                  *  /dev/md/1 -> 1
 704                  *  /dev/md/d1 -> d1
 705                  *  /dev/md/home -> home
 706                  *  /dev/mdhome -> home
 707                  */
 708                 /* FIXME compare this with rules in create_mddev */
 709                 name = strrchr(mddev, '/');
 710                 if (name) {
 711                         name++;
 712                         if (strncmp(name, "md_", 3)==0 &&
 713                             strlen(name) > 3 &&
 714                             (name-mddev) == 5 /* /dev/ */)
 715                                 name += 3;
 716                         else if (strncmp(name, "md", 2)==0 &&
 717                                  strlen(name) > 2 &&
 718                                  isdigit(name[2]) &&
 719                                  (name-mddev) == 5 /* /dev/ */)
 720                                 name += 2;
 721                 }
 722         }
 723         if (!st->ss->init_super(st, &info.array, s->size, name, c->homehost, uuid,
 724                                 data_offset))
 725                 goto abort_locked;
 726
 727         total_slots = info.array.nr_disks;
 728         st->ss->getinfo_super(st, &info, NULL);
 729         sysfs_init(&info, mdfd, NULL);
 730
 731         if (did_default && c->verbose >= 0) {
 732                 if (is_subarray(info.text_version)) {
 733                         char devnm[32];
 734                         char *ep;
 735                         struct mdinfo *mdi;
 736
 737                         strncpy(devnm, info.text_version+1, 32);
 738                         devnm[31] = 0;
 739                         ep = strchr(devnm, '/');
 740                         if (ep)
 741                                 *ep = 0;
 742
 743                         mdi = sysfs_read(-1, devnm, GET_VERSION);
 744
 745                         pr_err("Creating array inside %s container %s\n",
 746                                 mdi?mdi->text_version:"managed", devnm);
 747                         sysfs_free(mdi);
 748                 } else
 749                         pr_err("Defaulting to version %s metadata\n", info.text_version);
 750         }
 751
 752         map_update(&map, fd2devnm(mdfd), info.text_version,
 753                    info.uuid, chosen_name);
 754         /* Keep map locked until devices have been added to array
 755          * to stop another mdadm from finding and using those devices.
 756          */
 757
 758         if (s->bitmap_file && vers < 9003) {
 759                 major_num = BITMAP_MAJOR_HOSTENDIAN;
 760 #ifdef __BIG_ENDIAN
 761                 pr_err("Warning - bitmaps created on this kernel are not portable\n"
 762                         "  between different architectured.  Consider upgrading the Linux kernel.\n");
 763 #endif
 764         }
 765
 766         if (s->bitmap_file && (strcmp(s->bitmap_file, "internal")==0 ||
 767                                strcmp(s->bitmap_file, "clustered")==0)) {
 768                 if ((vers%100) < 2) {
 769                         pr_err("internal bitmaps not supported by this kernel.\n");
 770                         goto abort_locked;
 771                 }
 772                 if (!st->ss->add_internal_bitmap) {
 773                         pr_err("internal bitmaps not supported with %s metadata\n",
 774                                 st->ss->name);
 775                         goto abort_locked;
 776                 }
 777                 if (st->ss->add_internal_bitmap(st, &s->bitmap_chunk,
 778                                                 c->delay, s->write_behind,
 779                                                 bitmapsize, 1, major_num)) {
 780                         pr_err("Given bitmap chunk size not supported.\n");
 781                         goto abort_locked;
 782                 }
 783                 s->bitmap_file = NULL;
 784         }
 785
 786         sysfs_init(&info, mdfd, NULL);
 787
 788         if (st->ss->external && st->container_devnm[0]) {
 789                 /* member */
 790
 791                 /* When creating a member, we need to be careful
 792                  * to negotiate with mdmon properly.
 793                  * If it is already running, we cannot write to
 794                  * the devices and must ask it to do that part.
 795                  * If it isn't running, we write to the devices,
 796                  * and then start it.
 797                  * We hold an exclusive open on the container
 798                  * device to make sure mdmon doesn't exit after
 799                  * we checked that it is running.
 800                  *
 801                  * For now, fail if it is already running.
 802                  */
 803                 container_fd = open_dev_excl(st->container_devnm);
 804                 if (container_fd < 0) {
 805                         pr_err("Cannot get exclusive open on container - weird.\n");
 806                         goto abort_locked;
 807                 }
 808                 if (mdmon_running(st->container_devnm)) {
 809                         if (c->verbose)
 810                                 pr_err("reusing mdmon for %s.\n",
 811                                         st->container_devnm);
 812                         st->update_tail = &st->updates;
 813                 } else
 814                         need_mdmon = 1;
 815         }
 816         rv = set_array_info(mdfd, st, &info);
 817         if (rv) {
 818                 pr_err("failed to set array info for %s: %s\n",
 819                         mddev, strerror(errno));
 820                 goto abort_locked;
 821         }
 822
 823         if (s->bitmap_file) {
 824                 int uuid[4];
 825
 826                 st->ss->uuid_from_super(st, uuid);
 827                 if (CreateBitmap(s->bitmap_file, c->force, (char*)uuid, s->bitmap_chunk,
 828                                  c->delay, s->write_behind,
 829                                  bitmapsize,
 830                                  major_num)) {
 831                         goto abort_locked;
 832                 }
 833                 bitmap_fd = open(s->bitmap_file, O_RDWR);
 834                 if (bitmap_fd < 0) {
 835                         pr_err("weird: %s cannot be openned\n",
 836                                 s->bitmap_file);
 837                         goto abort_locked;
 838                 }
 839                 if (ioctl(mdfd, SET_BITMAP_FILE, bitmap_fd) < 0) {
 840                         pr_err("Cannot set bitmap file for %s: %s\n",
 841                                 mddev, strerror(errno));
 842                         goto abort_locked;
 843                 }
 844         }
 845
 846         infos = xmalloc(sizeof(*infos) * total_slots);
 847         enable_fds(total_slots);
 848         for (pass=1; pass <=2 ; pass++) {
 849                 struct mddev_dev *moved_disk = NULL; /* the disk that was moved out of the insert point */
 850
 851                 for (dnum=0, raid_disk_num=0, dv = devlist ; dv ;
 852                      dv=(dv->next)?(dv->next):moved_disk, dnum++) {
 853                         int fd;
 854                         struct stat stb;
 855                         struct mdinfo *inf = &infos[dnum];
 856
 857                         if (dnum >= total_slots)
 858                                 abort();
 859                         if (dnum == insert_point) {
 860                                 raid_disk_num += 1;
 861                                 moved_disk = dv;
 862                                 continue;
 863                         }
 864                         if (strcasecmp(dv->devname, "missing")==0) {
 865                                 raid_disk_num += 1;
 866                                 continue;
 867                         }
 868                         if (have_container)
 869                                 moved_disk = NULL;
 870                         if (have_container && dnum < info.array.raid_disks - 1)
 871                                 /* repeatedly use the container */
 872                                 moved_disk = dv;
 873
 874                         switch(pass) {
 875                         case 1:
 876                                 *inf = info;
 877
 878                                 inf->disk.number = dnum;
 879                                 inf->disk.raid_disk = raid_disk_num++;
 880
 881                                 if (dv->disposition == 'j') {
 882                                         inf->disk.raid_disk = MD_DISK_ROLE_JOURNAL;
 883                                         inf->disk.state = (1<<MD_DISK_JOURNAL);
 884                                         raid_disk_num--;
 885                                 } else if (inf->disk.raid_disk < s->raiddisks)
 886                                         inf->disk.state = (1<<MD_DISK_ACTIVE) |
 887                                                 (1<<MD_DISK_SYNC);
 888                                 else
 889                                         inf->disk.state = 0;
 890
 891                                 if (dv->writemostly == FlagSet)
 892                                         inf->disk.state |= (1<<MD_DISK_WRITEMOSTLY);
 893                                 if (dv->failfast == FlagSet)
 894                                         inf->disk.state |= (1<<MD_DISK_FAILFAST);
 895
 896                                 if (have_container)
 897                                         fd = -1;
 898                                 else {
 899                                         if (st->ss->external &&
 900                                             st->container_devnm[0])
 901                                                 fd = open(dv->devname, O_RDWR);
 902                                         else
 903                                                 fd = open(dv->devname, O_RDWR|O_EXCL);
 904
 905                                         if (fd < 0) {
 906                                                 pr_err("failed to open %s after earlier success - aborting\n",
 907                                                         dv->devname);
 908                                                 goto abort_locked;
 909                                         }
 910                                         fstat(fd, &stb);
 911                                         inf->disk.major = major(stb.st_rdev);
 912                                         inf->disk.minor = minor(stb.st_rdev);
 913                                 }
 914                                 if (fd >= 0)
 915                                         remove_partitions(fd);
 916                                 if (st->ss->add_to_super(st, &inf->disk,
 917                                                          fd, dv->devname,
 918                                                          dv->data_offset)) {
 919                                         ioctl(mdfd, STOP_ARRAY, NULL);
 920                                         goto abort_locked;
 921                                 }
 922                                 st->ss->getinfo_super(st, inf, NULL);
 923                                 safe_mode_delay = inf->safe_mode_delay;
 924
 925                                 if (have_container && c->verbose > 0)
 926                                         pr_err("Using %s for device %d\n",
 927                                                 map_dev(inf->disk.major,
 928                                                         inf->disk.minor,
 929                                                         0), dnum);
 930
 931                                 if (!have_container) {
 932                                         /* getinfo_super might have lost these ... */
 933                                         inf->disk.major = major(stb.st_rdev);
 934                                         inf->disk.minor = minor(stb.st_rdev);
 935                                 }
 936                                 break;
 937                         case 2:
 938                                 inf->errors = 0;
 939
 940                                 rv = add_disk(mdfd, st, &info, inf);
 941
 942                                 if (rv) {
 943                                         pr_err("ADD_NEW_DISK for %s failed: %s\n",
 944                                                dv->devname, strerror(errno));
 945                                         goto abort_locked;
 946                                 }
 947                                 break;
 948                         }
 949                         if (!have_container &&
 950                             dv == moved_disk && dnum != insert_point) break;
 951                 }
 952                 if (pass == 1) {
 953                         struct mdinfo info_new;
 954                         struct map_ent *me = NULL;
 955
 956                         /* check to see if the uuid has changed due to these
 957                          * metadata changes, and if so update the member array
 958                          * and container uuid.  Note ->write_init_super clears
 959                          * the subarray cursor such that ->getinfo_super once
 960                          * again returns container info.
 961                          */
 962                         st->ss->getinfo_super(st, &info_new, NULL);
 963                         if (st->ss->external && s->level != LEVEL_CONTAINER &&
 964                             !same_uuid(info_new.uuid, info.uuid, 0)) {
 965                                 map_update(&map, fd2devnm(mdfd),
 966                                            info_new.text_version,
 967                                            info_new.uuid, chosen_name);
 968                                 me = map_by_devnm(&map, st->container_devnm);
 969                         }
 970
 971                         if (st->ss->write_init_super(st)) {
 972                                 st->ss->free_super(st);
 973                                 goto abort_locked;
 974                         }
 975
 976                         /* update parent container uuid */
 977                         if (me) {
 978                                 char *path = xstrdup(me->path);
 979
 980                                 st->ss->getinfo_super(st, &info_new, NULL);
 981                                 map_update(&map, st->container_devnm,
 982                                            info_new.text_version,
 983                                            info_new.uuid, path);
 984                                 free(path);
 985                         }
 986
 987                         flush_metadata_updates(st);
 988                         st->ss->free_super(st);
 989                 }
 990         }
 991         map_unlock(&map);
 992         free(infos);
 993
 994         if (s->level == LEVEL_CONTAINER) {
 995                 /* No need to start.  But we should signal udev to
 996                  * create links */
 997                 sysfs_uevent(&info, "change");
 998                 if (c->verbose >= 0)
 999                         pr_err("container %s prepared.\n", mddev);
1000                 wait_for(chosen_name, mdfd);
1001         } else if (c->runstop == 1 || subdevs >= s->raiddisks) {
1002                 if (st->ss->external) {
1003                         int err;
1004                         switch(s->level) {
1005                         case LEVEL_LINEAR:
1006                         case LEVEL_MULTIPATH:
1007                         case 0:
1008                                 err = sysfs_set_str(&info, NULL, "array_state",
1009                                                     c->readonly
1010                                                     ? "readonly"
1011                                                     : "active");
1012                                 need_mdmon = 0;
1013                                 break;
1014                         default:
1015                                 err = sysfs_set_str(&info, NULL, "array_state",
1016                                                     "readonly");
1017                                 break;
1018                         }
1019                         sysfs_set_safemode(&info, safe_mode_delay);
1020                         if (err) {
1021                                 pr_err("failed to activate array.\n");
1022                                 ioctl(mdfd, STOP_ARRAY, NULL);
1023                                 goto abort;
1024                         }
1025                 } else if (c->readonly &&
1026                            sysfs_attribute_available(
1027                                    &info, NULL, "array_state")) {
1028                         if (sysfs_set_str(&info, NULL,
1029                                           "array_state", "readonly") < 0) {
1030                                 pr_err("Failed to start array: %s\n",
1031                                        strerror(errno));
1032                                 ioctl(mdfd, STOP_ARRAY, NULL);
1033                                 goto abort;
1034                         }
1035                 } else {
1036                         /* param is not actually used */
1037                         mdu_param_t param;
1038                         if (ioctl(mdfd, RUN_ARRAY, &param)) {
1039                                 pr_err("RUN_ARRAY failed: %s\n",
1040                                        strerror(errno));
1041                                 if (info.array.chunk_size & (info.array.chunk_size-1)) {
1042                                         cont_err("Problem may be that chunk size is not a power of 2\n");
1043                                 }
1044                                 ioctl(mdfd, STOP_ARRAY, NULL);
1045                                 goto abort;
1046                         }
1047                         /* if start_ro module parameter is set, array is
1048                          * auto-read-only, which is bad as the resync won't
1049                          * start.  So lets make it read-write now.
1050                          */
1051                         ioctl(mdfd, RESTART_ARRAY_RW, NULL);
1052                 }
1053                 if (c->verbose >= 0)
1054                         pr_err("array %s started.\n", mddev);
1055                 if (st->ss->external && st->container_devnm[0]) {
1056                         if (need_mdmon)
1057                                 start_mdmon(st->container_devnm);
1058
1059                         ping_monitor(st->container_devnm);
1060                         close(container_fd);
1061                 }
1062                 wait_for(chosen_name, mdfd);
1063         } else {
1064                 pr_err("not starting array - not enough devices.\n");
1065         }
1066         close(mdfd);
1067         return 0;
1068
1069  abort:
1070         map_lock(&map);
1071  abort_locked:
1072         map_remove(&map, fd2devnm(mdfd));
1073         map_unlock(&map);
1074
1075         if (mdfd >= 0)
1076                 close(mdfd);
1077         return 1;
1078 }