Change MAJOR() etc to major() etc
[thirdparty/mdadm.git] / Assemble.c
CommitLineData
64c4757e 1/*
9a9dab36 2 * mdadm - manage Linux "md" devices aka RAID arrays.
64c4757e 3 *
cd29a5c8 4 * Copyright (C) 2001-2002 Neil Brown <neilb@cse.unsw.edu.au>
64c4757e
NB
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neilb@cse.unsw.edu.au>
23 * Paper: Neil Brown
24 * School of Computer Science and Engineering
25 * The University of New South Wales
26 * Sydney, 2052
27 * Australia
28 */
29
9a9dab36 30#include "mdadm.h"
64c4757e 31#include "md_u.h"
52826846 32#include "md_p.h"
64c4757e
NB
33
34int Assemble(char *mddev, int mdfd,
52826846 35 mddev_ident_t ident, char *conffile,
cd29a5c8 36 mddev_dev_t devlist,
64c4757e 37 int readonly, int runstop,
5787fa49 38 char *update,
64c4757e
NB
39 int verbose, int force)
40{
41 /*
52826846
NB
42 * The task of Assemble is to find a collection of
43 * devices that should (according to their superblocks)
44 * form an array, and to give this collection to the MD driver.
45 * In Linux-2.4 and later, this involves submitting a
64c4757e
NB
46 * SET_ARRAY_INFO ioctl with no arg - to prepare
47 * the array - and then submit a number of
48 * ADD_NEW_DISK ioctls to add disks into
49 * the array. Finally RUN_ARRAY might
50 * be submitted to start the array.
51 *
52 * Much of the work of Assemble is in finding and/or
53 * checking the disks to make sure they look right.
54 *
55 * If mddev is not set, then scan must be and we
56 * read through the config file for dev+uuid mapping
57 * We recurse, setting mddev, for each device that
58 * - isn't running
59 * - has a valid uuid (or any uuid if !uuidset
60 *
61 * If mddev is set, we try to determine state of md.
62 * check version - must be at least 0.90.0
63 * check kernel version. must be at least 2.4.
64 * If not, we can possibly fall back on START_ARRAY
65 * Try to GET_ARRAY_INFO.
66 * If possible, give up
67 * If not, try to STOP_ARRAY just to make sure
68 *
69 * If !uuidset and scan, look in conf-file for uuid
70 * If not found, give up
cd29a5c8 71 * If !devlist and scan and uuidset, get list of devs from conf-file
64c4757e
NB
72 *
73 * For each device:
74 * Check superblock - discard if bad
75 * Check uuid (set if we don't have one) - discard if no match
5787fa49 76 * Check superblock similarity if we have a superblock - discard if different
64c4757e
NB
77 * Record events, devicenum, utime
78 * This should give us a list of devices for the array
79 * We should collect the most recent event and utime numbers
80 *
81 * Count disks with recent enough event count
82 * While force && !enough disks
83 * Choose newest rejected disks, update event count
84 * mark clean and rewrite superblock
85 * If recent kernel:
86 * SET_ARRAY_INFO
87 * foreach device with recent events : ADD_NEW_DISK
88 * if runstop == 1 || "enough" disks and runstop==0 -> RUN_ARRAY
89 * If old kernel:
90 * Check the device numbers in superblock are right
91 * update superblock if any changes
92 * START_ARRAY
93 *
94 */
95 int old_linux = 0;
96 int vers;
97 mdu_array_info_t array;
64c4757e
NB
98 mdp_super_t first_super, super;
99 struct {
100 char *devname;
98c6faba
NB
101 unsigned int major, minor;
102 unsigned int oldmajor, oldminor;
64c4757e
NB
103 long long events;
104 time_t utime;
105 int uptodate;
d013a55e 106 int state;
52826846 107 int raid_disk;
5787fa49 108 } *devices;
56eedc1a 109 int *best = NULL; /* indexed by raid_disk */
98c6faba
NB
110 unsigned int bestcnt = 0;
111 int devcnt = 0;
112 unsigned int okcnt, sparecnt;
113 unsigned int req_cnt;
114 unsigned int i;
64c4757e 115 int most_recent = 0;
cd29a5c8 116 int chosen_drive;
52826846 117 int change = 0;
cd29a5c8
NB
118 int inargv = 0;
119 int start_partial_ok = force || devlist==NULL;
98c6faba 120 unsigned int num_devs;
5787fa49 121 mddev_dev_t tmpdev;
64c4757e 122
64c4757e
NB
123 vers = md_get_version(mdfd);
124 if (vers <= 0) {
e0d19036 125 fprintf(stderr, Name ": %s appears not to be an md device.\n", mddev);
64c4757e
NB
126 return 1;
127 }
682c7051
NB
128 if (vers < 9000) {
129 fprintf(stderr, Name ": Assemble requires driver version 0.90.0 or later.\n"
52826846 130 " Upgrade your kernel or try --build\n");
64c4757e
NB
131 return 1;
132 }
682c7051 133 if (get_linux_version() < 2004000)
64c4757e
NB
134 old_linux = 1;
135
136 if (ioctl(mdfd, GET_ARRAY_INFO, &array)>=0) {
682c7051 137 fprintf(stderr, Name ": device %s already active - cannot assemble it\n",
64c4757e
NB
138 mddev);
139 return 1;
140 }
141 ioctl(mdfd, STOP_ARRAY, NULL); /* just incase it was started but has no content */
142
143 /*
52826846
NB
144 * If any subdevs are listed, then any that don't
145 * match ident are discarded. Remainder must all match and
146 * become the array.
147 * If no subdevs, then we scan all devices in the config file, but
148 * there must be something in the identity
64c4757e 149 */
64c4757e 150
cd29a5c8 151 if (!devlist &&
52826846
NB
152 ident->uuid_set == 0 &&
153 ident->super_minor < 0 &&
154 ident->devices == NULL) {
155 fprintf(stderr, Name ": No identity information available for %s - cannot assemble.\n",
156 mddev);
157 return 1;
64c4757e 158 }
cd29a5c8 159 if (devlist == NULL)
64c4757e 160 devlist = conf_get_devs(conffile);
cd29a5c8 161 else inargv = 1;
64c4757e 162
5787fa49
NB
163 tmpdev = devlist; num_devs = 0;
164 while (tmpdev) {
165 num_devs++;
166 tmpdev = tmpdev->next;
167 }
168 best = malloc(num_devs * sizeof(*best));
169 devices = malloc(num_devs * sizeof(*devices));
170
64c4757e 171 first_super.md_magic = 0;
5787fa49 172 for (i=0; i<num_devs; i++)
64c4757e
NB
173 best[i] = -1;
174
82b27616
NB
175 if (verbose)
176 fprintf(stderr, Name ": looking for devices for %s\n",
177 mddev);
178
cd29a5c8 179 while ( devlist) {
64c4757e
NB
180 char *devname;
181 int this_uuid[4];
182 int dfd;
183 struct stat stb;
52826846
NB
184 int havesuper=0;
185
cd29a5c8
NB
186 devname = devlist->devname;
187 devlist = devlist->next;
64c4757e 188
52826846 189 if (ident->devices &&
56eedc1a
NB
190 !match_oneof(ident->devices, devname)) {
191 if (inargv || verbose)
192 fprintf(stderr, Name ": %s is not one of %s\n", devname, ident->devices);
52826846 193 continue;
56eedc1a 194 }
52826846 195
64c4757e
NB
196 dfd = open(devname, O_RDONLY, 0);
197 if (dfd < 0) {
198 if (inargv || verbose)
682c7051 199 fprintf(stderr, Name ": cannot open device %s: %s\n",
64c4757e 200 devname, strerror(errno));
52826846
NB
201 } else if (fstat(dfd, &stb)< 0) {
202 /* Impossible! */
203 fprintf(stderr, Name ": fstat failed for %s: %s\n",
204 devname, strerror(errno));
205 close(dfd);
cd29a5c8
NB
206 } else if ((stb.st_mode & S_IFMT) != S_IFBLK) {
207 fprintf(stderr, Name ": %s is not a block device.\n",
52826846
NB
208 devname);
209 close(dfd);
cd29a5c8 210 } else if (load_super(dfd, &super)) {
64c4757e 211 if (inargv || verbose)
682c7051 212 fprintf( stderr, Name ": no RAID superblock on %s\n",
64c4757e
NB
213 devname);
214 close(dfd);
52826846
NB
215 } else {
216 havesuper =1;
217 uuid_from_super(this_uuid, &super);
218 close(dfd);
64c4757e 219 }
52826846
NB
220
221 if (ident->uuid_set &&
222 (!havesuper || same_uuid(this_uuid, ident->uuid)==0)) {
223 if (inargv || verbose)
224 fprintf(stderr, Name ": %s has wrong uuid.\n",
225 devname);
226 continue;
82b27616 227 }
98c6faba 228 if (ident->super_minor != UnSet &&
52826846 229 (!havesuper || ident->super_minor != super.md_minor)) {
64c4757e 230 if (inargv || verbose)
52826846 231 fprintf(stderr, Name ": %s has wrong super-minor.\n",
64c4757e
NB
232 devname);
233 continue;
234 }
98c6faba
NB
235 if (ident->level != UnSet &&
236 (!havesuper|| ident->level != (int)super.level)) {
cd29a5c8
NB
237 if (inargv || verbose)
238 fprintf(stderr, Name ": %s has wrong raid level.\n",
239 devname);
240 continue;
241 }
98c6faba 242 if (ident->raid_disks != UnSet &&
cd29a5c8
NB
243 (!havesuper || ident->raid_disks!= super.raid_disks)) {
244 if (inargv || verbose)
245 fprintf(stderr, Name ": %s requires wrong number of drives.\n",
246 devname);
247 continue;
248 }
52826846
NB
249
250 /* If we are this far, then we are commited to this device.
251 * If the super_block doesn't exist, or doesn't match others,
252 * then we cannot continue
253 */
52826846
NB
254
255 if (!havesuper) {
256 fprintf(stderr, Name ": %s has no superblock - assembly aborted\n",
257 devname);
258 return 1;
259 }
260 if (compare_super(&first_super, &super)) {
261 fprintf(stderr, Name ": superblock on %s doesn't match others - assembly aborted\n",
262 devname);
263 return 1;
64c4757e
NB
264 }
265
5787fa49
NB
266
267 /* this is needed until we get a more relaxed super block format */
64c4757e 268 if (devcnt >= MD_SB_DISKS) {
682c7051 269 fprintf(stderr, Name ": ouch - too many devices appear to be in this array. Ignoring %s\n",
64c4757e
NB
270 devname);
271 continue;
272 }
5787fa49
NB
273
274 /* looks like a good enough match to update the super block if needed */
275 if (update) {
276 if (strcmp(update, "sparc2.2")==0 ) {
277 /* 2.2 sparc put the events in the wrong place
278 * So we copy the tail of the superblock
279 * up 4 bytes before continuing
280 */
281 __u32 *sb32 = (__u32*)&super;
282 memcpy(sb32+MD_SB_GENERIC_CONSTANT_WORDS+7,
283 sb32+MD_SB_GENERIC_CONSTANT_WORDS+7+1,
284 (MD_SB_WORDS - (MD_SB_GENERIC_CONSTANT_WORDS+7+1))*4);
285 fprintf (stderr, Name ": adjusting superblock of %s for 2.2/sparc compatability.\n",
286 devname);
287 }
288 if (strcmp(update, "super-minor") ==0) {
289 struct stat stb2;
290 fstat(mdfd, &stb2);
0df46c2a 291 super.md_minor = minor(stb2.st_rdev);
5787fa49
NB
292 if (verbose)
293 fprintf(stderr, Name ": updating superblock of %s with minor number %d\n",
294 devname, super.md_minor);
295 }
feb716e9
NB
296 if (strcmp(update, "summaries") == 0) {
297 /* set nr_disks, active_disks, working_disks,
298 * failed_disks, spare_disks based on disks[]
299 * array in superblock.
300 * Also make sure extra slots aren't 'failed'
301 */
302 super.nr_disks = super.active_disks =
303 super.working_disks = super.failed_disks =
304 super.spare_disks = 0;
305 for (i=0; i < MD_SB_DISKS ; i++)
306 if (super.disks[i].major ||
307 super.disks[i].minor) {
308 int state = super.disks[i].state;
309 if (state & (1<<MD_DISK_REMOVED))
310 continue;
311 super.nr_disks++;
312 if (state & (1<<MD_DISK_ACTIVE))
313 super.active_disks++;
314 if (state & (1<<MD_DISK_FAULTY))
315 super.failed_disks++;
316 else
317 super.working_disks++;
318 if (state == 0)
319 super.spare_disks++;
320 } else if (i >= super.raid_disks && super.disks[i].number == 0)
321 super.disks[i].state = 0;
322 }
e5329c37
NB
323 if (strcmp(update, "resync") == 0) {
324 /* make sure resync happens */
325 super.state &= ~(1<<MD_SB_CLEAN);
326 super.recovery_cp = 0;
327 }
5787fa49
NB
328 super.sb_csum = calc_sb_csum(&super);
329 dfd = open(devname, O_RDWR, 0);
330 if (dfd < 0)
331 fprintf(stderr, Name ": Cannot open %s for superblock update\n",
332 devname);
333 else if (store_super(dfd, &super))
334 fprintf(stderr, Name ": Could not re-write superblock on %s.\n",
335 devname);
336 if (dfd >= 0)
337 close(dfd);
338 }
339
cd29a5c8
NB
340 if (verbose)
341 fprintf(stderr, Name ": %s is identified as a member of %s, slot %d.\n",
342 devname, mddev, super.this_disk.raid_disk);
64c4757e 343 devices[devcnt].devname = devname;
0df46c2a
NB
344 devices[devcnt].major = major(stb.st_rdev);
345 devices[devcnt].minor = minor(stb.st_rdev);
11a3e71d
NB
346 devices[devcnt].oldmajor = super.this_disk.major;
347 devices[devcnt].oldminor = super.this_disk.minor;
64c4757e
NB
348 devices[devcnt].events = md_event(&super);
349 devices[devcnt].utime = super.utime;
52826846 350 devices[devcnt].raid_disk = super.this_disk.raid_disk;
64c4757e 351 devices[devcnt].uptodate = 0;
d013a55e 352 devices[devcnt].state = super.this_disk.state;
64c4757e
NB
353 if (most_recent < devcnt) {
354 if (devices[devcnt].events
355 > devices[most_recent].events)
356 most_recent = devcnt;
357 }
98c6faba 358 if ((int)super.level == -4)
5787fa49
NB
359 /* with multipath, the raid_disk from the superblock is meaningless */
360 i = devcnt;
361 else
362 i = devices[devcnt].raid_disk;
98c6faba 363 if (i < 10000) {
56eedc1a 364 if (i >= bestcnt) {
98c6faba 365 unsigned int newbestcnt = i+10;
56eedc1a 366 int *newbest = malloc(sizeof(int)*newbestcnt);
98c6faba 367 unsigned int c;
56eedc1a
NB
368 for (c=0; c < newbestcnt; c++)
369 if (c < bestcnt)
370 newbest[c] = best[c];
371 else
372 newbest[c] = -1;
373 if (best)free(best);
374 best = newbest;
375 bestcnt = newbestcnt;
376 }
52826846
NB
377 if (best[i] == -1
378 || devices[best[i]].events < devices[devcnt].events)
379 best[i] = devcnt;
56eedc1a 380 }
64c4757e
NB
381 devcnt++;
382 }
383
384 if (devcnt == 0) {
682c7051 385 fprintf(stderr, Name ": no devices found for %s\n",
64c4757e
NB
386 mddev);
387 return 1;
388 }
389 /* now we have some devices that might be suitable.
390 * I wonder how many
391 */
392 okcnt = 0;
52826846 393 sparecnt=0;
56eedc1a 394 for (i=0; i< bestcnt ;i++) {
64c4757e 395 int j = best[i];
cd29a5c8 396 int event_margin = !force;
64c4757e 397 if (j < 0) continue;
d013a55e
NB
398 /* note: we ignore error flags in multipath arrays
399 * as they don't make sense
400 */
98c6faba 401 if ((int)first_super.level != -4)
aa88f531
NB
402 if (!(devices[j].state & (1<<MD_DISK_SYNC))) {
403 if (!(devices[j].state & (1<<MD_DISK_FAULTY)))
404 sparecnt++;
d013a55e 405 continue;
aa88f531 406 }
cd29a5c8 407 if (devices[j].events+event_margin >=
64c4757e
NB
408 devices[most_recent].events) {
409 devices[j].uptodate = 1;
52826846
NB
410 if (i < first_super.raid_disks)
411 okcnt++;
412 else
413 sparecnt++;
64c4757e
NB
414 }
415 }
416 while (force && !enough(first_super.level, first_super.raid_disks, okcnt)) {
417 /* Choose the newest best drive which is
418 * not up-to-date, update the superblock
419 * and add it.
420 */
52826846 421 int fd;
cd29a5c8 422 chosen_drive = -1;
56eedc1a 423 for (i=0; i<first_super.raid_disks && i < bestcnt; i++) {
52826846
NB
424 int j = best[i];
425 if (j>=0 &&
426 !devices[j].uptodate &&
427 devices[j].events > 0 &&
428 (chosen_drive < 0 ||
429 devices[j].events > devices[chosen_drive].events))
430 chosen_drive = j;
431 }
432 if (chosen_drive < 0)
433 break;
434 fprintf(stderr, Name ": forcing event count in %s(%d) from %d upto %d\n",
435 devices[chosen_drive].devname, devices[chosen_drive].raid_disk,
436 (int)(devices[chosen_drive].events),
437 (int)(devices[most_recent].events));
438 fd = open(devices[chosen_drive].devname, O_RDWR);
439 if (fd < 0) {
440 fprintf(stderr, Name ": Couldn't open %s for write - not updating\n",
441 devices[chosen_drive].devname);
442 devices[chosen_drive].events = 0;
443 continue;
444 }
445 if (load_super(fd, &super)) {
446 close(fd);
447 fprintf(stderr, Name ": RAID superblock disappeared from %s - not updating.\n",
448 devices[chosen_drive].devname);
449 devices[chosen_drive].events = 0;
450 continue;
451 }
452 super.events_hi = (devices[most_recent].events>>32)&0xFFFFFFFF;
453 super.events_lo = (devices[most_recent].events)&0xFFFFFFFF;
5787fa49
NB
454 if (super.level == 5 || super.level == 4) {
455 /* need to force clean */
d013a55e 456 super.state = (1<<MD_SB_CLEAN);
5787fa49 457 }
52826846
NB
458 super.sb_csum = calc_sb_csum(&super);
459/*DRYRUN*/ if (store_super(fd, &super)) {
460 close(fd);
461 fprintf(stderr, Name ": Could not re-write superblock on %s\n",
462 devices[chosen_drive].devname);
463 devices[chosen_drive].events = 0;
464 continue;
465 }
466 close(fd);
467 devices[chosen_drive].events = devices[most_recent].events;
468 devices[chosen_drive].uptodate = 1;
469 okcnt++;
64c4757e 470 }
52826846
NB
471
472 /* Now we want to look at the superblock which the kernel will base things on
473 * and compare the devices that we think are working with the devices that the
474 * superblock thinks are working.
475 * If there are differences and --force is given, then update this chosen
476 * superblock.
477 */
cd29a5c8 478 chosen_drive = -1;
56eedc1a 479 for (i=0; chosen_drive < 0 && i<bestcnt; i++) {
52826846
NB
480 int j = best[i];
481 int fd;
482 if (j<0)
483 continue;
484 if (!devices[j].uptodate)
485 continue;
486 chosen_drive = j;
487 if ((fd=open(devices[j].devname, O_RDONLY))< 0) {
488 fprintf(stderr, Name ": Cannot open %s: %s\n",
489 devices[j].devname, strerror(errno));
490 return 1;
491 }
492 if (load_super(fd, &super)) {
493 close(fd);
494 fprintf(stderr, Name ": RAID superblock has disappeared from %s\n",
495 devices[j].devname);
496 return 1;
497 }
498 close(fd);
499 }
500
56eedc1a 501 for (i=0; i<bestcnt; i++) {
52826846 502 int j = best[i];
98c6faba 503 unsigned int desired_state;
11a3e71d
NB
504
505 if (i < super.raid_disks)
506 desired_state = (1<<MD_DISK_ACTIVE) | (1<<MD_DISK_SYNC);
507 else
508 desired_state = 0;
509
52826846
NB
510 if (j<0)
511 continue;
512 if (!devices[j].uptodate)
513 continue;
11a3e71d
NB
514#if 0
515This doesnt work yet
516 if (devices[j].major != super.disks[i].major ||
517 devices[j].minor != super.disks[i].minor) {
52826846 518 change |= 1;
11a3e71d
NB
519 super.disks[i].major = devices[j].major;
520 super.disks[i].minor = devices[j].minor;
521 }
522#endif
523 if (devices[j].oldmajor != super.disks[i].major ||
524 devices[j].oldminor != super.disks[i].minor) {
525 change |= 2;
e0d19036
NB
526 super.disks[i].major = devices[j].oldmajor;
527 super.disks[i].minor = devices[j].oldminor;
52826846
NB
528 }
529 if (devices[j].uptodate &&
11a3e71d 530 (super.disks[i].state != desired_state)) {
52826846
NB
531 if (force) {
532 fprintf(stderr, Name ": "
cd29a5c8 533 "clearing FAULTY flag for device %d in %s for %s\n",
52826846 534 j, mddev, devices[j].devname);
11a3e71d 535 super.disks[i].state = desired_state;
52826846
NB
536 change |= 2;
537 } else {
538 fprintf(stderr, Name ": "
11a3e71d 539 "device %d in %s has wrong state in superblock, but %s seems ok\n",
52826846
NB
540 i, mddev, devices[j].devname);
541 }
542 }
543 if (!devices[j].uptodate &&
544 !(super.disks[i].state & (1 << MD_DISK_FAULTY))) {
545 fprintf(stderr, Name ": devices %d of %s is not marked FAULTY in superblock, but cannot be found\n",
546 i, mddev);
547 }
548 }
d013a55e
NB
549 if (force && (super.level == 4 || super.level == 5) &&
550 okcnt == super.raid_disks-1) {
551 super.state = (1<< MD_SB_CLEAN);
552 change |= 2;
553 }
52826846
NB
554
555 if ((force && (change & 2))
556 || (old_linux && (change & 1))) {
557 int fd;
558 super.sb_csum = calc_sb_csum(&super);
559 fd = open(devices[chosen_drive].devname, O_RDWR);
560 if (fd < 0) {
561 fprintf(stderr, Name ": Could open %s for write - cannot Assemble array.\n",
562 devices[chosen_drive].devname);
563 return 1;
564 }
565 if (store_super(fd, &super)) {
566 close(fd);
567 fprintf(stderr, Name ": Could not re-write superblock on %s\n",
568 devices[chosen_drive].devname);
569 return 1;
570 }
571 close(fd);
572 change = 0;
573 }
574
aa88f531
NB
575 /* count number of in-sync devices according to the superblock.
576 * We must have this number to start the array without -s or -R
577 */
578 req_cnt = 0;
579 for (i=0; i<MD_SB_DISKS; i++)
580 if ((first_super.disks[i].state & (1<<MD_DISK_SYNC)) &&
581 (first_super.disks[i].state & (1<<MD_DISK_ACTIVE)) &&
582 !(first_super.disks[i].state & (1<<MD_DISK_FAULTY)))
583 req_cnt ++;
584
585
64c4757e
NB
586 /* Almost ready to actually *do* something */
587 if (!old_linux) {
588 if (ioctl(mdfd, SET_ARRAY_INFO, NULL) != 0) {
682c7051 589 fprintf(stderr, Name ": SET_ARRAY_INFO failed for %s: %s\n",
64c4757e
NB
590 mddev, strerror(errno));
591 return 1;
592 }
52826846 593 /* First, add the raid disks, but add the chosen one last */
56eedc1a 594 for (i=0; i<= bestcnt; i++) {
52826846 595 int j;
56eedc1a 596 if (i < bestcnt) {
52826846
NB
597 j = best[i];
598 if (j == chosen_drive)
599 continue;
600 } else
601 j = chosen_drive;
602
56eedc1a 603 if (j >= 0 /* && devices[j].uptodate */) {
64c4757e
NB
604 mdu_disk_info_t disk;
605 memset(&disk, 0, sizeof(disk));
606 disk.major = devices[j].major;
607 disk.minor = devices[j].minor;
608 if (ioctl(mdfd, ADD_NEW_DISK, &disk)!=0) {
682c7051 609 fprintf(stderr, Name ": failed to add %s to %s: %s\n",
64c4757e
NB
610 devices[j].devname,
611 mddev,
612 strerror(errno));
52826846
NB
613 if (i < first_super.raid_disks)
614 okcnt--;
615 else
616 sparecnt--;
617 } else if (verbose)
618 fprintf(stderr, Name ": added %s to %s as %d\n",
619 devices[j].devname, mddev, devices[j].raid_disk);
620 } else if (verbose && i < first_super.raid_disks)
682c7051 621 fprintf(stderr, Name ": no uptodate device for slot %d of %s\n",
64c4757e
NB
622 i, mddev);
623 }
52826846 624
64c4757e
NB
625 if (runstop == 1 ||
626 (runstop == 0 &&
aa88f531
NB
627 ( enough(first_super.level, first_super.raid_disks, okcnt) &&
628 (okcnt >= req_cnt || start_partial_ok)
629 ))) {
82b27616 630 if (ioctl(mdfd, RUN_ARRAY, NULL)==0) {
52826846
NB
631 fprintf(stderr, Name ": %s has been started with %d drive%s",
632 mddev, okcnt, okcnt==1?"":"s");
aa88f531
NB
633 if (okcnt < first_super.raid_disks)
634 fprintf(stderr, " (out of %d)", first_super.raid_disks);
52826846
NB
635 if (sparecnt)
636 fprintf(stderr, " and %d spare%s", sparecnt, sparecnt==1?"":"s");
637 fprintf(stderr, ".\n");
64c4757e 638 return 0;
82b27616 639 }
682c7051 640 fprintf(stderr, Name ": failed to RUN_ARRAY %s: %s\n",
64c4757e
NB
641 mddev, strerror(errno));
642 return 1;
643 }
82b27616 644 if (runstop == -1) {
52826846
NB
645 fprintf(stderr, Name ": %s assembled from %d drive%s, but not started.\n",
646 mddev, okcnt, okcnt==1?"":"s");
64c4757e 647 return 0;
82b27616 648 }
aa88f531
NB
649 fprintf(stderr, Name ": %s assembled from %d drive%s", mddev, okcnt, okcnt==1?"":"s");
650 if (sparecnt)
651 fprintf(stderr, " and %d spare%s", sparecnt, sparecnt==1?"":"s");
652 if (!enough(first_super.level, first_super.raid_disks, okcnt))
653 fprintf(stderr, " - not enough to start the array.\n");
654 else {
655 if (req_cnt == first_super.raid_disks)
656 fprintf(stderr, " - need all %d to start it", req_cnt);
657 else
658 fprintf(stderr, " - need %d of %d to start", req_cnt, first_super.raid_disks);
659 fprintf(stderr, " (use --run to insist).\n");
660 }
64c4757e 661 return 1;
82b27616 662 } else {
52826846
NB
663 /* The "chosen_drive" is a good choice, and if necessary, the superblock has
664 * been updated to point to the current locations of devices.
665 * so we can just start the array
82b27616 666 */
cd29a5c8 667 unsigned long dev;
0df46c2a 668 dev = makedev(devices[chosen_drive].major,
82b27616
NB
669 devices[chosen_drive].minor);
670 if (ioctl(mdfd, START_ARRAY, dev)) {
671 fprintf(stderr, Name ": Cannot start array: %s\n",
672 strerror(errno));
673 }
674
64c4757e 675 }
e0d19036 676 return 0;
64c4757e 677}