X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super1.c;h=4e380d98a4c3b6c918f515cd00247c6065a72e69;hb=def1133297d8f619c8fd644d6d8c6633ddcaa929;hp=9299322fff9c4844a440c5619059619b1ceb51df;hpb=bb7295f15e02d8cd8b52de14f40c1d7e10555cc9;p=thirdparty%2Fmdadm.git

diff --git a/super1.c b/super1.c
index 9299322f..4e380d98 100644
--- a/super1.c
+++ b/super1.c
@@ -58,7 +58,10 @@ struct mdp_superblock_1 {
 	__u32	delta_disks;	/* change in number of raid_disks		*/
 	__u32	new_layout;	/* new layout					*/
 	__u32	new_chunk;	/* new chunk size (bytes)			*/
-	__u8	pad1[128-124];	/* set to 0 when written */
+	__u32	new_offset;	/* signed number to add to data_offset in new
+				 * layout.  0 == no-change.  This can be
+				 * different on each device in the array.
+				 */
 
 	/* constant this-device information - 64 bytes */
 	__u64	data_offset;	/* sector start of data, often 0 */
@@ -68,9 +71,14 @@ struct mdp_superblock_1 {
 	__u32	dev_number;	/* permanent identifier of this  device - not role in raid */
 	__u32	cnt_corrected_read; /* number of read errors that were corrected by re-writing */
 	__u8	device_uuid[16]; /* user-space setable, ignored by kernel */
-        __u8    devflags;        /* per-device flags.  Only one defined...*/
+	__u8    devflags;        /* per-device flags.  Only one defined...*/
 #define WriteMostly1    1        /* mask for writemostly flag in above */
-	__u8	pad2[64-57];	/* set to 0 when writing */
+	/* bad block log.  If there are any bad blocks the feature flag is set.
+	 * if offset and size are non-zero, that space is reserved and available.
+	 */
+	__u8	bblog_shift;	/* shift from sectors to block size for badblocklist */
+	__u16	bblog_size;	/* number of sectors reserved for badblocklist */
+	__u32	bblog_offset;	/* sector offset from superblock to bblog, signed */
 
 	/* array state information - 64 bytes */
 	__u64	utime;		/* 40 bits second, 24 btes microseconds */
@@ -89,6 +97,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;
 };
@@ -99,8 +114,24 @@ struct misc_dev_info {
 					   * must be honoured
 					   */
 #define	MD_FEATURE_RESHAPE_ACTIVE	4
-
-#define	MD_FEATURE_ALL			(1|2|4)
+#define	MD_FEATURE_BAD_BLOCKS		8 /* badblock list is not empty */
+#define	MD_FEATURE_REPLACEMENT		16 /* This device is replacing an
+					    * active device with same 'role'.
+					    * 'recovery_offset' is also set.
+					    */
+#define	MD_FEATURE_RESHAPE_BACKWARDS	32 /* Reshape doesn't change number
+					    * of devices, but is going
+					    * backwards anyway.
+					    */
+#define	MD_FEATURE_NEW_OFFSET		64 /* new_offset must be honoured */
+#define	MD_FEATURE_ALL			(MD_FEATURE_BITMAP_OFFSET	\
+					|MD_FEATURE_RECOVERY_OFFSET	\
+					|MD_FEATURE_RESHAPE_ACTIVE	\
+					|MD_FEATURE_BAD_BLOCKS		\
+					|MD_FEATURE_REPLACEMENT		\
+					|MD_FEATURE_RESHAPE_BACKWARDS	\
+					|MD_FEATURE_NEW_OFFSET		\
+					)
 
 #ifndef offsetof
 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
@@ -111,7 +142,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 ||
@@ -123,7 +153,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++;
 	}
@@ -136,35 +166,58 @@ 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(int fd, void *buf, int len)
+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;
+	int bsize, iosize;
 	char *b;
 	int n;
-	if (ioctl(fd, BLKSSZGET, &bsize) != 0 ||
-	    bsize <= len)
-		return read(fd, buf, len);
-	if (bsize > 4096)
+
+	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 = (char*)(((long)(abuf+4096))&~4095UL);
+	}
+	b = ROUND_UP_PTR((char *)abuf, 4096);
 
-	n = read(fd, b, bsize);
+	for (iosize = 0; iosize < len; iosize += bsize)
+		;
+	n = read(afd->fd, b, iosize);
 	if (n <= 0)
 		return n;
-	lseek(fd, len - n, 1);
+	lseek(afd->fd, len - n, 1);
 	if (n > len)
 		n = len;
 	memcpy(buf, b, n);
 	return n;
 }
 
