]> 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
ping_manager() to prevent 'add' before 'remove' completes
[thirdparty/mdadm.git] / Manage.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 "md_u.h"
32 #include "md_p.h"
33
34 #define REGISTER_DEV _IO (MD_MAJOR, 1)
35 #define START_MD _IO (MD_MAJOR, 2)
36 #define STOP_MD _IO (MD_MAJOR, 3)
37
38 int Manage_ro(char *devname, int fd, int readonly)
39 {
40 /* switch to readonly or rw
41 *
42 * requires >= 0.90.0
43 * first check that array is runing
44 * use RESTART_ARRAY_RW or STOP_ARRAY_RO
45 *
46 */
47 mdu_array_info_t array;
48 struct mdinfo *mdi;
49
50 if (md_get_version(fd) < 9000) {
51 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
52 return 1;
53 }
54 /* If this is an externally-manage array, we need to modify the
55 * metadata_version so that mdmon doesn't undo our change.
56 */
57 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
58 if (mdi &&
59 mdi->array.major_version == -1 &&
60 mdi->array.level > 0 &&
61 is_subarray(mdi->text_version)) {
62 char vers[64];
63 strcpy(vers, "external:");
64 strcat(vers, mdi->text_version);
65 if (readonly > 0) {
66 int rv;
67 /* We set readonly ourselves. */
68 vers[9] = '-';
69 sysfs_set_str(mdi, NULL, "metadata_version", vers);
70
71 close(fd);
72 rv = sysfs_set_str(mdi, NULL, "array_state", "readonly");
73
74 if (rv < 0) {
75 fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
76 devname, strerror(errno));
77
78 vers[9] = mdi->text_version[0];
79 sysfs_set_str(mdi, NULL, "metadata_version", vers);
80 return 1;
81 }
82 } else {
83 char *cp;
84 /* We cannot set read/write - must signal mdmon */
85 vers[9] = '/';
86 sysfs_set_str(mdi, NULL, "metadata_version", vers);
87
88 cp = strchr(vers+10, '/');
89 if (*cp)
90 *cp = 0;
91 ping_monitor(vers+10);
92 }
93 return 0;
94 }
95
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 int Manage_runstop(char *devname, int fd, int runstop, int quiet)
121 {
122 /* Run or stop the array. array must already be configured
123 * required >= 0.90.0
124 * Only print failure messages if quiet == 0;
125 * quiet > 0 means really be quiet
126 * quiet < 0 means we will try again if it fails.
127 */
128 mdu_param_t param; /* unused */
129
130 if (runstop == -1 && md_get_version(fd) < 9000) {
131 if (ioctl(fd, STOP_MD, 0)) {
132 if (quiet == 0) fprintf(stderr,
133 Name ": stopping device %s "
134 "failed: %s\n",
135 devname, strerror(errno));
136 return 1;
137 }
138 }
139
140 if (md_get_version(fd) < 9000) {
141 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
142 return 1;
143 }
144 /*
145 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
146 fprintf(stderr, Name ": %s does not appear to be active.\n",
147 devname);
148 return 1;
149 }
150 */
151 if (runstop>0) {
152 if (ioctl(fd, RUN_ARRAY, &param)) {
153 fprintf(stderr, Name ": failed to run array %s: %s\n",
154 devname, strerror(errno));
155 return 1;
156 }
157 if (quiet <= 0)
158 fprintf(stderr, Name ": started %s\n", devname);
159 } else if (runstop < 0){
160 struct map_ent *map = NULL;
161 struct stat stb;
162 struct mdinfo *mdi;
163 /* If this is an mdmon managed array, just write 'inactive'
164 * to the array state and let mdmon clear up.
165 */
166 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
167 if (mdi &&
168 mdi->array.level > 0 &&
169 is_subarray(mdi->text_version)) {
170 /* This is mdmon managed. */
171 close(fd);
172 if (sysfs_set_str(mdi, NULL,
173 "array_state", "inactive") < 0) {
174 if (quiet == 0)
175 fprintf(stderr, Name
176 ": failed to stop array %s: %s\n",
177 devname, strerror(errno));
178 return 1;
179 }
180
181 /* Give monitor a chance to act */
182 ping_monitor(mdi->text_version);
183
184 fd = open(devname, O_RDONLY);
185 } else if (mdi &&
186 mdi->array.major_version == -1 &&
187 mdi->array.minor_version == -2 &&
188 !is_subarray(mdi->text_version)) {
189 /* container, possibly mdmon-managed.
190 * Make sure mdmon isn't opening it, which
191 * would interfere with the 'stop'
192 */
193 ping_monitor(mdi->sys_name);
194 }
195 if (mdi)
196 sysfs_free(mdi);
197
198 if (fd >= 0 && ioctl(fd, STOP_ARRAY, NULL)) {
199 if (quiet == 0) {
200 fprintf(stderr, Name
201 ": failed to stop array %s: %s\n",
202 devname, strerror(errno));
203 if (errno == EBUSY)
204 fprintf(stderr, "Perhaps a running "
205 "process, mounted filesystem "
206 "or active volume group?\n");
207 }
208 return 1;
209 }
210
211 if (quiet <= 0)
212 fprintf(stderr, Name ": stopped %s\n", devname);
213 if (fd >= 0 && fstat(fd, &stb) == 0) {
214 int devnum;
215 if (major(stb.st_rdev) == MD_MAJOR)
216 devnum = minor(stb.st_rdev);
217 else
218 devnum = -1-(minor(stb.st_rdev)>>6);
219 map_delete(&map, devnum);
220 map_write(map);
221 map_free(map);
222 }
223 }
224 return 0;
225 }
226
227 int Manage_resize(char *devname, int fd, long long size, int raid_disks)
228 {
229 mdu_array_info_t info;
230 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
231 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
232 devname, strerror(errno));
233 return 1;
234 }
235 if (size >= 0)
236 info.size = size;
237 if (raid_disks > 0)
238 info.raid_disks = raid_disks;
239 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
240 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
241 devname, strerror(errno));
242 return 1;
243 }
244 return 0;
245 }
246
247 int Manage_reconfig(char *devname, int fd, int layout)
248 {
249 mdu_array_info_t info;
250 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
251 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
252 devname, strerror(errno));
253 return 1;
254 }
255 info.layout = layout;
256 printf("layout set to %d\n", info.layout);
257 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
258 fprintf(stderr, Name ": Cannot set layout for %s: %s\n",
259 devname, strerror(errno));
260 return 1;
261 }
262 return 0;
263 }
264
265 int Manage_subdevs(char *devname, int fd,
266 mddev_dev_t devlist, int verbose)
267 {
268 /* do something to each dev.
269 * devmode can be
270 * 'a' - add the device
271 * try HOT_ADD_DISK
272 * If that fails EINVAL, try ADD_NEW_DISK
273 * 'r' - remove the device HOT_REMOVE_DISK
274 * device can be 'faulty' or 'detached' in which case all
275 * matching devices are removed.
276 * 'f' - set the device faulty SET_DISK_FAULTY
277 * device can be 'detached' in which case any device that
278 * is inaccessible will be marked faulty.
279 */
280 mdu_array_info_t array;
281 mdu_disk_info_t disc;
282 unsigned long long array_size;
283 mddev_dev_t dv, next = NULL;
284 struct stat stb;
285 int j, jnext = 0;
286 int tfd;
287 struct supertype *st, *tst;
288 int duuid[4];
289 int ouuid[4];
290 int lfd = -1;
291
292 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
293 fprintf(stderr, Name ": cannot get array info for %s\n",
294 devname);
295 return 1;
296 }
297
298 /* array.size is only 32 bit and may be truncated.
299 * So read from sysfs if possible, and record number of sectors
300 */
301
302 array_size = get_component_size(fd);
303 if (array_size <= 0)
304 array_size = array.size * 2;
305
306 tst = super_by_fd(fd);
307 if (!tst) {
308 fprintf(stderr, Name ": unsupport array - version %d.%d\n",
309 array.major_version, array.minor_version);
310 return 1;
311 }
312
313 for (dv = devlist, j=0 ; dv; dv = next, j = jnext) {
314 unsigned long long ldsize;
315 char dvname[20];
316 char *dnprintable = dv->devname;
317 int err;
318
319 next = dv->next;
320 jnext = 0;
321
322 if (strcmp(dv->devname, "failed")==0 ||
323 strcmp(dv->devname, "faulty")==0) {
324 if (dv->disposition != 'r') {
325 fprintf(stderr, Name ": %s only meaningful "
326 "with -r, not -%c\n",
327 dv->devname, dv->disposition);
328 return 1;
329 }
330 for (; j < array.raid_disks + array.nr_disks ; j++) {
331 disc.number = j;
332 if (ioctl(fd, GET_DISK_INFO, &disc))
333 continue;
334 if (disc.major == 0 && disc.minor == 0)
335 continue;
336 if ((disc.state & 1) == 0) /* faulty */
337 continue;
338 stb.st_rdev = makedev(disc.major, disc.minor);
339 next = dv;
340 jnext = j+1;
341 sprintf(dvname,"%d:%d", disc.major, disc.minor);
342 dnprintable = dvname;
343 break;
344 }
345 if (jnext == 0)
346 continue;
347 } else if (strcmp(dv->devname, "detached") == 0) {
348 if (dv->disposition != 'r' && dv->disposition != 'f') {
349 fprintf(stderr, Name ": %s only meaningful "
350 "with -r of -f, not -%c\n",
351 dv->devname, dv->disposition);
352 return 1;
353 }
354 for (; j < array.raid_disks + array.nr_disks; j++) {
355 int sfd;
356 disc.number = j;
357 if (ioctl(fd, GET_DISK_INFO, &disc))
358 continue;
359 if (disc.major == 0 && disc.minor == 0)
360 continue;
361 sprintf(dvname,"%d:%d", disc.major, disc.minor);
362 sfd = dev_open(dvname, O_RDONLY);
363 if (sfd >= 0) {
364 close(sfd);
365 continue;
366 }
367 if (dv->disposition == 'f' &&
368 (disc.state & 1) == 1) /* already faulty */
369 continue;
370 if (errno != ENXIO)
371 continue;
372 stb.st_rdev = makedev(disc.major, disc.minor);
373 next = dv;
374 jnext = j+1;
375 dnprintable = dvname;
376 break;
377 }
378 if (jnext == 0)
379 continue;
380 } else {
381 j = 0;
382
383 if (stat(dv->devname, &stb)) {
384 fprintf(stderr, Name ": cannot find %s: %s\n",
385 dv->devname, strerror(errno));
386 return 1;
387 }
388 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
389 fprintf(stderr, Name ": %s is not a "
390 "block device.\n",
391 dv->devname);
392 return 1;
393 }
394 }
395 switch(dv->disposition){
396 default:
397 fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
398 dv->devname, dv->disposition);
399 return 1;
400 case 'a':
401 /* add the device */
402 if (tst->subarray[0]) {
403 fprintf(stderr, Name ": Cannot add disks to a"
404 " \'member\' array, perform this"
405 " operation on the parent container\n");
406 return 1;
407 }
408 /* Make sure it isn't in use (in 2.6 or later) */
409 tfd = open(dv->devname, O_RDONLY|O_EXCL|O_DIRECT);
410 if (tfd < 0) {
411 fprintf(stderr, Name ": Cannot open %s: %s\n",
412 dv->devname, strerror(errno));
413 return 1;
414 }
415 remove_partitions(tfd);
416
417 st = dup_super(tst);
418
419 if (array.not_persistent==0)
420 st->ss->load_super(st, tfd, NULL);
421
422 if (!get_dev_size(tfd, dv->devname, &ldsize)) {
423 close(tfd);
424 return 1;
425 }
426 close(tfd);
427
428
429 if (!tst->ss->external &&
430 array.major_version == 0 &&
431 md_get_version(fd)%100 < 2) {
432 if (ioctl(fd, HOT_ADD_DISK,
433 (unsigned long)stb.st_rdev)==0) {
434 if (verbose >= 0)
435 fprintf(stderr, Name ": hot added %s\n",
436 dv->devname);
437 continue;
438 }
439
440 fprintf(stderr, Name ": hot add failed for %s: %s\n",
441 dv->devname, strerror(errno));
442 return 1;
443 }
444
445 if (array.not_persistent == 0 || tst->ss->external) {
446 /* Make sure device is large enough */
447 if (tst->ss->avail_size(tst, ldsize/512) <
448 array_size) {
449 fprintf(stderr, Name ": %s not large enough to join array\n",
450 dv->devname);
451 return 1;
452 }
453
454 /* need to find a sample superblock to copy, and
455 * a spare slot to use.
456 * For 'external' array (well, container based),
457 * We can just load the metadata for the array.
458 */
459 if (tst->ss->external) {
460 tst->ss->load_super(tst, fd, NULL);
461 } else for (j = 0; j < tst->max_devs; j++) {
462 char *dev;
463 int dfd;
464 disc.number = j;
465 if (ioctl(fd, GET_DISK_INFO, &disc))
466 continue;
467 if (disc.major==0 && disc.minor==0)
468 continue;
469 if ((disc.state & 4)==0) continue; /* sync */
470 /* Looks like a good device to try */
471 dev = map_dev(disc.major, disc.minor, 1);
472 if (!dev) continue;
473 dfd = dev_open(dev, O_RDONLY);
474 if (dfd < 0) continue;
475 if (tst->ss->load_super(tst, dfd,
476 NULL)) {
477 close(dfd);
478 continue;
479 }
480 close(dfd);
481 break;
482 }
483 /* FIXME this is a bad test to be using */
484 if (!tst->sb) {
485 fprintf(stderr, Name ": cannot find valid superblock in this array - HELP\n");
486 return 1;
487 }
488 /* Possibly this device was recently part of the array
489 * and was temporarily removed, and is now being re-added.
490 * If so, we can simply re-add it.
491 */
492 tst->ss->uuid_from_super(tst, duuid);
493
494 /* re-add doesn't work for version-1 superblocks
495 * before 2.6.18 :-(
496 */
497 if (array.major_version == 1 &&
498 get_linux_version() <= 2006018)
499 ;
500 else if (st->sb) {
501 st->ss->uuid_from_super(st, ouuid);
502 if (memcmp(duuid, ouuid, sizeof(ouuid))==0) {
503 /* looks close enough for now. Kernel
504 * will worry about whether a bitmap
505 * based reconstruction is possible.
506 */
507 struct mdinfo mdi;
508 st->ss->getinfo_super(st, &mdi);
509 disc.major = major(stb.st_rdev);
510 disc.minor = minor(stb.st_rdev);
511 disc.number = mdi.disk.number;
512 disc.raid_disk = mdi.disk.raid_disk;
513 disc.state = mdi.disk.state;
514 if (dv->writemostly)
515 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
516 if (ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
517 if (verbose >= 0)
518 fprintf(stderr, Name ": re-added %s\n", dv->devname);
519 continue;
520 }
521 /* fall back on normal-add */
522 }
523 }
524 } else {
525 /* non-persistent. Must ensure that new drive
526 * is at least array.size big.
527 */
528 if (ldsize/512 < array_size) {
529 fprintf(stderr, Name ": %s not large enough to join array\n",
530 dv->devname);
531 return 1;
532 }
533 }
534 /* in 2.6.17 and earlier, version-1 superblocks won't
535 * use the number we write, but will choose a free number.
536 * we must choose the same free number, which requires
537 * starting at 'raid_disks' and counting up
538 */
539 for (j = array.raid_disks; j< tst->max_devs; j++) {
540 disc.number = j;
541 if (ioctl(fd, GET_DISK_INFO, &disc))
542 break;
543 if (disc.major==0 && disc.minor==0)
544 break;
545 if (disc.state & 8) /* removed */
546 break;
547 }
548 disc.major = major(stb.st_rdev);
549 disc.minor = minor(stb.st_rdev);
550 disc.number =j;
551 disc.state = 0;
552 if (array.not_persistent==0 || tst->ss->external) {
553 int dfd;
554 if (dv->writemostly)
555 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
556 dfd = open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
557 tst->ss->add_to_super(tst, &disc, dfd,
558 dv->devname);
559 /* write_init_super will close 'dfd' */
560 if (tst->ss->external)
561 /* mdmon will write the metadata */
562 close(dfd);
563 else if (tst->ss->write_init_super(tst))
564 return 1;
565 } else if (dv->re_add) {
566 /* this had better be raid1.
567 * As we are "--re-add"ing we must find a spare slot
568 * to fill.
569 */
570 char *used = malloc(array.raid_disks);
571 memset(used, 0, array.raid_disks);
572 for (j=0; j< tst->max_devs; j++) {
573 mdu_disk_info_t disc2;
574 disc2.number = j;
575 if (ioctl(fd, GET_DISK_INFO, &disc2))
576 continue;
577 if (disc2.major==0 && disc2.minor==0)
578 continue;
579 if (disc2.state & 8) /* removed */
580 continue;
581 if (disc2.raid_disk < 0)
582 continue;
583 if (disc2.raid_disk > array.raid_disks)
584 continue;
585 used[disc2.raid_disk] = 1;
586 }
587 for (j=0 ; j<array.raid_disks; j++)
588 if (!used[j]) {
589 disc.raid_disk = j;
590 disc.state |= (1<<MD_DISK_SYNC);
591 break;
592 }
593 }
594 if (dv->writemostly)
595 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
596 if (tst->ss->external) {
597 /* add a disk to an external metadata container
598 * only if mdmon is around to see it
599 */
600 struct mdinfo new_mdi;
601 struct mdinfo *sra;
602 int container_fd;
603 int devnum = fd2devnum(fd);
604
605 container_fd = open_dev_excl(devnum);
606 if (container_fd < 0) {
607 fprintf(stderr, Name ": add failed for %s:"
608 " could not get exclusive access to container\n",
609 dv->devname);
610 return 1;
611 }
612
613 if (!mdmon_running(devnum)) {
614 fprintf(stderr, Name ": add failed for %s: mdmon not running\n",
615 dv->devname);
616 close(container_fd);
617 return 1;
618 }
619
620 sra = sysfs_read(container_fd, -1, 0);
621 if (!sra) {
622 fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
623 dv->devname);
624 close(container_fd);
625 return 1;
626 }
627 sra->array.level = LEVEL_CONTAINER;
628 /* Need to set data_offset and component_size */
629 tst->ss->getinfo_super(tst, &new_mdi);
630 new_mdi.disk.major = disc.major;
631 new_mdi.disk.minor = disc.minor;
632 if (sysfs_add_disk(sra, &new_mdi) != 0) {
633 fprintf(stderr, Name ": add new device to external metadata"
634 " failed for %s\n", dv->devname);
635 close(container_fd);
636 return 1;
637 }
638 ping_monitor(devnum2devname(devnum));
639 sysfs_free(sra);
640 close(container_fd);
641 } else if (ioctl(fd, ADD_NEW_DISK, &disc)) {
642 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
643 dv->devname, j, strerror(errno));
644 return 1;
645 }
646 if (verbose >= 0)
647 fprintf(stderr, Name ": added %s\n", dv->devname);
648 break;
649
650 case 'r':
651 /* hot remove */
652 if (tst->subarray[0]) {
653 fprintf(stderr, Name ": Cannot remove disks from a"
654 " \'member\' array, perform this"
655 " operation on the parent container\n");
656 return 1;
657 }
658 if (tst->ss->external) {
659 /* To remove a device from a container, we must
660 * check that it isn't in use in an array.
661 * This involves looking in the 'holders'
662 * directory - there must be just one entry,
663 * the container.
664 * To ensure that it doesn't get used as a
665 * hold spare while we are checking, we
666 * get an O_EXCL open on the container
667 */
668 int dnum = fd2devnum(fd);
669 lfd = open_dev_excl(dnum);
670 if (lfd < 0) {
671 fprintf(stderr, Name
672 ": Cannot get exclusive access "
673 " to container - odd\n");
674 return 1;
675 }
676 if (!sysfs_unique_holder(dnum, stb.st_rdev)) {
677 fprintf(stderr, Name
678 ": %s is %s, cannot remove.\n",
679 dnprintable,
680 errno == EEXIST ? "still in use":
681 "not a member");
682 close(lfd);
683 return 1;
684 }
685 }
686 /* FIXME check that it is a current member */
687 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
688 if (err && errno == ENODEV) {
689 /* Old kernels rejected this if no personality
690 * registered */
691 struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
692 struct mdinfo *dv = NULL;
693 if (sra)
694 dv = sra->devs;
695 for ( ; dv ; dv=dv->next)
696 if (dv->disk.major == major(stb.st_rdev) &&
697 dv->disk.minor == minor(stb.st_rdev))
698 break;
699 if (dv)
700 err = sysfs_set_str(sra, dv,
701 "state", "remove");
702 else
703 err = -1;
704 if (sra)
705 sysfs_free(sra);
706 }
707 if (err) {
708 fprintf(stderr, Name ": hot remove failed "
709 "for %s: %s\n", dnprintable,
710 strerror(errno));
711 if (lfd >= 0)
712 close(lfd);
713 return 1;
714 }
715 if (tst->ss->external) {
716 /*
717 * Before dropping our exclusive open we make an
718 * attempt at preventing mdmon from seeing an
719 * 'add' event before reconciling this 'remove'
720 * event.
721 */
722 char *name = devnum2devname(fd2devnum(fd));
723
724 if (!name) {
725 fprintf(stderr, Name ": unable to get container name\n");
726 return 1;
727 }
728
729 ping_manager(name);
730 free(name);
731 }
732 close(lfd);
733 if (verbose >= 0)
734 fprintf(stderr, Name ": hot removed %s\n",
735 dnprintable);
736 break;
737
738 case 'f': /* set faulty */
739 /* FIXME check current member */
740 if (ioctl(fd, SET_DISK_FAULTY, (unsigned long) stb.st_rdev)) {
741 fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
742 dnprintable, strerror(errno));
743 return 1;
744 }
745 if (verbose >= 0)
746 fprintf(stderr, Name ": set %s faulty in %s\n",
747 dnprintable, devname);
748 break;
749 }
750 }
751 return 0;
752
753 }
754
755 int autodetect(void)
756 {
757 /* Open any md device, and issue the RAID_AUTORUN ioctl */
758 int rv = 1;
759 int fd = dev_open("9:0", O_RDONLY);
760 if (fd >= 0) {
761 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
762 rv = 0;
763 close(fd);
764 }
765 return rv;
766 }
767 #endif
Unnamed repository; edit this file 'description' to name the repository.