* 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.
struct mddev_ident_s *array_list, *match;
char chosen_name[1024];
int rv;
- int devnum;
struct map_ent *mp, *map = NULL;
int dfd, mdfd;
char *avail;
int active_disks;
int trustworthy = FOREIGN;
char *name_to_use;
+ mdu_array_info_t ainf;
struct createinfo *ci = conf_get_create_info();
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;
+ }
+
+ if (!match && !conf_test_metadata(st->ss->name)) {
+ if (verbose >= 1)
+ fprintf(stderr, Name
+ ": %s has metadata type %s for which "
+ "auto-assembly is disabled\n",
+ devname, st->ss->name);
+ 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)
+ else if ((homehost == NULL ||
+ st->ss->match_home(st, homehost) != 1) &&
+ st->ss->match_home(st, "any") != 1)
trustworthy = FOREIGN;
- name_to_use = strchr(info.name, ':');
- if (name_to_use)
- name_to_use++;
else
- name_to_use = info.name;
+ trustworthy = LOCAL;
/* There are three possible sources for 'autof': command line,
* ARRAY line in mdadm.conf, or CREATE line in mdadm.conf.
return Incremental_container(st, devname, verbose, runstop,
autof, trustworthy);
}
- /* 4/ Check is array exists.
+
+ 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);
mp = map_by_uuid(&map, info.uuid);
if (mp)
- mdfd = open_mddev(mp->path, 0);
+ mdfd = open_dev(mp->devnum);
else
mdfd = -1;
struct mdinfo dinfo;
/* Couldn't find an existing array, maybe make a new one */
- mdfd = create_mddev(mp ? mp->path : match ? match->devname : NULL,
- info.name, autof, trustworthy, chosen_name);
-
+ mdfd = create_mddev(match ? match->devname : NULL,
+ name_to_use, autof, trustworthy, chosen_name);
if (mdfd < 0)
return 1;
close(mdfd);
return 2;
}
- sra = sysfs_read(mdfd, devnum, GET_DEVS);
+ sra = sysfs_read(mdfd, fd2devnum(mdfd), GET_DEVS);
if (!sra || !sra->devs || sra->devs->disk.raid_disk >= 0) {
/* It really should be 'none' - must be old buggy
* kernel, and mdadm -I may not be able to complete.
}
info.array.working_disks = 1;
sysfs_free(sra);
+ /* 6/ Make sure /var/run/mdadm.map contains this array. */
+ map_update(&map, fd2devnum(mdfd),
+ info.text_version,
+ info.uuid, chosen_name);
} else {
/* 5b/ if it does */
/* - check one drive in array to make sure metadata is a reasonably */
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));
- sra = sysfs_read(mdfd, devnum, (GET_DEVS | GET_STATE));
+ sra = sysfs_read(mdfd, fd2devnum(mdfd), (GET_DEVS | GET_STATE));
- 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",
info.array.working_disks ++;
}
- /* 6/ Make sure /var/run/mdadm.map contains this array. */
- map_update(&map, fd2devnum(mdfd),
- info.text_version,
- info.uuid, chosen_name);
/* 7/ Is there enough devices to possibly start the array? */
/* 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);
- return Incremental(chosen_name, verbose, runstop,
- NULL, homehost, autof);
+ wait_for(chosen_name, mdfd);
+ close(mdfd);
+ if (runstop < 0)
+ return 0; /* don't try to assemble */
+ 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);
if (enough(info.array.level, info.array.raid_disks,
info.array.layout, info.array.state & 1,
- avail, active_disks) == 0) {
+ avail, active_disks) == 0 ||
+ (runstop < 0 && active_disks < info.array.raid_disks)) {
free(avail);
if (verbose >= 0)
fprintf(stderr, Name
": %s attached to %s, not enough to start (%d).\n",
devname, chosen_name, active_disks);
+ map_unlock(&map);
close(mdfd);
return 0;
}
/* are enough, */
/* + add any bitmap file */
/* + start the array (auto-readonly). */
-{
- mdu_array_info_t ainf;
if (ioctl(mdfd, GET_ARRAY_INFO, &ainf) == 0) {
if (verbose >= 0)
fprintf(stderr, Name
": %s attached to %s which is already active.\n",
devname, chosen_name);
- close (mdfd);
+ close(mdfd);
+ map_unlock(&map);
return 0;
}
-}
+
+ map_unlock(&map);
if (runstop > 0 || active_disks >= info.array.working_disks) {
struct mdinfo *sra;
/* Let's try to start it */
}
close(bmfd);
}
- sra = sysfs_read(mdfd, devnum, 0);
+ sra = sysfs_read(mdfd, fd2devnum(mdfd), 0);
if ((sra == NULL || active_disks >= info.array.working_disks)
&& trustworthy != FOREIGN)
rv = ioctl(mdfd, RUN_ARRAY, NULL);
": %s attached to %s, which has been started.\n",
devname, chosen_name);
rv = 0;
+ wait_for(chosen_name, mdfd);
} else {
fprintf(stderr, Name
": %s attached to %s, but failed to start: %s.\n",
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 *list = st->ss->container_content(st);
struct mdinfo *ra;
+ struct map_ent *map = NULL;
+
+ map_lock(&map);
for (ra = list ; ra ; ra = ra->next) {
- struct mdinfo *dev, *sra;
int mdfd;
char chosen_name[1024];
- int working = 0, preexist = 0;
- struct map_ent *mp, *map = NULL;
+ struct map_ent *mp;
struct mddev_ident_s *match = NULL;
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;
}
-
- sysfs_init(ra, mdfd, 0);
-
- sra = sysfs_read(mdfd, 0, GET_VERSION);
- if (sra == NULL || strcmp(sra->text_version, ra->text_version) != 0)
- if (sysfs_set_array(ra, md_get_version(mdfd)) != 0)
- return 1;
- if (sra)
- sysfs_free(sra);
-
- for (dev = ra->devs; dev; dev = dev->next)
- if (sysfs_add_disk(ra, dev) == 0)
- working++;
- else if (errno == EEXIST)
- preexist++;
- if (working == 0)
- /* Nothing new, don't try to start */ ;
- else if (runstop > 0 ||
- (working + preexist) >= ra->array.working_disks) {
- switch(ra->array.level) {
- case LEVEL_LINEAR:
- case LEVEL_MULTIPATH:
- case 0:
- sysfs_set_str(ra, NULL, "array_state",
- "active");
- break;
- default:
- sysfs_set_str(ra, NULL, "array_state",
- "readonly");
- /* start mdmon if needed. */
- if (!mdmon_running(st->container_dev))
- start_mdmon(st->container_dev);
- ping_monitor(devnum2devname(st->container_dev));
- break;
- }
- sysfs_set_safemode(ra, ra->safe_mode_delay);
- if (verbose >= 0) {
- fprintf(stderr, Name
- ": Started %s with %d devices",
- chosen_name, working + preexist);
- if (preexist)
- fprintf(stderr, " (%d new)", working);
- fprintf(stderr, "\n");
- }
- /* FIXME should have an O_EXCL and wait for read-auto */
- } else
- if (verbose >= 0)
- fprintf(stderr, Name
- ": %s assembled with %d devices but "
- "not started\n",
- chosen_name, working);
- map_update(&map, fd2devnum(mdfd),
- ra->text_version,
- ra->uuid, chosen_name);
- close(mdfd);
+ assemble_container_content(st, mdfd, ra, runstop,
+ chosen_name, verbose);
}
+ map_unlock(&map);
return 0;
}
projects / thirdparty / mdadm.git / blobdiff