X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=util.c;h=79d2b0fecdb58077143bca5f8d2f6b2604110b7d;hp=7b43ee2e54d16df5b502dcca575d943384ad5cd2;hb=86983cce34645efb2b270a737d573e01eeee96e5;hpb=598f0d58ac3544e25f90f2d34337e15764f4d877

diff --git a/util.c b/util.c
index 7b43ee2e..79d2b0fe 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,19 +19,18 @@
  *    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>
+#include	<signal.h>
 
 /*
  * following taken from linux/blkpg.h because they aren't
@@ -66,6 +65,73 @@ struct blkpg_partition {
 	char volname[BLKPG_VOLNAMELTH];	/* volume label */
 };
 
+/* partition table structures so we can check metadata position
+ * against the end of the last partition.
+ * Only handle MBR ant GPT partition tables.
+ */
+struct MBR_part_record {
+  __u8 bootable;
+  __u8 first_head;
+  __u8 first_sector;
+  __u8 first_cyl;
+  __u8 part_type;
+  __u8 last_head;
+  __u8 last_sector;
+  __u8 last_cyl;
+  __u32 first_sect_lba;
+  __u32 blocks_num;
+};
+
+struct MBR {
+	__u8 pad[446];
+	struct MBR_part_record parts[4];
+	__u16 magic;
+} __attribute__((packed));
+
+struct GPT_part_entry {
+  unsigned char type_guid[16];
+  unsigned char partition_guid[16];
+  __u64 starting_lba;
+  __u64 ending_lba;
+  unsigned char attr_bits[8];
+  unsigned char name[72];
+} __attribute__((packed));
+
+struct GPT {
+	__u64 magic;
+	__u32 revision;
+	__u32 header_size;
+	__u32 crc;
+	__u32 pad1;
+	__u64 current_lba;
+	__u64 backup_lba;
+	__u64 first_lba;
+	__u64 last_lba;
+	__u8 guid[16];
+	__u64 part_start;
+	__u32 part_cnt;
+	__u32 part_size;
+	__u32 part_crc;
+	__u8 pad2[420];
+} __attribute__((packed));
+
+/* 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); }))
+
+
+/* MBR/GPT magic numbers */
+#define	MBR_SIGNATURE_MAGIC	__cpu_to_le16(0xAA55)
+#define	GPT_SIGNATURE_MAGIC	__cpu_to_le64(0x5452415020494645ULL)
+
+#define MBR_PARTITIONS               4
+#define MBR_GPT_PARTITION_TYPE       0xEE
+
 /*
  * Parse a 128 bit uuid in 4 integers
  * format is 32 hexx nibbles with options :.<space> separator
@@ -150,6 +216,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.
@@ -195,9 +328,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:
@@ -218,8 +351,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
@@ -265,6 +403,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)
 {
@@ -402,7 +570,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)
@@ -437,8 +605,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;
 	}
 
@@ -479,14 +649,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)
@@ -513,27 +682,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)
@@ -610,6 +779,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,
@@ -629,7 +815,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;
@@ -658,8 +843,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 */
@@ -714,26 +898,11 @@ void put_md_name(char *name)
 		unlink(name);
 }
 
-static int dev2major(int d)
-{
-	if (d >= 0)
-		return MD_MAJOR;
-	else
-		return get_mdp_major();
-}
-
-static int dev2minor(int d)
-{
-	if (d >= 0)
-		return d;
-	return (-1-d) << MdpMinorShift;
-}
-
 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;
 
@@ -770,19 +939,81 @@ int dev_open(char *dev, int flags)
 	if (e > dev && *e == ':' && e[1] &&
 	    (minor = strtoul(e+1, &e, 0)) >= 0 &&
 	    *e == 0) {
-		snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d", major, minor);
+		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);
+			fd = open(devname, flags|O_DIRECT);
 			unlink(devname);
 		}
 	} else
-		fd = open(dev, flags);
+		fd = open(dev, flags|O_DIRECT);
 	return fd;
 }
 
