X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=super-ddf.c;h=8153924e16fd33d001f96dc91e3135b65e06fbdf;hp=5d38750489193302e6a4bcd0e56809ccdc29957b;hb=37424f132cb3874fe51021b1b5e04445a3ba1bdb;hpb=103f2410ec581620367d6fde67a3a62f077062a7

diff --git a/super-ddf.c b/super-ddf.c
index 5d387504..8153924e 100644
--- a/super-ddf.c
+++ b/super-ddf.c
@@ -1,7 +1,7 @@
 /*
  * mdadm - manage Linux "md" devices aka RAID arrays.
  *
- * Copyright (C) 2006-2007 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
@@ -423,11 +423,16 @@ struct ddf_super {
 				unsigned long long size; /* sectors */
 				int pdnum;	/* index in ->phys */
 				struct spare_assign *spare;
+				void *mdupdate; /* hold metadata update */
+
+				/* These fields used by auto-layout */
+				int raiddisk; /* slot to fill in autolayout */
+				__u64 esize;
 			};
 		};
 		struct disk_data disk;
 		struct vcl *vlist[0]; /* max_part in size */
-	} *dlist;
+	} *dlist, *add_list;
 };
 
 #ifndef offsetof
@@ -445,7 +450,10 @@ static int calc_crc(void *buf, int len)
 
 	newcrc = crc32(0, buf, len);
 	ddf->crc = oldcrc;
-	return newcrc;
+	/* The crc is store (like everything) bigendian, so convert
+	 * here for simplicity
+	 */
+	return __cpu_to_be32(newcrc);
 }
 
 static int load_ddf_header(int fd, unsigned long long lba,
@@ -503,9 +511,8 @@ static void *load_section(int fd, struct ddf_super *super, void *buf,
 		/* All pre-allocated sections are a single block */
 		if (len != 1)
 			return NULL;
-	} else {
-		posix_memalign(&buf, 512, len<<9);
-	}
+	} else if (posix_memalign(&buf, 512, len<<9) != 0)
+		buf = NULL;
 
 	if (!buf)
 		return NULL;
@@ -636,14 +643,19 @@ static int load_ddf_local(int fd, struct ddf_super *super,
 	struct stat stb;
 	char *conf;
 	int i;
+	int confsec;
 	int vnum;
 	int max_virt_disks = __be16_to_cpu(super->active->max_vd_entries);
 	unsigned long long dsize;
 
 	/* First the local disk info */
-	posix_memalign((void**)&dl, 512,
+	if (posix_memalign((void**)&dl, 512,
 		       sizeof(*dl) +
-		       (super->max_part) * sizeof(dl->vlist[0]));
+		       (super->max_part) * sizeof(dl->vlist[0])) != 0) {
+		fprintf(stderr, Name ": %s could not allocate disk info buffer\n",
+			__func__);
+		return 1;
+	}
 
 	load_section(fd, super, &dl->disk,
 		     super->active->data_section_offset,
@@ -682,18 +694,24 @@ static int load_ddf_local(int fd, struct ddf_super *super,
 			    0);
 
 	vnum = 0;
-	for (i = 0;
-	     i < __be32_to_cpu(super->active->config_section_length);
-	     i += super->conf_rec_len) {
+	for (confsec = 0;
+	     confsec < __be32_to_cpu(super->active->config_section_length);
+	     confsec += super->conf_rec_len) {
 		struct vd_config *vd =
-			(struct vd_config *)((char*)conf + i*512);
+			(struct vd_config *)((char*)conf + confsec*512);
 		struct vcl *vcl;
 
 		if (vd->magic == DDF_SPARE_ASSIGN_MAGIC) {
 			if (dl->spare)
 				continue;
-			posix_memalign((void**)&dl->spare, 512,
-				       super->conf_rec_len*512);
+			if (posix_memalign((void**)&dl->spare, 512,
+				       super->conf_rec_len*512) != 0) {
+				fprintf(stderr, Name
+					": %s could not allocate spare info buf\n",
+					__func__);
+				return 1;
+			}
+				
 			memcpy(dl->spare, vd, super->conf_rec_len*512);
 			continue;
 		}
@@ -711,9 +729,14 @@ static int load_ddf_local(int fd, struct ddf_super *super,
 			    __be32_to_cpu(vcl->conf.seqnum))
 				continue;
 		} else {
-			posix_memalign((void**)&vcl, 512,
+			if (posix_memalign((void**)&vcl, 512,
 				       (super->conf_rec_len*512 +
-					offsetof(struct vcl, conf)));
+					offsetof(struct vcl, conf))) != 0) {
+				fprintf(stderr, Name
+					": %s could not allocate vcl buf\n",
+					__func__);
+				return 1;
+			}
 			vcl->next = super->conflist;
 			vcl->block_sizes = NULL; /* FIXME not for CONCAT */
 			super->conflist = vcl;
@@ -739,6 +762,9 @@ static int load_ddf_local(int fd, struct ddf_super *super,
 static int load_super_ddf_all(struct supertype *st, int fd,
 			      void **sbp, char *devname, int keep_fd);
 #endif
+
+static void free_super_ddf(struct supertype *st);
+
 static int load_super_ddf(struct supertype *st, int fd,
 			  char *devname)
 {
@@ -759,24 +785,24 @@ static int load_super_ddf(struct supertype *st, int fd,
 
 	/* 32M is a lower bound */
 	if (dsize <= 32*1024*1024) {
-		if (devname) {
+		if (devname)
 			fprintf(stderr,
 				Name ": %s is too small for ddf: "
 				"size is %llu sectors.\n",
 				devname, dsize>>9);
-			return 1;
-		}
+		return 1;
 	}
 	if (dsize & 511) {
-		if (devname) {
+		if (devname)
 			fprintf(stderr,
 				Name ": %s is an odd size for ddf: "
 				"size is %llu bytes.\n",
 				devname, dsize);
-			return 1;
-		}
+		return 1;
 	}
 
+	free_super_ddf(st);
+
 	if (posix_memalign((void**)&super, 512, sizeof(*super))!= 0) {
 		fprintf(stderr, Name ": malloc of %zu failed.\n",
 			sizeof(*super));
@@ -803,7 +829,28 @@ static int load_super_ddf(struct supertype *st, int fd,
 		return rv;
 	}
 
-	load_ddf_local(fd, super, devname, 0);
+	rv = load_ddf_local(fd, super, devname, 0);
+
+	if (rv) {
+		if (devname)
+			fprintf(stderr,
+				Name ": Failed to load all information "
+				"sections on %s\n", devname);
+		free(super);
+		return rv;
+	}
+
+	if (st->subarray[0]) {
+		struct vcl *v;
+
+		for (v = super->conflist; v; v = v->next)
+			if (v->vcnum == atoi(st->subarray))
+				super->currentconf = v;
+		if (!super->currentconf) {
+			free(super);
+			return 1;
+		}
+	}
 
 	/* Should possibly check the sections .... */
 
@@ -813,6 +860,7 @@ static int load_super_ddf(struct supertype *st, int fd,
 		st->minor_version = 0;
 		st->max_devs = 512;
 	}
+	st->loaded_container = 0;
 	return 0;
 
 }
@@ -942,6 +990,15 @@ static int map_num1(struct num_mapping *map, int num)
 	return map[i].num2;
 }
 
+static int all_ff(char *guid)
+{
+	int i;
+	for (i = 0; i < DDF_GUID_LEN; i++)
+		if (guid[i] != (char)0xff)
+			return 0;
+	return 1;
+}
+
 #ifndef MDASSEMBLE
 static void print_guid(char *guid, int tstamp)
 {
@@ -959,7 +1016,7 @@ static void print_guid(char *guid, int tstamp)
 		printf("%02X", guid[i]&255);
 	}
 
-	printf(" (");
+	printf("\n                  (");
 	while (l && guid[l-1] == ' ')
 		l--;
 	for (i=0 ; i<l ; i++) {
@@ -985,6 +1042,7 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid)
 	struct vcl *vcl;
 
 	for (vcl = sb->conflist ; vcl ; vcl = vcl->next) {
+		int i;
 		struct vd_config *vc = &vcl->conf;
 
 		if (calc_crc(vc, crl*512) != vc->crc)
@@ -993,8 +1051,22 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid)
 			continue;
 
 		/* Ok, we know about this VD, let's give more details */
-		printf(" Raid Devices[%d] : %d\n", n,
+		printf(" Raid Devices[%d] : %d (", n,
 		       __be16_to_cpu(vc->prim_elmnt_count));
+		for (i=0; i<__be16_to_cpu(vc->prim_elmnt_count); i++) {
+			int j;
+			int cnt = __be16_to_cpu(sb->phys->used_pdes);
+			for (j=0; j<cnt; j++)
+				if (vc->phys_refnum[i] == sb->phys->entries[j].refnum)
+					break;
+			if (i) printf(" ");
+			if (j < cnt)
+				printf("%d", j);
+			else
+				printf("--");
+		}
+		printf(")\n");
+		if (vc->chunk_shift != 255)
 		printf("   Chunk Size[%d] : %d sectors\n", n,
 		       1 << vc->chunk_shift);
 		printf("   Raid Level[%d] : %s\n", n,
@@ -1006,9 +1078,9 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid)
 			       map_num(ddf_sec_level, vc->srl) ?: "-unknown-");
 		}
 		printf("  Device Size[%d] : %llu\n", n,
-		       __be64_to_cpu(vc->blocks)/2);
+		       (unsigned long long)__be64_to_cpu(vc->blocks)/2);
 		printf("   Array Size[%d] : %llu\n", n,
-		       __be64_to_cpu(vc->array_blocks)/2);
+		       (unsigned long long)__be64_to_cpu(vc->array_blocks)/2);
 	}
 }
 
