]> git.ipfire.org Git - thirdparty/mdadm.git/blob - Manage.c
projects / thirdparty / mdadm.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
--stop: separate 'is busy' test for 'did it stop properly'.
[thirdparty/mdadm.git] / Manage.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2009 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 #define REGISTER_DEV _IO (MD_MAJOR, 1)
31 #define START_MD _IO (MD_MAJOR, 2)
32 #define STOP_MD _IO (MD_MAJOR, 3)
33
34 int Manage_ro(char *devname, int fd, int readonly)
35 {
36 /* switch to readonly or rw
37 *
38 * requires >= 0.90.0
39 * first check that array is runing
40 * use RESTART_ARRAY_RW or STOP_ARRAY_RO
41 *
42 */
43 mdu_array_info_t array;
44 #ifndef MDASSEMBLE
45 struct mdinfo *mdi;
46 #endif
47
48 if (md_get_version(fd) < 9000) {
49 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
50 return 1;
51 }
52 #ifndef MDASSEMBLE
53 /* If this is an externally-manage array, we need to modify the
54 * metadata_version so that mdmon doesn't undo our change.
55 */
56 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
57 if (mdi &&
58 mdi->array.major_version == -1 &&
59 mdi->array.level > 0 &&
60 is_subarray(mdi->text_version)) {
61 char vers[64];
62 strcpy(vers, "external:");
63 strcat(vers, mdi->text_version);
64 if (readonly > 0) {
65 int rv;
66 /* We set readonly ourselves. */
67 vers[9] = '-';
68 sysfs_set_str(mdi, NULL, "metadata_version", vers);
69
70 close(fd);
71 rv = sysfs_set_str(mdi, NULL, "array_state", "readonly");
72
73 if (rv < 0) {
74 fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
75 devname, strerror(errno));
76
77 vers[9] = mdi->text_version[0];
78 sysfs_set_str(mdi, NULL, "metadata_version", vers);
79 return 1;
80 }
81 } else {
82 char *cp;
83 /* We cannot set read/write - must signal mdmon */
84 vers[9] = '/';
85 sysfs_set_str(mdi, NULL, "metadata_version", vers);
86
87 cp = strchr(vers+10, '/');
88 if (*cp)
89 *cp = 0;
90 ping_monitor(vers+10);
91 }
92 return 0;
93 }
94 #endif
95 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
96 fprintf(stderr, Name ": %s does not appear to be active.\n",
97 devname);
98 return 1;
99 }
100
101 if (readonly>0) {
102 if (ioctl(fd, STOP_ARRAY_RO, NULL)) {
103 fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
104 devname, strerror(errno));
105 return 1;
106 }
107 } else if (readonly < 0) {
108 if (ioctl(fd, RESTART_ARRAY_RW, NULL)) {
109 fprintf(stderr, Name ": failed to set writable for %s: %s\n",
110 devname, strerror(errno));
111 return 1;
112 }
113 }
114 return 0;
115 }
116
117 #ifndef MDASSEMBLE
118
119 static void remove_devices(int devnum, char *path)
120 {
121 /*
122 * Remove names at 'path' - possibly with
123 * partition suffixes - which link to the 'standard'
124 * name for devnum. These were probably created
125 * by mdadm when the array was assembled.
126 */
127 char base[40];
128 char *path2;
129 char link[1024];
130 int n;
131 int part;
132 char *be;
133 char *pe;
134
135 if (!path)
136 return;
137
138 if (devnum >= 0)
139 sprintf(base, "/dev/md%d", devnum);
140 else
141 sprintf(base, "/dev/md_d%d", -1-devnum);
142 be = base + strlen(base);
143
144 path2 = malloc(strlen(path)+20);
145 strcpy(path2, path);
146 pe = path2 + strlen(path2);
147
148 for (part = 0; part < 16; part++) {
149 if (part) {
150 sprintf(be, "p%d", part);
151
152 if (isdigit(pe[-1]))
153 sprintf(pe, "p%d", part);
154 else
155 sprintf(pe, "%d", part);
156 }
157 n = readlink(path2, link, sizeof(link));
158 if (n && (int)strlen(base) == n &&
159 strncmp(link, base, n) == 0)
160 unlink(path2);
161 }
162 free(path2);
163 }
164
165
166 int Manage_runstop(char *devname, int fd, int runstop, int quiet)
167 {
168 /* Run or stop the array. array must already be configured
169 * required >= 0.90.0
170 * Only print failure messages if quiet == 0;
171 * quiet > 0 means really be quiet
172 * quiet < 0 means we will try again if it fails.
173 */
174 mdu_param_t param; /* unused */
175
176 if (runstop == -1 && md_get_version(fd) < 9000) {
177 if (ioctl(fd, STOP_MD, 0)) {
178 if (quiet == 0) fprintf(stderr,
179 Name ": stopping device %s "
180 "failed: %s\n",
181 devname, strerror(errno));
182 return 1;
183 }
184 }
185
186 if (md_get_version(fd) < 9000) {
187 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
188 return 1;
189 }
190 /*
191 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
192 fprintf(stderr, Name ": %s does not appear to be active.\n",
193 devname);
194 return 1;
195 }
196 */
197 if (runstop>0) {
198 if (ioctl(fd, RUN_ARRAY, &param)) {
199 fprintf(stderr, Name ": failed to run array %s: %s\n",
200 devname, strerror(errno));
201 return 1;
202 }
203 if (quiet <= 0)
204 fprintf(stderr, Name ": started %s\n", devname);
205 } else if (runstop < 0){
206 struct map_ent *map = NULL;
207 struct stat stb;
208 struct mdinfo *mdi;
209 int devnum;
210 int err;
211 int count;
212 /* If this is an mdmon managed array, just write 'inactive'
213 * to the array state and let mdmon clear up.
214 */
215 devnum = fd2devnum(fd);
216 /* Get EXCL access first. If this fails, then attempting
217 * to stop is probably a bad idea.
218 */
219 close(fd);
220 fd = open(devname, O_RDONLY|O_EXCL);
221 if (fd < 0 || fd2devnum(fd) != devnum) {
222 if (fd >= 0)
223 close(fd);
224 fprintf(stderr,
225 Name ": Cannot get exclusive access to %s:"
226 " possibly it is still in use.\n",
227 devname);
228 return 1;
229 }
230 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
231 if (mdi &&
232 mdi->array.level > 0 &&
233 is_subarray(mdi->text_version)) {
234 /* This is mdmon managed. */
235 close(fd);
236 if (sysfs_set_str(mdi, NULL,
237 "array_state", "inactive") < 0) {
238 if (quiet == 0)
239 fprintf(stderr, Name
240 ": failed to stop array %s: %s\n",
241 devname, strerror(errno));
242 return 1;
243 }
244
245 /* Give monitor a chance to act */
246 ping_monitor(mdi->text_version);
247
248 fd = open_dev_excl(devnum);
249 if (fd < 0) {
250 fprintf(stderr, Name
251 ": failed to completely stop %s"
252 ": Device is busy\n",
253 devname);
254 return 1;
255 }
256 } else if (mdi &&
257 mdi->array.major_version == -1 &&
258 mdi->array.minor_version == -2 &&
259 !is_subarray(mdi->text_version)) {
260 struct mdstat_ent *mds, *m;
261 /* container, possibly mdmon-managed.
262 * Make sure mdmon isn't opening it, which
263 * would interfere with the 'stop'
264 */
265 ping_monitor(mdi->sys_name);
266
267 /* now check that there are no existing arrays
268 * which are members of this array
269 */
270 mds = mdstat_read(0, 0);
271 for (m=mds; m; m=m->next)
272 if (m->metadata_version &&
273 strncmp(m->metadata_version, "external:", 9)==0 &&
274 is_subarray(m->metadata_version+9) &&
275 devname2devnum(m->metadata_version+10) == devnum) {
276 if (!quiet)
277 fprintf(stderr, Name
278 ": Cannot stop container %s: "
279 "member %s still active\n",
280 devname, m->dev);
281 free_mdstat(mds);
282 if (mdi)
283 sysfs_free(mdi);
284 return 1;
285 }
286 }
287
288 /* As we have an O_EXCL open, any use of the device
289 * which blocks STOP_ARRAY is probably a transient use,
290 * so it is reasonable to retry for a while - 5 seconds.
291 */
292 count = 25; err = 0;
293 while (count && fd >= 0
294 && (err = ioctl(fd, STOP_ARRAY, NULL)) < 0
295 && errno == EBUSY) {
296 usleep(200000);
297 count --;
298 }
299 if (fd >= 0 && err) {
300 if (quiet == 0) {
301 fprintf(stderr, Name
302 ": failed to stop array %s: %s\n",
303 devname, strerror(errno));
304 if (errno == EBUSY)
305 fprintf(stderr, "Perhaps a running "
306 "process, mounted filesystem "
307 "or active volume group?\n");
308 }
309 if (mdi)
310 sysfs_free(mdi);
311 return 1;
312 }
313 /* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
314 * was stopped, so We'll do it here just to be sure. Drop any
315 * partitions as well...
316 */
317 if (fd >= 0)
318 ioctl(fd, BLKRRPART, 0);
319 if (mdi)
320 sysfs_uevent(mdi, "change");
321
322
323 if (devnum != NoMdDev &&
324 (stat("/dev/.udev", &stb) != 0 ||
325 check_env("MDADM_NO_UDEV"))) {
326 struct map_ent *mp = map_by_devnum(&map, devnum);
327 remove_devices(devnum, mp ? mp->path : NULL);
328 }
329
330
331 if (quiet <= 0)
332 fprintf(stderr, Name ": stopped %s\n", devname);
333 map_lock(&map);
334 map_remove(&map, devnum);
335 map_unlock(&map);
336 }
337 return 0;
338 }
339
340 int Manage_resize(char *devname, int fd, long long size, int raid_disks)
341 {
342 mdu_array_info_t info;
343 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
344 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
345 devname, strerror(errno));
346 return 1;
347 }
348 if (size >= 0)
349 info.size = size;
350 if (raid_disks > 0)
351 info.raid_disks = raid_disks;
352 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
353 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
354 devname, strerror(errno));
355 return 1;
356 }
357 return 0;
358 }
359
360 int Manage_subdevs(char *devname, int fd,
361 mddev_dev_t devlist, int verbose, int test)
362 {
363 /* do something to each dev.
364 * devmode can be
365 * 'a' - add the device
366 * try HOT_ADD_DISK
367 * If that fails EINVAL, try ADD_NEW_DISK
368 * 'r' - remove the device HOT_REMOVE_DISK
369 * device can be 'faulty' or 'detached' in which case all
370 * matching devices are removed.
371 * 'f' - set the device faulty SET_DISK_FAULTY
372 * device can be 'detached' in which case any device that
373 * is inaccessible will be marked faulty.
374 * For 'f' and 'r', the device can also be a kernel-internal
375 * name such as 'sdb'.
376 */
377 mddev_dev_t add_devlist = NULL;
378 mdu_array_info_t array;
379 mdu_disk_info_t disc;
380 unsigned long long array_size;
381 mddev_dev_t dv, next = NULL;
382 struct stat stb;
383 int j, jnext = 0;
384 int tfd = -1;
385 struct supertype *st, *tst;
386 int duuid[4];
387 int ouuid[4];
388 int lfd = -1;
389 int sysfd = -1;
390 int count = 0; /* number of actions taken */
391
392 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
393 fprintf(stderr, Name ": cannot get array info for %s\n",
394 devname);
395 return 1;
396 }
397
398 /* array.size is only 32 bit and may be truncated.
399 * So read from sysfs if possible, and record number of sectors
400 */
401
402 array_size = get_component_size(fd);
403 if (array_size <= 0)
404 array_size = array.size * 2;
405
406 tst = super_by_fd(fd);
407 if (!tst) {
408 fprintf(stderr, Name ": unsupport array - version %d.%d\n",
409 array.major_version, array.minor_version);
410 return 1;
411 }
412
413 stb.st_rdev = 0;
414 for (dv = devlist, j=0 ; dv; dv = next, j = jnext) {
415 unsigned long long ldsize;
416 char dvname[20];
417 char *dnprintable = dv->devname;
418 char *add_dev = dv->devname;
419 int err;
420 int re_add_failed = 0;
421
422 next = dv->next;
423 jnext = 0;
424
425 if (strcmp(dv->devname, "failed")==0 ||
426 strcmp(dv->devname, "faulty")==0) {
427 if (dv->disposition != 'r') {
428 fprintf(stderr, Name ": %s only meaningful "
429 "with -r, not -%c\n",
430 dv->devname, dv->disposition);
431 return 1;
432 }
433 for (; j < array.raid_disks + array.nr_disks ; j++) {
434 unsigned dev;
435 disc.number = j;
436 if (ioctl(fd, GET_DISK_INFO, &disc))
437 continue;
438 if (disc.major == 0 && disc.minor == 0)
439 continue;
440 if ((disc.state & 1) == 0) /* faulty */
441 continue;
442 dev = makedev(disc.major, disc.minor);
443 if (stb.st_rdev == dev)
444 /* already did that one */
445 continue;
446 stb.st_rdev = dev;
447 next = dv;
448 /* same slot again next time - things might
449 * have reshuffled */
450 jnext = j;
451 sprintf(dvname,"%d:%d", disc.major, disc.minor);
452 dnprintable = dvname;
453 break;
454 }
455 if (next != dv)
456 continue;
457 } else if (strcmp(dv->devname, "detached") == 0) {
458 if (dv->disposition != 'r' && dv->disposition != 'f') {
459 fprintf(stderr, Name ": %s only meaningful "
460 "with -r of -f, not -%c\n",
461 dv->devname, dv->disposition);
462 return 1;
463 }
464 for (; j < array.raid_disks + array.nr_disks; j++) {
465 int sfd;
466 unsigned dev;
467 disc.number = j;
468 if (ioctl(fd, GET_DISK_INFO, &disc))
469 continue;
470 if (disc.major == 0 && disc.minor == 0)
471 continue;
472 sprintf(dvname,"%d:%d", disc.major, disc.minor);
473 sfd = dev_open(dvname, O_RDONLY);
474 if (sfd >= 0) {
475 close(sfd);
476 continue;
477 }
478 if (dv->disposition == 'f' &&
479 (disc.state & 1) == 1) /* already faulty */
480 continue;
481 if (errno != ENXIO)
482 continue;
483 dev = makedev(disc.major, disc.minor);
484 if (stb.st_rdev == dev)
485 /* already did that one */
486 continue;
487 stb.st_rdev = dev;
488 next = dv;
489 /* same slot again next time - things might
490 * have reshuffled */
491 jnext = j;
492 dnprintable = dvname;
493 break;
494 }
495 if (next != dv)
496 continue;
497 } else if (strcmp(dv->devname, "missing") == 0) {
498 if (dv->disposition != 'a' || dv->re_add == 0) {
499 fprintf(stderr, Name ": 'missing' only meaningful "
500 "with --re-add\n");
501 return 1;
502 }
503 if (add_devlist == NULL)
504 add_devlist = conf_get_devs();
505 if (add_devlist == NULL) {
506 fprintf(stderr, Name ": no devices to scan for missing members.");
507 continue;
508 }
509 add_dev = add_devlist->devname;
510 add_devlist = add_devlist->next;
511 if (add_devlist != NULL)
512 next = dv;
513 if (stat(add_dev, &stb) < 0)
514 continue;
515 } else if (strchr(dv->devname, '/') == NULL &&
516 strchr(dv->devname, ':') == NULL &&
517 strlen(dv->devname) < 50) {
518 /* Assume this is a kernel-internal name like 'sda1' */
519 int found = 0;
520 char dname[55];
521 if (dv->disposition != 'r' && dv->disposition != 'f') {
522 fprintf(stderr, Name ": %s only meaningful "
523 "with -r or -f, not -%c\n",
524 dv->devname, dv->disposition);
525 return 1;
526 }
527
528 sprintf(dname, "dev-%s", dv->devname);
529 sysfd = sysfs_open(fd2devnum(fd), dname, "block/dev");
530 if (sysfd >= 0) {
531 char dn[20];
532 int mj,mn;
533 if (sysfs_fd_get_str(sysfd, dn, 20) > 0 &&
534 sscanf(dn, "%d:%d", &mj,&mn) == 2) {
535 stb.st_rdev = makedev(mj,mn);
536 found = 1;
537 }
538 close(sysfd);
539 sysfd = -1;
540 }
541 if (!found) {
542 sysfd = sysfs_open(fd2devnum(fd), dname, "state");
543 if (sysfd < 0) {
544 fprintf(stderr, Name ": %s does not appear "
545 "to be a component of %s\n",
546 dv->devname, devname);
547 return 1;
548 }
549 }
550 } else {
551 j = 0;
552
553 tfd = dev_open(dv->devname, O_RDONLY);
554 if (tfd < 0 && dv->disposition == 'r' &&
555 lstat(dv->devname, &stb) == 0)
556 /* Be happy, the lstat worked, that is
557 * enough for --remove
558 */
559 ;
560 else {
561 if (tfd < 0 || fstat(tfd, &stb) != 0) {
562 fprintf(stderr, Name ": cannot find %s: %s\n",
563 dv->devname, strerror(errno));
564 if (tfd >= 0)
565 close(tfd);
566 return 1;
567 }
568 close(tfd);
569 tfd = -1;
570 }
571 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
572 fprintf(stderr, Name ": %s is not a "
573 "block device.\n",
574 dv->devname);
575 return 1;
576 }
577 }
578 switch(dv->disposition){
579 default:
580 fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
581 dv->devname, dv->disposition);
582 return 1;
583 case 'a':
584 /* add the device */
585 if (tst->subarray[0]) {
586 fprintf(stderr, Name ": Cannot add disks to a"
587 " \'member\' array, perform this"
588 " operation on the parent container\n");
589 return 1;
590 }
591 /* Make sure it isn't in use (in 2.6 or later) */
592 tfd = dev_open(add_dev, O_RDONLY|O_EXCL|O_DIRECT);
593 if (tfd < 0 && add_dev != dv->devname)
594 continue;
595 if (tfd < 0) {
596 fprintf(stderr, Name ": Cannot open %s: %s\n",
597 dv->devname, strerror(errno));
598 return 1;
599 }
600
601 st = dup_super(tst);
602
603 if (array.not_persistent==0)
604 st->ss->load_super(st, tfd, NULL);
605
606 if (add_dev == dv->devname) {
607 if (!get_dev_size(tfd, dv->devname, &ldsize)) {
608 close(tfd);
609 return 1;
610 }
611 } else if (!get_dev_size(tfd, NULL, &ldsize)) {
612 close(tfd);
613 tfd = -1;
614 continue;
615 }
616
617 if (!tst->ss->external &&
618 array.major_version == 0 &&
619 md_get_version(fd)%100 < 2) {
620 close(tfd);
621 tfd = -1;
622 if (ioctl(fd, HOT_ADD_DISK,
623 (unsigned long)stb.st_rdev)==0) {
624 if (verbose >= 0)
625 fprintf(stderr, Name ": hot added %s\n",
626 add_dev);
627 continue;
628 }
629
630 fprintf(stderr, Name ": hot add failed for %s: %s\n",
631 add_dev, strerror(errno));
632 return 1;
633 }
634
635 if (array.not_persistent == 0 || tst->ss->external) {
636
637 /* need to find a sample superblock to copy, and
638 * a spare slot to use.
639 * For 'external' array (well, container based),
640 * We can just load the metadata for the array.
641 */
642 if (tst->sb)
643 /* already loaded */;
644 else if (tst->ss->external) {
645 tst->ss->load_super(tst, fd, NULL);
646 } else for (j = 0; j < tst->max_devs; j++) {
647 char *dev;
648 int dfd;
649 disc.number = j;
650 if (ioctl(fd, GET_DISK_INFO, &disc))
651 continue;
652 if (disc.major==0 && disc.minor==0)
653 continue;
654 if ((disc.state & 4)==0) continue; /* sync */
655 /* Looks like a good device to try */
656 dev = map_dev(disc.major, disc.minor, 1);
657 if (!dev) continue;
658 dfd = dev_open(dev, O_RDONLY);
659 if (dfd < 0) continue;
660 if (tst->ss->load_super(tst, dfd,
661 NULL)) {
662 close(dfd);
663 continue;
664 }
665 close(dfd);
666 break;
667 }
668 /* FIXME this is a bad test to be using */
669 if (!tst->sb) {
670 close(tfd);
671 fprintf(stderr, Name ": cannot find valid superblock in this array - HELP\n");
672 return 1;
673 }
674
675 /* Make sure device is large enough */
676 if (tst->ss->avail_size(tst, ldsize/512) <
677 array_size) {
678 close(tfd);
679 tfd = -1;
680 if (add_dev != dv->devname)
681 continue;
682 fprintf(stderr, Name ": %s not large enough to join array\n",
683 dv->devname);
684 return 1;
685 }
686
687 /* Possibly this device was recently part of the array
688 * and was temporarily removed, and is now being re-added.
689 * If so, we can simply re-add it.
690 */
691 tst->ss->uuid_from_super(tst, duuid);
692
693 /* re-add doesn't work for version-1 superblocks
694 * before 2.6.18 :-(
695 */
696 if (array.major_version == 1 &&
697 get_linux_version() <= 2006018)
698 ;
699 else if (st->sb) {
700 struct mdinfo mdi;
701 st->ss->getinfo_super(st, &mdi);
702 st->ss->uuid_from_super(st, ouuid);
703 if ((mdi.disk.state & (1<<MD_DISK_ACTIVE)) &&
704 !(mdi.disk.state & (1<<MD_DISK_FAULTY)) &&
705 memcmp(duuid, ouuid, sizeof(ouuid))==0) {
706 /* look like it is worth a try. Need to
707 * make sure kernel will accept it though.
708 */
709 disc.number = mdi.disk.number;
710 if (ioctl(fd, GET_DISK_INFO, &disc) != 0
711 || disc.major != 0 || disc.minor != 0
712 || !enough_fd(fd))
713 goto skip_re_add;
714 disc.major = major(stb.st_rdev);
715 disc.minor = minor(stb.st_rdev);
716 disc.number = mdi.disk.number;
717 disc.raid_disk = mdi.disk.raid_disk;
718 disc.state = mdi.disk.state;
719 if (dv->writemostly == 1)
720 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
721 if (dv->writemostly == 2)
722 disc.state &= ~(1 << MD_DISK_WRITEMOSTLY);
723 remove_partitions(tfd);
724 close(tfd);
725 tfd = -1;
726 /* don't even try if disk is marked as faulty */
727 errno = 0;
728 if (ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
729 if (verbose >= 0)
730 fprintf(stderr, Name ": re-added %s\n", add_dev);
731 count++;
732 continue;
733 }
734 if (errno == ENOMEM || errno == EROFS) {
735 fprintf(stderr, Name ": add new device failed for %s: %s\n",
736 add_dev, strerror(errno));
737 if (add_dev != dv->devname)
738 continue;
739 return 1;
740 }
741 skip_re_add:
742 re_add_failed = 1;
743 }
744 }
745 if (add_dev != dv->devname) {
746 if (verbose > 0)
747 fprintf(stderr, Name
748 ": --re-add for %s to %s is not possible\n",
749 add_dev, devname);
750 if (tfd >= 0) {
751 close(tfd);
752 tfd = -1;
753 }
754 continue;
755 }
756 if (dv->re_add) {
757 if (tfd >= 0)
758 close(tfd);
759 fprintf(stderr, Name
760 ": --re-add for %s to %s is not possible\n",
761 dv->devname, devname);
762 return 1;
763 }
764 if (re_add_failed) {
765 fprintf(stderr, Name ": %s reports being an active member for %s, but a --re-add fails.\n",
766 dv->devname, devname);
767 fprintf(stderr, Name ": not performing --add as that would convert %s in to a spare.\n",
768 dv->devname);
769 fprintf(stderr, Name ": To make this a spare, use \"mdadm --zero-superblock %s\" first.\n",
770 dv->devname);
771 if (tfd >= 0)
772 close(tfd);
773 return 1;
774 }
775 } else {
776 /* non-persistent. Must ensure that new drive
777 * is at least array.size big.
778 */
779 if (ldsize/512 < array_size) {
780 fprintf(stderr, Name ": %s not large enough to join array\n",
781 dv->devname);
782 if (tfd >= 0)
783 close(tfd);
784 return 1;
785 }
786 }
787 /* committed to really trying this device now*/
788 if (tfd >= 0) {
789 remove_partitions(tfd);
790 close(tfd);
791 tfd = -1;
792 }
793 /* in 2.6.17 and earlier, version-1 superblocks won't
794 * use the number we write, but will choose a free number.
795 * we must choose the same free number, which requires
796 * starting at 'raid_disks' and counting up
797 */
798 for (j = array.raid_disks; j< tst->max_devs; j++) {
799 disc.number = j;
800 if (ioctl(fd, GET_DISK_INFO, &disc))
801 break;
802 if (disc.major==0 && disc.minor==0)
803 break;
804 if (disc.state & 8) /* removed */
805 break;
806 }
807 disc.major = major(stb.st_rdev);
808 disc.minor = minor(stb.st_rdev);
809 disc.number =j;
810 disc.state = 0;
811 if (array.not_persistent==0) {
812 int dfd;
813 if (dv->writemostly == 1)
814 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
815 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
816 if (tst->ss->add_to_super(tst, &disc, dfd,
817 dv->devname)) {
818 close(dfd);
819 return 1;
820 }
821 /* write_init_super will close 'dfd' */
822 if (tst->ss->write_init_super(tst))
823 return 1;
824 } else if (dv->re_add) {
825 /* this had better be raid1.
826 * As we are "--re-add"ing we must find a spare slot
827 * to fill.
828 */
829 char *used = malloc(array.raid_disks);
830 memset(used, 0, array.raid_disks);
831 for (j=0; j< tst->max_devs; j++) {
832 mdu_disk_info_t disc2;
833 disc2.number = j;
834 if (ioctl(fd, GET_DISK_INFO, &disc2))
835 continue;
836 if (disc2.major==0 && disc2.minor==0)
837 continue;
838 if (disc2.state & 8) /* removed */
839 continue;
840 if (disc2.raid_disk < 0)
841 continue;
842 if (disc2.raid_disk > array.raid_disks)
843 continue;
844 used[disc2.raid_disk] = 1;
845 }
846 for (j=0 ; j<array.raid_disks; j++)
847 if (!used[j]) {
848 disc.raid_disk = j;
849 disc.state |= (1<<MD_DISK_SYNC);
850 break;
851 }
852 free(used);
853 }
854 if (dv->writemostly == 1)
855 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
856 if (tst->ss->external) {
857 /* add a disk to an external metadata container
858 * only if mdmon is around to see it
859 */
860 struct mdinfo new_mdi;
861 struct mdinfo *sra;
862 int container_fd;
863 int devnum = fd2devnum(fd);
864 int dfd;
865
866 container_fd = open_dev_excl(devnum);
867 if (container_fd < 0) {
868 fprintf(stderr, Name ": add failed for %s:"
869 " could not get exclusive access to container\n",
870 dv->devname);
871 return 1;
872 }
873
874 if (!mdmon_running(devnum)) {
875 fprintf(stderr, Name ": add failed for %s: mdmon not running\n",
876 dv->devname);
877 close(container_fd);
878 return 1;
879 }
880
881 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
882 if (tst->ss->add_to_super(tst, &disc, dfd,
883 dv->devname)) {
884 close(dfd);
885 close(container_fd);
886 return 1;
887 }
888 close(dfd);
889
890 sra = sysfs_read(container_fd, -1, 0);
891 if (!sra) {
892 fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
893 dv->devname);
894 close(container_fd);
895 return 1;
896 }
897 sra->array.level = LEVEL_CONTAINER;
898 /* Need to set data_offset and component_size */
899 tst->ss->getinfo_super(tst, &new_mdi);
900 new_mdi.disk.major = disc.major;
901 new_mdi.disk.minor = disc.minor;
902 new_mdi.recovery_start = 0;
903 if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
904 fprintf(stderr, Name ": add new device to external metadata"
905 " failed for %s\n", dv->devname);
906 close(container_fd);
907 return 1;
908 }
909 ping_monitor(devnum2devname(devnum));
910 sysfs_free(sra);
911 close(container_fd);
912 } else if (ioctl(fd, ADD_NEW_DISK, &disc)) {
913 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
914 dv->devname, j, strerror(errno));
915 return 1;
916 }
917 if (verbose >= 0)
918 fprintf(stderr, Name ": added %s\n", dv->devname);
919 break;
920
921 case 'r':
922 /* hot remove */
923 if (tst->subarray[0]) {
924 fprintf(stderr, Name ": Cannot remove disks from a"
925 " \'member\' array, perform this"
926 " operation on the parent container\n");
927 if (sysfd >= 0)
928 close(sysfd);
929 return 1;
930 }
931 if (tst->ss->external) {
932 /* To remove a device from a container, we must
933 * check that it isn't in use in an array.
934 * This involves looking in the 'holders'
935 * directory - there must be just one entry,
936 * the container.
937 * To ensure that it doesn't get used as a
938 * hold spare while we are checking, we
939 * get an O_EXCL open on the container
940 */
941 int dnum = fd2devnum(fd);
942 lfd = open_dev_excl(dnum);
943 if (lfd < 0) {
944 fprintf(stderr, Name
945 ": Cannot get exclusive access "
946 " to container - odd\n");
947 if (sysfd >= 0)
948 close(sysfd);
949 return 1;
950 }
951 /* in the detached case it is not possible to
952 * check if we are the unique holder, so just
953 * rely on the 'detached' checks
954 */
955 if (strcmp(dv->devname, "detached") == 0 ||
956 sysfd >= 0 ||
957 sysfs_unique_holder(dnum, stb.st_rdev))
958 /* pass */;
959 else {
960 fprintf(stderr, Name
961 ": %s is %s, cannot remove.\n",
962 dnprintable,
963 errno == EEXIST ? "still in use":
964 "not a member");
965 close(lfd);
966 return 1;
967 }
968 }
969 /* FIXME check that it is a current member */
970 if (sysfd >= 0) {
971 /* device has been removed and we don't know
972 * the major:minor number
973 */
974 int n = write(sysfd, "remove", 6);
975 if (n != 6)
976 err = -1;
977 else
978 err = 0;
979 close(sysfd);
980 sysfd = -1;
981 } else {
982 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
983 if (err && errno == ENODEV) {
984 /* Old kernels rejected this if no personality
985 * registered */
986 struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
987 struct mdinfo *dv = NULL;
988 if (sra)
989 dv = sra->devs;
990 for ( ; dv ; dv=dv->next)
991 if (dv->disk.major == (int)major(stb.st_rdev) &&
992 dv->disk.minor == (int)minor(stb.st_rdev))
993 break;
994 if (dv)
995 err = sysfs_set_str(sra, dv,
996 "state", "remove");
997 else
998 err = -1;
999 if (sra)
1000 sysfs_free(sra);
1001 }
1002 }
1003 if (err) {
1004 fprintf(stderr, Name ": hot remove failed "
1005 "for %s: %s\n", dnprintable,
1006 strerror(errno));
1007 if (lfd >= 0)
1008 close(lfd);
1009 return 1;
1010 }
1011 if (tst->ss->external) {
1012 /*
1013 * Before dropping our exclusive open we make an
1014 * attempt at preventing mdmon from seeing an
1015 * 'add' event before reconciling this 'remove'
1016 * event.
1017 */
1018 char *name = devnum2devname(fd2devnum(fd));
1019
1020 if (!name) {
1021 fprintf(stderr, Name ": unable to get container name\n");
1022 return 1;
1023 }
1024
1025 ping_manager(name);
1026 free(name);
1027 }
1028 if (lfd >= 0)
1029 close(lfd);
1030 count++;
1031 if (verbose >= 0)
1032 fprintf(stderr, Name ": hot removed %s from %s\n",
1033 dnprintable, devname);
1034 break;
1035
1036 case 'f': /* set faulty */
1037 /* FIXME check current member */
1038 if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
1039 (sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
1040 (unsigned long) stb.st_rdev))) {
1041 fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
1042 dnprintable, strerror(errno));
1043 if (sysfd >= 0)
1044 close(sysfd);
1045 return 1;
1046 }
1047 if (sysfd >= 0)
1048 close(sysfd);
1049 sysfd = -1;
1050 count++;
1051 if (verbose >= 0)
1052 fprintf(stderr, Name ": set %s faulty in %s\n",
1053 dnprintable, devname);
1054 break;
1055 }
1056 }
1057 if (test && count == 0)
1058 return 2;
1059 return 0;
1060 }
1061
1062 int autodetect(void)
1063 {
1064 /* Open any md device, and issue the RAID_AUTORUN ioctl */
1065 int rv = 1;
1066 int fd = dev_open("9:0", O_RDONLY);
1067 if (fd >= 0) {
1068 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
1069 rv = 0;
1070 close(fd);
1071 }
1072 return rv;
1073 }
1074
1075 int Update_subarray(char *dev, char *subarray, char *update, mddev_ident_t ident, int quiet)
1076 {
1077 struct supertype supertype, *st = &supertype;
1078 int fd, rv = 2;
1079
1080 memset(st, 0, sizeof(*st));
1081 if (snprintf(st->subarray, sizeof(st->subarray), "%s", subarray) >=
1082 (signed)sizeof(st->subarray)) {
1083 if (!quiet)
1084 fprintf(stderr,
1085 Name ": Input overflow for subarray '%s' > %zu bytes\n",
1086 subarray, sizeof(st->subarray) - 1);
1087 return 2;
1088 }
1089
1090 fd = open_subarray(dev, st, quiet);
1091 if (fd < 0)
1092 return 2;
1093
1094 if (!st->ss->update_subarray) {
1095 if (!quiet)
1096 fprintf(stderr,
1097 Name ": Operation not supported for %s metadata\n",
1098 st->ss->name);
1099 goto free_super;
1100 }
1101
1102 if (mdmon_running(st->devnum))
1103 st->update_tail = &st->updates;
1104
1105 rv = st->ss->update_subarray(st, update, ident);
1106
1107 if (rv) {
1108 if (!quiet)
1109 fprintf(stderr, Name ": Failed to update %s of subarray-%s in %s\n",
1110 update, subarray, dev);
1111 } else if (st->update_tail)
1112 flush_metadata_updates(st);
1113 else
1114 st->ss->sync_metadata(st);
1115
1116 if (rv == 0 && strcmp(update, "name") == 0 && !quiet)
1117 fprintf(stderr,
1118 Name ": Updated subarray-%s name from %s, UUIDs may have changed\n",
1119 subarray, dev);
1120
1121 free_super:
1122 st->ss->free_super(st);
1123 close(fd);
1124
1125 return rv;
1126 }
1127 #endif
Unnamed repository; edit this file 'description' to name the repository.