-static int awrite(int fd, void *buf, int len)
+static int awrite(struct align_fd *afd, void *buf, int len)
 {
 	/* aligned write.
 	 * On devices with a 4K sector size, we need to write
@@ -172,25 +225,34 @@ static int awrite(int fd, void *buf, int len)
 	 * than the write.
 	 * The address must be sector-aligned.
 	 */
-	int bsize;
+	int bsize, iosize;
 	char *b;
 	int n;
-	if (ioctl(fd, BLKSSZGET, &bsize) != 0 ||
-	    bsize <= len)
-		return write(fd, buf, len);
-	if (bsize > 4096)
+
+	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 = (char*)(((long)(abuf+4096))&~4095UL);
+	}
+	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);
+	}
 
-	n = read(fd, b, bsize);
-	if (n <= 0)
-		return n;
-	lseek(fd, -n, 1);
 	memcpy(b, buf, len);
-	n = write(fd, b, bsize);
+	n = write(afd->fd, b, iosize);
 	if (n <= 0)
 		return n;
-	lseek(fd, len - n, 1);
+	lseek(afd->fd, len - n, 1);
 	return len;
 }
 
@@ -240,7 +302,7 @@ static void examine_super1(struct supertype *st, char *homehost)
 	       (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;
+		int ddsks = 0, ddsks_denom = 1;
 		switch(__le32_to_cpu(sb->level)) {
 		case 1: ddsks=1;break;
 		case 4:
@@ -248,13 +310,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),
@@ -263,6 +327,11 @@ static void examine_super1(struct supertype *st, char *homehost)
 	if (sb->data_offset)
 		printf("    Data Offset : %llu sectors\n",
 		       (unsigned long long)__le64_to_cpu(sb->data_offset));
+	if (sb->new_offset) {
+		unsigned long long offset = __le64_to_cpu(sb->data_offset);
+		offset += (signed)(int32_t)__le32_to_cpu(sb->new_offset);
+		printf("     New Offset : %llu sectors\n", offset);
+	}
 	printf("   Super Offset : %llu sectors\n",
 	       (unsigned long long)__le64_to_cpu(sb->super_offset));
 	if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET)
@@ -279,7 +348,7 @@ static void examine_super1(struct supertype *st, char *homehost)
 		printf("Internal Bitmap : %ld sectors from superblock\n",
 		       (long)(int32_t)__le32_to_cpu(sb->bitmap_offset));
 	}
-	if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
+	if (sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)) {
 		printf("  Reshape pos'n : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->reshape_position)/2,
 		       human_size(__le64_to_cpu(sb->reshape_position)<<9));
 		if (__le32_to_cpu(sb->delta_disks)) {
@@ -314,7 +383,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");
@@ -323,6 +392,17 @@ static void examine_super1(struct supertype *st, char *homehost)
 	atime = __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL;
 	printf("    Update Time : %.24s\n", ctime(&atime));
 
+	if (sb->bblog_size && sb->bblog_offset) {
+		printf("  Bad Block Log : %d entries available at offset %ld sectors",
+		       __le16_to_cpu(sb->bblog_size)*512/8,
+		       (long)__le32_to_cpu(sb->bblog_offset));
+		if (sb->feature_map &
+		    __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
+			printf(" - bad blocks present.");
+		printf("\n");
+	}
+
+
 	if (calc_sb_1_csum(sb) == sb->sb_csum)
 		printf("       Checksum : %x - correct\n", __le32_to_cpu(sb->sb_csum));
 	else
@@ -381,25 +461,28 @@ static void examine_super1(struct supertype *st, char *homehost)
 		role = 0xFFFF;
 	if (role >= 0xFFFE)
 		printf("spare\n");
+	else if (sb->feature_map & __cpu_to_le32(MD_FEATURE_REPLACEMENT))
+		printf("Replacement device %d\n", role);
 	else
 		printf("Active device %d\n", role);
 
 	printf("   Array State : ");
 	for (d=0; d<__le32_to_cpu(sb->raid_disks) + delta_extra; d++) {
 		int cnt = 0;
-		int me = 0;
 		unsigned int i;
 		for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
 			unsigned int role = __le16_to_cpu(sb->dev_roles[i]);
-			if (role == d) {
-				if (i == __le32_to_cpu(sb->dev_number))
-					me = 1;
+			if (role == d)
 				cnt++;
-			}
 		}
-		if (cnt > 1) printf("?");
-		else if (cnt == 1) printf("A");
-		else printf (".");
+		if (cnt == 2)
+			printf("R");
+		else if (cnt == 1)
+			printf("A");
+		else if (cnt == 0)
+			printf(".");
+		else
+			printf("?");
 	}
 #if 0
 	/* This is confusing too */
@@ -411,7 +494,7 @@ static void examine_super1(struct supertype *st, char *homehost)
 	}
 	if (faulty) printf(" %d failed", faulty);
 #endif
-	printf(" ('A' == active, '.' == missing)");
+	printf(" ('A' == active, '.' == missing, 'R' == replacing)");
 	printf("\n");
 }
 
