X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=super-intel.c;h=207d3be952fa78f8bf4c26332812b3d73a912a63;hp=6676692ff9e52b836eed6ac73212aaf30cdc6e97;hb=0d5a423fe7481de5ce20c6174841afeb1aadd255;hpb=f2f27e63c44baac976b0022c6830393954d59fd4 diff --git a/super-intel.c b/super-intel.c index 6676692f..207d3be9 100644 --- a/super-intel.c +++ b/super-intel.c @@ -21,9 +21,11 @@ #include "mdadm.h" #include "mdmon.h" #include "sha1.h" +#include "platform-intel.h" #include #include #include +#include /* MPB == Metadata Parameter Block */ #define MPB_SIGNATURE "Intel Raid ISM Cfg Sig. " @@ -51,6 +53,7 @@ #define MPB_SECTOR_CNT 418 #define IMSM_RESERVED_SECTORS 4096 +#define SECT_PER_MB_SHIFT 11 /* Disk configuration info. */ #define IMSM_MAX_DEVICES 255 @@ -86,7 +89,7 @@ struct imsm_map { __u8 num_members; /* number of member disks */ __u8 num_domains; /* number of parity domains */ __u8 failed_disk_num; /* valid only when state is degraded */ - __u8 reserved[1]; + __u8 ddf; __u32 filler[7]; /* expansion area */ #define IMSM_ORD_REBUILD (1 << 24) __u32 disk_ord_tbl[1]; /* disk_ord_tbl[num_members], @@ -103,6 +106,7 @@ struct imsm_vol { #define MIGR_VERIFY 2 /* analagous to echo check > sync_action */ #define MIGR_GEN_MIGR 3 #define MIGR_STATE_CHANGE 4 +#define MIGR_REPAIR 5 __u8 migr_type; /* Initializing, Rebuilding, ... */ __u8 dirty; __u8 fs_state; /* fast-sync state for CnG (0xff == disabled) */ @@ -191,6 +195,29 @@ struct bbm_log { static char *map_state_str[] = { "normal", "uninitialized", "degraded", "failed" }; #endif +static __u8 migr_type(struct imsm_dev *dev) +{ + if (dev->vol.migr_type == MIGR_VERIFY && + dev->status & DEV_VERIFY_AND_FIX) + return MIGR_REPAIR; + else + return dev->vol.migr_type; +} + +static void set_migr_type(struct imsm_dev *dev, __u8 migr_type) +{ + /* for compatibility with older oroms convert MIGR_REPAIR, into + * MIGR_VERIFY w/ DEV_VERIFY_AND_FIX status + */ + if (migr_type == MIGR_REPAIR) { + dev->vol.migr_type = MIGR_VERIFY; + dev->status |= DEV_VERIFY_AND_FIX; + } else { + dev->vol.migr_type = migr_type; + dev->status &= ~DEV_VERIFY_AND_FIX; + } +} + static unsigned int sector_count(__u32 bytes) { return ((bytes + (512-1)) & (~(512-1))) / 512; @@ -201,6 +228,12 @@ static unsigned int mpb_sectors(struct imsm_super *mpb) return sector_count(__le32_to_cpu(mpb->mpb_size)); } +struct intel_dev { + struct imsm_dev *dev; + struct intel_dev *next; + int index; +}; + /* internal representation of IMSM metadata */ struct intel_super { union { @@ -213,8 +246,8 @@ struct intel_super { int updates_pending; /* count of pending updates for mdmon */ int creating_imsm; /* flag to indicate container creation */ int current_vol; /* index of raid device undergoing creation */ - #define IMSM_MAX_RAID_DEVS 2 - struct imsm_dev *dev_tbl[IMSM_MAX_RAID_DEVS]; + __u32 create_offset; /* common start for 'current_vol' */ + struct intel_dev *devlist; struct dl { struct dl *next; int index; @@ -223,10 +256,15 @@ struct intel_super { char *devname; struct imsm_disk disk; int fd; + int extent_cnt; + struct extent *e; /* for determining freespace @ create */ + int raiddisk; /* slot to fill in autolayout */ } *disks; struct dl *add; /* list of disks to add while mdmon active */ struct dl *missing; /* disks removed while we weren't looking */ struct bbm_log *bbm_log; + const char *hba; /* device path of the raid controller for this metadata */ + const struct imsm_orom *orom; /* platform firmware support */ }; struct extent { @@ -248,6 +286,10 @@ struct imsm_update_activate_spare { struct imsm_update_activate_spare *next; }; +struct disk_info { + __u8 serial[MAX_RAID_SERIAL_LEN]; +}; + struct imsm_update_create_array { enum imsm_update_type type; int dev_idx; @@ -361,6 +403,20 @@ static size_t sizeof_imsm_dev(struct imsm_dev *dev, int migr_state) return size; } +#ifndef MDASSEMBLE +/* retrieve disk serial number list from a metadata update */ +static struct disk_info *get_disk_info(struct imsm_update_create_array *update) +{ + void *u = update; + struct disk_info *inf; + + inf = u + sizeof(*update) - sizeof(struct imsm_dev) + + sizeof_imsm_dev(&update->dev, 0); + + return inf; +} +#endif + static struct imsm_dev *__get_imsm_dev(struct imsm_super *mpb, __u8 index) { int offset; @@ -384,9 +440,14 @@ static struct imsm_dev *__get_imsm_dev(struct imsm_super *mpb, __u8 index) static struct imsm_dev *get_imsm_dev(struct intel_super *super, __u8 index) { + struct intel_dev *dv; + if (index >= super->anchor->num_raid_devs) return NULL; - return super->dev_tbl[index]; + for (dv = super->devlist; dv; dv = dv->next) + if (dv->index == index) + return dv->dev; + return NULL; } static __u32 get_imsm_ord_tbl_ent(struct imsm_dev *dev, int slot) @@ -415,6 +476,20 @@ static void set_imsm_ord_tbl_ent(struct imsm_map *map, int slot, __u32 ord) map->disk_ord_tbl[slot] = __cpu_to_le32(ord); } +static int get_imsm_disk_slot(struct imsm_map *map, int idx) +{ + int slot; + __u32 ord; + + for (slot = 0; slot < map->num_members; slot++) { + ord = __le32_to_cpu(map->disk_ord_tbl[slot]); + if (ord_to_idx(ord) == idx) + return slot; + } + + return -1; +} + static int get_imsm_raid_level(struct imsm_map *map) { if (map->raid_level == 1) { @@ -438,25 +513,30 @@ static int cmp_extent(const void *av, const void *bv) return 0; } -static struct extent *get_extents(struct intel_super *super, struct dl *dl) +static int count_memberships(struct dl *dl, struct intel_super *super) { - /* find a list of used extents on the given physical device */ - struct extent *rv, *e; - int i, j; int memberships = 0; - __u32 reservation = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS; + int i; for (i = 0; i < super->anchor->num_raid_devs; i++) { struct imsm_dev *dev = get_imsm_dev(super, i); struct imsm_map *map = get_imsm_map(dev, 0); - for (j = 0; j < map->num_members; j++) { - __u32 index = get_imsm_disk_idx(dev, j); - - if (index == dl->index) - memberships++; - } + if (get_imsm_disk_slot(map, dl->index) >= 0) + memberships++; } + + return memberships; +} + +static struct extent *get_extents(struct intel_super *super, struct dl *dl) +{ + /* find a list of used extents on the given physical device */ + struct extent *rv, *e; + int i; + int memberships = count_memberships(dl, super); + __u32 reservation = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS; + rv = malloc(sizeof(struct extent) * (memberships + 1)); if (!rv) return NULL; @@ -466,14 +546,10 @@ static struct extent *get_extents(struct intel_super *super, struct dl *dl) struct imsm_dev *dev = get_imsm_dev(super, i); struct imsm_map *map = get_imsm_map(dev, 0); - for (j = 0; j < map->num_members; j++) { - __u32 index = get_imsm_disk_idx(dev, j); - - if (index == dl->index) { - e->start = __le32_to_cpu(map->pba_of_lba0); - e->size = __le32_to_cpu(map->blocks_per_member); - e++; - } + if (get_imsm_disk_slot(map, dl->index) >= 0) { + e->start = __le32_to_cpu(map->pba_of_lba0); + e->size = __le32_to_cpu(map->blocks_per_member); + e++; } } qsort(rv, memberships, sizeof(*rv), cmp_extent); @@ -489,6 +565,13 @@ static struct extent *get_extents(struct intel_super *super, struct dl *dl) remainder = __le32_to_cpu(dl->disk.total_blocks) - (last->start + last->size); + /* round down to 1k block to satisfy precision of the kernel + * 'size' interface + */ + remainder &= ~1UL; + /* make sure remainder is still sane */ + if (remainder < ROUND_UP(super->len, 512) >> 9) + remainder = ROUND_UP(super->len, 512) >> 9; if (reservation > remainder) reservation = remainder; } @@ -541,10 +624,8 @@ static void print_imsm_dev(struct imsm_dev *dev, char *uuid, int disk_idx) printf(" UUID : %s\n", uuid); printf(" RAID Level : %d\n", get_imsm_raid_level(map)); printf(" Members : %d\n", map->num_members); - for (slot = 0; slot < map->num_members; slot++) - if (disk_idx== get_imsm_disk_idx(dev, slot)) - break; - if (slot < map->num_members) { + slot = get_imsm_disk_slot(map, disk_idx); + if (slot >= 0) { ord = get_imsm_ord_tbl_ent(dev, slot); printf(" This Slot : %d%s\n", slot, ord & IMSM_ORD_REBUILD ? " (out-of-sync)" : ""); @@ -565,10 +646,23 @@ static void print_imsm_dev(struct imsm_dev *dev, char *uuid, int disk_idx) printf(" Chunk Size : %u KiB\n", __le16_to_cpu(map->blocks_per_strip) / 2); printf(" Reserved : %d\n", __le32_to_cpu(dev->reserved_blocks)); - printf(" Migrate State : %s", dev->vol.migr_state ? "migrating" : "idle"); - if (dev->vol.migr_state) - printf(": %s", dev->vol.migr_type ? "rebuilding" : "initializing"); - printf("\n"); + printf(" Migrate State : %s", dev->vol.migr_state ? "migrating" : "idle\n"); + if (dev->vol.migr_state) { + if (migr_type(dev) == MIGR_INIT) + printf(": initializing\n"); + else if (migr_type(dev) == MIGR_REBUILD) + printf(": rebuilding\n"); + else if (migr_type(dev) == MIGR_VERIFY) + printf(": check\n"); + else if (migr_type(dev) == MIGR_GEN_MIGR) + printf(": general migration\n"); + else if (migr_type(dev) == MIGR_STATE_CHANGE) + printf(": state change\n"); + else if (migr_type(dev) == MIGR_REPAIR) + printf(": repair\n"); + else + printf(": \n", migr_type(dev)); + } printf(" Map State : %s", map_state_str[map->map_state]); if (dev->vol.migr_state) { struct imsm_map *map = get_imsm_map(dev, 1); @@ -623,7 +717,7 @@ static void examine_super_imsm(struct supertype *st, char *homehost) printf(" Family : %08x\n", __le32_to_cpu(mpb->family_num)); printf(" Generation : %08x\n", __le32_to_cpu(mpb->generation_num)); getinfo_super_imsm(st, &info); - fname_from_uuid(st, &info, nbuf,'-'); + fname_from_uuid(st, &info, nbuf, ':'); printf(" UUID : %s\n", nbuf + 5); sum = __le32_to_cpu(mpb->check_sum); printf(" Checksum : %08x %s\n", sum, @@ -641,7 +735,8 @@ static void examine_super_imsm(struct supertype *st, char *homehost) printf(" Signature : %x\n", __le32_to_cpu(log->signature)); printf(" Entry Count : %d\n", __le32_to_cpu(log->entry_count)); printf(" Spare Blocks : %d\n", __le32_to_cpu(log->reserved_spare_block_count)); - printf(" First Spare : %llx\n", __le64_to_cpu(log->first_spare_lba)); + printf(" First Spare : %llx\n", + (unsigned long long) __le64_to_cpu(log->first_spare_lba)); } for (i = 0; i < mpb->num_raid_devs; i++) { struct mdinfo info; @@ -649,7 +744,7 @@ static void examine_super_imsm(struct supertype *st, char *homehost) super->current_vol = i; getinfo_super_imsm(st, &info); - fname_from_uuid(st, &info, nbuf, '-'); + fname_from_uuid(st, &info, nbuf, ':'); print_imsm_dev(dev, nbuf + 5, super->disks->index); } for (i = 0; i < mpb->num_disks; i++) { @@ -659,7 +754,7 @@ static void examine_super_imsm(struct supertype *st, char *homehost) } } -static void brief_examine_super_imsm(struct supertype *st) +static void brief_examine_super_imsm(struct supertype *st, int verbose) { /* We just write a generic IMSM ARRAY entry */ struct mdinfo info; @@ -668,22 +763,38 @@ static void brief_examine_super_imsm(struct supertype *st) struct intel_super *super = st->sb; int i; - if (!super->anchor->num_raid_devs) + if (!super->anchor->num_raid_devs) { + printf("ARRAY metadata=imsm\n"); return; + } getinfo_super_imsm(st, &info); - fname_from_uuid(st, &info, nbuf,'-'); - printf("ARRAY metadata=imsm auto=md UUID=%s\n", nbuf + 5); + fname_from_uuid(st, &info, nbuf, ':'); for (i = 0; i < super->anchor->num_raid_devs; i++) { struct imsm_dev *dev = get_imsm_dev(super, i); super->current_vol = i; getinfo_super_imsm(st, &info); - fname_from_uuid(st, &info, nbuf1,'-'); - printf("ARRAY /dev/md/%.16s container=%s\n" - " member=%d auto=mdp UUID=%s\n", + fname_from_uuid(st, &info, nbuf1, ':'); + printf("ARRAY /dev/md/%.16s container=%s member=%d UUID=%s\n", dev->volume, nbuf + 5, i, nbuf1 + 5); } + printf("ARRAY metadata=imsm UUID=%s\n", nbuf + 5); +} + +static void export_examine_super_imsm(struct supertype *st) +{ + struct intel_super *super = st->sb; + struct imsm_super *mpb = super->anchor; + struct mdinfo info; + char nbuf[64]; + + getinfo_super_imsm(st, &info); + fname_from_uuid(st, &info, nbuf, ':'); + printf("MD_METADATA=imsm\n"); + printf("MD_LEVEL=container\n"); + printf("MD_UUID=%s\n", nbuf+5); + printf("MD_DEVICES=%u\n", mpb->num_disks); } static void detail_super_imsm(struct supertype *st, char *homehost) @@ -692,7 +803,7 @@ static void detail_super_imsm(struct supertype *st, char *homehost) char nbuf[64]; getinfo_super_imsm(st, &info); - fname_from_uuid(st, &info, nbuf,'-'); + fname_from_uuid(st, &info, nbuf, ':'); printf("\n UUID : %s\n", nbuf + 5); } @@ -701,9 +812,278 @@ static void brief_detail_super_imsm(struct supertype *st) struct mdinfo info; char nbuf[64]; getinfo_super_imsm(st, &info); - fname_from_uuid(st, &info, nbuf,'-'); + fname_from_uuid(st, &info, nbuf, ':'); printf(" UUID=%s", nbuf + 5); } + +static int imsm_read_serial(int fd, char *devname, __u8 *serial); +static void fd2devname(int fd, char *name); + +static int imsm_enumerate_ports(const char *hba_path, int port_count, int host_base, int verbose) +{ + /* dump an unsorted list of devices attached to ahci, as well as + * non-connected ports + */ + int hba_len = strlen(hba_path) + 1; + struct dirent *ent; + DIR *dir; + char *path = NULL; + int err = 0; + unsigned long port_mask = (1 << port_count) - 1; + + if (port_count > sizeof(port_mask) * 8) { + if (verbose) + fprintf(stderr, Name ": port_count %d out of range\n", port_count); + return 2; + } + + /* scroll through /sys/dev/block looking for devices attached to + * this hba + */ + dir = opendir("/sys/dev/block"); + for (ent = dir ? readdir(dir) : NULL; ent; ent = readdir(dir)) { + int fd; + char model[64]; + char vendor[64]; + char buf[1024]; + int major, minor; + char *device; + char *c; + int port; + int type; + + if (sscanf(ent->d_name, "%d:%d", &major, &minor) != 2) + continue; + path = devt_to_devpath(makedev(major, minor)); + if (!path) + continue; + if (!path_attached_to_hba(path, hba_path)) { + free(path); + path = NULL; + continue; + } + + /* retrieve the scsi device type */ + if (asprintf(&device, "/sys/dev/block/%d:%d/device/xxxxxxx", major, minor) < 0) { + if (verbose) + fprintf(stderr, Name ": failed to allocate 'device'\n"); + err = 2; + break; + } + sprintf(device, "/sys/dev/block/%d:%d/device/type", major, minor); + if (load_sys(device, buf) != 0) { + if (verbose) + fprintf(stderr, Name ": failed to read device type for %s\n", + path); + err = 2; + free(device); + break; + } + type = strtoul(buf, NULL, 10); + + /* if it's not a disk print the vendor and model */ + if (!(type == 0 || type == 7 || type == 14)) { + vendor[0] = '\0'; + model[0] = '\0'; + sprintf(device, "/sys/dev/block/%d:%d/device/vendor", major, minor); + if (load_sys(device, buf) == 0) { + strncpy(vendor, buf, sizeof(vendor)); + vendor[sizeof(vendor) - 1] = '\0'; + c = (char *) &vendor[sizeof(vendor) - 1]; + while (isspace(*c) || *c == '\0') + *c-- = '\0'; + + } + sprintf(device, "/sys/dev/block/%d:%d/device/model", major, minor); + if (load_sys(device, buf) == 0) { + strncpy(model, buf, sizeof(model)); + model[sizeof(model) - 1] = '\0'; + c = (char *) &model[sizeof(model) - 1]; + while (isspace(*c) || *c == '\0') + *c-- = '\0'; + } + + if (vendor[0] && model[0]) + sprintf(buf, "%.64s %.64s", vendor, model); + else + switch (type) { /* numbers from hald/linux/device.c */ + case 1: sprintf(buf, "tape"); break; + case 2: sprintf(buf, "printer"); break; + case 3: sprintf(buf, "processor"); break; + case 4: + case 5: sprintf(buf, "cdrom"); break; + case 6: sprintf(buf, "scanner"); break; + case 8: sprintf(buf, "media_changer"); break; + case 9: sprintf(buf, "comm"); break; + case 12: sprintf(buf, "raid"); break; + default: sprintf(buf, "unknown"); + } + } else + buf[0] = '\0'; + free(device); + + /* chop device path to 'host%d' and calculate the port number */ + c = strchr(&path[hba_len], '/'); + *c = '\0'; + if (sscanf(&path[hba_len], "host%d", &port) == 1) + port -= host_base; + else { + if (verbose) { + *c = '/'; /* repair the full string */ + fprintf(stderr, Name ": failed to determine port number for %s\n", + path); + } + err = 2; + break; + } + + /* mark this port as used */ + port_mask &= ~(1 << port); + + /* print out the device information */ + if (buf[0]) { + printf(" Port%d : - non-disk device (%s) -\n", port, buf); + continue; + } + + fd = dev_open(ent->d_name, O_RDONLY); + if (fd < 0) + printf(" Port%d : - disk info unavailable -\n", port); + else { + fd2devname(fd, buf); + printf(" Port%d : %s", port, buf); + if (imsm_read_serial(fd, NULL, (__u8 *) buf) == 0) + printf(" (%s)\n", buf); + else + printf("()\n"); + } + close(fd); + free(path); + path = NULL; + } + if (path) + free(path); + if (dir) + closedir(dir); + if (err == 0) { + int i; + + for (i = 0; i < port_count; i++) + if (port_mask & (1 << i)) + printf(" Port%d : - no device attached -\n", i); + } + + return err; +} + +static int detail_platform_imsm(int verbose, int enumerate_only) +{ + /* There are two components to imsm platform support, the ahci SATA + * controller and the option-rom. To find the SATA controller we + * simply look in /sys/bus/pci/drivers/ahci to see if an ahci + * controller with the Intel vendor id is present. This approach + * allows mdadm to leverage the kernel's ahci detection logic, with the + * caveat that if ahci.ko is not loaded mdadm will not be able to + * detect platform raid capabilities. The option-rom resides in a + * platform "Adapter ROM". We scan for its signature to retrieve the + * platform capabilities. If raid support is disabled in the BIOS the + * option-rom capability structure will not be available. + */ + const struct imsm_orom *orom; + struct sys_dev *list, *hba; + DIR *dir; + struct dirent *ent; + const char *hba_path; + int host_base = 0; + int port_count = 0; + + if (enumerate_only) { + if (check_env("IMSM_NO_PLATFORM") || find_imsm_orom()) + return 0; + return 2; + } + + list = find_driver_devices("pci", "ahci"); + for (hba = list; hba; hba = hba->next) + if (devpath_to_vendor(hba->path) == 0x8086) + break; + + if (!hba) { + if (verbose) + fprintf(stderr, Name ": unable to find active ahci controller\n"); + free_sys_dev(&list); + return 2; + } else if (verbose) + fprintf(stderr, Name ": found Intel SATA AHCI Controller\n"); + hba_path = hba->path; + hba->path = NULL; + free_sys_dev(&list); + + orom = find_imsm_orom(); + if (!orom) { + if (verbose) + fprintf(stderr, Name ": imsm option-rom not found\n"); + return 2; + } + + printf(" Platform : Intel(R) Matrix Storage Manager\n"); + printf(" Version : %d.%d.%d.%d\n", orom->major_ver, orom->minor_ver, + orom->hotfix_ver, orom->build); + printf(" RAID Levels :%s%s%s%s%s\n", + imsm_orom_has_raid0(orom) ? " raid0" : "", + imsm_orom_has_raid1(orom) ? " raid1" : "", + imsm_orom_has_raid1e(orom) ? " raid1e" : "", + imsm_orom_has_raid10(orom) ? " raid10" : "", + imsm_orom_has_raid5(orom) ? " raid5" : ""); + printf(" Chunk Sizes :%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", + imsm_orom_has_chunk(orom, 2) ? " 2k" : "", + imsm_orom_has_chunk(orom, 4) ? " 4k" : "", + imsm_orom_has_chunk(orom, 8) ? " 8k" : "", + imsm_orom_has_chunk(orom, 16) ? " 16k" : "", + imsm_orom_has_chunk(orom, 32) ? " 32k" : "", + imsm_orom_has_chunk(orom, 64) ? " 64k" : "", + imsm_orom_has_chunk(orom, 128) ? " 128k" : "", + imsm_orom_has_chunk(orom, 256) ? " 256k" : "", + imsm_orom_has_chunk(orom, 512) ? " 512k" : "", + imsm_orom_has_chunk(orom, 1024*1) ? " 1M" : "", + imsm_orom_has_chunk(orom, 1024*2) ? " 2M" : "", + imsm_orom_has_chunk(orom, 1024*4) ? " 4M" : "", + imsm_orom_has_chunk(orom, 1024*8) ? " 8M" : "", + imsm_orom_has_chunk(orom, 1024*16) ? " 16M" : "", + imsm_orom_has_chunk(orom, 1024*32) ? " 32M" : "", + imsm_orom_has_chunk(orom, 1024*64) ? " 64M" : ""); + printf(" Max Disks : %d\n", orom->tds); + printf(" Max Volumes : %d\n", orom->vpa); + printf(" I/O Controller : %s\n", hba_path); + + /* find the smallest scsi host number to determine a port number base */ + dir = opendir(hba_path); + for (ent = dir ? readdir(dir) : NULL; ent; ent = readdir(dir)) { + int host; + + if (sscanf(ent->d_name, "host%d", &host) != 1) + continue; + if (port_count == 0) + host_base = host; + else if (host < host_base) + host_base = host; + + if (host + 1 > port_count + host_base) + port_count = host + 1 - host_base; + + } + if (dir) + closedir(dir); + + if (!port_count || imsm_enumerate_ports(hba_path, port_count, + host_base, verbose) != 0) { + if (verbose) + fprintf(stderr, Name ": failed to enumerate ports\n"); + return 2; + } + + return 0; +} #endif static int match_home_imsm(struct supertype *st, char *homehost) @@ -751,7 +1131,7 @@ static void uuid_from_super_imsm(struct supertype *st, int uuid[4]) struct imsm_dev *dev = NULL; sha1_init_ctx(&ctx); - sha1_process_bytes(super->anchor->sig, MAX_SIGNATURE_LENGTH, &ctx); + sha1_process_bytes(super->anchor->sig, MPB_SIG_LEN, &ctx); sha1_process_bytes(&super->anchor->family_num, sizeof(__u32), &ctx); if (super->current_vol >= 0) dev = get_imsm_dev(super, super->current_vol); @@ -804,7 +1184,7 @@ static int imsm_level_to_layout(int level) case 10: return 0x102; } - return -1; + return UnSet; } static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info) @@ -812,7 +1192,11 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info) struct intel_super *super = st->sb; struct imsm_dev *dev = get_imsm_dev(super, super->current_vol); struct imsm_map *map = get_imsm_map(dev, 0); + struct dl *dl; + for (dl = super->disks; dl; dl = dl->next) + if (dl->raiddisk == info->disk.raid_disk) + break; info->container_member = super->current_vol; info->array.raid_disks = map->num_members; info->array.level = get_imsm_raid_level(map); @@ -822,9 +1206,16 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info) info->array.utime = 0; info->array.chunk_size = __le16_to_cpu(map->blocks_per_strip) << 9; info->array.state = !dev->vol.dirty; + info->custom_array_size = __le32_to_cpu(dev->size_high); + info->custom_array_size <<= 32; + info->custom_array_size |= __le32_to_cpu(dev->size_low); info->disk.major = 0; info->disk.minor = 0; + if (dl) { + info->disk.major = dl->major; + info->disk.minor = dl->minor; + } info->data_offset = __le32_to_cpu(map->pba_of_lba0); info->component_size = __le32_to_cpu(map->blocks_per_member); @@ -833,7 +1224,8 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info) if (map->map_state == IMSM_T_STATE_UNINITIALIZED || dev->vol.dirty) info->resync_start = 0; else if (dev->vol.migr_state) - info->resync_start = __le32_to_cpu(dev->vol.curr_migr_unit); + /* FIXME add curr_migr_unit to resync_start conversion */ + info->resync_start = 0; else info->resync_start = ~0ULL; @@ -849,6 +1241,32 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info) uuid_from_super_imsm(st, info->uuid); } +/* check the config file to see if we can return a real uuid for this spare */ +static void fixup_container_spare_uuid(struct mdinfo *inf) +{ + struct mddev_ident_s *array_list; + + if (inf->array.level != LEVEL_CONTAINER || + memcmp(inf->uuid, uuid_match_any, sizeof(int[4])) != 0) + return; + + array_list = conf_get_ident(NULL); + + for (; array_list; array_list = array_list->next) { + if (array_list->uuid_set) { + struct supertype *_sst; /* spare supertype */ + struct supertype *_cst; /* container supertype */ + + _cst = array_list->st; + _sst = _cst->ss->match_metadata_desc(inf->text_version); + if (_sst) { + memcpy(inf->uuid, array_list->uuid, sizeof(int[4])); + free(_sst); + break; + } + } + } +} static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info) { @@ -892,6 +1310,10 @@ static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info) info->component_size = reserved; s = disk->status; info->disk.state = s & CONFIGURED_DISK ? (1 << MD_DISK_ACTIVE) : 0; + /* we don't change info->disk.raid_disk here because + * this state will be finalized in mdmon after we have + * found the 'most fresh' version of the metadata + */ info->disk.state |= s & FAILED_DISK ? (1 << MD_DISK_FAULTY) : 0; info->disk.state |= s & SPARE_DISK ? 0 : (1 << MD_DISK_SYNC); } @@ -901,8 +1323,10 @@ static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info) */ if (info->disk.state & (1 << MD_DISK_SYNC) || super->anchor->num_raid_devs) uuid_from_super_imsm(st, info->uuid); - else + else { memcpy(info->uuid, uuid_match_any, sizeof(int[4])); + fixup_container_spare_uuid(info); + } } static int update_super_imsm(struct supertype *st, struct mdinfo *info, @@ -973,6 +1397,23 @@ static __u64 avail_size_imsm(struct supertype *st, __u64 devsize) return devsize - (MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS); } +static void free_devlist(struct intel_super *super) +{ + struct intel_dev *dv; + + while (super->devlist) { + dv = super->devlist->next; + free(super->devlist->dev); + free(super->devlist); + super->devlist = dv; + } +} + +static void imsm_copy_dev(struct imsm_dev *dest, struct imsm_dev *src) +{ + memcpy(dest, src, sizeof_imsm_dev(src, 0)); +} + static int compare_super_imsm(struct supertype *st, struct supertype *tst) { /* @@ -1009,22 +1450,34 @@ static int compare_super_imsm(struct supertype *st, struct supertype *tst) if (first->anchor->num_raid_devs == 0 && sec->anchor->num_raid_devs > 0) { int i; + struct intel_dev *dv; + struct imsm_dev *dev; /* we need to copy raid device info from sec if an allocation * fails here we don't associate the spare */ for (i = 0; i < sec->anchor->num_raid_devs; i++) { - first->dev_tbl[i] = malloc(sizeof(struct imsm_dev)); - if (!first->dev_tbl) { - while (--i >= 0) { - free(first->dev_tbl[i]); - first->dev_tbl[i] = NULL; - } - fprintf(stderr, "imsm: failed to associate spare\n"); - return 3; + dv = malloc(sizeof(*dv)); + if (!dv) + break; + dev = malloc(sizeof_imsm_dev(get_imsm_dev(sec, i), 1)); + if (!dev) { + free(dv); + break; } - *first->dev_tbl[i] = *sec->dev_tbl[i]; + dv->dev = dev; + dv->index = i; + dv->next = first->devlist; + first->devlist = dv; } + if (i <= sec->anchor->num_raid_devs) { + /* allocation failure */ + free_devlist(first); + fprintf(stderr, "imsm: failed to associate spare\n"); + return 3; + } + for (i = 0; i < sec->anchor->num_raid_devs; i++) + imsm_copy_dev(get_imsm_dev(first, i), get_imsm_dev(sec, i)); first->anchor->num_raid_devs = sec->anchor->num_raid_devs; first->anchor->family_num = sec->anchor->family_num; @@ -1067,7 +1520,10 @@ static int imsm_read_serial(int fd, char *devname, int rv; int rsp_len; int len; - char *c, *rsp_buf; + char *dest; + char *src; + char *rsp_buf; + int i; memset(scsi_serial, 0, sizeof(scsi_serial)); @@ -1087,27 +1543,42 @@ static int imsm_read_serial(int fd, char *devname, return rv; } - /* trim leading whitespace */ rsp_len = scsi_serial[3]; + if (!rsp_len) { + if (devname) + fprintf(stderr, + Name ": Failed to retrieve serial for %s\n", + devname); + return 2; + } rsp_buf = (char *) &scsi_serial[4]; - c = rsp_buf; - while (isspace(*c)) - c++; - /* truncate len to the end of rsp_buf if necessary */ - if (c + MAX_RAID_SERIAL_LEN > rsp_buf + rsp_len) - len = rsp_len - (c - rsp_buf); - else + /* trim all whitespace and non-printable characters and convert + * ':' to ';' + */ + for (i = 0, dest = rsp_buf; i < rsp_len; i++) { + src = &rsp_buf[i]; + if (*src > 0x20) { + /* ':' is reserved for use in placeholder serial + * numbers for missing disks + */ + if (*src == ':') + *dest++ = ';'; + else + *dest++ = *src; + } + } + len = dest - rsp_buf; + dest = rsp_buf; + + /* truncate leading characters */ + if (len > MAX_RAID_SERIAL_LEN) { + dest += len - MAX_RAID_SERIAL_LEN; len = MAX_RAID_SERIAL_LEN; + } - /* initialize the buffer and copy rsp_buf characters */ memset(serial, 0, MAX_RAID_SERIAL_LEN); - memcpy(serial, c, len); - - /* trim trailing whitespace starting with the last character copied */ - c = (char *) &serial[len - 1]; - while (isspace(*c) || *c == '\0') - *c-- = '\0'; + memcpy(serial, dest, len); return 0; } @@ -1122,6 +1593,17 @@ static void serialcpy(__u8 *dest, __u8 *src) strncpy((char *) dest, (char *) src, MAX_RAID_SERIAL_LEN); } +static struct dl *serial_to_dl(__u8 *serial, struct intel_super *super) +{ + struct dl *dl; + + for (dl = super->disks; dl; dl = dl->next) + if (serialcmp(dl->serial, serial) == 0) + break; + + return dl; +} + static int load_imsm_disk(int fd, struct intel_super *super, char *devname, int keep_fd) { @@ -1141,10 +1623,7 @@ load_imsm_disk(int fd, struct intel_super *super, char *devname, int keep_fd) * super->disks while the current anchor believes it is a raid member, * check if we need to update dl->index */ - for (dl = super->disks; dl; dl = dl->next) - if (serialcmp(dl->serial, serial) == 0) - break; - + dl = serial_to_dl(serial, super); if (!dl) dl = malloc(sizeof(*dl)); else @@ -1167,6 +1646,7 @@ load_imsm_disk(int fd, struct intel_super *super, char *devname, int keep_fd) dl->devname = devname ? strdup(devname) : NULL; serialcpy(dl->serial, serial); dl->index = -2; + dl->e = NULL; } else if (keep_fd) { close(dl->fd); dl->fd = fd; @@ -1207,11 +1687,6 @@ load_imsm_disk(int fd, struct intel_super *super, char *devname, int keep_fd) return 0; } -static void imsm_copy_dev(struct imsm_dev *dest, struct imsm_dev *src) -{ - memcpy(dest, src, sizeof_imsm_dev(src, 0)); -} - #ifndef MDASSEMBLE /* When migrating map0 contains the 'destination' state while map1 * contains the current state. When not migrating map0 contains the @@ -1222,28 +1697,50 @@ static void imsm_copy_dev(struct imsm_dev *dest, struct imsm_dev *src) * 1/ Idle (migr_state=0 map0state=normal||unitialized||degraded||failed) * 2/ Initialize (migr_state=1 migr_type=MIGR_INIT map0state=normal * map1state=unitialized) - * 3/ Verify (Resync) (migr_state=1 migr_type=MIGR_REBUILD map0state=normal + * 3/ Repair (Resync) (migr_state=1 migr_type=MIGR_REPAIR map0state=normal * map1state=normal) * 4/ Rebuild (migr_state=1 migr_type=MIGR_REBUILD map0state=normal * map1state=degraded) */ -static void migrate(struct imsm_dev *dev, __u8 to_state, int rebuild_resync) +static void migrate(struct imsm_dev *dev, __u8 to_state, int migr_type) { struct imsm_map *dest; struct imsm_map *src = get_imsm_map(dev, 0); dev->vol.migr_state = 1; - dev->vol.migr_type = rebuild_resync; + set_migr_type(dev, migr_type); dev->vol.curr_migr_unit = 0; dest = get_imsm_map(dev, 1); + /* duplicate and then set the target end state in map[0] */ memcpy(dest, src, sizeof_imsm_map(src)); + if (migr_type == MIGR_REBUILD) { + __u32 ord; + int i; + + for (i = 0; i < src->num_members; i++) { + ord = __le32_to_cpu(src->disk_ord_tbl[i]); + set_imsm_ord_tbl_ent(src, i, ord_to_idx(ord)); + } + } + src->map_state = to_state; } static void end_migration(struct imsm_dev *dev, __u8 map_state) { struct imsm_map *map = get_imsm_map(dev, 0); + struct imsm_map *prev = get_imsm_map(dev, dev->vol.migr_state); + int i; + + /* merge any IMSM_ORD_REBUILD bits that were not successfully + * completed in the last migration. + * + * FIXME add support for online capacity expansion and + * raid-level-migration + */ + for (i = 0; i < prev->num_members; i++) + map->disk_ord_tbl[i] |= prev->disk_ord_tbl[i]; dev->vol.migr_state = 0; dev->vol.curr_migr_unit = 0; @@ -1261,17 +1758,26 @@ static int parse_raid_devices(struct intel_super *super) for (i = 0; i < super->anchor->num_raid_devs; i++) { struct imsm_dev *dev_iter = __get_imsm_dev(super->anchor, i); + struct intel_dev *dv; len = sizeof_imsm_dev(dev_iter, 0); len_migr = sizeof_imsm_dev(dev_iter, 1); if (len_migr > len) space_needed += len_migr - len; + dv = malloc(sizeof(*dv)); + if (!dv) + return 1; dev_new = malloc(len_migr); - if (!dev_new) + if (!dev_new) { + free(dv); return 1; + } imsm_copy_dev(dev_new, dev_iter); - super->dev_tbl[i] = dev_new; + dv->dev = dev_new; + dv->index = i; + dv->next = super->devlist; + super->devlist = dv; } /* ensure that super->buf is large enough when all raid devices @@ -1284,7 +1790,8 @@ static int parse_raid_devices(struct intel_super *super) if (posix_memalign(&buf, 512, len) != 0) return 1; - memcpy(buf, super->buf, len); + memcpy(buf, super->buf, super->len); + memset(buf + super->len, 0, len - super->len); free(super->buf); super->buf = buf; super->len = len; @@ -1369,6 +1876,17 @@ static int load_imsm_mpb(int fd, struct intel_super *super, char *devname) sectors = mpb_sectors(anchor) - 1; free(anchor); if (!sectors) { + check_sum = __gen_imsm_checksum(super->anchor); + if (check_sum != __le32_to_cpu(super->anchor->check_sum)) { + if (devname) + fprintf(stderr, + Name ": IMSM checksum %x != %x on %s\n", + check_sum, + __le32_to_cpu(super->anchor->check_sum), + devname); + return 2; + } + rc = load_imsm_disk(fd, super, devname, 0); if (rc == 0) rc = parse_raid_devices(super); @@ -1399,7 +1917,7 @@ static int load_imsm_mpb(int fd, struct intel_super *super, char *devname) Name ": IMSM checksum %x != %x on %s\n", check_sum, __le32_to_cpu(super->anchor->check_sum), devname); - return 2; + return 3; } /* FIXME the BBM log is disk specific so we cannot use this global @@ -1421,6 +1939,8 @@ static void __free_imsm_disk(struct dl *d) close(d->fd); if (d->devname) free(d->devname); + if (d->e) + free(d->e); free(d); } @@ -1444,19 +1964,17 @@ static void free_imsm_disks(struct intel_super *super) /* free all the pieces hanging off of a super pointer */ static void __free_imsm(struct intel_super *super, int free_disks) { - int i; - if (super->buf) { free(super->buf); super->buf = NULL; } if (free_disks) free_imsm_disks(super); - for (i = 0; i < IMSM_MAX_RAID_DEVS; i++) - if (super->dev_tbl[i]) { - free(super->dev_tbl[i]); - super->dev_tbl[i] = NULL; - } + free_devlist(super); + if (super->hba) { + free((void *) super->hba); + super->hba = NULL; + } } static void free_imsm(struct intel_super *super) @@ -1484,6 +2002,23 @@ static struct intel_super *alloc_super(int creating_imsm) memset(super, 0, sizeof(*super)); super->creating_imsm = creating_imsm; super->current_vol = -1; + super->create_offset = ~((__u32 ) 0); + if (!check_env("IMSM_NO_PLATFORM")) + super->orom = find_imsm_orom(); + if (super->orom && !check_env("IMSM_TEST_OROM")) { + struct sys_dev *list, *ent; + + /* find the first intel ahci controller */ + list = find_driver_devices("pci", "ahci"); + for (ent = list; ent; ent = ent->next) + if (devpath_to_vendor(ent->path) == 0x8086) + break; + if (ent) { + super->hba = ent->path; + ent->path = NULL; + } + free_sys_dev(&list); + } } return super; @@ -1503,16 +2038,9 @@ static int find_missing(struct intel_super *super) for (i = 0; i < mpb->num_disks; i++) { disk = __get_imsm_disk(mpb, i); - for (dl = super->disks; dl; dl = dl->next) - if (serialcmp(dl->disk.serial, disk->serial) == 0) - break; + dl = serial_to_dl(disk->serial, super); if (dl) continue; - /* ok we have a 'disk' without a live entry in - * super->disks - */ - if (disk->status & FAILED_DISK || !(disk->status & USABLE_DISK)) - continue; /* never mind, already marked */ dl = malloc(sizeof(*dl)); if (!dl) @@ -1524,6 +2052,7 @@ static int find_missing(struct intel_super *super) dl->index = i; serialcpy(dl->serial, disk->serial); dl->disk = *disk; + dl->e = NULL; dl->next = super->missing; super->missing = dl; } @@ -1542,9 +2071,16 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp, char nm[20]; int dfd; int rv; + int devnum = fd2devnum(fd); + int retry; + enum sysfs_read_flags flags; + + flags = GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE; + if (mdmon_running(devnum)) + flags |= SKIP_GONE_DEVS; - /* check if this disk is a member of an active array */ - sra = sysfs_read(fd, 0, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE); + /* check if 'fd' an opened container */ + sra = sysfs_read(fd, 0, flags); if (!sra) return 1; @@ -1561,11 +2097,20 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp, for (sd = sra->devs; sd; sd = sd->next) { sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor); dfd = dev_open(nm, keep_fd ? O_RDWR : O_RDONLY); - if (!dfd) { + if (dfd < 0) { free_imsm(super); return 2; } rv = load_imsm_mpb(dfd, super, NULL); + + /* retry the load if we might have raced against mdmon */ + if (rv == 3 && mdmon_running(devnum)) + for (retry = 0; retry < 3; retry++) { + usleep(3000); + rv = load_imsm_mpb(dfd, super, NULL); + if (rv != 3) + break; + } if (!keep_fd) close(dfd); if (rv == 0) { @@ -1579,7 +2124,7 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp, } } else { free_imsm(super); - return 2; + return rv; } } @@ -1591,7 +2136,7 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp, /* load the most up to date anchor */ sprintf(nm, "%d:%d", best->disk.major, best->disk.minor); dfd = dev_open(nm, O_RDONLY); - if (!dfd) { + if (dfd < 0) { free_imsm(super); return 1; } @@ -1606,7 +2151,7 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp, for (sd = sra->devs ; sd ; sd = sd->next) { sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor); dfd = dev_open(nm, keep_fd? O_RDWR : O_RDONLY); - if (!dfd) { + if (dfd < 0) { free_imsm(super); return 2; } @@ -1624,12 +2169,14 @@ static int load_super_imsm_all(struct supertype *st, int fd, void **sbp, if (st->subarray[0]) { if (atoi(st->subarray) <= super->anchor->num_raid_devs) super->current_vol = atoi(st->subarray); - else + else { + free_imsm(super); return 1; + } } *sbp = super; - st->container_dev = fd2devnum(fd); + st->container_dev = devnum; if (st->ss == NULL) { st->ss = &super_imsm; st->minor_version = 0; @@ -1650,8 +2197,8 @@ static int load_super_imsm(struct supertype *st, int fd, char *devname) if (load_super_imsm_all(st, fd, &st->sb, devname, 1) == 0) return 0; #endif - if (st->subarray[0]) - return 1; /* FIXME */ + + free_super_imsm(st); super = alloc_super(0); if (!super) { @@ -1672,9 +2219,18 @@ static int load_super_imsm(struct supertype *st, int fd, char *devname) return rv; } - st->sb = super; - if (st->ss == NULL) { - st->ss = &super_imsm; + if (st->subarray[0]) { + if (atoi(st->subarray) <= super->anchor->num_raid_devs) + super->current_vol = atoi(st->subarray); + else { + free_imsm(super); + return 1; + } + } + + st->sb = super; + if (st->ss == NULL) { + st->ss = &super_imsm; st->minor_version = 0; st->max_devs = IMSM_MAX_DEVICES; } @@ -1690,20 +2246,69 @@ static __u16 info_to_blocks_per_strip(mdu_array_info_t *info) return info->chunk_size >> 9; } -static __u32 info_to_num_data_stripes(mdu_array_info_t *info) +static __u32 info_to_num_data_stripes(mdu_array_info_t *info, int num_domains) { __u32 num_stripes; num_stripes = (info->size * 2) / info_to_blocks_per_strip(info); - if (info->level == 1) - num_stripes /= 2; + num_stripes /= num_domains; return num_stripes; } static __u32 info_to_blocks_per_member(mdu_array_info_t *info) { - return (info->size * 2) & ~(info_to_blocks_per_strip(info) - 1); + if (info->level == 1) + return info->size * 2; + else + return (info->size * 2) & ~(info_to_blocks_per_strip(info) - 1); +} + +static void imsm_update_version_info(struct intel_super *super) +{ + /* update the version and attributes */ + struct imsm_super *mpb = super->anchor; + char *version; + struct imsm_dev *dev; + struct imsm_map *map; + int i; + + for (i = 0; i < mpb->num_raid_devs; i++) { + dev = get_imsm_dev(super, i); + map = get_imsm_map(dev, 0); + if (__le32_to_cpu(dev->size_high) > 0) + mpb->attributes |= MPB_ATTRIB_2TB; + + /* FIXME detect when an array spans a port multiplier */ + #if 0 + mpb->attributes |= MPB_ATTRIB_PM; + #endif + + if (mpb->num_raid_devs > 1 || + mpb->attributes != MPB_ATTRIB_CHECKSUM_VERIFY) { + version = MPB_VERSION_ATTRIBS; + switch (get_imsm_raid_level(map)) { + case 0: mpb->attributes |= MPB_ATTRIB_RAID0; break; + case 1: mpb->attributes |= MPB_ATTRIB_RAID1; break; + case 10: mpb->attributes |= MPB_ATTRIB_RAID10; break; + case 5: mpb->attributes |= MPB_ATTRIB_RAID5; break; + } + } else { + if (map->num_members >= 5) + version = MPB_VERSION_5OR6_DISK_ARRAY; + else if (dev->status == DEV_CLONE_N_GO) + version = MPB_VERSION_CNG; + else if (get_imsm_raid_level(map) == 5) + version = MPB_VERSION_RAID5; + else if (map->num_members >= 3) + version = MPB_VERSION_3OR4_DISK_ARRAY; + else if (get_imsm_raid_level(map) == 1) + version = MPB_VERSION_RAID1; + else + version = MPB_VERSION_RAID0; + } + strcpy(((char *) mpb->sig) + strlen(MPB_SIGNATURE), version); + } } static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, @@ -1715,18 +2320,19 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, */ struct intel_super *super = st->sb; struct imsm_super *mpb = super->anchor; + struct intel_dev *dv; struct imsm_dev *dev; struct imsm_vol *vol; struct imsm_map *map; int idx = mpb->num_raid_devs; int i; unsigned long long array_blocks; - __u32 offset = 0; size_t size_old, size_new; + __u32 num_data_stripes; - if (mpb->num_raid_devs >= 2) { + if (super->orom && mpb->num_raid_devs >= super->orom->vpa) { fprintf(stderr, Name": This imsm-container already has the " - "maximum of 2 volumes\n"); + "maximum of %d volumes\n", super->orom->vpa); return 0; } @@ -1755,49 +2361,74 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, */ if (super->current_vol == 0) mpb->num_disks = 0; + + for (i = 0; i < super->current_vol; i++) { + dev = get_imsm_dev(super, i); + if (strncmp((char *) dev->volume, name, + MAX_RAID_SERIAL_LEN) == 0) { + fprintf(stderr, Name": '%s' is already defined for this container\n", + name); + return 0; + } + } + sprintf(st->subarray, "%d", idx); + dv = malloc(sizeof(*dv)); + if (!dv) { + fprintf(stderr, Name ": failed to allocate device list entry\n"); + return 0; + } dev = malloc(sizeof(*dev) + sizeof(__u32) * (info->raid_disks - 1)); if (!dev) { + free(dv); fprintf(stderr, Name": could not allocate raid device\n"); return 0; } strncpy((char *) dev->volume, name, MAX_RAID_SERIAL_LEN); - array_blocks = calc_array_size(info->level, info->raid_disks, - info->layout, info->chunk_size, - info->size*2); + if (info->level == 1) + array_blocks = info_to_blocks_per_member(info); + else + array_blocks = calc_array_size(info->level, info->raid_disks, + info->layout, info->chunk_size, + info->size*2); + /* round array size down to closest MB */ + array_blocks = (array_blocks >> SECT_PER_MB_SHIFT) << SECT_PER_MB_SHIFT; + dev->size_low = __cpu_to_le32((__u32) array_blocks); dev->size_high = __cpu_to_le32((__u32) (array_blocks >> 32)); dev->status = __cpu_to_le32(0); dev->reserved_blocks = __cpu_to_le32(0); vol = &dev->vol; vol->migr_state = 0; - vol->migr_type = MIGR_INIT; + set_migr_type(dev, MIGR_INIT); vol->dirty = 0; vol->curr_migr_unit = 0; - for (i = 0; i < idx; i++) { - struct imsm_dev *prev = get_imsm_dev(super, i); - struct imsm_map *pmap = get_imsm_map(prev, 0); - - offset += __le32_to_cpu(pmap->blocks_per_member); - offset += IMSM_RESERVED_SECTORS; - } map = get_imsm_map(dev, 0); - map->pba_of_lba0 = __cpu_to_le32(offset); + map->pba_of_lba0 = __cpu_to_le32(super->create_offset); map->blocks_per_member = __cpu_to_le32(info_to_blocks_per_member(info)); map->blocks_per_strip = __cpu_to_le16(info_to_blocks_per_strip(info)); - map->num_data_stripes = __cpu_to_le32(info_to_num_data_stripes(info)); + map->failed_disk_num = ~0; map->map_state = info->level ? IMSM_T_STATE_UNINITIALIZED : IMSM_T_STATE_NORMAL; + map->ddf = 1; if (info->level == 1 && info->raid_disks > 2) { fprintf(stderr, Name": imsm does not support more than 2 disks" "in a raid1 volume\n"); return 0; } - if (info->level == 10) + + map->raid_level = info->level; + if (info->level == 10) { map->raid_level = 1; + map->num_domains = info->raid_disks / 2; + } else if (info->level == 1) + map->num_domains = info->raid_disks; else - map->raid_level = info->level; + map->num_domains = 1; + + num_data_stripes = info_to_num_data_stripes(info, map->num_domains); + map->num_data_stripes = __cpu_to_le32(num_data_stripes); map->num_members = info->raid_disks; for (i = 0; i < map->num_members; i++) { @@ -1805,7 +2436,13 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info, set_imsm_ord_tbl_ent(map, i, 0); } mpb->num_raid_devs++; - super->dev_tbl[super->current_vol] = dev; + + dv->dev = dev; + dv->index = super->current_vol; + dv->next = super->devlist; + super->devlist = dv; + + imsm_update_version_info(super); return 1; } @@ -1825,6 +2462,7 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info, struct intel_super *super; struct imsm_super *mpb; size_t mpb_size; + char *version; if (!info) { st->sb = NULL; @@ -1845,9 +2483,12 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info, mpb = super->buf; memset(mpb, 0, mpb_size); - memcpy(mpb->sig, MPB_SIGNATURE, strlen(MPB_SIGNATURE)); - memcpy(mpb->sig + strlen(MPB_SIGNATURE), MPB_VERSION_RAID5, - strlen(MPB_VERSION_RAID5)); + mpb->attributes = MPB_ATTRIB_CHECKSUM_VERIFY; + + version = (char *) mpb->sig; + strcpy(version, MPB_SIGNATURE); + version += strlen(MPB_SIGNATURE); + strcpy(version, MPB_VERSION_RAID0); mpb->mpb_size = mpb_size; st->sb = super; @@ -1855,7 +2496,7 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info, } #ifndef MDASSEMBLE -static void add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk, +static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk, int fd, char *devname) { struct intel_super *super = st->sb; @@ -1867,13 +2508,30 @@ static void add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk, dev = get_imsm_dev(super, super->current_vol); map = get_imsm_map(dev, 0); - for (dl = super->disks; dl ; dl = dl->next) - if (dl->major == dk->major && - dl->minor == dk->minor) - break; + if (! (dk->state & (1<state & (1<disks; dl; dl = dl->next) + if (dl->raiddisk == dk->raid_disk) + break; + } else { + for (dl = super->disks; dl ; dl = dl->next) + if (dl->major == dk->major && + dl->minor == dk->minor) + break; + } + + if (!dl) { + fprintf(stderr, Name ": %s is not a member of the same container\n", devname); + return 1; + } /* add a pristine spare to the metadata */ if (dl->index < 0) { @@ -1894,9 +2552,11 @@ static void add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk, sum = __gen_imsm_checksum(mpb); mpb->family_num = __cpu_to_le32(sum); } + + return 0; } -static void add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk, +static int add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk, int fd, char *devname) { struct intel_super *super = st->sb; @@ -1906,17 +2566,25 @@ static void add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk, int rv; struct stat stb; - if (super->current_vol >= 0) { - add_to_super_imsm_volume(st, dk, fd, devname); - return; + /* if we are on an RAID enabled platform check that the disk is + * attached to the raid controller + */ + if (super->hba && !disk_attached_to_hba(fd, super->hba)) { + fprintf(stderr, + Name ": %s is not attached to the raid controller: %s\n", + devname ? : "disk", super->hba); + return 1; } + if (super->current_vol >= 0) + return add_to_super_imsm_volume(st, dk, fd, devname); + fstat(fd, &stb); dd = malloc(sizeof(*dd)); if (!dd) { fprintf(stderr, Name ": malloc failed %s:%d.\n", __func__, __LINE__); - abort(); + return 1; } memset(dd, 0, sizeof(*dd)); dd->major = major(stb.st_rdev); @@ -1924,6 +2592,7 @@ static void add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk, dd->index = -1; dd->devname = devname ? strdup(devname) : NULL; dd->fd = fd; + dd->e = NULL; rv = imsm_read_serial(fd, devname, dd->serial); if (rv) { fprintf(stderr, @@ -1949,6 +2618,8 @@ static void add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk, dd->next = super->disks; super->disks = dd; } + + return 0; } static int store_imsm_mpb(int fd, struct intel_super *super); @@ -2023,7 +2694,7 @@ static int write_super_imsm(struct intel_super *super, int doclose) for (i = 0; i < mpb->num_raid_devs; i++) { struct imsm_dev *dev = __get_imsm_dev(mpb, i); - imsm_copy_dev(dev, super->dev_tbl[i]); + imsm_copy_dev(dev, get_imsm_dev(super, i)); mpb_size += sizeof_imsm_dev(dev, 0); } mpb_size += __le32_to_cpu(mpb->bbm_log_size); @@ -2059,8 +2730,14 @@ static int create_array(struct supertype *st) struct imsm_update_create_array *u; struct intel_super *super = st->sb; struct imsm_dev *dev = get_imsm_dev(super, super->current_vol); + struct imsm_map *map = get_imsm_map(dev, 0); + struct disk_info *inf; + struct imsm_disk *disk; + int i; + int idx; - len = sizeof(*u) - sizeof(*dev) + sizeof_imsm_dev(dev, 0); + len = sizeof(*u) - sizeof(*dev) + sizeof_imsm_dev(dev, 0) + + sizeof(*inf) * map->num_members; u = malloc(len); if (!u) { fprintf(stderr, "%s: failed to allocate update buffer\n", @@ -2071,6 +2748,12 @@ static int create_array(struct supertype *st) u->type = update_create_array; u->dev_idx = super->current_vol; imsm_copy_dev(&u->dev, dev); + inf = get_disk_info(u); + for (i = 0; i < map->num_members; i++) { + idx = get_imsm_disk_idx(dev, i); + disk = get_imsm_disk(super, idx); + serialcpy(inf[i].serial, disk->serial); + } append_metadata_update(st, u, len); return 0; @@ -2162,12 +2845,25 @@ static int validate_geometry_imsm_container(struct supertype *st, int level, { int fd; unsigned long long ldsize; + const struct imsm_orom *orom; if (level != LEVEL_CONTAINER) return 0; if (!dev) return 1; + if (check_env("IMSM_NO_PLATFORM")) + orom = NULL; + else + orom = find_imsm_orom(); + if (orom && raiddisks > orom->tds) { + if (verbose) + fprintf(stderr, Name ": %d exceeds maximum number of" + " platform supported disks: %d\n", + raiddisks, orom->tds); + return 0; + } + fd = open(dev, O_RDONLY|O_EXCL, 0); if (fd < 0) { if (verbose) @@ -2186,6 +2882,131 @@ static int validate_geometry_imsm_container(struct supertype *st, int level, return 1; } +static unsigned long long find_size(struct extent *e, int *idx, int num_extents) +{ + const unsigned long long base_start = e[*idx].start; + unsigned long long end = base_start + e[*idx].size; + int i; + + if (base_start == end) + return 0; + + *idx = *idx + 1; + for (i = *idx; i < num_extents; i++) { + /* extend overlapping extents */ + if (e[i].start >= base_start && + e[i].start <= end) { + if (e[i].size == 0) + return 0; + if (e[i].start + e[i].size > end) + end = e[i].start + e[i].size; + } else if (e[i].start > end) { + *idx = i; + break; + } + } + + return end - base_start; +} + +static unsigned long long merge_extents(struct intel_super *super, int sum_extents) +{ + /* build a composite disk with all known extents and generate a new + * 'maxsize' given the "all disks in an array must share a common start + * offset" constraint + */ + struct extent *e = calloc(sum_extents, sizeof(*e)); + struct dl *dl; + int i, j; + int start_extent; + unsigned long long pos; + unsigned long long start = 0; + unsigned long long maxsize; + unsigned long reserve; + + if (!e) + return ~0ULL; /* error */ + + /* coalesce and sort all extents. also, check to see if we need to + * reserve space between member arrays + */ + j = 0; + for (dl = super->disks; dl; dl = dl->next) { + if (!dl->e) + continue; + for (i = 0; i < dl->extent_cnt; i++) + e[j++] = dl->e[i]; + } + qsort(e, sum_extents, sizeof(*e), cmp_extent); + + /* merge extents */ + i = 0; + j = 0; + while (i < sum_extents) { + e[j].start = e[i].start; + e[j].size = find_size(e, &i, sum_extents); + j++; + if (e[j-1].size == 0) + break; + } + + pos = 0; + maxsize = 0; + start_extent = 0; + i = 0; + do { + unsigned long long esize; + + esize = e[i].start - pos; + if (esize >= maxsize) { + maxsize = esize; + start = pos; + start_extent = i; + } + pos = e[i].start + e[i].size; + i++; + } while (e[i-1].size); + free(e); + + if (start_extent > 0) + reserve = IMSM_RESERVED_SECTORS; /* gap between raid regions */ + else + reserve = 0; + + if (maxsize < reserve) + return ~0ULL; + + super->create_offset = ~((__u32) 0); + if (start + reserve > super->create_offset) + return ~0ULL; /* start overflows create_offset */ + super->create_offset = start + reserve; + + return maxsize - reserve; +} + +static int is_raid_level_supported(const struct imsm_orom *orom, int level, int raiddisks) +{ + if (level < 0 || level == 6 || level == 4) + return 0; + + /* if we have an orom prevent invalid raid levels */ + if (orom) + switch (level) { + case 0: return imsm_orom_has_raid0(orom); + case 1: + if (raiddisks > 2) + return imsm_orom_has_raid1e(orom); + return imsm_orom_has_raid1(orom) && raiddisks == 2; + case 10: return imsm_orom_has_raid10(orom) && raiddisks == 4; + case 5: return imsm_orom_has_raid5(orom) && raiddisks > 2; + } + else + return 1; /* not on an Intel RAID platform so anything goes */ + + return 0; +} + +#define pr_vrb(fmt, arg...) (void) (verbose && fprintf(stderr, Name fmt, ##arg)) /* validate_geometry_imsm_volume - lifted from validate_geometry_ddf_bvd * FIX ME add ahci details */ @@ -2197,32 +3018,44 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level, { struct stat stb; struct intel_super *super = st->sb; + struct imsm_super *mpb = super->anchor; struct dl *dl; unsigned long long pos = 0; unsigned long long maxsize; struct extent *e; int i; - if (level == LEVEL_CONTAINER) + /* We must have the container info already read in. */ + if (!super) return 0; - if (level == 1 && raiddisks > 2) { - if (verbose) - fprintf(stderr, Name ": imsm does not support more " - "than 2 in a raid1 configuration\n"); + if (!is_raid_level_supported(super->orom, level, raiddisks)) { + pr_vrb(": platform does not support raid%d with %d disk%s\n", + level, raiddisks, raiddisks > 1 ? "s" : ""); return 0; } - - /* We must have the container info already read in. */ - if (!super) + if (super->orom && level != 1 && + !imsm_orom_has_chunk(super->orom, chunk)) { + pr_vrb(": platform does not support a chunk size of: %d\n", chunk); + return 0; + } + if (layout != imsm_level_to_layout(level)) { + if (level == 5) + pr_vrb(": imsm raid 5 only supports the left-asymmetric layout\n"); + else if (level == 10) + pr_vrb(": imsm raid 10 only supports the n2 layout\n"); + else + pr_vrb(": imsm unknown layout %#x for this raid level %d\n", + layout, level); return 0; + } if (!dev) { /* General test: make sure there is space for * 'raiddisks' device extents of size 'size' at a given * offset */ - unsigned long long minsize = size*2 /* convert to blocks */; + unsigned long long minsize = size; unsigned long long start_offset = ~0ULL; int dcnt = 0; if (minsize == 0) @@ -2263,6 +3096,7 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level, } return 1; } + /* This device must be a member of the set */ if (stat(dev, &stb) < 0) return 0; @@ -2278,23 +3112,143 @@ static int validate_geometry_imsm_volume(struct supertype *st, int level, fprintf(stderr, Name ": %s is not in the " "same imsm set\n", dev); return 0; + } else if (super->orom && dl->index < 0 && mpb->num_raid_devs) { + /* If a volume is present then the current creation attempt + * cannot incorporate new spares because the orom may not + * understand this configuration (all member disks must be + * members of each array in the container). + */ + fprintf(stderr, Name ": %s is a spare and a volume" + " is already defined for this container\n", dev); + fprintf(stderr, Name ": The option-rom requires all member" + " disks to be a member of all volumes\n"); + return 0; } + + /* retrieve the largest free space block */ e = get_extents(super, dl); maxsize = 0; i = 0; - if (e) do { - unsigned long long esize; - esize = e[i].start - pos; - if (esize >= maxsize) - maxsize = esize; - pos = e[i].start + e[i].size; - i++; - } while (e[i-1].size); + if (e) { + do { + unsigned long long esize; + + esize = e[i].start - pos; + if (esize >= maxsize) + maxsize = esize; + pos = e[i].start + e[i].size; + i++; + } while (e[i-1].size); + dl->e = e; + dl->extent_cnt = i; + } else { + if (verbose) + fprintf(stderr, Name ": unable to determine free space for: %s\n", + dev); + return 0; + } + if (maxsize < size) { + if (verbose) + fprintf(stderr, Name ": %s not enough space (%llu < %llu)\n", + dev, maxsize, size); + return 0; + } + + /* count total number of extents for merge */ + i = 0; + for (dl = super->disks; dl; dl = dl->next) + if (dl->e) + i += dl->extent_cnt; + + maxsize = merge_extents(super, i); + if (maxsize < size) { + if (verbose) + fprintf(stderr, Name ": not enough space after merge (%llu < %llu)\n", + maxsize, size); + return 0; + } else if (maxsize == ~0ULL) { + if (verbose) + fprintf(stderr, Name ": failed to merge %d extents\n", i); + return 0; + } + *freesize = maxsize; return 1; } +static int reserve_space(struct supertype *st, int raiddisks, + unsigned long long size, int chunk, + unsigned long long *freesize) +{ + struct intel_super *super = st->sb; + struct imsm_super *mpb = super->anchor; + struct dl *dl; + int i; + int extent_cnt; + struct extent *e; + unsigned long long maxsize; + unsigned long long minsize; + int cnt; + int used; + + /* find the largest common start free region of the possible disks */ + used = 0; + extent_cnt = 0; + cnt = 0; + for (dl = super->disks; dl; dl = dl->next) { + dl->raiddisk = -1; + + if (dl->index >= 0) + used++; + + /* don't activate new spares if we are orom constrained + * and there is already a volume active in the container + */ + if (super->orom && dl->index < 0 && mpb->num_raid_devs) + continue; + + e = get_extents(super, dl); + if (!e) + continue; + for (i = 1; e[i-1].size; i++) + ; + dl->e = e; + dl->extent_cnt = i; + extent_cnt += i; + cnt++; + } + + maxsize = merge_extents(super, extent_cnt); + minsize = size; + if (size == 0) + minsize = chunk; + + if (cnt < raiddisks || + (super->orom && used && used != raiddisks) || + maxsize < minsize) { + fprintf(stderr, Name ": not enough devices with space to create array.\n"); + return 0; /* No enough free spaces large enough */ + } + + if (size == 0) { + size = maxsize; + if (chunk) { + size /= chunk; + size *= chunk; + } + } + + cnt = 0; + for (dl = super->disks; dl; dl = dl->next) + if (dl->e) + dl->raiddisk = cnt++; + + *freesize = size; + + return 1; +} + static int validate_geometry_imsm(struct supertype *st, int level, int layout, int raiddisks, int chunk, unsigned long long size, char *dev, unsigned long long *freesize, @@ -2314,6 +3268,20 @@ static int validate_geometry_imsm(struct supertype *st, int level, int layout, verbose); } + if (!dev) { + if (st->sb && freesize) { + /* we are being asked to automatically layout a + * new volume based on the current contents of + * the container. If the the parameters can be + * satisfied reserve_space will record the disks, + * start offset, and size of the volume to be + * created. add_to_super and getinfo_super + * detect when autolayout is in progress. + */ + return reserve_space(st, raiddisks, size, chunk, freesize); + } + return 1; + } if (st->sb) { /* creating in a given container */ return validate_geometry_imsm_volume(st, level, layout, @@ -2412,6 +3380,18 @@ static struct mdinfo *container_content_imsm(struct supertype *st) struct mdinfo *this; int slot; + /* do not publish arrays that are in the middle of an + * unsupported migration + */ + if (dev->vol.migr_state && + (migr_type(dev) == MIGR_GEN_MIGR || + migr_type(dev) == MIGR_STATE_CHANGE)) { + fprintf(stderr, Name ": cannot assemble volume '%.16s':" + " unsupported migration in progress\n", + dev->volume); + continue; + } + this = malloc(sizeof(*this)); memset(this, 0, sizeof(*this)); this->next = rest; @@ -2458,7 +3438,7 @@ static struct mdinfo *container_content_imsm(struct supertype *st) info_d = malloc(sizeof(*info_d)); if (!info_d) { fprintf(stderr, Name ": failed to allocate disk" - " for volume %s\n", (char *) dev->volume); + " for volume %.16s\n", dev->volume); free(this); this = rest; break; @@ -2578,10 +3558,23 @@ static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev) int failed = 0; struct imsm_disk *disk; struct imsm_map *map = get_imsm_map(dev, 0); + struct imsm_map *prev = get_imsm_map(dev, dev->vol.migr_state); + __u32 ord; + int idx; - for (i = 0; i < map->num_members; i++) { - __u32 ord = get_imsm_ord_tbl_ent(dev, i); - int idx = ord_to_idx(ord); + /* at the beginning of migration we set IMSM_ORD_REBUILD on + * disks that are being rebuilt. New failures are recorded to + * map[0]. So we look through all the disks we started with and + * see if any failures are still present, or if any new ones + * have arrived + * + * FIXME add support for online capacity expansion and + * raid-level-migration + */ + for (i = 0; i < prev->num_members; i++) { + ord = __le32_to_cpu(prev->disk_ord_tbl[i]); + ord |= __le32_to_cpu(map->disk_ord_tbl[i]); + idx = ord_to_idx(ord); disk = get_imsm_disk(super, idx); if (!disk || disk->status & FAILED_DISK || @@ -2599,7 +3592,8 @@ static int is_resyncing(struct imsm_dev *dev) if (!dev->vol.migr_state) return 0; - if (dev->vol.migr_type == MIGR_INIT) + if (migr_type(dev) == MIGR_INIT || + migr_type(dev) == MIGR_REPAIR) return 1; migr_map = get_imsm_map(dev, 1); @@ -2617,7 +3611,7 @@ static int is_rebuilding(struct imsm_dev *dev) if (!dev->vol.migr_state) return 0; - if (dev->vol.migr_type != MIGR_REBUILD) + if (migr_type(dev) != MIGR_REBUILD) return 0; migr_map = get_imsm_map(dev, 1); @@ -2628,11 +3622,38 @@ static int is_rebuilding(struct imsm_dev *dev) return 0; } -static void mark_failure(struct imsm_disk *disk) +/* return true if we recorded new information */ +static int mark_failure(struct imsm_dev *dev, struct imsm_disk *disk, int idx) { - if (disk->status & FAILED_DISK) - return; + __u32 ord; + int slot; + struct imsm_map *map; + + /* new failures are always set in map[0] */ + map = get_imsm_map(dev, 0); + + slot = get_imsm_disk_slot(map, idx); + if (slot < 0) + return 0; + + ord = __le32_to_cpu(map->disk_ord_tbl[slot]); + if ((disk->status & FAILED_DISK) && (ord & IMSM_ORD_REBUILD)) + return 0; + disk->status |= FAILED_DISK; + set_imsm_ord_tbl_ent(map, slot, idx | IMSM_ORD_REBUILD); + if (~map->failed_disk_num == 0) + map->failed_disk_num = slot; + return 1; +} + +static void mark_missing(struct imsm_dev *dev, struct imsm_disk *disk, int idx) +{ + mark_failure(dev, disk, idx); + + if (disk->scsi_id == __cpu_to_le32(~(__u32)0)) + return; + disk->scsi_id = __cpu_to_le32(~(__u32)0); memmove(&disk->serial[0], &disk->serial[1], MAX_RAID_SERIAL_LEN - 1); } @@ -2658,7 +3679,7 @@ static int imsm_set_array_state(struct active_array *a, int consistent) dprintf("imsm: mark missing\n"); end_migration(dev, map_state); for (dl = super->missing; dl; dl = dl->next) - mark_failure(&dl->disk); + mark_missing(dev, &dl->disk, dl->index); super->updates_pending++; } @@ -2670,7 +3691,8 @@ static int imsm_set_array_state(struct active_array *a, int consistent) if (is_resync_complete(a)) { /* complete intialization / resync, - * recovery is completed in ->set_disk + * recovery and interrupted recovery is completed in + * ->set_disk */ if (is_resyncing(dev)) { dprintf("imsm: mark resync done\n"); @@ -2680,20 +3702,14 @@ static int imsm_set_array_state(struct active_array *a, int consistent) } else if (!is_resyncing(dev) && !failed) { /* mark the start of the init process if nothing is failed */ dprintf("imsm: mark resync start (%llu)\n", a->resync_start); - if (map->map_state == IMSM_T_STATE_NORMAL) - migrate(dev, IMSM_T_STATE_NORMAL, MIGR_REBUILD); - else + if (map->map_state == IMSM_T_STATE_UNINITIALIZED) migrate(dev, IMSM_T_STATE_NORMAL, MIGR_INIT); + else + migrate(dev, IMSM_T_STATE_NORMAL, MIGR_REPAIR); super->updates_pending++; } - /* check if we can update the migration checkpoint */ - if (dev->vol.migr_state && - __le32_to_cpu(dev->vol.curr_migr_unit) != a->resync_start) { - dprintf("imsm: checkpoint migration (%llu)\n", a->resync_start); - dev->vol.curr_migr_unit = __cpu_to_le32(a->resync_start); - super->updates_pending++; - } + /* FIXME check if we can update curr_migr_unit from resync_start */ /* mark dirty / clean */ if (dev->vol.dirty != !consistent) { @@ -2732,13 +3748,13 @@ static void imsm_set_disk(struct active_array *a, int n, int state) disk = get_imsm_disk(super, ord_to_idx(ord)); /* check for new failures */ - if ((state & DS_FAULTY) && !(disk->status & FAILED_DISK)) { - mark_failure(disk); - super->updates_pending++; + if (state & DS_FAULTY) { + if (mark_failure(dev, disk, ord_to_idx(ord))) + super->updates_pending++; } /* check if in_sync */ - if (state & DS_INSYNC && ord & IMSM_ORD_REBUILD) { + if (state & DS_INSYNC && ord & IMSM_ORD_REBUILD && is_rebuilding(dev)) { struct imsm_map *migr_map = get_imsm_map(dev, 1); set_imsm_ord_tbl_ent(migr_map, n, ord_to_idx(ord)); @@ -2751,6 +3767,8 @@ static void imsm_set_disk(struct active_array *a, int n, int state) /* check if recovery complete, newly degraded, or failed */ if (map_state == IMSM_T_STATE_NORMAL && is_rebuilding(dev)) { end_migration(dev, map_state); + map = get_imsm_map(dev, 0); + map->failed_disk_num = ~0; super->updates_pending++; } else if (map_state == IMSM_T_STATE_DEGRADED && map->map_state != map_state && @@ -2828,18 +3846,21 @@ static struct dl *imsm_readd(struct intel_super *super, int idx, struct active_a return dl; } -static struct dl *imsm_add_spare(struct intel_super *super, int slot, struct active_array *a) +static struct dl *imsm_add_spare(struct intel_super *super, int slot, + struct active_array *a, int activate_new) { struct imsm_dev *dev = get_imsm_dev(super, a->info.container_member); int idx = get_imsm_disk_idx(dev, slot); - struct imsm_map *map = get_imsm_map(dev, 0); + struct imsm_super *mpb = super->anchor; + struct imsm_map *map; unsigned long long esize; unsigned long long pos; struct mdinfo *d; struct extent *ex; - int j; + int i, j; int found; __u32 array_start; + __u32 blocks; struct dl *dl; for (dl = super->disks; dl; dl = dl->next) { @@ -2855,52 +3876,71 @@ static struct dl *imsm_add_spare(struct intel_super *super, int slot, struct act continue; /* skip in use or failed drives */ - if (dl->disk.status & FAILED_DISK || idx == dl->index) { - dprintf("%x:%x status ( %s%s)\n", - dl->major, dl->minor, - dl->disk.status & FAILED_DISK ? "failed " : "", - idx == dl->index ? "in use " : ""); + if (dl->disk.status & FAILED_DISK || idx == dl->index || + dl->index == -2) { + dprintf("%x:%x status (failed: %d index: %d)\n", + dl->major, dl->minor, + (dl->disk.status & FAILED_DISK) == FAILED_DISK, idx); continue; } + /* skip pure spares when we are looking for partially + * assimilated drives + */ + if (dl->index == -1 && !activate_new) + continue; + /* Does this unused device have the requisite free space? - * We need a->info.component_size sectors + * It needs to be able to cover all member volumes */ ex = get_extents(super, dl); if (!ex) { dprintf("cannot get extents\n"); continue; } - found = 0; - j = 0; - pos = 0; - array_start = __le32_to_cpu(map->pba_of_lba0); + for (i = 0; i < mpb->num_raid_devs; i++) { + dev = get_imsm_dev(super, i); + map = get_imsm_map(dev, 0); - do { - /* check that we can start at pba_of_lba0 with - * a->info.component_size of space + /* check if this disk is already a member of + * this array */ - esize = ex[j].start - pos; - if (array_start >= pos && - array_start + a->info.component_size < ex[j].start) { - found = 1; + if (get_imsm_disk_slot(map, dl->index) >= 0) + continue; + + found = 0; + j = 0; + pos = 0; + array_start = __le32_to_cpu(map->pba_of_lba0); + blocks = __le32_to_cpu(map->blocks_per_member); + + do { + /* check that we can start at pba_of_lba0 with + * blocks_per_member of space + */ + esize = ex[j].start - pos; + if (array_start >= pos && + array_start + blocks < ex[j].start) { + found = 1; + break; + } + pos = ex[j].start + ex[j].size; + j++; + } while (ex[j-1].size); + + if (!found) break; - } - pos = ex[j].start + ex[j].size; - j++; - - } while (ex[j-1].size); + } free(ex); - if (!found) { - dprintf("%x:%x does not have %llu at %d\n", + if (i < mpb->num_raid_devs) { + dprintf("%x:%x does not have %u at %u\n", dl->major, dl->minor, - a->info.component_size, - __le32_to_cpu(map->pba_of_lba0)); + blocks, array_start); /* No room */ continue; - } else - break; + } + return dl; } return dl; @@ -2958,12 +3998,17 @@ static struct mdinfo *imsm_activate_spare(struct active_array *a, continue; /* - * OK, this device needs recovery. Try to re-add the previous - * occupant of this slot, if this fails add a new spare + * OK, this device needs recovery. Try to re-add the + * previous occupant of this slot, if this fails see if + * we can continue the assimilation of a spare that was + * partially assimilated, finally try to activate a new + * spare. */ dl = imsm_readd(super, i, a); if (!dl) - dl = imsm_add_spare(super, i, a); + dl = imsm_add_spare(super, i, a, 0); + if (!dl) + dl = imsm_add_spare(super, i, a, 1); if (!dl) continue; @@ -3047,18 +4092,20 @@ static struct mdinfo *imsm_activate_spare(struct active_array *a, return rv; } -static int disks_overlap(struct imsm_dev *d1, struct imsm_dev *d2) +static int disks_overlap(struct intel_super *super, int idx, struct imsm_update_create_array *u) { - struct imsm_map *m1 = get_imsm_map(d1, 0); - struct imsm_map *m2 = get_imsm_map(d2, 0); + struct imsm_dev *dev = get_imsm_dev(super, idx); + struct imsm_map *map = get_imsm_map(dev, 0); + struct imsm_map *new_map = get_imsm_map(&u->dev, 0); + struct disk_info *inf = get_disk_info(u); + struct imsm_disk *disk; int i; int j; - int idx; - for (i = 0; i < m1->num_members; i++) { - idx = get_imsm_disk_idx(d1, i); - for (j = 0; j < m2->num_members; j++) - if (idx == get_imsm_disk_idx(d2, j)) + for (i = 0; i < map->num_members; i++) { + disk = get_imsm_disk(super, get_imsm_disk_idx(dev, i)); + for (j = 0; j < new_map->num_members; j++) + if (serialcmp(disk->serial, inf[j].serial) == 0) return 1; } @@ -3161,9 +4208,10 @@ static void imsm_process_update(struct supertype *st, found = 0; for (a = st->arrays; a ; a = a->next) { dev = get_imsm_dev(super, a->info.container_member); - for (i = 0; i < map->num_members; i++) - if (victim == get_imsm_disk_idx(dev, i)) - found++; + map = get_imsm_map(dev, 0); + + if (get_imsm_disk_slot(map, victim) >= 0) + found++; } /* delete the victim if it is no longer being @@ -3199,30 +4247,33 @@ static void imsm_process_update(struct supertype *st, * (FIX ME) notice that its update did not take hold. */ struct imsm_update_create_array *u = (void *) update->buf; + struct intel_dev *dv; struct imsm_dev *dev; struct imsm_map *map, *new_map; unsigned long long start, end; unsigned long long new_start, new_end; int i; - int overlap = 0; + struct disk_info *inf; + struct dl *dl; /* handle racing creates: first come first serve */ if (u->dev_idx < mpb->num_raid_devs) { dprintf("%s: subarray %d already defined\n", __func__, u->dev_idx); - return; + goto create_error; } /* check update is next in sequence */ if (u->dev_idx != mpb->num_raid_devs) { dprintf("%s: can not create array %d expected index %d\n", __func__, u->dev_idx, mpb->num_raid_devs); - return; + goto create_error; } new_map = get_imsm_map(&u->dev, 0); new_start = __le32_to_cpu(new_map->pba_of_lba0); new_end = new_start + __le32_to_cpu(new_map->blocks_per_member); + inf = get_disk_info(u); /* handle activate_spare versus create race: * check to make sure that overlapping arrays do not include @@ -3235,40 +4286,67 @@ static void imsm_process_update(struct supertype *st, end = start + __le32_to_cpu(map->blocks_per_member); if ((new_start >= start && new_start <= end) || (start >= new_start && start <= new_end)) - overlap = 1; - if (overlap && disks_overlap(dev, &u->dev)) { + /* overlap */; + else + continue; + + if (disks_overlap(super, i, u)) { dprintf("%s: arrays overlap\n", __func__); - return; + goto create_error; } } - /* check num_members sanity */ - if (new_map->num_members > mpb->num_disks) { - dprintf("%s: num_disks out of range\n", __func__); - return; - } /* check that prepare update was successful */ if (!update->space) { dprintf("%s: prepare update failed\n", __func__); - return; + goto create_error; + } + + /* check that all disks are still active before committing + * changes. FIXME: could we instead handle this by creating a + * degraded array? That's probably not what the user expects, + * so better to drop this update on the floor. + */ + for (i = 0; i < new_map->num_members; i++) { + dl = serial_to_dl(inf[i].serial, super); + if (!dl) { + dprintf("%s: disk disappeared\n", __func__); + goto create_error; + } } super->updates_pending++; - dev = update->space; - map = get_imsm_map(dev, 0); + + /* convert spares to members and fixup ord_tbl */ + for (i = 0; i < new_map->num_members; i++) { + dl = serial_to_dl(inf[i].serial, super); + if (dl->index == -1) { + dl->index = mpb->num_disks; + mpb->num_disks++; + dl->disk.status |= CONFIGURED_DISK; + dl->disk.status &= ~SPARE_DISK; + } + set_imsm_ord_tbl_ent(new_map, i, dl->index); + } + + dv = update->space; + dev = dv->dev; update->space = NULL; imsm_copy_dev(dev, &u->dev); - map = get_imsm_map(dev, 0); - super->dev_tbl[u->dev_idx] = dev; + dv->index = u->dev_idx; + dv->next = super->devlist; + super->devlist = dv; mpb->num_raid_devs++; - /* fix up flags */ - for (i = 0; i < map->num_members; i++) { - struct imsm_disk *disk; - - disk = get_imsm_disk(super, get_imsm_disk_idx(dev, i)); - disk->status |= CONFIGURED_DISK; - disk->status &= ~SPARE_DISK; + imsm_update_version_info(super); + break; + create_error: + /* mdmon knows how to release update->space, but not + * ((struct intel_dev *) update->space)->dev + */ + if (update->space) { + dv = update->space; + free(dv->dev); } break; } @@ -3318,9 +4396,41 @@ static void imsm_prepare_update(struct supertype *st, switch (type) { case update_create_array: { struct imsm_update_create_array *u = (void *) update->buf; + struct intel_dev *dv; + struct imsm_dev *dev = &u->dev; + struct imsm_map *map = get_imsm_map(dev, 0); + struct dl *dl; + struct disk_info *inf; + int i; + int activate = 0; + + inf = get_disk_info(u); + len = sizeof_imsm_dev(dev, 1); + /* allocate a new super->devlist entry */ + dv = malloc(sizeof(*dv)); + if (dv) { + dv->dev = malloc(len); + if (dv->dev) + update->space = dv; + else { + free(dv); + update->space = NULL; + } + } - len = sizeof_imsm_dev(&u->dev, 1); - update->space = malloc(len); + /* count how many spares will be converted to members */ + for (i = 0; i < map->num_members; i++) { + dl = serial_to_dl(inf[i].serial, super); + if (!dl) { + /* hmm maybe it failed?, nothing we can do about + * it here + */ + continue; + } + if (count_memberships(dl, super) == 0) + activate++; + } + len += activate * sizeof(struct imsm_disk); break; default: break; @@ -3343,7 +4453,9 @@ static void imsm_prepare_update(struct supertype *st, free(super->next_buf); super->next_len = buf_len; - if (posix_memalign(&super->next_buf, buf_len, 512) != 0) + if (posix_memalign(&super->next_buf, 512, buf_len) == 0) + memset(super->next_buf, 0, buf_len); + else super->next_buf = NULL; } } @@ -3405,11 +4517,13 @@ struct superswitch super_imsm = { #ifndef MDASSEMBLE .examine_super = examine_super_imsm, .brief_examine_super = brief_examine_super_imsm, + .export_examine_super = export_examine_super_imsm, .detail_super = detail_super_imsm, .brief_detail_super = brief_detail_super_imsm, .write_init_super = write_init_super_imsm, .validate_geometry = validate_geometry_imsm, .add_to_super = add_to_super_imsm, + .detail_platform = detail_platform_imsm, #endif .match_home = match_home_imsm, .uuid_from_super= uuid_from_super_imsm, @@ -3426,8 +4540,10 @@ struct superswitch super_imsm = { .free_super = free_super_imsm, .match_metadata_desc = match_metadata_desc_imsm, .container_content = container_content_imsm, + .default_layout = imsm_level_to_layout, .external = 1, + .name = "imsm", #ifndef MDASSEMBLE /* for mdmon */