X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super1.c;h=5c6530ed66f51bf2088d57b92ddf071611ba2e59;hb=e7b84f9d5029338980d99d04b479ce814d4c4fcb;hp=3d392cb05c996dc96f0156c11dd0103707e10be6;hpb=cf8de6913b63a99602cc2bb6e6ea7b9f9eb694d9;p=thirdparty%2Fmdadm.git

diff --git a/super1.c b/super1.c
index 3d392cb0..5c6530ed 100644
--- a/super1.c
+++ b/super1.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,12 +19,7 @@
  *    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"
@@ -81,8 +76,8 @@ struct mdp_superblock_1 {
 	__u64	utime;		/* 40 bits second, 24 btes microseconds */
 	__u64	events;		/* incremented when superblock updated */
 	__u64	resync_offset;	/* data before this offset (from data_offset) known to be in sync */
-	__u32	sb_csum;	/* checksum upto devs[max_dev] */
-	__u32	max_dev;	/* size of devs[] array to consider */
+	__u32	sb_csum;	/* checksum upto dev_roles[max_dev] */
+	__u32	max_dev;	/* size of dev_roles[] array to consider */
 	__u8	pad3[64-32];	/* set to 0 when writing */
 
 	/* device state information. Indexed by dev_number.
@@ -94,6 +89,13 @@ struct mdp_superblock_1 {
 	__u16	dev_roles[0];	/* role in array, or 0xffff for a spare, or 0xfffe for faulty */
 };
 
+#define MAX_SB_SIZE 4096
+/* bitmap super size is 256, but we round up to a sector for alignment */
+#define BM_SUPER_SIZE 512
+#define MAX_DEVS ((int)(MAX_SB_SIZE - sizeof(struct mdp_superblock_1)) / 2)
+#define SUPER1_SIZE	(MAX_SB_SIZE + BM_SUPER_SIZE \
+			 + sizeof(struct misc_dev_info))
+
 struct misc_dev_info {
 	__u64 device_size;
 };
@@ -116,7 +118,6 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 	unsigned long long newcsum;
 	int size = sizeof(*sb) + __le32_to_cpu(sb->max_dev)*2;
 	unsigned int *isuper = (unsigned int*)sb;