@@ -432,7 +515,12 @@ static void brief_examine_super1(struct supertype *st, int verbose)
 	else
 		nm = NULL;
 
-	printf("ARRAY%s%s", nm ? " /dev/md/":"", nm);
+	printf("ARRAY ");
+	if (nm) {
+		printf("/dev/md/");
+		print_escape(nm);
+		putchar(' ');
+	}
 	if (verbose && c)
 		printf(" level=%s", c);
 	sb_offset = __le64_to_cpu(sb->super_offset);
@@ -449,8 +537,10 @@ static void brief_examine_super1(struct supertype *st, int verbose)
 		if ((i&3)==0 && i != 0) printf(":");
 		printf("%02x", sb->set_uuid[i]);
 	}
-	if (sb->set_name[0])
-		printf(" name=%.32s", sb->set_name);
+	if (sb->set_name[0]) {
+		printf(" name=");
+		print_quoted(sb->set_name);
+	}
 	printf("\n");
 }
 
@@ -459,6 +549,7 @@ static void export_examine_super1(struct supertype *st)
 	struct mdp_superblock_1 *sb = st->sb;
 	int i;
 	int len = 32;
+	int layout;
 
 	printf("MD_LEVEL=%s\n", map_num(pers, __le32_to_cpu(sb->level)));
 	printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks));
@@ -470,6 +561,24 @@ static void export_examine_super1(struct supertype *st)
 		}
 	if (len)
 		printf("MD_NAME=%.*s\n", len, sb->set_name);
+	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:
+			case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break;
+			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);
+				ddsks_denom = (layout&255) * ((layout>>8)&255);
+			}
+		if (ddsks) {
+			long long asize = __le64_to_cpu(sb->size);
+			asize = (asize << 9) * ddsks / ddsks_denom;
+			printf("MD_ARRAY_SIZE=%s\n",human_size_brief(asize,JEDEC));
+		}
+	}
 	printf("MD_UUID=");
 	for (i=0; i<16; i++) {
 		if ((i&3)==0 && i != 0) printf(":");
@@ -512,8 +621,10 @@ static void brief_detail_super1(struct supertype *st)
 	struct mdp_superblock_1 *sb = st->sb;
 	int i;
 
-	if (sb->set_name[0])
-		printf(" name=%.32s", sb->set_name);
+	if (sb->set_name[0]) {
+		printf(" name=");
+		print_quoted(sb->set_name);
+	}
 	printf(" UUID=");
 	for (i=0; i<16; i++) {
 		if ((i&3)==0 && i != 0) printf(":");
@@ -537,6 +648,59 @@ static void export_detail_super1(struct supertype *st)
 		printf("MD_NAME=%.*s\n", len, sb->set_name);
 }
 
+static int examine_badblocks_super1(struct supertype *st, int fd, char *devname)
+{
+	struct mdp_superblock_1 *sb = st->sb;
+	unsigned long long offset;
+	int size;
+	__u64 *bbl, *bbp;
+	int i;
+
+	if  (!sb->bblog_size || __le32_to_cpu(sb->bblog_size) > 100
+	     || !sb->bblog_offset){
+		printf("No bad-blocks list configured on %s\n", devname);
+		return 0;
+	}
+	if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
+	    == 0) {
+		printf("Bad-blocks list is empty in %s\n", devname);
+		return 0;
+	}
+
+	size = __le32_to_cpu(sb->bblog_size)* 512;
+	posix_memalign((void**)&bbl, 4096, size);
+	offset = __le64_to_cpu(sb->super_offset) +
+		(int)__le32_to_cpu(sb->bblog_offset);
+	offset <<= 9;
+	if (lseek64(fd, offset, 0) < 0) {
+		pr_err("Cannot seek to bad-blocks list\n");
+		return 1;
+	}
+	if (read(fd, bbl, size) != size) {
+		pr_err("Cannot read bad-blocks list\n");
+		return 1;
+	}
+	/* 64bits per entry. 10 bits is block-count, 54 bits is block
+	 * offset.  Blocks are sectors unless bblog->shift makes them bigger
+	 */
+	bbp = (__u64*)bbl;
+	printf("Bad-blocks on %s:\n", devname);
+	for (i = 0; i < size/8; i++, bbp++) {
+		__u64 bb = __le64_to_cpu(*bbp);
+		int count = bb & 0x3ff;
+		unsigned long long sector = bb >> 10;
+
+		if (bb + 1 == 0)
+			break;
+
+		sector <<= sb->bblog_shift;
+		count <<= sb->bblog_shift;
+
+		printf("%20llu for %d sectors\n", sector, count);
+	}
+	return 0;
+}
+
 #endif
 
 static int match_home1(struct supertype *st, char *homehost)