@@ -1020,6 +1092,7 @@ static void examine_vds(struct ddf_super *sb)
 
 	for (i=0; i<cnt; i++) {
 		struct virtual_entry *ve = &sb->virt->entries[i];
+		printf("\n");
 		printf("      VD GUID[%d] : ", i); print_guid(ve->guid, 1);
 		printf("\n");
 		printf("         unit[%d] : %d\n", i, __be16_to_cpu(ve->unit));
@@ -1043,40 +1116,44 @@ static void examine_pds(struct ddf_super *sb)
 	int i;
 	struct dl *dl;
 	printf(" Physical Disks : %d\n", cnt);
+	printf("      Number    RefNo      Size       Device      Type/State\n");
 
 	for (i=0 ; i<cnt ; i++) {
 		struct phys_disk_entry *pd = &sb->phys->entries[i];
 		int type = __be16_to_cpu(pd->type);
 		int state = __be16_to_cpu(pd->state);
 
-		printf("      PD GUID[%d] : ", i); print_guid(pd->guid, 0);
-		printf("\n");
-		printf("          ref[%d] : %08x\n", i,
+		//printf("      PD GUID[%d] : ", i); print_guid(pd->guid, 0);
+		//printf("\n");
+		printf("       %3d    %08x  ", i,
 		       __be32_to_cpu(pd->refnum));
-		printf("         mode[%d] : %s%s%s%s%s\n", i,
+		printf("%8lluK ", 
+		       (unsigned long long)__be64_to_cpu(pd->config_size)>>1);
+		for (dl = sb->dlist; dl ; dl = dl->next) {
+			if (dl->disk.refnum == pd->refnum) {
+				char *dv = map_dev(dl->major, dl->minor, 0);
+				if (dv) {
+					printf("%-15s", dv);
+					break;
+				}
+			}
+		}
+		if (!dl)
+			printf("%15s","");
+		printf(" %s%s%s%s%s",
 		       (type&2) ? "active":"",
-		       (type&4) ? "Global Spare":"",
+		       (type&4) ? "Global-Spare":"",
 		       (type&8) ? "spare" : "",
 		       (type&16)? ", foreign" : "",
 		       (type&32)? "pass-through" : "");
-		printf("        state[%d] : %s%s%s%s%s%s%s\n", i,
+		printf("/%s%s%s%s%s%s%s",
 		       (state&1)? "Online": "Offline",
 		       (state&2)? ", Failed": "",
 		       (state&4)? ", Rebuilding": "",
 		       (state&8)? ", in-transition": "",
-		       (state&16)? ", SMART errors": "",
-		       (state&32)? ", Unrecovered Read Errors": "",
+		       (state&16)? ", SMART-errors": "",
+		       (state&32)? ", Unrecovered-Read-Errors": "",
 		       (state&64)? ", Missing" : "");
-		printf("   Avail Size[%d] : %llu K\n", i,
-		       __be64_to_cpu(pd->config_size)>>1);
-		for (dl = sb->dlist; dl ; dl = dl->next) {
-			if (dl->disk.refnum == pd->refnum) {
-				char *dv = map_dev(dl->major, dl->minor, 0);
-				if (dv)
-					printf("       Device[%d] : %s\n",
-					       i, dv);
-			}
-		}
 		printf("\n");
 	}
 }
@@ -1098,22 +1175,49 @@ static void examine_super_ddf(struct supertype *st, char *homehost)
 	examine_pds(sb);
 }
 
-static void brief_examine_super_ddf(struct supertype *st)
+static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info);
+
+static void uuid_from_super_ddf(struct supertype *st, int uuid[4]);
+
+static void brief_examine_super_ddf(struct supertype *st, int verbose)
 {
 	/* We just write a generic DDF ARRAY entry
-	 * The uuid is all hex, 6 groups of 4 bytes
 	 */
 	struct ddf_super *ddf = st->sb;
+	struct mdinfo info;
 	int i;
-	printf("ARRAY /dev/ddf metadata=ddf UUID=");
-	for (i = 0; i < DDF_GUID_LEN; i++) {
-		if ((i&3) == 0 && i != 0)
-			printf(":");
-		printf("%02X", 255&ddf->anchor.guid[i]);
-	}
-	printf("\n");
+	char nbuf[64];
+	getinfo_super_ddf(st, &info);
+	fname_from_uuid(st, &info, nbuf, ':');
+
+	for (i=0; i<__be16_to_cpu(ddf->virt->max_vdes); i++) {
+		struct virtual_entry *ve = &ddf->virt->entries[i];
+		struct vcl vcl;
+		char nbuf1[64];
+		if (all_ff(ve->guid))
+			continue;
+		memcpy(vcl.conf.guid, ve->guid, DDF_GUID_LEN);
+		ddf->currentconf =&vcl;
+		uuid_from_super_ddf(st, info.uuid);
+		fname_from_uuid(st, &info, nbuf1, ':');
+		printf("ARRAY container=%s member=%d UUID=%s\n",
+		       nbuf+5, i, nbuf1+5);
+	}
+	printf("ARRAY metadata=ddf UUID=%s\n", nbuf + 5);
 }
 
+static void export_examine_super_ddf(struct supertype *st)
+{
+	struct mdinfo info;
+	char nbuf[64];
+	getinfo_super_ddf(st, &info);
+	fname_from_uuid(st, &info, nbuf, ':');
+	printf("MD_METADATA=ddf\n");
+	printf("MD_LEVEL=container\n");
+	printf("MD_UUID=%s\n", nbuf+5);
+}
+	
+
 static void detail_super_ddf(struct supertype *st, char *homehost)
 {
 	/* FIXME later
@@ -1130,6 +1234,11 @@ static void brief_detail_super_ddf(struct supertype *st)
 	 * Can that be stored in ddf_super??
 	 */
 //	struct ddf_super *ddf = st->sb;
+	struct mdinfo info;
+	char nbuf[64];
+	getinfo_super_ddf(st, &info);
+	fname_from_uuid(st, &info, nbuf,':');
+	printf(" UUID=%s", nbuf + 5);
 }
 #endif
 
@@ -1148,6 +1257,7 @@ static int match_home_ddf(struct supertype *st, char *homehost)
 		ddf->controller.vendor_data[len] == 0);
 }
 
