]> git.ipfire.org Git - thirdparty/mdadm.git/blob - Assemble.c
projects / thirdparty / mdadm.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
assemble: combine the two create_mddev calls in to one.
[thirdparty/mdadm.git] / Assemble.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neilb@cse.unsw.edu.au>
23 * Paper: Neil Brown
24 * School of Computer Science and Engineering
25 * The University of New South Wales
26 * Sydney, 2052
27 * Australia
28 */
29
30 #include "mdadm.h"
31 #include <ctype.h>
32
33 static int name_matches(char *found, char *required, char *homehost)
34 {
35 /* See if the name found matches the required name, possibly
36 * prefixed with 'homehost'
37 */
38 char fnd[33];
39
40 strncpy(fnd, found, 32);
41 fnd[32] = 0;
42 if (strcmp(found, required)==0)
43 return 1;
44 if (homehost) {
45 int l = strlen(homehost);
46 if (l < 32 && fnd[l] == ':' &&
47 strcmp(fnd+l+1, required)==0)
48 return 1;
49 }
50 return 0;
51 }
52
53 int Assemble(struct supertype *st, char *mddev,
54 mddev_ident_t ident,
55 mddev_dev_t devlist, char *backup_file,
56 int readonly, int runstop,
57 char *update, char *homehost,
58 int verbose, int force)
59 {
60 /*
61 * The task of Assemble is to find a collection of
62 * devices that should (according to their superblocks)
63 * form an array, and to give this collection to the MD driver.
64 * In Linux-2.4 and later, this involves submitting a
65 * SET_ARRAY_INFO ioctl with no arg - to prepare
66 * the array - and then submit a number of
67 * ADD_NEW_DISK ioctls to add disks into
68 * the array. Finally RUN_ARRAY might
69 * be submitted to start the array.
70 *
71 * Much of the work of Assemble is in finding and/or
72 * checking the disks to make sure they look right.
73 *
74 * If mddev is not set, then scan must be set and we
75 * read through the config file for dev+uuid mapping
76 * We recurse, setting mddev, for each device that
77 * - isn't running
78 * - has a valid uuid (or any uuid if !uuidset)
79 *
80 * If mddev is set, we try to determine state of md.
81 * check version - must be at least 0.90.0
82 * check kernel version. must be at least 2.4.
83 * If not, we can possibly fall back on START_ARRAY
84 * Try to GET_ARRAY_INFO.
85 * If possible, give up
86 * If not, try to STOP_ARRAY just to make sure
87 *
88 * If !uuidset and scan, look in conf-file for uuid
89 * If not found, give up
90 * If !devlist and scan and uuidset, get list of devs from conf-file
91 *
92 * For each device:
93 * Check superblock - discard if bad
94 * Check uuid (set if we don't have one) - discard if no match
95 * Check superblock similarity if we have a superblock - discard if different
96 * Record events, devicenum
97 * This should give us a list of devices for the array
98 * We should collect the most recent event number
99 *
100 * Count disks with recent enough event count
101 * While force && !enough disks
102 * Choose newest rejected disks, update event count
103 * mark clean and rewrite superblock
104 * If recent kernel:
105 * SET_ARRAY_INFO
106 * foreach device with recent events : ADD_NEW_DISK
107 * if runstop == 1 || "enough" disks and runstop==0 -> RUN_ARRAY
108 * If old kernel:
109 * Check the device numbers in superblock are right
110 * update superblock if any changes
111 * START_ARRAY
112 *
113 */
114 int mdfd;
115 int clean;
116 int auto_assem = (mddev == NULL);
117 int old_linux = 0;
118 int vers = vers; /* Keep gcc quite - it really is initialised */
119 struct {
120 char *devname;
121 int uptodate; /* set once we decide that this device is as
122 * recent as everything else in the array.
123 */
124 struct mdinfo i;
125 } *devices;
126 int *best = NULL; /* indexed by raid_disk */
127 unsigned int bestcnt = 0;
128 int devcnt = 0;
129 unsigned int okcnt, sparecnt;
130 unsigned int req_cnt;
131 unsigned int i;
132 int most_recent = 0;
133 int chosen_drive;
134 int change = 0;
135 int inargv = 0;
136 int bitmap_done;
137 int start_partial_ok = (runstop >= 0) &&
138 (force || devlist==NULL || auto_assem);
139 unsigned int num_devs;
140 mddev_dev_t tmpdev;
141 struct mdinfo info;
142 mdu_array_info_t tmp_inf;
143 char *avail;
144 int nextspare = 0;
145 int uuid_for_name = 0;
146
147 memset(&info, 0, sizeof(info));
148
149 if (get_linux_version() < 2004000)
150 old_linux = 1;
151
152 /*
153 * If any subdevs are listed, then any that don't
154 * match ident are discarded. Remainder must all match and
155 * become the array.
156 * If no subdevs, then we scan all devices in the config file, but
157 * there must be something in the identity
158 */
159
160 if (!devlist &&
161 ident->uuid_set == 0 &&
162 ident->super_minor < 0 &&
163 ident->devices == NULL) {
164 fprintf(stderr, Name ": No identity information available for %s - cannot assemble.\n",
165 mddev ? mddev : "further assembly");
166 return 1;
167 }
168
169 /* if the configuration specifies a container then we use that to
170 * determine the devices and retrieve the array configuration
171 */
172 #ifndef MDASSEMBLE
173 if (ident->container && ident->member) {
174 int cfd = open(ident->container, O_RDWR);
175 struct mdinfo *mdi;
176 struct supertype container;
177
178 if (verbose>0)
179 fprintf(stderr, Name ": looking to assemble member array %s"
180 " inside container %s\n", ident->member, ident->container);
181 if (cfd < 0) {
182 if (verbose>0)
183 fprintf(stderr, Name ": unable to open container %s: %s\n",
184 ident->container, strerror(errno));
185 return 1;
186 }
187
188 mdi = sysfs_read(cfd, fd2devnum(cfd), GET_VERSION);
189 if (!mdi) {
190 close(cfd);
191 if (verbose>0)
192 fprintf(stderr, Name ": unable to read container %s\n",
193 ident->container);
194 return 1;
195 }
196 container.ss = find_metadata_methods(mdi->text_version);
197 sysfs_free(mdi);
198 if (!container.ss) {
199 close(cfd);
200 fprintf(stderr, Name ": %s uses unknown metadata: %s\n",
201 ident->container, mdi->text_version);
202 return 1;
203 }
204 if (container.ss->load_super(&container, cfd, ident->container)) {
205 fprintf(stderr, Name ": Cannot load metadata for container %s\n",
206 ident->container);
207 return 1;
208 }
209
210 return Incremental_container(&container, ident->container,
211 verbose, runstop, ident->autof);
212 }
213 #endif
214 if (devlist == NULL)
215 devlist = conf_get_devs();
216 else if (mddev)
217 inargv = 1;
218
219 try_again:
220 /* We come back here when doing auto-assembly and attempting some
221 * set of devices failed. Those are now marked as ->used==2 and
222 * we ignore them and try again
223 */
224
225 tmpdev = devlist; num_devs = 0;
226 while (tmpdev) {
227 if (tmpdev->used)
228 tmpdev->used = 2;
229 else
230 num_devs++;
231 tmpdev = tmpdev->next;
232 }
233 devices = malloc(num_devs * sizeof(*devices));
234
235 if (!st && ident->st) st = ident->st;
236
237 if (verbose>0)
238 fprintf(stderr, Name ": looking for devices for %s\n",
239 mddev ? mddev : "further assembly");
240
241 /* first walk the list of devices to find a consistent set
242 * that match the criterea, if that is possible.
243 * We flag the ones we like with 'used'.
244 */
245 for (tmpdev = devlist;
246 tmpdev;
247 tmpdev = tmpdev->next) {
248 char *devname = tmpdev->devname;
249 int dfd;
250 struct stat stb;
251 struct supertype *tst = dup_super(st);
252
253 if (tmpdev->used > 1) continue;
254
255 if (ident->devices &&
256 !match_oneof(ident->devices, devname)) {
257 if ((inargv && verbose>=0) || verbose > 0)
258 fprintf(stderr, Name ": %s is not one of %s\n", devname, ident->devices);
259 continue;
260 }
261
262 dfd = dev_open(devname, O_RDONLY|O_EXCL);
263 if (dfd < 0) {
264 if ((inargv && verbose >= 0) || verbose > 0)
265 fprintf(stderr, Name ": cannot open device %s: %s\n",
266 devname, strerror(errno));
267 tmpdev->used = 2;
268 } else if (fstat(dfd, &stb)< 0) {
269 /* Impossible! */
270 fprintf(stderr, Name ": fstat failed for %s: %s\n",
271 devname, strerror(errno));
272 tmpdev->used = 2;
273 } else if ((stb.st_mode & S_IFMT) != S_IFBLK) {
274 fprintf(stderr, Name ": %s is not a block device.\n",
275 devname);
276 tmpdev->used = 2;
277 } else if (!tst && (tst = guess_super(dfd)) == NULL) {
278 if ((inargv && verbose >= 0) || verbose > 0)
279 fprintf(stderr, Name ": no recogniseable superblock on %s\n",
280 devname);
281 tmpdev->used = 2;
282 } else if (tst->ss->load_super(tst,dfd, NULL)) {
283 if ((inargv && verbose >= 0) || verbose > 0)
284 fprintf( stderr, Name ": no RAID superblock on %s\n",
285 devname);
286 } else {
287 tst->ss->getinfo_super(tst, &info);
288 }
289 if (dfd >= 0) close(dfd);
290
291 if (ident->uuid_set && (!update || strcmp(update, "uuid")!= 0) &&
292 (!tst || !tst->sb ||
293 same_uuid(info.uuid, ident->uuid, tst->ss->swapuuid)==0)) {
294 if ((inargv && verbose >= 0) || verbose > 0)
295 fprintf(stderr, Name ": %s has wrong uuid.\n",
296 devname);
297 goto loop;
298 }
299 if (ident->name[0] && (!update || strcmp(update, "name")!= 0) &&
300 (!tst || !tst->sb ||
301 name_matches(info.name, ident->name, homehost)==0)) {
302 if ((inargv && verbose >= 0) || verbose > 0)
303 fprintf(stderr, Name ": %s has wrong name.\n",
304 devname);
305 goto loop;
306 }
307 if (ident->super_minor != UnSet &&
308 (!tst || !tst->sb ||
309 ident->super_minor != info.array.md_minor)) {
310 if ((inargv && verbose >= 0) || verbose > 0)
311 fprintf(stderr, Name ": %s has wrong super-minor.\n",
312 devname);
313 goto loop;
314 }
315 if (ident->level != UnSet &&
316 (!tst || !tst->sb ||
317 ident->level != info.array.level)) {
318 if ((inargv && verbose >= 0) || verbose > 0)
319 fprintf(stderr, Name ": %s has wrong raid level.\n",
320 devname);
321 goto loop;
322 }
323 if (ident->raid_disks != UnSet &&
324 (!tst || !tst->sb ||
325 ident->raid_disks!= info.array.raid_disks)) {
326 if ((inargv && verbose >= 0) || verbose > 0)
327 fprintf(stderr, Name ": %s requires wrong number of drives.\n",
328 devname);
329 goto loop;
330 }
331 if (auto_assem) {
332 if (tst == NULL || tst->sb == NULL)
333 continue;
334 switch(tst->ss->match_home(tst, homehost))
335 {
336 case 1: /* happy with match. */
337 break;
338 case -1: /* cannot match */
339 uuid_for_name = 1;
340 break;
341 case 0: /* Doesn't match */
342 if (update)
343 /* We are changing the name*/
344 break;
345 if ((inargv && verbose >= 0) || verbose > 0)
346 fprintf(stderr, Name ": %s is not built for "
347 "host %s - using UUID for "
348 "device name.\n",
349 devname, homehost);
350
351 /* Auto-assemble, and this is not a usable host */
352 /* if update != NULL, we are updating the host
353 * name... */
354 uuid_for_name = 1;
355 break;
356 }
357 }
358 /* If we are this far, then we are nearly commited to this device.
359 * If the super_block doesn't exist, or doesn't match others,
360 * then we probably cannot continue
361 * However if one of the arrays is for the homehost, and
362 * the other isn't that can disambiguate.
363 */
364
365 if (!tst || !tst->sb) {
366 fprintf(stderr, Name ": %s has no superblock - assembly aborted\n",
367 devname);
368 if (st)
369 st->ss->free_super(st);
370 return 1;
371 }
372
373 if (st == NULL)
374 st = dup_super(tst);
375 if (st->minor_version == -1)
376 st->minor_version = tst->minor_version;
377 if (st->ss != tst->ss ||
378 st->minor_version != tst->minor_version ||
379 st->ss->compare_super(st, tst) != 0) {
380 /* Some mismatch. If exactly one array matches this host,
381 * we can resolve on that one.
382 * Or, if we are auto assembling, we just ignore the second
383 * for now.
384 */
385 if (auto_assem)
386 goto loop;
387 if (homehost) {
388 int first = st->ss->match_home(st, homehost);
389 int last = tst->ss->match_home(tst, homehost);
390 if (first != last &&
391 (first == 1 || last == 1)) {
392 /* We can do something */
393 if (first) {/* just ignore this one */
394 if ((inargv && verbose >= 0) || verbose > 0)
395 fprintf(stderr, Name ": %s misses out due to wrong homehost\n",
396 devname);
397 goto loop;
398 } else { /* reject all those sofar */
399 mddev_dev_t td;
400 if ((inargv && verbose >= 0) || verbose > 0)
401 fprintf(stderr, Name ": %s overrides previous devices due to good homehost\n",
402 devname);
403 for (td=devlist; td != tmpdev; td=td->next)
404 if (td->used == 1)
405 td->used = 0;
406 tmpdev->used = 1;
407 goto loop;
408 }
409 }
410 }
411 fprintf(stderr, Name ": superblock on %s doesn't match others - assembly aborted\n",
412 devname);
413 tst->ss->free_super(tst);
414 st->ss->free_super(st);
415 return 1;
416 }
417
418 tmpdev->used = 1;
419
420 loop:
421 if (tst)
422 tst->ss->free_super(tst);
423 }
424
425 if (!st || !st->sb)
426 return 2;
427
428 /* Now need to open array the device.
429 * We create a name '/dev/md/XXX' based on the info in the
430 * superblock, and call create_mddev on that
431 */
432
433 if (mddev == NULL) {
434 char nbuf[64];
435 char *c;
436 int rc;
437
438 st->ss->getinfo_super(st, &info);
439 if (uuid_for_name)
440 c = fname_from_uuid(st, &info, nbuf, '-');
441 else {
442 c = strchr(info.name, ':');
443 if (c) c++; else c= info.name;
444 }
445 if (isdigit(*c) && ((ident->autof & 7)==4 || (ident->autof&7)==6))
446 /* /dev/md/d0 style for partitionable */
447 rc = asprintf(&mddev, "/dev/md/d%s", c);
448 else
449 rc = asprintf(&mddev, "/dev/md/%s", c);
450 if (rc < 0) {
451 st->ss->free_super(st);
452 free(devices);
453 mddev = NULL;
454 goto try_again;
455 }
456 }
457 mdfd = create_mddev(mddev, ident->autof);
458 if (mdfd < 0) {
459 st->ss->free_super(st);
460 free(devices);
461 if (auto_assem)
462 goto try_again;
463 return 1;
464 }
465 vers = md_get_version(mdfd);
466 if (vers < 9000) {
467 fprintf(stderr, Name ": Assemble requires driver version 0.90.0 or later.\n"
468 " Upgrade your kernel or try --build\n");
469 close(mdfd);
470 return 1;
471 }
472 if (ioctl(mdfd, GET_ARRAY_INFO, &tmp_inf)==0) {
473 fprintf(stderr, Name ": %s already active, cannot restart it!\n",
474 mddev);
475 for (tmpdev = devlist ;
476 tmpdev && tmpdev->used != 1;
477 tmpdev = tmpdev->next)
478 ;
479 if (tmpdev && auto_assem)
480 fprintf(stderr, Name ": %s needed for %s...\n",
481 mddev, tmpdev->devname);
482 close(mdfd);
483 mdfd = -3;
484 st->ss->free_super(st);
485 free(devices);
486 if (auto_assem)
487 goto try_again;
488 return 1;
489 }
490 ioctl(mdfd, STOP_ARRAY, NULL); /* just incase it was started but has no content */
491
492 /* Ok, no bad inconsistancy, we can try updating etc */
493 bitmap_done = 0;
494 for (tmpdev = devlist; tmpdev; tmpdev=tmpdev->next) if (tmpdev->used == 1) {
495 char *devname = tmpdev->devname;
496 struct stat stb;
497 /* looks like a good enough match to update the super block if needed */
498 #ifndef MDASSEMBLE
499 if (update) {
500 int dfd;
501 /* prepare useful information in info structures */
502 struct stat stb2;
503 struct supertype *tst;
504 fstat(mdfd, &stb2);
505
506 if (strcmp(update, "uuid")==0 &&
507 !ident->uuid_set) {
508 int rfd;
509 if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
510 read(rfd, ident->uuid, 16) != 16) {
511 *(__u32*)(ident->uuid) = random();
512 *(__u32*)(ident->uuid+1) = random();
513 *(__u32*)(ident->uuid+2) = random();
514 *(__u32*)(ident->uuid+3) = random();
515 }
516 if (rfd >= 0) close(rfd);
517 }
518 dfd = dev_open(devname, O_RDWR|O_EXCL);
519
520 remove_partitions(dfd);
521
522 tst = dup_super(st);
523 tst->ss->load_super(tst, dfd, NULL);
524 tst->ss->getinfo_super(tst, &info);
525
526 memcpy(info.uuid, ident->uuid, 16);
527 strcpy(info.name, ident->name);
528 info.array.md_minor = minor(stb2.st_rdev);
529
530 tst->ss->update_super(tst, &info, update,
531 devname, verbose,
532 ident->uuid_set, homehost);
533 if (strcmp(update, "uuid")==0 &&
534 !ident->uuid_set) {
535 ident->uuid_set = 1;
536 memcpy(ident->uuid, info.uuid, 16);
537 }
538 if (dfd < 0)
539 fprintf(stderr, Name ": Cannot open %s for superblock update\n",
540 devname);
541 else if (tst->ss->store_super(tst, dfd))
542 fprintf(stderr, Name ": Could not re-write superblock on %s.\n",
543 devname);
544 if (dfd >= 0)
545 close(dfd);
546
547 if (strcmp(update, "uuid")==0 &&
548 ident->bitmap_fd >= 0 && !bitmap_done) {
549 if (bitmap_update_uuid(ident->bitmap_fd,
550 info.uuid,
551 tst->ss->swapuuid) != 0)
552 fprintf(stderr, Name ": Could not update uuid on external bitmap.\n");
553 else
554 bitmap_done = 1;
555 }
556 tst->ss->free_super(tst);
557 } else
558 #endif
559 {
560 struct supertype *tst = dup_super(st);
561 int dfd;
562 dfd = dev_open(devname, O_RDWR|O_EXCL);
563
564 remove_partitions(dfd);
565
566 tst->ss->load_super(tst, dfd, NULL);
567 tst->ss->getinfo_super(tst, &info);
568 tst->ss->free_super(tst);
569 close(dfd);
570 }
571
572 stat(devname, &stb);
573
574 if (verbose > 0)
575 fprintf(stderr, Name ": %s is identified as a member of %s, slot %d.\n",
576 devname, mddev, info.disk.raid_disk);
577 devices[devcnt].devname = devname;
578 devices[devcnt].uptodate = 0;
579 devices[devcnt].i = info;
580 devices[devcnt].i.disk.major = major(stb.st_rdev);
581 devices[devcnt].i.disk.minor = minor(stb.st_rdev);
582 if (most_recent < devcnt) {
583 if (devices[devcnt].i.events
584 > devices[most_recent].i.events)
585 most_recent = devcnt;
586 }
587 if (info.array.level == -4)
588 /* with multipath, the raid_disk from the superblock is meaningless */
589 i = devcnt;
590 else
591 i = devices[devcnt].i.disk.raid_disk;
592 if (i+1 == 0) {
593 if (nextspare < info.array.raid_disks)
594 nextspare = info.array.raid_disks;
595 i = nextspare++;
596 } else {
597 if (i >= info.array.raid_disks &&
598 i >= nextspare)
599 nextspare = i+1;
600 }
601 if (i < 10000) {
602 if (i >= bestcnt) {
603 unsigned int newbestcnt = i+10;
604 int *newbest = malloc(sizeof(int)*newbestcnt);
605 unsigned int c;
606 for (c=0; c < newbestcnt; c++)
607 if (c < bestcnt)
608 newbest[c] = best[c];
609 else
610 newbest[c] = -1;
611 if (best)free(best);
612 best = newbest;
613 bestcnt = newbestcnt;
614 }
615 if (best[i] >=0 &&
616 devices[best[i]].i.events
617 == devices[devcnt].i.events
618 && (devices[best[i]].i.disk.minor
619 != devices[devcnt].i.disk.minor)
620 && st->ss == &super0
621 && info.array.level != LEVEL_MULTIPATH) {
622 /* two different devices with identical superblock.
623 * Could be a mis-detection caused by overlapping
624 * partitions. fail-safe.
625 */
626 fprintf(stderr, Name ": WARNING %s and %s appear"
627 " to have very similar superblocks.\n"
628 " If they are really different, "
629 "please --zero the superblock on one\n"
630 " If they are the same or overlap,"
631 " please remove one from %s.\n",
632 devices[best[i]].devname, devname,
633 inargv ? "the list" :
634 "the\n DEVICE list in mdadm.conf"
635 );
636 close(mdfd);
637 return 1;
638 }
639 if (best[i] == -1
640 || (devices[best[i]].i.events
641 < devices[devcnt].i.events))
642 best[i] = devcnt;
643 }
644 devcnt++;
645 }
646
647 if (devcnt == 0) {
648 fprintf(stderr, Name ": no devices found for %s\n",
649 mddev);
650 if (st)
651 st->ss->free_super(st);
652 close(mdfd);
653 return 1;
654 }
655
656 if (update && strcmp(update, "byteorder")==0)
657 st->minor_version = 90;
658
659 st->ss->getinfo_super(st, &info);
660 clean = info.array.state & 1;
661
662 /* now we have some devices that might be suitable.
663 * I wonder how many
664 */
665 avail = malloc(info.array.raid_disks);
666 memset(avail, 0, info.array.raid_disks);
667 okcnt = 0;
668 sparecnt=0;
669 for (i=0; i< bestcnt ;i++) {
670 int j = best[i];
671 int event_margin = 1; /* always allow a difference of '1'
672 * like the kernel does
673 */
674 if (j < 0) continue;
675 /* note: we ignore error flags in multipath arrays
676 * as they don't make sense
677 */
678 if (info.array.level != -4)
679 if (!(devices[j].i.disk.state & (1<<MD_DISK_SYNC))) {
680 if (!(devices[j].i.disk.state
681 & (1<<MD_DISK_FAULTY)))
682 sparecnt++;
683 continue;
684 }
685 if (devices[j].i.events+event_margin >=
686 devices[most_recent].i.events) {
687 devices[j].uptodate = 1;
688 if (i < info.array.raid_disks) {
689 okcnt++;
690 avail[i]=1;
691 } else
692 sparecnt++;
693 }
694 }
695 while (force && !enough(info.array.level, info.array.raid_disks,
696 info.array.layout, 1,
697 avail, okcnt)) {
698 /* Choose the newest best drive which is
699 * not up-to-date, update the superblock
700 * and add it.
701 */
702 int fd;
703 struct supertype *tst;
704 long long current_events;
705 chosen_drive = -1;
706 for (i=0; i<info.array.raid_disks && i < bestcnt; i++) {
707 int j = best[i];
708 if (j>=0 &&
709 !devices[j].uptodate &&
710 devices[j].i.events > 0 &&
711 (chosen_drive < 0 ||
712 devices[j].i.events
713 > devices[chosen_drive].i.events))
714 chosen_drive = j;
715 }
716 if (chosen_drive < 0)
717 break;
718 current_events = devices[chosen_drive].i.events;
719 add_another:
720 if (verbose >= 0)
721 fprintf(stderr, Name ": forcing event count in %s(%d) from %d upto %d\n",
722 devices[chosen_drive].devname,
723 devices[chosen_drive].i.disk.raid_disk,
724 (int)(devices[chosen_drive].i.events),
725 (int)(devices[most_recent].i.events));
726 fd = dev_open(devices[chosen_drive].devname, O_RDWR|O_EXCL);
727 if (fd < 0) {
728 fprintf(stderr, Name ": Couldn't open %s for write - not updating\n",
729 devices[chosen_drive].devname);
730 devices[chosen_drive].i.events = 0;
731 continue;
732 }
733 tst = dup_super(st);
734 if (tst->ss->load_super(tst,fd, NULL)) {
735 close(fd);
736 fprintf(stderr, Name ": RAID superblock disappeared from %s - not updating.\n",
737 devices[chosen_drive].devname);
738 devices[chosen_drive].i.events = 0;
739 continue;
740 }
741 info.events = devices[most_recent].i.events;
742 tst->ss->update_super(tst, &info, "force-one",
743 devices[chosen_drive].devname, verbose,
744 0, NULL);
745
746 if (tst->ss->store_super(tst, fd)) {
747 close(fd);
748 fprintf(stderr, Name ": Could not re-write superblock on %s\n",
749 devices[chosen_drive].devname);
750 devices[chosen_drive].i.events = 0;
751 tst->ss->free_super(tst);
752 continue;
753 }
754 close(fd);
755 devices[chosen_drive].i.events = devices[most_recent].i.events;
756 devices[chosen_drive].uptodate = 1;
757 avail[chosen_drive] = 1;
758 okcnt++;
759 tst->ss->free_super(tst);
760
761 /* If there are any other drives of the same vintage,
762 * add them in as well. We can't lose and we might gain
763 */
764 for (i=0; i<info.array.raid_disks && i < bestcnt ; i++) {
765 int j = best[i];
766 if (j >= 0 &&
767 !devices[j].uptodate &&
768 devices[j].i.events > 0 &&
769 devices[j].i.events == current_events) {
770 chosen_drive = j;
771 goto add_another;
772 }
773 }
774 }
775
776 /* Now we want to look at the superblock which the kernel will base things on
777 * and compare the devices that we think are working with the devices that the
778 * superblock thinks are working.
779 * If there are differences and --force is given, then update this chosen
780 * superblock.
781 */
782 chosen_drive = -1;
783 st->ss->free_super(st);
784 for (i=0; chosen_drive < 0 && i<bestcnt; i++) {
785 int j = best[i];
786 int fd;
787
788 if (j<0)
789 continue;
790 if (!devices[j].uptodate)
791 continue;
792 chosen_drive = j;
793 if ((fd=dev_open(devices[j].devname, O_RDONLY|O_EXCL))< 0) {
794 fprintf(stderr, Name ": Cannot open %s: %s\n",
795 devices[j].devname, strerror(errno));
796 close(mdfd);
797 return 1;
798 }
799 if (st->ss->load_super(st,fd, NULL)) {
800 close(fd);
801 fprintf(stderr, Name ": RAID superblock has disappeared from %s\n",
802 devices[j].devname);
803 close(mdfd);
804 return 1;
805 }
806 close(fd);
807 }
808 if (st->sb == NULL) {
809 fprintf(stderr, Name ": No suitable drives found for %s\n", mddev);
810 close(mdfd);
811 return 1;
812 }
813 st->ss->getinfo_super(st, &info);
814 #ifndef MDASSEMBLE
815 sysfs_init(&info, mdfd, 0);
816 #endif
817 for (i=0; i<bestcnt; i++) {
818 int j = best[i];
819 unsigned int desired_state;
820
821 if (i < info.array.raid_disks)
822 desired_state = (1<<MD_DISK_ACTIVE) | (1<<MD_DISK_SYNC);
823 else
824 desired_state = 0;
825
826 if (j<0)
827 continue;
828 if (!devices[j].uptodate)
829 continue;
830
831 devices[j].i.disk.state = desired_state;
832
833 if (st->ss->update_super(st, &devices[j].i, "assemble", NULL,
834 verbose, 0, NULL)) {
835 if (force) {
836 if (verbose >= 0)
837 fprintf(stderr, Name ": "
838 "clearing FAULTY flag for device %d in %s for %s\n",
839 j, mddev, devices[j].devname);
840 change = 1;
841 } else {
842 if (verbose >= -1)
843 fprintf(stderr, Name ": "
844 "device %d in %s has wrong state in superblock, but %s seems ok\n",
845 i, mddev, devices[j].devname);
846 }
847 }
848 #if 0
849 if (!(super.disks[i].i.disk.state & (1 << MD_DISK_FAULTY))) {
850 fprintf(stderr, Name ": devices %d of %s is not marked FAULTY in superblock, but cannot be found\n",
851 i, mddev);
852 }
853 #endif
854 }
855 if (force && !clean &&
856 !enough(info.array.level, info.array.raid_disks,
857 info.array.layout, clean,
858 avail, okcnt)) {
859 change += st->ss->update_super(st, &info, "force-array",
860 devices[chosen_drive].devname, verbose,
861 0, NULL);
862 clean = 1;
863 }
864
865 if (change) {
866 int fd;
867 fd = dev_open(devices[chosen_drive].devname, O_RDWR|O_EXCL);
868 if (fd < 0) {
869 fprintf(stderr, Name ": Could not open %s for write - cannot Assemble array.\n",
870 devices[chosen_drive].devname);
871 close(mdfd);
872 return 1;
873 }
874 if (st->ss->store_super(st, fd)) {
875 close(fd);
876 fprintf(stderr, Name ": Could not re-write superblock on %s\n",
877 devices[chosen_drive].devname);
878 close(mdfd);
879 return 1;
880 }
881 close(fd);
882 }
883
884 /* If we are in the middle of a reshape we may need to restore saved data
885 * that was moved aside due to the reshape overwriting live data
886 * The code of doing this lives in Grow.c
887 */
888 #ifndef MDASSEMBLE
889 if (info.reshape_active) {
890 int err = 0;
891 int *fdlist = malloc(sizeof(int)* bestcnt);
892 for (i=0; i<bestcnt; i++) {
893 int j = best[i];
894 if (j >= 0) {
895 fdlist[i] = dev_open(devices[j].devname, O_RDWR|O_EXCL);
896 if (fdlist[i] < 0) {
897 fprintf(stderr, Name ": Could not open %s for write - cannot Assemble array.\n",
898 devices[j].devname);
899 err = 1;
900 break;
901 }
902 } else
903 fdlist[i] = -1;
904 }
905 if (!err)
906 err = Grow_restart(st, &info, fdlist, bestcnt, backup_file);
907 while (i>0) {
908 i--;
909 if (fdlist[i]>=0) close(fdlist[i]);
910 }
911 if (err) {
912 fprintf(stderr, Name ": Failed to restore critical section for reshape, sorry.\n");
913 close(mdfd);
914 return err;
915 }
916 }
917 #endif
918 /* count number of in-sync devices according to the superblock.
919 * We must have this number to start the array without -s or -R
920 */
921 req_cnt = info.array.working_disks;
922
923 /* Almost ready to actually *do* something */
924 if (!old_linux) {
925 int rv;
926
927 rv = set_array_info(mdfd, st, &info);
928 if (rv) {
929 fprintf(stderr, Name ": failed to set array info for %s: %s\n",
930 mddev, strerror(errno));
931 close(mdfd);
932 return 1;
933 }
934 if (ident->bitmap_fd >= 0) {
935 if (ioctl(mdfd, SET_BITMAP_FILE, ident->bitmap_fd) != 0) {
936 fprintf(stderr, Name ": SET_BITMAP_FILE failed.\n");
937 close(mdfd);
938 return 1;
939 }
940 } else if (ident->bitmap_file) {
941 /* From config file */
942 int bmfd = open(ident->bitmap_file, O_RDWR);
943 if (bmfd < 0) {
944 fprintf(stderr, Name ": Could not open bitmap file %s\n",
945 ident->bitmap_file);
946 close(mdfd);
947 return 1;
948 }
949 if (ioctl(mdfd, SET_BITMAP_FILE, bmfd) != 0) {
950 fprintf(stderr, Name ": Failed to set bitmapfile for %s\n", mddev);
951 close(bmfd);
952 close(mdfd);
953 return 1;
954 }
955 close(bmfd);
956 }
957
958 /* First, add the raid disks, but add the chosen one last */
959 for (i=0; i<= bestcnt; i++) {
960 int j;
961 if (i < bestcnt) {
962 j = best[i];
963 if (j == chosen_drive)
964 continue;
965 } else
966 j = chosen_drive;
967
968 if (j >= 0 /* && devices[j].uptodate */) {
969 rv = add_disk(mdfd, st, &info, &devices[j].i);
970
971 if (rv) {
972 fprintf(stderr, Name ": failed to add "
973 "%s to %s: %s\n",
974 devices[j].devname,
975 mddev,
976 strerror(errno));
977 if (i < info.array.raid_disks
978 || i == bestcnt)
979 okcnt--;
980 else
981 sparecnt--;
982 } else if (verbose > 0)
983 fprintf(stderr, Name ": added %s "
984 "to %s as %d\n",
985 devices[j].devname, mddev,
986 devices[j].i.disk.raid_disk);
987 } else if (verbose > 0 && i < info.array.raid_disks)
988 fprintf(stderr, Name ": no uptodate device for "
989 "slot %d of %s\n",
990 i, mddev);
991 }
992
993 if (info.array.level == LEVEL_CONTAINER) {
994 if (verbose >= 0) {
995 fprintf(stderr, Name ": Container %s has been "
996 "assembled with %d drive%s",
997 mddev, okcnt+sparecnt, okcnt+sparecnt==1?"":"s");
998 if (okcnt < info.array.raid_disks)
999 fprintf(stderr, " (out of %d)",
1000 info.array.raid_disks);
1001 fprintf(stderr, "\n");
1002 }
1003 close(mdfd);
1004 return 0;
1005 }
1006
1007 if (runstop == 1 ||
1008 (runstop <= 0 &&
1009 ( enough(info.array.level, info.array.raid_disks,
1010 info.array.layout, clean, avail, okcnt) &&
1011 (okcnt >= req_cnt || start_partial_ok)
1012 ))) {
1013 if (ioctl(mdfd, RUN_ARRAY, NULL)==0) {
1014 if (verbose >= 0) {
1015 fprintf(stderr, Name ": %s has been started with %d drive%s",
1016 mddev, okcnt, okcnt==1?"":"s");
1017 if (okcnt < info.array.raid_disks)
1018 fprintf(stderr, " (out of %d)", info.array.raid_disks);
1019 if (sparecnt)
1020 fprintf(stderr, " and %d spare%s", sparecnt, sparecnt==1?"":"s");
1021 fprintf(stderr, ".\n");
1022 }
1023 close(mdfd);
1024 if (auto_assem) {
1025 int usecs = 1;
1026 /* There is a nasty race with 'mdadm --monitor'.
1027 * If it opens this device before we close it,
1028 * it gets an incomplete open on which IO
1029 * doesn't work and the capacity is
1030 * wrong.
1031 * If we reopen (to check for layered devices)
1032 * before --monitor closes, we loose.
1033 *
1034 * So: wait upto 1 second for there to be
1035 * a non-zero capacity.
1036 */
1037 while (usecs < 1000) {
1038 mdfd = open(mddev, O_RDONLY);
1039 if (mdfd >= 0) {
1040 unsigned long long size;
1041 if (get_dev_size(mdfd, NULL, &size) &&
1042 size > 0)
1043 break;
1044 close(mdfd);
1045 }
1046 usleep(usecs);
1047 usecs <<= 1;
1048 }
1049 }
1050 return 0;
1051 }
1052 fprintf(stderr, Name ": failed to RUN_ARRAY %s: %s\n",
1053 mddev, strerror(errno));
1054
1055 if (!enough(info.array.level, info.array.raid_disks,
1056 info.array.layout, 1, avail, okcnt))
1057 fprintf(stderr, Name ": Not enough devices to "
1058 "start the array.\n");
1059 else if (!enough(info.array.level,
1060 info.array.raid_disks,
1061 info.array.layout, clean,
1062 avail, okcnt))
1063 fprintf(stderr, Name ": Not enough devices to "
1064 "start the array while not clean "
1065 "- consider --force.\n");
1066
1067 if (auto_assem)
1068 ioctl(mdfd, STOP_ARRAY, NULL);
1069 close(mdfd);
1070 return 1;
1071 }
1072 if (runstop == -1) {
1073 fprintf(stderr, Name ": %s assembled from %d drive%s",
1074 mddev, okcnt, okcnt==1?"":"s");
1075 if (okcnt != info.array.raid_disks)
1076 fprintf(stderr, " (out of %d)", info.array.raid_disks);
1077 fprintf(stderr, ", but not started.\n");
1078 close(mdfd);
1079 return 0;
1080 }
1081 if (verbose >= -1) {
1082 fprintf(stderr, Name ": %s assembled from %d drive%s", mddev, okcnt, okcnt==1?"":"s");
1083 if (sparecnt)
1084 fprintf(stderr, " and %d spare%s", sparecnt, sparecnt==1?"":"s");
1085 if (!enough(info.array.level, info.array.raid_disks,
1086 info.array.layout, 1, avail, okcnt))
1087 fprintf(stderr, " - not enough to start the array.\n");
1088 else if (!enough(info.array.level,
1089 info.array.raid_disks,
1090 info.array.layout, clean,
1091 avail, okcnt))
1092 fprintf(stderr, " - not enough to start the "
1093 "array while not clean - consider "
1094 "--force.\n");
1095 else {
1096 if (req_cnt == info.array.raid_disks)
1097 fprintf(stderr, " - need all %d to start it", req_cnt);
1098 else
1099 fprintf(stderr, " - need %d of %d to start", req_cnt, info.array.raid_disks);
1100 fprintf(stderr, " (use --run to insist).\n");
1101 }
1102 }
1103 if (auto_assem)
1104 ioctl(mdfd, STOP_ARRAY, NULL);
1105 return 1;
1106 } else {
1107 /* The "chosen_drive" is a good choice, and if necessary, the superblock has
1108 * been updated to point to the current locations of devices.
1109 * so we can just start the array
1110 */
1111 unsigned long dev;
1112 dev = makedev(devices[chosen_drive].i.disk.major,
1113 devices[chosen_drive].i.disk.minor);
1114 if (ioctl(mdfd, START_ARRAY, dev)) {
1115 fprintf(stderr, Name ": Cannot start array: %s\n",
1116 strerror(errno));
1117 }
1118
1119 }
1120 close(mdfd);
1121 return 0;
1122 }
Unnamed repository; edit this file 'description' to name the repository.