X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super-intel.c;h=f438044e82587daf40364c55b000d6de14482c34;hb=4e8d9f0a1650cd187554d7d34fd85c74441cbc7c;hp=a2acaaf2429ed9592518998204702c84d5a87ffd;hpb=4e9d21862d0fbea7e028ff3a48a0b734440e6015;p=thirdparty%2Fmdadm.git

diff --git a/super-intel.c b/super-intel.c
index a2acaaf2..f438044e 100644
--- a/super-intel.c
+++ b/super-intel.c
@@ -230,7 +230,7 @@ static unsigned int mpb_sectors(struct imsm_super *mpb)
 struct intel_dev {
 	struct imsm_dev *dev;
 	struct intel_dev *next;
-	int index;
+	unsigned index;
 };
 
 /* internal representation of IMSM metadata */
@@ -243,7 +243,6 @@ struct intel_super {
 	void *next_buf; /* for realloc'ing buf from the manager */
 	size_t next_len;
 	int updates_pending; /* count of pending updates for mdmon */
-	int creating_imsm; /* flag to indicate container creation */
 	int current_vol; /* index of raid device undergoing creation */
 	__u32 create_offset; /* common start for 'current_vol' */
 	__u32 random; /* random data for seeding new family numbers */
@@ -283,6 +282,8 @@ struct extent {
 enum imsm_update_type {
 	update_activate_spare,
 	update_create_array,
+	update_kill_array,
+	update_rename_array,
 	update_add_disk,
 };
 
@@ -304,6 +305,17 @@ struct imsm_update_create_array {
 	struct imsm_dev dev;
 };
 
+struct imsm_update_kill_array {
+	enum imsm_update_type type;
+	int dev_idx;
+};
+
+struct imsm_update_rename_array {
+	enum imsm_update_type type;
+	__u8 name[MAX_RAID_SERIAL_LEN];
+	int dev_idx;
+};
+
 struct imsm_update_add_disk {
 	enum imsm_update_type type;
 };
@@ -345,7 +357,6 @@ static struct imsm_disk *__get_imsm_disk(struct imsm_super *mpb, __u8 index)
 	return &mpb->disk[index];
 }
 
-#ifndef MDASSEMBLE
 /* retrieve a disk from the parsed metadata */
 static struct imsm_disk *get_imsm_disk(struct intel_super *super, __u8 index)
 {
@@ -357,7 +368,6 @@ static struct imsm_disk *get_imsm_disk(struct intel_super *super, __u8 index)
 	
 	return NULL;
 }
-#endif
 
 /* generate a checksum directly from the anchor when the anchor is known to be
  * up-to-date, currently only at load or write_super after coalescing
@@ -486,7 +496,7 @@ static void set_imsm_ord_tbl_ent(struct imsm_map *map, int slot, __u32 ord)
 	map->disk_ord_tbl[slot] = __cpu_to_le32(ord);
 }
 
-static int get_imsm_disk_slot(struct imsm_map *map, int idx)
+static int get_imsm_disk_slot(struct imsm_map *map, unsigned idx)
 {
 	int slot;
 	__u32 ord;
@@ -580,7 +590,7 @@ static struct extent *get_extents(struct intel_super *super, struct dl *dl)
 		 */
 		remainder &= ~1UL;
 		/* make sure remainder is still sane */
-		if (remainder < ROUND_UP(super->len, 512) >> 9)
+		if (remainder < (unsigned)ROUND_UP(super->len, 512) >> 9)
 			remainder = ROUND_UP(super->len, 512) >> 9;
 		if (reservation > remainder)
 			reservation = remainder;
@@ -637,10 +647,12 @@ static int is_failed(struct imsm_disk *disk)
 }
 
 #ifndef MDASSEMBLE
