X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=super1.c;h=6974daa0fb304cc26aa794b3e13550d771278efe;hp=b7cd962a7e375de6c0c7667749ccf60acaffc88e;hb=d1d599ea0d25b047bc0541e62431e635e1e29f18;hpb=35ddc76dcbcb7ef5f1ca57e557bfa4c3cdf6a6eb

diff --git a/super1.c b/super1.c
index b7cd962a..6974daa0 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.
@@ -141,13 +136,72 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 	return __cpu_to_le32(csum);
 }
 
+static char abuf[4096+4096];
+static int aread(int fd, 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;
+	char *b;
+	int n;
+	if (ioctl(fd, BLKSSZGET, &bsize) != 0 ||
+	    bsize <= len)
+		return read(fd, buf, len);
+	if (bsize > 4096)
+		return -1;
+	b = (char*)(((long)(abuf+4096))&~4095UL);
+
+	n = read(fd, b, bsize);
+	if (n <= 0)
+		return n;
+	lseek(fd, len - n, 1);
+	if (n > len)
+		n = len;
+	memcpy(buf, b, n);
+	return n;
+}
+
+static int awrite(int fd, 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;
+	char *b;
+	int n;
+	if (ioctl(fd, BLKSSZGET, &bsize) != 0 ||
+	    bsize <= len)
+		return write(fd, buf, len);
+	if (bsize > 4096)
+		return -1;
+	b = (char*)(((long)(abuf+4096))&~4095UL);
+
+	n = read(fd, b, bsize);
+	if (n <= 0)
+		return n;
+	lseek(fd, -n, 1);
+	memcpy(b, buf, len);
+	n = write(fd, b, bsize);
+	if (n <= 0)
+		return n;
+	lseek(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,7 +239,7 @@ 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) {
+	if (__le32_to_cpu(sb->level) > 0) {
 		int ddsks=0;
 		switch(__le32_to_cpu(sb->level)) {
 		case 1: ddsks=1;break;
@@ -230,13 +284,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,11 +299,14 @@ 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 : near=%d, %s=%d\n",
-				       __le32_to_cpu(sb->new_layout)&255,
-				       (__le32_to_cpu(sb->new_layout)&0x10000)?"offset":"far",
-				       (__le32_to_cpu(sb->new_layout)>>8)&255);
+				printf("     New Layout :");
+				print_r10_layout(__le32_to_cpu(sb->new_layout));
+				printf("\n");
 			}
 		}
 		if (__le32_to_cpu(sb->new_chunk) != __le32_to_cpu(sb->chunksize))
@@ -279,12 +334,15 @@ 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 : near=%d, %s=%d\n",
-		       lo&255,
-		       (lo&0x10000)?"offset":"far",
-		       (lo>>8)&255);
+		printf("         Layout :");
+		print_r10_layout(lo);
+		printf("\n");
 	}
 	switch(__le32_to_cpu(sb->level)) {
 	case 0:
@@ -300,6 +358,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)
@@ -312,13 +372,25 @@ 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]);
+			unsigned int role = __le16_to_cpu(sb->dev_roles[i]);
 			if (role == d) {
 				if (i == __le32_to_cpu(sb->dev_number))
 					me = 1;
@@ -326,10 +398,11 @@ static void examine_super1(struct supertype *st, char *homehost)
 			}
 		}
 		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]);
@@ -337,11 +410,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 +430,21 @@ static void brief_examine_super1(struct supertype *st)
 	else if (sb->set_name[0])
 		nm = sb->set_name;
 	else
-		nm = "??";
+		nm = NULL;
 
-	printf("ARRAY /dev/md/%s level=%s ", 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,12 +558,13 @@ 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;
 
 	info->array.major_version = 1;
 	info->array.minor_version = st->minor_version;
@@ -515,7 +595,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 */
@@ -533,6 +613,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,18 +625,38 @@ 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++) {
+	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,
@@ -570,20 +675,18 @@ 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)
@@ -594,11 +697,10 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 			sb->dev_roles[d] = want;
 			rv = 1;
 		}