-	int i;
 
 /* make sure I can count... */
 	if (offsetof(struct mdp_superblock_1,data_offset) != 128 ||
@@ -128,7 +129,7 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 	disk_csum = sb->sb_csum;
 	sb->sb_csum = 0;
 	newcsum = 0;
-	for (i=0; size>=4; size -= 4 ) {
+	for (; size>=4; size -= 4 ) {
 		newcsum += __le32_to_cpu(*isuper);
 		isuper++;
 	}
@@ -141,13 +142,104 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 	return __cpu_to_le32(csum);
 }
 
+/*
+ * Information related to file descriptor used for aligned reads/writes.
+ * Cache the block size.
+ */
+struct align_fd {
+	int fd;
+	int blk_sz;
+};
+
+static void init_afd(struct align_fd *afd, int fd)
+{
+	afd->fd = fd;
+
+	if (ioctl(afd->fd, BLKSSZGET, &afd->blk_sz) != 0)
+		afd->blk_sz = 512;
+}
+
+static char abuf[4096+4096];
+static int aread(struct align_fd *afd, void *buf, int len)
+{
+	/* aligned read.
+	 * On devices with a 4K sector size, we need to read
+	 * the full sector and copy relevant bits into
+	 * the buffer
+	 */
+	int bsize, iosize;
+	char *b;
+	int n;
+
+	bsize = afd->blk_sz;
+
+	if (!bsize || bsize > 4096 || len > 4096) {
+		if (!bsize)
+			fprintf(stderr, "WARNING - aread() called with "
+				"invalid block size\n");
+		return -1;
+	}
+	b = ROUND_UP_PTR((char *)abuf, 4096);
+
+	for (iosize = 0; iosize < len; iosize += bsize)
+		;
+	n = read(afd->fd, b, iosize);
+	if (n <= 0)
+		return n;
+	lseek(afd->fd, len - n, 1);
+	if (n > len)
+		n = len;
+	memcpy(buf, b, n);
+	return n;
+}
+
+static int awrite(struct align_fd *afd, void *buf, int len)
+{
+	/* aligned write.
+	 * On devices with a 4K sector size, we need to write
+	 * the full sector.  We pre-read if the sector is larger
+	 * than the write.
+	 * The address must be sector-aligned.
+	 */
+	int bsize, iosize;
+	char *b;
+	int n;
+
+	bsize = afd->blk_sz;
+	if (!bsize || bsize > 4096 || len > 4096) {
+		if (!bsize)
+			fprintf(stderr, "WARNING - awrite() called with "
+				"invalid block size\n");
+		return -1;
+	}
+	b = ROUND_UP_PTR((char *)abuf, 4096);
+
+	for (iosize = 0; iosize < len ; iosize += bsize)
+		;
+
+	if (len != iosize) {
+		n = read(afd->fd, b, iosize);
+		if (n <= 0)
+			return n;
+		lseek(afd->fd, -n, 1);
+	}
+
+	memcpy(b, buf, len);
+	n = write(afd->fd, b, iosize);
+	if (n <= 0)
+		return n;
+	lseek(afd->fd, len - n, 1);
+	return len;
+}
+
 #ifndef MDASSEMBLE
 static void examine_super1(struct supertype *st, char *homehost)
 {
 	struct mdp_superblock_1 *sb = st->sb;
 	time_t atime;
-	int d;
-	int faulty;
+	unsigned int d;
+	int role;
+	int delta_extra = 0;
 	int i;
 	char *c;
 	int l = homehost ? strlen(homehost) : 0;
@@ -185,8 +277,8 @@ static void examine_super1(struct supertype *st, char *homehost)
 	printf(" Avail Dev Size : %llu%s\n",
 	       (unsigned long long)__le64_to_cpu(sb->data_size),
 	       human_size(__le64_to_cpu(sb->data_size)<<9));
-	if (__le32_to_cpu(sb->level) >= 0) {
-		int ddsks=0;
+	if (__le32_to_cpu(sb->level) > 0) {
+		int ddsks = 0, ddsks_denom = 1;
 		switch(__le32_to_cpu(sb->level)) {
 		case 1: ddsks=1;break;
 		case 4:
@@ -194,13 +286,15 @@ static void examine_super1(struct supertype *st, char *homehost)
 		case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break;
 		case 10:
 			layout = __le32_to_cpu(sb->layout);
-			ddsks = __le32_to_cpu(sb->raid_disks)
-				 / (layout&255) / ((layout>>8)&255);
+			ddsks = __le32_to_cpu(sb->raid_disks);
+			ddsks_denom = (layout&255) * ((layout>>8)&255);
 		}
-		if (ddsks)
+		if (ddsks) {
+			long long asize = __le64_to_cpu(sb->size);
+			asize = (asize << 9) * ddsks / ddsks_denom;
 			printf("     Array Size : %llu%s\n",
-			       ddsks*(unsigned long long)__le64_to_cpu(sb->size),
-			       human_size(ddsks*__le64_to_cpu(sb->size)<<9));
+			       asize >> 10,  human_size(asize));
+		}
 		if (sb->size != sb->data_size)
 			printf("  Used Dev Size : %llu%s\n",
 			       (unsigned long long)__le64_to_cpu(sb->size),
@@ -230,13 +324,11 @@ static void examine_super1(struct supertype *st, char *homehost)
 		       human_size(__le64_to_cpu(sb->reshape_position)<<9));
 		if (__le32_to_cpu(sb->delta_disks)) {
 			printf("  Delta Devices : %d", __le32_to_cpu(sb->delta_disks));
-			if (__le32_to_cpu(sb->delta_disks))
-				printf(" (%d->%d)\n",
-				       __le32_to_cpu(sb->raid_disks)-__le32_to_cpu(sb->delta_disks),
-				       __le32_to_cpu(sb->raid_disks));
-			else
-				printf(" (%d->%d)\n", __le32_to_cpu(sb->raid_disks),
-				       __le32_to_cpu(sb->raid_disks)+__le32_to_cpu(sb->delta_disks));
+			printf(" (%d->%d)\n",
+			       __le32_to_cpu(sb->raid_disks)-__le32_to_cpu(sb->delta_disks),
+			       __le32_to_cpu(sb->raid_disks));
+			if ((int)__le32_to_cpu(sb->delta_disks) < 0)
+				delta_extra = -__le32_to_cpu(sb->delta_disks);
 		}
 		if (__le32_to_cpu(sb->new_level) != __le32_to_cpu(sb->level)) {
 			c = map_num(pers, __le32_to_cpu(sb->new_level));
@@ -247,6 +339,10 @@ static void examine_super1(struct supertype *st, char *homehost)
 				c = map_num(r5layout, __le32_to_cpu(sb->new_layout));
 				printf("     New Layout : %s\n", c?c:"-unknown-");
 			}
+			if (__le32_to_cpu(sb->level) == 6) {
+				c = map_num(r6layout, __le32_to_cpu(sb->new_layout));
+				printf("     New Layout : %s\n", c?c:"-unknown-");
+			}
 			if (__le32_to_cpu(sb->level) == 10) {
 				printf("     New Layout :");
 				print_r10_layout(__le32_to_cpu(sb->new_layout));
@@ -258,7 +354,7 @@ static void examine_super1(struct supertype *st, char *homehost)
 		printf("\n");
 	}
 	if (sb->devflags) {
-		printf("      Flags :");
+		printf("          Flags :");
 		if (sb->devflags & WriteMostly1)
 			printf(" write-mostly");
 		printf("\n");
@@ -278,6 +374,10 @@ static void examine_super1(struct supertype *st, char *homehost)
 		c = map_num(r5layout, __le32_to_cpu(sb->layout));
 		printf("         Layout : %s\n", c?c:"-unknown-");
 	}
+	if (__le32_to_cpu(sb->level) == 6) {
+		c = map_num(r6layout, __le32_to_cpu(sb->layout));
+		printf("         Layout : %s\n", c?c:"-unknown-");
+	}
 	if (__le32_to_cpu(sb->level) == 10) {
 		int lo = __le32_to_cpu(sb->layout);
 		printf("         Layout :");
@@ -298,6 +398,8 @@ static void examine_super1(struct supertype *st, char *homehost)
 	default: break;
 	}
 	printf("\n");
+#if 0
+	/* This turns out to just be confusing */
 	printf("    Array Slot : %d (", __le32_to_cpu(sb->dev_number));
 	for (i= __le32_to_cpu(sb->max_dev); i> 0 ; i--)
 		if (__le16_to_cpu(sb->dev_roles[i-1]) != 0xffff)
@@ -310,24 +412,33 @@ static void examine_super1(struct supertype *st, char *homehost)
 		else printf("%d", role);
 	}
 	printf(")\n");
+#endif
+	printf("   Device Role : ");
+	d = __le32_to_cpu(sb->dev_number);
+	if (d < __le32_to_cpu(sb->max_dev))
+		role = __le16_to_cpu(sb->dev_roles[d]);
+	else
+		role = 0xFFFF;
+	if (role >= 0xFFFE)
+		printf("spare\n");
+	else
+		printf("Active device %d\n", role);
+
 	printf("   Array State : ");
-	for (d=0; d<__le32_to_cpu(sb->raid_disks); d++) {
+	for (d=0; d<__le32_to_cpu(sb->raid_disks) + delta_extra; d++) {
 		int cnt = 0;
-		int me = 0;
-		int i;
+		unsigned int i;
 		for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
-			int role = __le16_to_cpu(sb->dev_roles[i]);
-			if (role == d) {
-				if (i == __le32_to_cpu(sb->dev_number))
-					me = 1;
+			unsigned int role = __le16_to_cpu(sb->dev_roles[i]);
+			if (role == d)
 				cnt++;
-			}
 		}
 		if (cnt > 1) printf("?");
-		else if (cnt == 1 && me) printf("U");
-		else if (cnt == 1) printf("u");
-		else printf ("_");
+		else if (cnt == 1) printf("A");
+		else printf (".");
 	}
+#if 0
+	/* This is confusing too */
 	faulty = 0;
 	for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
 		int role = __le16_to_cpu(sb->dev_roles[i]);
@@ -335,11 +446,13 @@ static void examine_super1(struct supertype *st, char *homehost)
 			faulty++;
 	}
 	if (faulty) printf(" %d failed", faulty);
+#endif
+	printf(" ('A' == active, '.' == missing)");
 	printf("\n");
 }
 
 
