* Incremental.c - support --incremental. Part of:
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2006 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
char *array_name);
int Incremental(char *devname, int verbose, int runstop,
- struct supertype *st, char *homehost, int autof)
+ struct supertype *st, char *homehost, int require_homehost,
+ int autof)
{
/* Add this device to an array, creating the array if necessary
* and starting the array if sensible or - if runstop>0 - if possible.
match = array_list;
}
+ if (match && match->devname
+ && strcasecmp(match->devname, "<ignore>") == 0) {
+ if (verbose >= 0)
+ fprintf(stderr, Name ": array containing %s is explicitly"
+ " ignored by mdadm.conf\n",
+ devname);
+ return 1;
+ }
+
/* 3a/ if not, check for homehost match. If no match, continue
* but don't trust the 'name' in the array. Thus a 'random' minor
* number will be assigned, and the device name will be based
* on that. */
if (match)
trustworthy = LOCAL;
- else if (homehost == NULL ||
- st->ss->match_home(st, homehost) != 1)
- trustworthy = FOREIGN;
- name_to_use = strchr(info.name, ':');
- if (name_to_use)
- name_to_use++;
+ else if (st->ss->match_home(st, homehost) == 1)
+ trustworthy = LOCAL;
+ else if (st->ss->match_home(st, "any") == 1)
+ trustworthy = LOCAL_ANY;
else
- name_to_use = info.name;
+ trustworthy = FOREIGN;
+
+
+ if (!match && !conf_test_metadata(st->ss->name,
+ (trustworthy == LOCAL))) {
+ if (verbose >= 1)
+ fprintf(stderr, Name
+ ": %s has metadata type %s for which "
+ "auto-assembly is disabled\n",
+ devname, st->ss->name);
+ return 1;
+ }
+ if (trustworthy == LOCAL_ANY)
+ trustworthy = LOCAL;
/* There are three possible sources for 'autof': command line,
* ARRAY line in mdadm.conf, or CREATE line in mdadm.conf.
autof = ci->autof;
if (st->ss->container_content && st->loaded_container) {
+ if ((runstop > 0 && info.container_enough >= 0) ||
+ info.container_enough > 0)
+ /* pass */;
+ else {
+ if (verbose)
+ fprintf(stderr, Name ": not enough devices to start the container\n");
+ return 0;
+ }
+
/* This is a pre-built container array, so we do something
* rather different.
*/
return Incremental_container(st, devname, verbose, runstop,
autof, trustworthy);
}
+
+ name_to_use = info.name;
+ if (name_to_use[0] == 0 &&
+ info.array.level == LEVEL_CONTAINER &&
+ trustworthy == LOCAL) {
+ name_to_use = info.text_version;
+ trustworthy = METADATA;
+ }
+ if (name_to_use[0] && trustworthy != LOCAL &&
+ ! require_homehost &&
+ conf_name_is_free(name_to_use))
+ trustworthy = LOCAL;
+
+ /* strip "hostname:" prefix from name if we have decided
+ * to treat it as LOCAL
+ */
+ if (trustworthy == LOCAL && strchr(name_to_use, ':') != NULL)
+ name_to_use = strchr(name_to_use, ':')+1;
+
/* 4/ Check if array exists.
*/
- map_lock(&map);
+ if (map_lock(&map))
+ fprintf(stderr, Name ": failed to get exclusive lock on "
+ "mapfile\n");
mp = map_by_uuid(&map, info.uuid);
- if (mp) {
- mdfd = open_mddev(mp->path, 0);
- if (mdfd < 0 && mddev_busy(mp->devnum)) {
- /* maybe udev hasn't created it yet. */
- char buf[50];
- sprintf(buf, "%d:%d", dev2major(mp->devnum),
- dev2minor(mp->devnum));
- mdfd = dev_open(buf, O_RDWR);
- }
- } else
+ if (mp)
+ mdfd = open_dev(mp->devnum);
+ else
mdfd = -1;
if (mdfd < 0) {
/* Couldn't find an existing array, maybe make a new one */
mdfd = create_mddev(match ? match->devname : NULL,
- info.name, autof, trustworthy, chosen_name);
-
+ name_to_use, autof, trustworthy, chosen_name);
if (mdfd < 0)
return 1;
struct supertype *st2;
struct mdinfo info2, *d;
- strcpy(chosen_name, mp->path);
-
+ if (mp->path)
+ strcpy(chosen_name, mp->path);
+ else
+ strcpy(chosen_name, devnum2devname(mp->devnum));
+
+ /* It is generally not OK to add non-spare drives to a
+ * running array as they are probably missing because
+ * they failed. However if runstop is 1, then the
+ * array was possibly started early and our best be is
+ * to add this anyway. It would probably be good to
+ * allow explicit policy statement about this.
+ */
+ if ((info.disk.state & (1<<MD_DISK_SYNC)) != 0
+ && runstop < 1) {
+ int active = 0;
+
+ if (st->ss->external) {
+ char *devname = devnum2devname(fd2devnum(mdfd));
+
+ active = devname && is_container_active(devname);
+ free(devname);
+ } else if (ioctl(mdfd, GET_ARRAY_INFO, &ainf) == 0)
+ active = 1;
+ if (active) {
+ fprintf(stderr, Name
+ ": not adding %s to active array (without --run) %s\n",
+ devname, chosen_name);
+ close(mdfd);
+ return 2;
+ }
+ }
sra = sysfs_read(mdfd, fd2devnum(mdfd), (GET_DEVS | GET_STATE));
+ if (!sra)
+ return 2;
- sprintf(dn, "%d:%d", sra->devs->disk.major,
- sra->devs->disk.minor);
- dfd2 = dev_open(dn, O_RDONLY);
- st2 = dup_super(st);
- if (st2->ss->load_super(st2, dfd2, NULL) ||
- st->ss->compare_super(st, st2) != 0) {
- fprintf(stderr, Name
- ": metadata mismatch between %s and "
- "chosen array %s\n",
- devname, chosen_name);
- close(mdfd);
+ if (sra->devs) {
+ sprintf(dn, "%d:%d", sra->devs->disk.major,
+ sra->devs->disk.minor);
+ dfd2 = dev_open(dn, O_RDONLY);
+ st2 = dup_super(st);
+ if (st2->ss->load_super(st2, dfd2, NULL) ||
+ st->ss->compare_super(st, st2) != 0) {
+ fprintf(stderr, Name
+ ": metadata mismatch between %s and "
+ "chosen array %s\n",
+ devname, chosen_name);
+ close(mdfd);
+ close(dfd2);
+ return 2;
+ }
close(dfd2);
- return 2;
- }
- close(dfd2);
- memset(&info2, 0, sizeof(info2));
- st2->ss->getinfo_super(st2, &info2);
- st2->ss->free_super(st2);
- if (info.array.level != info2.array.level ||
- memcmp(info.uuid, info2.uuid, 16) != 0 ||
- info.array.raid_disks != info2.array.raid_disks) {
- fprintf(stderr, Name
- ": unexpected difference between %s and %s.\n",
- chosen_name, devname);
- close(mdfd);
- return 2;
+ memset(&info2, 0, sizeof(info2));
+ st2->ss->getinfo_super(st2, &info2);
+ st2->ss->free_super(st2);
+ if (info.array.level != info2.array.level ||
+ memcmp(info.uuid, info2.uuid, 16) != 0 ||
+ info.array.raid_disks != info2.array.raid_disks) {
+ fprintf(stderr, Name
+ ": unexpected difference between %s and %s.\n",
+ chosen_name, devname);
+ close(mdfd);
+ return 2;
+ }
}
info2.disk.major = major(stb.st_rdev);
info2.disk.minor = minor(stb.st_rdev);
/* add disk needs to know about containers */
if (st->ss->external)
sra->array.level = LEVEL_CONTAINER;
- err = add_disk(mdfd, st2, sra, &info2);
+ err = add_disk(mdfd, st, sra, &info2);
if (err < 0 && errno == EBUSY) {
/* could be another device present with the same
* disk.number. Find and reject any such
*/
find_reject(mdfd, st, sra, info.disk.number,
info.events, verbose, chosen_name);
- err = add_disk(mdfd, st2, sra, &info2);
+ err = add_disk(mdfd, st, sra, &info2);
}
if (err < 0) {
fprintf(stderr, Name ": failed to add %s to %s: %s.\n",
/* 7a/ if not, finish with success. */
if (info.array.level == LEVEL_CONTAINER) {
/* Try to assemble within the container */
- close(mdfd);
map_unlock(&map);
sysfs_uevent(&info, "change");
if (verbose >= 0)
fprintf(stderr, Name
": container %s now has %d devices\n",
chosen_name, info.array.working_disks);
- wait_for(chosen_name);
- return Incremental(chosen_name, verbose, runstop,
- NULL, homehost, autof);
+ wait_for(chosen_name, mdfd);
+ close(mdfd);
+ rv = Incremental(chosen_name, verbose, runstop,
+ NULL, homehost, require_homehost, autof);
+ if (rv == 1)
+ /* Don't fail the whole -I if a subarray didn't
+ * have enough devices to start yet
+ */
+ rv = 0;
+ return rv;
}
avail = NULL;
active_disks = count_active(st, mdfd, &avail, &info);
": %s attached to %s, which has been started.\n",
devname, chosen_name);
rv = 0;
- wait_for(chosen_name);
+ wait_for(chosen_name, mdfd);
} else {
fprintf(stderr, Name
": %s attached to %s, but failed to start: %s.\n",
struct mdinfo *sra = sysfs_read(mdfd, -1, GET_DEVS | GET_STATE);
char *avail = NULL;
+ if (!sra)
+ return 0;
+
for (d = sra->devs ; d ; d = d->next) {
char dn[30];
int dfd;
return cnt + cnt1;
}
-void RebuildMap(void)
-{
- struct mdstat_ent *mdstat = mdstat_read(0, 0);
- struct mdstat_ent *md;
- struct map_ent *map = NULL;
- int mdp = get_mdp_major();
-
- for (md = mdstat ; md ; md = md->next) {
- struct mdinfo *sra = sysfs_read(-1, md->devnum, GET_DEVS);
- struct mdinfo *sd;
-
- for (sd = sra->devs ; sd ; sd = sd->next) {
- char dn[30];
- int dfd;
- int ok;
- struct supertype *st;
- char *path;
- struct mdinfo info;
-
- sprintf(dn, "%d:%d", sd->disk.major, sd->disk.minor);
- dfd = dev_open(dn, O_RDONLY);
- if (dfd < 0)
- continue;
- st = guess_super(dfd);
- if ( st == NULL)
- ok = -1;
- else
- ok = st->ss->load_super(st, dfd, NULL);
- close(dfd);
- if (ok != 0)
- continue;
- st->ss->getinfo_super(st, &info);
- if (md->devnum > 0)
- path = map_dev(MD_MAJOR, md->devnum, 0);
- else
- path = map_dev(mdp, (-1-md->devnum)<< 6, 0);
- map_add(&map, md->devnum,
- info.text_version,
- info.uuid, path ? : "/unknown");
- st->ss->free_super(st);
- break;
- }
- sysfs_free(sra);
- }
- map_write(map);
- map_free(map);
- for (md = mdstat ; md ; md = md->next) {
- struct mdinfo *sra = sysfs_read(-1, md->devnum, GET_VERSION);
- sysfs_uevent(sra, "change");
- sysfs_free(sra);
- }
-}
-
int IncrementalScan(int verbose)
{
/* look at every device listed in the 'map' file.
mdu_array_info_t array;
mdu_bitmap_file_t bmf;
struct mdinfo *sra;
- int mdfd = open_mddev(me->path, 0);
+ int mdfd = open_dev(me->devnum);
if (mdfd < 0)
continue;
}
/* Ok, we can try this one. Maybe it needs a bitmap */
for (mddev = devs ; mddev ; mddev = mddev->next)
- if (mddev->devname
- && strcmp(mddev->devname, me->path) == 0)
+ if (mddev->devname && me->path
+ && devname_matches(mddev->devname, me->path))
break;
if (mddev && mddev->bitmap_file) {
/*
if (verbose >= 0)
fprintf(stderr, Name
": started array %s\n",
- me->path);
+ me->path ?: devnum2devname(me->devnum));
} else {
fprintf(stderr, Name
": failed to start array %s: %s\n",
- me->path, strerror(errno));
+ me->path ?: devnum2devname(me->devnum),
+ strerror(errno));
rv = 1;
}
}
struct mdinfo *ra;
struct map_ent *map = NULL;
- map_lock(&map);
+ if (map_lock(&map))
+ fprintf(stderr, Name ": failed to get exclusive lock on "
+ "mapfile\n");
for (ra = list ; ra ; ra = ra->next) {
int mdfd;
char chosen_name[1024];
struct map_ent *mp;
struct mddev_ident_s *match = NULL;
- int err;
mp = map_by_uuid(&map, ra->uuid);
- if (!mp) {
+ if (mp) {
+ mdfd = open_dev(mp->devnum);
+ if (mp->path)
+ strcpy(chosen_name, mp->path);
+ else
+ strcpy(chosen_name, devnum2devname(mp->devnum));
+ } else {
- /* Check in mdadm.conf for devices == devname and
+ /* Check in mdadm.conf for container == devname and
* member == ra->text_version after second slash.
*/
char *sub = strchr(ra->text_version+1, '/');
array_list->member);
break;
}
- }
- mdfd = create_mddev(match ? match->devname : NULL,
- ra->name,
- autof,
- trustworthy,
- chosen_name);
+ if (match && match->devname &&
+ strcasecmp(match->devname, "<ignore>") == 0) {
+ if (verbose > 0)
+ fprintf(stderr, Name ": array %s/%s is "
+ "explicitly ignored by mdadm.conf\n",
+ match->container, match->member);
+ return 2;
+ }
+ if (match)
+ trustworthy = LOCAL;
+
+ mdfd = create_mddev(match ? match->devname : NULL,
+ ra->name,
+ autof,
+ trustworthy,
+ chosen_name);
+ }
if (mdfd < 0) {
fprintf(stderr, Name ": failed to open %s: %s.\n",
return 2;
}
- err = assemble_container_content(st, mdfd, ra, runstop,
- chosen_name, verbose);
- if (err)
- return err;
+ assemble_container_content(st, mdfd, ra, runstop,
+ chosen_name, verbose);
}
map_unlock(&map);
return 0;
}
+
+/*
+ * IncrementalRemove - Attempt to see if the passed in device belongs to any
+ * raid arrays, and if so first fail (if needed) and then remove the device.
+ *
+ * @devname - The device we want to remove
+ *
+ * Note: the device name must be a kernel name like "sda", so
+ * that we can find it in /proc/mdstat
+ */
+int IncrementalRemove(char *devname, int verbose)
+{
+ int mdfd;
+ int rv;
+ struct mdstat_ent *ent;
+ struct mddev_dev_s devlist;
+
+ if (strchr(devname, '/')) {
+ fprintf(stderr, Name ": incremental removal requires a "
+ "kernel device name, not a file: %s\n", devname);
+ return 1;
+ }
+ ent = mdstat_by_component(devname);
+ if (!ent) {
+ fprintf(stderr, Name ": %s does not appear to be a component "
+ "of any array\n", devname);
+ return 1;
+ }
+ mdfd = open_dev(ent->devnum);
+ if (mdfd < 0) {
+ fprintf(stderr, Name ": Cannot open array %s!!\n", ent->dev);
+ return 1;
+ }
+ memset(&devlist, 0, sizeof(devlist));
+ devlist.devname = devname;
+ devlist.disposition = 'f';
+ Manage_subdevs(ent->dev, mdfd, &devlist, verbose, 0);
+ devlist.disposition = 'r';
+ rv = Manage_subdevs(ent->dev, mdfd, &devlist, verbose, 0);
+ close(mdfd);
+ return rv;
+}