-struct superswitch *superlist[] = { &super0, &super1, &super_ddf, NULL };
+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];
+	int i;
+
+	sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
+	for (i=0 ; i<25 ; i++) {
+		int fd = dev_open(buf, O_RDWR|O_EXCL);
+		if (fd >= 0)
+			return fd;
+		if (errno != EBUSY)
+			return fd;
+		usleep(200000);
+	}
+	return -1;
+}
+
+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, NULL };
 
 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
+
 struct supertype *super_by_fd(int fd)
 {
 	mdu_array_info_t array;
@@ -793,6 +1024,7 @@ struct supertype *super_by_fd(int fd)
 	char *verstr;
 	char version[20];
 	int i;
+	char *subarray = NULL;
 
 	sra = sysfs_read(fd, 0, GET_VERSION);
 
@@ -812,42 +1044,59 @@ struct supertype *super_by_fd(int fd)
 		sprintf(version, "%d.%d", vers, minor);
 		verstr = version;
 	}
+	if (minor == -2 && is_subarray(verstr)) {
+		char *dev = verstr+1;
+		subarray = strchr(dev, '/');
+		int devnum;
+		if (subarray)
+			*subarray++ = '\0';
+		devnum = devname2devnum(dev);
+		subarray = strdup(subarray);
+		if (sra)
+			sysfs_free(sra);
+		sra = sysfs_read(-1, devnum, GET_VERSION);
+		if (sra && sra->text_version[0])
+			verstr = sra->text_version;
+		else
+			verstr = "-no-metadata-";
+	}
+
 	for (i = 0; st == NULL && superlist[i] ; i++)
 		st = superlist[i]->match_metadata_desc(verstr);
 
 	if (sra)
 		sysfs_free(sra);
-	if (st)
+	if (st) {
 		st->sb = NULL;
+		if (subarray) {
+			strncpy(st->subarray, subarray, 32);
+			st->subarray[31] = 0;
+			free(subarray);
+		} else
+			st->subarray[0] = 0;
+	}
 	return st;
 }
 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
 
 
-struct supertype *dup_super(struct supertype *st)
+struct supertype *dup_super(struct supertype *orig)
 {
-	struct supertype *stnew = NULL;
-	char *verstr = NULL;
-	char version[20];
-	int i;
+	struct supertype *st;
 
+	if (!orig)
+		return orig;
+	st = malloc(sizeof(*st));
 	if (!st)
 		return st;
-
-	if (st->ss->text_version)
-		strcpy(version, st->ss->text_version);
-	else if (st->minor_version == -1)
-		sprintf(version, "%d", st->ss->major);
-	else
-		sprintf(version, "%d.%d", st->ss->major, st->minor_version);
-	verstr = version;
-
-	for (i = 0; stnew == NULL && superlist[i] ; i++)
-		stnew = superlist[i]->match_metadata_desc(verstr);
-
-	if (stnew)
-		stnew->sb = NULL;
-	return stnew;
+	memset(st, 0, sizeof(*st));
+	st->ss = orig->ss;
+	st->max_devs = orig->max_devs;
+	st->minor_version = orig->minor_version;
+	strcpy(st->subarray, orig->subarray);
+	st->sb = NULL;
+	st->info = NULL;
+	return st;
 }
 
 struct supertype *guess_super(int fd)
@@ -862,11 +1111,10 @@ struct supertype *guess_super(int fd)
 	int i;
 
 	st = malloc(sizeof(*st));
-	memset(st, 0, sizeof(*st));
 	for (i=0 ; superlist[i]; i++) {
 		int rv;
 		ss = superlist[i];
-		st->ss = NULL;
+		memset(st, 0, sizeof(*st));
 		rv = ss->load_super(st, fd, NULL);
 		if (rv == 0) {
 			struct mdinfo info;
@@ -881,7 +1129,7 @@ struct supertype *guess_super(int fd)
 	}
 	if (bestsuper != -1) {
 		int rv;
-		st->ss = NULL;
+		memset(st, 0, sizeof(*st));
 		rv = superlist[bestsuper]->load_super(st, fd, NULL);
 		if (rv == 0) {
 			superlist[bestsuper]->free_super(st);
@@ -920,6 +1168,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;
+	int 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;
+	int 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;
@@ -975,9 +1363,288 @@ int open_container(int fd)
 			return dfd;
 		}
 	}
+	closedir(dir);
 	return -1;
 }
 