-static void brief_examine_super1(struct supertype *st)
+static void brief_examine_super1(struct supertype *st, int verbose)
 {
 	struct mdp_superblock_1 *sb = st->sb;
 	int i;
@@ -355,17 +468,19 @@ static void brief_examine_super1(struct supertype *st)
 	else
 		nm = NULL;
 
-	printf("ARRAY%s%s level=%s ",
-	       nm ? " /dev/md/":"", nm,
-	       c?c:"-unknown-");
+	printf("ARRAY%s%s", nm ? " /dev/md/":"", nm);
+	if (verbose && c)
+		printf(" level=%s", c);
 	sb_offset = __le64_to_cpu(sb->super_offset);
 	if (sb_offset <= 4)
-		printf("metadata=1.1 ");
+		printf(" metadata=1.1 ");
 	else if (sb_offset <= 8)
-		printf("metadata=1.2 ");
+		printf(" metadata=1.2 ");
 	else
-		printf("metadata=1.0 ");
-	printf("num-devices=%d UUID=", __le32_to_cpu(sb->raid_disks));
+		printf(" metadata=1.0 ");
+	if (verbose)
+		printf("num-devices=%d ", __le32_to_cpu(sb->raid_disks));
+	printf("UUID=");
 	for (i=0; i<16; i++) {
 		if ((i&3)==0 && i != 0) printf(":");
 		printf("%02x", sb->set_uuid[i]);
@@ -479,13 +594,15 @@ static void uuid_from_super1(struct supertype *st, int uuid[4])
 		cuuid[i] = super->set_uuid[i];
 }
 
-static void getinfo_super1(struct supertype *st, struct mdinfo *info)
+static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 {
 	struct mdp_superblock_1 *sb = st->sb;
 	int working = 0;
-	int i;
-	int role;
+	unsigned int i;
+	unsigned int role;
+	unsigned int map_disks = info->array.raid_disks;
 
+	memset(info, 0, sizeof(*info));
 	info->array.major_version = 1;
 	info->array.minor_version = st->minor_version;
 	info->array.patch_version = 0;
@@ -497,17 +614,19 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info)
 	info->array.utime = __le64_to_cpu(sb->utime);
 	info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512;
 	info->array.state =
-		(__le64_to_cpu(sb->resync_offset) >= __le64_to_cpu(sb->size))
+		(__le64_to_cpu(sb->resync_offset) == MaxSector)
 		? 1 : 0;
 
 	info->data_offset = __le64_to_cpu(sb->data_offset);
 	info->component_size = __le64_to_cpu(sb->size);
+	if (sb->feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET))
+		info->bitmap_offset = (int32_t)__le32_to_cpu(sb->bitmap_offset);
 
 	info->disk.major = 0;
 	info->disk.minor = 0;
 	info->disk.number = __le32_to_cpu(sb->dev_number);
 	if (__le32_to_cpu(sb->dev_number) >= __le32_to_cpu(sb->max_dev) ||
-	    __le32_to_cpu(sb->max_dev) > 512)
+	    __le32_to_cpu(sb->dev_number) >= MAX_DEVS)
 		role = 0xfffe;
 	else
 		role = __le16_to_cpu(sb->dev_roles[__le32_to_cpu(sb->dev_number)]);
@@ -515,7 +634,7 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info)
 	info->disk.raid_disk = -1;
 	switch(role) {
 	case 0xFFFF:
-		info->disk.state = 2; /* spare: ACTIVE, not sync, not faulty */
+		info->disk.state = 0; /* spare: not active, not sync, not faulty */
 		break;
 	case 0xFFFE:
 		info->disk.state = 1; /* faulty */
@@ -524,6 +643,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info)
 		info->disk.state = 6; /* active and in sync */
 		info->disk.raid_disk = role;
 	}
+	if (sb->devflags & WriteMostly1)
+		info->disk.state |= (1 << MD_DISK_WRITEMOSTLY);
 	info->events = __le64_to_cpu(sb->events);
 	sprintf(info->text_version, "1.%d", st->minor_version);
 	info->safe_mode_delay = 200;
@@ -533,6 +654,11 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info)
 	strncpy(info->name, sb->set_name, 32);
 	info->name[32] = 0;
 
+	if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RECOVERY_OFFSET))
+		info->recovery_start = __le32_to_cpu(sb->recovery_offset);
+	else
+		info->recovery_start = MaxSector;
+
 	if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
 		info->reshape_active = 1;
 		info->reshape_progress = __le64_to_cpu(sb->reshape_position);
@@ -540,25 +666,48 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info)
 		info->delta_disks = __le32_to_cpu(sb->delta_disks);
 		info->new_layout = __le32_to_cpu(sb->new_layout);
 		info->new_chunk = __le32_to_cpu(sb->new_chunk)<<9;
+		if (info->delta_disks < 0)
+			info->array.raid_disks -= info->delta_disks;
 	} else
 		info->reshape_active = 0;
 
-	for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
+	info->recovery_blocked = info->reshape_active;
+
+	if (map)
+		for (i=0; i<map_disks; i++)
+			map[i] = 0;
+	for (i = 0; i < __le32_to_cpu(sb->max_dev); i++) {
 		role = __le16_to_cpu(sb->dev_roles[i]);
-		if (/*role == 0xFFFF || */role < info->array.raid_disks)
+		if (/*role == 0xFFFF || */role < (unsigned) info->array.raid_disks) {
 			working++;
+			if (map && role < map_disks)
+				map[role] = 1;
+		}
 	}
 
 	info->array.working_disks = working;
 }
 
+static struct mdinfo *container_content1(struct supertype *st, char *subarray)
+{
+	struct mdinfo *info;
+
+	if (subarray)
+		return NULL;
+
+	info = malloc(sizeof(*info));
+	getinfo_super1(st, info, NULL);
+	return info;
+}
+
 static int update_super1(struct supertype *st, struct mdinfo *info,
 			 char *update,
 			 char *devname, int verbose,
 			 int uuid_set, char *homehost)
 {
-	/* NOTE: for 'assemble' and 'force' we need to return non-zero if any change was made.
-	 * For others, the return value is ignored.
+	/* NOTE: for 'assemble' and 'force' we need to return non-zero
+	 * if any change was made.  For others, the return value is
+	 * ignored.
 	 */
 	int rv = 0;
 	struct mdp_superblock_1 *sb = st->sb;
@@ -570,35 +719,46 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 		if (sb->events != __cpu_to_le64(info->events))
 			rv = 1;
 		sb->events = __cpu_to_le64(info->events);
-	}
-	if (strcmp(update, "force-array")==0) {
+	} else if (strcmp(update, "force-array")==0) {
 		/* Degraded array and 'force' requests to
 		 * maybe need to mark it 'clean'.
 		 */
 		switch(__le32_to_cpu(sb->level)) {
 		case 5: case 4: case 6:
 			/* need to force clean */
-			if (sb->resync_offset != ~0ULL)
+			if (sb->resync_offset != MaxSector)
 				rv = 1;
-			sb->resync_offset = ~0ULL;
+			sb->resync_offset = MaxSector;
 		}
-	}
-	if (strcmp(update, "assemble")==0) {
+	} else if (strcmp(update, "assemble")==0) {
 		int d = info->disk.number;
 		int want;
 		if (info->disk.state == 6)
-			want = __cpu_to_le32(info->disk.raid_disk);
+			want = info->disk.raid_disk;
 		else
 			want = 0xFFFF;
-		if (sb->dev_roles[d] != want) {
-			sb->dev_roles[d] = want;
+		if (sb->dev_roles[d] != __cpu_to_le16(want)) {
+			sb->dev_roles[d] = __cpu_to_le16(want);
 			rv = 1;
 		}
-	}
-	if (strcmp(update, "linear-grow-new") == 0) {
-		int i;
+		if (info->reshape_active &&
+		    sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) &&
+		    info->delta_disks >= 0 &&
+		    info->reshape_progress < __le64_to_cpu(sb->reshape_position)) {
+			sb->reshape_position = __cpu_to_le64(info->reshape_progress);
+			rv = 1;
+		}
+		if (info->reshape_active &&
+		    sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) &&
+		    info->delta_disks < 0 &&
+		    info->reshape_progress > __le64_to_cpu(sb->reshape_position)) {
+			sb->reshape_position = __cpu_to_le64(info->reshape_progress);
+			rv = 1;
+		}
+	} else if (strcmp(update, "linear-grow-new") == 0) {
+		unsigned int i;
 		int rfd, fd;
-		int max = __le32_to_cpu(sb->max_dev);
+		unsigned int max = __le32_to_cpu(sb->max_dev);
 
 		for (i=0 ; i < max ; i++)
 			if (__le16_to_cpu(sb->dev_roles[i]) >= 0xfffe)
@@ -610,11 +770,11 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 
 		if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
 		    read(rfd, sb->device_uuid, 16) != 16) {
-			*(__u32*)(sb->device_uuid) = random();
-			*(__u32*)(sb->device_uuid+4) = random();
-			*(__u32*)(sb->device_uuid+8) = random();
-			*(__u32*)(sb->device_uuid+12) = random();
+			__u32 r[4] = {random(), random(), random(), random()};
+			memcpy(sb->device_uuid, r, 16);
 		}