+#ifndef MDASSEMBLE
 static struct vd_config *find_vdcr(struct ddf_super *ddf, int inst)
 {
 	struct vcl *v;
@@ -1157,6 +1267,7 @@ static struct vd_config *find_vdcr(struct ddf_super *ddf, int inst)
 			return &v->conf;
 	return NULL;
 }
+#endif
 
 static int find_phys(struct ddf_super *ddf, __u32 phys_refnum)
 {
@@ -1176,11 +1287,14 @@ static void uuid_from_super_ddf(struct supertype *st, int uuid[4])
 	 *  uuid to put into bitmap file (Create, Grow)
 	 *  uuid for backup header when saving critical section (Grow)
 	 *  comparing uuids when re-adding a device into an array
+	 *    In these cases the uuid required is that of the data-array,
+	 *    not the device-set.
+	 *  uuid to recognise same set when adding a missing device back
+	 *    to an array.   This is a uuid for the device-set.
+	 *  
 	 * For each of these we can make do with a truncated
 	 * or hashed uuid rather than the original, as long as
 	 * everyone agrees.
-	 * In each case the uuid required is that of the data-array,
-	 * not the device-set.
 	 * In the case of SVD we assume the BVD is of interest,
 	 * though that might be the case if a bitmap were made for
 	 * a mirrored SVD - worry about that later.
@@ -1190,19 +1304,19 @@ static void uuid_from_super_ddf(struct supertype *st, int uuid[4])
 	 */
 	struct ddf_super *ddf = st->sb;
 	struct vcl *vcl = ddf->currentconf;
+	char *guid;
+	char buf[20];
+	struct sha1_ctx ctx;
 
-	if (!vcl)
-		memset(uuid, 0, sizeof (uuid));
-	else {
-		char buf[20];
-		struct sha1_ctx ctx;
-		sha1_init_ctx(&ctx);
-		sha1_process_bytes(&vcl->conf.guid, DDF_GUID_LEN, &ctx);
-		if (vcl->conf.sec_elmnt_count > 1)
-			sha1_process_bytes(&vcl->conf.sec_elmnt_seq, 1, &ctx);
-		sha1_finish_ctx(&ctx, buf);
-		memcpy(uuid, buf, sizeof(uuid));
-	}
+	if (vcl)
+		guid = vcl->conf.guid;
+	else
+		guid = ddf->anchor.guid;
+
+	sha1_init_ctx(&ctx);
+	sha1_process_bytes(guid, DDF_GUID_LEN, &ctx);
+	sha1_finish_ctx(&ctx, buf);
+	memcpy(uuid, buf, 4*4);
 }
 
 static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info);
@@ -1238,18 +1352,22 @@ static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info)
 		info->component_size = ddf->dlist->size - info->data_offset;
 	} else {
 		info->disk.number = -1;
+		info->disk.raid_disk = -1;
 //		info->disk.raid_disk = find refnum in the table and use index;
 	}
 	info->disk.state = (1 << MD_DISK_SYNC);
 
 
 	info->reshape_active = 0;
+	info->name[0] = 0;
 
+	info->array.major_version = -1;
+	info->array.minor_version = -2;
 	strcpy(info->text_version, "ddf");
+	info->safe_mode_delay = 0;
 
-//	uuid_from_super_ddf(info->uuid, sbv);
+	uuid_from_super_ddf(st, info->uuid);
 
-//	info->name[] ?? ;
 }
 
 static int rlq_to_layout(int rlq, int prl, int raiddisks);
@@ -1259,6 +1377,8 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info)
 	struct ddf_super *ddf = st->sb;
 	struct vcl *vc = ddf->currentconf;
 	int cd = ddf->currentdev;
+	int j;
+	struct dl *dl;
 
 	/* FIXME this returns BVD info - what if we want SVD ?? */
 
@@ -1271,6 +1391,7 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info)
 		__be32_to_cpu(*(__u32*)(vc->conf.guid+16));
 	info->array.utime	  = DECADE + __be32_to_cpu(vc->conf.timestamp);
 	info->array.chunk_size	  = 512 << vc->conf.chunk_shift;
+	info->custom_array_size	  = 0;
 
 	if (cd >= 0 && cd < ddf->mppe) {
 		info->data_offset	  = __be64_to_cpu(vc->lba_offset[cd]);
@@ -1280,8 +1401,15 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info)
 			info->component_size = __be64_to_cpu(vc->conf.blocks);
 	}
 
+	for (dl = ddf->dlist; dl ; dl = dl->next)
+		if (dl->raiddisk == info->disk.raid_disk)
+			break;
 	info->disk.major = 0;
 	info->disk.minor = 0;