-	}
-	if (strcmp(update, "linear-grow-new") == 0) {
-		int i;
-		int rfd;
-		int max = __le32_to_cpu(sb->max_dev);
+	} else if (strcmp(update, "linear-grow-new") == 0) {
+		unsigned int i;
+		int rfd, fd;
+		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,25 +712,41 @@ 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);
-	}
-	if (strcmp(update, "linear-grow-update") == 0) {
+
+		fd = open(devname, O_RDONLY);
+		if (fd >= 0) {
+			unsigned long long ds;
+			get_dev_size(fd, devname, &ds);
+			close(fd);
+			ds >>= 9;
+			if (__le64_to_cpu(sb->super_offset) <
+			    __le64_to_cpu(sb->data_offset)) {
+				sb->data_size = __cpu_to_le64(
+					ds - __le64_to_cpu(sb->data_offset));
+			} else {
+				ds -= 8*2;
+				ds &= ~(unsigned long long)(4*2-1);
+				sb->super_offset = __cpu_to_le64(ds);
+				sb->data_size = __cpu_to_le64(
+					ds - __le64_to_cpu(sb->data_offset));
+			}
+		}
+	} 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) {
@@ -636,8 +754,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 			bm = (struct bitmap_super_s*)(st->sb+1024);
 			memcpy(bm->uuid, sb->set_uuid, 16);
 		}
-	}
-	if (strcmp(update, "homehost") == 0 &&
+	} else if (strcmp(update, "homehost") == 0 &&
 	    homehost) {
 		char *c;
 		update = "name";
@@ -647,8 +764,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));
@@ -660,8 +776,7 @@ 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 */
@@ -673,9 +788,10 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
 			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
+		rv = -1;
 
 	sb->sb_csum = calc_sb_1_csum(sb);
 	return rv;
@@ -689,8 +805,12 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
 	int rfd;
 	char defname[10];
 
-	posix_memalign((void**)&sb, 512, (1024 + 512 + 
-					  sizeof(struct misc_dev_info)));
+	if (posix_memalign((void**)&sb, 512, (1024 + 512 + 
+			   sizeof(struct misc_dev_info))) != 0) {
+		fprintf(stderr, Name
+			": %s could not allocate superblock\n", __func__);
+		return 0;
+	}
 	memset(sb, 0, 1024);
 
 	st->sb = sb;
@@ -716,10 +836,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);
 	}
@@ -753,7 +871,7 @@ 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))/
@@ -773,7 +891,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;
@@ -787,6 +905,10 @@ 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) < 384)
+		sb->max_dev = __cpu_to_le32(dk->number+1);
+
 	sb->dev_number = __cpu_to_le32(dk->number);
 	sb->sb_csum = calc_sb_1_csum(sb);
 
@@ -799,6 +921,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
 
@@ -858,7 +982,7 @@ static int store_super1(struct supertype *st, int fd)
 	sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev);
 	sbsize = (sbsize+511)&(~511UL);
 
-	if (write(fd, sb, sbsize) != sbsize)
+	if (awrite(fd, sb, sbsize) != sbsize)
 		return 4;
 
 	if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
@@ -866,8 +990,8 @@ static int store_super1(struct supertype *st, int fd)
 			(((char*)sb)+1024);
 		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))
+			if (awrite(fd, bm, sizeof(*bm)) !=
+			    sizeof(*bm))
 			    return 5;
 		}
 	}
@@ -881,6 +1005,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)
@@ -897,10 +1023,11 @@ static int write_init_super1(struct supertype *st)
 	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;
 
 	for (di = st->info; di && ! rv ; di = di->next) {
 		if (di->disk.state == 1)
@@ -908,8 +1035,8 @@ static int write_init_super1(struct supertype *st)
 		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))
@@ -917,12 +1044,12 @@ static int write_init_super1(struct supertype *st)
 
 		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;
