]> 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
teach imsm and ddf what st->subarray means at load_super time
[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 /* Remove all 'standard' devices for 'devnum', including
122 * partitions. Also remove names at 'path' - possibly with
123 * partition suffixes - which link to those names.
124 */
125 char base[40];
126 char *path2;
127 char link[1024];
128 int n;
129 int part;
130 char *be;
131 char *pe;
132
133 if (devnum >= 0)
134 sprintf(base, "/dev/md%d", devnum);
135 else
136 sprintf(base, "/dev/md_d%d", -1-devnum);
137 be = base + strlen(base);
138 if (path) {
139 path2 = malloc(strlen(path)+20);
140 strcpy(path2, path);
141 pe = path2 + strlen(path2);
142 } else
143 path = NULL;
144
145 for (part = 0; part < 16; part++) {
146 if (part) {
147 sprintf(be, "p%d", part);
148 if (path) {
149 if (isdigit(pe[-1]))
150 sprintf(pe, "p%d", part);
151 else
152 sprintf(pe, "%d", part);
153 }
154 }
155 /* FIXME test if really is md device ?? */
156 unlink(base);
157 if (path) {
158 n = readlink(path2, link, sizeof(link));
159 if (n && strlen(base) == n &&
160 strncmp(link, base, n) == 0)
161 unlink(path2);
162 }
163 }
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 /* If this is an mdmon managed array, just write 'inactive'
212 * to the array state and let mdmon clear up.
213 */
214 devnum = fd2devnum(fd);
215 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
216 if (mdi &&
217 mdi->array.level > 0 &&
218 is_subarray(mdi->text_version)) {
219 /* This is mdmon managed. */
220 close(fd);
221 if (sysfs_set_str(mdi, NULL,
222 "array_state", "inactive") < 0) {
223 if (quiet == 0)
224 fprintf(stderr, Name
225 ": failed to stop array %s: %s\n",
226 devname, strerror(errno));
227 return 1;
228 }
229
230 /* Give monitor a chance to act */
231 ping_monitor(mdi->text_version);
232
233 fd = open(devname, O_RDONLY);
234 } else if (mdi &&
235 mdi->array.major_version == -1 &&
236 mdi->array.minor_version == -2 &&
237 !is_subarray(mdi->text_version)) {
238 /* container, possibly mdmon-managed.
239 * Make sure mdmon isn't opening it, which
240 * would interfere with the 'stop'
241 */
242 ping_monitor(mdi->sys_name);
243 }
244
245 if (fd >= 0 && ioctl(fd, STOP_ARRAY, NULL)) {
246 if (quiet == 0) {
247 fprintf(stderr, Name
248 ": failed to stop array %s: %s\n",
249 devname, strerror(errno));
250 if (errno == EBUSY)
251 fprintf(stderr, "Perhaps a running "
252 "process, mounted filesystem "
253 "or active volume group?\n");
254 }
255 if (mdi)
256 sysfs_free(mdi);
257 return 1;
258 }
259 /* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
260 * was stopped, so We'll do it here just to be sure. Drop any
261 * partitions as well...
262 */
263 if (fd >= 0)
264 ioctl(fd, BLKRRPART, 0);
265 if (mdi)
266 sysfs_uevent(mdi, "change");
267
268
269 if (devnum != NoMdDev &&
270 (stat("/dev/.udev", &stb) != 0 ||
271 check_env("MDADM_NO_UDEV"))) {
272 struct map_ent *mp = map_by_devnum(&map, devnum);
273 remove_devices(devnum, mp ? mp->path : NULL);
274 }
275
276
277 if (quiet <= 0)
278 fprintf(stderr, Name ": stopped %s\n", devname);
279 if (devnum != NoMdDev) {
280 map_delete(&map, devnum);
281 map_write(map);
282 map_free(map);
283 }
284 }
285 return 0;
286 }
287
288 int Manage_resize(char *devname, int fd, long long size, int raid_disks)
289 {
290 mdu_array_info_t info;
291 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
292 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
293 devname, strerror(errno));
294 return 1;
295 }
296 if (size >= 0)
297 info.size = size;
298 if (raid_disks > 0)
299 info.raid_disks = raid_disks;
300 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
301 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
302 devname, strerror(errno));
303 return 1;
304 }
305 return 0;
306 }
307
308 int Manage_reconfig(char *devname, int fd, int layout)
309 {
310 mdu_array_info_t info;
311 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
312 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
313 devname, strerror(errno));
314 return 1;
315 }
316 info.layout = layout;
317 printf("layout set to %d\n", info.layout);
318 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
319 fprintf(stderr, Name ": Cannot set layout for %s: %s\n",
320 devname, strerror(errno));
321 return 1;
322 }
323 return 0;
324 }
325
326 int Manage_subdevs(char *devname, int fd,
327 mddev_dev_t devlist, int verbose)
328 {
329 /* do something to each dev.
330 * devmode can be
331 * 'a' - add the device
332 * try HOT_ADD_DISK
333 * If that fails EINVAL, try ADD_NEW_DISK
334 * 'r' - remove the device HOT_REMOVE_DISK
335 * device can be 'faulty' or 'detached' in which case all
336 * matching devices are removed.
337 * 'f' - set the device faulty SET_DISK_FAULTY
338 * device can be 'detached' in which case any device that
339 * is inaccessible will be marked faulty.
340 */
341 mdu_array_info_t array;
342 mdu_disk_info_t disc;
343 unsigned long long array_size;
344 mddev_dev_t dv, next = NULL;
345 struct stat stb;
346 int j, jnext = 0;
347 int tfd;
348 struct supertype *st, *tst;
349 int duuid[4];
350 int ouuid[4];
351 int lfd = -1;
352
353 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
354 fprintf(stderr, Name ": cannot get array info for %s\n",
355 devname);
356 return 1;
357 }
358
359 /* array.size is only 32 bit and may be truncated.
360 * So read from sysfs if possible, and record number of sectors
361 */
362
363 array_size = get_component_size(fd);
364 if (array_size <= 0)
365 array_size = array.size * 2;
366
367 tst = super_by_fd(fd);
368 if (!tst) {
369 fprintf(stderr, Name ": unsupport array - version %d.%d\n",
370 array.major_version, array.minor_version);
371 return 1;
372 }
373
374 for (dv = devlist, j=0 ; dv; dv = next, j = jnext) {
375 unsigned long long ldsize;
376 char dvname[20];
377 char *dnprintable = dv->devname;
378 int err;
379
380 next = dv->next;
381 jnext = 0;
382
383 if (strcmp(dv->devname, "failed")==0 ||
384 strcmp(dv->devname, "faulty")==0) {
385 if (dv->disposition != 'r') {
386 fprintf(stderr, Name ": %s only meaningful "
387 "with -r, not -%c\n",
388 dv->devname, dv->disposition);
389 return 1;
390 }
391 for (; j < array.raid_disks + array.nr_disks ; j++) {
392 disc.number = j;
393 if (ioctl(fd, GET_DISK_INFO, &disc))
394 continue;
395 if (disc.major == 0 && disc.minor == 0)
396 continue;
397 if ((disc.state & 1) == 0) /* faulty */
398 continue;
399 stb.st_rdev = makedev(disc.major, disc.minor);
400 next = dv;
401 jnext = j+1;
402 sprintf(dvname,"%d:%d", disc.major, disc.minor);
403 dnprintable = dvname;
404 break;
405 }
406 if (jnext == 0)
407 continue;
408 } else if (strcmp(dv->devname, "detached") == 0) {
409 if (dv->disposition != 'r' && dv->disposition != 'f') {
410 fprintf(stderr, Name ": %s only meaningful "
411 "with -r of -f, not -%c\n",
412 dv->devname, dv->disposition);
413 return 1;
414 }
415 for (; j < array.raid_disks + array.nr_disks; j++) {
416 int sfd;
417 disc.number = j;
418 if (ioctl(fd, GET_DISK_INFO, &disc))
419 continue;
420 if (disc.major == 0 && disc.minor == 0)
421 continue;
422 sprintf(dvname,"%d:%d", disc.major, disc.minor);
423 sfd = dev_open(dvname, O_RDONLY);
424 if (sfd >= 0) {
425 close(sfd);
426 continue;
427 }
428 if (dv->disposition == 'f' &&
429 (disc.state & 1) == 1) /* already faulty */
430 continue;
431 if (errno != ENXIO)
432 continue;
433 stb.st_rdev = makedev(disc.major, disc.minor);
434 next = dv;
435 jnext = j+1;
436 dnprintable = dvname;
437 break;
438 }
439 if (jnext == 0)
440 continue;
441 } else {
442 j = 0;
443
444 tfd = dev_open(dv->devname, O_RDONLY);
445 if (tfd < 0 || fstat(tfd, &stb) != 0) {
446 fprintf(stderr, Name ": cannot find %s: %s\n",
447 dv->devname, strerror(errno));
448 if (tfd >= 0)
449 close(tfd);
450 return 1;
451 }
452 close(tfd);
453 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
454 fprintf(stderr, Name ": %s is not a "
455 "block device.\n",
456 dv->devname);
457 return 1;
458 }
459 }
460 switch(dv->disposition){
461 default:
462 fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
463 dv->devname, dv->disposition);
464 return 1;
465 case 'a':
466 /* add the device */
467 if (tst->subarray[0]) {
468 fprintf(stderr, Name ": Cannot add disks to a"
469 " \'member\' array, perform this"
470 " operation on the parent container\n");
471 return 1;
472 }
473 /* Make sure it isn't in use (in 2.6 or later) */
474 tfd = dev_open(dv->devname, O_RDONLY|O_EXCL|O_DIRECT);
475 if (tfd < 0) {
476 fprintf(stderr, Name ": Cannot open %s: %s\n",
477 dv->devname, strerror(errno));
478 return 1;
479 }
480 remove_partitions(tfd);
481
482 st = dup_super(tst);
483
484 if (array.not_persistent==0)
485 st->ss->load_super(st, tfd, NULL);
486
487 if (!get_dev_size(tfd, dv->devname, &ldsize)) {
488 close(tfd);
489 return 1;
490 }
491 close(tfd);
492
493
494 if (!tst->ss->external &&
495 array.major_version == 0 &&
496 md_get_version(fd)%100 < 2) {
497 if (ioctl(fd, HOT_ADD_DISK,
498 (unsigned long)stb.st_rdev)==0) {
499 if (verbose >= 0)
500 fprintf(stderr, Name ": hot added %s\n",
501 dv->devname);
502 continue;
503 }
504
505 fprintf(stderr, Name ": hot add failed for %s: %s\n",
506 dv->devname, strerror(errno));
507 return 1;
508 }
509
510 if (array.not_persistent == 0 || tst->ss->external) {
511
512 /* need to find a sample superblock to copy, and
513 * a spare slot to use.
514 * For 'external' array (well, container based),
515 * We can just load the metadata for the array.
516 */
517 if (tst->ss->external) {
518 tst->ss->load_super(tst, fd, NULL);
519 } else for (j = 0; j < tst->max_devs; j++) {
520 char *dev;
521 int dfd;
522 disc.number = j;
523 if (ioctl(fd, GET_DISK_INFO, &disc))
524 continue;
525 if (disc.major==0 && disc.minor==0)
526 continue;
527 if ((disc.state & 4)==0) continue; /* sync */
528 /* Looks like a good device to try */
529 dev = map_dev(disc.major, disc.minor, 1);
530 if (!dev) continue;
531 dfd = dev_open(dev, O_RDONLY);
532 if (dfd < 0) continue;
533 if (tst->ss->load_super(tst, dfd,
534 NULL)) {
535 close(dfd);
536 continue;
537 }
538 close(dfd);
539 break;
540 }
541 /* FIXME this is a bad test to be using */
542 if (!tst->sb) {
543 fprintf(stderr, Name ": cannot find valid superblock in this array - HELP\n");
544 return 1;
545 }
546
547 /* Make sure device is large enough */
548 if (tst->ss->avail_size(tst, ldsize/512) <
549 array_size) {
550 fprintf(stderr, Name ": %s not large enough to join array\n",
551 dv->devname);
552 return 1;
553 }
554
555 /* Possibly this device was recently part of the array
556 * and was temporarily removed, and is now being re-added.
557 * If so, we can simply re-add it.
558 */
559 tst->ss->uuid_from_super(tst, duuid);
560
561 /* re-add doesn't work for version-1 superblocks
562 * before 2.6.18 :-(
563 */
564 if (array.major_version == 1 &&
565 get_linux_version() <= 2006018)
566 ;
567 else if (st->sb) {
568 st->ss->uuid_from_super(st, ouuid);
569 if (memcmp(duuid, ouuid, sizeof(ouuid))==0) {
570 /* looks close enough for now. Kernel
571 * will worry about whether a bitmap
572 * based reconstruction is possible.
573 */
574 struct mdinfo mdi;
575 st->ss->getinfo_super(st, &mdi);
576 disc.major = major(stb.st_rdev);
577 disc.minor = minor(stb.st_rdev);
578 disc.number = mdi.disk.number;
579 disc.raid_disk = mdi.disk.raid_disk;
580 disc.state = mdi.disk.state;
581 if (dv->writemostly == 1)
582 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
583 if (dv->writemostly == 2)
584 disc.state &= ~(1 << MD_DISK_WRITEMOSTLY);
585 if (ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
586 if (verbose >= 0)
587 fprintf(stderr, Name ": re-added %s\n", dv->devname);
588 continue;
589 }
590 if (errno == ENOMEM || errno == EROFS) {
591 fprintf(stderr, Name ": add new device failed for %s: %s\n",
592 dv->devname, strerror(errno));
593 return 1;
594 }
595 /* fall back on normal-add */
596 }
597 }
598 } else {
599 /* non-persistent. Must ensure that new drive
600 * is at least array.size big.
601 */
602 if (ldsize/512 < array_size) {
603 fprintf(stderr, Name ": %s not large enough to join array\n",
604 dv->devname);
605 return 1;
606 }
607 }
608 /* in 2.6.17 and earlier, version-1 superblocks won't
609 * use the number we write, but will choose a free number.
610 * we must choose the same free number, which requires
611 * starting at 'raid_disks' and counting up
612 */
613 for (j = array.raid_disks; j< tst->max_devs; j++) {
614 disc.number = j;
615 if (ioctl(fd, GET_DISK_INFO, &disc))
616 break;
617 if (disc.major==0 && disc.minor==0)
618 break;
619 if (disc.state & 8) /* removed */
620 break;
621 }
622 disc.major = major(stb.st_rdev);
623 disc.minor = minor(stb.st_rdev);
624 disc.number =j;
625 disc.state = 0;
626 if (array.not_persistent==0 || tst->ss->external) {
627 int dfd;
628 if (dv->writemostly == 1)
629 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
630 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
631 if (tst->ss->add_to_super(tst, &disc, dfd,
632 dv->devname)) {
633 close(dfd);
634 return 1;
635 }
636 /* write_init_super will close 'dfd' */
637 if (tst->ss->external)
638 /* mdmon will write the metadata */
639 close(dfd);
640 else if (tst->ss->write_init_super(tst))
641 return 1;
642 } else if (dv->re_add) {
643 /* this had better be raid1.
644 * As we are "--re-add"ing we must find a spare slot
645 * to fill.
646 */
647 char *used = malloc(array.raid_disks);
648 memset(used, 0, array.raid_disks);
649 for (j=0; j< tst->max_devs; j++) {
650 mdu_disk_info_t disc2;
651 disc2.number = j;
652 if (ioctl(fd, GET_DISK_INFO, &disc2))
653 continue;
654 if (disc2.major==0 && disc2.minor==0)
655 continue;
656 if (disc2.state & 8) /* removed */
657 continue;
658 if (disc2.raid_disk < 0)
659 continue;
660 if (disc2.raid_disk > array.raid_disks)
661 continue;
662 used[disc2.raid_disk] = 1;
663 }
664 for (j=0 ; j<array.raid_disks; j++)
665 if (!used[j]) {
666 disc.raid_disk = j;
667 disc.state |= (1<<MD_DISK_SYNC);
668 break;
669 }
670 }
671 if (dv->writemostly == 1)
672 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
673 if (tst->ss->external) {
674 /* add a disk to an external metadata container
675 * only if mdmon is around to see it
676 */
677 struct mdinfo new_mdi;
678 struct mdinfo *sra;
679 int container_fd;
680 int devnum = fd2devnum(fd);
681
682 container_fd = open_dev_excl(devnum);
683 if (container_fd < 0) {
684 fprintf(stderr, Name ": add failed for %s:"
685 " could not get exclusive access to container\n",
686 dv->devname);
687 return 1;
688 }
689
690 if (!mdmon_running(devnum)) {
691 fprintf(stderr, Name ": add failed for %s: mdmon not running\n",
692 dv->devname);
693 close(container_fd);
694 return 1;
695 }
696
697 sra = sysfs_read(container_fd, -1, 0);
698 if (!sra) {
699 fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
700 dv->devname);
701 close(container_fd);
702 return 1;
703 }
704 sra->array.level = LEVEL_CONTAINER;
705 /* Need to set data_offset and component_size */
706 tst->ss->getinfo_super(tst, &new_mdi);
707 new_mdi.disk.major = disc.major;
708 new_mdi.disk.minor = disc.minor;
709 if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
710 fprintf(stderr, Name ": add new device to external metadata"
711 " failed for %s\n", dv->devname);
712 close(container_fd);
713 return 1;
714 }
715 ping_monitor(devnum2devname(devnum));
716 sysfs_free(sra);
717 close(container_fd);
718 } else if (ioctl(fd, ADD_NEW_DISK, &disc)) {
719 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
720 dv->devname, j, strerror(errno));
721 return 1;
722 }
723 if (verbose >= 0)
724 fprintf(stderr, Name ": added %s\n", dv->devname);
725 break;
726
727 case 'r':
728 /* hot remove */
729 if (tst->subarray[0]) {
730 fprintf(stderr, Name ": Cannot remove disks from a"
731 " \'member\' array, perform this"
732 " operation on the parent container\n");
733 return 1;
734 }
735 if (tst->ss->external) {
736 /* To remove a device from a container, we must
737 * check that it isn't in use in an array.
738 * This involves looking in the 'holders'
739 * directory - there must be just one entry,
740 * the container.
741 * To ensure that it doesn't get used as a
742 * hold spare while we are checking, we
743 * get an O_EXCL open on the container
744 */
745 int dnum = fd2devnum(fd);
746 lfd = open_dev_excl(dnum);
747 if (lfd < 0) {
748 fprintf(stderr, Name
749 ": Cannot get exclusive access "
750 " to container - odd\n");
751 return 1;
752 }
753 /* in the detached case it is not possible to
754 * check if we are the unique holder, so just
755 * rely on the 'detached' checks
756 */
757 if (strcmp(dv->devname, "detached") == 0 ||
758 sysfs_unique_holder(dnum, stb.st_rdev))
759 /* pass */;
760 else {
761 fprintf(stderr, Name
762 ": %s is %s, cannot remove.\n",
763 dnprintable,
764 errno == EEXIST ? "still in use":
765 "not a member");
766 close(lfd);
767 return 1;
768 }
769 }
770 /* FIXME check that it is a current member */
771 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
772 if (err && errno == ENODEV) {
773 /* Old kernels rejected this if no personality
774 * registered */
775 struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
776 struct mdinfo *dv = NULL;
777 if (sra)
778 dv = sra->devs;
779 for ( ; dv ; dv=dv->next)
780 if (dv->disk.major == major(stb.st_rdev) &&
781 dv->disk.minor == minor(stb.st_rdev))
782 break;
783 if (dv)
784 err = sysfs_set_str(sra, dv,
785 "state", "remove");
786 else
787 err = -1;
788 if (sra)
789 sysfs_free(sra);
790 }
791 if (err) {
792 fprintf(stderr, Name ": hot remove failed "
793 "for %s: %s\n", dnprintable,
794 strerror(errno));
795 if (lfd >= 0)
796 close(lfd);
797 return 1;
798 }
799 if (tst->ss->external) {
800 /*
801 * Before dropping our exclusive open we make an
802 * attempt at preventing mdmon from seeing an
803 * 'add' event before reconciling this 'remove'
804 * event.
805 */
806 char *name = devnum2devname(fd2devnum(fd));
807
808 if (!name) {
809 fprintf(stderr, Name ": unable to get container name\n");
810 return 1;
811 }
812
813 ping_manager(name);
814 free(name);
815 }
816 close(lfd);
817 if (verbose >= 0)
818 fprintf(stderr, Name ": hot removed %s\n",
819 dnprintable);
820 break;
821
822 case 'f': /* set faulty */
823 /* FIXME check current member */
824 if (ioctl(fd, SET_DISK_FAULTY, (unsigned long) stb.st_rdev)) {
825 fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
826 dnprintable, strerror(errno));
827 return 1;
828 }
829 if (verbose >= 0)
830 fprintf(stderr, Name ": set %s faulty in %s\n",
831 dnprintable, devname);
832 break;
833 }
834 }
835 return 0;
836
837 }
838
839 int autodetect(void)
840 {
841 /* Open any md device, and issue the RAID_AUTORUN ioctl */
842 int rv = 1;
843 int fd = dev_open("9:0", O_RDONLY);
844 if (fd >= 0) {
845 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
846 rv = 0;
847 close(fd);
848 }
849 return rv;
850 }
851 #endif
Unnamed repository; edit this file 'description' to name the repository.