+	if (dl) {
+		info->disk.major = dl->major;
+		info->disk.minor = dl->minor;
+	}
 //	info->disk.number = __be32_to_cpu(ddf->disk.refnum);
 //	info->disk.raid_disk = find refnum in the table and use index;
 //	info->disk.state = ???;
@@ -1299,11 +1427,18 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info)
 	uuid_from_super_ddf(st, info->uuid);
 
 	info->container_member = atoi(st->subarray);
+	info->array.major_version = -1;
+	info->array.minor_version = -2;
 	sprintf(info->text_version, "/%s/%s",
 		devnum2devname(st->container_dev),
 		st->subarray);
+	info->safe_mode_delay = 200;
 
-//	info->name[] ?? ;
+	memcpy(info->name, ddf->virt->entries[info->container_member].name, 16);
+	info->name[16]=0;
+	for(j=0; j<16; j++)
+		if (info->name[j] == ' ')
+			info->name[j] = 0;
 }
 
 
@@ -1377,10 +1512,20 @@ static int update_super_ddf(struct supertype *st, struct mdinfo *info,
 	return rv;
 }
 
+__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;
+}
+
 static void make_header_guid(char *guid)
 {
 	__u32 stamp;
-	int rfd;
 	/* Create a DDF Header of Virtual Disk GUID */
 
 	/* 24 bytes of fiction required.
@@ -1395,11 +1540,8 @@ static void make_header_guid(char *guid)
 	memcpy(guid+12, &stamp, 4);
 	stamp = __cpu_to_be32(time(0) - DECADE);
 	memcpy(guid+16, &stamp, 4);
-	rfd = open("/dev/urandom", O_RDONLY);
-	if (rfd < 0 || read(rfd, &stamp, 4) != 4)
-		stamp = random();
+	stamp = random32();
 	memcpy(guid+20, &stamp, 4);
-	if (rfd >= 0) close(rfd);
 }
 
 static int init_super_ddf_bvd(struct supertype *st,
@@ -1455,7 +1597,10 @@ static int init_super_ddf(struct supertype *st,
 		return init_super_ddf_bvd(st, info, size, name, homehost,
 					  uuid);
 
-	posix_memalign((void**)&ddf, 512, sizeof(*ddf));
+	if (posix_memalign((void**)&ddf, 512, sizeof(*ddf)) != 0) {
+		fprintf(stderr, Name ": %s could not allocate superblock\n", __func__);
+		return 0;
+	}
 	memset(ddf, 0, sizeof(*ddf));
 	ddf->dlist = NULL; /* no physical disks yet */
 	ddf->conflist = NULL; /* No virtual disks yet */
@@ -1581,8 +1726,13 @@ static int init_super_ddf(struct supertype *st,
 	memcpy(ddf->controller.product_id, "What Is My PID??", 16);
 	memset(ddf->controller.pad, 0xff, 8);
 	memset(ddf->controller.vendor_data, 0xff, 448);
+	if (homehost && strlen(homehost) < 440)
+		strcpy((char*)ddf->controller.vendor_data, homehost);
 
-	posix_memalign((void**)&pd, 512, pdsize);
+	if (posix_memalign((void**)&pd, 512, pdsize) != 0) {
+		fprintf(stderr, Name ": %s could not allocate pd\n", __func__);
+		return 0;
+	}
 	ddf->phys = pd;
 	ddf->pdsize = pdsize;
 
@@ -1593,7 +1743,10 @@ static int init_super_ddf(struct supertype *st,
 	pd->max_pdes = __cpu_to_be16(max_phys_disks);
 	memset(pd->pad, 0xff, 52);
 
-	posix_memalign((void**)&vd, 512, vdsize);
+	if (posix_memalign((void**)&vd, 512, vdsize) != 0) {
+		fprintf(stderr, Name ": %s could not allocate vd\n", __func__);
+		return 0;
+	}
 	ddf->virt = vd;
 	ddf->vdsize = vdsize;
 	memset(vd, 0, vdsize);
@@ -1610,14 +1763,6 @@ static int init_super_ddf(struct supertype *st,
 	return 1;
 }
 
-static int all_ff(char *guid)
-{
-	int i;
-	for (i = 0; i < DDF_GUID_LEN; i++)
-		if (guid[i] != (char)0xff)
-			return 0;
-	return 1;
-}
 static int chunk_to_shift(int chunksize)
 {
 	return ffs(chunksize/512)-1;
@@ -1652,20 +1797,25 @@ static int layout_to_rlq(int level, int layout, int raiddisks)
 		}
 		break;
 	case 5:
-	case 6:
 		switch(layout) {
 		case ALGORITHM_LEFT_ASYMMETRIC:
 			return DDF_RAID5_N_RESTART;
 		case ALGORITHM_RIGHT_ASYMMETRIC:
-			if (level == 5)
-				return DDF_RAID5_0_RESTART;
-			else
-				return DDF_RAID6_0_RESTART;
+			return DDF_RAID5_0_RESTART;
 		case ALGORITHM_LEFT_SYMMETRIC:
 			return DDF_RAID5_N_CONTINUE;
 		case ALGORITHM_RIGHT_SYMMETRIC:
 			return -1; /* not mentioned in standard */
 		}
+	case 6:
+		switch(layout) {
+		case ALGORITHM_ROTATING_N_RESTART:
+			return DDF_RAID5_N_RESTART;
+		case ALGORITHM_ROTATING_ZERO_RESTART:
+			return DDF_RAID6_0_RESTART;
+		case ALGORITHM_ROTATING_N_CONTINUE:
+			return DDF_RAID5_N_CONTINUE;
+		}
 	}
 	return -1;
 }
@@ -1700,11 +1850,11 @@ static int rlq_to_layout(int rlq, int prl, int raiddisks)
 	case DDF_RAID6:
 		switch(rlq) {
 		case DDF_RAID5_N_RESTART:
-			return ALGORITHM_LEFT_ASYMMETRIC;
+			return ALGORITHM_ROTATING_N_RESTART;
 		case DDF_RAID6_0_RESTART:
-			return ALGORITHM_RIGHT_ASYMMETRIC;
+			return ALGORITHM_ROTATING_ZERO_RESTART;
 		case DDF_RAID5_N_CONTINUE:
-			return ALGORITHM_LEFT_SYMMETRIC;
+			return ALGORITHM_ROTATING_N_CONTINUE;
 		default:
 			return -1;
 		}
@@ -1712,6 +1862,7 @@ static int rlq_to_layout(int rlq, int prl, int raiddisks)
 	return -1;
 }
 
+#ifndef MDASSEMBLE
 struct extent {
 	unsigned long long start, size;
 };
@@ -1762,6 +1913,7 @@ FIXME ignore DDF_Legacy devices?
 	rv[n].size = 0;
 	return rv;
 }