@@ -975,16 +1102,23 @@ 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;
+			/* 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;
+
+			sb->data_offset = __cpu_to_le64(reserved);
+			sb->data_size = __cpu_to_le64(dsize - reserved);
 			break;
 		case 2:
 			sb_offset = 4*2;
@@ -993,9 +1127,18 @@ static int write_init_super1(struct supertype *st)
 			    > dsize)
 				bm_space = dsize - __le64_to_cpu(sb->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;
+			/* 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;
+
+			sb->data_offset = __cpu_to_le64(reserved);
+			sb->data_size = __cpu_to_le64(dsize - reserved);
 			break;
 		default:
 			return -EINVAL;
@@ -1036,9 +1179,13 @@ static int compare_super1(struct supertype *st, struct supertype *tst)
 		return 1;
 
 	if (!first) {
-		posix_memalign((void**)&first, 512,
+		if (posix_memalign((void**)&first, 512,
 			       1024 + 512 +
-			       sizeof(struct misc_dev_info));
+			       sizeof(struct misc_dev_info)) != 0) {
+			fprintf(stderr, Name
+				": %s could not allocate superblock\n", __func__);
+			return 1;
+		}
 		memcpy(first, second, 1024 + 512 + 
 		       sizeof(struct misc_dev_info));
 		st->sb = first;
@@ -1070,9 +1217,6 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 
 	free_super1(st);
 
-	if (st->subarray[0])
-		return 1;
-
 	if (st->ss == NULL || st->minor_version == -1) {
 		int bestvers = -1;
 		struct supertype tst;
@@ -1152,11 +1296,15 @@ static int load_super1(struct supertype *st, int fd, char *devname)
 		return 1;
 	}
 
-	posix_memalign((void**)&super, 512,
+	if (posix_memalign((void**)&super, 512,
 		       1024 + 512 +
-		       sizeof(struct misc_dev_info));
+		       sizeof(struct misc_dev_info)) != 0) {
+		fprintf(stderr, Name ": %s could not allocate superblock\n",
+			__func__);
+		return 1;
+	}
 
-	if (read(fd, super, 1024) != 1024) {
+	if (aread(fd, super, 1024) != 1024) {
 		if (devname)
 			fprintf(stderr, Name ": Cannot read superblock on %s\n",
 				devname);
@@ -1201,7 +1349,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)
+	if (aread(fd, ((char*)super)+1024, 512)
 	    != 512)
 		goto no_bitmap;
 
@@ -1223,6 +1371,7 @@ static struct supertype *match_metadata_desc1(char *arg)
 	if (!st) return st;
 
 	memset(st, 0, sizeof(*st));
+	st->container_dev = NoMdDev;
 	st->ss = &super1;
 	st->max_devs = 384;
 	st->sb = NULL;
@@ -1235,11 +1384,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;
@@ -1260,15 +1413,35 @@ static struct supertype *match_metadata_desc1(char *arg)
  */
 static __u64 avail_size1(struct supertype *st, __u64 devsize)
 {
+	struct mdp_superblock_1 *super = st->sb;
 	if (devsize < 24)
 		return 0;
 
-	devsize -= choose_bm_space(devsize);
+	if (super == NULL)
+		/* creating:  allow suitable space for bitmap */
+		devsize -= 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);
+	}
+#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 alignment of data_offset.
+		 * We haven't access to device details so allow
+		 * 1 Meg if bigger than 1Gig
+		 */
+		if (devsize > 1024*1024*2)
+			devsize -= 1024*2;
+	}
 	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));
@@ -1303,15 +1476,15 @@ 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;
 	struct mdp_superblock_1 *sb = st->sb;
 	bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + 1024);
 
 	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) {
 			/* We are creating array, so we *know* how much room has
@@ -1319,11 +1492,6 @@ add_internal_bitmap1(struct supertype *st,
 			 */
 			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)
@@ -1371,16 +1539,25 @@ 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;
 	}
 
@@ -1428,8 +1605,7 @@ static int write_bitmap1(struct supertype *st, int fd)
 	int rv = 0;
 
 	int towrite, n;
-	char abuf[4096+512];
-	char *buf = (char*)(((long)(abuf+512))&~511UL);
+	char *buf = (char*)(((long)(abuf+4096))&~4095UL);
 
 	locate_bitmap1(st, fd);
 
@@ -1475,8 +1651,11 @@ static int validate_geometry1(struct supertype *st, int level,
 	unsigned long long ldsize;
 	int fd;
 
-	if (level == LEVEL_CONTAINER)
+	if (level == LEVEL_CONTAINER) {
+		if (verbose)
+			fprintf(stderr, Name ": 1.x metadata does not support containers\n");
 		return 0;
+	}
 	if (!subdev)
 		return 1;
 
@@ -1514,6 +1693,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,
@@ -1530,4 +1710,5 @@ struct superswitch super1 = {
 #else
 	.swapuuid = 1,
 #endif
+	.name = "1.x",
 };