X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=util.c;h=c2169d68dfa77d4590c918267f12e194a19fb470;hp=fe46f3b02d9c20a58079e0f70f8b48d41308d1e5;hb=0592faeb5e693d4317fb85d5ab013697a21c301d;hpb=44d2e36556921e82a9fde02b554f799741c92531

diff --git a/util.c b/util.c
index fe46f3b0..c2169d68 100644
--- a/util.c
+++ b/util.c
@@ -1,7 +1,7 @@
 /*
  * mdadm - manage Linux "md" devices aka RAID arrays.
  *
- * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
  *
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -19,18 +19,14 @@
  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  *    Author: Neil Brown
- *    Email: <neilb@cse.unsw.edu.au>
- *    Paper: Neil Brown
- *           School of Computer Science and Engineering
- *           The University of New South Wales
- *           Sydney, 2052
- *           Australia
+ *    Email: <neilb@suse.de>
  */
 
 #include	"mdadm.h"
 #include	"md_p.h"
 #include	<sys/socket.h>
 #include	<sys/utsname.h>
+#include	<sys/wait.h>
 #include	<sys/un.h>
 #include	<ctype.h>
 #include	<dirent.h>
@@ -69,6 +65,17 @@ struct blkpg_partition {
 	char volname[BLKPG_VOLNAMELTH];	/* volume label */
 };
 
+#include "part.h"
+
+/* Force a compilation error if condition is true */
+#define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition))
+
+/* Force a compilation error if condition is true, but also produce a
+   result (of value 0 and type size_t), so the expression can be used
+   e.g. in a structure initializer (or where-ever else comma expressions
+   aren't permitted). */
+#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
+
 /*
  * Parse a 128 bit uuid in 4 integers
  * format is 32 hexx nibbles with options :.<space> separator
@@ -153,6 +160,73 @@ int get_linux_version()
 	return (a*1000000)+(b*1000)+c;
 }
 
+#ifndef MDASSEMBLE
+long long parse_size(char *size)
+{
+	/* parse 'size' which should be a number optionally
+	 * followed by 'K', 'M', or 'G'.
+	 * Without a suffix, K is assumed.
+	 * Number returned is in sectors (half-K)
+	 */
+	char *c;
+	long long s = strtoll(size, &c, 10);
+	if (s > 0) {
+		switch (*c) {
+		case 'K':
+			c++;
+		default:
+			s *= 2;
+			break;
+		case 'M':
+			c++;
+			s *= 1024 * 2;
+			break;
+		case 'G':
+			c++;
+			s *= 1024 * 1024 * 2;
+			break;
+		}
+	}
+	if (*c)
+		s = 0;
+	return s;
+}
+
+int parse_layout_10(char *layout)
+{
+	int copies, rv;
+	char *cp;
+	/* Parse the layout string for raid10 */
+	/* 'f', 'o' or 'n' followed by a number <= raid_disks */
+	if ((layout[0] !=  'n' && layout[0] != 'f' && layout[0] != 'o') ||
+	    (copies = strtoul(layout+1, &cp, 10)) < 1 ||
+	    copies > 200 ||
+	    *cp)
+		return -1;
+	if (layout[0] == 'n')
+		rv = 256 + copies;
+	else if (layout[0] == 'o')
+		rv = 0x10000 + (copies<<8) + 1;
+	else
+		rv = 1 + (copies<<8);
+	return rv;
+}
+
+int parse_layout_faulty(char *layout)
+{
+	/* Parse the layout string for 'faulty' */
+	int ln = strcspn(layout, "0123456789");
+	char *m = strdup(layout);
+	int mode;
+	m[ln] = 0;
+	mode = map_name(faultylayout, m);
+	if (mode == UnSet)
+		return -1;
+
+	return mode | (atoi(layout+ln)<< ModeShift);
+}
+#endif
+
 void remove_partitions(int fd)
 {
 	/* remove partitions from this block devices.
@@ -172,6 +246,31 @@ void remove_partitions(int fd)
 #endif
 }
 
+int test_partition(int fd)
+{
+	/* Check if fd is a whole-disk or a partition.
+	 * BLKPG will return EINVAL on a partition, and BLKPG_DEL_PARTITION
+	 * will return ENXIO on an invalid partition number.
+	 */
+	struct blkpg_ioctl_arg a;
+	struct blkpg_partition p;
+	a.op = BLKPG_DEL_PARTITION;
+	a.data = (void*)&p;
+	a.datalen = sizeof(p);
+	a.flags = 0;
+	memset(a.data, 0, a.datalen);
+	p.pno = 1<<30;
+	if (ioctl(fd, BLKPG, &a) == 0)
+		/* Very unlikely, but not a partition */
+		return 0;
+	if (errno == ENXIO)
+		/* not a partition */
+		return 0;
+
+	return 1;
+}
+
+
 int enough(int level, int raid_disks, int layout, int clean,
 	   char *avail, int avail_disks)
 {
@@ -198,9 +297,9 @@ int enough(int level, int raid_disks, int layout, int clean,
 		} while (first != 0);
 		return 1;
 
-	case -4:
+	case LEVEL_MULTIPATH:
 		return avail_disks>= 1;
-	case -1:
+	case LEVEL_LINEAR:
 	case 0:
 		return avail_disks == raid_disks;
 	case 1:
@@ -221,8 +320,13 @@ int enough(int level, int raid_disks, int layout, int clean,
 	}
 }
 