@@ -561,11 +725,16 @@ static void uuid_from_super1(struct supertype *st, int uuid[4])
 static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 {
 	struct mdp_superblock_1 *sb = st->sb;
+	struct bitmap_super_s *bsb = (void*)(((char*)sb)+MAX_SB_SIZE);
+	struct misc_dev_info *misc = (void*)(((char*)sb)+MAX_SB_SIZE+BM_SUPER_SIZE);
 	int working = 0;
 	unsigned int i;
 	unsigned int role;
 	unsigned int map_disks = info->array.raid_disks;
+	unsigned long long super_offset;
+	unsigned long long data_size;
 
+	memset(info, 0, sizeof(*info));
 	info->array.major_version = 1;
 	info->array.minor_version = st->minor_version;
 	info->array.patch_version = 0;
@@ -577,21 +746,56 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 	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)]);
 
+	super_offset = __le64_to_cpu(sb->super_offset);
+	data_size = __le64_to_cpu(sb->size);
+	if (info->data_offset < super_offset) {
+		unsigned long long end;
+		info->space_before = info->data_offset;
+		end = super_offset;
+		if (info->bitmap_offset < 0)
+			end += info->bitmap_offset;
+		if (info->data_offset + data_size < end)
+			info->space_after = end - data_size - info->data_offset;
+		else
+			info->space_after = 0;
+	} else {
+		info->space_before = (info->data_offset -
+				      super_offset);
+		if (info->bitmap_offset > 0) {
+			unsigned long long bmend = info->bitmap_offset;
+			unsigned long long size = __le64_to_cpu(bsb->sync_size);
+			size /= __le32_to_cpu(bsb->chunksize) >> 9;
+			size = (size + 7) >> 3;
+			size += sizeof(bitmap_super_t);
+			size = ROUND_UP(size, 4096);
+			size /= 512;
+			size += bmend;
+			if (size < info->space_before)
+				info->space_before -= size;
+			else
+				info->space_before = 0;
+		} else
+			info->space_before -= 8; /* superblock */
+		info->space_after = misc->device_size - data_size - info->data_offset;
+	}
+
 	info->disk.raid_disk = -1;
 	switch(role) {
 	case 0xFFFF:
@@ -604,6 +808,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 		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;
@@ -613,6 +819,12 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 	strncpy(info->name, sb->set_name, 32);
 	info->name[32] = 0;
 
+	if ((__le32_to_cpu(sb->feature_map)&MD_FEATURE_REPLACEMENT)) {
+		info->disk.state &= ~(1 << MD_DISK_SYNC);
+		info->disk.state |=  1 << MD_DISK_REPLACEMENT;
+	}
+
+
 	if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RECOVERY_OFFSET))
 		info->recovery_start = __le32_to_cpu(sb->recovery_offset);
 	else
@@ -620,6 +832,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 
 	if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
 		info->reshape_active = 1;
+		if (info->array.level == 10)
+			info->reshape_active |= RESHAPE_NO_BACKUP;
 		info->reshape_progress = __le64_to_cpu(sb->reshape_position);
 		info->new_level = __le32_to_cpu(sb->new_level);
 		info->delta_disks = __le32_to_cpu(sb->delta_disks);
@@ -630,6 +844,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 	} else
 		info->reshape_active = 0;
 
+	info->recovery_blocked = info->reshape_active;
+
 	if (map)
 		for (i=0; i<map_disks; i++)
 			map[i] = 0;
@@ -652,7 +868,7 @@ static struct mdinfo *container_content1(struct supertype *st, char *subarray)
 	if (subarray)
 		return NULL;
 
-	info = malloc(sizeof(*info));
+	info = xmalloc(sizeof(*info));
 	getinfo_super1(st, info, NULL);
 	return info;
 }
@@ -669,6 +885,21 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 	int rv = 0;
 	struct mdp_superblock_1 *sb = st->sb;
 