+static __u64 blocks_per_migr_unit(struct imsm_dev *dev);
+
 static void print_imsm_dev(struct imsm_dev *dev, char *uuid, int disk_idx)
 {
 	__u64 sz;
-	int slot;
+	int slot, i;
 	struct imsm_map *map = get_imsm_map(dev, 0);
 	__u32 ord;
 
@@ -649,6 +661,12 @@ static void print_imsm_dev(struct imsm_dev *dev, char *uuid, int disk_idx)
 	printf("           UUID : %s\n", uuid);
 	printf("     RAID Level : %d\n", get_imsm_raid_level(map));
 	printf("        Members : %d\n", map->num_members);
+	printf("          Slots : [");
+	for (i = 0; i < map->num_members; i++) {
+		ord = get_imsm_ord_tbl_ent(dev, i);
+		printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
+	}
+	printf("]\n");
 	slot = get_imsm_disk_slot(map, disk_idx);
 	if (slot >= 0) {
 		ord = get_imsm_ord_tbl_ent(dev, slot);
@@ -671,27 +689,32 @@ static void print_imsm_dev(struct imsm_dev *dev, char *uuid, int disk_idx)
 	printf("     Chunk Size : %u KiB\n",
 		__le16_to_cpu(map->blocks_per_strip) / 2);
 	printf("       Reserved : %d\n", __le32_to_cpu(dev->reserved_blocks));
-	printf("  Migrate State : %s", dev->vol.migr_state ? "migrating" : "idle\n");
+	printf("  Migrate State : ");
 	if (dev->vol.migr_state) {
 		if (migr_type(dev) == MIGR_INIT)
-			printf(": initializing\n");
+			printf("initialize\n");
 		else if (migr_type(dev) == MIGR_REBUILD)
-			printf(": rebuilding\n");
+			printf("rebuild\n");
 		else if (migr_type(dev) == MIGR_VERIFY)
-			printf(": check\n");
+			printf("check\n");
 		else if (migr_type(dev) == MIGR_GEN_MIGR)
-			printf(": general migration\n");
+			printf("general migration\n");
 		else if (migr_type(dev) == MIGR_STATE_CHANGE)
-			printf(": state change\n");
+			printf("state change\n");
 		else if (migr_type(dev) == MIGR_REPAIR)
-			printf(": repair\n");
+			printf("repair\n");
 		else
-			printf(": <unknown:%d>\n", migr_type(dev));
-	}
+			printf("<unknown:%d>\n", migr_type(dev));
+	} else
+		printf("idle\n");
 	printf("      Map State : %s", map_state_str[map->map_state]);
 	if (dev->vol.migr_state) {
 		struct imsm_map *map = get_imsm_map(dev, 1);
+
 		printf(" <-- %s", map_state_str[map->map_state]);
+		printf("\n     Checkpoint : %u (%llu)",
+		       __le32_to_cpu(dev->vol.curr_migr_unit),
+		       (unsigned long long)blocks_per_migr_unit(dev));
 	}
 	printf("\n");
 	printf("    Dirty State : %s\n", dev->vol.dirty ? "dirty" : "clean");
@@ -703,7 +726,7 @@ static void print_imsm_disk(struct imsm_super *mpb, int index, __u32 reserved)
 	char str[MAX_RAID_SERIAL_LEN + 1];
 	__u64 sz;
 
-	if (index < 0)
+	if (index < 0 || !disk)
 		return;
 
 	printf("\n");
@@ -868,7 +891,7 @@ static int imsm_enumerate_ports(const char *hba_path, int port_count, int host_b
 	int err = 0;
 	unsigned long port_mask = (1 << port_count) - 1;
 
-	if (port_count > sizeof(port_mask) * 8) {
+	if (port_count > (int)sizeof(port_mask) * 8) {
 		if (verbose)
 			fprintf(stderr, Name ": port_count %d out of range\n", port_count);
 		return 2;
@@ -961,6 +984,12 @@ static int imsm_enumerate_ports(const char *hba_path, int port_count, int host_b
 
 		/* chop device path to 'host%d' and calculate the port number */
 		c = strchr(&path[hba_len], '/');
+		if (!c) {
+			if (verbose)
+				fprintf(stderr, Name ": %s - invalid path name\n", path + hba_len);
+			err = 2;
+			break;
+		}
 		*c = '\0';
 		if (sscanf(&path[hba_len], "host%d", &port) == 1)
 			port -= host_base;
@@ -1217,6 +1246,179 @@ get_imsm_numerical_version(struct imsm_super *mpb, int *m, int *p)
 }
 #endif
 
+static __u32 migr_strip_blocks_resync(struct imsm_dev *dev)
+{
+	/* migr_strip_size when repairing or initializing parity */
+	struct imsm_map *map = get_imsm_map(dev, 0);
+	__u32 chunk = __le32_to_cpu(map->blocks_per_strip);
+
+	switch (get_imsm_raid_level(map)) {
+	case 5:
+	case 10:
+		return chunk;
+	default:
+		return 128*1024 >> 9;
+	}
+}
+
+static __u32 migr_strip_blocks_rebuild(struct imsm_dev *dev)
+{
+	/* migr_strip_size when rebuilding a degraded disk, no idea why
+	 * this is different than migr_strip_size_resync(), but it's good
+	 * to be compatible
+	 */
+	struct imsm_map *map = get_imsm_map(dev, 1);
+	__u32 chunk = __le32_to_cpu(map->blocks_per_strip);
+
+	switch (get_imsm_raid_level(map)) {
+	case 1:
+	case 10:
+		if (map->num_members % map->num_domains == 0)
+			return 128*1024 >> 9;
+		else
+			return chunk;
+	case 5:
+		return max((__u32) 64*1024 >> 9, chunk);
+	default:
+		return 128*1024 >> 9;
+	}
+}
+
+static __u32 num_stripes_per_unit_resync(struct imsm_dev *dev)
+{
+	struct imsm_map *lo = get_imsm_map(dev, 0);
+	struct imsm_map *hi = get_imsm_map(dev, 1);
+	__u32 lo_chunk = __le32_to_cpu(lo->blocks_per_strip);
+	__u32 hi_chunk = __le32_to_cpu(hi->blocks_per_strip);
+
+	return max((__u32) 1, hi_chunk / lo_chunk);
+}
+
+static __u32 num_stripes_per_unit_rebuild(struct imsm_dev *dev)
+{
+	struct imsm_map *lo = get_imsm_map(dev, 0);
+	int level = get_imsm_raid_level(lo);
+
+	if (level == 1 || level == 10) {
+		struct imsm_map *hi = get_imsm_map(dev, 1);
+
+		return hi->num_domains;
+	} else
+		return num_stripes_per_unit_resync(dev);
+}
+
+static __u8 imsm_num_data_members(struct imsm_dev *dev)
+{
+	/* named 'imsm_' because raid0, raid1 and raid10
+	 * counter-intuitively have the same number of data disks
+	 */
+	struct imsm_map *map = get_imsm_map(dev, 0);
+
+	switch (get_imsm_raid_level(map)) {
+	case 0:
+	case 1:
+	case 10:
+		return map->num_members;
+	case 5:
+		return map->num_members - 1;
+	default:
+		dprintf("%s: unsupported raid level\n", __func__);
+		return 0;
+	}
+}
+
+static __u32 parity_segment_depth(struct imsm_dev *dev)
+{
+	struct imsm_map *map = get_imsm_map(dev, 0);
+	__u32 chunk =  __le32_to_cpu(map->blocks_per_strip);
+
+	switch(get_imsm_raid_level(map)) {
+	case 1:
+	case 10:
+		return chunk * map->num_domains;
+	case 5:
+		return chunk * map->num_members;
+	default:
+		return chunk;
+	}
+}
+
+static __u32 map_migr_block(struct imsm_dev *dev, __u32 block)
+{
+	struct imsm_map *map = get_imsm_map(dev, 1);
+	__u32 chunk = __le32_to_cpu(map->blocks_per_strip);
+	__u32 strip = block / chunk;
+
+	switch (get_imsm_raid_level(map)) {
+	case 1:
+	case 10: {
+		__u32 vol_strip = (strip * map->num_domains) + 1;
+		__u32 vol_stripe = vol_strip / map->num_members;
+
+		return vol_stripe * chunk + block % chunk;
+	} case 5: {
+		__u32 stripe = strip / (map->num_members - 1);
+
+		return stripe * chunk + block % chunk;
+	}
+	default:
+		return 0;
+	}
+}
+
+static __u64 blocks_per_migr_unit(struct imsm_dev *dev)
+{
+	/* calculate the conversion factor between per member 'blocks'
+	 * (md/{resync,rebuild}_start) and imsm migration units, return
+	 * 0 for the 'not migrating' and 'unsupported migration' cases
+	 */
+	if (!dev->vol.migr_state)
+		return 0;
+
+	switch (migr_type(dev)) {
+	case MIGR_VERIFY:
+	case MIGR_REPAIR:
+	case MIGR_INIT: {
+		struct imsm_map *map = get_imsm_map(dev, 0);
+		__u32 stripes_per_unit;
+		__u32 blocks_per_unit;
+		__u32 parity_depth;
+		__u32 migr_chunk;
+		__u32 block_map;
+		__u32 block_rel;
+		__u32 segment;
+		__u32 stripe;
+		__u8  disks;
+
+		/* yes, this is really the translation of migr_units to
+		 * per-member blocks in the 'resync' case
+		 */
+		stripes_per_unit = num_stripes_per_unit_resync(dev);
+		migr_chunk = migr_strip_blocks_resync(dev);
+		disks = imsm_num_data_members(dev);
+		blocks_per_unit = stripes_per_unit * migr_chunk * disks;
+		stripe = __le32_to_cpu(map->blocks_per_strip) * disks;
+		segment = blocks_per_unit / stripe;
+		block_rel = blocks_per_unit - segment * stripe;
+		parity_depth = parity_segment_depth(dev);
+		block_map = map_migr_block(dev, block_rel);
+		return block_map + parity_depth * segment;
+	}
+	case MIGR_REBUILD: {
+		__u32 stripes_per_unit;
+		__u32 migr_chunk;
+
+		stripes_per_unit = num_stripes_per_unit_rebuild(dev);
+		migr_chunk = migr_strip_blocks_rebuild(dev);
+		return migr_chunk * stripes_per_unit;
+	}
+	case MIGR_GEN_MIGR:
+	case MIGR_STATE_CHANGE:
+	default:
+		return 0;
+	}
+}
+
 static int imsm_level_to_layout(int level)
 {
 	switch (level) {
@@ -1238,6 +1440,7 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info)
 	struct imsm_dev *dev = get_imsm_dev(super, super->current_vol);
 	struct imsm_map *map = get_imsm_map(dev, 0);
 	struct dl *dl;
+	char *devname;
 
 	for (dl = super->disks; dl; dl = dl->next)
 		if (dl->raiddisk == info->disk.raid_disk)
@@ -1265,23 +1468,48 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info)
 	info->data_offset	  = __le32_to_cpu(map->pba_of_lba0);
 	info->component_size	  = __le32_to_cpu(map->blocks_per_member);
 	memset(info->uuid, 0, sizeof(info->uuid));
+	info->recovery_start = MaxSector;
+	info->reshape_active = 0;
 
-	if (map->map_state == IMSM_T_STATE_UNINITIALIZED || dev->vol.dirty)
-		info->resync_start = 0;
-	else if (dev->vol.migr_state)
-		/* FIXME add curr_migr_unit to resync_start conversion */
+	if (map->map_state == IMSM_T_STATE_UNINITIALIZED || dev->vol.dirty) {
 		info->resync_start = 0;
-	else
-		info->resync_start = ~0ULL;
+	} else if (dev->vol.migr_state) {
+		switch (migr_type(dev)) {
+		case MIGR_REPAIR:
+		case MIGR_INIT: {
+			__u64 blocks_per_unit = blocks_per_migr_unit(dev);
+			__u64 units = __le32_to_cpu(dev->vol.curr_migr_unit);
+
+			info->resync_start = blocks_per_unit * units;
+			break;
+		}
+		case MIGR_VERIFY:
+			/* we could emulate the checkpointing of
+			 * 'sync_action=check' migrations, but for now
+			 * we just immediately complete them
+			 */
+		case MIGR_REBUILD:
+			/* this is handled by container_content_imsm() */
+		case MIGR_GEN_MIGR:
+		case MIGR_STATE_CHANGE:
+			/* FIXME handle other migrations */
+		default:
+			/* we are not dirty, so... */
+			info->resync_start = MaxSector;
+		}
+	} else
+		info->resync_start = MaxSector;
 
 	strncpy(info->name, (char *) dev->volume, MAX_RAID_SERIAL_LEN);
 	info->name[MAX_RAID_SERIAL_LEN] = 0;
 
 	info->array.major_version = -1;
 	info->array.minor_version = -2;
-	sprintf(info->text_version, "/%s/%d",
-		devnum2devname(st->container_dev),
-		info->container_member);
+	devname = devnum2devname(st->container_dev);
+	*info->text_version = '\0';
+	if (devname)
+		sprintf(info->text_version, "/%s/%d", devname, info->container_member);
+	free(devname);
 	info->safe_mode_delay = 4000;  /* 4 secs like the Matrix driver */
 	uuid_from_super_imsm(st, info->uuid);
 }
@@ -1317,6 +1545,20 @@ static void fixup_container_spare_uuid(struct mdinfo *inf)
 	}
 }
 
+
+static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev, int failed);
+static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev);
+
+static struct imsm_disk *get_imsm_missing(struct intel_super *super, __u8 index)
+{
+	struct dl *d;
+
+	for (d = super->missing; d; d = d->next)
+		if (d->index == index)
+			return &d->disk;
+	return NULL;
+}
+
 static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info)
 {
 	struct intel_super *super = st->sb;
@@ -1349,6 +1591,54 @@ static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info)
 	info->disk.number = -1;
 	info->disk.state = 0;
 	info->name[0] = 0;
