X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=Incremental.c;h=a8a072d438b209212b4b3299908c5e556944ac35;hb=c61c4dd01df75d3a56809db19ec827203505830b;hp=b1cee23fe0c94285047789ee3bb7c1bf3747d29e;hpb=a7c6e3fb24f8335005a6ff8e0eb668faa257c941;p=thirdparty%2Fmdadm.git

diff --git a/Incremental.c b/Incremental.c
index b1cee23f..a8a072d4 100644
--- a/Incremental.c
+++ b/Incremental.c
@@ -2,7 +2,7 @@
  * 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
@@ -37,7 +37,8 @@ static void find_reject(int mdfd, struct supertype *st, struct mdinfo *sra,
 			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.
@@ -211,16 +212,39 @@ int Incremental(char *devname, int verbose, int runstop,
 		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;
+	else if (st->ss->match_home(st, homehost) == 1)
+		trustworthy = LOCAL;
+	else if (st->ss->match_home(st, "any") == 1)
+		trustworthy = LOCAL_ANY;
 	else
+		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,
@@ -234,39 +258,49 @@ int Incremental(char *devname, int verbose, int runstop,
 		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 1;
+		}
+
 		/* 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 = strchr(info.name, ':');
-	if (name_to_use)
-		name_to_use++;
-	else
-		name_to_use = info.name;
 
-	if ((!name_to_use || name_to_use[0] == 0) &&
+	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) {
@@ -331,50 +365,82 @@ int Incremental(char *devname, int verbose, int runstop,
 		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 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 (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",
@@ -400,17 +466,20 @@ int Incremental(char *devname, int verbose, int runstop,
 				chosen_name, info.array.working_disks);
 		wait_for(chosen_name, mdfd);
 		close(mdfd);
-		if (runstop < 0)
-			return 0; /* don't try to assemble */
-		return Incremental(chosen_name, verbose, runstop,
-				   NULL, homehost, autof);
+		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 ||
-	    (runstop < 0 && active_disks < info.array.raid_disks)) {
+		   avail, active_disks) == 0) {
 		free(avail);
 		if (verbose >= 0)
 			fprintf(stderr, Name
@@ -546,6 +615,9 @@ static int count_active(struct supertype *st, int mdfd, char **availp,
 	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;
@@ -628,7 +700,7 @@ int IncrementalScan(int verbose)
 		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;
@@ -639,8 +711,8 @@ int IncrementalScan(int verbose)
 		}
 		/* 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) {
 			/*
@@ -674,11 +746,12 @@ int IncrementalScan(int verbose)
 				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;
 			}
 		}
@@ -722,23 +795,27 @@ int Incremental_container(struct supertype *st, char *devname, int verbose,
 	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) {
 			mdfd = open_dev(mp->devnum);
-			strcpy(chosen_name, mp->path);
+			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, '/');
@@ -776,6 +853,17 @@ int Incremental_container(struct supertype *st, char *devname, int verbose,
 				break;
 			}
 
+			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,
@@ -789,11 +877,51 @@ int Incremental_container(struct supertype *st, char *devname, int verbose,
 			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;
+}