+	if (strcmp(update, "homehost") == 0 &&
+	    homehost) {
+		/* Note that 'homehost' is special as it is really
+		 * a "name" update.
+		 */
+		char *c;
+		update = "name";
+		c = strchr(sb->set_name, ':');
+		if (c)
+			strncpy(info->name, c+1, 31 - (c-sb->set_name));
+		else
+			strncpy(info->name, sb->set_name, 32);
+		info->name[32] = 0;
+	}
+
 	if (strcmp(update, "force-one")==0) {
 		/* Not enough devices for a working array,
 		 * so bring this one up-to-date
@@ -690,7 +921,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 	} else if (strcmp(update, "assemble")==0) {
 		int d = info->disk.number;
 		int want;
-		if (info->disk.state == 6)
+		if (info->disk.state & (1<<MD_DISK_ACTIVE))
 			want = info->disk.raid_disk;
 		else
 			want = 0xFFFF;
@@ -698,6 +929,20 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 			sb->dev_roles[d] = __cpu_to_le16(want);
 			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;
+		}
+		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;
@@ -752,21 +997,61 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 
 		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);
 		}
 	} 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, ':');
-		if (c)
-			strncpy(info->name, c+1, 31 - (c-sb->set_name));
-		else
-			strncpy(info->name, sb->set_name, 32);
-		info->name[32] = 0;
+	} else if (strcmp(update, "bbl") == 0) {
+		/* only possible if there is room after the bitmap, or if
+		 * there is no bitmap
+		 */
+		unsigned long long sb_offset = __le64_to_cpu(sb->super_offset);
+		unsigned long long data_offset = __le64_to_cpu(sb->data_offset);
+		long bitmap_offset = (long)__le64_to_cpu(sb->bitmap_offset);
+		long bm_sectors = 0;
+		long space;
+
+		if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
+			struct bitmap_super_s *bsb;
+			bsb = (struct bitmap_super_s *)(((char*)sb)+MAX_SB_SIZE);
+			bm_sectors = bitmap_sectors(bsb);
+		}
+
+		if (sb_offset < data_offset) {
+			/* 1.1 or 1.2.  Put bbl just before data
+			 */
+			long bb_offset;
+			space = data_offset - sb_offset;
+			bb_offset = space - 8;
+			if (bm_sectors && bitmap_offset > 0)
+				space -= (bitmap_offset + bm_sectors);
+			else
+				space -= 8; /* The superblock */
+			if (space >= 8) {
+				sb->bblog_size = __cpu_to_le16(8);
+				sb->bblog_offset = __cpu_to_le32(bb_offset);
+			}
+		} else {
+			/* 1.0 - Put bbl just before super block */
+			if (bm_sectors && bitmap_offset < 0)
+				space = -bitmap_offset - bm_sectors;
+			else
+				space = sb_offset - data_offset -
+					__le64_to_cpu(sb->data_size);
+			if (space >= 8) {
+				sb->bblog_size = __cpu_to_le16(8);
+				sb->bblog_offset = __cpu_to_le32((unsigned)-8);
+			}
+		}
+	} else if (strcmp(update, "no-bbl") == 0) {
+		if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
+			pr_err("Cannot remove active bbl from %s\n",devname);
+		else {
+			sb->bblog_size = 0;
+			sb->bblog_shift = 0;
+			sb->bblog_offset = 0;
+		}
 	} else if (strcmp(update, "name") == 0) {
 		if (info->name[0] == 0)
 			sprintf(info->name, "%d", info->array.md_minor);
@@ -784,7 +1069,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 	    __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(
@@ -793,6 +1078,10 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 		       __le64_to_cpu(sb->data_size));
 	} 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;
 
@@ -801,20 +1090,20 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 }
 
 static int init_super1(struct supertype *st, mdu_array_info_t *info,
-		       unsigned long long size, char *name, char *homehost, int *uuid)
+		       unsigned long long size, char *name, char *homehost,
+		       int *uuid, unsigned long long data_offset)
 {
 	struct mdp_superblock_1 *sb;
 	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) {
@@ -823,9 +1112,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;
 	}
 
@@ -849,7 +1138,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) {
@@ -866,7 +1154,7 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 	sb->chunksize = __cpu_to_le32(info->chunk_size>>9);
 	sb->raid_disks = __cpu_to_le32(info->raid_disks);
 
-	sb->data_offset = __cpu_to_le64(0);
+	sb->data_offset = __cpu_to_le64(data_offset);
 	sb->data_size = __cpu_to_le64(0);
 	sb->super_offset = __cpu_to_le64(0);
 	sb->recovery_offset = __cpu_to_le64(0);
@@ -877,11 +1165,11 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 		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;
 }
@@ -889,13 +1177,14 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 struct devinfo {
 	int fd;
 	char *devname;
+	long long data_offset;
 	mdu_disk_info_t disk;
 	struct devinfo *next;
 };
 #ifndef MDASSEMBLE
 /* Add a device to the superblock being created */
 static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