+	info->recovery_start = MaxSector;
+
+	/* do we have the all the insync disks that we expect? */
+	if (st->loaded_container) {
+		struct imsm_super *mpb = super->anchor;
+		int max_enough = -1, i;
+
+		for (i = 0; i < mpb->num_raid_devs; i++) {
+			struct imsm_dev *dev = get_imsm_dev(super, i);
+			int failed, enough, j, missing = 0;
+			struct imsm_map *map;
+			__u8 state;
+
+			failed = imsm_count_failed(super, dev);
+			state = imsm_check_degraded(super, dev, failed);
+			map = get_imsm_map(dev, dev->vol.migr_state);
+
+			/* any newly missing disks?
+			 * (catches single-degraded vs double-degraded)
+			 */
+			for (j = 0; j < map->num_members; j++) {
+				__u32 ord = get_imsm_ord_tbl_ent(dev, i);
+				__u32 idx = ord_to_idx(ord);
+
+				if (!(ord & IMSM_ORD_REBUILD) &&
+				    get_imsm_missing(super, idx)) {
+					missing = 1;
+					break;
+				}
+			}
+
+			if (state == IMSM_T_STATE_FAILED)
+				enough = -1;
+			else if (state == IMSM_T_STATE_DEGRADED &&
+				 (state != map->map_state || missing))
+				enough = 0;
+			else /* we're normal, or already degraded */
+				enough = 1;
+
+			/* in the missing/failed disk case check to see
+			 * if at least one array is runnable
+			 */
+			max_enough = max(max_enough, enough);
+		}
+		dprintf("%s: enough: %d\n", __func__, max_enough);
+		info->container_enough = max_enough;
+	} else
+		info->container_enough = -1;
 
 	if (super->disks) {
 		__u32 reserved = imsm_reserved_sectors(super, super->disks);
@@ -1568,6 +1858,7 @@ static int compare_super_imsm(struct supertype *st, struct supertype *tst)
 		first->anchor->num_raid_devs = sec->anchor->num_raid_devs;
 		first->anchor->orig_family_num = sec->anchor->orig_family_num;
 		first->anchor->family_num = sec->anchor->family_num;
+		memcpy(first->anchor->sig, sec->anchor->sig, MAX_SIGNATURE_LENGTH);
 		for (i = 0; i < sec->anchor->num_raid_devs; i++)
 			imsm_copy_dev(get_imsm_dev(first, i), get_imsm_dev(sec, i));
 	}
