diff options
Diffstat (limited to 'super1.c')
-rw-r--r-- | super1.c | 355 |
1 files changed, 225 insertions, 130 deletions
@@ -454,12 +454,6 @@ static void export_detail_super1(struct supertype *st) } if (len) printf("MD_NAME=%.*s\n", len, sb->set_name); - printf("MD_UUID="); - for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); - printf("%02x", sb->set_uuid[i]); - } - printf("\n"); } #endif @@ -491,7 +485,7 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info) int role; info->array.major_version = 1; - info->array.minor_version = __le32_to_cpu(sb->feature_map); + info->array.minor_version = st->minor_version; info->array.patch_version = 0; info->array.raid_disks = __le32_to_cpu(sb->raid_disks); info->array.level = __le32_to_cpu(sb->level); @@ -529,6 +523,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info) info->disk.raid_disk = role; } info->events = __le64_to_cpu(sb->events); + sprintf(info->text_version, "1.%d", st->minor_version); + info->safe_mode_delay = 200; memcpy(info->uuid, sb->set_uuid, 16); @@ -687,7 +683,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info, __le64_to_cpu(sb->data_offset)) { /* set data_size to device size less data_offset */ struct misc_dev_info *misc = (struct misc_dev_info*) - (st->sb + 1024 + sizeof(struct bitmap_super_s)); + (st->sb + 1024 + 512); printf("Size was %llu\n", (unsigned long long) __le64_to_cpu(sb->data_size)); sb->data_size = __cpu_to_le64( @@ -705,15 +701,21 @@ 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) { - struct mdp_superblock_1 *sb = malloc(1024 + sizeof(bitmap_super_t) + - sizeof(struct misc_dev_info)); + struct mdp_superblock_1 *sb; int spares; int rfd; char defname[10]; + + if (posix_memalign((void**)&sb, 512, (1024 + 512 + + sizeof(struct misc_dev_info))) != 0) { + fprintf(stderr, Name + ": %s could not allocate superblock\n", __func__); + return 0; + } memset(sb, 0, 1024); st->sb = sb; - if (info->major_version == -1) { + if (info == NULL) { /* zeroing superblock */ return 0; } @@ -784,18 +786,42 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, 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_super1(struct supertype *st, mdu_disk_info_t *dk) +static void add_to_super1(struct supertype *st, mdu_disk_info_t *dk, + int fd, char *devname) { struct mdp_superblock_1 *sb = st->sb; __u16 *rp = sb->dev_roles + dk->number; + struct devinfo *di, **dip; + if ((dk->state & 6) == 6) /* active, sync */ *rp = __cpu_to_le16(dk->raid_disk); else if ((dk->state & ~2) == 0) /* active or idle -> spare */ *rp = 0xffff; else *rp = 0xfffe; + + sb->dev_number = __cpu_to_le32(dk->number); + sb->sb_csum = calc_sb_1_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 = *dk; + di->next = NULL; + *dip = di; } +#endif static void locate_bitmap1(struct supertype *st, int fd); @@ -851,6 +877,7 @@ static int store_super1(struct supertype *st, int fd) return 3; sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev); + sbsize = (sbsize+511)&(~511UL); if (write(fd, sb, sbsize) != sbsize) return 4; @@ -860,7 +887,8 @@ static int store_super1(struct supertype *st, int fd) (((char*)sb)+1024); if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) { locate_bitmap1(st, fd); - if (write(fd, bm, sizeof(*bm)) != sizeof(*bm)) + if (write(fd, bm, ROUND_UP(sizeof(*bm),512)) != + ROUND_UP(sizeof(*bm),512)) return 5; } } @@ -883,123 +911,133 @@ static unsigned long choose_bm_space(unsigned long devsize) return 4*2; } -static int write_init_super1(struct supertype *st, - mdu_disk_info_t *dinfo, char *devname) +#ifndef MDASSEMBLE +static int write_init_super1(struct supertype *st) { struct mdp_superblock_1 *sb = st->sb; struct supertype refst; - int fd = open(devname, O_RDWR | O_EXCL); int rfd; - int rv; + int rv = 0; int bm_space; - + struct devinfo *di; unsigned long long dsize, array_size; long long sb_offset; + for (di = st->info; di && ! rv ; di = di->next) { + if (di->disk.state == 1) + continue; + if (di->fd < 0) + continue; - if (fd < 0) { - fprintf(stderr, Name ": Failed to open %s to write superblock\n", - devname); - return -1; - } + Kill(di->devname, 0, 1, 1); + Kill(di->devname, 0, 1, 1); - sb->dev_number = __cpu_to_le32(dinfo->number); - if (dinfo->state & (1<<MD_DISK_WRITEMOSTLY)) - sb->devflags |= __cpu_to_le32(WriteMostly1); + sb->dev_number = __cpu_to_le32(di->disk.number); + if (di->disk.state & (1<<MD_DISK_WRITEMOSTLY)) + sb->devflags |= __cpu_to_le32(WriteMostly1); - if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 || - read(rfd, sb->device_uuid, 16) != 16) { - *(__u32*)(sb->device_uuid) = random(); - *(__u32*)(sb->device_uuid+4) = random(); - *(__u32*)(sb->device_uuid+8) = random(); - *(__u32*)(sb->device_uuid+12) = random(); - } - if (rfd >= 0) close(rfd); - sb->events = 0; - - refst =*st; - refst.sb = NULL; - if (load_super1(&refst, fd, NULL)==0) { - struct mdp_superblock_1 *refsb = refst.sb; - - memcpy(sb->device_uuid, refsb->device_uuid, 16); - if (memcmp(sb->set_uuid, refsb->set_uuid, 16)==0) { - /* same array, so preserve events and dev_number */ - sb->events = refsb->events; - /* bugs in 2.6.17 and earlier mean the dev_number - * chosen in Manage must be preserved - */ - if (get_linux_version() >= 2006018) - sb->dev_number = refsb->dev_number; + if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 || + read(rfd, sb->device_uuid, 16) != 16) { + *(__u32*)(sb->device_uuid) = random(); + *(__u32*)(sb->device_uuid+4) = random(); + *(__u32*)(sb->device_uuid+8) = random(); + *(__u32*)(sb->device_uuid+12) = random(); + } + if (rfd >= 0) close(rfd); + sb->events = 0; + + refst =*st; + refst.sb = NULL; + if (load_super1(&refst, di->fd, NULL)==0) { + struct mdp_superblock_1 *refsb = refst.sb; + + memcpy(sb->device_uuid, refsb->device_uuid, 16); + if (memcmp(sb->set_uuid, refsb->set_uuid, 16)==0) { + /* same array, so preserve events and + * dev_number */ + sb->events = refsb->events; + /* bugs in 2.6.17 and earlier mean the + * dev_number chosen in Manage must be preserved + */ + if (get_linux_version() >= 2006018) + sb->dev_number = refsb->dev_number; + } + free(refsb); } - free(refsb); - } - - if (!get_dev_size(fd, NULL, &dsize)) - return 1; - dsize >>= 9; - if (dsize < 24) { - close(fd); - return 2; - } + if (!get_dev_size(di->fd, NULL, &dsize)) + return 1; + dsize >>= 9; + if (dsize < 24) { + close(di->fd); + return 2; + } - /* - * Calculate the position of the superblock. - * It is always aligned to a 4K boundary and - * depending on minor_version, it can be: - * 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. - */ - array_size = __le64_to_cpu(sb->size); - /* work out how much space we left for a bitmap */ - bm_space = choose_bm_space(array_size); - switch(st->minor_version) { - case 0: - sb_offset = dsize; - sb_offset -= 8*2; - sb_offset &= ~(4*2-1); - sb->super_offset = __cpu_to_le64(sb_offset); - sb->data_offset = __cpu_to_le64(0); + /* + * Calculate the position of the superblock. + * It is always aligned to a 4K boundary and + * depending on minor_version, it can be: + * 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. + */ + array_size = __le64_to_cpu(sb->size); + /* work out how much space we left for a bitmap */ + bm_space = choose_bm_space(array_size); + + switch(st->minor_version) { + case 0: + sb_offset = dsize; + sb_offset -= 8*2; + sb_offset &= ~(4*2-1); + sb->super_offset = __cpu_to_le64(sb_offset); + sb->data_offset = __cpu_to_le64(0); if (sb_offset - bm_space < array_size) bm_space = sb_offset - array_size; - sb->data_size = __cpu_to_le64(sb_offset - bm_space); - break; - case 1: - sb->super_offset = __cpu_to_le64(0); - if (4*2 + bm_space + __le64_to_cpu(sb->size) > dsize) - bm_space = dsize - __le64_to_cpu(sb->size) - 4*2; - sb->data_offset = __cpu_to_le64(bm_space + 4*2); - sb->data_size = __cpu_to_le64(dsize - bm_space - 4*2); - 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; - sb->data_offset = __cpu_to_le64(4*2 + 4*2 + bm_space); - sb->data_size = __cpu_to_le64(dsize - 4*2 - 4*2 - bm_space ); - break; - default: - return -EINVAL; - } + sb->data_size = __cpu_to_le64(sb_offset - bm_space); + break; + case 1: + sb->super_offset = __cpu_to_le64(0); + if (4*2 + bm_space + __le64_to_cpu(sb->size) > dsize) + bm_space = dsize - __le64_to_cpu(sb->size) -4*2; + sb->data_offset = __cpu_to_le64(bm_space + 4*2); + sb->data_size = __cpu_to_le64(dsize - bm_space - 4*2); + 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; + sb->data_offset = __cpu_to_le64(4*2 + 4*2 + bm_space); + sb->data_size = __cpu_to_le64(dsize - 4*2 - 4*2 + - bm_space ); + break; + default: + return -EINVAL; + } - sb->sb_csum = calc_sb_1_csum(sb); - rv = store_super1(st, fd); - if (rv) - fprintf(stderr, Name ": failed to write superblock to %s\n", devname); + 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, fd); - close(fd); + if (rv == 0 && (__le32_to_cpu(sb->feature_map) & 1)) + rv = st->ss->write_bitmap(st, di->fd); + close(di->fd); + di->fd = -1; + } return rv; } +#endif static int compare_super1(struct supertype *st, struct supertype *tst) { @@ -1019,9 +1057,14 @@ static int compare_super1(struct supertype *st, struct supertype *tst) return 1; if (!first) { - first = malloc(1024+sizeof(bitmap_super_t) + - sizeof(struct misc_dev_info)); - memcpy(first, second, 1024+sizeof(bitmap_super_t) + + if (posix_memalign((void**)&first, 512, + 1024 + 512 + + sizeof(struct misc_dev_info)) != 0) { + fprintf(stderr, Name + ": %s could not allocate superblock\n", __func__); + return 1; + } + memcpy(first, second, 1024 + 512 + sizeof(struct misc_dev_info)); st->sb = first; return 0; @@ -1052,13 +1095,16 @@ static int load_super1(struct supertype *st, int fd, char *devname) free_super1(st); + if (st->subarray[0]) + return 1; + if (st->ss == NULL || st->minor_version == -1) { int bestvers = -1; struct supertype tst; __u64 bestctime = 0; /* guess... choose latest ctime */ + memset(&tst, 0, sizeof(tst)); tst.ss = &super1; - tst.sb = NULL; for (tst.minor_version = 0; tst.minor_version <= 2 ; tst.minor_version++) { switch(load_super1(&tst, fd, devname)) { case 0: super = tst.sb; @@ -1131,8 +1177,13 @@ static int load_super1(struct supertype *st, int fd, char *devname) return 1; } - super = malloc(1024 + sizeof(bitmap_super_t) + - sizeof(struct misc_dev_info)); + if (posix_memalign((void**)&super, 512, + 1024 + 512 + + sizeof(struct misc_dev_info)) != 0) { + fprintf(stderr, Name ": %s could not allocate superblock\n", + __func__); + return 1; + } if (read(fd, super, 1024) != 1024) { if (devname) @@ -1168,7 +1219,7 @@ static int load_super1(struct supertype *st, int fd, char *devname) bsb = (struct bitmap_super_s *)(((char*)super)+1024); - misc = (struct misc_dev_info*) (bsb+1); + misc = (struct misc_dev_info*) (((char*)super)+1024+512); misc->device_size = dsize; /* Now check on the bitmap superblock */ @@ -1179,8 +1230,8 @@ static int load_super1(struct supertype *st, int fd, char *devname) * should get that written out. */ locate_bitmap1(st, fd); - if (read(fd, ((char*)super)+1024, sizeof(struct bitmap_super_s)) - != sizeof(struct bitmap_super_s)) + if (read(fd, ((char*)super)+1024, 512) + != 512) goto no_bitmap; uuid_from_super1(st, uuid); @@ -1200,23 +1251,30 @@ static struct supertype *match_metadata_desc1(char *arg) struct supertype *st = malloc(sizeof(*st)); if (!st) return st; + memset(st, 0, sizeof(*st)); st->ss = &super1; st->max_devs = 384; st->sb = NULL; - if (strcmp(arg, "1.0") == 0) { + /* leading zeros can be safely ignored. --detail generates them. */ + while (*arg == '0') + arg++; + if (strcmp(arg, "1.0") == 0 || + strcmp(arg, "1.00") == 0) { st->minor_version = 0; return st; } - if (strcmp(arg, "1.1") == 0) { + if (strcmp(arg, "1.1") == 0 || + strcmp(arg, "1.01") == 0) { st->minor_version = 1; return st; } - if (strcmp(arg, "1.2") == 0) { + if (strcmp(arg, "1.2") == 0 || + strcmp(arg, "1.02") == 0) { st->minor_version = 2; return st; } if (strcmp(arg, "1") == 0 || - strcmp(arg, "default/large") == 0) { + strcmp(arg, "default") == 0) { st->minor_version = -1; return st; } @@ -1410,25 +1468,28 @@ static int write_bitmap1(struct supertype *st, int fd) int rv = 0; int towrite, n; - char buf[4096]; + char abuf[4096+512]; + char *buf = (char*)(((long)(abuf+512))&~511UL); locate_bitmap1(st, fd); - if (write(fd, ((char*)sb)+1024, sizeof(bitmap_super_t)) != - sizeof(bitmap_super_t)) - return -2; + memset(buf, 0xff, 4096); + memcpy(buf, ((char*)sb)+1024, sizeof(bitmap_super_t)); + towrite = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9); towrite = (towrite+7) >> 3; /* bits to bytes */ - memset(buf, 0xff, sizeof(buf)); + towrite += sizeof(bitmap_super_t); + towrite = ROUND_UP(towrite, 512); 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) @@ -1444,6 +1505,40 @@ static void free_super1(struct supertype *st) st->sb = NULL; } +#ifndef MDASSEMBLE +static int validate_geometry1(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 (!subdev) + return 1; + + fd = open(subdev, O_RDONLY|O_EXCL, 0); + if (fd < 0) { + if (verbose) + fprintf(stderr, Name ": super1.x cannot open %s: %s\n", + subdev, strerror(errno)); + return 0; + } + + if (!get_dev_size(fd, subdev, &ldsize)) { + close(fd); + return 0; + } + close(fd); + + *freesize = avail_size1(st, ldsize >> 9); + return 1; +} +#endif /* MDASSEMBLE */ + struct superswitch super1 = { #ifndef MDASSEMBLE .examine_super = examine_super1, @@ -1452,15 +1547,16 @@ struct superswitch super1 = { .detail_super = detail_super1, .brief_detail_super = brief_detail_super1, .export_detail_super = export_detail_super1, + .write_init_super = write_init_super1, + .validate_geometry = validate_geometry1, + .add_to_super = add_to_super1, #endif .match_home = match_home1, .uuid_from_super = uuid_from_super1, .getinfo_super = getinfo_super1, .update_super = update_super1, .init_super = init_super1, - .add_to_super = add_to_super1, .store_super = store_super1, - .write_init_super = write_init_super1, .compare_super = compare_super1, .load_super = load_super1, .match_metadata_desc = match_metadata_desc1, @@ -1469,7 +1565,6 @@ struct superswitch super1 = { .locate_bitmap = locate_bitmap1, .write_bitmap = write_bitmap1, .free_super = free_super1, - .major = 1, #if __BYTE_ORDER == BIG_ENDIAN .swapuuid = 0, #else |