-			  int fd, char *devname)
+			 int fd, char *devname, unsigned long long data_offset)
 {
 	struct mdp_superblock_1 *sb = st->sb;
 	__u16 *rp = sb->dev_roles + dk->number;
@@ -909,19 +1198,21 @@ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
 		*rp = 0xfffe;
 
 	if (dk->number >= (int)__le32_to_cpu(sb->max_dev) &&
-	    __le32_to_cpu(sb->max_dev) < 384)
+	    __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;
 	while (*dip)
 		dip = &(*dip)->next;
-	di = malloc(sizeof(struct devinfo));
+	di = xmalloc(sizeof(struct devinfo));
 	di->fd = fd;
 	di->devname = devname;
 	di->disk = *dk;
+	di->data_offset = data_offset;
 	di->next = NULL;
 	*dip = di;
 
@@ -935,6 +1226,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;
 
@@ -946,6 +1238,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
@@ -975,27 +1269,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 (awrite(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 (awrite(fd, bm, sizeof(*bm)) !=
-			    sizeof(*bm))
-			    return 5;
+			if (awrite(&afd, bm, sizeof(*bm)) != sizeof(*bm))
+				return 5;
 		}
 	}
 	fsync(fd);
@@ -1032,20 +1324,23 @@ static int write_init_super1(struct supertype *st)
 	unsigned long long reserved;
 	struct devinfo *di;
 	unsigned long long dsize, array_size;
-	unsigned long long sb_offset;
+	unsigned long long sb_offset, headroom;
+	unsigned long long data_offset;
 
-	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;
 
-		while (Kill(di->devname, NULL, 0, 1, 1) == 0)
+		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) {
@@ -1076,13 +1371,16 @@ static int write_init_super1(struct supertype *st)
 		}
 		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;
 		}
 
 
@@ -1095,73 +1393,125 @@ static int write_init_super1(struct supertype *st)
 		 * 2: 4K from start of device.
 		 * Depending on the array size, we might leave extra space
 		 * for a bitmap.
+		 * Also leave 4K for bad-block log.
 		 */
 		array_size = __le64_to_cpu(sb->size);
-		/* work out how much space we left for a bitmap */
-		bm_space = choose_bm_space(array_size);
+		/* work out how much space we left for a bitmap,
+		 * Add 8 sectors for bad block log */
+		bm_space = choose_bm_space(array_size) + 8;
+
+		/* 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
+		 * However we make it at least 2 chunks as one chunk
+		 * is minimum needed for reshape.
+		 */
+		headroom = 128 * 1024 * 2;
+		while  (headroom << 10 > array_size &&
+			headroom/2 >= __le32_to_cpu(sb->chunksize) * 2)
+			headroom >>= 1;
 
+		data_offset = di->data_offset;
 		switch(st->minor_version) {
 		case 0:
 			sb_offset = dsize;
 			sb_offset -= 8*2;
 			sb_offset &= ~(4*2-1);
 			sb->super_offset = __cpu_to_le64(sb_offset);
-			sb->data_offset = __cpu_to_le64(0);
+			if (data_offset == INVALID_SECTORS)
+				sb->data_offset = 0;
 			if (sb_offset < array_size + bm_space)
 				bm_space = sb_offset - array_size;
 			sb->data_size = __cpu_to_le64(sb_offset - bm_space);
+			if (bm_space >= 8) {
+				sb->bblog_size = __cpu_to_le16(8);
+				sb->bblog_offset = __cpu_to_le32((unsigned)-8);
+			}
 			break;
 		case 1:
 			sb->super_offset = __cpu_to_le64(0);
-			reserved = bm_space + 4*2;
-			/* Try for multiple of 1Meg so it is nicely aligned */
-			#define ONE_MEG (2*1024)
-			reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG;
-			if (reserved + __le64_to_cpu(sb->size) > dsize)
-				reserved = dsize - __le64_to_cpu(sb->size);
-			/* force 4K alignment */
-			reserved &= ~7ULL;
+			if (data_offset == INVALID_SECTORS) {
+				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;
+
+			} else
+				reserved = data_offset;
 
 			sb->data_offset = __cpu_to_le64(reserved);
 			sb->data_size = __cpu_to_le64(dsize - reserved);
+			if (reserved >= 16) {
+				sb->bblog_size = __cpu_to_le16(8);
+				sb->bblog_offset = __cpu_to_le32(reserved-8);
+			}
 			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)