@@ -1579,7 +1870,7 @@ static void fd2devname(int fd, char *name)
 {
 	struct stat st;
 	char path[256];
-	char dname[100];
+	char dname[PATH_MAX];
 	char *nm;
 	int rv;
 
@@ -1908,6 +2199,13 @@ static int load_imsm_mpb(int fd, struct intel_super *super, char *devname)
 	__u32 check_sum;
 
 	get_dev_size(fd, NULL, &dsize);
+	if (dsize < 1024) {
+		if (devname)
+			fprintf(stderr,
+				Name ": %s: device to small for imsm\n",
+				devname);
+		return 1;
+	}
 
 	if (lseek64(fd, dsize - (512 * 2), SEEK_SET) < 0) {
 		if (devname)
@@ -1979,7 +2277,7 @@ static int load_imsm_mpb(int fd, struct intel_super *super, char *devname)
 		return 1;
 	}
 
-	if (read(fd, super->buf + 512, super->len - 512) != super->len - 512) {
+	if ((unsigned)read(fd, super->buf + 512, super->len - 512) != super->len - 512) {
 		if (devname)
 			fprintf(stderr,
 				Name ": Cannot read extended mpb on %s: %s\n",
@@ -2083,13 +2381,12 @@ static void free_super_imsm(struct supertype *st)
 	st->sb = NULL;
 }
 
-static struct intel_super *alloc_super(int creating_imsm)
+static struct intel_super *alloc_super(void)
 {
 	struct intel_super *super = malloc(sizeof(*super));
 
 	if (super) {
 		memset(super, 0, sizeof(*super));
-		super->creating_imsm = creating_imsm;
 		super->current_vol = -1;
 		super->create_offset = ~((__u32 ) 0);
 		if (!check_env("IMSM_NO_PLATFORM"))
@@ -2430,7 +2727,7 @@ imsm_thunderdome(struct intel_super **super_list, int len)
 			struct intel_disk *idisk;
 
 			idisk = disk_list_get(dl->serial, disk_list);
-			if (is_spare(&idisk->disk) &&
+			if (idisk && is_spare(&idisk->disk) &&
 			    !is_failed(&idisk->disk) && !is_configured(&idisk->disk))
 				dl->index = -1;
 			else {
@@ -2476,25 +2773,21 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp,
 	int retry;
 	int err = 0;
 	int i;
-	enum sysfs_read_flags flags;
-
-	flags = GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE;
-	if (mdmon_running(devnum))
-		flags |= SKIP_GONE_DEVS;
 
 	/* check if 'fd' an opened container */
-	sra = sysfs_read(fd, 0, flags);
+	sra = sysfs_read(fd, 0, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE);
 	if (!sra)
 		return 1;
 
 	if (sra->array.major_version != -1 ||
 	    sra->array.minor_version != -2 ||
-	    strcmp(sra->text_version, "imsm") != 0)
-		return 1;
-
+	    strcmp(sra->text_version, "imsm") != 0) {
+		err = 1;
+		goto error;
+	}
 	/* load all mpbs */
 	for (sd = sra->devs, i = 0; sd; sd = sd->next, i++) {
-		struct intel_super *s = alloc_super(0);
+		struct intel_super *s = alloc_super();
 		char nm[32];
 		int dfd;
 
@@ -2540,11 +2833,20 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp,
 	}
 
 	if (st->subarray[0]) {
-		if (atoi(st->subarray) <= super->anchor->num_raid_devs)
-			super->current_vol = atoi(st->subarray);
+		unsigned long val;
+		char *ep;
+
+		err = 1;
+		val = strtoul(st->subarray, &ep, 10);
+		if (*ep != '\0') {
+			free_imsm(super);
+			goto error;
+		}
+
+		if (val < super->anchor->num_raid_devs)
+			super->current_vol = val;
 		else {
 			free_imsm(super);
-			err = 1;
 			goto error;
 		}
 	}
@@ -2557,6 +2859,7 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp,
 		super_list = super_list->next;
 		free_imsm(s);
 	}
+	sysfs_free(sra);
 
 	if (err)
 		return err;
@@ -2584,9 +2887,13 @@ static int load_super_imsm(struct supertype *st, int fd, char *devname)
 		return 0;
 #endif
 
+	if (test_partition(fd))
+		/* IMSM not allowed on partitions */
+		return 1;
+
 	free_super_imsm(st);
 
-	super = alloc_super(0);
+	super = alloc_super();
 	if (!super) {
 		fprintf(stderr,
 			Name ": malloc of %zu failed.\n",
@@ -2606,8 +2913,17 @@ static int load_super_imsm(struct supertype *st, int fd, char *devname)
 	}
 
 	if (st->subarray[0]) {
-		if (atoi(st->subarray) <= super->anchor->num_raid_devs)
-			super->current_vol = atoi(st->subarray);
+		unsigned long val;
+		char *ep;
+
+		val = strtoul(st->subarray, &ep, 10);
+		if (*ep != '\0') {
+			free_imsm(super);
+			return 1;
+		}
+
+		if (val < super->anchor->num_raid_devs)
+			super->current_vol = val;
 		else {
 			free_imsm(super);
 			return 1;
@@ -2697,6 +3013,30 @@ static void imsm_update_version_info(struct intel_super *super)
 	}
 }
 
+static int check_name(struct intel_super *super, char *name, int quiet)
+{
+	struct imsm_super *mpb = super->anchor;
+	char *reason = NULL;
+	int i;
+
+	if (strlen(name) > MAX_RAID_SERIAL_LEN)
+		reason = "must be 16 characters or less";
+
+	for (i = 0; i < mpb->num_raid_devs; i++) {
+		struct imsm_dev *dev = get_imsm_dev(super, i);
+
+		if (strncmp((char *) dev->volume, name, MAX_RAID_SERIAL_LEN) == 0) {
+			reason = "already exists";
+			break;
+		}
+	}
+
+	if (reason && !quiet)
+		fprintf(stderr, Name ": imsm volume name %s\n", reason);
+
+	return !reason;
+}
+
 static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
 				  unsigned long long size, char *name,
 				  char *homehost, int *uuid)
@@ -2748,16 +3088,8 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
 	if (super->current_vol == 0)
 		mpb->num_disks = 0;
 
-	for (i = 0; i < super->current_vol; i++) {
-		dev = get_imsm_dev(super, i);
-		if (strncmp((char *) dev->volume, name,
-			     MAX_RAID_SERIAL_LEN) == 0) {
-			fprintf(stderr, Name": '%s' is already defined for this container\n",
-				name);
-			return 0;
-		}
-	}
-
+	if (!check_name(super, name, 0))
+		return 0;
 	sprintf(st->subarray, "%d", idx);
 	dv = malloc(sizeof(*dv));
 	if (!dv) {
@@ -2799,6 +3131,8 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
 	map->ddf = 1;
 
 	if (info->level == 1 && info->raid_disks > 2) {
+		free(dev);
+		free(dv);
 		fprintf(stderr, Name": imsm does not support more than 2 disks"
 				"in a raid1 volume\n");
 		return 0;
@@ -2819,7 +3153,7 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
 	map->num_members = info->raid_disks;
 	for (i = 0; i < map->num_members; i++) {
 		/* initialized in add_to_super */
-		set_imsm_ord_tbl_ent(map, i, 0);
+		set_imsm_ord_tbl_ent(map, i, IMSM_ORD_REBUILD);
 	}
 	mpb->num_raid_devs++;
 
@@ -2858,7 +3192,7 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info,
 	else
 		mpb_size = 512;
 
-	super = alloc_super(1);
+	super = alloc_super();
 	if (super && posix_memalign(&super->buf, 512, mpb_size) != 0) {
 		free(super);
 		super = NULL;
@@ -2897,6 +3231,7 @@ static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk,
 	struct dl *dl;
 	struct imsm_dev *dev;
 	struct imsm_map *map;
+	int slot;
 
 	dev = get_imsm_dev(super, super->current_vol);
 	map = get_imsm_map(dev, 0);
@@ -2931,6 +3266,14 @@ static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk,
 		dl->index = super->anchor->num_disks;
 		super->anchor->num_disks++;
 	}
+	/* Check the device has not already been added */
+	slot = get_imsm_disk_slot(map, dl->index);
+	if (slot >= 0 &&
+	    (get_imsm_ord_tbl_ent(dev, slot) & IMSM_ORD_REBUILD) == 0) {
+		fprintf(stderr, Name ": %s has been included in this array twice\n",
+			devname);
+		return 1;
+	}
 	set_imsm_ord_tbl_ent(map, dk->number, dl->index);
 	dl->disk.status = CONFIGURED_DISK;
 
@@ -3225,8 +3568,12 @@ static int write_init_super_imsm(struct supertype *st)
 		}
 
 		return rv;
-	} else
+	} else {
+		struct dl *d;
+		for (d = super->disks; d; d = d->next)
+			Kill(d->devname, NULL, 0, 1, 1);
 		return write_super_imsm(st->sb, 1);
+	}
 }
 #endif
 
@@ -3339,7 +3686,7 @@ static unsigned long long merge_extents(struct intel_super *super, int sum_exten
 	unsigned long reserve;
 
 	if (!e)
-		return ~0ULL; /* error */
+		return 0;
 
 	/* coalesce and sort all extents. also, check to see if we need to
 	 * reserve space between member arrays
@@ -3382,17 +3729,23 @@ static unsigned long long merge_extents(struct intel_super *super, int sum_exten
 	} while (e[i-1].size);
 	free(e);
 
+	if (maxsize == 0)
+		return 0;
+
+	/* FIXME assumes volume at offset 0 is the first volume in a
+	 * container
+	 */
 	if (start_extent > 0)
 		reserve = IMSM_RESERVED_SECTORS; /* gap between raid regions */
 	else
 		reserve = 0;
 
 	if (maxsize < reserve)
-		return ~0ULL;
+		return 0;
 
 	super->create_offset = ~((__u32) 0);
 	if (start + reserve > super->create_offset)
-		return ~0ULL; /* start overflows create_offset */
+		return 0; /* start overflows create_offset */
 	super->create_offset = start + reserve;
 
 	return maxsize - reserve;
@@ -3421,6 +3774,34 @@ static int is_raid_level_supported(const struct imsm_orom *orom, int level, int
 }
 
 #define pr_vrb(fmt, arg...) (void) (verbose && fprintf(stderr, Name fmt, ##arg))
+static int
+validate_geometry_imsm_orom(struct intel_super *super, int level, int layout,
+			    int raiddisks, int chunk, int verbose)
+{
+	if (!is_raid_level_supported(super->orom, level, raiddisks)) {
+		pr_vrb(": platform does not support raid%d with %d disk%s\n",
+			level, raiddisks, raiddisks > 1 ? "s" : "");
+		return 0;
+	}
+	if (super->orom && level != 1 &&
+	    !imsm_orom_has_chunk(super->orom, chunk)) {
+		pr_vrb(": platform does not support a chunk size of: %d\n", chunk);
+		return 0;
+	}
+	if (layout != imsm_level_to_layout(level)) {
+		if (level == 5)
+			pr_vrb(": imsm raid 5 only supports the left-asymmetric layout\n");
+		else if (level == 10)
+			pr_vrb(": imsm raid 10 only supports the n2 layout\n");
+		else
+			pr_vrb(": imsm unknown layout %#x for this raid level %d\n",
+				layout, level);
+		return 0;
+	}
+
+	return 1;
+}
+
 /* validate_geometry_imsm_volume - lifted from validate_geometry_ddf_bvd 
  * FIX ME add ahci details
  */
@@ -3432,7 +3813,7 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level,
 {
 	struct stat stb;
 	struct intel_super *super = st->sb;
-	struct imsm_super *mpb;
+	struct imsm_super *mpb = super->anchor;
 	struct dl *dl;
 	unsigned long long pos = 0;
 	unsigned long long maxsize;
@@ -3442,28 +3823,9 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level,
 	/* We must have the container info already read in. */
 	if (!super)
 		return 0;
-	mpb = super->anchor;
 
-	if (!is_raid_level_supported(super->orom, level, raiddisks)) {
-		pr_vrb(": platform does not support raid%d with %d disk%s\n",
-			level, raiddisks, raiddisks > 1 ? "s" : "");
-		return 0;
-	}
-	if (super->orom && level != 1 &&
-	    !imsm_orom_has_chunk(super->orom, chunk)) {
-		pr_vrb(": platform does not support a chunk size of: %d\n", chunk);
+	if (!validate_geometry_imsm_orom(super, level, layout, raiddisks, chunk, verbose))
 		return 0;
-	}
-	if (layout != imsm_level_to_layout(level)) {
-		if (level == 5)
-			pr_vrb(": imsm raid 5 only supports the left-asymmetric layout\n");
-		else if (level == 10)
-			pr_vrb(": imsm raid 10 only supports the n2 layout\n");
-		else
-			pr_vrb(": imsm unknown layout %#x for this raid level %d\n",
-				layout, level);
-		return 0;
-	}
 
 	if (!dev) {
 		/* General test:  make sure there is space for
@@ -3471,7 +3833,7 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level,
 		 * offset
 		 */
 		unsigned long long minsize = size;
-		unsigned long long start_offset = ~0ULL;
+		unsigned long long start_offset = MaxSector;
 		int dcnt = 0;
 		if (minsize == 0)
 			minsize = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
@@ -3487,7 +3849,7 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level,
 				esize = e[i].start - pos;
 				if (esize >= minsize)
 					found = 1;
-				if (found && start_offset == ~0ULL) {
+				if (found && start_offset == MaxSector) {
 					start_offset = pos;
 					break;
 				} else if (found && pos != start_offset) {
@@ -3518,8 +3880,8 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level,
 	if ((S_IFMT & stb.st_mode) != S_IFBLK)
 		return 0;
 	for (dl = super->disks ; dl ; dl = dl->next) {
-		if (dl->major == major(stb.st_rdev) &&
-		    dl->minor == minor(stb.st_rdev))
+		if (dl->major == (int)major(stb.st_rdev) &&
+		    dl->minor == (int)minor(stb.st_rdev))
 			break;
 	}
 	if (!dl) {
@@ -3576,15 +3938,11 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level,
 			i += dl->extent_cnt;
 
 	maxsize = merge_extents(super, i);
-	if (maxsize < size) {
+	if (maxsize < size || maxsize == 0) {
 		if (verbose)
 			fprintf(stderr, Name ": not enough space after merge (%llu < %llu)\n",
 				maxsize, size);
 		return 0;
-	} else if (maxsize == ~0ULL) {
-		if (verbose)
-			fprintf(stderr, Name ": failed to merge %d extents\n", i);
-		return 0;
 	}
 
 	*freesize = maxsize;
@@ -3641,7 +3999,8 @@ static int reserve_space(struct supertype *st, int raiddisks,
 
 	if (cnt < raiddisks ||
 	    (super->orom && used && used != raiddisks) ||
-	    maxsize < minsize) {
+	    maxsize < minsize ||
+	    maxsize == 0) {
 		fprintf(stderr, Name ": not enough devices with space to create array.\n");
 		return 0; /* No enough free spaces large enough */
 	}
@@ -3694,6 +4053,10 @@ static int validate_geometry_imsm(struct supertype *st, int level, int layout,
 			 * created.  add_to_super and getinfo_super
 			 * detect when autolayout is in progress.
 			 */
+			if (!validate_geometry_imsm_orom(st->sb, level, layout,
+							 raiddisks, chunk,
+							 verbose))
+				return 0;
 			return reserve_space(st, raiddisks, size, chunk, freesize);
 		}
 		return 1;
@@ -3705,21 +4068,6 @@ static int validate_geometry_imsm(struct supertype *st, int level, int layout,
 						     dev, freesize, verbose);
 	}
 
-	/* limit creation to the following levels */
-	if (!dev)
-		switch (level) {
-		case 0:
-		case 1:
-		case 10:
-		case 5:
-			return 0;
-		default:
-			if (verbose)
-				fprintf(stderr, Name
-					": IMSM only supports levels 0,1,5,10\n");
-			return 1;
-		}
-
 	/* This device needs to be a device in an 'imsm' container */
 	fd = open(dev, O_RDONLY|O_EXCL, 0);
 	if (fd >= 0) {
@@ -3773,8 +4121,191 @@ static int validate_geometry_imsm(struct supertype *st, int level, int layout,
 	close(cfd);
 	return 0;
 }
+
+static int default_chunk_imsm(struct supertype *st)
+{
+	struct intel_super *super = st->sb;
+
+	if (!super->orom)
+		return 0;
+
+	return imsm_orom_default_chunk(super->orom);
+}
+
+static void handle_missing(struct intel_super *super, struct imsm_dev *dev);
+
+static int kill_subarray_imsm(struct supertype *st)
+{
+	/* remove the subarray currently referenced by ->current_vol */
+	__u8 i;
+	struct intel_dev **dp;
+	struct intel_super *super = st->sb;
+	__u8 current_vol = super->current_vol;
+	struct imsm_super *mpb = super->anchor;
+
+	if (super->current_vol < 0)
+		return 2;
+	super->current_vol = -1; /* invalidate subarray cursor */
+
+	/* block deletions that would change the uuid of active subarrays
+	 *
+	 * FIXME when immutable ids are available, but note that we'll
+	 * also need to fixup the invalidated/active subarray indexes in
+	 * mdstat
+	 */
+	for (i = 0; i < mpb->num_raid_devs; i++) {
+		char subarray[4];
+
+		if (i < current_vol)
+			continue;
+		sprintf(subarray, "%u", i);
+		if (is_subarray_active(subarray, st->devname)) {
+			fprintf(stderr,
+				Name ": deleting subarray-%d would change the UUID of active subarray-%d, aborting\n",
+				current_vol, i);
+
+			return 2;
+		}
+	}
+
+	if (st->update_tail) {
+		struct imsm_update_kill_array *u = malloc(sizeof(*u));
+
+		if (!u)
+			return 2;
+		u->type = update_kill_array;
+		u->dev_idx = current_vol;
+		append_metadata_update(st, u, sizeof(*u));
+
+		return 0;
+	}
+
+	for (dp = &super->devlist; *dp;)
+		if ((*dp)->index == current_vol) {
+			*dp = (*dp)->next;
+		} else {
+			handle_missing(super, (*dp)->dev);
+			if ((*dp)->index > current_vol)
+				(*dp)->index--;
+			dp = &(*dp)->next;
+		}
+
+	/* no more raid devices, all active components are now spares,
+	 * but of course failed are still failed
+	 */
+	if (--mpb->num_raid_devs == 0) {
+		struct dl *d;
+
+		for (d = super->disks; d; d = d->next)
+			if (d->index > -2) {
+				d->index = -1;
+				d->disk.status = SPARE_DISK;
+			}
+	}
+
+	super->updates_pending++;
+
+	return 0;
+}
+
+static int update_subarray_imsm(struct supertype *st, char *update, mddev_ident_t ident)
+{
+	/* update the subarray currently referenced by ->current_vol */
+	struct intel_super *super = st->sb;
+	struct imsm_super *mpb = super->anchor;
+
+	if (super->current_vol < 0)
+		return 2;
+
+	if (strcmp(update, "name") == 0) {
+		char *name = ident->name;
+
+		if (is_subarray_active(st->subarray, st->devname)) {
+			fprintf(stderr,
+				Name ": Unable to update name of active subarray\n");
+			return 2;
+		}
+
+		if (!check_name(super, name, 0))
+			return 2;
+
+		if (st->update_tail) {
+			struct imsm_update_rename_array *u = malloc(sizeof(*u));
+
+			if (!u)
+				return 2;
+			u->type = update_rename_array;
+			u->dev_idx = super->current_vol;
+			snprintf((char *) u->name, MAX_RAID_SERIAL_LEN, "%s", name);
+			append_metadata_update(st, u, sizeof(*u));
+		} else {
+			struct imsm_dev *dev;
+			int i;
+
+			dev = get_imsm_dev(super, super->current_vol);
+			snprintf((char *) dev->volume, MAX_RAID_SERIAL_LEN, "%s", name);
+			for (i = 0; i < mpb->num_raid_devs; i++) {
+				dev = get_imsm_dev(super, i);
+				handle_missing(super, dev);
+			}
+			super->updates_pending++;
+		}
+	} else
+		return 2;
+
+	return 0;
+}
 #endif /* MDASSEMBLE */
 
+static int is_rebuilding(struct imsm_dev *dev)
+{
+	struct imsm_map *migr_map;
+
+	if (!dev->vol.migr_state)
+		return 0;
+
+	if (migr_type(dev) != MIGR_REBUILD)
+		return 0;
+
+	migr_map = get_imsm_map(dev, 1);
+
+	if (migr_map->map_state == IMSM_T_STATE_DEGRADED)
+		return 1;
+	else
+		return 0;
+}
+
+static void update_recovery_start(struct imsm_dev *dev, struct mdinfo *array)
+{
+	struct mdinfo *rebuild = NULL;
+	struct mdinfo *d;
+	__u32 units;
+
+	if (!is_rebuilding(dev))
+		return;
+
+	/* Find the rebuild target, but punt on the dual rebuild case */
+	for (d = array->devs; d; d = d->next)
+		if (d->recovery_start == 0) {
+			if (rebuild)
+				return;
+			rebuild = d;
+		}
+
+	if (!rebuild) {
+		/* (?) none of the disks are marked with
+		 * IMSM_ORD_REBUILD, so assume they are missing and the
+		 * disk_ord_tbl was not correctly updated
+		 */
+		dprintf("%s: failed to locate out-of-sync disk\n", __func__);
+		return;
+	}
+
+	units = __le32_to_cpu(dev->vol.curr_migr_unit);
+	rebuild->recovery_start = units * blocks_per_migr_unit(dev);
+}
+
+
 static struct mdinfo *container_content_imsm(struct supertype *st)
 {
 	/* Given a container loaded by load_super_imsm_all,
@@ -3817,7 +4348,7 @@ static struct mdinfo *container_content_imsm(struct supertype *st)
 
 		this = malloc(sizeof(*this));
 		if (!this) {
-			fprintf(stderr, Name ": failed to allocate %lu bytes\n",
+			fprintf(stderr, Name ": failed to allocate %zu bytes\n",
 				sizeof(*this));
 			break;
 		}
@@ -3827,6 +4358,7 @@ static struct mdinfo *container_content_imsm(struct supertype *st)
 		super->current_vol = i;
 		getinfo_super_imsm_volume(st, this);
 		for (slot = 0 ; slot <  map->num_members; slot++) {
+			unsigned long long recovery_start;
 			struct mdinfo *info_d;
 			struct dl *d;
 			int idx;
@@ -3840,33 +4372,41 @@ static struct mdinfo *container_content_imsm(struct supertype *st)
 				if (d->index == idx)
 					break;
 
+			recovery_start = MaxSector;
 			if (d == NULL)
 				skip = 1;
 			if (d && is_failed(&d->disk))
 				skip = 1;
 			if (ord & IMSM_ORD_REBUILD)
-				skip = 1;
+				recovery_start = 0;
 
 			/* 
 			 * if we skip some disks the array will be assmebled degraded;
-			 * reset resync start to avoid a dirty-degraded situation
+			 * reset resync start to avoid a dirty-degraded
+			 * situation when performing the intial sync
 			 *
 			 * FIXME handle dirty degraded
 			 */
-			if (skip && !dev->vol.dirty)
-				this->resync_start = ~0ULL;
+			if ((skip || recovery_start == 0) && !dev->vol.dirty)
+				this->resync_start = MaxSector;
 			if (skip)
 				continue;
 
-			info_d = malloc(sizeof(*info_d));
+			info_d = calloc(1, sizeof(*info_d));
 			if (!info_d) {
 				fprintf(stderr, Name ": failed to allocate disk"
 					" for volume %.16s\n", dev->volume);
+				info_d = this->devs;
+				while (info_d) {
+					struct mdinfo *d = info_d->next;
+
+					free(info_d);
+					info_d = d;
+				}
 				free(this);
 				this = rest;
 				break;
 			}
-			memset(info_d, 0, sizeof(*info_d));
 			info_d->next = this->devs;
 			this->devs = info_d;
 
@@ -3874,13 +4414,17 @@ static struct mdinfo *container_content_imsm(struct supertype *st)
 			info_d->disk.major = d->major;
 			info_d->disk.minor = d->minor;
 			info_d->disk.raid_disk = slot;
+			info_d->recovery_start = recovery_start;
 
-			this->array.working_disks++;
+			if (info_d->recovery_start == MaxSector)
+				this->array.working_disks++;
 
 			info_d->events = __le32_to_cpu(mpb->generation_num);
 			info_d->data_offset = __le32_to_cpu(map->pba_of_lba0);
 			info_d->component_size = __le32_to_cpu(map->blocks_per_member);
 		}
+		/* now that the disk list is up-to-date fixup recovery_start */
+		update_recovery_start(dev, this);
 		rest = this;
 	}
 
@@ -3888,24 +4432,6 @@ static struct mdinfo *container_content_imsm(struct supertype *st)
 }
 
 
-#ifndef MDASSEMBLE
-static int imsm_open_new(struct supertype *c, struct active_array *a,
-			 char *inst)
-{
-	struct intel_super *super = c->sb;
-	struct imsm_super *mpb = super->anchor;
-	
-	if (atoi(inst) >= mpb->num_raid_devs) {
-		fprintf(stderr, "%s: subarry index %d, out of range\n",
-			__func__, atoi(inst));
-		return -ENODEV;
-	}
-
-	dprintf("imsm: open_new %s\n", inst);
-	a->info.container_member = atoi(inst);
-	return 0;
-}
-
 static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev, int failed)
 {
 	struct imsm_map *map = get_imsm_map(dev, 0);
@@ -4004,6 +4530,24 @@ static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev)
 	return failed;
 }
 
+#ifndef MDASSEMBLE
+static int imsm_open_new(struct supertype *c, struct active_array *a,
+			 char *inst)
+{
+	struct intel_super *super = c->sb;
+	struct imsm_super *mpb = super->anchor;
+	
+	if (atoi(inst) >= mpb->num_raid_devs) {
+		fprintf(stderr, "%s: subarry index %d, out of range\n",
+			__func__, atoi(inst));
+		return -ENODEV;
+	}
+
+	dprintf("imsm: open_new %s\n", inst);
+	a->info.container_member = atoi(inst);
+	return 0;
+}
+
 static int is_resyncing(struct imsm_dev *dev)
 {
 	struct imsm_map *migr_map;
@@ -4023,24 +4567,6 @@ static int is_resyncing(struct imsm_dev *dev)
 		return 0;
 }
 
-static int is_rebuilding(struct imsm_dev *dev)
-{
-	struct imsm_map *migr_map;
-
-	if (!dev->vol.migr_state)
-		return 0;
-
-	if (migr_type(dev) != MIGR_REBUILD)
-		return 0;
-
-	migr_map = get_imsm_map(dev, 1);
-
-	if (migr_map->map_state == IMSM_T_STATE_DEGRADED)
-		return 1;
-	else
-		return 0;
-}
-
 /* return true if we recorded new information */
 static int mark_failure(struct imsm_dev *dev, struct imsm_disk *disk, int idx)
 {
@@ -4062,7 +4588,7 @@ static int mark_failure(struct imsm_dev *dev, struct imsm_disk *disk, int idx)
 	disk->status |= FAILED_DISK;
 	disk->status &= ~CONFIGURED_DISK;
 	set_imsm_ord_tbl_ent(map, slot, idx | IMSM_ORD_REBUILD);
-	if (~map->failed_disk_num == 0)
+	if (map->failed_disk_num == 0xff)
 		map->failed_disk_num = slot;
 	return 1;
 }
@@ -4078,6 +4604,24 @@ static void mark_missing(struct imsm_dev *dev, struct imsm_disk *disk, int idx)
 	memmove(&disk->serial[0], &disk->serial[1], MAX_RAID_SERIAL_LEN - 1);
 }
 
+static void handle_missing(struct intel_super *super, struct imsm_dev *dev)
+{
+	__u8 map_state;
+	struct dl *dl;
+	int failed;
+
+	if (!super->missing)
+		return;
+	failed = imsm_count_failed(super, dev);
+	map_state = imsm_check_degraded(super, dev, failed);
+
+	dprintf("imsm: mark missing\n");
+	end_migration(dev, map_state);
+	for (dl = super->missing; dl; dl = dl->next)
+		mark_missing(dev, &dl->disk, dl->index);
+	super->updates_pending++;
+}
+
 /* Handle dirty -> clean transititions and resync.  Degraded and rebuild
  * states are handled in imsm_set_disk() with one exception, when a
  * resync is stopped due to a new failure this routine will set the
@@ -4091,25 +4635,19 @@ static int imsm_set_array_state(struct active_array *a, int consistent)
 	struct imsm_map *map = get_imsm_map(dev, 0);
 	int failed = imsm_count_failed(super, dev);
 	__u8 map_state = imsm_check_degraded(super, dev, failed);
+	__u32 blocks_per_unit;
 
 	/* before we activate this array handle any missing disks */
-	if (consistent == 2 && super->missing) {
-		struct dl *dl;
+	if (consistent == 2)
+		handle_missing(super, dev);
 
-		dprintf("imsm: mark missing\n");
-		end_migration(dev, map_state);
-		for (dl = super->missing; dl; dl = dl->next)
-			mark_missing(dev, &dl->disk, dl->index);
-		super->updates_pending++;
-	}
-		
 	if (consistent == 2 &&
-	    (!is_resync_complete(a) ||
+	    (!is_resync_complete(&a->info) ||
 	     map_state != IMSM_T_STATE_NORMAL ||
 	     dev->vol.migr_state))
 		consistent = 0;
 
-	if (is_resync_complete(a)) {
+	if (is_resync_complete(&a->info)) {
 		/* complete intialization / resync,
 		 * recovery and interrupted recovery is completed in
 		 * ->set_disk
@@ -4118,10 +4656,11 @@ static int imsm_set_array_state(struct active_array *a, int consistent)
 			dprintf("imsm: mark resync done\n");
 			end_migration(dev, map_state);
 			super->updates_pending++;
+			a->last_checkpoint = 0;
 		}
 	} else if (!is_resyncing(dev) && !failed) {
 		/* mark the start of the init process if nothing is failed */
-		dprintf("imsm: mark resync start (%llu)\n", a->resync_start);
+		dprintf("imsm: mark resync start\n");
 		if (map->map_state == IMSM_T_STATE_UNINITIALIZED)
 			migrate(dev, IMSM_T_STATE_NORMAL, MIGR_INIT);
 		else
@@ -4129,12 +4668,29 @@ static int imsm_set_array_state(struct active_array *a, int consistent)
 		super->updates_pending++;
 	}
 
-	 /* FIXME check if we can update curr_migr_unit from resync_start */
+	/* check if we can update curr_migr_unit from resync_start, recovery_start */
+	blocks_per_unit = blocks_per_migr_unit(dev);
+	if (blocks_per_unit) {
+		__u32 units32;
+		__u64 units;
+
+		units = a->last_checkpoint / blocks_per_unit;
+		units32 = units;
+
+		/* check that we did not overflow 32-bits, and that
+		 * curr_migr_unit needs updating
+		 */
+		if (units32 == units &&
+		    __le32_to_cpu(dev->vol.curr_migr_unit) != units32) {
+			dprintf("imsm: mark checkpoint (%u)\n", units32);
+			dev->vol.curr_migr_unit = __cpu_to_le32(units32);
+			super->updates_pending++;
+		}
+	}
 
 	/* mark dirty / clean */
 	if (dev->vol.dirty != !consistent) {
-		dprintf("imsm: mark '%s' (%llu)\n",
-			consistent ? "clean" : "dirty", a->resync_start);
+		dprintf("imsm: mark '%s'\n", consistent ? "clean" : "dirty");
 		if (consistent)
 			dev->vol.dirty = 0;
 		else
@@ -4190,17 +4746,20 @@ static void imsm_set_disk(struct active_array *a, int n, int state)
 		map = get_imsm_map(dev, 0);
 		map->failed_disk_num = ~0;
 		super->updates_pending++;
+		a->last_checkpoint = 0;
 	} else if (map_state == IMSM_T_STATE_DEGRADED &&
 		   map->map_state != map_state &&
 		   !dev->vol.migr_state) {
 		dprintf("imsm: mark degraded\n");
 		map->map_state = map_state;
 		super->updates_pending++;
+		a->last_checkpoint = 0;
 	} else if (map_state == IMSM_T_STATE_FAILED &&
 		   map->map_state != map_state) {
 		dprintf("imsm: mark failed\n");
 		end_migration(dev, map_state);
 		super->updates_pending++;
+		a->last_checkpoint = 0;
 	}
 }
 
@@ -4221,7 +4780,8 @@ static int store_imsm_mpb(int fd, struct imsm_super *mpb)
 		if (lseek64(fd, dsize - (512 * (2 + sectors)), SEEK_SET) < 0)
 			return 1;
 
-		if (write(fd, buf + 512, 512 * sectors) != 512 * sectors)
+		if ((unsigned long long)write(fd, buf + 512, 512 * sectors)
+		    != 512 * sectors)
 			return 1;
 	}
 
@@ -4278,8 +4838,8 @@ static struct dl *imsm_add_spare(struct intel_super *super, int slot,
 	struct extent *ex;
 	int i, j;
 	int found;
-	__u32 array_start;
-	__u32 array_end;
+	__u32 array_start = 0;
+	__u32 array_end = 0;
 	struct dl *dl;
 
 	for (dl = super->disks; dl; dl = dl->next) {
@@ -4451,6 +5011,7 @@ static struct mdinfo *imsm_activate_spare(struct active_array *a,
 		di->disk.major = dl->major;
 		di->disk.minor = dl->minor;
 		di->disk.state = 0;
+		di->recovery_start = 0;
 		di->data_offset = __le32_to_cpu(map->pba_of_lba0);
 		di->component_size = a->info.component_size;
 		di->container_member = inst;
@@ -4529,7 +5090,7 @@ static int disks_overlap(struct intel_super *super, int idx, struct imsm_update_
 	return 0;
 }
 
-static void imsm_delete(struct intel_super *super, struct dl **dlp, int index);
+static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned index);
 
 static void imsm_process_update(struct supertype *st,
 			        struct metadata_update *update)
@@ -4776,6 +5337,70 @@ static void imsm_process_update(struct supertype *st,
 		}
 		break;
 	}
+	case update_kill_array: {
+		struct imsm_update_kill_array *u = (void *) update->buf;
+		int victim = u->dev_idx;
+		struct active_array *a;
+		struct intel_dev **dp;
+		struct imsm_dev *dev;
+
+		/* sanity check that we are not affecting the uuid of
+		 * active arrays, or deleting an active array
+		 *
+		 * FIXME when immutable ids are available, but note that
+		 * we'll also need to fixup the invalidated/active
+		 * subarray indexes in mdstat
+		 */
+		for (a = st->arrays; a; a = a->next)
+			if (a->info.container_member >= victim)
+				break;
+		/* by definition if mdmon is running at least one array
+		 * is active in the container, so checking
+		 * mpb->num_raid_devs is just extra paranoia
+		 */
+		dev = get_imsm_dev(super, victim);
+		if (a || !dev || mpb->num_raid_devs == 1) {
+			dprintf("failed to delete subarray-%d\n", victim);
+			break;
+		}
+
+		for (dp = &super->devlist; *dp;)
+			if ((*dp)->index == (unsigned)super->current_vol) {
+				*dp = (*dp)->next;
+			} else {
+				if ((*dp)->index > (unsigned)victim)
+					(*dp)->index--;
+				dp = &(*dp)->next;
+			}
+		mpb->num_raid_devs--;
+		super->updates_pending++;
+		break;
+	}
+	case update_rename_array: {
+		struct imsm_update_rename_array *u = (void *) update->buf;
+		char name[MAX_RAID_SERIAL_LEN+1];
+		int target = u->dev_idx;
+		struct active_array *a;
+		struct imsm_dev *dev;
+
+		/* sanity check that we are not affecting the uuid of
+		 * an active array
+		 */
+		snprintf(name, MAX_RAID_SERIAL_LEN, "%s", (char *) u->name);
+		name[MAX_RAID_SERIAL_LEN] = '\0';
+		for (a = st->arrays; a; a = a->next)
+			if (a->info.container_member == target)
+				break;
+		dev = get_imsm_dev(super, u->dev_idx);
+		if (a || !dev || !check_name(super, name, 1)) {
+			dprintf("failed to rename subarray-%d\n", target);
+			break;
+		}
+
+		snprintf((char *) dev->volume, MAX_RAID_SERIAL_LEN, "%s", name);
+		super->updates_pending++;
+		break;
+	}
 	case update_add_disk:
 
 		/* we may be able to repair some arrays if disks are
@@ -4887,7 +5512,7 @@ static void imsm_prepare_update(struct supertype *st,
 }
 
 /* must be called while manager is quiesced */
-static void imsm_delete(struct intel_super *super, struct dl **dlp, int index)
+static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned index)
 {
 	struct imsm_super *mpb = super->anchor;
 	struct dl *iter;
@@ -4901,10 +5526,10 @@ static void imsm_delete(struct intel_super *super, struct dl **dlp, int index)
 
 	/* shift all indexes down one */
 	for (iter = super->disks; iter; iter = iter->next)
-		if (iter->index > index)
+		if (iter->index > (int)index)
 			iter->index--;
 	for (iter = super->missing; iter; iter = iter->next)
-		if (iter->index > index)
+		if (iter->index > (int)index)
 			iter->index--;
 
 	for (i = 0; i < mpb->num_raid_devs; i++) {
@@ -4949,8 +5574,11 @@ struct superswitch super_imsm = {
 	.brief_detail_super = brief_detail_super_imsm,
 	.write_init_super = write_init_super_imsm,
 	.validate_geometry = validate_geometry_imsm,
+	.default_chunk	= default_chunk_imsm,
 	.add_to_super	= add_to_super_imsm,
 	.detail_platform = detail_platform_imsm,
+	.kill_subarray = kill_subarray_imsm,
+	.update_subarray = update_subarray_imsm,
 #endif
 	.match_home	= match_home_imsm,
 	.uuid_from_super= uuid_from_super_imsm,
@@ -4975,7 +5603,6 @@ struct superswitch super_imsm = {
 #ifndef MDASSEMBLE
 /* for mdmon */
 	.open_new	= imsm_open_new,
-	.load_super	= load_super_imsm,
 	.set_array_state= imsm_set_array_state,
 	.set_disk	= imsm_set_disk,
 	.sync_metadata	= imsm_sync_metadata,