]> 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
Merge branch 'master' of git://github.com/djbw/mdadm
[thirdparty/mdadm.git] / Manage.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neilb@suse.de>
23 */
24
25 #include "mdadm.h"
26 #include "md_u.h"
27 #include "md_p.h"
28 #include <ctype.h>
29
30 #define REGISTER_DEV _IO (MD_MAJOR, 1)
31 #define START_MD _IO (MD_MAJOR, 2)
32 #define STOP_MD _IO (MD_MAJOR, 3)
33
34 int Manage_ro(char *devname, int fd, int readonly)
35 {
36 /* switch to readonly or rw
37 *
38 * requires >= 0.90.0
39 * first check that array is runing
40 * use RESTART_ARRAY_RW or STOP_ARRAY_RO
41 *
42 */
43 mdu_array_info_t array;
44 #ifndef MDASSEMBLE
45 struct mdinfo *mdi;
46 #endif
47
48 if (md_get_version(fd) < 9000) {
49 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
50 return 1;
51 }
52 #ifndef MDASSEMBLE
53 /* If this is an externally-manage array, we need to modify the
54 * metadata_version so that mdmon doesn't undo our change.
55 */
56 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
57 if (mdi &&
58 mdi->array.major_version == -1 &&
59 mdi->array.level > 0 &&
60 is_subarray(mdi->text_version)) {
61 char vers[64];
62 strcpy(vers, "external:");
63 strcat(vers, mdi->text_version);
64 if (readonly > 0) {
65 int rv;
66 /* We set readonly ourselves. */
67 vers[9] = '-';
68 sysfs_set_str(mdi, NULL, "metadata_version", vers);
69
70 close(fd);
71 rv = sysfs_set_str(mdi, NULL, "array_state", "readonly");
72
73 if (rv < 0) {
74 fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
75 devname, strerror(errno));
76
77 vers[9] = mdi->text_version[0];
78 sysfs_set_str(mdi, NULL, "metadata_version", vers);
79 return 1;
80 }
81 } else {
82 char *cp;
83 /* We cannot set read/write - must signal mdmon */
84 vers[9] = '/';
85 sysfs_set_str(mdi, NULL, "metadata_version", vers);
86
87 cp = strchr(vers+10, '/');
88 if (*cp)
89 *cp = 0;
90 ping_monitor(vers+10);
91 }
92 return 0;
93 }
94 #endif
95 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
96 fprintf(stderr, Name ": %s does not appear to be active.\n",
97 devname);
98 return 1;
99 }
100
101 if (readonly>0) {
102 if (ioctl(fd, STOP_ARRAY_RO, NULL)) {
103 fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
104 devname, strerror(errno));
105 return 1;
106 }
107 } else if (readonly < 0) {
108 if (ioctl(fd, RESTART_ARRAY_RW, NULL)) {
109 fprintf(stderr, Name ": failed to set writable for %s: %s\n",
110 devname, strerror(errno));
111 return 1;
112 }
113 }
114 return 0;
115 }
116
117 #ifndef MDASSEMBLE
118
119 static void remove_devices(int devnum, char *path)
120 {
121 /* Remove all 'standard' devices for 'devnum', including
122 * partitions. Also remove names at 'path' - possibly with
123 * partition suffixes - which link to those names.
124 */
125 char base[40];
126 char *path2;
127 char link[1024];
128 int n;
129 int part;
130 char *be;
131 char *pe;
132
133 if (devnum >= 0)
134 sprintf(base, "/dev/md%d", devnum);
135 else
136 sprintf(base, "/dev/md_d%d", -1-devnum);
137 be = base + strlen(base);
138 if (path) {
139 path2 = malloc(strlen(path)+20);
140 strcpy(path2, path);
141 pe = path2 + strlen(path2);
142 } else
143 path2 = path = NULL;
144
145 for (part = 0; part < 16; part++) {
146 if (part) {
147 sprintf(be, "p%d", part);
148 if (path) {
149 if (isdigit(pe[-1]))
150 sprintf(pe, "p%d", part);
151 else
152 sprintf(pe, "%d", part);
153 }
154 }
155 /* FIXME test if really is md device ?? */
156 unlink(base);
157 if (path) {
158 n = readlink(path2, link, sizeof(link));
159 if (n && strlen(base) == n &&
160 strncmp(link, base, n) == 0)
161 unlink(path2);
162 }
163 }
164 free(path2);
165 }
166
167
168 int Manage_runstop(char *devname, int fd, int runstop, int quiet)
169 {
170 /* Run or stop the array. array must already be configured
171 * required >= 0.90.0
172 * Only print failure messages if quiet == 0;
173 * quiet > 0 means really be quiet
174 * quiet < 0 means we will try again if it fails.
175 */
176 mdu_param_t param; /* unused */
177
178 if (runstop == -1 && md_get_version(fd) < 9000) {
179 if (ioctl(fd, STOP_MD, 0)) {
180 if (quiet == 0) fprintf(stderr,
181 Name ": stopping device %s "
182 "failed: %s\n",
183 devname, strerror(errno));
184 return 1;
185 }
186 }
187
188 if (md_get_version(fd) < 9000) {
189 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
190 return 1;
191 }
192 /*
193 if (ioctl(fd, GET_ARRAY_INFO, &array)) {
194 fprintf(stderr, Name ": %s does not appear to be active.\n",
195 devname);
196 return 1;
197 }
198 */
199 if (runstop>0) {
200 if (ioctl(fd, RUN_ARRAY, &param)) {
201 fprintf(stderr, Name ": failed to run array %s: %s\n",
202 devname, strerror(errno));
203 return 1;
204 }
205 if (quiet <= 0)
206 fprintf(stderr, Name ": started %s\n", devname);
207 } else if (runstop < 0){
208 struct map_ent *map = NULL;
209 struct stat stb;
210 struct mdinfo *mdi;
211 int devnum;
212 /* If this is an mdmon managed array, just write 'inactive'
213 * to the array state and let mdmon clear up.
214 */
215 devnum = fd2devnum(fd);
216 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
217 if (mdi &&
218 mdi->array.level > 0 &&
219 is_subarray(mdi->text_version)) {
220 /* This is mdmon managed. */
221 close(fd);
222 if (sysfs_set_str(mdi, NULL,
223 "array_state", "inactive") < 0) {
224 if (quiet == 0)
225 fprintf(stderr, Name
226 ": failed to stop array %s: %s\n",
227 devname, strerror(errno));
228 return 1;
229 }
230
231 /* Give monitor a chance to act */
232 ping_monitor(mdi->text_version);
233
234 fd = open(devname, O_RDONLY);
235 } else if (mdi &&
236 mdi->array.major_version == -1 &&
237 mdi->array.minor_version == -2 &&
238 !is_subarray(mdi->text_version)) {
239 struct mdstat_ent *mds, *m;
240 /* container, possibly mdmon-managed.
241 * Make sure mdmon isn't opening it, which
242 * would interfere with the 'stop'
243 */
244 ping_monitor(mdi->sys_name);
245
246 /* now check that there are no existing arrays
247 * which are members of this array
248 */
249 mds = mdstat_read(0, 0);
250 for (m=mds; m; m=m->next)
251 if (m->metadata_version &&
252 strncmp(m->metadata_version, "external:", 9)==0 &&
253 is_subarray(m->metadata_version+9) &&
254 devname2devnum(m->metadata_version+10) == devnum) {
255 if (!quiet)
256 fprintf(stderr, Name
257 ": Cannot stop container %s: "
258 "member %s still active\n",
259 devname, m->dev);
260 free_mdstat(mds);
261 if (mdi)
262 sysfs_free(mdi);
263 return 1;
264 }
265 }
266
267 if (fd >= 0 && ioctl(fd, STOP_ARRAY, NULL)) {
268 if (quiet == 0) {
269 fprintf(stderr, Name
270 ": failed to stop array %s: %s\n",
271 devname, strerror(errno));
272 if (errno == EBUSY)
273 fprintf(stderr, "Perhaps a running "
274 "process, mounted filesystem "
275 "or active volume group?\n");
276 }
277 if (mdi)
278 sysfs_free(mdi);
279 return 1;
280 }
281 /* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
282 * was stopped, so We'll do it here just to be sure. Drop any
283 * partitions as well...
284 */
285 if (fd >= 0)
286 ioctl(fd, BLKRRPART, 0);
287 if (mdi)
288 sysfs_uevent(mdi, "change");
289
290
291 if (devnum != NoMdDev &&
292 (stat("/dev/.udev", &stb) != 0 ||
293 check_env("MDADM_NO_UDEV"))) {
294 struct map_ent *mp = map_by_devnum(&map, devnum);
295 remove_devices(devnum, mp ? mp->path : NULL);
296 }
297
298
299 if (quiet <= 0)
300 fprintf(stderr, Name ": stopped %s\n", devname);
301 map_lock(&map);
302 map_remove(&map, devnum);
303 map_unlock(&map);
304 }
305 return 0;
306 }
307
308 int Manage_resize(char *devname, int fd, long long size, int raid_disks)
309 {
310 mdu_array_info_t info;
311 if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
312 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
313 devname, strerror(errno));
314 return 1;
315 }
316 if (size >= 0)
317 info.size = size;
318 if (raid_disks > 0)
319 info.raid_disks = raid_disks;
320 if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
321 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
322 devname, strerror(errno));
323 return 1;
324 }
325 return 0;
326 }
327
328 int Manage_subdevs(char *devname, int fd,
329 mddev_dev_t devlist, int verbose, int test)
330 {
331 /* do something to each dev.
332 * devmode can be
333 * 'a' - add the device
334 * try HOT_ADD_DISK
335 * If that fails EINVAL, try ADD_NEW_DISK
336 * 'r' - remove the device HOT_REMOVE_DISK
337 * device can be 'faulty' or 'detached' in which case all
338 * matching devices are removed.
339 * 'f' - set the device faulty SET_DISK_FAULTY
340 * device can be 'detached' in which case any device that
341 * is inaccessible will be marked faulty.
342 * For 'f' and 'r', the device can also be a kernel-internal
343 * name such as 'sdb'.
344 */
345 mddev_dev_t add_devlist = NULL;
346 mdu_array_info_t array;
347 mdu_disk_info_t disc;
348 unsigned long long array_size;
349 mddev_dev_t dv, next = NULL;
350 struct stat stb;
351 int j, jnext = 0;
352 int tfd;
353 struct supertype *st, *tst;
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);
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
389 next = dv->next;
390 jnext = 0;
391
392 if (strcmp(dv->devname, "failed")==0 ||
393 strcmp(dv->devname, "faulty")==0) {
394 if (dv->disposition != 'r') {
395 fprintf(stderr, Name ": %s only meaningful "
396 "with -r, not -%c\n",
397 dv->devname, dv->disposition);
398 return 1;
399 }
400 for (; j < array.raid_disks + array.nr_disks ; j++) {
401 int dev;
402 disc.number = j;
403 if (ioctl(fd, GET_DISK_INFO, &disc))
404 continue;
405 if (disc.major == 0 && disc.minor == 0)
406 continue;
407 if ((disc.state & 1) == 0) /* faulty */
408 continue;
409 dev = makedev(disc.major, disc.minor);
410 if (stb.st_rdev == dev)
411 /* already did that one */
412 continue;
413 stb.st_rdev = dev;
414 next = dv;
415 /* same slot again next time - things might
416 * have reshuffled */
417 jnext = j;
418 sprintf(dvname,"%d:%d", disc.major, disc.minor);
419 dnprintable = dvname;
420 break;
421 }
422 if (jnext == 0)
423 continue;
424 } else if (strcmp(dv->devname, "detached") == 0) {
425 if (dv->disposition != 'r' && dv->disposition != 'f') {
426 fprintf(stderr, Name ": %s only meaningful "
427 "with -r of -f, not -%c\n",
428 dv->devname, dv->disposition);
429 return 1;
430 }
431 for (; j < array.raid_disks + array.nr_disks; j++) {
432 int sfd;
433 int dev;
434 disc.number = j;
435 if (ioctl(fd, GET_DISK_INFO, &disc))
436 continue;
437 if (disc.major == 0 && disc.minor == 0)
438 continue;
439 sprintf(dvname,"%d:%d", disc.major, disc.minor);
440 sfd = dev_open(dvname, O_RDONLY);
441 if (sfd >= 0) {
442 close(sfd);
443 continue;
444 }
445 if (dv->disposition == 'f' &&
446 (disc.state & 1) == 1) /* already faulty */
447 continue;
448 if (errno != ENXIO)
449 continue;
450 dev = makedev(disc.major, disc.minor);
451 if (stb.st_rdev == dev)
452 /* already did that one */
453 continue;
454 stb.st_rdev = dev;
455 next = dv;
456 /* same slot again next time - things might
457 * have reshuffled */
458 jnext = j;
459 dnprintable = dvname;
460 break;
461 }
462 if (jnext == 0)
463 continue;
464 } else if (strcmp(dv->devname, "missing") == 0) {
465 if (dv->disposition != 'a' || dv->re_add == 0) {
466 fprintf(stderr, Name ": 'missing' only meaningful "
467 "with --re-add\n");
468 return 1;
469 }
470 if (add_devlist == NULL)
471 add_devlist = conf_get_devs();
472 if (add_devlist == NULL) {
473 fprintf(stderr, Name ": no devices to scan for missing members.");
474 continue;
475 }
476 add_dev = add_devlist->devname;
477 add_devlist = add_devlist->next;
478 if (add_devlist != NULL)
479 next = dv;
480 if (stat(add_dev, &stb) < 0)
481 continue;
482 } else if (strchr(dv->devname, '/') == NULL &&
483 strlen(dv->devname) < 50) {
484 /* Assume this is a kernel-internal name like 'sda1' */
485 int found = 0;
486 char dname[55];
487 if (dv->disposition != 'r' && dv->disposition != 'f') {
488 fprintf(stderr, Name ": %s only meaningful "
489 "with -r of -f, not -%c\n",
490 dv->devname, dv->disposition);
491 return 1;
492 }
493
494 sprintf(dname, "dev-%s", dv->devname);
495 sysfd = sysfs_open(fd2devnum(fd), dname, "block/dev");
496 if (sysfd >= 0) {
497 char dn[20];
498 int mj,mn;
499 if (sysfs_fd_get_str(sysfd, dn, 20) > 0 &&
500 sscanf(dn, "%d:%d", &mj,&mn) == 2) {
501 stb.st_rdev = makedev(mj,mn);
502 found = 1;
503 }
504 close(sysfd);
505 sysfd = -1;
506 }
507 if (!found) {
508 sysfd = sysfs_open(fd2devnum(fd), dname, "state");
509 if (sysfd < 0) {
510 fprintf(stderr, Name ": %s does not appear "
511 "to be a component of %s\n",
512 dv->devname, devname);
513 return 1;
514 }
515 }
516 } else {
517 j = 0;
518
519 tfd = dev_open(dv->devname, O_RDONLY);
520 if (tfd < 0 && dv->disposition == 'r' &&
521 lstat(dv->devname, &stb) == 0)
522 /* Be happy, the lstat worked, that is
523 * enough for --remove
524 */
525 ;
526 else {
527 if (tfd < 0 || fstat(tfd, &stb) != 0) {
528 fprintf(stderr, Name ": cannot find %s: %s\n",
529 dv->devname, strerror(errno));
530 if (tfd >= 0)
531 close(tfd);
532 return 1;
533 }
534 close(tfd);
535 }
536 if ((stb.st_mode & S_IFMT) != S_IFBLK) {
537 fprintf(stderr, Name ": %s is not a "
538 "block device.\n",
539 dv->devname);
540 return 1;
541 }
542 }
543 switch(dv->disposition){
544 default:
545 fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
546 dv->devname, dv->disposition);
547 return 1;
548 case 'a':
549 /* add the device */
550 if (tst->subarray[0]) {
551 fprintf(stderr, Name ": Cannot add disks to a"
552 " \'member\' array, perform this"
553 " operation on the parent container\n");
554 return 1;
555 }
556 /* Make sure it isn't in use (in 2.6 or later) */
557 tfd = dev_open(add_dev, O_RDONLY|O_EXCL|O_DIRECT);
558 if (tfd < 0 && add_dev != dv->devname)
559 continue;
560 if (tfd < 0) {
561 fprintf(stderr, Name ": Cannot open %s: %s\n",
562 dv->devname, strerror(errno));
563 return 1;
564 }
565
566 st = dup_super(tst);
567
568 if (array.not_persistent==0)
569 st->ss->load_super(st, tfd, NULL);
570
571 if (add_dev == dv->devname) {
572 if (!get_dev_size(tfd, dv->devname, &ldsize)) {
573 close(tfd);
574 return 1;
575 }
576 } else if (!get_dev_size(tfd, NULL, &ldsize)) {
577 close(tfd);
578 continue;
579 }
580
581 if (!tst->ss->external &&
582 array.major_version == 0 &&
583 md_get_version(fd)%100 < 2) {
584 close(tfd);
585 if (ioctl(fd, HOT_ADD_DISK,
586 (unsigned long)stb.st_rdev)==0) {
587 if (verbose >= 0)
588 fprintf(stderr, Name ": hot added %s\n",
589 add_dev);
590 continue;
591 }
592
593 fprintf(stderr, Name ": hot add failed for %s: %s\n",
594 add_dev, strerror(errno));
595 return 1;
596 }
597
598 if (array.not_persistent == 0 || tst->ss->external) {
599
600 /* need to find a sample superblock to copy, and
601 * a spare slot to use.
602 * For 'external' array (well, container based),
603 * We can just load the metadata for the array.
604 */
605 if (tst->sb)
606 /* already loaded */;
607 else if (tst->ss->external) {
608 tst->ss->load_super(tst, fd, NULL);
609 } else for (j = 0; j < tst->max_devs; j++) {
610 char *dev;
611 int dfd;
612 disc.number = j;
613 if (ioctl(fd, GET_DISK_INFO, &disc))
614 continue;
615 if (disc.major==0 && disc.minor==0)
616 continue;
617 if ((disc.state & 4)==0) continue; /* sync */
618 /* Looks like a good device to try */
619 dev = map_dev(disc.major, disc.minor, 1);
620 if (!dev) continue;
621 dfd = dev_open(dev, O_RDONLY);
622 if (dfd < 0) continue;
623 if (tst->ss->load_super(tst, dfd,
624 NULL)) {
625 close(dfd);
626 continue;
627 }
628 close(dfd);
629 break;
630 }
631 /* FIXME this is a bad test to be using */
632 if (!tst->sb) {
633 close(tfd);
634 fprintf(stderr, Name ": cannot find valid superblock in this array - HELP\n");
635 return 1;
636 }
637
638 /* Make sure device is large enough */
639 if (tst->ss->avail_size(tst, ldsize/512) <
640 array_size) {
641 close(tfd);
642 if (add_dev != dv->devname)
643 continue;
644 fprintf(stderr, Name ": %s not large enough to join array\n",
645 dv->devname);
646 return 1;
647 }
648
649 /* Possibly this device was recently part of the array
650 * and was temporarily removed, and is now being re-added.
651 * If so, we can simply re-add it.
652 */
653 tst->ss->uuid_from_super(tst, duuid);
654
655 /* re-add doesn't work for version-1 superblocks
656 * before 2.6.18 :-(
657 */
658 if (array.major_version == 1 &&
659 get_linux_version() <= 2006018)
660 ;
661 else if (st->sb) {
662 st->ss->uuid_from_super(st, ouuid);
663 if (memcmp(duuid, ouuid, sizeof(ouuid))==0) {
664 /* looks close enough for now. Kernel
665 * will worry about whether a bitmap
666 * based reconstruction is possible.
667 */
668 struct mdinfo mdi;
669 st->ss->getinfo_super(st, &mdi);
670 disc.major = major(stb.st_rdev);
671 disc.minor = minor(stb.st_rdev);
672 disc.number = mdi.disk.number;
673 disc.raid_disk = mdi.disk.raid_disk;
674 disc.state = mdi.disk.state;
675 if (dv->writemostly == 1)
676 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
677 if (dv->writemostly == 2)
678 disc.state &= ~(1 << MD_DISK_WRITEMOSTLY);
679 remove_partitions(tfd);
680 close(tfd);
681 tfd = -1;
682 /* don't even try if disk is marked as faulty */
683 errno = 0;
684 if ((disc.state & 1) == 0 &&
685 ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
686 if (verbose >= 0)
687 fprintf(stderr, Name ": re-added %s\n", add_dev);
688 count++;
689 continue;
690 }
691 if (errno == ENOMEM || errno == EROFS) {
692 close(tfd);
693 fprintf(stderr, Name ": add new device failed for %s: %s\n",
694 add_dev, strerror(errno));
695 if (add_dev != dv->devname)
696 continue;
697 return 1;
698 }
699 /* fall back on normal-add */
700 }
701 }
702 if (add_dev != dv->devname) {
703 if (verbose > 0)
704 fprintf(stderr, Name
705 ": --re-add for %s to %s is not possible\n",
706 add_dev, devname);
707 if (tfd >= 0)
708 close(tfd);
709 continue;
710 }
711 if (dv->re_add) {
712 if (tfd >= 0)
713 close(tfd);
714 fprintf(stderr, Name
715 ": --re-add for %s to %s is not possible\n",
716 dv->devname, devname);
717 return 1;
718 }
719 } else {
720 /* non-persistent. Must ensure that new drive
721 * is at least array.size big.
722 */
723 if (ldsize/512 < array_size) {
724 fprintf(stderr, Name ": %s not large enough to join array\n",
725 dv->devname);
726 return 1;
727 }
728 }
729 /* committed to really trying this device now*/
730 if (tfd >= 0) {
731 remove_partitions(tfd);
732 close(tfd);
733 }
734 /* in 2.6.17 and earlier, version-1 superblocks won't
735 * use the number we write, but will choose a free number.
736 * we must choose the same free number, which requires
737 * starting at 'raid_disks' and counting up
738 */
739 for (j = array.raid_disks; j< tst->max_devs; j++) {
740 disc.number = j;
741 if (ioctl(fd, GET_DISK_INFO, &disc))
742 break;
743 if (disc.major==0 && disc.minor==0)
744 break;
745 if (disc.state & 8) /* removed */
746 break;
747 }
748 disc.major = major(stb.st_rdev);
749 disc.minor = minor(stb.st_rdev);
750 disc.number =j;
751 disc.state = 0;
752 if (array.not_persistent==0 || tst->ss->external) {
753 int dfd;
754 if (dv->writemostly == 1)
755 disc.state |= 1 << MD_DISK_WRITEMOSTLY;
756 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
757 if (tst->ss->add_to_super(tst, &disc, dfd,
758 dv->devname)) {
759 close(dfd);
760 return 1;
761 }
762 /* write_init_super will close 'dfd' */
763 if (tst->ss->external)
764 /* mdmon will write the metadata */
765 close(dfd);
766 else if (tst->ss->write_init_super(tst))
767 return 1;
768 } else if (dv->re_add) {
769 /* this had better be raid1.
770 * As we are "--re-add"ing we must find a spare slot
771 * to fill.
772 */
773 char *used = malloc(array.raid_disks);
774 memset(used, 0, array.raid_disks);
775 for (j=0; j< tst->max_devs; j++) {
776 mdu_disk_info_t disc2;
777 disc2.number = j;
778 if (ioctl(fd, GET_DISK_INFO, &disc2))
779 continue;
780 if (disc2.major==0 && disc2.minor==0)
781 continue;
782 if (disc2.state & 8) /* removed */
783 continue;
784 if (disc2.raid_disk < 0)
785 continue;
786 if (disc2.raid_disk > array.raid_disks)
787 continue;
788 used[disc2.raid_disk] = 1;
789 }
790 for (j=0 ; j<array.raid_disks; j++)
791 if (!used[j]) {
792 disc.raid_disk = j;
793 disc.state |= (1<<MD_DISK_SYNC);
794 break;
795 }
796 free(used);
797 }
798 if (dv->writemostly == 1)
799 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
800 if (tst->ss->external) {
801 /* add a disk to an external metadata container
802 * only if mdmon is around to see it
803 */
804 struct mdinfo new_mdi;
805 struct mdinfo *sra;
806 int container_fd;
807 int devnum = fd2devnum(fd);
808
809 container_fd = open_dev_excl(devnum);
810 if (container_fd < 0) {
811 fprintf(stderr, Name ": add failed for %s:"
812 " could not get exclusive access to container\n",
813 dv->devname);
814 return 1;
815 }
816
817 if (!mdmon_running(devnum)) {
818 fprintf(stderr, Name ": add failed for %s: mdmon not running\n",
819 dv->devname);
820 close(container_fd);
821 return 1;
822 }
823
824 sra = sysfs_read(container_fd, -1, 0);
825 if (!sra) {
826 fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
827 dv->devname);
828 close(container_fd);
829 return 1;
830 }
831 sra->array.level = LEVEL_CONTAINER;
832 /* Need to set data_offset and component_size */
833 tst->ss->getinfo_super(tst, &new_mdi);
834 new_mdi.disk.major = disc.major;
835 new_mdi.disk.minor = disc.minor;
836 new_mdi.recovery_start = 0;
837 if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
838 fprintf(stderr, Name ": add new device to external metadata"
839 " failed for %s\n", dv->devname);
840 close(container_fd);
841 return 1;
842 }
843 ping_monitor(devnum2devname(devnum));
844 sysfs_free(sra);
845 close(container_fd);
846 } else if (ioctl(fd, ADD_NEW_DISK, &disc)) {
847 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
848 dv->devname, j, strerror(errno));
849 return 1;
850 }
851 if (verbose >= 0)
852 fprintf(stderr, Name ": added %s\n", dv->devname);
853 break;
854
855 case 'r':
856 /* hot remove */
857 if (tst->subarray[0]) {
858 fprintf(stderr, Name ": Cannot remove disks from a"
859 " \'member\' array, perform this"
860 " operation on the parent container\n");
861 if (sysfd >= 0)
862 close(sysfd);
863 return 1;
864 }
865 if (tst->ss->external) {
866 /* To remove a device from a container, we must
867 * check that it isn't in use in an array.
868 * This involves looking in the 'holders'
869 * directory - there must be just one entry,
870 * the container.
871 * To ensure that it doesn't get used as a
872 * hold spare while we are checking, we
873 * get an O_EXCL open on the container
874 */
875 int dnum = fd2devnum(fd);
876 lfd = open_dev_excl(dnum);
877 if (lfd < 0) {
878 fprintf(stderr, Name
879 ": Cannot get exclusive access "
880 " to container - odd\n");
881 if (sysfd >= 0)
882 close(sysfd);
883 return 1;
884 }
885 /* in the detached case it is not possible to
886 * check if we are the unique holder, so just
887 * rely on the 'detached' checks
888 */
889 if (strcmp(dv->devname, "detached") == 0 ||
890 sysfd >= 0 ||
891 sysfs_unique_holder(dnum, stb.st_rdev))
892 /* pass */;
893 else {
894 fprintf(stderr, Name
895 ": %s is %s, cannot remove.\n",
896 dnprintable,
897 errno == EEXIST ? "still in use":
898 "not a member");
899 close(lfd);
900 return 1;
901 }
902 }
903 /* FIXME check that it is a current member */
904 if (sysfd >= 0) {
905 /* device has been removed and we don't know
906 * the major:minor number
907 */
908 int n = write(sysfd, "remove", 6);
909 if (n != 6)
910 err = -1;
911 else
912 err = 0;
913 close(sysfd);
914 sysfd = -1;
915 } else {
916 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
917 if (err && errno == ENODEV) {
918 /* Old kernels rejected this if no personality
919 * registered */
920 struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
921 struct mdinfo *dv = NULL;
922 if (sra)
923 dv = sra->devs;
924 for ( ; dv ; dv=dv->next)
925 if (dv->disk.major == major(stb.st_rdev) &&
926 dv->disk.minor == minor(stb.st_rdev))
927 break;
928 if (dv)
929 err = sysfs_set_str(sra, dv,
930 "state", "remove");
931 else
932 err = -1;
933 if (sra)
934 sysfs_free(sra);
935 }
936 }
937 if (err) {
938 fprintf(stderr, Name ": hot remove failed "
939 "for %s: %s\n", dnprintable,
940 strerror(errno));
941 if (lfd >= 0)
942 close(lfd);
943 return 1;
944 }
945 if (tst->ss->external) {
946 /*
947 * Before dropping our exclusive open we make an
948 * attempt at preventing mdmon from seeing an
949 * 'add' event before reconciling this 'remove'
950 * event.
951 */
952 char *name = devnum2devname(fd2devnum(fd));
953
954 if (!name) {
955 fprintf(stderr, Name ": unable to get container name\n");
956 return 1;
957 }
958
959 ping_manager(name);
960 free(name);
961 }
962 if (lfd >= 0)
963 close(lfd);
964 count++;
965 if (verbose >= 0)
966 fprintf(stderr, Name ": hot removed %s from %s\n",
967 dnprintable, devname);
968 break;
969
970 case 'f': /* set faulty */
971 /* FIXME check current member */
972 if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
973 (sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
974 (unsigned long) stb.st_rdev))) {
975 fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
976 dnprintable, strerror(errno));
977 if (sysfd >= 0)
978 close(sysfd);
979 return 1;
980 }
981 if (sysfd >= 0)
982 close(sysfd);
983 sysfd = -1;
984 count++;
985 if (verbose >= 0)
986 fprintf(stderr, Name ": set %s faulty in %s\n",
987 dnprintable, devname);
988 break;
989 }
990 }
991 if (test && count == 0)
992 return 2;
993 return 0;
994 }
995
996 int autodetect(void)
997 {
998 /* Open any md device, and issue the RAID_AUTORUN ioctl */
999 int rv = 1;
1000 int fd = dev_open("9:0", O_RDONLY);
1001 if (fd >= 0) {
1002 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
1003 rv = 0;
1004 close(fd);
1005 }
1006 return rv;
1007 }
1008
1009 int Update_subarray(char *dev, char *subarray, char *update, mddev_ident_t ident, int quiet)
1010 {
1011 struct supertype supertype, *st = &supertype;
1012 int fd, rv = 2;
1013
1014 memset(st, 0, sizeof(*st));
1015 if (snprintf(st->subarray, sizeof(st->subarray), "%s", subarray) >=
1016 sizeof(st->subarray)) {
1017 if (!quiet)
1018 fprintf(stderr,
1019 Name ": Input overflow for subarray '%s' > %zu bytes\n",
1020 subarray, sizeof(st->subarray) - 1);
1021 return 2;
1022 }
1023
1024 fd = open_subarray(dev, st, quiet);
1025 if (fd < 0)
1026 return 2;
1027
1028 if (!st->ss->update_subarray) {
1029 if (!quiet)
1030 fprintf(stderr,
1031 Name ": Operation not supported for %s metadata\n",
1032 st->ss->name);
1033 goto free_super;
1034 }
1035
1036 if (mdmon_running(st->devnum))
1037 st->update_tail = &st->updates;
1038
1039 rv = st->ss->update_subarray(st, update, ident);
1040
1041 if (rv) {
1042 if (!quiet)
1043 fprintf(stderr, Name ": Failed to update %s of subarray-%s in %s\n",
1044 update, subarray, dev);
1045 } else if (st->update_tail)
1046 flush_metadata_updates(st);
1047 else
1048 st->ss->sync_metadata(st);
1049
1050 if (rv == 0 && strcmp(update, "name") == 0 && !quiet)
1051 fprintf(stderr,
1052 Name ": Updated subarray-%s name from %s, UUIDs may have changed\n",
1053 subarray, dev);
1054
1055 free_super:
1056 st->ss->free_super(st);
1057 close(fd);
1058
1059 return rv;
1060 }
1061 #endif
Unnamed repository; edit this file 'description' to name the repository.