-			    > dsize)
-				bm_space = dsize - __le64_to_cpu(sb->size)
-					- 4*2 - 4*2;
-
-			reserved = bm_space + 4*2 + 4*2;
-			/* Try for multiple of 1Meg so it is nicely aligned */
-			#define ONE_MEG (2*1024)
-			reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG;
-			if (reserved + __le64_to_cpu(sb->size) > dsize)
-				reserved = dsize - __le64_to_cpu(sb->size);
-			/* force 4K alignment */
-			reserved &= ~7ULL;
+			if (data_offset == INVALID_SECTORS) {
+				if (4*2 + 4*2 + bm_space + array_size
+				    > dsize)
+					bm_space = dsize - array_size
+						- 4*2 - 4*2;
+
+				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;
+
+			} else
+				reserved = data_offset;
 
 			sb->data_offset = __cpu_to_le64(reserved);
 			sb->data_size = __cpu_to_le64(dsize - reserved);
+			if (reserved >= 16+16) {
+				sb->bblog_size = __cpu_to_le16(8);
+				/* '8' sectors for the bblog, and another '8'
+				 * because we want offset from superblock, not
+				 * start of device.
+				 */
+				sb->bblog_offset = __cpu_to_le32(reserved-8-8);
+			}
 			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
@@ -1184,15 +1534,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;
 	}
@@ -1217,9 +1563,12 @@ 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);
 
+	init_afd(&afd, fd);
+
 	if (st->ss == NULL || st->minor_version == -1) {
 		int bestvers = -1;
 		struct supertype tst;
@@ -1246,7 +1595,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;
@@ -1260,7 +1609,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;
 	}
@@ -1289,27 +1638,22 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 		return -EINVAL;
 	}
 
-	ioctl(fd, BLKFLSBUF, 0); /* make sure we read current data */
-
-
 	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 (aread(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;
@@ -1317,7 +1661,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;
@@ -1325,23 +1669,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 */
@@ -1352,8 +1696,7 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 	 * should get that written out.
 	 */
 	locate_bitmap1(st, fd);
-	if (aread(fd, ((char*)super)+1024, 512)
-	    != 512)
+	if (aread(&afd, bsb, 512) != 512)
 		goto no_bitmap;
 
 	uuid_from_super1(st, uuid);
@@ -1363,20 +1706,19 @@ 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 = xcalloc(1, sizeof(*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')
@@ -1414,35 +1756,60 @@ static struct supertype *match_metadata_desc1(char *arg)
  * superblock type st, and reserving 'reserve' sectors for
  * a possible bitmap
  */
-static __u64 avail_size1(struct supertype *st, __u64 devsize)
+static __u64 _avail_size1(struct supertype *st, __u64 devsize,
+			  unsigned long long data_offset, int chunksize)
 {
 	struct mdp_superblock_1 *super = st->sb;
+	int bmspace = 0;
 	if (devsize < 24)
 		return 0;
 
 	if (super == NULL)
 		/* creating:  allow suitable space for bitmap */
-		devsize -= choose_bm_space(devsize);
+		bmspace = choose_bm_space(devsize);
 #ifndef MDASSEMBLE
 	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);
-		devsize -= bitmap_sectors(bsb);
+		bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE);
+		bmspace = bitmap_sectors(bsb);
 	}
 #endif
+	/* Allow space for bad block log */
+	if (super && super->bblog_size)
+		devsize -= __le16_to_cpu(super->bblog_size);
+	else
+		devsize -= 8;
+
 
 	if (st->minor_version < 0)
 		/* not specified, so time to set default */
 		st->minor_version = 2;
+
+	if (data_offset != INVALID_SECTORS)
+		switch(st->minor_version) {
+		case 0:
+			return devsize - data_offset - 8*2;
+		case 1:
+		case 2:
+			return devsize - data_offset;
+		default:
+			return 0;
+		}
+
+	devsize -= bmspace;
+
 	if (super == NULL && st->minor_version > 0) {
 		/* haven't committed to a size yet, so allow some
-		 * slack for alignment of data_offset.
-		 * We haven't access to device details so allow
-		 * 1 Meg if bigger than 1Gig
+		 * slack for space for reshape.
+		 * Limit slack to 128M, but aim for about 0.1%
 		 */
-		if (devsize > 1024*1024*2)
-			devsize -= 1024*2;
+		unsigned long long headroom = 128*1024*2;
+		while ((headroom << 10) > devsize &&
+		       (chunksize == 0 ||
+			headroom / 2 >= ((unsigned)chunksize*2)*2))
+			headroom >>= 1;
+		devsize -= headroom;
 	}
 	switch(st->minor_version) {
 	case 0:
@@ -1457,6 +1824,11 @@ static __u64 avail_size1(struct supertype *st, __u64 devsize)
 	}
 	return 0;
 }
+static __u64 avail_size1(struct supertype *st, __u64 devsize,
+			 unsigned long long data_offset)
+{
+	return _avail_size1(st, devsize, data_offset, 0);
+}
 
 static int
 add_internal_bitmap1(struct supertype *st,
@@ -1465,12 +1837,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 !!!
 	 */
@@ -1479,31 +1849,46 @@ add_internal_bitmap1(struct supertype *st,
 	unsigned long long max_bits;
 	unsigned long long min_chunk;
 	long offset;
+	long bbl_offset, bbl_size;
 	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 (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));
+			bbl_size = 8;
 		} 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 &&
+			bbl_size = __le16_to_cpu(sb->bblog_size);
+			if (bbl_size < 8)
+				bbl_size = 8;
+			bbl_offset = (__s32)__le32_to_cpu(sb->bblog_offset);
+			if (bbl_size < -bbl_offset)
+				bbl_size = -bbl_offset;
+
+			if (!may_change || (room < 3*2 &&
 				  __le32_to_cpu(sb->max_dev) <= 384)) {
 				room = 3*2;
 				offset = 1*2;
+				bbl_size = 0;
 			} else {
 				offset = 0; /* means movable offset */
 			}
@@ -1511,17 +1896,25 @@ 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));
+			bbl_size = 8;
 		} 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;
