X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=super1.c;h=0fd84e25bfde2fbfd1f5fb814f0d1e42bd7c57f8;hp=9ba1ded4e00d152d28d413af20eeeb3c002559e3;hb=1ade5cc15a61c6fe3084c5170934e05e9a574843;hpb=0f23aa88f81127eae744d60eedd4884f021562d0 diff --git a/super1.c b/super1.c index 9ba1ded4..0fd84e25 100644 --- a/super1.c +++ b/super1.c @@ -22,6 +22,7 @@ * Email: */ +#include #include "mdadm.h" /* * The version-1 superblock : @@ -57,8 +58,11 @@ struct mdp_superblock_1 { __u64 reshape_position; /* next address in array-space for reshape */ __u32 delta_disks; /* change in number of raid_disks */ __u32 new_layout; /* new layout */ - __u32 new_chunk; /* new chunk size (bytes) */ - __u8 pad1[128-124]; /* set to 0 when written */ + __u32 new_chunk; /* new chunk size (sectors) */ + __u32 new_offset; /* signed number to add to data_offset in new + * layout. 0 == no-change. This can be + * different on each device in the array. + */ /* constant this-device information - 64 bytes */ __u64 data_offset; /* sector start of data, often 0 */ @@ -68,9 +72,14 @@ struct mdp_superblock_1 { __u32 dev_number; /* permanent identifier of this device - not role in raid */ __u32 cnt_corrected_read; /* number of read errors that were corrected by re-writing */ __u8 device_uuid[16]; /* user-space setable, ignored by kernel */ - __u8 devflags; /* per-device flags. Only one defined...*/ + __u8 devflags; /* per-device flags. Only one defined...*/ #define WriteMostly1 1 /* mask for writemostly flag in above */ - __u8 pad2[64-57]; /* set to 0 when writing */ + /* bad block log. If there are any bad blocks the feature flag is set. + * if offset and size are non-zero, that space is reserved and available. + */ + __u8 bblog_shift; /* shift from sectors to block size for badblocklist */ + __u16 bblog_size; /* number of sectors reserved for badblocklist */ + __u32 bblog_offset; /* sector offset from superblock to bblog, signed */ /* array state information - 64 bytes */ __u64 utime; /* 40 bits second, 24 btes microseconds */ @@ -89,6 +98,13 @@ struct mdp_superblock_1 { __u16 dev_roles[0]; /* role in array, or 0xffff for a spare, or 0xfffe for faulty */ }; +#define MAX_SB_SIZE 4096 +/* bitmap super size is 256, but we round up to a sector for alignment */ +#define BM_SUPER_SIZE 512 +#define MAX_DEVS ((int)(MAX_SB_SIZE - sizeof(struct mdp_superblock_1)) / 2) +#define SUPER1_SIZE (MAX_SB_SIZE + BM_SUPER_SIZE \ + + sizeof(struct misc_dev_info)) + struct misc_dev_info { __u64 device_size; }; @@ -99,19 +115,31 @@ struct misc_dev_info { * must be honoured */ #define MD_FEATURE_RESHAPE_ACTIVE 4 +#define MD_FEATURE_BAD_BLOCKS 8 /* badblock list is not empty */ +#define MD_FEATURE_REPLACEMENT 16 /* This device is replacing an + * active device with same 'role'. + * 'recovery_offset' is also set. + */ +#define MD_FEATURE_RESHAPE_BACKWARDS 32 /* Reshape doesn't change number + * of devices, but is going + * backwards anyway. + */ +#define MD_FEATURE_NEW_OFFSET 64 /* new_offset must be honoured */ +#define MD_FEATURE_ALL (MD_FEATURE_BITMAP_OFFSET \ + |MD_FEATURE_RECOVERY_OFFSET \ + |MD_FEATURE_RESHAPE_ACTIVE \ + |MD_FEATURE_BAD_BLOCKS \ + |MD_FEATURE_REPLACEMENT \ + |MD_FEATURE_RESHAPE_BACKWARDS \ + |MD_FEATURE_NEW_OFFSET \ + ) -#define MD_FEATURE_ALL (1|2|4) - -#ifndef offsetof -#define offsetof(t,f) ((size_t)&(((t*)0)->f)) -#endif static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb) { unsigned int disk_csum, csum; unsigned long long newcsum; int size = sizeof(*sb) + __le32_to_cpu(sb->max_dev)*2; unsigned int *isuper = (unsigned int*)sb; - int i; /* make sure I can count... */ if (offsetof(struct mdp_superblock_1,data_offset) != 128 || @@ -123,7 +151,7 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb) disk_csum = sb->sb_csum; sb->sb_csum = 0; newcsum = 0; - for (i=0; size>=4; size -= 4 ) { + for (; size>=4; size -= 4 ) { newcsum += __le32_to_cpu(*isuper); isuper++; } @@ -136,35 +164,58 @@ static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb) return __cpu_to_le32(csum); } +/* + * Information related to file descriptor used for aligned reads/writes. + * Cache the block size. + */ +struct align_fd { + int fd; + int blk_sz; +}; + +static void init_afd(struct align_fd *afd, int fd) +{ + afd->fd = fd; + + if (ioctl(afd->fd, BLKSSZGET, &afd->blk_sz) != 0) + afd->blk_sz = 512; +} + static char abuf[4096+4096]; -static int aread(int fd, void *buf, int len) +static int aread(struct align_fd *afd, void *buf, int len) { /* aligned read. * On devices with a 4K sector size, we need to read * the full sector and copy relevant bits into * the buffer */ - int bsize; + int bsize, iosize; char *b; int n; - if (ioctl(fd, BLKSSZGET, &bsize) != 0 || - bsize <= len) - return read(fd, buf, len); - if (bsize > 4096) + + bsize = afd->blk_sz; + + if (!bsize || bsize > 4096 || len > 4096) { + if (!bsize) + fprintf(stderr, "WARNING - aread() called with " + "invalid block size\n"); return -1; - b = (char*)(((long)(abuf+4096))&~4095UL); + } + b = ROUND_UP_PTR((char *)abuf, 4096); - n = read(fd, b, bsize); + for (iosize = 0; iosize < len; iosize += bsize) + ; + n = read(afd->fd, b, iosize); if (n <= 0) return n; - lseek(fd, len - n, 1); + lseek(afd->fd, len - n, 1); if (n > len) n = len; memcpy(buf, b, n); return n; } -static int awrite(int fd, void *buf, int len) +static int awrite(struct align_fd *afd, void *buf, int len) { /* aligned write. * On devices with a 4K sector size, we need to write @@ -172,25 +223,34 @@ static int awrite(int fd, void *buf, int len) * than the write. * The address must be sector-aligned. */ - int bsize; + int bsize, iosize; char *b; int n; - if (ioctl(fd, BLKSSZGET, &bsize) != 0 || - bsize <= len) - return write(fd, buf, len); - if (bsize > 4096) + + bsize = afd->blk_sz; + if (!bsize || bsize > 4096 || len > 4096) { + if (!bsize) + fprintf(stderr, "WARNING - awrite() called with " + "invalid block size\n"); return -1; - b = (char*)(((long)(abuf+4096))&~4095UL); + } + b = ROUND_UP_PTR((char *)abuf, 4096); + + for (iosize = 0; iosize < len ; iosize += bsize) + ; + + if (len != iosize) { + n = read(afd->fd, b, iosize); + if (n <= 0) + return n; + lseek(afd->fd, -n, 1); + } - n = read(fd, b, bsize); - if (n <= 0) - return n; - lseek(fd, -n, 1); memcpy(b, buf, len); - n = write(fd, b, bsize); + n = write(afd->fd, b, iosize); if (n <= 0) return n; - lseek(fd, len - n, 1); + lseek(afd->fd, len - n, 1); return len; } @@ -207,6 +267,7 @@ static void examine_super1(struct supertype *st, char *homehost) int l = homehost ? strlen(homehost) : 0; int layout; unsigned long long sb_offset; + struct mdinfo info; printf(" Magic : %08x\n", __le32_to_cpu(sb->magic)); printf(" Version : 1"); @@ -240,7 +301,7 @@ static void examine_super1(struct supertype *st, char *homehost) (unsigned long long)__le64_to_cpu(sb->data_size), human_size(__le64_to_cpu(sb->data_size)<<9)); if (__le32_to_cpu(sb->level) > 0) { - int ddsks=0; + int ddsks = 0, ddsks_denom = 1; switch(__le32_to_cpu(sb->level)) { case 1: ddsks=1;break; case 4: @@ -248,13 +309,15 @@ static void examine_super1(struct supertype *st, char *homehost) case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break; case 10: layout = __le32_to_cpu(sb->layout); - ddsks = __le32_to_cpu(sb->raid_disks) - / (layout&255) / ((layout>>8)&255); + ddsks = __le32_to_cpu(sb->raid_disks); + ddsks_denom = (layout&255) * ((layout>>8)&255); } - if (ddsks) + if (ddsks) { + long long asize = __le64_to_cpu(sb->size); + asize = (asize << 9) * ddsks / ddsks_denom; printf(" Array Size : %llu%s\n", - ddsks*(unsigned long long)__le64_to_cpu(sb->size), - human_size(ddsks*__le64_to_cpu(sb->size)<<9)); + asize >> 10, human_size(asize)); + } if (sb->size != sb->data_size) printf(" Used Dev Size : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->size), @@ -263,10 +326,23 @@ static void examine_super1(struct supertype *st, char *homehost) if (sb->data_offset) printf(" Data Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->data_offset)); + if (sb->new_offset && + (__le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET)) { + unsigned long long offset = __le64_to_cpu(sb->data_offset); + offset += (signed)(int32_t)__le32_to_cpu(sb->new_offset); + printf(" New Offset : %llu sectors\n", offset); + } printf(" Super Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->super_offset)); if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET) printf("Recovery Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->recovery_offset)); + + st->ss->getinfo_super(st, &info, NULL); + if (info.space_after != 1 && + !(__le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET)) + printf(" Unused Space : before=%llu sectors, after=%llu sectors\n", + info.space_before, info.space_after); + printf(" State : %s\n", (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean"); printf(" Device UUID : "); for (i=0; i<16; i++) { @@ -279,7 +355,7 @@ static void examine_super1(struct supertype *st, char *homehost) printf("Internal Bitmap : %ld sectors from superblock\n", (long)(int32_t)__le32_to_cpu(sb->bitmap_offset)); } - if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) { + if (sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)) { printf(" Reshape pos'n : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->reshape_position)/2, human_size(__le64_to_cpu(sb->reshape_position)<<9)); if (__le32_to_cpu(sb->delta_disks)) { @@ -314,7 +390,7 @@ static void examine_super1(struct supertype *st, char *homehost) printf("\n"); } if (sb->devflags) { - printf(" Flags :"); + printf(" Flags :"); if (sb->devflags & WriteMostly1) printf(" write-mostly"); printf("\n"); @@ -323,6 +399,16 @@ static void examine_super1(struct supertype *st, char *homehost) atime = __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL; printf(" Update Time : %.24s\n", ctime(&atime)); + if (sb->bblog_size && sb->bblog_offset) { + printf(" Bad Block Log : %d entries available at offset %ld sectors", + __le16_to_cpu(sb->bblog_size)*512/8, + (long)(int32_t)__le32_to_cpu(sb->bblog_offset)); + if (sb->feature_map & + __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) + printf(" - bad blocks present."); + printf("\n"); + } + if (calc_sb_1_csum(sb) == sb->sb_csum) printf(" Checksum : %x - correct\n", __le32_to_cpu(sb->sb_csum)); else @@ -381,25 +467,28 @@ static void examine_super1(struct supertype *st, char *homehost) role = 0xFFFF; if (role >= 0xFFFE) printf("spare\n"); + else if (sb->feature_map & __cpu_to_le32(MD_FEATURE_REPLACEMENT)) + printf("Replacement device %d\n", role); else printf("Active device %d\n", role); printf(" Array State : "); for (d=0; d<__le32_to_cpu(sb->raid_disks) + delta_extra; d++) { int cnt = 0; - int me = 0; unsigned int i; for (i=0; i< __le32_to_cpu(sb->max_dev); i++) { unsigned int role = __le16_to_cpu(sb->dev_roles[i]); - if (role == d) { - if (i == __le32_to_cpu(sb->dev_number)) - me = 1; + if (role == d) cnt++; - } } - if (cnt > 1) printf("?"); - else if (cnt == 1) printf("A"); - else printf ("."); + if (cnt == 2) + printf("R"); + else if (cnt == 1) + printf("A"); + else if (cnt == 0) + printf("."); + else + printf("?"); } #if 0 /* This is confusing too */ @@ -411,11 +500,10 @@ static void examine_super1(struct supertype *st, char *homehost) } if (faulty) printf(" %d failed", faulty); #endif - printf(" ('A' == active, '.' == missing)"); + printf(" ('A' == active, '.' == missing, 'R' == replacing)"); printf("\n"); } - static void brief_examine_super1(struct supertype *st, int verbose) { struct mdp_superblock_1 *sb = st->sb; @@ -432,7 +520,12 @@ static void brief_examine_super1(struct supertype *st, int verbose) else nm = NULL; - printf("ARRAY%s%s", nm ? " /dev/md/":"", nm); + printf("ARRAY "); + if (nm) { + printf("/dev/md/"); + print_escape(nm); + putchar(' '); + } if (verbose && c) printf(" level=%s", c); sb_offset = __le64_to_cpu(sb->super_offset); @@ -449,8 +542,10 @@ static void brief_examine_super1(struct supertype *st, int verbose) if ((i&3)==0 && i != 0) printf(":"); printf("%02x", sb->set_uuid[i]); } - if (sb->set_name[0]) - printf(" name=%.32s", sb->set_name); + if (sb->set_name[0]) { + printf(" name="); + print_quoted(sb->set_name); + } printf("\n"); } @@ -459,6 +554,7 @@ static void export_examine_super1(struct supertype *st) struct mdp_superblock_1 *sb = st->sb; int i; int len = 32; + int layout; printf("MD_LEVEL=%s\n", map_num(pers, __le32_to_cpu(sb->level))); printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks)); @@ -470,6 +566,24 @@ static void export_examine_super1(struct supertype *st) } if (len) printf("MD_NAME=%.*s\n", len, sb->set_name); + if (__le32_to_cpu(sb->level) > 0) { + int ddsks = 0, ddsks_denom = 1; + switch(__le32_to_cpu(sb->level)) { + case 1: ddsks=1;break; + case 4: + case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break; + case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break; + case 10: + layout = __le32_to_cpu(sb->layout); + ddsks = __le32_to_cpu(sb->raid_disks); + ddsks_denom = (layout&255) * ((layout>>8)&255); + } + if (ddsks) { + long long asize = __le64_to_cpu(sb->size); + asize = (asize << 9) * ddsks / ddsks_denom; + printf("MD_ARRAY_SIZE=%s\n",human_size_brief(asize,JEDEC)); + } + } printf("MD_UUID="); for (i=0; i<16; i++) { if ((i&3)==0 && i != 0) printf(":"); @@ -488,6 +602,143 @@ static void export_examine_super1(struct supertype *st) (unsigned long long)__le64_to_cpu(sb->events)); } +static int copy_metadata1(struct supertype *st, int from, int to) +{ + /* Read superblock. If it looks good, write it out. + * Then if a bitmap is present, copy that. + * And if a bad-block-list is present, copy that too. + */ + void *buf; + unsigned long long dsize, sb_offset; + const int bufsize = 4*1024; + struct mdp_superblock_1 super, *sb; + + if (posix_memalign(&buf, 4096, bufsize) != 0) + return 1; + + if (!get_dev_size(from, NULL, &dsize)) + goto err; + + dsize >>= 9; + if (dsize < 24) + goto err; + switch(st->minor_version) { + case 0: + sb_offset = dsize; + sb_offset -= 8*2; + sb_offset &= ~(4*2-1); + break; + case 1: + sb_offset = 0; + break; + case 2: + sb_offset = 4*2; + break; + default: + goto err; + } + + if (lseek64(from, sb_offset << 9, 0) < 0LL) + goto err; + if (read(from, buf, bufsize) != bufsize) + goto err; + + sb = buf; + super = *sb; // save most of sb for when we reuse buf + + if (__le32_to_cpu(super.magic) != MD_SB_MAGIC || + __le32_to_cpu(super.major_version) != 1 || + __le64_to_cpu(super.super_offset) != sb_offset || + calc_sb_1_csum(sb) != super.sb_csum) + goto err; + + if (lseek64(to, sb_offset << 9, 0) < 0LL) + goto err; + if (write(to, buf, bufsize) != bufsize) + goto err; + + if (super.feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET)) { + unsigned long long bitmap_offset = sb_offset; + int bytes = 4096; // just an estimate. + int written = 0; + struct align_fd afrom, ato; + + init_afd(&afrom, from); + init_afd(&ato, to); + + bitmap_offset += (int32_t)__le32_to_cpu(super.bitmap_offset); + + if (lseek64(from, bitmap_offset<<9, 0) < 0) + goto err; + if (lseek64(to, bitmap_offset<<9, 0) < 0) + goto err; + + for (written = 0; written < bytes ; ) { + int n = bytes - written; + if (n > 4096) + n = 4096; + if (aread(&afrom, buf, n) != n) + goto err; + if (written == 0) { + /* have the header, can calculate + * correct bitmap bytes */ + bitmap_super_t *bms; + int bits; + bms = (void*)buf; + bits = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9); + bytes = (bits+7) >> 3; + bytes += sizeof(bitmap_super_t); + bytes = ROUND_UP(bytes, 512); + if (n > bytes) + n = bytes; + } + if (awrite(&ato, buf, n) != n) + goto err; + written += n; + } + } + + if (super.bblog_size != 0 && + __le32_to_cpu(super.bblog_size) <= 100 && + super.bblog_offset != 0 && + (super.feature_map & __le32_to_cpu(MD_FEATURE_BAD_BLOCKS))) { + /* There is a bad block log */ + unsigned long long bb_offset = sb_offset; + int bytes = __le32_to_cpu(super.bblog_size) * 512; + int written = 0; + struct align_fd afrom, ato; + + init_afd(&afrom, from); + init_afd(&ato, to); + + bb_offset += (int32_t)__le32_to_cpu(super.bblog_offset); + + if (lseek64(from, bb_offset<<9, 0) < 0) + goto err; + if (lseek64(to, bb_offset<<9, 0) < 0) + goto err; + + for (written = 0; written < bytes ; ) { + int n = bytes - written; + if (n > 4096) + n = 4096; + if (aread(&afrom, buf, n) != n) + goto err; + + if (awrite(&ato, buf, n) != n) + goto err; + written += n; + } + } + + free(buf); + return 0; + +err: + free(buf); + return 1; +} + static void detail_super1(struct supertype *st, char *homehost) { struct mdp_superblock_1 *sb = st->sb; @@ -512,8 +763,10 @@ static void brief_detail_super1(struct supertype *st) struct mdp_superblock_1 *sb = st->sb; int i; - if (sb->set_name[0]) - printf(" name=%.32s", sb->set_name); + if (sb->set_name[0]) { + printf(" name="); + print_quoted(sb->set_name); + } printf(" UUID="); for (i=0; i<16; i++) { if ((i&3)==0 && i != 0) printf(":"); @@ -537,6 +790,62 @@ static void export_detail_super1(struct supertype *st) printf("MD_NAME=%.*s\n", len, sb->set_name); } +static int examine_badblocks_super1(struct supertype *st, int fd, char *devname) +{ + struct mdp_superblock_1 *sb = st->sb; + unsigned long long offset; + int size; + __u64 *bbl, *bbp; + int i; + + if (!sb->bblog_size || __le32_to_cpu(sb->bblog_size) > 100 + || !sb->bblog_offset){ + printf("No bad-blocks list configured on %s\n", devname); + return 0; + } + if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) + == 0) { + printf("Bad-blocks list is empty in %s\n", devname); + return 0; + } + + size = __le32_to_cpu(sb->bblog_size)* 512; + if (posix_memalign((void**)&bbl, 4096, size) != 0) { + pr_err("could not allocate badblocks list\n"); + return 0; + } + offset = __le64_to_cpu(sb->super_offset) + + (int)__le32_to_cpu(sb->bblog_offset); + offset <<= 9; + if (lseek64(fd, offset, 0) < 0) { + pr_err("Cannot seek to bad-blocks list\n"); + return 1; + } + if (read(fd, bbl, size) != size) { + pr_err("Cannot read bad-blocks list\n"); + return 1; + } + /* 64bits per entry. 10 bits is block-count, 54 bits is block + * offset. Blocks are sectors unless bblog->shift makes them bigger + */ + bbp = (__u64*)bbl; + printf("Bad-blocks on %s:\n", devname); + for (i = 0; i < size/8; i++, bbp++) { + __u64 bb = __le64_to_cpu(*bbp); + int count = bb & 0x3ff; + unsigned long long sector = bb >> 10; + + if (bb + 1 == 0) + break; + + sector <<= sb->bblog_shift; + count <<= sb->bblog_shift; + + printf("%20llu for %d sectors\n", sector, count); + } + return 0; +} + #endif static int match_home1(struct supertype *st, char *homehost) @@ -561,11 +870,16 @@ static void uuid_from_super1(struct supertype *st, int uuid[4]) static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) { struct mdp_superblock_1 *sb = st->sb; + struct bitmap_super_s *bsb = (void*)(((char*)sb)+MAX_SB_SIZE); + struct misc_dev_info *misc = (void*)(((char*)sb)+MAX_SB_SIZE+BM_SUPER_SIZE); int working = 0; unsigned int i; unsigned int role; unsigned int map_disks = info->array.raid_disks; + unsigned long long super_offset; + unsigned long long data_size; + memset(info, 0, sizeof(*info)); info->array.major_version = 1; info->array.minor_version = st->minor_version; info->array.patch_version = 0; @@ -577,21 +891,84 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) info->array.utime = __le64_to_cpu(sb->utime); info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512; info->array.state = - (__le64_to_cpu(sb->resync_offset) >= __le64_to_cpu(sb->size)) + (__le64_to_cpu(sb->resync_offset) == MaxSector) ? 1 : 0; info->data_offset = __le64_to_cpu(sb->data_offset); info->component_size = __le64_to_cpu(sb->size); + if (sb->feature_map & __le32_to_cpu(MD_FEATURE_BITMAP_OFFSET)) + info->bitmap_offset = (int32_t)__le32_to_cpu(sb->bitmap_offset); info->disk.major = 0; info->disk.minor = 0; info->disk.number = __le32_to_cpu(sb->dev_number); if (__le32_to_cpu(sb->dev_number) >= __le32_to_cpu(sb->max_dev) || - __le32_to_cpu(sb->max_dev) > 512) + __le32_to_cpu(sb->dev_number) >= MAX_DEVS) role = 0xfffe; else role = __le16_to_cpu(sb->dev_roles[__le32_to_cpu(sb->dev_number)]); + super_offset = __le64_to_cpu(sb->super_offset); + if (info->array.level <= 0) + data_size = __le64_to_cpu(sb->data_size); + else + data_size = __le64_to_cpu(sb->size); + if (info->data_offset < super_offset) { + unsigned long long end; + info->space_before = info->data_offset; + end = super_offset; + + if (sb->bblog_offset && sb->bblog_size) { + unsigned long long bboffset = super_offset; + bboffset += (int32_t)__le32_to_cpu(sb->bblog_offset); + if (bboffset < end) + end = bboffset; + } + + if (super_offset + info->bitmap_offset < end) + end = super_offset + info->bitmap_offset; + + if (info->data_offset + data_size < end) + info->space_after = end - data_size - info->data_offset; + else + info->space_after = 0; + } else { + unsigned long long earliest; + earliest = super_offset + (32+4)*2; /* match kernel */ + if (info->bitmap_offset > 0) { + unsigned long long bmend = info->bitmap_offset; + unsigned long long size = __le64_to_cpu(bsb->sync_size); + size /= __le32_to_cpu(bsb->chunksize) >> 9; + size = (size + 7) >> 3; + size += sizeof(bitmap_super_t); + size = ROUND_UP(size, 4096); + size /= 512; + bmend += size; + if (bmend > earliest) + bmend = earliest; + } + if (sb->bblog_offset && sb->bblog_size) { + unsigned long long bbend = super_offset; + bbend += (int32_t)__le32_to_cpu(sb->bblog_offset); + bbend += __le32_to_cpu(sb->bblog_size); + if (bbend > earliest) + earliest = bbend; + } + if (earliest < info->data_offset) + info->space_before = info->data_offset - earliest; + else + info->space_before = 0; + info->space_after = misc->device_size - data_size - info->data_offset; + } + if (info->space_before == 0 && info->space_after == 0) { + /* It will look like we don't support data_offset changes, + * be we do - it's just that there is no room. + * A change that reduced the number of devices should + * still be allowed, so set the otherwise useless value of '1' + */ + info->space_after = 1; + } + info->disk.raid_disk = -1; switch(role) { case 0xFFFF: @@ -604,6 +981,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) info->disk.state = 6; /* active and in sync */ info->disk.raid_disk = role; } + if (sb->devflags & WriteMostly1) + info->disk.state |= (1 << MD_DISK_WRITEMOSTLY); info->events = __le64_to_cpu(sb->events); sprintf(info->text_version, "1.%d", st->minor_version); info->safe_mode_delay = 200; @@ -613,6 +992,11 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) strncpy(info->name, sb->set_name, 32); info->name[32] = 0; + if ((__le32_to_cpu(sb->feature_map)&MD_FEATURE_REPLACEMENT)) { + info->disk.state &= ~(1 << MD_DISK_SYNC); + info->disk.state |= 1 << MD_DISK_REPLACEMENT; + } + if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RECOVERY_OFFSET)) info->recovery_start = __le32_to_cpu(sb->recovery_offset); else @@ -620,6 +1004,9 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) { info->reshape_active = 1; + if ((sb->feature_map & __le32_to_cpu(MD_FEATURE_NEW_OFFSET)) && + sb->new_offset != 0) + info->reshape_active |= RESHAPE_NO_BACKUP; info->reshape_progress = __le64_to_cpu(sb->reshape_position); info->new_level = __le32_to_cpu(sb->new_level); info->delta_disks = __le32_to_cpu(sb->delta_disks); @@ -630,6 +1017,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) } else info->reshape_active = 0; + info->recovery_blocked = info->reshape_active; + if (map) for (i=0; isb; + if (strcmp(update, "homehost") == 0 && + homehost) { + /* Note that 'homehost' is special as it is really + * a "name" update. + */ + char *c; + update = "name"; + c = strchr(sb->set_name, ':'); + if (c) + strncpy(info->name, c+1, 31 - (c-sb->set_name)); + else + strncpy(info->name, sb->set_name, 32); + info->name[32] = 0; + } + if (strcmp(update, "force-one")==0) { /* Not enough devices for a working array, * so bring this one up-to-date @@ -690,7 +1094,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info, } else if (strcmp(update, "assemble")==0) { int d = info->disk.number; int want; - if (info->disk.state == 6) + if (info->disk.state & (1<disk.raid_disk; else want = 0xFFFF; @@ -766,21 +1170,63 @@ static int update_super1(struct supertype *st, struct mdinfo *info, if (__le32_to_cpu(sb->feature_map)&MD_FEATURE_BITMAP_OFFSET) { struct bitmap_super_s *bm; - bm = (struct bitmap_super_s*)(st->sb+1024); + bm = (struct bitmap_super_s*)(st->sb+MAX_SB_SIZE); memcpy(bm->uuid, sb->set_uuid, 16); } } else if (strcmp(update, "no-bitmap") == 0) { sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_BITMAP_OFFSET); - } else if (strcmp(update, "homehost") == 0 && - homehost) { - char *c; - update = "name"; - c = strchr(sb->set_name, ':'); - if (c) - strncpy(info->name, c+1, 31 - (c-sb->set_name)); - else - strncpy(info->name, sb->set_name, 32); - info->name[32] = 0; + } else if (strcmp(update, "bbl") == 0) { + /* only possible if there is room after the bitmap, or if + * there is no bitmap + */ + unsigned long long sb_offset = __le64_to_cpu(sb->super_offset); + unsigned long long data_offset = __le64_to_cpu(sb->data_offset); + long bitmap_offset = (long)(int32_t)__le32_to_cpu(sb->bitmap_offset); + long bm_sectors = 0; + long space; + +#ifndef MDASSEMBLE + if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) { + struct bitmap_super_s *bsb; + bsb = (struct bitmap_super_s *)(((char*)sb)+MAX_SB_SIZE); + bm_sectors = bitmap_sectors(bsb); + } +#endif + if (sb_offset < data_offset) { + /* 1.1 or 1.2. Put bbl after bitmap leaving at least 32K + */ + long bb_offset; + bb_offset = sb_offset + 8; + if (bm_sectors && bitmap_offset > 0) + bb_offset = bitmap_offset + bm_sectors; + while (bb_offset < (long)sb_offset + 8 + 32*2 + && bb_offset + 8+8 <= (long)data_offset) + /* too close to bitmap, and room to grow */ + bb_offset += 8; + if (bb_offset + 8 <= (long)data_offset) { + sb->bblog_size = __cpu_to_le16(8); + sb->bblog_offset = __cpu_to_le32(bb_offset); + } + } else { + /* 1.0 - Put bbl just before super block */ + if (bm_sectors && bitmap_offset < 0) + space = -bitmap_offset - bm_sectors; + else + space = sb_offset - data_offset - + __le64_to_cpu(sb->data_size); + if (space >= 8) { + sb->bblog_size = __cpu_to_le16(8); + sb->bblog_offset = __cpu_to_le32((unsigned)-8); + } + } + } else if (strcmp(update, "no-bbl") == 0) { + if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) + pr_err("Cannot remove active bbl from %s\n",devname); + else { + sb->bblog_size = 0; + sb->bblog_shift = 0; + sb->bblog_offset = 0; + } } else if (strcmp(update, "name") == 0) { if (info->name[0] == 0) sprintf(info->name, "%d", info->array.md_minor); @@ -798,15 +1244,72 @@ static int update_super1(struct supertype *st, struct mdinfo *info, __le64_to_cpu(sb->data_offset)) { /* set data_size to device size less data_offset */ struct misc_dev_info *misc = (struct misc_dev_info*) - (st->sb + 1024 + 512); - printf("Size was %llu\n", (unsigned long long) - __le64_to_cpu(sb->data_size)); + (st->sb + MAX_SB_SIZE + BM_SUPER_SIZE); sb->data_size = __cpu_to_le64( misc->device_size - __le64_to_cpu(sb->data_offset)); - printf("Size is %llu\n", (unsigned long long) - __le64_to_cpu(sb->data_size)); + } else if (strcmp(update, "revert-reshape") == 0) { + rv = -2; + if (!(sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE))) + pr_err("No active reshape to revert on %s\n", + devname); + else { + __u32 temp; + unsigned long long reshape_sectors; + long reshape_chunk; + rv = 0; + /* reshape_position is a little messy. + * Its value must be a multiple of the larger + * chunk size, and of the "after" data disks. + * So when reverting we need to change it to + * be a multiple of the new "after" data disks, + * which is the old "before". + * If it isn't already a multiple of 'before', + * the only thing we could do would be + * copy some block around on the disks, which + * is easy to get wrong. + * So we reject a revert-reshape unless the + * alignment is good. + */ + if (__le32_to_cpu(sb->level) >= 4 && + __le32_to_cpu(sb->level) <= 6) { + reshape_sectors = __le64_to_cpu(sb->reshape_position); + reshape_chunk = __le32_to_cpu(sb->new_chunk); + reshape_chunk *= __le32_to_cpu(sb->raid_disks) - __le32_to_cpu(sb->delta_disks) - + (__le32_to_cpu(sb->level)==6 ? 2 : 1); + if (reshape_sectors % reshape_chunk) { + pr_err("Reshape position is not suitably aligned.\n"); + pr_err("Try normal assembly and stop again\n"); + return -2; + } + } + sb->raid_disks = __cpu_to_le32(__le32_to_cpu(sb->raid_disks) - + __le32_to_cpu(sb->delta_disks)); + if (sb->delta_disks == 0) + sb->feature_map ^= __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS); + else + sb->delta_disks = __cpu_to_le32(-__le32_to_cpu(sb->delta_disks)); + + temp = sb->new_layout; + sb->new_layout = sb->layout; + sb->layout = temp; + + temp = sb->new_chunk; + sb->new_chunk = sb->chunksize; + sb->chunksize = temp; + + if (sb->feature_map & __cpu_to_le32(MD_FEATURE_NEW_OFFSET)) { + long offset_delta = (int32_t)__le32_to_cpu(sb->new_offset); + sb->data_offset = __cpu_to_le64(__le64_to_cpu(sb->data_offset) + offset_delta); + sb->new_offset = __cpu_to_le32(-offset_delta); + sb->data_size = __cpu_to_le64(__le64_to_cpu(sb->data_size) - offset_delta); + } + } } else if (strcmp(update, "_reshape_progress")==0) sb->reshape_position = __cpu_to_le64(info->reshape_progress); + else if (strcmp(update, "writemostly")==0) + sb->devflags |= WriteMostly1; + else if (strcmp(update, "readwrite")==0) + sb->devflags &= ~WriteMostly1; else rv = -1; @@ -815,20 +1318,20 @@ static int update_super1(struct supertype *st, struct mdinfo *info, } static int init_super1(struct supertype *st, mdu_array_info_t *info, - unsigned long long size, char *name, char *homehost, int *uuid) + unsigned long long size, char *name, char *homehost, + int *uuid, unsigned long long data_offset) { struct mdp_superblock_1 *sb; int spares; int rfd; char defname[10]; + int sbsize; - if (posix_memalign((void**)&sb, 512, (1024 + 512 + - sizeof(struct misc_dev_info))) != 0) { - fprintf(stderr, Name - ": %s could not allocate superblock\n", __func__); + if (posix_memalign((void**)&sb, 4096, SUPER1_SIZE) != 0) { + pr_err("could not allocate superblock\n"); return 0; } - memset(sb, 0, 1024); + memset(sb, 0, SUPER1_SIZE); st->sb = sb; if (info == NULL) { @@ -837,9 +1340,9 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, } spares = info->working_disks - info->active_disks; - if (info->raid_disks + spares > 384) { - fprintf(stderr, Name ": too many devices requested: %d+%d > %d\n", - info->raid_disks , spares, 384); + if (info->raid_disks + spares > MAX_DEVS) { + pr_err("too many devices requested: %d+%d > %d\n", + info->raid_disks , spares, MAX_DEVS); return 0; } @@ -863,7 +1366,6 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, sprintf(defname, "%d", info->md_minor); name = defname; } - memset(sb->set_name, 0, 32); if (homehost && strchr(name, ':')== NULL && strlen(homehost)+1+strlen(name) < 32) { @@ -880,7 +1382,7 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, sb->chunksize = __cpu_to_le32(info->chunk_size>>9); sb->raid_disks = __cpu_to_le32(info->raid_disks); - sb->data_offset = __cpu_to_le64(0); + sb->data_offset = __cpu_to_le64(data_offset); sb->data_size = __cpu_to_le64(0); sb->super_offset = __cpu_to_le64(0); sb->recovery_offset = __cpu_to_le64(0); @@ -891,11 +1393,11 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, sb->resync_offset = MaxSector; else sb->resync_offset = 0; - sb->max_dev = __cpu_to_le32((1024- sizeof(struct mdp_superblock_1))/ - sizeof(sb->dev_roles[0])); - memset(sb->pad3, 0, sizeof(sb->pad3)); + sbsize = sizeof(struct mdp_superblock_1) + 2 * (info->raid_disks + spares); + sbsize = ROUND_UP(sbsize, 512); + sb->max_dev = __cpu_to_le32((sbsize - sizeof(struct mdp_superblock_1)) / 2); - memset(sb->dev_roles, 0xff, 1024 - sizeof(struct mdp_superblock_1)); + memset(sb->dev_roles, 0xff, MAX_SB_SIZE - sizeof(struct mdp_superblock_1)); return 1; } @@ -903,13 +1405,14 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, struct devinfo { int fd; char *devname; + long long data_offset; mdu_disk_info_t disk; struct devinfo *next; }; #ifndef MDASSEMBLE /* Add a device to the superblock being created */ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk, - int fd, char *devname) + int fd, char *devname, unsigned long long data_offset) { struct mdp_superblock_1 *sb = st->sb; __u16 *rp = sb->dev_roles + dk->number; @@ -923,19 +1426,21 @@ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk, *rp = 0xfffe; if (dk->number >= (int)__le32_to_cpu(sb->max_dev) && - __le32_to_cpu(sb->max_dev) < 384) + __le32_to_cpu(sb->max_dev) < MAX_DEVS) sb->max_dev = __cpu_to_le32(dk->number+1); sb->dev_number = __cpu_to_le32(dk->number); + sb->devflags = 0; /* don't copy another disks flags */ sb->sb_csum = calc_sb_1_csum(sb); dip = (struct devinfo **)&st->info; while (*dip) dip = &(*dip)->next; - di = malloc(sizeof(struct devinfo)); + di = xmalloc(sizeof(struct devinfo)); di->fd = fd; di->devname = devname; di->disk = *dk; + di->data_offset = data_offset; di->next = NULL; *dip = di; @@ -949,6 +1454,7 @@ static int store_super1(struct supertype *st, int fd) { struct mdp_superblock_1 *sb = st->sb; unsigned long long sb_offset; + struct align_fd afd; int sbsize; unsigned long long dsize; @@ -960,6 +1466,8 @@ static int store_super1(struct supertype *st, int fd) if (dsize < 24) return 2; + init_afd(&afd, fd); + /* * Calculate the position of the superblock. * It is always aligned to a 4K boundary and @@ -984,32 +1492,28 @@ static int store_super1(struct supertype *st, int fd) return -EINVAL; } - - if (sb_offset != __le64_to_cpu(sb->super_offset) && 0 != __le64_to_cpu(sb->super_offset) ) { - fprintf(stderr, Name ": internal error - sb_offset is wrong\n"); + pr_err("internal error - sb_offset is wrong\n"); abort(); } if (lseek64(fd, sb_offset << 9, 0)< 0LL) return 3; - sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev); - sbsize = (sbsize+511)&(~511UL); + sbsize = ROUND_UP(sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev), 512); - if (awrite(fd, sb, sbsize) != sbsize) + if (awrite(&afd, sb, sbsize) != sbsize) return 4; if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) { struct bitmap_super_s *bm = (struct bitmap_super_s*) - (((char*)sb)+1024); + (((char*)sb)+MAX_SB_SIZE); if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) { locate_bitmap1(st, fd); - if (awrite(fd, bm, sizeof(*bm)) != - sizeof(*bm)) - return 5; + if (awrite(&afd, bm, sizeof(*bm)) != sizeof(*bm)) + return 5; } } fsync(fd); @@ -1043,23 +1547,25 @@ static int write_init_super1(struct supertype *st) int rfd; int rv = 0; unsigned long long bm_space; - unsigned long long reserved; struct devinfo *di; unsigned long long dsize, array_size; unsigned long long sb_offset; + unsigned long long data_offset; - for (di = st->info; di && ! rv ; di = di->next) { - if (di->disk.state == 1) + for (di = st->info; di; di = di->next) { + if (di->disk.state & (1 << MD_DISK_FAULTY)) continue; if (di->fd < 0) continue; - while (Kill(di->devname, NULL, 0, 1, 1) == 0) + while (Kill(di->devname, NULL, 0, -1, 1) == 0) ; sb->dev_number = __cpu_to_le32(di->disk.number); if (di->disk.state & (1<devflags |= __cpu_to_le32(WriteMostly1); + sb->devflags |= WriteMostly1; + else + sb->devflags &= ~WriteMostly1; if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 || read(rfd, sb->device_uuid, 16) != 16) { @@ -1072,7 +1578,7 @@ static int write_init_super1(struct supertype *st) sb->events = 0; refst = dup_super(st); - if (load_super1(refst, di->fd, NULL)==0) { + if (load_super1(refst, di->fd, NULL)==0) { struct mdp_superblock_1 *refsb = refst->sb; memcpy(sb->device_uuid, refsb->device_uuid, 16); @@ -1090,16 +1596,18 @@ static int write_init_super1(struct supertype *st) } free(refst); - if (!get_dev_size(di->fd, NULL, &dsize)) - return 1; + if (!get_dev_size(di->fd, NULL, &dsize)) { + rv = 1; + goto error_out; + } dsize >>= 9; if (dsize < 24) { close(di->fd); - return 2; + rv = 2; + goto error_out; } - /* * Calculate the position of the superblock. * It is always aligned to a 4K boundary and @@ -1107,75 +1615,94 @@ static int write_init_super1(struct supertype *st) * 0: At least 8K, but less than 12K, from end of device * 1: At start of device * 2: 4K from start of device. - * Depending on the array size, we might leave extra space - * for a bitmap. + * data_offset has already been set. */ array_size = __le64_to_cpu(sb->size); - /* work out how much space we left for a bitmap */ - bm_space = choose_bm_space(array_size); + /* work out how much space we left for a bitmap, + * Add 8 sectors for bad block log */ + bm_space = choose_bm_space(array_size) + 8; + data_offset = di->data_offset; + if (data_offset == INVALID_SECTORS) + data_offset = st->data_offset; switch(st->minor_version) { case 0: + if (data_offset == INVALID_SECTORS) + data_offset = 0; sb_offset = dsize; sb_offset -= 8*2; sb_offset &= ~(4*2-1); + sb->data_offset = __cpu_to_le64(data_offset); sb->super_offset = __cpu_to_le64(sb_offset); - sb->data_offset = __cpu_to_le64(0); if (sb_offset < array_size + bm_space) bm_space = sb_offset - array_size; sb->data_size = __cpu_to_le64(sb_offset - bm_space); + if (bm_space >= 8) { + sb->bblog_size = __cpu_to_le16(8); + sb->bblog_offset = __cpu_to_le32((unsigned)-8); + } break; case 1: sb->super_offset = __cpu_to_le64(0); - reserved = bm_space + 4*2; - /* Try for multiple of 1Meg so it is nicely aligned */ - #define ONE_MEG (2*1024) - reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG; - if (reserved + __le64_to_cpu(sb->size) > dsize) - reserved = dsize - __le64_to_cpu(sb->size); - /* force 4K alignment */ - reserved &= ~7ULL; - - sb->data_offset = __cpu_to_le64(reserved); - sb->data_size = __cpu_to_le64(dsize - reserved); + if (data_offset == INVALID_SECTORS) + data_offset = 16; + + sb->data_offset = __cpu_to_le64(data_offset); + sb->data_size = __cpu_to_le64(dsize - data_offset); + if (data_offset >= 8 + 32*2 + 8) { + sb->bblog_size = __cpu_to_le16(8); + sb->bblog_offset = __cpu_to_le32(8 + 32*2); + } else if (data_offset >= 16) { + sb->bblog_size = __cpu_to_le16(8); + sb->bblog_offset = __cpu_to_le32(data_offset-8); + } break; case 2: sb_offset = 4*2; - sb->super_offset = __cpu_to_le64(4*2); - if (4*2 + 4*2 + bm_space + __le64_to_cpu(sb->size) - > dsize) - bm_space = dsize - __le64_to_cpu(sb->size) - - 4*2 - 4*2; - - reserved = bm_space + 4*2 + 4*2; - /* Try for multiple of 1Meg so it is nicely aligned */ - #define ONE_MEG (2*1024) - reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG; - if (reserved + __le64_to_cpu(sb->size) > dsize) - reserved = dsize - __le64_to_cpu(sb->size); - /* force 4K alignment */ - reserved &= ~7ULL; - - sb->data_offset = __cpu_to_le64(reserved); - sb->data_size = __cpu_to_le64(dsize - reserved); + sb->super_offset = __cpu_to_le64(sb_offset); + if (data_offset == INVALID_SECTORS) + data_offset = 24; + + sb->data_offset = __cpu_to_le64(data_offset); + sb->data_size = __cpu_to_le64(dsize - data_offset); + if (data_offset >= 16 + 32*2 + 8) { + sb->bblog_size = __cpu_to_le16(8); + sb->bblog_offset = __cpu_to_le32(8 + 32*2); + } else if (data_offset >= 16+16) { + sb->bblog_size = __cpu_to_le16(8); + /* '8' sectors for the bblog, and another '8' + * because we want offset from superblock, not + * start of device. + */ + sb->bblog_offset = __cpu_to_le32(data_offset-8-8); + } break; default: - return -EINVAL; + pr_err("Failed to write invalid " + "metadata format 1.%i to %s\n", + st->minor_version, di->devname); + rv = -EINVAL; + goto out; + } + if (conf_get_create_info()->bblist == 0) { + sb->bblog_size = 0; + sb->bblog_offset = 0; } - sb->sb_csum = calc_sb_1_csum(sb); rv = store_super1(st, di->fd); - if (rv) - fprintf(stderr, - Name ": failed to write superblock to %s\n", - di->devname); - if (rv == 0 && (__le32_to_cpu(sb->feature_map) & 1)) rv = st->ss->write_bitmap(st, di->fd); close(di->fd); di->fd = -1; + if (rv) + goto error_out; } +error_out: + if (rv) + pr_err("Failed to write metadata to %s\n", + di->devname); +out: return rv; } #endif @@ -1198,15 +1725,11 @@ static int compare_super1(struct supertype *st, struct supertype *tst) return 1; if (!first) { - if (posix_memalign((void**)&first, 512, - 1024 + 512 + - sizeof(struct misc_dev_info)) != 0) { - fprintf(stderr, Name - ": %s could not allocate superblock\n", __func__); + if (posix_memalign((void**)&first, 4096, SUPER1_SIZE) != 0) { + pr_err("could not allocate superblock\n"); return 1; } - memcpy(first, second, 1024 + 512 + - sizeof(struct misc_dev_info)); + memcpy(first, second, SUPER1_SIZE); st->sb = first; return 0; } @@ -1231,9 +1754,12 @@ static int load_super1(struct supertype *st, int fd, char *devname) int uuid[4]; struct bitmap_super_s *bsb; struct misc_dev_info *misc; + struct align_fd afd; free_super1(st); + init_afd(&afd, fd); + if (st->ss == NULL || st->minor_version == -1) { int bestvers = -1; struct supertype tst; @@ -1260,7 +1786,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) int rv; tst.minor_version = bestvers; tst.ss = &super1; - tst.max_devs = 384; + tst.max_devs = MAX_DEVS; rv = load_super1(&tst, fd, devname); if (rv == 0) *st = tst; @@ -1274,7 +1800,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (dsize < 24) { if (devname) - fprintf(stderr, Name ": %s is too small for md: size is %llu sectors.\n", + pr_err("%s is too small for md: size is %llu sectors.\n", devname, dsize); return 1; } @@ -1303,27 +1829,21 @@ static int load_super1(struct supertype *st, int fd, char *devname) return -EINVAL; } - ioctl(fd, BLKFLSBUF, 0); /* make sure we read current data */ - - if (lseek64(fd, sb_offset << 9, 0)< 0LL) { if (devname) - fprintf(stderr, Name ": Cannot seek to superblock on %s: %s\n", + pr_err("Cannot seek to superblock on %s: %s\n", devname, strerror(errno)); return 1; } - if (posix_memalign((void**)&super, 512, - 1024 + 512 + - sizeof(struct misc_dev_info)) != 0) { - fprintf(stderr, Name ": %s could not allocate superblock\n", - __func__); + if (posix_memalign((void**)&super, 4096, SUPER1_SIZE) != 0) { + pr_err("could not allocate superblock\n"); return 1; } - if (aread(fd, super, 1024) != 1024) { + if (aread(&afd, super, MAX_SB_SIZE) != MAX_SB_SIZE) { if (devname) - fprintf(stderr, Name ": Cannot read superblock on %s\n", + pr_err("Cannot read superblock on %s\n", devname); free(super); return 1; @@ -1331,7 +1851,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (__le32_to_cpu(super->magic) != MD_SB_MAGIC) { if (devname) - fprintf(stderr, Name ": No super block found on %s (Expected magic %08x, got %08x)\n", + pr_err("No super block found on %s (Expected magic %08x, got %08x)\n", devname, MD_SB_MAGIC, __le32_to_cpu(super->magic)); free(super); return 2; @@ -1339,24 +1859,26 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (__le32_to_cpu(super->major_version) != 1) { if (devname) - fprintf(stderr, Name ": Cannot interpret superblock on %s - version is %d\n", + pr_err("Cannot interpret superblock on %s - version is %d\n", devname, __le32_to_cpu(super->major_version)); free(super); return 2; } if (__le64_to_cpu(super->super_offset) != sb_offset) { if (devname) - fprintf(stderr, Name ": No superblock found on %s (super_offset is wrong)\n", + pr_err("No superblock found on %s (super_offset is wrong)\n", devname); free(super); return 2; } st->sb = super; - bsb = (struct bitmap_super_s *)(((char*)super)+1024); + bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE); - misc = (struct misc_dev_info*) (((char*)super)+1024+512); + misc = (struct misc_dev_info*) (((char*)super)+MAX_SB_SIZE+BM_SUPER_SIZE); misc->device_size = dsize; + if (st->data_offset == INVALID_SECTORS) + st->data_offset = __le64_to_cpu(super->data_offset); /* Now check on the bitmap superblock */ if ((__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) == 0) @@ -1366,8 +1888,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) * should get that written out. */ locate_bitmap1(st, fd); - if (aread(fd, ((char*)super)+1024, 512) - != 512) + if (aread(&afd, bsb, 512) != 512) goto no_bitmap; uuid_from_super1(st, uuid); @@ -1377,21 +1898,20 @@ static int load_super1(struct supertype *st, int fd, char *devname) return 0; no_bitmap: - super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map) & ~1); + super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map) + & ~MD_FEATURE_BITMAP_OFFSET); return 0; } - static struct supertype *match_metadata_desc1(char *arg) { - struct supertype *st = malloc(sizeof(*st)); - if (!st) return st; + struct supertype *st = xcalloc(1, sizeof(*st)); - memset(st, 0, sizeof(*st)); - st->container_dev = NoMdDev; + st->container_devnm[0] = 0; st->ss = &super1; - st->max_devs = 384; + st->max_devs = MAX_DEVS; st->sb = NULL; + st->data_offset = INVALID_SECTORS; /* leading zeros can be safely ignored. --detail generates them. */ while (*arg == '0') arg++; @@ -1428,46 +1948,57 @@ static struct supertype *match_metadata_desc1(char *arg) * superblock type st, and reserving 'reserve' sectors for * a possible bitmap */ -static __u64 avail_size1(struct supertype *st, __u64 devsize) +static __u64 avail_size1(struct supertype *st, __u64 devsize, + unsigned long long data_offset) { struct mdp_superblock_1 *super = st->sb; + int bmspace = 0; + int bbspace = 0; if (devsize < 24) return 0; - 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) { + if (__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) { /* hot-add. allow for actual size of bitmap */ struct bitmap_super_s *bsb; - bsb = (struct bitmap_super_s *)(((char*)super)+1024); - devsize -= bitmap_sectors(bsb); + bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE); + bmspace = bitmap_sectors(bsb); } #endif + /* Allow space for bad block log */ + if (super->bblog_size) + bbspace = __le16_to_cpu(super->bblog_size); 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; - } + + if (data_offset == INVALID_SECTORS) + data_offset = st->data_offset; + + if (data_offset != INVALID_SECTORS) + switch(st->minor_version) { + case 0: + return devsize - data_offset - 8*2 - bbspace; + case 1: + case 2: + return devsize - data_offset; + default: + return 0; + } + + devsize -= bmspace; + switch(st->minor_version) { case 0: /* at end */ - return ((devsize - 8*2 ) & ~(4*2-1)); + return ((devsize - 8*2 - bbspace ) & ~(4*2-1)); case 1: /* at start, 4K for superblock and possible bitmap */ - return devsize - 4*2; + return devsize - 4*2 - bbspace; case 2: /* 4k from start, 4K for superblock and possible bitmap */ - return devsize - (4+4)*2; + return devsize - (4+4)*2 - bbspace; } return 0; } @@ -1479,12 +2010,10 @@ add_internal_bitmap1(struct supertype *st, int may_change, int major) { /* - * If not may_change, then this is a 'Grow', and the bitmap - * must fit after the superblock. - * If may_change, then this is create, and we can put the bitmap - * before the superblock if we like, or may move the start. - * If !may_change, the bitmap MUST live at offset of 1K, until - * we get a sysfs interface. + * If not may_change, then this is a 'Grow' without sysfs support for + * bitmaps, and the bitmap must fit after the superblock at 1K offset. + * If may_change, then this is create or a Grow with sysfs syupport, + * and we can put the bitmap wherever we like. * * size is in sectors, chunk is in bytes !!! */ @@ -1493,31 +2022,45 @@ add_internal_bitmap1(struct supertype *st, unsigned long long max_bits; unsigned long long min_chunk; long offset; + long bbl_offset, bbl_size; unsigned long long chunk = *chunkp; int room = 0; + int creating = 0; struct mdp_superblock_1 *sb = st->sb; - bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + 1024); + bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MAX_SB_SIZE); + int uuid[4]; + if (__le64_to_cpu(sb->data_size) == 0) + /* Must be creating the array, else data_size would be non-zero */ + creating = 1; switch(st->minor_version) { case 0: /* either 3K after the superblock (when hot-add), * or some amount of space before. */ - if (may_change) { + if (creating) { /* We are creating array, so we *know* how much room has * been left. */ offset = 0; - room = choose_bm_space(__le64_to_cpu(sb->size)); + bbl_size = 8; + room = choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size; } else { room = __le64_to_cpu(sb->super_offset) - __le64_to_cpu(sb->data_offset) - __le64_to_cpu(sb->data_size); - /* remove '1 ||' when we can set offset via sysfs */ - if (1 || (room < 3*2 && + bbl_size = __le16_to_cpu(sb->bblog_size); + if (bbl_size < 8) + bbl_size = 8; + bbl_offset = (__s32)__le32_to_cpu(sb->bblog_offset); + if (bbl_size < -bbl_offset) + bbl_size = -bbl_offset; + + if (!may_change || (room < 3*2 && __le32_to_cpu(sb->max_dev) <= 384)) { room = 3*2; offset = 1*2; + bbl_size = 0; } else { offset = 0; /* means movable offset */ } @@ -1525,17 +2068,25 @@ add_internal_bitmap1(struct supertype *st, break; case 1: case 2: /* between superblock and data */ - if (may_change) { + if (creating) { offset = 4*2; - room = choose_bm_space(__le64_to_cpu(sb->size)); + bbl_size = 8; + room = choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size; } else { room = __le64_to_cpu(sb->data_offset) - __le64_to_cpu(sb->super_offset); - if (1 || __le32_to_cpu(sb->max_dev) <= 384) { - room -= 2; + bbl_size = __le16_to_cpu(sb->bblog_size); + if (bbl_size) + room = __le32_to_cpu(sb->bblog_offset) + bbl_size; + else + bbl_size = 8; + + if (!may_change) { + room -= 2; /* Leave 1K for superblock */ offset = 2; + bbl_size = 0; } else { - room -= 4*2; + room -= 4*2; /* leave 4K for superblock */ offset = 4*2; } } @@ -1544,10 +2095,15 @@ add_internal_bitmap1(struct supertype *st, return 0; } + room -= bbl_size; if (chunk == UnSet && room > 128*2) /* Limit to 128K of bitmap when chunk size not requested */ room = 128*2; + if (room <= 1) + /* No room for a bitmap */ + return 0; + max_bits = (room * 512 - sizeof(bitmap_super_t)) * 8; min_chunk = 4096; /* sub-page chunks don't work yet.. */ @@ -1575,16 +2131,18 @@ add_internal_bitmap1(struct supertype *st, bits = (size*512) / chunk + 1; room = ((bits+7)/8 + sizeof(bitmap_super_t) +4095)/4096; room *= 8; /* convert 4K blocks to sectors */ - offset = -room; + offset = -room - bbl_size; } - sb->bitmap_offset = __cpu_to_le32(offset); + sb->bitmap_offset = (int32_t)__cpu_to_le32(offset); - sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | 1); + sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) + | MD_FEATURE_BITMAP_OFFSET); memset(bms, 0, sizeof(*bms)); bms->magic = __cpu_to_le32(BITMAP_MAGIC); bms->version = __cpu_to_le32(major); - uuid_from_super1(st, (int*)bms->uuid); + uuid_from_super1(st, uuid); + memcpy(bms->uuid, uuid, 16); bms->chunksize = __cpu_to_le32(chunk); bms->daemon_sleep = __cpu_to_le32(delay); bms->sync_size = __cpu_to_le64(size); @@ -1594,7 +2152,6 @@ add_internal_bitmap1(struct supertype *st, return 1; } - static void locate_bitmap1(struct supertype *st, int fd) { unsigned long long offset; @@ -1618,16 +2175,21 @@ static void locate_bitmap1(struct supertype *st, int fd) static int write_bitmap1(struct supertype *st, int fd) { struct mdp_superblock_1 *sb = st->sb; - bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+1024); + bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+MAX_SB_SIZE); int rv = 0; - + void *buf; int towrite, n; - char *buf = (char*)(((long)(abuf+4096))&~4095UL); + struct align_fd afd; + + init_afd(&afd, fd); locate_bitmap1(st, fd); + if (posix_memalign(&buf, 4096, 4096)) + return -ENOMEM; + memset(buf, 0xff, 4096); - memcpy(buf, ((char*)sb)+1024, sizeof(bitmap_super_t)); + memcpy(buf, (char *)bms, sizeof(bitmap_super_t)); towrite = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9); towrite = (towrite+7) >> 3; /* bits to bytes */ @@ -1637,7 +2199,7 @@ static int write_bitmap1(struct supertype *st, int fd) n = towrite; if (n > 4096) n = 4096; - n = write(fd, buf, n); + n = awrite(&afd, buf, n); if (n > 0) towrite -= n; else @@ -1648,6 +2210,7 @@ static int write_bitmap1(struct supertype *st, int fd) if (towrite) rv = -2; + free(buf); return rv; } @@ -1669,27 +2232,34 @@ static void free_super1(struct supertype *st) static int validate_geometry1(struct supertype *st, int level, int layout, int raiddisks, int *chunk, unsigned long long size, + unsigned long long data_offset, char *subdev, unsigned long long *freesize, int verbose) { - unsigned long long ldsize; + unsigned long long ldsize, devsize; + int bmspace; + unsigned long long headroom; int fd; if (level == LEVEL_CONTAINER) { if (verbose) - fprintf(stderr, Name ": 1.x metadata does not support containers\n"); + pr_err("1.x metadata does not support containers\n"); return 0; } - if (chunk && *chunk == UnSet) + if (*chunk == UnSet) *chunk = DEFAULT_CHUNK; if (!subdev) return 1; + if (st->minor_version < 0) + /* not specified, so time to set default */ + st->minor_version = 2; + fd = open(subdev, O_RDONLY|O_EXCL, 0); if (fd < 0) { if (verbose) - fprintf(stderr, Name ": super1.x cannot open %s: %s\n", + pr_err("super1.x cannot open %s: %s\n", subdev, strerror(errno)); return 0; } @@ -1700,11 +2270,118 @@ static int validate_geometry1(struct supertype *st, int level, } close(fd); - *freesize = avail_size1(st, ldsize >> 9); + devsize = ldsize >> 9; + if (devsize < 24) { + *freesize = 0; + return 0; + } + + /* creating: allow suitable space for bitmap */ + bmspace = choose_bm_space(devsize); + + if (data_offset == INVALID_SECTORS) + data_offset = st->data_offset; + if (data_offset == INVALID_SECTORS) + switch (st->minor_version) { + case 0: + data_offset = 0; + break; + case 1: + case 2: + /* Choose data offset appropriate for this device + * and use as default for whole array. + * The data_offset must allow for bitmap space + * and base metadata, should allow for some headroom + * for reshape, and should be rounded to multiple + * of 1M. + * Headroom is limited to 128M, but aim for about 0.1% + */ + headroom = 128*1024*2; + while ((headroom << 10) > devsize && + (*chunk == 0 || + headroom / 2 >= ((unsigned)(*chunk)*2)*2)) + headroom >>= 1; + data_offset = 12*2 + bmspace + headroom; + #define ONE_MEG (2*1024) + if (data_offset > ONE_MEG) + data_offset = (data_offset / ONE_MEG) * ONE_MEG; + break; + } + if (st->data_offset == INVALID_SECTORS) + st->data_offset = data_offset; + switch(st->minor_version) { + case 0: /* metadata at end. Round down and subtract space to reserve */ + devsize = (devsize & ~(4ULL*2-1)); + /* space for metadata, bblog, bitmap */ + devsize -= 8*2 + 8 + bmspace; + break; + case 1: + case 2: + devsize -= data_offset; + break; + } + *freesize = devsize; return 1; } #endif /* MDASSEMBLE */ +void *super1_make_v0(struct supertype *st, struct mdinfo *info, mdp_super_t *sb0) +{ + /* Create a v1.0 superblock based on 'info'*/ + void *ret; + struct mdp_superblock_1 *sb; + int i; + int rfd; + unsigned long long offset; + + if (posix_memalign(&ret, 4096, 1024) != 0) + return NULL; + sb = ret; + memset(ret, 0, 1024); + sb->magic = __cpu_to_le32(MD_SB_MAGIC); + sb->major_version = __cpu_to_le32(1); + + copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid); + sprintf(sb->set_name, "%d", sb0->md_minor); + sb->ctime = __cpu_to_le32(info->array.ctime+1); + sb->level = __cpu_to_le32(info->array.level); + sb->layout = __cpu_to_le32(info->array.layout); + sb->size = __cpu_to_le64(info->component_size); + sb->chunksize = __cpu_to_le32(info->array.chunk_size/512); + sb->raid_disks = __cpu_to_le32(info->array.raid_disks); + if (info->array.level > 0) + sb->data_size = sb->size; + else + sb->data_size = st->ss->avail_size(st, st->devsize/512, 0); + sb->resync_offset = MaxSector; + sb->max_dev = __cpu_to_le32(MD_SB_DISKS); + sb->dev_number = __cpu_to_le32(info->disk.number); + sb->utime = __cpu_to_le64(info->array.utime); + + offset = st->devsize/512 - 8*2; + offset &= ~(4*2-1); + sb->super_offset = __cpu_to_le64(offset); + //*(__u64*)(st->other + 128 + 8 + 8) = __cpu_to_le64(offset); + + if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 || + read(rfd, sb->device_uuid, 16) != 16) { + __u32 r[4] = {random(), random(), random(), random()}; + memcpy(sb->device_uuid, r, 16); + } + if (rfd >= 0) + close(rfd); + + for (i = 0; i < MD_SB_DISKS; i++) { + int state = sb0->disks[i].state; + sb->dev_roles[i] = 0xFFFF; + if ((state & (1<dev_roles[i] = __cpu_to_le16(sb0->disks[i].raid_disk); + } + sb->sb_csum = calc_sb_1_csum(sb); + return ret; +} + struct superswitch super1 = { #ifndef MDASSEMBLE .examine_super = examine_super1, @@ -1716,6 +2393,8 @@ struct superswitch super1 = { .write_init_super = write_init_super1, .validate_geometry = validate_geometry1, .add_to_super = add_to_super1, + .examine_badblocks = examine_badblocks_super1, + .copy_metadata = copy_metadata1, #endif .match_home = match_home1, .uuid_from_super = uuid_from_super1,