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