+			bbl_size = __le16_to_cpu(sb->bblog_size);
+			if (bbl_size)
+				room = __le32_to_cpu(sb->bblog_offset) + bbl_size;
+			else
+				bbl_size = 8;
+
+			if (!may_change) {
+				room -= 2; /* Leave 1K for superblock */
 				offset = 2;
+				bbl_size = 0;
 			} else {
-				room -= 4*2;
+				room -= 4*2; /* leave 4K for superblock */
 				offset = 4*2;
 			}
 		}
@@ -1530,6 +1923,7 @@ add_internal_bitmap1(struct supertype *st,
 		return 0;
 	}
 
+	room -= bbl_size;
 	if (chunk == UnSet && room > 128*2)
 		/* Limit to 128K of bitmap when chunk size not requested */
 		room = 128*2;
@@ -1561,16 +1955,18 @@ add_internal_bitmap1(struct supertype *st,
 		bits = (size*512) / chunk + 1;
 		room = ((bits+7)/8 + sizeof(bitmap_super_t) +4095)/4096;
 		room *= 8; /* convert 4K blocks to sectors */
-		offset = -room;
+		offset = -room - bbl_size;
 	}
 
-	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);
@@ -1580,7 +1976,6 @@ add_internal_bitmap1(struct supertype *st,
 	return 1;
 }
 
-
 static void locate_bitmap1(struct supertype *st, int fd)
 {
 	unsigned long long offset;
@@ -1604,16 +1999,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 *buf = (char*)(((long)(abuf+4096))&~4095UL);
+	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 */
@@ -1623,7 +2023,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
@@ -1634,6 +2034,7 @@ static int write_bitmap1(struct supertype *st, int fd)
 	if (towrite)
 		rv = -2;
 
+	free(buf);
 	return rv;
 }
 
@@ -1655,6 +2056,7 @@ static void free_super1(struct supertype *st)
 static int validate_geometry1(struct supertype *st, int level,
 			      int layout, int raiddisks,
 			      int *chunk, unsigned long long size,
+			      unsigned long long data_offset,
 			      char *subdev, unsigned long long *freesize,
 			      int verbose)
 {
@@ -1663,7 +2065,7 @@ static int validate_geometry1(struct supertype *st, int level,
 
 	if (level == LEVEL_CONTAINER) {
 		if (verbose)
-			fprintf(stderr, Name ": 1.x metadata does not support containers\n");
+			pr_err("1.x metadata does not support containers\n");
 		return 0;
 	}
 	if (chunk && *chunk == UnSet)
@@ -1675,7 +2077,7 @@ static int validate_geometry1(struct supertype *st, int level,
 	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;
 	}
@@ -1686,7 +2088,7 @@ static int validate_geometry1(struct supertype *st, int level,
 	}
 	close(fd);
 
-	*freesize = avail_size1(st, ldsize >> 9);
+	*freesize = _avail_size1(st, ldsize >> 9, data_offset, *chunk);
 	return 1;
 }
 #endif /* MDASSEMBLE */
@@ -1702,6 +2104,7 @@ struct superswitch super1 = {
 	.write_init_super = write_init_super1,
 	.validate_geometry = validate_geometry1,
 	.add_to_super = add_to_super1,
+	.examine_badblocks = examine_badblocks_super1,
 #endif
 	.match_home = match_home1,
 	.uuid_from_super = uuid_from_super1,