]> 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: allow manual control of external raid0 readonly flag
[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 /* 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 struct mdstat_ent *mds, *m;
239 /* container, possibly mdmon-managed.
240 * Make sure mdmon isn't opening it, which
241 * would interfere with the 'stop'
242 */
243 ping_monitor(mdi->sys_name);
244
245 /* now check that there are no existing arrays
246 * which are members of this array
247 */
248 mds = mdstat_read(0, 0);
249 for (m=mds; m; m=m->next)
250 if (m->metadata_version &&
251 strncmp(m->metadata_version, "external:", 9)==0 &&
252 is_subarray(m->metadata_version+9) &&
253 devname2devnum(m->metadata_version+10) == devnum) {
254 if (!quiet)
255 fprintf(stderr, Name
256 ": Cannot stop container %s: "
257 "member %s still active\n",
258 devname, m->dev);
259 free_mdstat(mds);
260 if (mdi)
261 sysfs_free(mdi);
262 return 1;
263 }
264 }
265
266 if (fd >= 0 && ioctl(fd, STOP_ARRAY, NULL)) {
267 if (quiet == 0) {
268 fprintf(stderr, Name
269 ": failed to stop array %s: %s\n",
270 devname, strerror(errno));
271 if (errno == EBUSY)
272 fprintf(stderr, "Perhaps a running "
273 "process, mounted filesystem "
274 "or active volume group?\n");
275 }
276 if (mdi)
277 sysfs_free(mdi);
278 return 1;
279 }
280 /* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
281 * was stopped, so We'll do it here just to be sure. Drop any
282 * partitions as well...
283 */
284 if (fd >= 0)
285 ioctl(fd, BLKRRPART, 0);
286 if (mdi)
287 sysfs_uevent(mdi, "change");
288
289
290 if (devnum != NoMdDev &&
291 (stat("/dev/.udev", &stb) != 0 ||
292 check_env("MDADM_NO_UDEV"))) {
293 struct map_ent *mp = map_by_devnum(&map, devnum);
294 remove_devices(devnum, mp ? mp->path : NULL);
295 }
296
297
298 if (quiet <= 0)
299 fprintf(stderr, Name ": stopped %s\n", devname);
300 map_lock(&map);
301 map_remove(&map, devnum);
302 map_unlock(&map);
303 }
304 return 0;
305 }
306
307 int Manage_resize(char *devname, int fd, long long size, int raid_disks)
308 {
309 mdu_array_info_t info;
310 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
311 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
312 devname, strerror(errno));
313 return 1;
314 }
315 if (size >= 0)
316 info.size = size;
317 if (raid_disks > 0)
318 info.raid_disks = raid_disks;
319 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
320 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
321 devname, strerror(errno));
322 return 1;
323 }
324 return 0;
325 }
326
327 int Manage_subdevs(char *devname, int fd,
328 struct mddev_dev *devlist, int verbose, int test)
329 {
330 /* do something to each dev.
331 * devmode can be
332 * 'a' - add the device
333 * try HOT_ADD_DISK
334 * If that fails EINVAL, try ADD_NEW_DISK
335 * 'r' - remove the device HOT_REMOVE_DISK
336 * device can be 'faulty' or 'detached' in which case all
337 * matching devices are removed.
338 * 'f' - set the device faulty SET_DISK_FAULTY
339 * device can be 'detached' in which case any device that
340 * is inaccessible will be marked faulty.
341 * For 'f' and 'r', the device can also be a kernel-internal
342 * name such as 'sdb'.
343 */
344 struct mddev_dev *add_devlist = NULL;
345 mdu_array_info_t array;
346 mdu_disk_info_t disc;
347 unsigned long long array_size;
348 struct mddev_dev *dv, *next = NULL;
349 struct stat stb;
350 int j, jnext = 0;
351 int tfd = -1;
352 struct supertype *st, *tst;
353 char *subarray = NULL;
354 int duuid[4];
355 int ouuid[4];
356 int lfd = -1;
357 int sysfd = -1;
358 int count = 0; /* number of actions taken */
359
360 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
361 fprintf(stderr, Name ": cannot get array info for %s\n",
362 devname);
363 return 1;
364 }
365
366 /* array.size is only 32 bit and may be truncated.
367 * So read from sysfs if possible, and record number of sectors
368 */
369
370 array_size = get_component_size(fd);
371 if (array_size <= 0)
372 array_size = array.size * 2;
373
374 tst = super_by_fd(fd, &subarray);
375 if (!tst) {
376 fprintf(stderr, Name ": unsupport array - version %d.%d\n",
377 array.major_version, array.minor_version);
378 return 1;
379 }
380
381 stb.st_rdev = 0;
382 for (dv = devlist, j=0 ; dv; dv = next, j = jnext) {
383 unsigned long long ldsize;
384 char dvname[20];
385 char *dnprintable = dv->devname;
386 char *add_dev = dv->devname;
387 int err;
388 int re_add_failed = 0;
389
390 next = dv->next;
391 jnext = 0;
392
393 if (strcmp(dv->devname, "failed")==0 ||
394 strcmp(dv->devname, "faulty")==0) {
395 if (dv->disposition != 'r') {
396 fprintf(stderr, Name ": %s only meaningful "
397 "with -r, not -%c\n",
398 dv->devname, dv->disposition);
399 return 1;
400 }
401 for (; j < array.raid_disks + array.nr_disks ; j++) {
402 unsigned dev;
403 disc.number = j;
404 if (ioctl(fd, GET_DISK_INFO, &disc))
405 continue;
406 if (disc.major == 0 && disc.minor == 0)
407 continue;
408 if ((disc.state & 1) == 0) /* faulty */
409 continue;
410 dev = makedev(disc.major, disc.minor);
411 if (stb.st_rdev == dev)
412 /* already did that one */
413 continue;
414 stb.st_rdev = dev;
415 next = dv;
416 /* same slot again next time - things might
417 * have reshuffled */
418 jnext = j;
419 sprintf(dvname,"%d:%d", disc.major, disc.minor);
420 dnprintable = dvname;
421 break;
422 }
423 if (jnext == 0)
424 continue;
425 } else if (strcmp(dv->devname, "detached") == 0) {
426 if (dv->disposition != 'r' && dv->disposition != 'f') {
427 fprintf(stderr, Name ": %s only meaningful "
428 "with -r of -f, not -%c\n",
429 dv->devname, dv->disposition);
430 return 1;
431 }
432 for (; j < array.raid_disks + array.nr_disks; j++) {
433 int sfd;
434 unsigned dev;
435 disc.number = j;
436 if (ioctl(fd, GET_DISK_INFO, &disc))
437 continue;
438 if (disc.major == 0 && disc.minor == 0)
439 continue;
440 sprintf(dvname,"%d:%d", disc.major, disc.minor);
441 sfd = dev_open(dvname, O_RDONLY);
442 if (sfd >= 0) {
443 close(sfd);
444 continue;
445 }
446 if (dv->disposition == 'f' &&
447 (disc.state & 1) == 1) /* already faulty */
448 continue;
449 if (errno != ENXIO)
450 continue;
451 dev = makedev(disc.major, disc.minor);
452 if (stb.st_rdev == dev)
453 /* already did that one */
454 continue;
455 stb.st_rdev = dev;
456 next = dv;
457 /* same slot again next time - things might
458 * have reshuffled */
459 jnext = j;
460 dnprintable = dvname;
461 break;
462 }
463 if (jnext == 0)
464 continue;
465 } else if (strcmp(dv->devname, "missing") == 0) {
466 if (dv->disposition != 'a' || dv->re_add == 0) {
467 fprintf(stderr, Name ": 'missing' only meaningful "
468 "with --re-add\n");
469 return 1;
470 }
471 if (add_devlist == NULL)
472 add_devlist = conf_get_devs();
473 if (add_devlist == NULL) {
474 fprintf(stderr, Name ": no devices to scan for missing members.");
475 continue;
476 }
477 add_dev = add_devlist->devname;
478 add_devlist = add_devlist->next;
479 if (add_devlist != NULL)
480 next = dv;
481 if (stat(add_dev, &stb) < 0)
482 continue;
483 } else if (strchr(dv->devname, '/') == NULL &&
484 strchr(dv->devname, ':') == NULL &&
485 strlen(dv->devname) < 50) {
486 /* Assume this is a kernel-internal name like 'sda1' */
487 int found = 0;
488 char dname[55];
489 if (dv->disposition != 'r' && dv->disposition != 'f') {
490 fprintf(stderr, Name ": %s only meaningful "
491 "with -r or -f, not -%c\n",
492 dv->devname, dv->disposition);
493 return 1;
494 }
495
496 sprintf(dname, "dev-%s", dv->devname);
497 sysfd = sysfs_open(fd2devnum(fd), dname, "block/dev");
498 if (sysfd >= 0) {
499 char dn[20];
500 int mj,mn;
501 if (sysfs_fd_get_str(sysfd, dn, 20) > 0 &&
502 sscanf(dn, "%d:%d", &mj,&mn) == 2) {
503 stb.st_rdev = makedev(mj,mn);
504 found = 1;
505 }
506 close(sysfd);
507 sysfd = -1;
508 }
509 if (!found) {
510 sysfd = sysfs_open(fd2devnum(fd), dname, "state");
511 if (sysfd < 0) {
512 fprintf(stderr, Name ": %s does not appear "
513 "to be a component of %s\n",
514 dv->devname, devname);
515 return 1;
516 }
517 }
518 } else {
519 j = 0;
520
521 tfd = dev_open(dv->devname, O_RDONLY);
522 if (tfd < 0 && dv->disposition == 'r' &&
523 lstat(dv->devname, &stb) == 0)
524 /* Be happy, the lstat worked, that is
525 * enough for --remove
526 */
527 ;
528 else {
529 if (tfd < 0 || fstat(tfd, &stb) != 0) {
530 fprintf(stderr, Name ": cannot find %s: %s\n",
531 dv->devname, strerror(errno));
532 if (tfd >= 0)
533 close(tfd);
534 return 1;
535 }
536 close(tfd);
537 tfd = -1;
538 }
539 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
540 fprintf(stderr, Name ": %s is not a "
541 "block device.\n",
542 dv->devname);
543 return 1;
544 }
545 }
546 switch(dv->disposition){
547 default:
548 fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
549 dv->devname, dv->disposition);
550 return 1;
551 case 'a':
552 /* add the device */
553 if (subarray) {
554 fprintf(stderr, Name ": Cannot add disks to a"
555 " \'member\' array, perform this"
556 " operation on the parent container\n");
557 return 1;
558 }
559 /* Make sure it isn't in use (in 2.6 or later) */
560 tfd = dev_open(add_dev, O_RDONLY|O_EXCL|O_DIRECT);
561 if (tfd < 0 && add_dev != dv->devname)
562 continue;
563 if (tfd < 0) {
564 fprintf(stderr, Name ": Cannot open %s: %s\n",
565 dv->devname, strerror(errno));
566 return 1;
567 }
568
569 st = dup_super(tst);
570
571 if (array.not_persistent==0)
572 st->ss->load_super(st, tfd, NULL);
573
574 if (add_dev == dv->devname) {
575 if (!get_dev_size(tfd, dv->devname, &ldsize)) {
576 close(tfd);
577 return 1;
578 }
579 } else if (!get_dev_size(tfd, NULL, &ldsize)) {
580 close(tfd);
581 tfd = -1;
582 continue;
583 }
584
585 if (!tst->ss->external &&
586 array.major_version == 0 &&
587 md_get_version(fd)%100 < 2) {
588 close(tfd);
589 tfd = -1;
590 if (ioctl(fd, HOT_ADD_DISK,
591 (unsigned long)stb.st_rdev)==0) {
592 if (verbose >= 0)
593 fprintf(stderr, Name ": hot added %s\n",
594 add_dev);
595 continue;
596 }
597
598 fprintf(stderr, Name ": hot add failed for %s: %s\n",
599 add_dev, strerror(errno));
600 return 1;
601 }
602
603 if (array.not_persistent == 0 || tst->ss->external) {
604
605 /* need to find a sample superblock to copy, and
606 * a spare slot to use.
607 * For 'external' array (well, container based),
608 * We can just load the metadata for the array.
609 */
610 if (tst->sb)
611 /* already loaded */;
612 else if (tst->ss->external) {
613 tst->ss->load_container(tst, fd, NULL);
614 } else for (j = 0; j < tst->max_devs; j++) {
615 char *dev;
616 int dfd;
617 disc.number = j;
618 if (ioctl(fd, GET_DISK_INFO, &disc))
619 continue;
620 if (disc.major==0 && disc.minor==0)
621 continue;
622 if ((disc.state & 4)==0) continue; /* sync */
623 /* Looks like a good device to try */
624 dev = map_dev(disc.major, disc.minor, 1);
625 if (!dev) continue;
626 dfd = dev_open(dev, O_RDONLY);
627 if (dfd < 0) continue;
628 if (tst->ss->load_super(tst, dfd,
629 NULL)) {
630 close(dfd);
631 continue;
632 }
633 close(dfd);
634 break;
635 }
636 /* FIXME this is a bad test to be using */
637 if (!tst->sb) {
638 close(tfd);
639 fprintf(stderr, Name ": cannot find valid superblock in this array - HELP\n");
640 return 1;
641 }
642
643 /* Make sure device is large enough */
644 if (tst->ss->avail_size(tst, ldsize/512) <
645 array_size) {
646 close(tfd);
647 tfd = -1;
648 if (add_dev != dv->devname)
649 continue;
650 fprintf(stderr, Name ": %s not large enough to join array\n",
651 dv->devname);
652 return 1;
653 }
654
655 /* Possibly this device was recently part of the array
656 * and was temporarily removed, and is now being re-added.
657 * If so, we can simply re-add it.
658 */
659 tst->ss->uuid_from_super(tst, duuid);
660
661 /* re-add doesn't work for version-1 superblocks
662 * before 2.6.18 :-(
663 */
664 if (array.major_version == 1 &&
665 get_linux_version() <= 2006018)
666 ;
667 else if (st->sb) {
668 struct mdinfo mdi;
669 st->ss->getinfo_super(st, &mdi, NULL);
670 st->ss->uuid_from_super(st, ouuid);
671 if ((mdi.disk.state & (1<<MD_DISK_ACTIVE)) &&
672 !(mdi.disk.state & (1<<MD_DISK_FAULTY)) &&
673 memcmp(duuid, ouuid, sizeof(ouuid))==0) {
674 /* look like it is worth a try. Need to
675 * make sure kernel will accept it though.
676 */
677 disc.number = mdi.disk.number;
678 if (ioctl(fd, GET_DISK_INFO, &disc) != 0
679 || disc.major != 0 || disc.minor != 0
680 || !enough_fd(fd))
681 goto skip_re_add;
682 disc.major = major(stb.st_rdev);
683 disc.minor = minor(stb.st_rdev);
684 disc.number = mdi.disk.number;
685 disc.raid_disk = mdi.disk.raid_disk;
686 disc.state = mdi.disk.state;
687 if (dv->writemostly == 1)
688 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
689 if (dv->writemostly == 2)
690 disc.state &= ~(1 << MD_DISK_WRITEMOSTLY);
691 remove_partitions(tfd);
692 close(tfd);
693 tfd = -1;
694 /* don't even try if disk is marked as faulty */
695 errno = 0;
696 if (ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
697 if (verbose >= 0)
698 fprintf(stderr, Name ": re-added %s\n", add_dev);
699 count++;
700 continue;
701 }
702 if (errno == ENOMEM || errno == EROFS) {
703 fprintf(stderr, Name ": add new device failed for %s: %s\n",
704 add_dev, strerror(errno));
705 if (add_dev != dv->devname)
706 continue;
707 return 1;
708 }
709 skip_re_add:
710 re_add_failed = 1;
711 }
712 }
713 if (add_dev != dv->devname) {
714 if (verbose > 0)
715 fprintf(stderr, Name
716 ": --re-add for %s to %s is not possible\n",
717 add_dev, devname);
718 if (tfd >= 0) {
719 close(tfd);
720 tfd = -1;
721 }
722 continue;
723 }
724 if (dv->re_add) {
725 if (tfd >= 0)
726 close(tfd);
727 fprintf(stderr, Name
728 ": --re-add for %s to %s is not possible\n",
729 dv->devname, devname);
730 return 1;
731 }
732 if (re_add_failed) {
733 fprintf(stderr, Name ": %s reports being an active member for %s, but a --re-add fails.\n",
734 dv->devname, devname);
735 fprintf(stderr, Name ": not performing --add as that would convert %s in to a spare.\n",
736 dv->devname);
737 fprintf(stderr, Name ": To make this a spare, use \"mdadm --zero-superblock %s\" first.\n",
738 dv->devname);
739 if (tfd >= 0)
740 close(tfd);
741 return 1;
742 }
743 } else {
744 /* non-persistent. Must ensure that new drive
745 * is at least array.size big.
746 */
747 if (ldsize/512 < array_size) {
748 fprintf(stderr, Name ": %s not large enough to join array\n",
749 dv->devname);
750 if (tfd >= 0)
751 close(tfd);
752 return 1;
753 }
754 }
755 /* committed to really trying this device now*/
756 if (tfd >= 0) {
757 remove_partitions(tfd);
758 close(tfd);
759 tfd = -1;
760 }
761 /* in 2.6.17 and earlier, version-1 superblocks won't
762 * use the number we write, but will choose a free number.
763 * we must choose the same free number, which requires
764 * starting at 'raid_disks' and counting up
765 */
766 for (j = array.raid_disks; j< tst->max_devs; j++) {
767 disc.number = j;
768 if (ioctl(fd, GET_DISK_INFO, &disc))
769 break;
770 if (disc.major==0 && disc.minor==0)
771 break;
772 if (disc.state & 8) /* removed */
773 break;
774 }
775 disc.major = major(stb.st_rdev);
776 disc.minor = minor(stb.st_rdev);
777 disc.number =j;
778 disc.state = 0;
779 if (array.not_persistent==0 || tst->ss->external) {
780 int dfd;
781 if (dv->writemostly == 1)
782 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
783 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
784 if (tst->ss->add_to_super(tst, &disc, dfd,
785 dv->devname)) {
786 close(dfd);
787 return 1;
788 }
789 /* write_init_super will close 'dfd' */
790 if (tst->ss->external)
791 /* mdmon will write the metadata */
792 close(dfd);
793 else if (tst->ss->write_init_super(tst))
794 return 1;
795 } else if (dv->re_add) {
796 /* this had better be raid1.
797 * As we are "--re-add"ing we must find a spare slot
798 * to fill.
799 */
800 char *used = malloc(array.raid_disks);
801 memset(used, 0, array.raid_disks);
802 for (j=0; j< tst->max_devs; j++) {
803 mdu_disk_info_t disc2;
804 disc2.number = j;
805 if (ioctl(fd, GET_DISK_INFO, &disc2))
806 continue;
807 if (disc2.major==0 && disc2.minor==0)
808 continue;
809 if (disc2.state & 8) /* removed */
810 continue;
811 if (disc2.raid_disk < 0)
812 continue;
813 if (disc2.raid_disk > array.raid_disks)
814 continue;
815 used[disc2.raid_disk] = 1;
816 }
817 for (j=0 ; j<array.raid_disks; j++)
818 if (!used[j]) {
819 disc.raid_disk = j;
820 disc.state |= (1<<MD_DISK_SYNC);
821 break;
822 }
823 free(used);
824 }
825 if (dv->writemostly == 1)
826 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
827 if (tst->ss->external) {
828 /* add a disk to an external metadata container
829 * only if mdmon is around to see it
830 */
831 struct mdinfo new_mdi;
832 struct mdinfo *sra;
833 int container_fd;
834 int devnum = fd2devnum(fd);
835
836 container_fd = open_dev_excl(devnum);
837 if (container_fd < 0) {
838 fprintf(stderr, Name ": add failed for %s:"
839 " could not get exclusive access to container\n",
840 dv->devname);
841 return 1;
842 }
843
844 if (!mdmon_running(devnum)) {
845 fprintf(stderr, Name ": add failed for %s: mdmon not running\n",
846 dv->devname);
847 close(container_fd);
848 return 1;
849 }
850
851 sra = sysfs_read(container_fd, -1, 0);
852 if (!sra) {
853 fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
854 dv->devname);
855 close(container_fd);
856 return 1;
857 }
858 sra->array.level = LEVEL_CONTAINER;
859 /* Need to set data_offset and component_size */
860 tst->ss->getinfo_super(tst, &new_mdi, NULL);
861 new_mdi.disk.major = disc.major;
862 new_mdi.disk.minor = disc.minor;
863 new_mdi.recovery_start = 0;
864 if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
865 fprintf(stderr, Name ": add new device to external metadata"
866 " failed for %s\n", dv->devname);
867 close(container_fd);
868 return 1;
869 }
870 ping_monitor(devnum2devname(devnum));
871 sysfs_free(sra);
872 close(container_fd);
873 } else if (ioctl(fd, ADD_NEW_DISK, &disc)) {
874 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
875 dv->devname, j, strerror(errno));
876 return 1;
877 }
878 if (verbose >= 0)
879 fprintf(stderr, Name ": added %s\n", dv->devname);
880 break;
881
882 case 'r':
883 /* hot remove */
884 if (subarray) {
885 fprintf(stderr, Name ": Cannot remove disks from a"
886 " \'member\' array, perform this"
887 " operation on the parent container\n");
888 if (sysfd >= 0)
889 close(sysfd);
890 return 1;
891 }
892 if (tst->ss->external) {
893 /* To remove a device from a container, we must
894 * check that it isn't in use in an array.
895 * This involves looking in the 'holders'
896 * directory - there must be just one entry,
897 * the container.
898 * To ensure that it doesn't get used as a
899 * hold spare while we are checking, we
900 * get an O_EXCL open on the container
901 */
902 int dnum = fd2devnum(fd);
903 lfd = open_dev_excl(dnum);
904 if (lfd < 0) {
905 fprintf(stderr, Name
906 ": Cannot get exclusive access "
907 " to container - odd\n");
908 if (sysfd >= 0)
909 close(sysfd);
910 return 1;
911 }
912 /* in the detached case it is not possible to
913 * check if we are the unique holder, so just
914 * rely on the 'detached' checks
915 */
916 if (strcmp(dv->devname, "detached") == 0 ||
917 sysfd >= 0 ||
918 sysfs_unique_holder(dnum, stb.st_rdev))
919 /* pass */;
920 else {
921 fprintf(stderr, Name
922 ": %s is %s, cannot remove.\n",
923 dnprintable,
924 errno == EEXIST ? "still in use":
925 "not a member");
926 close(lfd);
927 return 1;
928 }
929 }
930 /* FIXME check that it is a current member */
931 if (sysfd >= 0) {
932 /* device has been removed and we don't know
933 * the major:minor number
934 */
935 int n = write(sysfd, "remove", 6);
936 if (n != 6)
937 err = -1;
938 else
939 err = 0;
940 close(sysfd);
941 sysfd = -1;
942 } else {
943 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
944 if (err && errno == ENODEV) {
945 /* Old kernels rejected this if no personality
946 * registered */
947 struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
948 struct mdinfo *dv = NULL;
949 if (sra)
950 dv = sra->devs;
951 for ( ; dv ; dv=dv->next)
952 if (dv->disk.major == (int)major(stb.st_rdev) &&
953 dv->disk.minor == (int)minor(stb.st_rdev))
954 break;
955 if (dv)
956 err = sysfs_set_str(sra, dv,
957 "state", "remove");
958 else
959 err = -1;
960 if (sra)
961 sysfs_free(sra);
962 }
963 }
964 if (err) {
965 fprintf(stderr, Name ": hot remove failed "
966 "for %s: %s\n", dnprintable,
967 strerror(errno));
968 if (lfd >= 0)
969 close(lfd);
970 return 1;
971 }
972 if (tst->ss->external) {
973 /*
974 * Before dropping our exclusive open we make an
975 * attempt at preventing mdmon from seeing an
976 * 'add' event before reconciling this 'remove'
977 * event.
978 */
979 char *name = devnum2devname(fd2devnum(fd));
980
981 if (!name) {
982 fprintf(stderr, Name ": unable to get container name\n");
983 return 1;
984 }
985
986 ping_manager(name);
987 free(name);
988 }
989 if (lfd >= 0)
990 close(lfd);
991 count++;
992 if (verbose >= 0)
993 fprintf(stderr, Name ": hot removed %s from %s\n",
994 dnprintable, devname);
995 break;
996
997 case 'f': /* set faulty */
998 /* FIXME check current member */
999 if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
1000 (sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
1001 (unsigned long) stb.st_rdev))) {
1002 fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
1003 dnprintable, strerror(errno));
1004 if (sysfd >= 0)
1005 close(sysfd);
1006 return 1;
1007 }
1008 if (sysfd >= 0)
1009 close(sysfd);
1010 sysfd = -1;
1011 count++;
1012 if (verbose >= 0)
1013 fprintf(stderr, Name ": set %s faulty in %s\n",
1014 dnprintable, devname);
1015 break;
1016 }
1017 }
1018 if (test && count == 0)
1019 return 2;
1020 return 0;
1021 }
1022
1023 int autodetect(void)
1024 {
1025 /* Open any md device, and issue the RAID_AUTORUN ioctl */
1026 int rv = 1;
1027 int fd = dev_open("9:0", O_RDONLY);
1028 if (fd >= 0) {
1029 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
1030 rv = 0;
1031 close(fd);
1032 }
1033 return rv;
1034 }
1035
1036 int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet)
1037 {
1038 struct supertype supertype, *st = &supertype;
1039 int fd, rv = 2;
1040
1041 memset(st, 0, sizeof(*st));
1042
1043 fd = open_subarray(dev, subarray, st, quiet);
1044 if (fd < 0)
1045 return 2;
1046
1047 if (!st->ss->update_subarray) {
1048 if (!quiet)
1049 fprintf(stderr,
1050 Name ": Operation not supported for %s metadata\n",
1051 st->ss->name);
1052 goto free_super;
1053 }
1054
1055 if (mdmon_running(st->devnum))
1056 st->update_tail = &st->updates;
1057
1058 rv = st->ss->update_subarray(st, subarray, update, ident);
1059
1060 if (rv) {
1061 if (!quiet)
1062 fprintf(stderr, Name ": Failed to update %s of subarray-%s in %s\n",
1063 update, subarray, dev);
1064 } else if (st->update_tail)
1065 flush_metadata_updates(st);
1066 else
1067 st->ss->sync_metadata(st);
1068
1069 if (rv == 0 && strcmp(update, "name") == 0 && !quiet)
1070 fprintf(stderr,
1071 Name ": Updated subarray-%s name from %s, UUIDs may have changed\n",
1072 subarray, dev);
1073
1074 free_super:
1075 st->ss->free_super(st);
1076 close(fd);
1077
1078 return rv;
1079 }
1080 #endif
Unnamed repository; edit this file 'description' to name the repository.