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