+const int uuid_match_any[4] = { ~0, ~0, ~0, ~0 };
 int same_uuid(int a[4], int b[4], int swapuuid)
 {
+	if (memcmp(a, uuid_match_any, sizeof(int[4])) == 0 ||
+	    memcmp(b, uuid_match_any, sizeof(int[4])) == 0)
+		return 1;
+
 	if (swapuuid) {
 		/* parse uuids are hostendian.
 		 * uuid's from some superblocks are big-ending
@@ -268,6 +372,36 @@ void copy_uuid(void *a, int b[4], int swapuuid)
 		memcpy(a, b, 16);
 }
 
+char *__fname_from_uuid(int id[4], int swap, char *buf, char sep)
+{
+	int i, j;
+	char uuid[16];
+	char *c = buf;
+	strcpy(c, "UUID-");
+	c += strlen(c);
+	copy_uuid(uuid, id, swap);
+	for (i = 0; i < 4; i++) {
+		if (i)
+			*c++ = sep;
+		for (j = 3; j >= 0; j--) {
+			sprintf(c,"%02x", (unsigned char) uuid[j+4*i]);
+			c+= 2;
+		}
+	}
+	return buf;
+
+}
+
+char *fname_from_uuid(struct supertype *st, struct mdinfo *info, char *buf, char sep)
+{
+	// dirty hack to work around an issue with super1 superblocks...
+	// super1 superblocks need swapuuid set in order for assembly to
+	// work, but can't have it set if we want this printout to match
+	// all the other uuid printouts in super1.c, so we force swapuuid
+	// to 1 to make our printout match the rest of super1
+	return __fname_from_uuid(info->uuid, (st->ss == &super1) ? 1 : st->ss->swapuuid, buf, sep);
+}
+
 #ifndef MDASSEMBLE
 int check_ext2(int fd, char *name)
 {
@@ -405,7 +539,7 @@ int is_standard(char *dev, int *nump)
 	if (strncmp(d, "/d",2)==0)
 		d += 2, type=1; /* /dev/md/dN{pM} */
 	else if (strncmp(d, "/md_d", 5)==0)
-		d += 5, type=1; /* /dev/md_dNpM */
+		d += 5, type=1; /* /dev/md_dN{pM} */
 	else if (strncmp(d, "/md", 3)==0)
 		d += 3, type=-1; /* /dev/mdN */
 	else if (d-dev > 3 && strncmp(d-2, "md/", 3)==0)
@@ -440,8 +574,10 @@ int devlist_ready = 0;
 int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
 {
 	struct stat st;
+
 	if (S_ISLNK(stb->st_mode)) {
-		stat(name, &st);
+		if (stat(name, &st) != 0)
+			return 0;
 		stb = &st;
 	}
 
@@ -482,14 +618,13 @@ int nftw(const char *path, int (*han)(const char *name, const struct stat *stb,
 /*
  * Find a block device with the right major/minor number.
  * If we find multiple names, choose the shortest.
- * If we find a non-standard name, it is probably there
- * deliberately so prefer it over a standard name.
+ * If we find a name in /dev/md/, we prefer that.
  * This applies only to names for MD devices.
  */
 char *map_dev(int major, int minor, int create)
 {
 	struct devmap *p;
-	char *std = NULL, *nonstd=NULL;
+	char *regular = NULL, *preferred=NULL;
 	int did_check = 0;
 
 	if (major == 0 && minor == 0)
@@ -516,27 +651,27 @@ char *map_dev(int major, int minor, int create)
 	for (p=devlist; p; p=p->next)
 		if (p->major == major &&
 		    p->minor == minor) {
-			if (is_standard(p->name, NULL)) {
-				if (std == NULL ||
-				    strlen(p->name) < strlen(std))
-					std = p->name;
+			if (strncmp(p->name, "/dev/md/",8) == 0) {
+				if (preferred == NULL ||
+				    strlen(p->name) < strlen(preferred))
+					preferred = p->name;
 			} else {
-				if (nonstd == NULL ||
-				    strlen(p->name) < strlen(nonstd))
-					nonstd = p->name;
+				if (regular == NULL ||
+				    strlen(p->name) < strlen(regular))
+					regular = p->name;
 			}
 		}
-	if (!std && !nonstd && !did_check) {
+	if (!regular && !preferred && !did_check) {
 		devlist_ready = 0;
 		goto retry;
 	}
-	if (create && !std && !nonstd) {
+	if (create && !regular && !preferred) {
 		static char buf[30];
 		snprintf(buf, sizeof(buf), "%d:%d", major, minor);
-		nonstd = buf;
+		regular = buf;
 	}
 
-	return nonstd ? nonstd : std;
+	return preferred ? preferred : regular;
 }
 
 unsigned long calc_csum(void *super, int bytes)
@@ -613,6 +748,23 @@ char *human_size_brief(long long bytes)
 			);
 	return buf;
 }
+
+void print_r10_layout(int layout)
+{
+	int near = layout & 255;
+	int far = (layout >> 8) & 255;
+	int offset = (layout&0x10000);
+	char *sep = "";
+
+	if (near != 1) {
+		printf("%s near=%d", sep, near);
+		sep = ",";
+	}
+	if (far != 1)
+		printf("%s %s=%d", sep, offset?"offset":"far", far);
+	if (near*far == 1)
+		printf("NO REDUNDANCY");
+}
 #endif
 
 unsigned long long calc_array_size(int level, int raid_disks, int layout,
@@ -632,7 +784,6 @@ unsigned long long calc_array_size(int level, int raid_disks, int layout,
 	return data_disks * devsize;
 }
 
-#if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 int get_mdp_major(void)
 {
 static int mdp_major = -1;
@@ -661,8 +812,7 @@ static int mdp_major = -1;
 	return mdp_major;
 }
 
-
-
+#if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 char *get_md_name(int dev)
 {
 	/* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
@@ -721,7 +871,7 @@ int find_free_devnum(int use_partitions)
 {
 	int devnum;
 	for (devnum = 127; devnum != 128;
-	     devnum = devnum ? devnum-1 : (1<<22)-1) {
+	     devnum = devnum ? devnum-1 : (1<<20)-1) {
 		char *dn;
 		int _devnum;
 
@@ -753,22 +903,44 @@ int dev_open(char *dev, int flags)
 	int minor;
 
 	if (!dev) return -1;
+	flags |= O_DIRECT;
 
 	major = strtoul(dev, &e, 0);
 	if (e > dev && *e == ':' && e[1] &&
 	    (minor = strtoul(e+1, &e, 0)) >= 0 &&
 	    *e == 0) {
-		snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d",
-			 (int)getpid(), major, minor);
-		if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) {
-			fd = open(devname, flags|O_DIRECT);
-			unlink(devname);
+		char *path = map_dev(major, minor, 0);
+		if (path)
+			fd = open(path, flags);
+		if (fd < 0) {
+			snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d",
+				 (int)getpid(), major, minor);
+			if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) {
+				fd = open(devname, flags);
+				unlink(devname);
+			}
+		}
+		if (fd < 0) {
+			snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d",
+				 (int)getpid(), major, minor);
+			if (mknod(devname, S_IFBLK|0600, makedev(major, minor))==0) {
+				fd = open(devname, flags);
+				unlink(devname);
+			}
 		}
 	} else
-		fd = open(dev, flags|O_DIRECT);
+		fd = open(dev, flags);
 	return fd;
 }
 
+int open_dev(int devnum)
+{
+	char buf[20];
+
+	sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
+	return dev_open(buf, O_RDWR);
+}
+
 int open_dev_excl(int devnum)
 {
 	char buf[20];
@@ -786,7 +958,47 @@ int open_dev_excl(int devnum)
 	return -1;
 }
 
-struct superswitch *superlist[] = { &super0, &super1, &super_ddf, &super_imsm, NULL };
+int same_dev(char *one, char *two)
+{
+	struct stat st1, st2;
+	if (stat(one, &st1) != 0)
+		return 0;
+	if (stat(two, &st2) != 0)
+		return 0;
+	if ((st1.st_mode & S_IFMT) != S_IFBLK)
+		return 0;
+	if ((st2.st_mode & S_IFMT) != S_IFBLK)
+		return 0;
+	return st1.st_rdev == st2.st_rdev;
+}
+
+void wait_for(char *dev, int fd)
+{
+	int i;
+	struct stat stb_want;
+
+	if (fstat(fd, &stb_want) != 0 ||
+	    (stb_want.st_mode & S_IFMT) != S_IFBLK)
+		return;
+
+	for (i=0 ; i<25 ; i++) {
+		struct stat stb;
+		if (stat(dev, &stb) == 0 &&
+		    (stb.st_mode & S_IFMT) == S_IFBLK &&
+		    (stb.st_rdev == stb_want.st_rdev))
+			return;
+		usleep(200000);
+	}
+	if (i == 25)
+		dprintf("%s: timeout waiting for %s\n", __func__, dev);
+}
+
+struct superswitch *superlist[] =
+{
+	&super0, &super1,
+	&super_ddf, &super_imsm,
+	&mbr, &gpt,
+	NULL };
 
 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 
@@ -820,7 +1032,7 @@ struct supertype *super_by_fd(int fd)
 		sprintf(version, "%d.%d", vers, minor);
 		verstr = version;
 	}
-	if (minor == -2 && verstr[0] == '/') {
+	if (minor == -2 && is_subarray(verstr)) {
 		char *dev = verstr+1;
 		subarray = strchr(dev, '/');
 		int devnum;
@@ -831,7 +1043,10 @@ struct supertype *super_by_fd(int fd)
 		if (sra)
 			sysfs_free(sra);
 		sra = sysfs_read(-1, devnum, GET_VERSION);
-		verstr = sra->text_version ? : "-no-metadata-";
+		if (sra && sra->text_version[0])
+			verstr = sra->text_version;
+		else
+			verstr = "-no-metadata-";
 	}
 
 	for (i = 0; st == NULL && superlist[i] ; i++)
@@ -879,7 +1094,7 @@ struct supertype *guess_super(int fd)
 	 */
 	struct superswitch  *ss;
 	struct supertype *st;
-	unsigned long besttime = 0;
+	time_t besttime = 0;
 	int bestsuper = -1;
 	int i;
 
@@ -941,6 +1156,146 @@ int get_dev_size(int fd, char *dname, unsigned long long *sizep)
 	return 1;
 }
 
+
+/* Sets endofpart parameter to the last block used by the last GPT partition on the device.
+ * Returns: 1 if successful
+ *         -1 for unknown partition type
+ *          0 for other errors
+ */
+static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
+{
+	struct GPT gpt;
+	unsigned char buf[512];
+	unsigned char empty_gpt_entry[16]= {0};
+	struct GPT_part_entry *part;
+	unsigned long long curr_part_end;
+	unsigned all_partitions, entry_size;
+	unsigned part_nr;
+
+	*endofpart = 0;
+
+	BUILD_BUG_ON(sizeof(gpt) != 512);
+	/* read GPT header */
+	lseek(fd, 512, SEEK_SET);
+	if (read(fd, &gpt, 512) != 512)
+		return 0;
+
+	/* get the number of partition entries and the entry size */
+	all_partitions = __le32_to_cpu(gpt.part_cnt);
+	entry_size = __le32_to_cpu(gpt.part_size);
+
+	/* Check GPT signature*/
+	if (gpt.magic != GPT_SIGNATURE_MAGIC)
+		return -1;
+
+	/* sanity checks */
+	if (all_partitions > 1024 ||
+	    entry_size > 512)
+		return -1;
+
+	/* read first GPT partition entries */
+	if (read(fd, buf, 512) != 512)
+		return 0;
+
+	part = (struct GPT_part_entry*)buf;
+
+	for (part_nr=0; part_nr < all_partitions; part_nr++) {
+		/* is this valid partition? */
+		if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
+			/* check the last lba for the current partition */
+			curr_part_end = __le64_to_cpu(part->ending_lba);
+			if (curr_part_end > *endofpart)
+				*endofpart = curr_part_end;
+		}
+
+		part = (struct GPT_part_entry*)((unsigned char*)part + entry_size);
+
+		if ((unsigned char *)part >= buf + 512) {
+			if (read(fd, buf, 512) != 512)
+				return 0;
+			part = (struct GPT_part_entry*)buf;
+		}
+	}
+	return 1;
+}
+
+/* Sets endofpart parameter to the last block used by the last partition on the device.
+ * Returns: 1 if successful
+ *         -1 for unknown partition type
+ *          0 for other errors
+ */
+static int get_last_partition_end(int fd, unsigned long long *endofpart)
+{
+	struct MBR boot_sect;
+	struct MBR_part_record *part;
+	unsigned long long curr_part_end;
+	unsigned part_nr;
+	int retval = 0;
+
+	*endofpart = 0;
+
+	BUILD_BUG_ON(sizeof(boot_sect) != 512);
+	/* read MBR */
+	lseek(fd, 0, 0);
+	if (read(fd, &boot_sect, 512) != 512)
+		goto abort;
+
+	/* check MBP signature */
+	if (boot_sect.magic == MBR_SIGNATURE_MAGIC) {
+		retval = 1;
+		/* found the correct signature */
+		part = boot_sect.parts;
+
+		for (part_nr=0; part_nr < MBR_PARTITIONS; part_nr++) {
+			/* check for GPT type */
+			if (part->part_type == MBR_GPT_PARTITION_TYPE) {
+				retval = get_gpt_last_partition_end(fd, endofpart);
+				break;
+			}
+			/* check the last used lba for the current partition  */
+			curr_part_end = __le32_to_cpu(part->first_sect_lba) +
+				__le32_to_cpu(part->blocks_num);
+			if (curr_part_end > *endofpart)
+				*endofpart = curr_part_end;
+
+			part++;
+		}
+	} else {
+		/* Unknown partition table */
+		retval = -1;
+	}
+ abort:
+	return retval;
+}
+
+int check_partitions(int fd, char *dname, unsigned long long freesize)
+{
+	/*
+	 * Check where the last partition ends
+	 */
+	unsigned long long endofpart;
+	int ret;
+
+	if ((ret = get_last_partition_end(fd, &endofpart)) > 0) {
+		/* There appears to be a partition table here */
+		if (freesize == 0) {
+			/* partitions will not be visible in new device */
+			fprintf(stderr,
+				Name ": partition table exists on %s but will be lost or\n"
+				"       meaningless after creating array\n",
+				dname);
+			return 1;
+		} else if (endofpart > freesize) {
+			/* last partition overlaps metadata */
+			fprintf(stderr,
+				Name ": metadata will over-write last partition on %s.\n",
+				dname);
+			return 1;
+		}
+	}
+	return 0;
+}
+
 void get_one_disk(int mdfd, mdu_array_info_t *ainf, mdu_disk_info_t *disk)
 {
 	int d;
@@ -984,7 +1339,7 @@ int open_container(int fd)
 			continue;
 		n = read(dfd, buf, sizeof(buf));
 		close(dfd);
-		if (n <= 0 || n >= sizeof(buf))
+		if (n <= 0 || (unsigned)n >= sizeof(buf))
 			continue;
 		buf[n] = 0;
 		if (sscanf(buf, "%d:%d", &major, &minor) != 2)
@@ -1000,10 +1355,222 @@ int open_container(int fd)
 	return -1;
 }
 
+struct superswitch *version_to_superswitch(char *vers)
+{
+	int i;
+
+	for (i = 0; superlist[i]; i++) {
+		struct superswitch *ss = superlist[i];
+
+		if (strcmp(vers, ss->name) == 0)
+			return ss;
+	}
+
+	return NULL;
+}
+
+int is_container_member(struct mdstat_ent *mdstat, char *container)
+{
+	if (mdstat->metadata_version == NULL ||
+	    strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
+	    !is_subarray(mdstat->metadata_version+9) ||
+	    strncmp(mdstat->metadata_version+10, container, strlen(container)) != 0 ||
+	    mdstat->metadata_version[10+strlen(container)] != '/')
+		return 0;
+
+	return 1;
+}
+
+int is_subarray_active(char *subarray, char *container)
+{
+	struct mdstat_ent *mdstat = mdstat_read(0, 0);
+	struct mdstat_ent *ent;
+
+	for (ent = mdstat; ent; ent = ent->next) {
+		if (is_container_member(ent, container)) {
+			char *inst = &ent->metadata_version[10+strlen(container)+1];
+
+			if (!subarray || strcmp(inst, subarray) == 0)
+				break;
+		}
+	}
+
+	free_mdstat(mdstat);
+
+	return ent != NULL;
+}
+
+int is_container_active(char *container)
+{
+	return is_subarray_active(NULL, container);
+}
+
+/* open_subarray - opens a subarray in a container
+ * @dev: container device name
+ * @st: supertype with only ->subarray set
+ * @quiet: block reporting errors flag
+ *
+ * On success returns an fd to a container and fills in *st
+ */
+int open_subarray(char *dev, struct supertype *st, int quiet)
+{
+	struct mdinfo *mdi;
+	int fd, err = 1;
+
+	fd = open(dev, O_RDWR|O_EXCL);
+	if (fd < 0) {
+		if (!quiet)
+			fprintf(stderr, Name ": Couldn't open %s, aborting\n",
+				dev);
+		return 2;
+	}
+
+	st->devnum = fd2devnum(fd);
+	if (st->devnum == NoMdDev) {
+		if (!quiet)
+			fprintf(stderr,
+				Name ": Failed to determine device number for %s\n",
+				dev);
+		goto close_fd;
+	}
+
+	mdi = sysfs_read(fd, st->devnum, GET_VERSION|GET_LEVEL);
+	if (!mdi) {
+		if (!quiet)
+			fprintf(stderr, Name ": Failed to read sysfs for %s\n",
+				dev);
+		goto close_fd;
+	}
+
+	if (mdi->array.level != UnSet) {
+		if (!quiet)
+			fprintf(stderr, Name ": %s is not a container\n", dev);
+		goto free_sysfs;
+	}
+
+	st->ss = version_to_superswitch(mdi->text_version);
+	if (!st->ss) {
+		if (!quiet)
+			fprintf(stderr,
+				Name ": Operation not supported for %s metadata\n",
+				mdi->text_version);
+		goto free_sysfs;
+	}
+
+	st->devname = devnum2devname(st->devnum);
+	if (!st->devname) {
+		if (!quiet)
+			fprintf(stderr, Name ": Failed to allocate device name\n");
+		goto free_sysfs;
+	}
+
+	if (st->ss->load_super(st, fd, NULL)) {
+		if (!quiet)
+			fprintf(stderr, Name ": Failed to find subarray-%s in %s\n",
+				st->subarray, dev);
+		goto free_name;
+	}
+
+	if (!st->loaded_container) {
+		if (!quiet)
+			fprintf(stderr, Name ": %s is not a container\n", dev);
+		goto free_super;
+	}
+
+	err = 0;
+
+ free_super:
+	if (err)
+		st->ss->free_super(st);
+ free_name:
+	if (err)
+		free(st->devname);
+ free_sysfs:
+	sysfs_free(mdi);
+ close_fd:
+	if (err)
+		close(fd);
+
+	if (err)
+		return -1;
+	else
+		return fd;
+}
+
+int add_disk(int mdfd, struct supertype *st,
+	     struct mdinfo *sra, struct mdinfo *info)
+{
+	/* Add a device to an array, in one of 2 ways. */
+	int rv;
+#ifndef MDASSEMBLE
+	if (st->ss->external) {
+		if (info->disk.state & (1<<MD_DISK_SYNC))
+			info->recovery_start = MaxSector;
+		else
+			info->recovery_start = 0;
+		rv = sysfs_add_disk(sra, info, 0);
+		if (! rv) {
+			struct mdinfo *sd2;
+			for (sd2 = sra->devs; sd2; sd2=sd2->next)
+				if (sd2 == info)
+					break;
+			if (sd2 == NULL) {
+				sd2 = malloc(sizeof(*sd2));
+				*sd2 = *info;
+				sd2->next = sra->devs;
+				sra->devs = sd2;
+			}
+		}
+	} else
+#endif
+		rv = ioctl(mdfd, ADD_NEW_DISK, &info->disk);
+	return rv;
+}
+
+int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info)
+{
+	/* Initialise kernel's knowledge of array.
+	 * This varies between externally managed arrays
+	 * and older kernels
+	 */
+	int vers = md_get_version(mdfd);
+	int rv;
+
+#ifndef MDASSEMBLE
+	if (st->ss->external)
+		rv = sysfs_set_array(info, vers);
+	else
+#endif
+		if ((vers % 100) >= 1) { /* can use different versions */
+		mdu_array_info_t inf;
+		memset(&inf, 0, sizeof(inf));
+		inf.major_version = info->array.major_version;
+		inf.minor_version = info->array.minor_version;
+		rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
+	} else
+		rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
+	return rv;
+}
+
+unsigned long long min_recovery_start(struct mdinfo *array)
+{
+	/* find the minimum recovery_start in an array for metadata
+	 * formats that only record per-array recovery progress instead
+	 * of per-device
+	 */
+	unsigned long long recovery_start = MaxSector;
+	struct mdinfo *d;
+
+	for (d = array->devs; d; d = d->next)
+		recovery_start = min(recovery_start, d->recovery_start);
+
+	return recovery_start;
+}
+
 char *devnum2devname(int num)
 {
 	char name[100];
-	if (num > 0)
+	if (num >= 0)
 		sprintf(name, "md%d", num);
 	else
 		sprintf(name, "md_d%d", -1-num);
@@ -1021,55 +1588,75 @@ int devname2devnum(char *name)
 	return num;
 }
 
+int stat2devnum(struct stat *st)
+{
+	char path[30];
+	char link[200];
+	char *cp;
+	int n;
+
+	if ((S_IFMT & st->st_mode) == S_IFBLK) {
+		if (major(st->st_rdev) == MD_MAJOR)
+			return minor(st->st_rdev);
+		else if (major(st->st_rdev) == (unsigned)get_mdp_major())
+			return -1- (minor(st->st_rdev)>>MdpMinorShift);
+
+		/* must be an extended-minor partition. Look at the
+		 * /sys/dev/block/%d:%d link which must look like
+		 * ../../block/mdXXX/mdXXXpYY
+		 */
+		sprintf(path, "/sys/dev/block/%d:%d", major(st->st_rdev),
+			minor(st->st_rdev));
+		n = readlink(path, link, sizeof(link)-1);
+		if (n <= 0)
+			return NoMdDev;
+		link[n] = 0;
+		cp = strrchr(link, '/');
+		if (cp) *cp = 0;
+		cp = strchr(link, '/');
+		if (cp && strncmp(cp, "/md", 3) == 0)
+			return devname2devnum(cp+1);
+	}
+	return NoMdDev;
+
+}
+
 int fd2devnum(int fd)
 {
 	struct stat stb;
-	if (fstat(fd, &stb) == 0 &&
-	    (S_IFMT&stb.st_mode)==S_IFBLK) {
-		if (major(stb.st_rdev) == MD_MAJOR)
-			return minor(stb.st_rdev);
-		else
-			return -1- (minor(stb.st_rdev)>>6);
-	}
-	return -1;
+	if (fstat(fd, &stb) == 0)
+		return stat2devnum(&stb);
+	return NoMdDev;
 }
 
-int mdmon_running(int devnum)
+int mdmon_pid(int devnum)
 {
 	char path[100];
 	char pid[10];
 	int fd;
 	int n;
-	sprintf(path, "/var/run/mdadm/%s.pid", devnum2devname(devnum));
-	fd = open(path, O_RDONLY, 0);
+	char *devname = devnum2devname(devnum);
+
+	sprintf(path, "%s/%s.pid", MDMON_DIR, devname);
+	free(devname);
+
+	fd = open(path, O_RDONLY | O_NOATIME, 0);
 
 	if (fd < 0)
-		return 0;
+		return -1;
 	n = read(fd, pid, 9);
 	close(fd);
 	if (n <= 0)
-		return 0;
-	if (kill(atoi(pid), 0) == 0)
-		return 1;
-	return 0;
+		return -1;
+	return atoi(pid);
 }
 
-int signal_mdmon(int devnum)
+int mdmon_running(int devnum)
 {
-	char path[100];
-	char pid[10];
-	int fd;
-	int n;
-	sprintf(path, "/var/run/mdadm/%s.pid", devnum2devname(devnum));
-	fd = open(path, O_RDONLY, 0);
-
-	if (fd < 0)
+	int pid = mdmon_pid(devnum);
+	if (pid <= 0)
 		return 0;
-	n = read(fd, pid, 9);
-	close(fd);
-	if (n <= 0)
-		return 0;
-	if (kill(atoi(pid), SIGUSR1) == 0)
+	if (kill(pid, 0) == 0)
 		return 1;
 	return 0;
 }
@@ -1078,6 +1665,8 @@ int start_mdmon(int devnum)
 {
 	int i;
 	int len;
+	pid_t pid;	
+	int status;
 	char pathbuf[1024];
 	char *paths[4] = {
 		pathbuf,
@@ -1086,7 +1675,7 @@ int start_mdmon(int devnum)
 		NULL
 	};
 
-	if (env_no_mdmon())
+	if (check_env("MDADM_NO_MDMON"))
 		return 0;
 
 	len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf));
@@ -1110,21 +1699,23 @@ int start_mdmon(int devnum)
 		for (i=0; paths[i]; i++)
 			if (paths[i][0])
 				execl(paths[i], "mdmon",
-				      map_dev(dev2major(devnum),
-					      dev2minor(devnum),
-					      1), NULL);
+				      devnum2devname(devnum),
+				      NULL);
 		exit(1);
 	case -1: fprintf(stderr, Name ": cannot run mdmon. "
 			 "Array remains readonly\n");
 		return -1;
-	default: ; /* parent - good */
+	default: /* parent - good */
+		pid = wait(&status);
+		if (pid < 0 || status != 0)
+			return -1;
 	}
 	return 0;
 }
 
-int env_no_mdmon(void)
+int check_env(char *name)
 {
-	char *val = getenv("MDADM_NO_MDMON");
+	char *val = getenv(name);
 
 	if (val && atoi(val) == 1)
 		return 1;
@@ -1132,7 +1723,18 @@ int env_no_mdmon(void)
 	return 0;
 }
 
+__u32 random32(void)
+{
+	__u32 rv;
+	int rfd = open("/dev/urandom", O_RDONLY);
+	if (rfd < 0 || read(rfd, &rv, 4) != 4)
+		rv = random();
+	if (rfd >= 0)
+		close(rfd);
+	return rv;
+}
 
+#ifndef MDASSEMBLE
 int flush_metadata_updates(struct supertype *st)
 {
 	int sfd;
@@ -1173,7 +1775,7 @@ void append_metadata_update(struct supertype *st, void *buf, int len)
 	*st->update_tail = mu;
 	st->update_tail = &mu->next;
 }
-
+#endif /* MDASSEMBLE */
 
 #ifdef __TINYC__
 /* tinyc doesn't optimize this check in ioctl.h out ... */