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