]> 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
Manage: fix the mess I made in earlier patch.
[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->add_to_super(tst, &disc, dfd,
839 dv->devname)) {
840 close(dfd);
841 return 1;
842 }
843 if (tst->ss->write_init_super(tst)) {
844 close(dfd);
845 return 1;
846 }
847 } else if (dv->re_add) {
848 /* this had better be raid1.
849 * As we are "--re-add"ing we must find a spare slot
850 * to fill.
851 */
852 char *used = malloc(array.raid_disks);
853 memset(used, 0, array.raid_disks);
854 for (j=0; j< tst->max_devs; j++) {
855 mdu_disk_info_t disc2;
856 disc2.number = j;
857 if (ioctl(fd, GET_DISK_INFO, &disc2))
858 continue;
859 if (disc2.major==0 && disc2.minor==0)
860 continue;
861 if (disc2.state & 8) /* removed */
862 continue;
863 if (disc2.raid_disk < 0)
864 continue;
865 if (disc2.raid_disk > array.raid_disks)
866 continue;
867 used[disc2.raid_disk] = 1;
868 }
869 for (j=0 ; j<array.raid_disks; j++)
870 if (!used[j]) {
871 disc.raid_disk = j;
872 disc.state |= (1<<MD_DISK_SYNC);
873 break;
874 }
875 free(used);
876 }
877 if (dv->writemostly == 1)
878 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
879 if (tst->ss->external) {
880 /* add a disk
881 * to an external metadata container */
882 struct mdinfo new_mdi;
883 struct mdinfo *sra;
884 int container_fd;
885 int devnum = fd2devnum(fd);
886 int dfd;
887
888 container_fd = open_dev_excl(devnum);
889 if (container_fd < 0) {
890 fprintf(stderr, Name ": add failed for %s:"
891 " could not get exclusive access to container\n",
892 dv->devname);
893 tst->ss->free_super(tst);
894 return 1;
895 }
896
897 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
898 if (mdmon_running(tst->container_dev))
899 tst->update_tail = &tst->updates;
900 if (tst->ss->add_to_super(tst, &disc, dfd,
901 dv->devname)) {
902 close(dfd);
903 close(container_fd);
904 return 1;
905 }
906 if (st->update_tail)
907 flush_metadata_updates(st);
908 else
909 tst->ss->sync_metadata(st);
910
911 sra = sysfs_read(container_fd, -1, 0);
912 if (!sra) {
913 fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
914 dv->devname);
915 close(container_fd);
916 tst->ss->free_super(tst);
917 return 1;
918 }
919 sra->array.level = LEVEL_CONTAINER;
920 /* Need to set data_offset and component_size */
921 tst->ss->getinfo_super(tst, &new_mdi, NULL);
922 new_mdi.disk.major = disc.major;
923 new_mdi.disk.minor = disc.minor;
924 new_mdi.recovery_start = 0;
925 /* Make sure fds are closed as they are O_EXCL which
926 * would block add_disk */
927 tst->ss->free_super(tst);
928 if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
929 fprintf(stderr, Name ": add new device to external metadata"
930 " failed for %s\n", dv->devname);
931 close(container_fd);
932 sysfs_free(sra);
933 return 1;
934 }
935 ping_monitor(devnum2devname(devnum));
936 sysfs_free(sra);
937 close(container_fd);
938 } else {
939 tst->ss->free_super(tst);
940 if (ioctl(fd, ADD_NEW_DISK, &disc)) {
941 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
942 dv->devname, j, strerror(errno));
943 return 1;
944 }
945 }
946 if (verbose >= 0)
947 fprintf(stderr, Name ": added %s\n", dv->devname);
948 break;
949
950 case 'r':
951 /* hot remove */
952 if (subarray) {
953 fprintf(stderr, Name ": Cannot remove disks from a"
954 " \'member\' array, perform this"
955 " operation on the parent container\n");
956 if (sysfd >= 0)
957 close(sysfd);
958 return 1;
959 }
960 if (tst->ss->external) {
961 /* To remove a device from a container, we must
962 * check that it isn't in use in an array.
963 * This involves looking in the 'holders'
964 * directory - there must be just one entry,
965 * the container.
966 * To ensure that it doesn't get used as a
967 * hold spare while we are checking, we
968 * get an O_EXCL open on the container
969 */
970 int dnum = fd2devnum(fd);
971 lfd = open_dev_excl(dnum);
972 if (lfd < 0) {
973 fprintf(stderr, Name
974 ": Cannot get exclusive access "
975 " to container - odd\n");
976 if (sysfd >= 0)
977 close(sysfd);
978 return 1;
979 }
980 /* in the detached case it is not possible to
981 * check if we are the unique holder, so just
982 * rely on the 'detached' checks
983 */
984 if (strcmp(dv->devname, "detached") == 0 ||
985 sysfd >= 0 ||
986 sysfs_unique_holder(dnum, stb.st_rdev))
987 /* pass */;
988 else {
989 fprintf(stderr, Name
990 ": %s is %s, cannot remove.\n",
991 dnprintable,
992 errno == EEXIST ? "still in use":
993 "not a member");
994 close(lfd);
995 return 1;
996 }
997 }
998 /* FIXME check that it is a current member */
999 if (sysfd >= 0) {
1000 /* device has been removed and we don't know
1001 * the major:minor number
1002 */
1003 int n = write(sysfd, "remove", 6);
1004 if (n != 6)
1005 err = -1;
1006 else
1007 err = 0;
1008 close(sysfd);
1009 sysfd = -1;
1010 } else {
1011 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
1012 if (err && errno == ENODEV) {
1013 /* Old kernels rejected this if no personality
1014 * registered */
1015 struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
1016 struct mdinfo *dv = NULL;
1017 if (sra)
1018 dv = sra->devs;
1019 for ( ; dv ; dv=dv->next)
1020 if (dv->disk.major == (int)major(stb.st_rdev) &&
1021 dv->disk.minor == (int)minor(stb.st_rdev))
1022 break;
1023 if (dv)
1024 err = sysfs_set_str(sra, dv,
1025 "state", "remove");
1026 else
1027 err = -1;
1028 if (sra)
1029 sysfs_free(sra);
1030 }
1031 }
1032 if (err) {
1033 fprintf(stderr, Name ": hot remove failed "
1034 "for %s: %s\n", dnprintable,
1035 strerror(errno));
1036 if (lfd >= 0)
1037 close(lfd);
1038 return 1;
1039 }
1040 if (tst->ss->external) {
1041 /*
1042 * Before dropping our exclusive open we make an
1043 * attempt at preventing mdmon from seeing an
1044 * 'add' event before reconciling this 'remove'
1045 * event.
1046 */
1047 char *name = devnum2devname(fd2devnum(fd));
1048
1049 if (!name) {
1050 fprintf(stderr, Name ": unable to get container name\n");
1051 return 1;
1052 }
1053
1054 ping_manager(name);
1055 free(name);
1056 }
1057 if (lfd >= 0)
1058 close(lfd);
1059 count++;
1060 if (verbose >= 0)
1061 fprintf(stderr, Name ": hot removed %s from %s\n",
1062 dnprintable, devname);
1063 break;
1064
1065 case 'f': /* set faulty */
1066 /* FIXME check current member */
1067 if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
1068 (sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
1069 (unsigned long) stb.st_rdev))) {
1070 fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
1071 dnprintable, strerror(errno));
1072 if (sysfd >= 0)
1073 close(sysfd);
1074 return 1;
1075 }
1076 if (sysfd >= 0)
1077 close(sysfd);
1078 sysfd = -1;
1079 count++;
1080 if (verbose >= 0)
1081 fprintf(stderr, Name ": set %s faulty in %s\n",
1082 dnprintable, devname);
1083 break;
1084 }
1085 }
1086 if (test && count == 0)
1087 return 2;
1088 return 0;
1089 }
1090
1091 int autodetect(void)
1092 {
1093 /* Open any md device, and issue the RAID_AUTORUN ioctl */
1094 int rv = 1;
1095 int fd = dev_open("9:0", O_RDONLY);
1096 if (fd >= 0) {
1097 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
1098 rv = 0;
1099 close(fd);
1100 }
1101 return rv;
1102 }
1103
1104 int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet)
1105 {
1106 struct supertype supertype, *st = &supertype;
1107 int fd, rv = 2;
1108
1109 memset(st, 0, sizeof(*st));
1110
1111 fd = open_subarray(dev, subarray, st, quiet);
1112 if (fd < 0)
1113 return 2;
1114
1115 if (!st->ss->update_subarray) {
1116 if (!quiet)
1117 fprintf(stderr,
1118 Name ": Operation not supported for %s metadata\n",
1119 st->ss->name);
1120 goto free_super;
1121 }
1122
1123 if (mdmon_running(st->devnum))
1124 st->update_tail = &st->updates;
1125
1126 rv = st->ss->update_subarray(st, subarray, update, ident);
1127
1128 if (rv) {
1129 if (!quiet)
1130 fprintf(stderr, Name ": Failed to update %s of subarray-%s in %s\n",
1131 update, subarray, dev);
1132 } else if (st->update_tail)
1133 flush_metadata_updates(st);
1134 else
1135 st->ss->sync_metadata(st);
1136
1137 if (rv == 0 && strcmp(update, "name") == 0 && !quiet)
1138 fprintf(stderr,
1139 Name ": Updated subarray-%s name from %s, UUIDs may have changed\n",
1140 subarray, dev);
1141
1142 free_super:
1143 st->ss->free_super(st);
1144 close(fd);
1145
1146 return rv;
1147 }
1148
1149 /* Move spare from one array to another
1150 * If adding to destination array fails
1151 * add back to original array
1152 * Returns 1 on success, 0 on failure */
1153 int move_spare(char *from_devname, char *to_devname, dev_t devid)
1154 {
1155 struct mddev_dev devlist;
1156 char devname[20];
1157
1158 /* try to remove and add */
1159 int fd1 = open(to_devname, O_RDONLY);
1160 int fd2 = open(from_devname, O_RDONLY);
1161
1162 if (fd1 < 0 || fd2 < 0) {
1163 if (fd1>=0) close(fd1);
1164 if (fd2>=0) close(fd2);
1165 return 0;
1166 }
1167
1168 devlist.next = NULL;
1169 devlist.used = 0;
1170 devlist.re_add = 0;
1171 devlist.writemostly = 0;
1172 devlist.devname = devname;
1173 sprintf(devname, "%d:%d", major(devid), minor(devid));
1174
1175 devlist.disposition = 'r';
1176 if (Manage_subdevs(from_devname, fd2, &devlist, -1, 0, NULL) == 0) {
1177 devlist.disposition = 'a';
1178 if (Manage_subdevs(to_devname, fd1, &devlist, -1, 0, NULL) == 0) {
1179 /* make sure manager is aware of changes */
1180 ping_manager(to_devname);
1181 ping_manager(from_devname);
1182 close(fd1);
1183 close(fd2);
1184 return 1;
1185 }
1186 else Manage_subdevs(from_devname, fd2, &devlist, -1, 0, NULL);
1187 }
1188 close(fd1);
1189 close(fd2);
1190 return 0;
1191 }
1192 #endif
Unnamed repository; edit this file 'description' to name the repository.