X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=super0.c;h=9f78b9452dec9e04792760500310769a0b277258;hp=87ef1e06158b2946224ef59f94c316bd233cee6c;hb=672ca1b7272c69ea3055aeb746a77b8408e5f3ed;hpb=e7bb5d23a9b29ae6f316fe3ce8970301e1bc0d4d

diff --git a/super0.c b/super0.c
index 87ef1e06..9f78b945 100644
--- a/super0.c
+++ b/super0.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,16 +19,12 @@
  *    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>
  */
 
+#define HAVE_STDINT_H 1
 #include "mdadm.h"
-#include <openssl/sha.h> /* for SHA1 */
+#include "sha1.h"
 /*
  * All handling for the 0.90.0 version superblock is in
  * this file.
@@ -37,7 +33,7 @@
  *   - initialising a new superblock
  *   - printing the superblock for --examine
  *   - printing part of the superblock for --detail
- * .. other stuff 
+ * .. other stuff
  */
 
 
@@ -52,10 +48,10 @@ static unsigned long calc_sb0_csum(mdp_super_t *super)
 }
 
 
-void super0_swap_endian(struct mdp_superblock_s *sb)
+static void super0_swap_endian(struct mdp_superblock_s *sb)
 {
 	/* as super0 superblocks are host-endian, it is sometimes
-	 * useful to be able to swap the endianness 
+	 * useful to be able to swap the endianness
 	 * as (almost) everything is u32's we byte-swap every 4byte
 	 * number.
 	 * We then also have to swap the events_hi and events_lo
@@ -84,23 +80,25 @@ void super0_swap_endian(struct mdp_superblock_s *sb)
 
 #ifndef MDASSEMBLE
 
-static void examine_super0(void *sbv, char *homehost)
+static void examine_super0(struct supertype *st, char *homehost)
 {
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	time_t atime;
 	int d;
+	int delta_extra = 0;
 	char *c;
 
 	printf("          Magic : %08x\n", sb->md_magic);
-	printf("        Version : %02d.%02d.%02d\n", sb->major_version, sb->minor_version,
+	printf("        Version : %d.%02d.%02d\n", sb->major_version, sb->minor_version,
 	       sb->patch_version);
 	if (sb->minor_version >= 90) {
 		printf("           UUID : %08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
 		       sb->set_uuid2, sb->set_uuid3);
 		if (homehost) {
-			unsigned char *hash = SHA1((unsigned char *)homehost,
-						   strlen(homehost),
-						   NULL);
+			char buf[20];
+			void *hash = sha1_buffer(homehost,
+						 strlen(homehost),
+						 buf);
 			if (memcmp(&sb->set_uuid2, hash, 8)==0)
 				printf(" (local to host %s)", homehost);
 		}
@@ -108,13 +106,17 @@ static void examine_super0(void *sbv, char *homehost)
 	} else
 		printf("           UUID : %08x\n", sb->set_uuid0);
 
+	if (sb->not_persistent)
+		printf("           Eedk : not persistent\n");
+
 	atime = sb->ctime;
 	printf("  Creation Time : %.24s\n", ctime(&atime));
 	c=map_num(pers, sb->level);
 	printf("     Raid Level : %s\n", c?c:"-unknown-");
 	if ((int)sb->level >= 0) {
 		int ddsks=0;
-		printf("    Device Size : %d%s\n", sb->size, human_size((long long)sb->size<<10));
+		printf("  Used Dev Size : %d%s\n", sb->size,
+		       human_size((long long)sb->size<<10));
 		switch(sb->level) {
 		case 1: ddsks=1;break;
 		case 4:
@@ -134,10 +136,9 @@ static void examine_super0(void *sbv, char *homehost)
 		printf("  Reshape pos'n : %llu%s\n", (unsigned long long)sb->reshape_position/2, human_size((long long)sb->reshape_position<<9));
 		if (sb->delta_disks) {
 			printf("  Delta Devices : %d", sb->delta_disks);
-			if (sb->delta_disks)
-				printf(" (%d->%d)\n", sb->raid_disks-sb->delta_disks, sb->raid_disks);
-			else
-				printf(" (%d->%d)\n", sb->raid_disks, sb->raid_disks+sb->delta_disks);
+			printf(" (%d->%d)\n", sb->raid_disks-sb->delta_disks, sb->raid_disks);
+			if (((int)sb->delta_disks) < 0)
+				delta_extra = - sb->delta_disks;
 		}
 		if (sb->new_level != sb->level) {
 			c = map_num(pers, sb->new_level);
@@ -148,6 +149,10 @@ static void examine_super0(void *sbv, char *homehost)
 				c = map_num(r5layout, sb->new_layout);
 				printf("     New Layout : %s\n", c?c:"-unknown-");
 			}
+			if (sb->level == 6) {
+				c = map_num(r6layout, sb->new_layout);
+				printf("     New Layout : %s\n", c?c:"-unknown-");
+			}
 			if (sb->level == 10) {
 				printf("     New Layout : near=%d, %s=%d\n",
 				       sb->new_layout&255,
@@ -173,22 +178,29 @@ static void examine_super0(void *sbv, char *homehost)
 		printf("       Checksum : %x - correct\n", sb->sb_csum);
 	else
 		printf("       Checksum : %x - expected %lx\n", sb->sb_csum, calc_sb0_csum(sb));
-	printf("         Events : %d.%d\n", sb->events_hi, sb->events_lo);
+	printf("         Events : %llu\n",
+	       ((unsigned long long)sb->events_hi << 32)
+	       + sb->events_lo);
 	printf("\n");
 	if (sb->level == 5) {
 		c = map_num(r5layout, sb->layout);
 		printf("         Layout : %s\n", c?c:"-unknown-");
 	}
+	if (sb->level == 6) {
+		c = map_num(r6layout, sb->layout);
+		printf("         Layout : %s\n", c?c:"-unknown-");
+	}
 	if (sb->level == 10) {
-		printf("         Layout : near=%d, %s=%d\n",
-		       sb->layout&255,
-		       (sb->layout&0x10000)?"offset":"far",
-		       (sb->layout>>8)&255);
+		printf("         Layout :");
+		print_r10_layout(sb->layout);
+		printf("\n");
 	}
 	switch(sb->level) {
 	case 0:
 	case 4:
 	case 5:
+	case 6:
+	case 10:
 		printf("     Chunk Size : %dK\n", sb->chunk_size/1024);
 		break;
 	case -1:
@@ -198,7 +210,7 @@ static void examine_super0(void *sbv, char *homehost)
 	}
 	printf("\n");
 	printf("      Number   Major   Minor   RaidDevice State\n");
-	for (d= -1; d<(signed int)(sb->raid_disks+sb->spare_disks); d++) {
+	for (d= -1; d<(signed int)(sb->raid_disks+delta_extra + sb->spare_disks); d++) {
 		mdp_disk_t *dp;
 		char *dv;
 		char nb[5];
@@ -223,27 +235,51 @@ static void examine_super0(void *sbv, char *homehost)
 	}
 }
 
-static void brief_examine_super0(void *sbv)
+static void brief_examine_super0(struct supertype *st, int verbose)
 {
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	char *c=map_num(pers, sb->level);
-	char *nm;
+	char devname[20];
+
+	sprintf(devname, "/dev/md%d", sb->md_minor);
+
+	if (verbose) {
+		printf("ARRAY %s level=%s num-devices=%d",
+		       devname,
+		       c?c:"-unknown-", sb->raid_disks);
+	} else
+		printf("ARRAY %s", devname);
 
-	printf("ARRAY %s level=%s num-devices=%d UUID=",
-	       nm = get_md_name(sb->md_minor),
-	       c?c:"-unknown-", sb->raid_disks);
 	if (sb->minor_version >= 90)
-		printf("%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
+		printf(" UUID=%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
 		       sb->set_uuid2, sb->set_uuid3);
 	else
-		printf("%08x", sb->set_uuid0);
+		printf(" UUID=%08x", sb->set_uuid0);
 	printf("\n");
-	put_md_name(nm);
 }
 
-static void detail_super0(void *sbv, char *homehost)
+static void export_examine_super0(struct supertype *st)
+{
+	mdp_super_t *sb = st->sb;
+
+	printf("MD_LEVEL=%s\n", map_num(pers, sb->level));
+	printf("MD_DEVICES=%d\n", sb->raid_disks);
+	if (sb->minor_version >= 90)
+		printf("MD_UUID=%08x:%08x:%08x:%08x\n",
+		       sb->set_uuid0, sb->set_uuid1,
+		       sb->set_uuid2, sb->set_uuid3);
+	else
+		printf("MD_UUID=%08x\n", sb->set_uuid0);
+	printf("MD_UPDATE_TIME=%llu\n",
+	       __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL);
+	printf("MD_EVENTS=%llu\n",
+	       ((unsigned long long)sb->events_hi << 32)
+	       + sb->events_lo);
+}
+
+static void detail_super0(struct supertype *st, char *homehost)
 {
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	printf("           UUID : ");
 	if (sb->minor_version >= 90)
 		printf("%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
@@ -251,18 +287,19 @@ static void detail_super0(void *sbv, char *homehost)
 	else
 		printf("%08x", sb->set_uuid0);
 	if (homehost) {
-		unsigned char *hash = SHA1((unsigned char *)homehost,
-					   strlen(homehost),
-					   NULL);
+		char buf[20];
+		void *hash = sha1_buffer(homehost,
+					 strlen(homehost),
+					 buf);
 		if (memcmp(&sb->set_uuid2, hash, 8)==0)
 			printf(" (local to host %s)", homehost);
 	}
 	printf("\n         Events : %d.%d\n\n", sb->events_hi, sb->events_lo);
 }
 
-static void brief_detail_super0(void *sbv)
+static void brief_detail_super0(struct supertype *st)
 {
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	printf(" UUID=");
 	if (sb->minor_version >= 90)
 		printf("%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
@@ -272,19 +309,24 @@ static void brief_detail_super0(void *sbv)
 }
 #endif
 
-static int match_home0(void *sbv, char *homehost)
+static int match_home0(struct supertype *st, char *homehost)
 {
-	mdp_super_t *sb = sbv;
-	unsigned char *hash = SHA1((unsigned char *)homehost,
-				   strlen(homehost),
-				   NULL);
+	mdp_super_t *sb = st->sb;
+	char buf[20];
+	char *hash;
+
+	if (!homehost)
+		return 0;
+	hash = sha1_buffer(homehost,
+			   strlen(homehost),
+			   buf);
 
 	return (memcmp(&sb->set_uuid2, hash, 8)==0);
 }
 
-static void uuid_from_super0(int uuid[4], void * sbv)
+static void uuid_from_super0(struct supertype *st, int uuid[4])
 {
-	mdp_super_t *super = sbv;
+	mdp_super_t *super = st->sb;
 	uuid[0] = super->set_uuid0;
 	if (super->minor_version >= 90) {
 		uuid[1] = super->set_uuid1;
@@ -297,9 +339,9 @@ static void uuid_from_super0(int uuid[4], void * sbv)
 	}
 }
 
-static void getinfo_super0(struct mdinfo *info, void *sbv)
+static void getinfo_super0(struct supertype *st, struct mdinfo *info)
 {
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	int working = 0;
 	int i;
 
@@ -313,6 +355,7 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
 	info->array.ctime = sb->ctime;
 	info->array.utime = sb->utime;
 	info->array.chunk_size = sb->chunk_size;
+	info->array.state = sb->state;
 	info->component_size = sb->size*2;
 
 	info->disk.state = sb->this_disk.state;
@@ -324,7 +367,10 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
 	info->events = md_event(sb);
 	info->data_offset = 0;
 
-	uuid_from_super0(info->uuid, sbv);
+	sprintf(info->text_version, "0.%d", sb->minor_version);
+	info->safe_mode_delay = 200;
+
+	uuid_from_super0(st, info->uuid);
 
 	if (sb->minor_version > 90 && (sb->reshape_position+1) != 0) {
 		info->reshape_active = 1;
@@ -333,6 +379,8 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
 		info->delta_disks = sb->delta_disks;
 		info->new_layout = sb->new_layout;
 		info->new_chunk = sb->new_chunk;
+		if (info->delta_disks < 0)
+			info->array.raid_disks -= info->delta_disks;
 	} else
 		info->reshape_active = 0;
 
@@ -340,6 +388,7 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
 	/* work_disks is calculated rather than read directly */
 	for (i=0; i < MD_SB_DISKS; i++)
 		if ((sb->disks[i].state & (1<<MD_DISK_SYNC)) &&
+		    (sb->disks[i].raid_disk < info->array.raid_disks) &&
 		    (sb->disks[i].state & (1<<MD_DISK_ACTIVE)) &&
 		    !(sb->disks[i].state & (1<<MD_DISK_FAULTY)))
 			working ++;
@@ -347,7 +396,8 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
 }
 
 