+#endif
 
 static int init_super_ddf_bvd(struct supertype *st,
 			      mdu_array_info_t *info,
@@ -1819,8 +1971,11 @@ static int init_super_ddf_bvd(struct supertype *st,
 		__cpu_to_be16(__be16_to_cpu(ddf->virt->populated_vdes)+1);
 
 	/* Now create a new vd_config */
-	posix_memalign((void**)&vcl, 512,
-		       (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512));
+	if (posix_memalign((void**)&vcl, 512,
+		           (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512)) != 0) {
+		fprintf(stderr, Name ": %s could not allocate vd_config\n", __func__);
+		return 0;
+	}
 	vcl->lba_offset = (__u64*) &vcl->conf.phys_refnum[ddf->mppe];
 	vcl->vcnum = venum;
 	sprintf(st->subarray, "%d", venum);
@@ -1865,7 +2020,7 @@ static int init_super_ddf_bvd(struct supertype *st,
 	memset(vc->vendor, 0xff, 32);
 
 	memset(vc->phys_refnum, 0xff, 4*ddf->mppe);
-	memset(vc->phys_refnum+(ddf->mppe * 4), 0x00, 8*ddf->mppe);
+	memset(vc->phys_refnum+ddf->mppe, 0x00, 8*ddf->mppe);
 
 	vcl->next = ddf->conflist;
 	ddf->conflist = vcl;
@@ -1874,6 +2029,7 @@ static int init_super_ddf_bvd(struct supertype *st,
 	return 1;
 }
 
+#ifndef MDASSEMBLE
 static void add_to_super_ddf_bvd(struct supertype *st,
 				 mdu_disk_info_t *dk, int fd, char *devname)
 {
@@ -1883,6 +2039,9 @@ static void add_to_super_ddf_bvd(struct supertype *st,
 	 * the phys_refnum and lba_offset for the newly created vd_config.
 	 * We might also want to update the type in the phys_disk
 	 * section.
+	 *
+	 * Alternately: fd == -1 and we have already chosen which device to
+	 * use and recorded in dlist->raid_disk;
 	 */
 	struct dl *dl;
 	struct ddf_super *ddf = st->sb;
@@ -1893,10 +2052,16 @@ static void add_to_super_ddf_bvd(struct supertype *st,
 	unsigned long long blocks, pos, esize;
 	struct extent *ex;
 
-	for (dl = ddf->dlist; dl ; dl = dl->next)
-		if (dl->major == dk->major &&
-		    dl->minor == dk->minor)
-			break;
+	if (fd == -1) {
+		for (dl = ddf->dlist; dl ; dl = dl->next)
+			if (dl->raiddisk == dk->raid_disk)
+				break;
+	} else {
+		for (dl = ddf->dlist; dl ; dl = dl->next)
+			if (dl->major == dk->major &&
+			    dl->minor == dk->minor)
+				break;
+	}
 	if (!dl || ! (dk->state & (1<<MD_DISK_SYNC)))
 		return;
 
@@ -1935,8 +2100,10 @@ static void add_to_super_ddf_bvd(struct supertype *st,
 		return;
 	dl->vlist[i] = ddf->currentconf;
 
-	dl->fd = fd;
-	dl->devname = devname;
+	if (fd >= 0)
+		dl->fd = fd;
+	if (devname)
+		dl->devname = devname;
 
 	/* Check how many working raid_disks, and if we can mark
 	 * array as optimal yet
@@ -1968,7 +2135,7 @@ static void add_to_super_ddf_bvd(struct supertype *st,
 /* add a device to a container, either while creating it or while
  * expanding a pre-existing container
  */
-static void add_to_super_ddf(struct supertype *st,
+static int add_to_super_ddf(struct supertype *st,
 			     mdu_disk_info_t *dk, int fd, char *devname)
 {
 	struct ddf_super *ddf = st->sb;
@@ -1982,19 +2149,23 @@ static void add_to_super_ddf(struct supertype *st,
 
 	if (ddf->currentconf) {
 		add_to_super_ddf_bvd(st, dk, fd, devname);
-		return;
+		return 0;
 	}
 
 	/* This is device numbered dk->number.  We need to create
 	 * a phys_disk entry and a more detailed disk_data entry.
 	 */
 	fstat(fd, &stb);
-	posix_memalign((void**)&dd, 512,
-		       sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part);
+	if (posix_memalign((void**)&dd, 512,
+		           sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part) != 0) {
+		fprintf(stderr, Name
+			": %s could allocate buffer for new disk, aborting\n",
+			__func__);
+		return 1;
+	}
 	dd->major = major(stb.st_rdev);
 	dd->minor = minor(stb.st_rdev);
 	dd->devname = devname;
-	dd->next = ddf->dlist;
 	dd->fd = fd;
 	dd->spare = NULL;
 
@@ -2003,12 +2174,12 @@ static void add_to_super_ddf(struct supertype *st,
 	tm = localtime(&now);
 	sprintf(dd->disk.guid, "%8s%04d%02d%02d",
 		T10, tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
-	*(__u32*)(dd->disk.guid + 16) = random();
-	*(__u32*)(dd->disk.guid + 20) = random();
+	*(__u32*)(dd->disk.guid + 16) = random32();
+	*(__u32*)(dd->disk.guid + 20) = random32();
 
 	do {
 		/* Cannot be bothered finding a CRC of some irrelevant details*/
-		dd->disk.refnum = random();
+		dd->disk.refnum = random32();
 		for (i = __be16_to_cpu(ddf->active->max_pd_entries) - 1;
 		     i >= 0; i--)
 			if (ddf->phys->entries[i].refnum == dd->disk.refnum)
@@ -2027,8 +2198,20 @@ static void add_to_super_ddf(struct supertype *st,
 	pde = &ddf->phys->entries[n];
 	dd->pdnum = n;
 
-	n++;
-	ddf->phys->used_pdes = __cpu_to_be16(n);
+	if (st->update_tail) {
+		int len = (sizeof(struct phys_disk) +
+			   sizeof(struct phys_disk_entry));
+		struct phys_disk *pd;
+
+		pd = malloc(len);
+		pd->magic = DDF_PHYS_RECORDS_MAGIC;
+		pd->used_pdes = __cpu_to_be16(n);
+		pde = &pd->entries[0];
+		dd->mdupdate = pd;
+	} else {
+		n++;
+		ddf->phys->used_pdes = __cpu_to_be16(n);
+	}
 
 	memcpy(pde->guid, dd->disk.guid, DDF_GUID_LEN);
 	pde->refnum = dd->disk.refnum;
@@ -2041,8 +2224,16 @@ static void add_to_super_ddf(struct supertype *st,
 	memset(pde->pad, 0xff, 6);
 
 	dd->size = size >> 9;
-	ddf->dlist = dd;
-	ddf->updates_pending = 1;
+	if (st->update_tail) {
+		dd->next = ddf->add_list;
+		ddf->add_list = dd;
+	} else {
+		dd->next = ddf->dlist;
+		ddf->dlist = dd;
+		ddf->updates_pending = 1;
+	}
+
+	return 0;
 }
 
 /*
@@ -2051,8 +2242,6 @@ static void add_to_super_ddf(struct supertype *st,
  * container.
  */
 
-#ifndef MDASSEMBLE
-
 static unsigned char null_conf[4096+512];
 
 static int __write_init_super_ddf(struct supertype *st, int do_close)
@@ -2063,15 +2252,20 @@ static int __write_init_super_ddf(struct supertype *st, int do_close)
 	struct dl *d;
 	int n_config;
 	int conf_size;
-
+	int attempts = 0;
+	int successes = 0;
 	unsigned long long size, sector;
 
+	/* try to write updated metadata,
+	 * if we catch a failure move on to the next disk
+	 */
 	for (d = ddf->dlist; d; d=d->next) {
 		int fd = d->fd;
 
 		if (fd < 0)
 			continue;
 
+		attempts++;
 		/* We need to fill in the primary, (secondary) and workspace
 		 * lba's in the headers, set their checksums,
 		 * Also checksum phys, virt....
@@ -2101,17 +2295,21 @@ static int __write_init_super_ddf(struct supertype *st, int do_close)
 
 		sector = size - 16*1024*2;
 		lseek64(fd, sector<<9, 0);
-		write(fd, &ddf->primary, 512);
+		if (write(fd, &ddf->primary, 512) < 0)
+			continue;
 
 		ddf->controller.crc = calc_crc(&ddf->controller, 512);
-		write(fd, &ddf->controller, 512);
+		if (write(fd, &ddf->controller, 512) < 0)
+			continue;
 
 		ddf->phys->crc = calc_crc(ddf->phys, ddf->pdsize);
 
-		write(fd, ddf->phys, ddf->pdsize);
+		if (write(fd, ddf->phys, ddf->pdsize) < 0)
+			continue;
 
 		ddf->virt->crc = calc_crc(ddf->virt, ddf->vdsize);
-		write(fd, ddf->virt, ddf->vdsize);
+		if (write(fd, ddf->virt, ddf->vdsize) < 0)
+			continue;
 
 		/* Now write lots of config records. */
 		n_config = ddf->max_part;
@@ -2123,32 +2321,43 @@ static int __write_init_super_ddf(struct supertype *st, int do_close)
 
 			if (c) {
 				c->conf.crc = calc_crc(&c->conf, conf_size);
-				write(fd, &c->conf, conf_size);
+				if (write(fd, &c->conf, conf_size) < 0)
+					break;
 			} else {
 				char *null_aligned = (char*)((((unsigned long)null_conf)+511)&~511UL);
 				if (null_conf[0] != 0xff)
 					memset(null_conf, 0xff, sizeof(null_conf));
 				int togo = conf_size;
 				while (togo > sizeof(null_conf)-512) {
-					write(fd, null_aligned, sizeof(null_conf)-512);
+					if (write(fd, null_aligned, sizeof(null_conf)-512) < 0)
+						break;
 					togo -= sizeof(null_conf)-512;
 				}
-				write(fd, null_aligned, togo);
+				if (write(fd, null_aligned, togo) < 0)
+					break;
 			}
 		}
+		if (i <= n_config)
+			continue;
 		d->disk.crc = calc_crc(&d->disk, 512);
-		write(fd, &d->disk, 512);
+		if (write(fd, &d->disk, 512) < 0)
+			continue;
 
 		/* Maybe do the same for secondary */
 
 		lseek64(fd, (size-1)*512, SEEK_SET);
-		write(fd, &ddf->anchor, 512);
-		if (do_close) {
-			close(fd);
+		if (write(fd, &ddf->anchor, 512) < 0)
+			continue;
+		successes++;
+	}
+
+	if (do_close)
+		for (d = ddf->dlist; d; d=d->next) {
+			close(d->fd);
 			d->fd = -1;
 		}
-	}
-	return 1;
+
+	return attempts != successes;
 }
 
 static int write_init_super_ddf(struct supertype *st)
@@ -2161,6 +2370,21 @@ static int write_init_super_ddf(struct supertype *st)
 		struct ddf_super *ddf = st->sb;
 		int len;
 
+		if (!ddf->currentconf) {
+			int len = (sizeof(struct phys_disk) +
+				   sizeof(struct phys_disk_entry));
+
+			/* adding a disk to the container. */
+			if (!ddf->add_list)
+				return 0;
+
+			append_metadata_update(st, ddf->add_list->mdupdate, len);
+			ddf->add_list->mdupdate = NULL;
+			return 0;
+		}
+
+		/* Newly created VD */
+
 		/* First the virtual disk.  We have a slightly fake header */
 		len = sizeof(struct virtual_disk) + sizeof(struct virtual_entry);
 		vd = malloc(len);
@@ -2192,6 +2416,96 @@ static __u64 avail_size_ddf(struct supertype *st, __u64 devsize)
 }
 
 #ifndef MDASSEMBLE
+
+static int reserve_space(struct supertype *st, int raiddisks,
+			 unsigned long long size, int chunk,
+			 unsigned long long *freesize)
+{
+	/* Find 'raiddisks' spare extents at least 'size' big (but
+	 * only caring about multiples of 'chunk') and remember
+	 * them.
+	 * If the cannot be found, fail.
+	 */
+	struct dl *dl;
+	struct ddf_super *ddf = st->sb;
+	int cnt = 0;
+
+	for (dl = ddf->dlist; dl ; dl=dl->next) {
+		dl->raiddisk = -1;	
+		dl->esize = 0;
+	}
+	/* Now find largest extent on each device */
+	for (dl = ddf->dlist ; dl ; dl=dl->next) {
+		struct extent *e = get_extents(ddf, dl);
+		unsigned long long pos = 0;
+		int i = 0;
+		int found = 0;
+		unsigned long long minsize = size;
+
+		if (size == 0)
+			minsize = chunk;
+
+		if (!e)
+			continue;
+		do {
+			unsigned long long esize;
+			esize = e[i].start - pos;
+			if (esize >= minsize) {
+				found = 1;
+				minsize = esize;
+			}
+			pos = e[i].start + e[i].size;
+			i++;
+		} while (e[i-1].size);
+		if (found) {
+			cnt++;
+			dl->esize = minsize;
+		}
+		free(e);
+	}
+	if (cnt < raiddisks) {
+		fprintf(stderr, Name ": not enough devices with space to create array.\n");
+		return 0; /* No enough free spaces large enough */
+	}
+	if (size == 0) {
+		/* choose the largest size of which there are at least 'raiddisk' */
+		for (dl = ddf->dlist ; dl ; dl=dl->next) {
+			struct dl *dl2;
+			if (dl->esize <= size)
+				continue;
+			/* This is bigger than 'size', see if there are enough */
+			cnt = 0;
+			for (dl2 = dl; dl2 ; dl2=dl2->next)
+				if (dl2->esize >= dl->esize)
+					cnt++;
+			if (cnt >= raiddisks)
+				size = dl->esize;
+		}
+		if (chunk) {
+			size = size / chunk;
+			size *= chunk;
+		}
+		*freesize = size;
+		if (size < 32) {
+			fprintf(stderr, Name ": not enough spare devices to create array.\n");
+			return 0;
+		}
+	}
+	/* We have a 'size' of which there are enough spaces.
+	 * We simply do a first-fit */
+	cnt = 0;
+	for (dl = ddf->dlist ; dl && cnt < raiddisks ; dl=dl->next) {
+		if (dl->esize < size)
+			continue;
+		
+		dl->raiddisk = cnt;
+		cnt++;
+	}
+	return 1;
+}
+
+
+
 static int
 validate_geometry_ddf_container(struct supertype *st,
 				int level, int layout, int raiddisks,
@@ -2230,15 +2544,6 @@ static int validate_geometry_ddf(struct supertype *st,
 						       verbose);
 	}
 
-	if (st->sb) {
-		/* A container has already been opened, so we are
-		 * creating in there.  Maybe a BVD, maybe an SVD.
-		 * Should make a distinction one day.
-		 */
-		return validate_geometry_ddf_bvd(st, level, layout, raiddisks,
-						 chunk, size, dev, freesize,
-						 verbose);
-	}
 	if (!dev) {
 		/* Initial sanity check.  Exclude illegal levels. */
 		int i;
@@ -2248,9 +2553,29 @@ static int validate_geometry_ddf(struct supertype *st,
 		if (ddf_level_num[i].num1 == MAXINT)
 			return 0;
 		/* Should check layout? etc */
+
+		if (st->sb && freesize) {
+			/* --create was given a container to create in.
+			 * So we need to check that there are enough
+			 * free spaces and return the amount of space.
+			 * We may as well remember which drives were
+			 * chosen so that add_to_super/getinfo_super
+			 * can return them.
+			 */
+			return reserve_space(st, raiddisks, size, chunk, freesize);
+		}
 		return 1;
 	}
 
+	if (st->sb) {
+		/* A container has already been opened, so we are
+		 * creating in there.  Maybe a BVD, maybe an SVD.
+		 * Should make a distinction one day.
+		 */
+		return validate_geometry_ddf_bvd(st, level, layout, raiddisks,
+						 chunk, size, dev, freesize,
+						 verbose);
+	}
 	/* This is the first device for the array.
 	 * If it is a container, we read it in and do automagic allocations,
 	 * no other devices should be given.
@@ -2346,6 +2671,8 @@ validate_geometry_ddf_container(struct supertype *st,
 	close(fd);
 
 	*freesize = avail_size_ddf(st, ldsize >> 9);
+	if (*freesize == 0)
+		return 0;
 
 	return 1;
 }
@@ -2452,8 +2779,14 @@ static int load_super_ddf_all(struct supertype *st, int fd,
 	int seq;
 	char nm[20];
 	int dfd;
+	int devnum = fd2devnum(fd);
+	enum sysfs_read_flags flags;
 
-	sra = sysfs_read(fd, 0, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE);
+	flags = GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE;
+	if (mdmon_running(devnum))
+		flags |= SKIP_GONE_DEVS;
+
+	sra = sysfs_read(fd, 0, flags);
 	if (!sra)
 		return 1;
 	if (sra->array.major_version != -1 ||
@@ -2496,12 +2829,18 @@ static int load_super_ddf_all(struct supertype *st, int fd,
 	close(dfd);
 	/* Now we need the device-local bits */
 	for (sd = sra->devs ; sd ; sd = sd->next) {
+		int rv;
+
 		sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
 		dfd = dev_open(nm, keep_fd? O_RDWR : O_RDONLY);
 		if (dfd < 0)
 			return 2;
-		seq = load_ddf_local(dfd, super, NULL, keep_fd);
+		rv = load_ddf_headers(dfd, super, NULL);
+		if (rv == 0)
+			rv = load_ddf_local(dfd, super, NULL, keep_fd);
 		if (!keep_fd) close(dfd);
+		if (rv)
+			return 1;
 	}
 	if (st->subarray[0]) {
 		struct vcl *v;
@@ -2519,9 +2858,10 @@ static int load_super_ddf_all(struct supertype *st, int fd,
 		st->max_devs = 512;
 		st->container_dev = fd2devnum(fd);
 	}
+	st->loaded_container = 1;
 	return 0;
 }
-#endif
+#endif /* MDASSEMBLE */
 
 static struct mdinfo *container_content_ddf(struct supertype *st)
 {
@@ -2540,6 +2880,7 @@ static struct mdinfo *container_content_ddf(struct supertype *st)
 	for (vc = ddf->conflist ; vc ; vc=vc->next)
 	{
 		int i;
+		int j;
 		struct mdinfo *this;
 		this = malloc(sizeof(*this));
 		memset(this, 0, sizeof(*this));
@@ -2552,6 +2893,8 @@ static struct mdinfo *container_content_ddf(struct supertype *st)
 		this->array.layout = rlq_to_layout(vc->conf.rlq, vc->conf.prl,
 						   this->array.raid_disks);
 		this->array.md_minor      = -1;
+		this->array.major_version = -1;
+		this->array.minor_version = -2;
 		this->array.ctime         = DECADE +
 			__be32_to_cpu(*(__u32*)(vc->conf.guid+16));
 		this->array.utime	  = DECADE +
@@ -2568,14 +2911,21 @@ static struct mdinfo *container_content_ddf(struct supertype *st)
 			this->array.state = 1;
 			this->resync_start = ~0ULL;
 		}
-		memcpy(this->name, ddf->virt->entries[i].name, 32);
-		this->name[33]=0;
+		memcpy(this->name, ddf->virt->entries[i].name, 16);
+		this->name[16]=0;
+		for(j=0; j<16; j++)
+			if (this->name[j] == ' ')
+				this->name[j] = 0;
 
 		memset(this->uuid, 0, sizeof(this->uuid));
 		this->component_size = __be64_to_cpu(vc->conf.blocks);
 		this->array.size = this->component_size / 2;
 		this->container_member = i;
 
+		ddf->currentconf = vc;
+		uuid_from_super_ddf(st, this->uuid);
+		ddf->currentconf = NULL;
+
 		sprintf(this->text_version, "/%s/%d",
 			devnum2devname(st->container_dev),
 			this->container_member);
@@ -2593,7 +2943,8 @@ static struct mdinfo *container_content_ddf(struct supertype *st)
 				if (d->disk.refnum == vc->conf.phys_refnum[i])
 					break;
 			if (d == NULL)
-				break;
+				/* Haven't found that one yet, maybe there are others */
+				continue;
 
 			dev = malloc(sizeof(*dev));
 			memset(dev, 0, sizeof(*dev));
@@ -2620,16 +2971,20 @@ static int store_zero_ddf(struct supertype *st, int fd)
 {
 	unsigned long long dsize;
 	void *buf;
+	int rc;
 
 	if (!get_dev_size(fd, NULL, &dsize))
 		return 1;
 
-	posix_memalign(&buf, 512, 512);
+	if (posix_memalign(&buf, 512, 512) != 0)
+		return 1;
 	memset(buf, 0, 512);
 
 	lseek64(fd, dsize-512, 0);
-	write(fd, buf, 512);
+	rc = write(fd, buf, 512);
 	free(buf);
+	if (rc < 0)
+		return 1;
 	return 0;
 }
 
@@ -2658,6 +3013,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst)
 	return 0;
 }
 
+#ifndef MDASSEMBLE
 /*
  * A new array 'a' has been started which claims to be instance 'inst'
  * within container 'c'.
@@ -2680,11 +3036,17 @@ static int ddf_open_new(struct supertype *c, struct active_array *a, char *inst)
  * For DDF, we need to clear the DDF_state_inconsistent bit in the
  * !global! virtual_disk.virtual_entry structure.
  */
-static void ddf_set_array_state(struct active_array *a, int consistent)
+static int ddf_set_array_state(struct active_array *a, int consistent)
 {
 	struct ddf_super *ddf = a->container->sb;
 	int inst = a->info.container_member;
 	int old = ddf->virt->entries[inst].state;
+	if (consistent == 2) {
+		/* Should check if a recovery should be started FIXME */
+		consistent = 1;
+		if (!is_resync_complete(a))
+			consistent = 0;
+	}
 	if (consistent)
 		ddf->virt->entries[inst].state &= ~DDF_state_inconsistent;
 	else
@@ -2694,7 +3056,7 @@ static void ddf_set_array_state(struct active_array *a, int consistent)
 
 	old = ddf->virt->entries[inst].init_state;
 	ddf->virt->entries[inst].init_state &= ~DDF_initstate_mask;
-	if (a->resync_start == ~0ULL)
+	if (is_resync_complete(a))
 		ddf->virt->entries[inst].init_state |= DDF_init_full;
 	else if (a->resync_start == 0)
 		ddf->virt->entries[inst].init_state |= DDF_init_not;
@@ -2705,6 +3067,7 @@ static void ddf_set_array_state(struct active_array *a, int consistent)
 
 	dprintf("ddf mark %d %s %llu\n", inst, consistent?"clean":"dirty",
 		a->resync_start);
+	return consistent;
 }
 
 /*
@@ -2887,6 +3250,20 @@ static void ddf_process_update(struct supertype *st,
 		ddf->phys->used_pdes = __cpu_to_be16(1 +
 					   __be16_to_cpu(ddf->phys->used_pdes));
 		ddf->updates_pending = 1;
+		if (ddf->add_list) {
+			struct active_array *a;
+			struct dl *al = ddf->add_list;
+			ddf->add_list = al->next;
+
+			al->next = ddf->dlist;
+			ddf->dlist = al;
+
+			/* As a device has been added, we should check
+			 * for any degraded devices that might make
+			 * use of this spare */
+			for (a = st->arrays ; a; a=a->next)
+				a->check_degraded = 1;
+		}
 		break;
 
 	case DDF_VIRT_RECORDS_MAGIC:
@@ -2926,6 +3303,8 @@ static void ddf_process_update(struct supertype *st,
 			       mppe * (sizeof(__u32) + sizeof(__u64)));
 		} else {
 			/* A new VD_CONF */
+			if (!update->space)
+				return;
 			vcl = update->space;
 			update->space = NULL;
 			vcl->next = ddf->conflist;
@@ -2986,9 +3365,10 @@ static void ddf_prepare_update(struct supertype *st,
 	struct ddf_super *ddf = st->sb;
 	__u32 *magic = (__u32*)update->buf;
 	if (*magic == DDF_VD_CONF_MAGIC)
-		posix_memalign(&update->space, 512,
+		if (posix_memalign(&update->space, 512,
 			       offsetof(struct vcl, conf)
-			       + ddf->conf_rec_len * 512);
+			       + ddf->conf_rec_len * 512) != 0)
+			update->space = NULL;
 }
 
 /*
@@ -3137,6 +3517,8 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a,
 
 			/* Cool, we have a device with some space at pos */
 			di = malloc(sizeof(*di));
+			if (!di)
+				continue;
 			memset(di, 0, sizeof(*di));
 			di->disk.number = i;
 			di->disk.raid_disk = i;
@@ -3169,8 +3551,21 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a,
 	 * phys_refnum and lba_offset values
 	 */
 	mu = malloc(sizeof(*mu));
+	if (mu && posix_memalign(&mu->space, 512, sizeof(struct vcl)) != 0) {
+		free(mu);
+		mu = NULL;
+	}
+	if (!mu) {
+		while (rv) {
+			struct mdinfo *n = rv->next;
+
+			free(rv);
+			rv = n;
+		}
+		return NULL;
+	}
+		
 	mu->buf = malloc(ddf->conf_rec_len * 512);
-	posix_memalign(&mu->space, 512, sizeof(struct vcl));
 	mu->len = ddf->conf_rec_len;
 	mu->next = *updates;
 	vc = find_vdcr(ddf, a->info.container_member);
@@ -3186,15 +3581,35 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a,
 	*updates = mu;
 	return rv;
 }
+#endif /* MDASSEMBLE */
+
+static int ddf_level_to_layout(int level)
+{
+	switch(level) {
+	case 0:
+	case 1:
+		return 0;
+	case 5:
+		return ALGORITHM_LEFT_SYMMETRIC;
+	case 6:
+		return ALGORITHM_ROTATING_N_CONTINUE;
+	case 10:
+		return 0x102;
+	default:
+		return UnSet;
+	}
+}
 
 struct superswitch super_ddf = {
 #ifndef	MDASSEMBLE
 	.examine_super	= examine_super_ddf,
 	.brief_examine_super = brief_examine_super_ddf,
+	.export_examine_super = export_examine_super_ddf,
 	.detail_super	= detail_super_ddf,
 	.brief_detail_super = brief_detail_super_ddf,
 	.validate_geometry = validate_geometry_ddf,
 	.write_init_super = write_init_super_ddf,
+	.add_to_super	= add_to_super_ddf,
 #endif
 	.match_home	= match_home_ddf,
 	.uuid_from_super= uuid_from_super_ddf,
@@ -3210,11 +3625,12 @@ struct superswitch super_ddf = {
 	.store_super	= store_zero_ddf,
 	.free_super	= free_super_ddf,
 	.match_metadata_desc = match_metadata_desc_ddf,
-	.add_to_super	= add_to_super_ddf,
 	.container_content = container_content_ddf,
+	.default_layout	= ddf_level_to_layout,
 
 	.external	= 1,
 
+#ifndef MDASSEMBLE
 /* for mdmon */
 	.open_new       = ddf_open_new,
 	.set_array_state= ddf_set_array_state,
@@ -3223,5 +3639,6 @@ struct superswitch super_ddf = {
 	.process_update	= ddf_process_update,
 	.prepare_update	= ddf_prepare_update,
 	.activate_spare = ddf_activate_spare,
-
+#endif
+	.name = "ddf",
 };