+		if (rfd >= 0)
+			close(rfd);
 
 		sb->dev_roles[i] =
 			__cpu_to_le16(info->disk.raid_disk);
@@ -637,27 +797,25 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 					ds - __le64_to_cpu(sb->data_offset));
 			}
 		}
-	}
-	if (strcmp(update, "linear-grow-update") == 0) {
+	} else if (strcmp(update, "linear-grow-update") == 0) {
 		sb->raid_disks = __cpu_to_le32(info->array.raid_disks);
 		sb->dev_roles[info->disk.number] =
 			__cpu_to_le16(info->disk.raid_disk);
-	}
-	if (strcmp(update, "resync") == 0) {
+	} else if (strcmp(update, "resync") == 0) {
 		/* make sure resync happens */
 		sb->resync_offset = 0ULL;
-	}
-	if (strcmp(update, "uuid") == 0) {
+	} else if (strcmp(update, "uuid") == 0) {
 		copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid);
 
 		if (__le32_to_cpu(sb->feature_map)&MD_FEATURE_BITMAP_OFFSET) {
 			struct bitmap_super_s *bm;
-			bm = (struct bitmap_super_s*)(st->sb+1024);
+			bm = (struct bitmap_super_s*)(st->sb+MAX_SB_SIZE);
 			memcpy(bm->uuid, sb->set_uuid, 16);
 		}
-	}
-	if (strcmp(update, "homehost") == 0 &&
-	    homehost) {
+	} else if (strcmp(update, "no-bitmap") == 0) {
+		sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
+	} else if (strcmp(update, "homehost") == 0 &&
+		   homehost) {
 		char *c;
 		update = "name";
 		c = strchr(sb->set_name, ':');
@@ -666,8 +824,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 		else
 			strncpy(info->name, sb->set_name, 32);
 		info->name[32] = 0;
-	}
-	if (strcmp(update, "name") == 0) {
+	} else if (strcmp(update, "name") == 0) {
 		if (info->name[0] == 0)
 			sprintf(info->name, "%d", info->array.md_minor);
 		memset(sb->set_name, 0, sizeof(sb->set_name));
@@ -679,22 +836,26 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 			strcat(sb->set_name, info->name);
 		} else
 			strcpy(sb->set_name, info->name);
-	}
-	if (strcmp(update, "devicesize") == 0 &&
+	} else if (strcmp(update, "devicesize") == 0 &&
 	    __le64_to_cpu(sb->super_offset) <
 	    __le64_to_cpu(sb->data_offset)) {
 		/* set data_size to device size less data_offset */
 		struct misc_dev_info *misc = (struct misc_dev_info*)
-			(st->sb + 1024 + 512);
+			(st->sb + MAX_SB_SIZE + BM_SUPER_SIZE);
 		printf("Size was %llu\n", (unsigned long long)
 		       __le64_to_cpu(sb->data_size));
 		sb->data_size = __cpu_to_le64(
 			misc->device_size - __le64_to_cpu(sb->data_offset));
 		printf("Size is %llu\n", (unsigned long long)
 		       __le64_to_cpu(sb->data_size));
-	}
-	if (strcmp(update, "_reshape_progress")==0)
+	} else if (strcmp(update, "_reshape_progress")==0)
 		sb->reshape_position = __cpu_to_le64(info->reshape_progress);
+	else if (strcmp(update, "writemostly")==0)
+		sb->devflags |= WriteMostly1;
+	else if (strcmp(update, "readwrite")==0)
+		sb->devflags &= ~WriteMostly1;
+	else
+		rv = -1;
 
 	sb->sb_csum = calc_sb_1_csum(sb);
 	return rv;
@@ -707,14 +868,13 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 	int spares;
 	int rfd;
 	char defname[10];
+	int sbsize;
 
-	if (posix_memalign((void**)&sb, 512, (1024 + 512 + 
-			   sizeof(struct misc_dev_info))) != 0) {
-		fprintf(stderr, Name
-			": %s could not allocate superblock\n", __func__);
+	if (posix_memalign((void**)&sb, 4096, SUPER1_SIZE) != 0) {
+		pr_err("%s could not allocate superblock\n", __func__);
 		return 0;
 	}
-	memset(sb, 0, 1024);
+	memset(sb, 0, SUPER1_SIZE);
 
 	st->sb = sb;
 	if (info == NULL) {
@@ -723,9 +883,9 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 	}
 
 	spares = info->working_disks - info->active_disks;
-	if (info->raid_disks + spares  > 384) {
-		fprintf(stderr, Name ": too many devices requested: %d+%d > %d\n",
-			info->raid_disks , spares, 384);
+	if (info->raid_disks + spares  > MAX_DEVS) {
+		pr_err("too many devices requested: %d+%d > %d\n",
+			info->raid_disks , spares, MAX_DEVS);
 		return 0;
 	}
 
@@ -739,10 +899,8 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 	else {
 		if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
 		    read(rfd, sb->set_uuid, 16) != 16) {
-			*(__u32*)(sb->set_uuid) = random();
-			*(__u32*)(sb->set_uuid+4) = random();
-			*(__u32*)(sb->set_uuid+8) = random();
-			*(__u32*)(sb->set_uuid+12) = random();
+			__u32 r[4] = {random(), random(), random(), random()};
+			memcpy(sb->set_uuid, r, 16);
 		}
 		if (rfd >= 0) close(rfd);
 	}
@@ -751,7 +909,6 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 		sprintf(defname, "%d", info->md_minor);
 		name = defname;
 	}
-	memset(sb->set_name, 0, 32);
 	if (homehost &&
 	    strchr(name, ':')== NULL &&
 	    strlen(homehost)+1+strlen(name) < 32) {
@@ -776,14 +933,14 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 	sb->utime = sb->ctime;
 	sb->events = __cpu_to_le64(1);
 	if (info->state & (1<<MD_SB_CLEAN))
-		sb->resync_offset = ~0ULL;
+		sb->resync_offset = MaxSector;
 	else
 		sb->resync_offset = 0;
-	sb->max_dev = __cpu_to_le32((1024- sizeof(struct mdp_superblock_1))/
-				    sizeof(sb->dev_roles[0]));
-	memset(sb->pad3, 0, sizeof(sb->pad3));
+	sbsize = sizeof(struct mdp_superblock_1) + 2 * (info->raid_disks + spares);
+	sbsize = ROUND_UP(sbsize, 512);
+	sb->max_dev = __cpu_to_le32((sbsize - sizeof(struct mdp_superblock_1)) / 2);
 
-	memset(sb->dev_roles, 0xff, 1024 - sizeof(struct mdp_superblock_1));
+	memset(sb->dev_roles, 0xff, MAX_SB_SIZE - sizeof(struct mdp_superblock_1));
 
 	return 1;
 }