+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)
+		sprintf(name, "md%d", num);
+	else
+		sprintf(name, "md_d%d", -1-num);
+	return strdup(name);
+}
+
+int devname2devnum(char *name)
+{
+	char *ep;
+	int num;
+	if (strncmp(name, "md_d", 4)==0)
+		num = -1-strtoul(name+4, &ep, 10);
+	else
+		num = strtoul(name+2, &ep, 10);
+	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) == 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)
+		return stat2devnum(&stb);
+	return NoMdDev;
+}
+
+char *pid_dir = VAR_RUN;
+
+int mdmon_pid(int devnum)
+{
+	char path[100];
+	char pid[10];
+	int fd;
+	int n;
+	sprintf(path, "%s/%s.pid", pid_dir, devnum2devname(devnum));
+	fd = open(path, O_RDONLY | O_NOATIME, 0);
+
+	if (fd < 0)
+		return -1;
+	n = read(fd, pid, 9);
+	close(fd);
+	if (n <= 0)
+		return -1;
+	return atoi(pid);
+}
+
+int mdmon_running(int devnum)
+{
+	int pid = mdmon_pid(devnum);
+	if (pid <= 0)
+		return 0;
+	if (kill(pid, 0) == 0)
+		return 1;
+	return 0;
+}
+
+int start_mdmon(int devnum)
+{
+	int i;
+	int len;
+	pid_t pid;	
+	int status;
+	char pathbuf[1024];
+	char *paths[4] = {
+		pathbuf,
+		"/sbin/mdmon",
+		"mdmon",
+		NULL
+	};
+
+	if (check_env("MDADM_NO_MDMON"))
+		return 0;
+
+	len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf));
+	if (len > 0) {
+		char *sl;
+		pathbuf[len] = 0;
+		sl = strrchr(pathbuf, '/');
+		if (sl)
+			sl++;
+		else
+			sl = pathbuf;
+		strcpy(sl, "mdmon");
+	} else
+		pathbuf[0] = '\0';
+
+	switch(fork()) {
+	case 0:
+		/* FIXME yuk. CLOSE_EXEC?? */
+		for (i=3; i < 100; i++)
+			close(i);
+		for (i=0; paths[i]; i++)
+			if (paths[i][0])
+				execl(paths[i], "mdmon",
+				      devnum2devname(devnum),
+				      NULL);
+		exit(1);
+	case -1: fprintf(stderr, Name ": cannot run mdmon. "
+			 "Array remains readonly\n");
+		return -1;
+	default: /* parent - good */
+		pid = wait(&status);
+		if (pid < 0 || status != 0)
+			return -1;
+	}
+	return 0;
+}
+
+int check_env(char *name)
+{
+	char *val = getenv(name);
+
+	if (val && atoi(val) == 1)
+		return 1;
+
+	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;
+	if (!st->updates) {
+		st->update_tail = NULL;
+		return -1;
+	}
+
+	sfd = connect_monitor(devnum2devname(st->container_dev));
+	if (sfd < 0)
+		return -1;
+
+	while (st->updates) {
+		struct metadata_update *mu = st->updates;
+		st->updates = mu->next;
+
+		send_message(sfd, mu, 0);
+		wait_reply(sfd, 0);
+		free(mu->buf);
+		free(mu);
+	}
+	ack(sfd, 0);
+	wait_reply(sfd, 0);
+	close(sfd);
+	st->update_tail = NULL;
+	return 0;
+}
+
+void append_metadata_update(struct supertype *st, void *buf, int len)
+{
+
+	struct metadata_update *mu = malloc(sizeof(*mu));
+
+	mu->buf = buf;
+	mu->len = len;
+	mu->space = NULL;
+	mu->next = NULL;
+	*st->update_tail = mu;
+	st->update_tail = &mu->next;
+}
+#endif /* MDASSEMBLE */
+
 #ifdef __TINYC__
 /* tinyc doesn't optimize this check in ioctl.h out ... */
 unsigned int __invalid_size_argument_for_IOC = 0;