-static int update_super0(struct mdinfo *info, void *sbv, char *update,
+static int update_super0(struct supertype *st, struct mdinfo *info,
+			 char *update,
 			 char *devname, int verbose,
 			 int uuid_set, char *homehost)
 {
@@ -355,7 +405,7 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 	 * For others, the return value is ignored.
 	 */
 	int rv = 0;
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	if (strcmp(update, "sparc2.2")==0 ) {
 		/* 2.2 sparc put the events in the wrong place
 		 * So we copy the tail of the superblock
@@ -378,14 +428,14 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 	if (strcmp(update, "summaries") == 0) {
 		int i;
 		/* set nr_disks, active_disks, working_disks,
-		 * failed_disks, spare_disks based on disks[] 
+		 * failed_disks, spare_disks based on disks[]
 		 * array in superblock.
 		 * Also make sure extra slots aren't 'failed'
 		 */
 		sb->nr_disks = sb->active_disks =
 			sb->working_disks = sb->failed_disks =
 			sb->spare_disks = 0;
-		for (i=0; i < MD_SB_DISKS ; i++) 
+		for (i=0; i < MD_SB_DISKS ; i++)
 			if (sb->disks[i].major ||
 			    sb->disks[i].minor) {
 				int state = sb->disks[i].state;
@@ -403,13 +453,21 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 			} else if (i >= sb->raid_disks && sb->disks[i].number == 0)
 				sb->disks[i].state = 0;
 	}
-	if (strcmp(update, "force")==0) {
+	if (strcmp(update, "force-one")==0) {
+		/* Not enough devices for a working array, so
+		 * bring this one up-to-date.
+		 */
 		__u32 ehi = sb->events_hi, elo = sb->events_lo;
 		sb->events_hi = (info->events>>32) & 0xFFFFFFFF;
 		sb->events_lo = (info->events) & 0xFFFFFFFF;
 		if (sb->events_hi != ehi ||
 		    sb->events_lo != elo)
 			rv = 1;
+	}
+	if (strcmp(update, "force-array")==0) {
+		/* degraded array and 'force' requested, so
+		 * maybe need to mark it 'clean'
+		 */
 		if ((sb->level == 5 || sb->level == 4 || sb->level == 6) &&
 		    (sb->state & (1 << MD_SB_CLEAN)) == 0) {
 			/* need to force clean */
@@ -420,23 +478,29 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 	if (strcmp(update, "assemble")==0) {
 		int d = info->disk.number;
 		int wonly = sb->disks[d].state & (1<<MD_DISK_WRITEMOSTLY);
-		if ((sb->disks[d].state & ~(1<<MD_DISK_WRITEMOSTLY))
+		int mask = (1<<MD_DISK_WRITEMOSTLY);
+		int add = 0;
+		if (sb->minor_version >= 91)
+			/* During reshape we don't insist on everything
+			 * being marked 'sync'
+			 */
+			add = (1<<MD_DISK_SYNC);
+		if (((sb->disks[d].state & ~mask) | add)
 		    != info->disk.state) {
 			sb->disks[d].state = info->disk.state | wonly;
 			rv = 1;
 		}
 	}
-	if (strcmp(update, "newdev") == 0) {
-		int d = info->disk.number;
-		memset(&sb->disks[d], 0, sizeof(sb->disks[d]));
-		sb->disks[d].number = d;
-		sb->disks[d].major = info->disk.major;
-		sb->disks[d].minor = info->disk.minor;
-		sb->disks[d].raid_disk = info->disk.raid_disk;
-		sb->disks[d].state = info->disk.state;
-		sb->this_disk = sb->disks[d];
-	}
-	if (strcmp(update, "grow") == 0) {
+	if (strcmp(update, "linear-grow-new") == 0) {
+		memset(&sb->disks[info->disk.number], 0, sizeof(sb->disks[0]));
+		sb->disks[info->disk.number].number = info->disk.number;
+		sb->disks[info->disk.number].major = info->disk.major;
+		sb->disks[info->disk.number].minor = info->disk.minor;
+		sb->disks[info->disk.number].raid_disk = info->disk.raid_disk;
+		sb->disks[info->disk.number].state = info->disk.state;
+		sb->this_disk = sb->disks[info->disk.number];
+	}
+	if (strcmp(update, "linear-grow-update") == 0) {
 		sb->raid_disks = info->array.raid_disks;
 		sb->nr_disks = info->array.nr_disks;
 		sb->active_disks = info->array.active_disks;
@@ -447,8 +511,6 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 		sb->disks[info->disk.number].minor = info->disk.minor;
 		sb->disks[info->disk.number].raid_disk = info->disk.raid_disk;
 		sb->disks[info->disk.number].state = info->disk.state;
-		if (sb->this_disk.number == info->disk.number)
-			sb->this_disk = sb->disks[info->disk.number];
 	}
 	if (strcmp(update, "resync") == 0) {
 		/* make sure resync happens */
@@ -464,9 +526,10 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 	}
 	if (strcmp(update, "uuid") == 0) {
 		if (!uuid_set && homehost) {
-			unsigned char *hash = SHA1((unsigned char*)homehost,
-						   strlen(homehost),
-						   NULL);
+			char buf[20];
+			char *hash = sha1_buffer(homehost,
+						 strlen(homehost),
+						 buf);
 			memcpy(info->uuid+2, hash, 8);
 		}
 		sb->set_uuid0 = info->uuid[0];
@@ -476,7 +539,7 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 		if (sb->state & (1<<MD_SB_BITMAP_PRESENT)) {
 			struct bitmap_super_s *bm;
 			bm = (struct bitmap_super_s*)(sb+1);
-			uuid_from_super0((int*)bm->uuid, sbv);
+			uuid_from_super0(st, (int*)bm->uuid);
 		}
 	}
 	if (strcmp(update, "_reshape_progress")==0)
@@ -486,12 +549,6 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update,
 	return rv;
 }
 
-static __u64 event_super0(void *sbv)
-{
-	mdp_super_t *sb = sbv;
-	return md_event(sb);
-}
-
 /*
  * For verion-0 superblock, the homehost is 'stored' in the
  * uuid.  8 bytes for a hash of the host leaving 8 bytes
@@ -501,17 +558,23 @@ static __u64 event_super0(void *sbv)
  */
 
 
-static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
-		       unsigned long long size, char *ignored_name, char *homehost)
+static int init_super0(struct supertype *st, mdu_array_info_t *info,
+		       unsigned long long size, char *ignored_name, char *homehost,
+		       int *uuid)
 {
-	mdp_super_t *sb = malloc(MD_SB_BYTES + sizeof(bitmap_super_t));
+	mdp_super_t *sb;
 	int spares;
-	int rfd;
+
+	if (posix_memalign((void**)&sb, 4096,
+			   MD_SB_BYTES + ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
+		fprintf(stderr, Name ": %s could not allocate superblock\n", __func__);
+		return 0;
+	}
 	memset(sb, 0, MD_SB_BYTES + sizeof(bitmap_super_t));
 
-	if (info->major_version == -1) {
+	st->sb = sb;
+	if (info == NULL) {
 		/* zeroing the superblock */
-		*sbp = sb;
 		return 0;
 	}
 
@@ -522,14 +585,11 @@ static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
 		return 0;
 	}
 
-	rfd = open("/dev/urandom", O_RDONLY);
 	sb->md_magic = MD_SB_MAGIC;
 	sb->major_version = 0;
 	sb->minor_version = 90;
 	sb->patch_version = 0;
 	sb->gvalid_words = 0; /* ignored */
-	if (rfd < 0 || read(rfd, &sb->set_uuid0, 4) != 4)
-		sb->set_uuid0 = random();
 	sb->ctime = time(0);
 	sb->level = info->level;
 	if (size != info->size)
@@ -539,17 +599,28 @@ static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
 	sb->raid_disks = info->raid_disks;
 	sb->md_minor = info->md_minor;
 	sb->not_persistent = 0;
-	if (rfd < 0 || read(rfd, &sb->set_uuid1, 12) != 12) {
-		sb->set_uuid1 = random();
-		sb->set_uuid2 = random();
-		sb->set_uuid3 = random();
+	if (uuid) {
+		sb->set_uuid0 = uuid[0];
+		sb->set_uuid1 = uuid[1];
+		sb->set_uuid2 = uuid[2];
+		sb->set_uuid3 = uuid[3];
+	} else {
+		int rfd = open("/dev/urandom", O_RDONLY);
+		if (rfd < 0 || read(rfd, &sb->set_uuid0, 4) != 4)
+			sb->set_uuid0 = random();
+		if (rfd < 0 || read(rfd, &sb->set_uuid1, 12) != 12) {
+			sb->set_uuid1 = random();
+			sb->set_uuid2 = random();
+			sb->set_uuid3 = random();
+		}
+		if (rfd >= 0)
+			close(rfd);
 	}
-	if (rfd >= 0)
-		close(rfd);
 	if (homehost) {
-		unsigned char *hash = SHA1((unsigned char*)homehost,
-					   strlen(homehost),
-					   NULL);
+		char buf[20];
+		char *hash = sha1_buffer(homehost,
+					 strlen(homehost),
+					 buf);
 		memcpy(&sb->set_uuid2, hash, 8);
 	}
 
@@ -565,41 +636,58 @@ static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
 	sb->layout = info->layout;
 	sb->chunk_size = info->chunk_size;
 
-	*sbp = sb;
 	return 1;
 }
 
+struct devinfo {
+	int fd;
+	char *devname;
+	mdu_disk_info_t disk;
+	struct devinfo *next;
+};
+
+#ifndef MDASSEMBLE
 /* Add a device to the superblock being created */
-static void add_to_super0(void *sbv, mdu_disk_info_t *dinfo)
+static int add_to_super0(struct supertype *st, mdu_disk_info_t *dinfo,
+			  int fd, char *devname)
 {
-	mdp_super_t *sb = sbv;
+	mdp_super_t *sb = st->sb;
 	mdp_disk_t *dk = &sb->disks[dinfo->number];
+	struct devinfo *di, **dip;
 
 	dk->number = dinfo->number;
 	dk->major = dinfo->major;
 	dk->minor = dinfo->minor;
 	dk->raid_disk = dinfo->raid_disk;
 	dk->state = dinfo->state;
+
+	sb->this_disk = sb->disks[dinfo->number];
+	sb->sb_csum = calc_sb0_csum(sb);
+
+	dip = (struct devinfo **)&st->info;
+	while (*dip)
+		dip = &(*dip)->next;
+	di = malloc(sizeof(struct devinfo));
+	di->fd = fd;
+	di->devname = devname;
+	di->disk = *dinfo;
+	di->next = NULL;
+	*dip = di;
+
+	return 0;
 }
+#endif
 
-static int store_super0(struct supertype *st, int fd, void *sbv)
+static int store_super0(struct supertype *st, int fd)
 {
-	unsigned long size;
 	unsigned long long dsize;
 	unsigned long long offset;
-	mdp_super_t *super = sbv;
-    
-#ifdef BLKGETSIZE64
-	if (ioctl(fd, BLKGETSIZE64, &dsize) != 0)
-#endif
-	{
-		if (ioctl(fd, BLKGETSIZE, &size))
-			return 1;
-		else
-			dsize = ((unsigned long long)size)<<9;
-	}
+	mdp_super_t *super = st->sb;
+
+	if (!get_dev_size(fd, NULL, &dsize))
+		return 1;
 
-	if (dsize < MD_RESERVED_SECTORS*2*512)
+	if (dsize < MD_RESERVED_SECTORS*512)
 		return 2;
 
 	offset = MD_NEW_SIZE_SECTORS(dsize>>9);
@@ -615,41 +703,52 @@ static int store_super0(struct supertype *st, int fd, void *sbv)
 	if (super->state & (1<<MD_SB_BITMAP_PRESENT)) {
 		struct bitmap_super_s * bm = (struct bitmap_super_s*)(super+1);
 		if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC)
-			write(fd, bm, sizeof(*bm));
+			if (write(fd, bm, ROUND_UP(sizeof(*bm),4096)) != 
+			    ROUND_UP(sizeof(*bm),4096))
+			    return 5;
 	}
 
 	fsync(fd);
 	return 0;
 }
 
-static int write_init_super0(struct supertype *st, void *sbv, mdu_disk_info_t *dinfo, char *devname)
+#ifndef MDASSEMBLE
+static int write_init_super0(struct supertype *st)
 {
-	mdp_super_t *sb = sbv;
-	int fd = open(devname, O_RDWR|O_EXCL);
-	int rv;
+	mdp_super_t *sb = st->sb;
+	int rv = 0;
+	struct devinfo *di;
 
-	if (fd < 0) {
-		fprintf(stderr, Name ": Failed to open %s to write superblock\n", devname);
-		return -1;
-	}
+	for (di = st->info ; di && ! rv ; di = di->next) {
 
-	sb->disks[dinfo->number].state &= ~(1<<MD_DISK_FAULTY);
-	sb->disks[dinfo->number].state |= (1<<MD_DISK_SYNC);
+		if (di->disk.state == 1)
+			continue;
+		if (di->fd == -1)
+			continue;
+		Kill(di->devname, 0, 1, 1);
+		Kill(di->devname, 0, 1, 1);
 
-	sb->this_disk = sb->disks[dinfo->number];
-	sb->sb_csum = calc_sb0_csum(sb);
-	rv = store_super0(st, fd, sb);
+		sb->disks[di->disk.number].state &= ~(1<<MD_DISK_FAULTY);
 
-	if (rv == 0 && (sb->state & (1<<MD_SB_BITMAP_PRESENT)))
-		rv = st->ss->write_bitmap(st, fd, sbv);
+		sb->this_disk = sb->disks[di->disk.number];
+		sb->sb_csum = calc_sb0_csum(sb);
+		rv = store_super0(st, di->fd);
 
-	close(fd);
-	if (rv)
-		fprintf(stderr, Name ": failed to write superblock to %s\n", devname);
+		if (rv == 0 && (sb->state & (1<<MD_SB_BITMAP_PRESENT)))
+			rv = st->ss->write_bitmap(st, di->fd);
+
+		if (rv)
+			fprintf(stderr,
+				Name ": failed to write superblock to %s\n",
+				di->devname);
+		close(di->fd);
+		di->fd = -1;
+	}
 	return rv;
 }
+#endif
 
-static int compare_super0(void **firstp, void *secondv)
+static int compare_super0(struct supertype *st, struct supertype *tst)
 {
 	/*
 	 * return:
@@ -658,21 +757,27 @@ static int compare_super0(void **firstp, void *secondv)
 	 *  2 wrong uuid
 	 *  3 wrong other info
 	 */
-	mdp_super_t *first = *firstp;
-	mdp_super_t *second = secondv;
-
+	mdp_super_t *first = st->sb;
+	mdp_super_t *second = tst->sb;
 	int uuid1[4], uuid2[4];
+
 	if (second->md_magic != MD_SB_MAGIC)
 		return 1;
 	if (!first) {
-		first = malloc(MD_SB_BYTES + sizeof(struct bitmap_super_s));
+		if (posix_memalign((void**)&first, 4096,
+			     MD_SB_BYTES + 
+			     ROUND_UP(sizeof(struct bitmap_super_s), 4096)) != 0) {
+			fprintf(stderr, Name
+				": %s could not allocate superblock\n", __func__);
+			return 1;
+		}
 		memcpy(first, second, MD_SB_BYTES + sizeof(struct bitmap_super_s));
-		*firstp = first;
+		st->sb = first;
 		return 0;
 	}
 
-	uuid_from_super0(uuid1, first);
-	uuid_from_super0(uuid2, second);
+	uuid_from_super0(st, uuid1);
+	uuid_from_super0(tst, uuid2);
 	if (!same_uuid(uuid1, uuid2, 0))
 		return 2;
 	if (first->major_version != second->major_version ||
@@ -689,7 +794,9 @@ static int compare_super0(void **firstp, void *secondv)
 }
 
 
-static int load_super0(struct supertype *st, int fd, void **sbp, char *devname)
+static void free_super0(struct supertype *st);
+
+static int load_super0(struct supertype *st, int fd, char *devname)
 {
 	/* try to read in the superblock
 	 * Return:
@@ -697,30 +804,25 @@ static int load_super0(struct supertype *st, int fd, void **sbp, char *devname)
 	 *  1 on cannot get superblock
 	 *  2 on superblock meaningless
 	 */
-	unsigned long size;
 	unsigned long long dsize;
 	unsigned long long offset;
 	mdp_super_t *super;
 	int uuid[4];
 	struct bitmap_super_s *bsb;
-    
-#ifdef BLKGETSIZE64
-	if (ioctl(fd, BLKGETSIZE64, &dsize) != 0)
-#endif
-	{
-		if (ioctl(fd, BLKGETSIZE, &size)) {
-			if (devname)
-				fprintf(stderr, Name ": cannot find device size for %s: %s\n",
-					devname, strerror(errno));
-			return 1;
-		} else
-			dsize = size << 9;
-	}
 
-	if (dsize < MD_RESERVED_SECTORS*2) {
+	free_super0(st);
+
+	if (st->subarray[0])
+		return 1;
+
+	if (!get_dev_size(fd, devname, &dsize))
+		return 1;
+
+	if (dsize < MD_RESERVED_SECTORS*512) {
 		if (devname)
-			fprintf(stderr, Name ": %s is too small for md: size is %ld sectors.\n",
-				devname, size);
+			fprintf(stderr, Name
+			    ": %s is too small for md: size is %llu sectors.\n",
+				devname, dsize);
 		return 1;
 	}
 
@@ -737,7 +839,13 @@ static int load_super0(struct supertype *st, int fd, void **sbp, char *devname)
 		return 1;
 	}
 
-	super = malloc(MD_SB_BYTES + sizeof(bitmap_super_t));
+	if (posix_memalign((void**)&super, 4096,
+			   MD_SB_BYTES +
+			   ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
+		fprintf(stderr, Name
+			": %s could not allocate superblock\n", __func__);
+		return 1;
+	}
 
 	if (read(fd, super, sizeof(*super)) != MD_SB_BYTES) {
 		if (devname)
@@ -765,11 +873,13 @@ static int load_super0(struct supertype *st, int fd, void **sbp, char *devname)
 		free(super);
 		return 2;
 	}
-	*sbp = super;
+	st->sb = super;
+
 	if (st->ss == NULL) {
 		st->ss = &super0;
-		st->minor_version = 90;
+		st->minor_version = super->minor_version;
 		st->max_devs = MD_SB_DISKS;
+		st->info = NULL;
 	}
 
 	/* Now check on the bitmap superblock */
@@ -779,11 +889,11 @@ static int load_super0(struct supertype *st, int fd, void **sbp, char *devname)
 	 * valid.  If it doesn't clear the bit.  An --assemble --force
 	 * should get that written out.
 	 */
-	if (read(fd, super+1, sizeof(struct bitmap_super_s))
-	    != sizeof(struct bitmap_super_s))
+	if (read(fd, super+1, ROUND_UP(sizeof(struct bitmap_super_s),4096))
+	    != ROUND_UP(sizeof(struct bitmap_super_s),4096))
 		goto no_bitmap;
 
-	uuid_from_super0(uuid, super);
+	uuid_from_super0(st, uuid);
 	bsb = (struct bitmap_super_s *)(super+1);
 	if (__le32_to_cpu(bsb->magic) != BITMAP_MAGIC ||
 	    memcmp(bsb->uuid, uuid, 16) != 0)
@@ -801,17 +911,29 @@ static struct supertype *match_metadata_desc0(char *arg)
 	struct supertype *st = malloc(sizeof(*st));
 	if (!st) return st;
 
+	memset(st, 0, sizeof(*st));
 	st->ss = &super0;
+	st->info = NULL;
 	st->minor_version = 90;
 	st->max_devs = MD_SB_DISKS;
+	st->sb = NULL;
+	/* we sometimes get 00.90 */
+	while (arg[0] == '0' && arg[1] == '0')
+		arg++;
 	if (strcmp(arg, "0") == 0 ||
 	    strcmp(arg, "0.90") == 0 ||
-	    strcmp(arg, "default") == 0
+	    strcmp(arg, "default") == 0 ||
+	    strcmp(arg, "") == 0 /* no metadata */
 		)
 		return st;
 
+	st->minor_version = 91; /* reshape in progress */
+	if (strcmp(arg, "0.91") == 0) /* For dup_super support */
+		return st;
+
 	st->minor_version = 9; /* flag for 'byte-swapped' */
-	if (strcmp(arg, "0.swap")==0)
+	if (strcmp(arg, "0.swap")==0 ||
+	    strcmp(arg, "0.9") == 0) /* For dup_super support */
 		return st;
 
 	free(st);
@@ -820,12 +942,15 @@ static struct supertype *match_metadata_desc0(char *arg)
 
 static __u64 avail_size0(struct supertype *st, __u64 devsize)
 {
-	if (devsize < MD_RESERVED_SECTORS*2)
+	if (devsize < MD_RESERVED_SECTORS)
 		return 0ULL;
 	return MD_NEW_SIZE_SECTORS(devsize);
 }
 
-static int add_internal_bitmap0(struct supertype *st, void *sbv, int chunk, int delay, int write_behind, unsigned long long size, int may_change, int major)
+static int add_internal_bitmap0(struct supertype *st, int *chunkp,
+				int delay, int write_behind,
+				unsigned long long size, int may_change,
+				int major)
 {
 	/*
 	 * The bitmap comes immediately after the superblock and must be 60K in size
@@ -836,7 +961,8 @@ static int add_internal_bitmap0(struct supertype *st, void *sbv, int chunk, int
 	unsigned long long bits;
 	unsigned long long max_bits = 60*1024*8;
 	unsigned long long min_chunk;
-	mdp_super_t *sb = sbv;
+	int chunk = *chunkp;
+	mdp_super_t *sb = st->sb;
 	bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MD_SB_BYTES);
 
 
@@ -856,32 +982,25 @@ static int add_internal_bitmap0(struct supertype *st, void *sbv, int chunk, int
 	memset(bms, 0, sizeof(*bms));
 	bms->magic = __cpu_to_le32(BITMAP_MAGIC);
 	bms->version = __cpu_to_le32(major);
-	uuid_from_super0((int*)bms->uuid, sb);
+	uuid_from_super0(st, (int*)bms->uuid);
 	bms->chunksize = __cpu_to_le32(chunk);
 	bms->daemon_sleep = __cpu_to_le32(delay);
 	bms->sync_size = __cpu_to_le64(size);
 	bms->write_behind = __cpu_to_le32(write_behind);
-
+	*chunkp = chunk;
 	return 1;
 }
 
 
-void locate_bitmap0(struct supertype *st, int fd, void *sbv)
+static void locate_bitmap0(struct supertype *st, int fd)
 {
 	unsigned long long dsize;
-	unsigned long size;
 	unsigned long long offset;
-#ifdef BLKGETSIZE64
-	if (ioctl(fd, BLKGETSIZE64, &dsize) != 0)
-#endif
-	{
-		if (ioctl(fd, BLKGETSIZE, &size))
-			return;
-		else
-			dsize = ((unsigned long long)size)<<9;
-	}
 
-	if (dsize < MD_RESERVED_SECTORS*2)
+	if (!get_dev_size(fd, NULL, &dsize))
+		return;
+
+	if (dsize < MD_RESERVED_SECTORS*512)
 		return;
 
 	offset = MD_NEW_SIZE_SECTORS(dsize>>9);
@@ -893,30 +1012,24 @@ void locate_bitmap0(struct supertype *st, int fd, void *sbv)
 	lseek64(fd, offset, 0);
 }
 
-int write_bitmap0(struct supertype *st, int fd, void *sbv)
+static int write_bitmap0(struct supertype *st, int fd)
 {
-	unsigned long size;
 	unsigned long long dsize;
 	unsigned long long offset;
-	mdp_super_t *sb = sbv;
-    
+	mdp_super_t *sb = st->sb;
+
 	int rv = 0;
 
 	int towrite, n;
-	char buf[4096];
+	char abuf[4096+4096];
+	char *buf = (char*)(((long)(abuf+4096))&~4095L);
+
+	if (!get_dev_size(fd, NULL, &dsize))
+		return 1;
 
-#ifdef BLKGETSIZE64
-	if (ioctl(fd, BLKGETSIZE64, &dsize) != 0)
-#endif
-	{
-		if (ioctl(fd, BLKGETSIZE, &size))
-			return 1;
-		else
-			dsize = ((unsigned long long)size)<<9;
-	}
 
-	if (dsize < MD_RESERVED_SECTORS*2)
-	return -1;
+	if (dsize < MD_RESERVED_SECTORS*512)
+		return -1;
 
 	offset = MD_NEW_SIZE_SECTORS(dsize>>9);
 
@@ -925,21 +1038,19 @@ int write_bitmap0(struct supertype *st, int fd, void *sbv)
 	if (lseek64(fd, offset + 4096, 0)< 0LL)
 		return 3;
 
-
-	if (write(fd, ((char*)sb)+MD_SB_BYTES, sizeof(bitmap_super_t)) !=
-	    sizeof(bitmap_super_t))
-		return -2;
-	towrite = 64*1024 - MD_SB_BYTES - sizeof(bitmap_super_t);
-	memset(buf, 0xff, sizeof(buf));
+	memset(buf, 0xff, 4096);
+	memcpy(buf,  ((char*)sb)+MD_SB_BYTES, sizeof(bitmap_super_t));
+	towrite = 64*1024;
 	while (towrite > 0) {
 		n = towrite;
-		if (n > sizeof(buf)) 
-			n = sizeof(buf);
+		if (n > 4096)
+			n = 4096;
 		n = write(fd, buf, n);
 		if (n > 0)
 			towrite -= n;
 		else
 			break;
+		memset(buf, 0xff, 4096);
 	}
 	fsync(fd);
 	if (towrite)
@@ -948,22 +1059,72 @@ int write_bitmap0(struct supertype *st, int fd, void *sbv)
 	return rv;
 }
 
+static void free_super0(struct supertype *st)
+{
+	if (st->sb)
+		free(st->sb);
+	st->sb = NULL;
+}
+
+#ifndef MDASSEMBLE
+static int validate_geometry0(struct supertype *st, int level,
+			      int layout, int raiddisks,
+			      int chunk, unsigned long long size,
+			      char *subdev, unsigned long long *freesize,
+			      int verbose)
+{
+	unsigned long long ldsize;
+	int fd;
+
+	if (level == LEVEL_CONTAINER)
+		return 0;
+	if (raiddisks > MD_SB_DISKS)
+		return 0;
+	if (size > (0x7fffffffULL<<9))
+		return 0;
+	if (!subdev)
+		return 1;
+
+	fd = open(subdev, O_RDONLY|O_EXCL, 0);
+	if (fd < 0) {
+		if (verbose)
+			fprintf(stderr, Name ": super0.90 cannot open %s: %s\n",
+				subdev, strerror(errno));
+		return 0;
+	}
+
+	if (!get_dev_size(fd, subdev, &ldsize)) {
+		close(fd);
+		return 0;
+	}
+	close(fd);
+
+	if (ldsize < MD_RESERVED_SECTORS * 512)
+		return 0;
+	if (size > (0x7fffffffULL<<9))
+		return 0;
+	*freesize = MD_NEW_SIZE_SECTORS(ldsize >> 9);
+	return 1;
+}
+#endif /* MDASSEMBLE */
+
 struct superswitch super0 = {
 #ifndef MDASSEMBLE
 	.examine_super = examine_super0,
 	.brief_examine_super = brief_examine_super0,
+	.export_examine_super = export_examine_super0,
 	.detail_super = detail_super0,
 	.brief_detail_super = brief_detail_super0,
+	.write_init_super = write_init_super0,
+	.validate_geometry = validate_geometry0,
+	.add_to_super = add_to_super0,
 #endif
 	.match_home = match_home0,
 	.uuid_from_super = uuid_from_super0,
 	.getinfo_super = getinfo_super0,
 	.update_super = update_super0,
-	.event_super = event_super0,
 	.init_super = init_super0,
-	.add_to_super = add_to_super0,
 	.store_super = store_super0,
-	.write_init_super = write_init_super0,
 	.compare_super = compare_super0,
 	.load_super = load_super0,
 	.match_metadata_desc = match_metadata_desc0,
@@ -971,6 +1132,6 @@ struct superswitch super0 = {
 	.add_internal_bitmap = add_internal_bitmap0,
 	.locate_bitmap = locate_bitmap0,
 	.write_bitmap = write_bitmap0,
-	.major = 0,
-	.swapuuid = 0,
+	.free_super = free_super0,
+	.name = "0.90",
 };