@@ -796,7 +953,7 @@ struct devinfo {
 };
 #ifndef MDASSEMBLE
 /* Add a device to the superblock being created */
-static void add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
+static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
 			  int fd, char *devname)
 {
 	struct mdp_superblock_1 *sb = st->sb;
@@ -810,7 +967,12 @@ static void add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
 	else
 		*rp = 0xfffe;
 
+	if (dk->number >= (int)__le32_to_cpu(sb->max_dev) &&
+	    __le32_to_cpu(sb->max_dev) < MAX_DEVS)
+		sb->max_dev = __cpu_to_le32(dk->number+1);
+
 	sb->dev_number = __cpu_to_le32(dk->number);
+	sb->devflags = 0; /* don't copy another disks flags */
 	sb->sb_csum = calc_sb_1_csum(sb);
 
 	dip = (struct devinfo **)&st->info;
@@ -822,6 +984,8 @@ static void add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
 	di->disk = *dk;
 	di->next = NULL;
 	*dip = di;
+
+	return 0;
 }
 #endif
 
@@ -831,6 +995,7 @@ static int store_super1(struct supertype *st, int fd)
 {
 	struct mdp_superblock_1 *sb = st->sb;
 	unsigned long long sb_offset;
+	struct align_fd afd;
 	int sbsize;
 	unsigned long long dsize;
 
@@ -842,6 +1007,8 @@ static int store_super1(struct supertype *st, int fd)
 	if (dsize < 24)
 		return 2;
 
+	init_afd(&afd, fd);
+
 	/*
 	 * Calculate the position of the superblock.
 	 * It is always aligned to a 4K boundary and
@@ -871,27 +1038,25 @@ static int store_super1(struct supertype *st, int fd)
 	if (sb_offset != __le64_to_cpu(sb->super_offset) &&
 	    0 != __le64_to_cpu(sb->super_offset)
 		) {
-		fprintf(stderr, Name ": internal error - sb_offset is wrong\n");
+		pr_err("internal error - sb_offset is wrong\n");
 		abort();
 	}
 
 	if (lseek64(fd, sb_offset << 9, 0)< 0LL)
 		return 3;
 
-	sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev);
-	sbsize = (sbsize+511)&(~511UL);
+	sbsize = ROUND_UP(sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev), 512);
 
-	if (write(fd, sb, sbsize) != sbsize)
+	if (awrite(&afd, sb, sbsize) != sbsize)
 		return 4;
 
 	if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
 		struct bitmap_super_s *bm = (struct bitmap_super_s*)
-			(((char*)sb)+1024);
+			(((char*)sb)+MAX_SB_SIZE);
 		if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) {
 			locate_bitmap1(st, fd);
-			if (write(fd, bm, ROUND_UP(sizeof(*bm),512)) !=
-			    ROUND_UP(sizeof(*bm),512))
-			    return 5;
+			if (awrite(&afd, bm, sizeof(*bm)) != sizeof(*bm))
+				return 5;
 		}
 	}
 	fsync(fd);
@@ -904,6 +1069,8 @@ static unsigned long choose_bm_space(unsigned long devsize)
 {
 	/* if the device is bigger than 8Gig, save 64k for bitmap usage,
 	 * if bigger than 200Gig, save 128k
+	 * NOTE: result must be multiple of 4K else bad things happen
+	 * on 4K-sector devices.
 	 */
 	if (devsize < 64*2) return 0;
 	if (devsize - 64*2 >= 200*1024*1024*2)
@@ -913,45 +1080,49 @@ static unsigned long choose_bm_space(unsigned long devsize)
 	return 4*2;
 }
 
+static void free_super1(struct supertype *st);
+
 #ifndef MDASSEMBLE
 static int write_init_super1(struct supertype *st)
 {
 	struct mdp_superblock_1 *sb = st->sb;
-	struct supertype refst;
+	struct supertype *refst;
 	int rfd;
 	int rv = 0;
-	int bm_space;
+	unsigned long long bm_space;
+	unsigned long long reserved;
 	struct devinfo *di;
 	unsigned long long dsize, array_size;
-	long long sb_offset;
+	unsigned long long sb_offset, headroom;
 
-	for (di = st->info; di && ! rv ; di = di->next) {
+	for (di = st->info; di; di = di->next) {
 		if (di->disk.state == 1)
 			continue;
 		if (di->fd < 0)
 			continue;
 
-		Kill(di->devname, 0, 1, 1);
-		Kill(di->devname, 0, 1, 1);
+		while (Kill(di->devname, NULL, 0, 1, 1) == 0)
+			;
 
 		sb->dev_number = __cpu_to_le32(di->disk.number);
 		if (di->disk.state & (1<<MD_DISK_WRITEMOSTLY))
-			sb->devflags |= __cpu_to_le32(WriteMostly1);
+			sb->devflags |= WriteMostly1;
+		else
+			sb->devflags &= ~WriteMostly1;
 
 		if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
 		    read(rfd, sb->device_uuid, 16) != 16) {
-			*(__u32*)(sb->device_uuid) = random();
-			*(__u32*)(sb->device_uuid+4) = random();
-			*(__u32*)(sb->device_uuid+8) = random();
-			*(__u32*)(sb->device_uuid+12) = random();
+			__u32 r[4] = {random(), random(), random(), random()};
+			memcpy(sb->device_uuid, r, 16);
 		}
-		if (rfd >= 0) close(rfd);
+		if (rfd >= 0)
+			close(rfd);
+
 		sb->events = 0;
 
-		refst =*st;
-		refst.sb = NULL;
-		if (load_super1(&refst, di->fd, NULL)==0) {
-			struct mdp_superblock_1 *refsb = refst.sb;
+		refst = dup_super(st);
+ 		if (load_super1(refst, di->fd, NULL)==0) {
+			struct mdp_superblock_1 *refsb = refst->sb;
 
 			memcpy(sb->device_uuid, refsb->device_uuid, 16);
 			if (memcmp(sb->set_uuid, refsb->set_uuid, 16)==0) {
@@ -964,16 +1135,20 @@ static int write_init_super1(struct supertype *st)
 				if (get_linux_version() >= 2006018)
 					sb->dev_number = refsb->dev_number;
 			}
-			free(refsb);
+			free_super1(refst);
 		}
+		free(refst);
 
-		if (!get_dev_size(di->fd, NULL, &dsize))
-			return 1;
+		if (!get_dev_size(di->fd, NULL, &dsize)) {
+			rv = 1;
+			goto error_out;
+		}
 		dsize >>= 9;
 
 		if (dsize < 24) {
 			close(di->fd);
-			return 2;
+			rv = 2;
+			goto error_out;
 		}
 
 
@@ -991,6 +1166,14 @@ static int write_init_super1(struct supertype *st)
 		/* work out how much space we left for a bitmap */
 		bm_space = choose_bm_space(array_size);
 
+		/* We try to leave 0.1% at the start for reshape
+		 * operations, but limit this to 128Meg (0.1% of 10Gig)
+		 * which is plenty for efficient reshapes
+		 */
+		headroom = 128 * 1024 * 2;
+		while  (headroom << 10 > array_size)
+			headroom >>= 1;
+
 		switch(st->minor_version) {
 		case 0:
 			sb_offset = dsize;
@@ -998,45 +1181,74 @@ static int write_init_super1(struct supertype *st)
 			sb_offset &= ~(4*2-1);
 			sb->super_offset = __cpu_to_le64(sb_offset);
 			sb->data_offset = __cpu_to_le64(0);
-		if (sb_offset - bm_space < array_size)
-			bm_space = sb_offset - array_size;
+			if (sb_offset < array_size + bm_space)
+				bm_space = sb_offset - array_size;
 			sb->data_size = __cpu_to_le64(sb_offset - bm_space);
 			break;
 		case 1:
 			sb->super_offset = __cpu_to_le64(0);
-			if (4*2 + bm_space + __le64_to_cpu(sb->size) > dsize)
-				bm_space = dsize - __le64_to_cpu(sb->size) -4*2;
-			sb->data_offset = __cpu_to_le64(bm_space + 4*2);
-			sb->data_size = __cpu_to_le64(dsize - bm_space - 4*2);
+			reserved = bm_space + 4*2;
+			if (reserved < headroom)
+				reserved = headroom;
+			if (reserved + array_size > dsize)
+				reserved = dsize - array_size;
+			/* Try for multiple of 1Meg so it is nicely aligned */
+			#define ONE_MEG (2*1024)
+			if (reserved > ONE_MEG)
+				reserved = (reserved/ONE_MEG) * ONE_MEG;
+
+			/* force 4K alignment */
+			reserved &= ~7ULL;
+
+			sb->data_offset = __cpu_to_le64(reserved);
+			sb->data_size = __cpu_to_le64(dsize - reserved);
 			break;
 		case 2:
 			sb_offset = 4*2;
 			sb->super_offset = __cpu_to_le64(4*2);
-			if (4*2 + 4*2 + bm_space + __le64_to_cpu(sb->size)
+			if (4*2 + 4*2 + bm_space + array_size
 			    > dsize)
-				bm_space = dsize - __le64_to_cpu(sb->size)
+				bm_space = dsize - array_size
 					- 4*2 - 4*2;
-			sb->data_offset = __cpu_to_le64(4*2 + 4*2 + bm_space);
-			sb->data_size = __cpu_to_le64(dsize - 4*2 - 4*2
-						      - bm_space );
+
+			reserved = bm_space + 4*2 + 4*2;
+			if (reserved < headroom)
+				reserved = headroom;
+			if (reserved + array_size > dsize)
+				reserved = dsize - array_size;
+			/* Try for multiple of 1Meg so it is nicely aligned */
+			#define ONE_MEG (2*1024)
+			if (reserved > ONE_MEG)
+				reserved = (reserved/ONE_MEG) * ONE_MEG;
+
+			/* force 4K alignment */
+			reserved &= ~7ULL;
+
+			sb->data_offset = __cpu_to_le64(reserved);
+			sb->data_size = __cpu_to_le64(dsize - reserved);
 			break;
 		default:
-			return -EINVAL;
+			pr_err("Failed to write invalid "
+			       "metadata format 1.%i to %s\n",
+			       st->minor_version, di->devname);
+			rv = -EINVAL;
+			goto out;
 		}
 
-
 		sb->sb_csum = calc_sb_1_csum(sb);
 		rv = store_super1(st, di->fd);
-		if (rv)
-			fprintf(stderr,
-				Name ": failed to write superblock to %s\n",
-				di->devname);
-
 		if (rv == 0 && (__le32_to_cpu(sb->feature_map) & 1))
 			rv = st->ss->write_bitmap(st, di->fd);
 		close(di->fd);
 		di->fd = -1;
+		if (rv)
+			goto error_out;
 	}
+error_out:
+	if (rv)
+		pr_err("Failed to write metadata to %s\n",
+		       di->devname);
+out:
 	return rv;
 }
 #endif
@@ -1059,15 +1271,11 @@ static int compare_super1(struct supertype *st, struct supertype *tst)
 		return 1;
 
 	if (!first) {
-		if (posix_memalign((void**)&first, 512,
-			       1024 + 512 +
-			       sizeof(struct misc_dev_info)) != 0) {
-			fprintf(stderr, Name
-				": %s could not allocate superblock\n", __func__);
+		if (posix_memalign((void**)&first, 4096, SUPER1_SIZE) != 0) {
+			pr_err("%s could not allocate superblock\n", __func__);
 			return 1;
 		}
-		memcpy(first, second, 1024 + 512 + 
-		       sizeof(struct misc_dev_info));
+		memcpy(first, second, SUPER1_SIZE);
 		st->sb = first;
 		return 0;
 	}
@@ -1084,8 +1292,6 @@ static int compare_super1(struct supertype *st, struct supertype *tst)
 	return 0;
 }
 
-static void free_super1(struct supertype *st);
-
 static int load_super1(struct supertype *st, int fd, char *devname)
 {
 	unsigned long long dsize;
@@ -1094,11 +1300,11 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 	int uuid[4];
 	struct bitmap_super_s *bsb;
 	struct misc_dev_info *misc;
+	struct align_fd afd;
 
 	free_super1(st);
 
-	if (st->subarray[0])
-		return 1;
+	init_afd(&afd, fd);
 
 	if (st->ss == NULL || st->minor_version == -1) {
 		int bestvers = -1;
@@ -1126,7 +1332,7 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 			int rv;
 			tst.minor_version = bestvers;
 			tst.ss = &super1;
-			tst.max_devs = 384;
+			tst.max_devs = MAX_DEVS;
 			rv = load_super1(&tst, fd, devname);
 			if (rv == 0)
 				*st = tst;
@@ -1140,7 +1346,7 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 
 	if (dsize < 24) {
 		if (devname)
-			fprintf(stderr, Name ": %s is too small for md: size is %llu sectors.\n",
+			pr_err("%s is too small for md: size is %llu sectors.\n",
 				devname, dsize);
 		return 1;
 	}
@@ -1174,22 +1380,20 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 
 	if (lseek64(fd, sb_offset << 9, 0)< 0LL) {
 		if (devname)
-			fprintf(stderr, Name ": Cannot seek to superblock on %s: %s\n",
+			pr_err("Cannot seek to superblock on %s: %s\n",
 				devname, strerror(errno));
 		return 1;
 	}
 
-	if (posix_memalign((void**)&super, 512,
-		       1024 + 512 +
-		       sizeof(struct misc_dev_info)) != 0) {
-		fprintf(stderr, Name ": %s could not allocate superblock\n",
+	if (posix_memalign((void**)&super, 4096, SUPER1_SIZE) != 0) {
+		pr_err("%s could not allocate superblock\n",
 			__func__);
 		return 1;
 	}
 
-	if (read(fd, super, 1024) != 1024) {
+	if (aread(&afd, super, MAX_SB_SIZE) != MAX_SB_SIZE) {
 		if (devname)
-			fprintf(stderr, Name ": Cannot read superblock on %s\n",
+			pr_err("Cannot read superblock on %s\n",
 				devname);
 		free(super);
 		return 1;
@@ -1197,7 +1401,7 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 
 	if (__le32_to_cpu(super->magic) != MD_SB_MAGIC) {
 		if (devname)
-			fprintf(stderr, Name ": No super block found on %s (Expected magic %08x, got %08x)\n",
+			pr_err("No super block found on %s (Expected magic %08x, got %08x)\n",
 				devname, MD_SB_MAGIC, __le32_to_cpu(super->magic));
 		free(super);
 		return 2;
@@ -1205,23 +1409,23 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 
 	if (__le32_to_cpu(super->major_version) != 1) {
 		if (devname)
-			fprintf(stderr, Name ": Cannot interpret superblock on %s - version is %d\n",
+			pr_err("Cannot interpret superblock on %s - version is %d\n",
 				devname, __le32_to_cpu(super->major_version));
 		free(super);
 		return 2;
 	}
 	if (__le64_to_cpu(super->super_offset) != sb_offset) {
 		if (devname)
-			fprintf(stderr, Name ": No superblock found on %s (super_offset is wrong)\n",
+			pr_err("No superblock found on %s (super_offset is wrong)\n",
 				devname);
 		free(super);
 		return 2;
 	}
 	st->sb = super;
 
-	bsb = (struct bitmap_super_s *)(((char*)super)+1024);
+	bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE);
 
-	misc = (struct misc_dev_info*) (((char*)super)+1024+512);
+	misc = (struct misc_dev_info*) (((char*)super)+MAX_SB_SIZE+BM_SUPER_SIZE);
 	misc->device_size = dsize;
 
 	/* Now check on the bitmap superblock */
@@ -1232,8 +1436,7 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 	 * should get that written out.
 	 */
 	locate_bitmap1(st, fd);
-	if (read(fd, ((char*)super)+1024, 512)
-	    != 512)
+	if (aread(&afd, bsb, 512) != 512)
 		goto no_bitmap;
 
 	uuid_from_super1(st, uuid);
@@ -1243,19 +1446,21 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 	return 0;
 
  no_bitmap:
-	super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map) & ~1);
+	super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map)
+					   & ~MD_FEATURE_BITMAP_OFFSET);
 	return 0;
 }
 
 
 static struct supertype *match_metadata_desc1(char *arg)
 {
-	struct supertype *st = malloc(sizeof(*st));
-	if (!st) return st;
+	struct supertype *st = calloc(1, sizeof(*st));
+	if (!st)
+		return st;
 
-	memset(st, 0, sizeof(*st));
+	st->container_dev = NoMdDev;
 	st->ss = &super1;
-	st->max_devs = 384;
+	st->max_devs = MAX_DEVS;
 	st->sb = NULL;
 	/* leading zeros can be safely ignored.  --detail generates them. */
 	while (*arg == '0')
@@ -1266,11 +1471,15 @@ static struct supertype *match_metadata_desc1(char *arg)
 		return st;
 	}
 	if (strcmp(arg, "1.1") == 0 ||
-	    strcmp(arg, "1.01") == 0) {
+	    strcmp(arg, "1.01") == 0
+		) {
 		st->minor_version = 1;
 		return st;
 	}
 	if (strcmp(arg, "1.2") == 0 ||
+#ifndef DEFAULT_OLD_METADATA /* ifdef in super0.c */
+	    strcmp(arg, "default") == 0 ||
+#endif /* DEFAULT_OLD_METADATA */
 	    strcmp(arg, "1.02") == 0) {
 		st->minor_version = 2;
 		return st;
@@ -1302,15 +1511,25 @@ static __u64 avail_size1(struct supertype *st, __u64 devsize)
 	else if (__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) {
 		/* hot-add. allow for actual size of bitmap */
 		struct bitmap_super_s *bsb;
-		bsb = (struct bitmap_super_s *)(((char*)super)+1024);
+		bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE);
 		devsize -= bitmap_sectors(bsb);
 	}
 #endif
 
+	if (st->minor_version < 0)
+		/* not specified, so time to set default */
+		st->minor_version = 2;
+	if (super == NULL && st->minor_version > 0) {
+		/* haven't committed to a size yet, so allow some
+		 * slack for space for reshape.
+		 * Limit slack to 128M, but aim for about 0.1%
+		 */
+		unsigned long long headroom = 128*1024*2;
+		while ((headroom << 10) > devsize)
+			headroom >>= 1;
+		devsize -= headroom;
+	}
 	switch(st->minor_version) {
-	case -1: /* no specified.  Now time to set default */
-		st->minor_version = 0;
-		/* FALL THROUGH */
 	case 0:
 		/* at end */
 		return ((devsize - 8*2 ) & ~(4*2-1));
@@ -1331,12 +1550,10 @@ add_internal_bitmap1(struct supertype *st,
 		     int may_change, int major)
 {
 	/*
-	 * If not may_change, then this is a 'Grow', and the bitmap
-	 * must fit after the superblock.
-	 * If may_change, then this is create, and we can put the bitmap
-	 * before the superblock if we like, or may move the start.
-	 * If !may_change, the bitmap MUST live at offset of 1K, until
-	 * we get a sysfs interface.
+	 * If not may_change, then this is a 'Grow' without sysfs support for
+	 * bitmaps, and the bitmap must fit after the superblock at 1K offset.
+	 * If may_change, then this is create or a Grow with sysfs syupport,
+	 * and we can put the bitmap wherever we like.
 	 *
 	 * size is in sectors,  chunk is in bytes !!!
 	 */
@@ -1345,33 +1562,33 @@ add_internal_bitmap1(struct supertype *st,
 	unsigned long long max_bits;
 	unsigned long long min_chunk;
 	long offset;
-	int chunk = *chunkp;
+	unsigned long long chunk = *chunkp;
 	int room = 0;
+	int creating = 0;
 	struct mdp_superblock_1 *sb = st->sb;
-	bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + 1024);
+	bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MAX_SB_SIZE);
+	int uuid[4];
 
+	if (__le64_to_cpu(sb->data_size) == 0)
+		/* Must be creating the array, else data_size would be non-zero */
+		creating = 1;
 	switch(st->minor_version) {
 	case 0:
-		/* either 3K after the superblock, or some amount of space
-		 * before.
+		/* either 3K after the superblock (when hot-add),
+		 * or some amount of space before.
 		 */
-		if (may_change) {
+		if (creating) {
 			/* We are creating array, so we *know* how much room has
 			 * been left.
 			 */
 			offset = 0;
 			room = choose_bm_space(__le64_to_cpu(sb->size));
-			if (room == 4*2) {
-				/* make it 3K after the superblock */
-				room = 3*2;
-				offset = 2;
-			}
 		} else {
 			room = __le64_to_cpu(sb->super_offset)
 				- __le64_to_cpu(sb->data_offset)
 				- __le64_to_cpu(sb->data_size);
-			/* remove '1 ||' when we can set offset via sysfs */
-			if (1 || (room < 3*2 &&
+
+			if (!may_change || (room < 3*2 &&
 				  __le32_to_cpu(sb->max_dev) <= 384)) {
 				room = 3*2;
 				offset = 1*2;
@@ -1382,17 +1599,17 @@ add_internal_bitmap1(struct supertype *st,
 		break;
 	case 1:
 	case 2: /* between superblock and data */
-		if (may_change) {
+		if (creating) {
 			offset = 4*2;
 			room = choose_bm_space(__le64_to_cpu(sb->size));
 		} else {
 			room = __le64_to_cpu(sb->data_offset)
 				- __le64_to_cpu(sb->super_offset);
-			if (1 || __le32_to_cpu(sb->max_dev) <= 384) {
-				room -= 2;
+			if (!may_change) {
+				room -= 2; /* Leave 1K for superblock */
 				offset = 2;
 			} else {
-				room -= 4*2;
+				room -= 4*2; /* leave 4K for superblock */
 				offset = 4*2;
 			}
 		}
@@ -1413,26 +1630,37 @@ add_internal_bitmap1(struct supertype *st,
 		min_chunk *= 2;
 		bits = (bits+1)/2;
 	}
-	if (chunk == UnSet)
+	if (chunk == UnSet) {
+		/* For practical purpose, 64Meg is a good
+		 * default chunk size for internal bitmaps.
+		 */
 		chunk = min_chunk;
-	else if (chunk < min_chunk)
+		if (chunk < 64*1024*1024)
+			chunk = 64*1024*1024;
+	} else if (chunk < min_chunk)
 		return 0; /* chunk size too small */
 	if (chunk == 0) /* rounding problem */
 		return 0;
 
 	if (offset == 0) {
+		/* start bitmap on a 4K boundary with enough space for
+		 * the bitmap
+		 */
 		bits = (size*512) / chunk + 1;
-		room = ((bits+7)/8 + sizeof(bitmap_super_t) +511)/512;
+		room = ((bits+7)/8 + sizeof(bitmap_super_t) +4095)/4096;
+		room *= 8; /* convert 4K blocks to sectors */
 		offset = -room;
 	}
 
-	sb->bitmap_offset = __cpu_to_le32(offset);
+	sb->bitmap_offset = (int32_t)__cpu_to_le32(offset);
 
-	sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | 1);
+	sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map)
+					| MD_FEATURE_BITMAP_OFFSET);
 	memset(bms, 0, sizeof(*bms));
 	bms->magic = __cpu_to_le32(BITMAP_MAGIC);
 	bms->version = __cpu_to_le32(major);
-	uuid_from_super1(st, (int*)bms->uuid);
+	uuid_from_super1(st, uuid);
+	memcpy(bms->uuid, uuid, 16);
 	bms->chunksize = __cpu_to_le32(chunk);
 	bms->daemon_sleep = __cpu_to_le32(delay);
 	bms->sync_size = __cpu_to_le64(size);
@@ -1442,7 +1670,6 @@ add_internal_bitmap1(struct supertype *st,
 	return 1;
 }
 
-
 static void locate_bitmap1(struct supertype *st, int fd)
 {
 	unsigned long long offset;
@@ -1466,17 +1693,21 @@ static void locate_bitmap1(struct supertype *st, int fd)
 static int write_bitmap1(struct supertype *st, int fd)
 {
 	struct mdp_superblock_1 *sb = st->sb;
-	bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+1024);
+	bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+MAX_SB_SIZE);
 	int rv = 0;
-
+	void *buf;
 	int towrite, n;
-	char abuf[4096+512];
-	char *buf = (char*)(((long)(abuf+512))&~511UL);
+	struct align_fd afd;
+
+	init_afd(&afd, fd);
 
 	locate_bitmap1(st, fd);
 
+	if (posix_memalign(&buf, 4096, 4096))
+		return -ENOMEM;
+
 	memset(buf, 0xff, 4096);
-	memcpy(buf, ((char*)sb)+1024, sizeof(bitmap_super_t));
+	memcpy(buf, (char *)bms, sizeof(bitmap_super_t));
 
 	towrite = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9);
 	towrite = (towrite+7) >> 3; /* bits to bytes */
@@ -1486,7 +1717,7 @@ static int write_bitmap1(struct supertype *st, int fd)
 		n = towrite;
 		if (n > 4096)
 			n = 4096;
-		n = write(fd, buf, n);
+		n = awrite(&afd, buf, n);
 		if (n > 0)
 			towrite -= n;
 		else
@@ -1497,6 +1728,7 @@ static int write_bitmap1(struct supertype *st, int fd)
 	if (towrite)
 		rv = -2;
 
+	free(buf);
 	return rv;
 }
 
@@ -1504,28 +1736,41 @@ static void free_super1(struct supertype *st)
 {
 	if (st->sb)
 		free(st->sb);
+	while (st->info) {
+		struct devinfo *di = st->info;
+		st->info = di->next;
+		if (di->fd >= 0)
+			close(di->fd);
+		free(di);
+	}
 	st->sb = NULL;
 }
 
 #ifndef MDASSEMBLE
 static int validate_geometry1(struct supertype *st, int level,
 			      int layout, int raiddisks,
-			      int chunk, unsigned long long size,
+			      int *chunk, unsigned long long size,
 			      char *subdev, unsigned long long *freesize,
 			      int verbose)
 {
 	unsigned long long ldsize;
 	int fd;
 
-	if (level == LEVEL_CONTAINER)
+	if (level == LEVEL_CONTAINER) {
+		if (verbose)
+			pr_err("1.x metadata does not support containers\n");
 		return 0;
+	}
+	if (chunk && *chunk == UnSet)
+		*chunk = DEFAULT_CHUNK;
+
 	if (!subdev)
 		return 1;
 
 	fd = open(subdev, O_RDONLY|O_EXCL, 0);
 	if (fd < 0) {
 		if (verbose)
-			fprintf(stderr, Name ": super1.x cannot open %s: %s\n",
+			pr_err("super1.x cannot open %s: %s\n",
 				subdev, strerror(errno));
 		return 0;
 	}
@@ -1556,6 +1801,7 @@ struct superswitch super1 = {
 	.match_home = match_home1,
 	.uuid_from_super = uuid_from_super1,
 	.getinfo_super = getinfo_super1,
+	.container_content = container_content1,
 	.update_super = update_super1,
 	.init_super = init_super1,
 	.store_super = store_super1,
@@ -1572,4 +1818,5 @@ struct superswitch super1 = {
 #else
 	.swapuuid = 1,
 #endif
+	.name = "1.x",
 };