X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super-intel.c;h=ddf4de90100c1e3d4dcf79c751c0cd4e1368194f;hb=1b17b4e4ff57a4f7dcbc87c5a03f2d9c87f6cb2f;hp=fbfb27e7a0e76a33fff33febb3023debfa298ce6;hpb=c17608eac3cfd3aca667e971ece2511fda8785af;p=thirdparty%2Fmdadm.git diff --git a/super-intel.c b/super-intel.c index fbfb27e7..ddf4de90 100644 --- a/super-intel.c +++ b/super-intel.c @@ -41,15 +41,50 @@ #define MAX_SIGNATURE_LENGTH 32 #define MAX_RAID_SERIAL_LEN 16 -#define MPB_ATTRIB_CHECKSUM_VERIFY __cpu_to_le32(0x80000000) -#define MPB_ATTRIB_PM __cpu_to_le32(0x40000000) -#define MPB_ATTRIB_2TB __cpu_to_le32(0x20000000) -#define MPB_ATTRIB_RAID0 __cpu_to_le32(0x00000001) -#define MPB_ATTRIB_RAID1 __cpu_to_le32(0x00000002) -#define MPB_ATTRIB_RAID10 __cpu_to_le32(0x00000004) -#define MPB_ATTRIB_RAID1E __cpu_to_le32(0x00000008) -#define MPB_ATTRIB_RAID5 __cpu_to_le32(0x00000010) -#define MPB_ATTRIB_RAIDCNG __cpu_to_le32(0x00000020) +/* supports RAID0 */ +#define MPB_ATTRIB_RAID0 __cpu_to_le32(0x00000001) +/* supports RAID1 */ +#define MPB_ATTRIB_RAID1 __cpu_to_le32(0x00000002) +/* supports RAID10 */ +#define MPB_ATTRIB_RAID10 __cpu_to_le32(0x00000004) +/* supports RAID1E */ +#define MPB_ATTRIB_RAID1E __cpu_to_le32(0x00000008) +/* supports RAID5 */ +#define MPB_ATTRIB_RAID5 __cpu_to_le32(0x00000010) +/* supports RAID CNG */ +#define MPB_ATTRIB_RAIDCNG __cpu_to_le32(0x00000020) +/* supports expanded stripe sizes of 256K, 512K and 1MB */ +#define MPB_ATTRIB_EXP_STRIPE_SIZE __cpu_to_le32(0x00000040) + +/* The OROM Support RST Caching of Volumes */ +#define MPB_ATTRIB_NVM __cpu_to_le32(0x02000000) +/* The OROM supports creating disks greater than 2TB */ +#define MPB_ATTRIB_2TB_DISK __cpu_to_le32(0x04000000) +/* The OROM supports Bad Block Management */ +#define MPB_ATTRIB_BBM __cpu_to_le32(0x08000000) + +/* THe OROM Supports NVM Caching of Volumes */ +#define MPB_ATTRIB_NEVER_USE2 __cpu_to_le32(0x10000000) +/* The OROM supports creating volumes greater than 2TB */ +#define MPB_ATTRIB_2TB __cpu_to_le32(0x20000000) +/* originally for PMP, now it's wasted b/c. Never use this bit! */ +#define MPB_ATTRIB_NEVER_USE __cpu_to_le32(0x40000000) +/* Verify MPB contents against checksum after reading MPB */ +#define MPB_ATTRIB_CHECKSUM_VERIFY __cpu_to_le32(0x80000000) + +/* Define all supported attributes that have to be accepted by mdadm + */ +#define MPB_ATTRIB_SUPPORTED (MPB_ATTRIB_CHECKSUM_VERIFY | \ + MPB_ATTRIB_2TB | \ + MPB_ATTRIB_2TB_DISK | \ + MPB_ATTRIB_RAID0 | \ + MPB_ATTRIB_RAID1 | \ + MPB_ATTRIB_RAID10 | \ + MPB_ATTRIB_RAID5 | \ + MPB_ATTRIB_EXP_STRIPE_SIZE) + +/* Define attributes that are unused but not harmful */ +#define MPB_ATTRIB_IGNORED (MPB_ATTRIB_NEVER_USE) #define MPB_SECTOR_CNT 2210 #define IMSM_RESERVED_SECTORS 4096 @@ -309,7 +344,7 @@ struct intel_super { struct extent *e; /* for determining freespace @ create */ int raiddisk; /* slot to fill in autolayout */ enum action action; - } *disks; + } *disks, *current_disk; struct dl *disk_mgmt_list; /* list of disks to add/remove while mdmon active */ struct dl *missing; /* disks removed while we weren't looking */ @@ -563,7 +598,7 @@ static __u8 *get_imsm_version(struct imsm_super *mpb) { return &mpb->sig[MPB_SIG_LEN]; } -#endif +#endif /* retrieve a disk directly from the anchor when the anchor is known to be * up-to-date, currently only at load time @@ -1095,7 +1130,95 @@ void examine_migr_rec_imsm(struct intel_super *super) break; } } +#endif /* MDASSEMBLE */ +/******************************************************************************* + * function: imsm_check_attributes + * Description: Function checks if features represented by attributes flags + * are supported by mdadm. + * Parameters: + * attributes - Attributes read from metadata + * Returns: + * 0 - passed attributes contains unsupported features flags + * 1 - all features are supported + ******************************************************************************/ +static int imsm_check_attributes(__u32 attributes) +{ + int ret_val = 1; + __u32 not_supported = MPB_ATTRIB_SUPPORTED^0xffffffff; + not_supported &= ~MPB_ATTRIB_IGNORED; + + not_supported &= attributes; + if (not_supported) { + fprintf(stderr, Name "(IMSM): Unsupported attributes : %x\n", + (unsigned)__le32_to_cpu(not_supported)); + if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) { + dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY \n"); + not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY; + } + if (not_supported & MPB_ATTRIB_2TB) { + dprintf("\t\tMPB_ATTRIB_2TB\n"); + not_supported ^= MPB_ATTRIB_2TB; + } + if (not_supported & MPB_ATTRIB_RAID0) { + dprintf("\t\tMPB_ATTRIB_RAID0\n"); + not_supported ^= MPB_ATTRIB_RAID0; + } + if (not_supported & MPB_ATTRIB_RAID1) { + dprintf("\t\tMPB_ATTRIB_RAID1\n"); + not_supported ^= MPB_ATTRIB_RAID1; + } + if (not_supported & MPB_ATTRIB_RAID10) { + dprintf("\t\tMPB_ATTRIB_RAID10\n"); + not_supported ^= MPB_ATTRIB_RAID10; + } + if (not_supported & MPB_ATTRIB_RAID1E) { + dprintf("\t\tMPB_ATTRIB_RAID1E\n"); + not_supported ^= MPB_ATTRIB_RAID1E; + } + if (not_supported & MPB_ATTRIB_RAID5) { + dprintf("\t\tMPB_ATTRIB_RAID5\n"); + not_supported ^= MPB_ATTRIB_RAID5; + } + if (not_supported & MPB_ATTRIB_RAIDCNG) { + dprintf("\t\tMPB_ATTRIB_RAIDCNG\n"); + not_supported ^= MPB_ATTRIB_RAIDCNG; + } + if (not_supported & MPB_ATTRIB_BBM) { + dprintf("\t\tMPB_ATTRIB_BBM\n"); + not_supported ^= MPB_ATTRIB_BBM; + } + if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) { + dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY (== MPB_ATTRIB_LEGACY)\n"); + not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY; + } + if (not_supported & MPB_ATTRIB_EXP_STRIPE_SIZE) { + dprintf("\t\tMPB_ATTRIB_EXP_STRIP_SIZE\n"); + not_supported ^= MPB_ATTRIB_EXP_STRIPE_SIZE; + } + if (not_supported & MPB_ATTRIB_2TB_DISK) { + dprintf("\t\tMPB_ATTRIB_2TB_DISK\n"); + not_supported ^= MPB_ATTRIB_2TB_DISK; + } + if (not_supported & MPB_ATTRIB_NEVER_USE2) { + dprintf("\t\tMPB_ATTRIB_NEVER_USE2\n"); + not_supported ^= MPB_ATTRIB_NEVER_USE2; + } + if (not_supported & MPB_ATTRIB_NEVER_USE) { + dprintf("\t\tMPB_ATTRIB_NEVER_USE\n"); + not_supported ^= MPB_ATTRIB_NEVER_USE; + } + + if (not_supported) + dprintf(Name "(IMSM): Unknown attributes : %x\n", not_supported); + + ret_val = 0; + } + + return ret_val; +} + +#ifndef MDASSEMBLE static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map); static void examine_super_imsm(struct supertype *st, char *homehost) @@ -1117,6 +1240,11 @@ static void examine_super_imsm(struct supertype *st, char *homehost) printf(" Orig Family : %08x\n", __le32_to_cpu(mpb->orig_family_num)); printf(" Family : %08x\n", __le32_to_cpu(mpb->family_num)); printf(" Generation : %08x\n", __le32_to_cpu(mpb->generation_num)); + printf(" Attributes : "); + if (imsm_check_attributes(mpb->attributes)) + printf("All supported\n"); + else + printf("not supported\n"); getinfo_super_imsm(st, &info, NULL); fname_from_uuid(st, &info, nbuf, ':'); printf(" UUID : %s\n", nbuf + 5); @@ -1396,9 +1524,9 @@ static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_b fd2devname(fd, buf); printf(" Port%d : %s", port, buf); if (imsm_read_serial(fd, NULL, (__u8 *) buf) == 0) - printf(" (%s)\n", buf); + printf(" (%.*s)\n", MAX_RAID_SERIAL_LEN, buf); else - printf("()\n"); + printf(" ()\n"); } close(fd); free(path); @@ -1419,8 +1547,6 @@ static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_b return err; } - - static void print_found_intel_controllers(struct sys_dev *elem) { for (; elem; elem = elem->next) { @@ -1822,7 +1948,7 @@ static __u64 blocks_per_migr_unit(struct intel_super *super, migr_chunk = migr_strip_blocks_resync(dev); disks = imsm_num_data_members(dev, 0); blocks_per_unit = stripes_per_unit * migr_chunk * disks; - stripe = __le32_to_cpu(map->blocks_per_strip) * disks; + stripe = __le16_to_cpu(map->blocks_per_strip) * disks; segment = blocks_per_unit / stripe; block_rel = blocks_per_unit - segment * stripe; parity_depth = parity_segment_depth(dev); @@ -1944,6 +2070,7 @@ out: return retval; } +#ifndef MDASSEMBLE /******************************************************************************* * function: imsm_create_metadata_checkpoint_update * Description: It creates update for checkpoint change. @@ -2061,6 +2188,7 @@ static int write_imsm_migr_rec(struct supertype *st) close(fd); return retval; } +#endif /* MDASSEMBLE */ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, char *dmap) { @@ -2079,9 +2207,8 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, if (prev_map) map_to_analyse = prev_map; - for (dl = super->disks; dl; dl = dl->next) - if (dl->raiddisk == info->disk.raid_disk) - break; + dl = super->current_disk; + info->container_member = super->current_vol; info->array.raid_disks = map->num_members; info->array.level = get_imsm_raid_level(map_to_analyse); @@ -2127,7 +2254,6 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, /* conversion is happening as RAID5 */ info->array.level = 5; info->array.layout = ALGORITHM_PARITY_N; - info->array.raid_disks += 1; info->delta_disks -= 1; break; default: @@ -2143,11 +2269,13 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, info->new_chunk = info->array.chunk_size; info->delta_disks = 0; } - info->disk.major = 0; - info->disk.minor = 0; + if (dl) { info->disk.major = dl->major; info->disk.minor = dl->minor; + info->disk.number = dl->index; + info->disk.raid_disk = get_imsm_disk_slot(map_to_analyse, + dl->index); } info->data_offset = __le32_to_cpu(map_to_analyse->pba_of_lba0); @@ -2195,11 +2323,20 @@ static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, unsigned long long array_blocks; int used_disks; + if (__le32_to_cpu(migr_rec->ascending_migr) && + (units < + (__le32_to_cpu(migr_rec->num_migr_units)-1)) && + (super->migr_rec->rec_status == + __cpu_to_le32(UNIT_SRC_IN_CP_AREA))) + units++; + info->reshape_progress = blocks_per_unit * units; dprintf("IMSM: General Migration checkpoint : %llu " "(%llu) -> read reshape progress : %llu\n", - units, blocks_per_unit, info->reshape_progress); + (unsigned long long)units, + (unsigned long long)blocks_per_unit, + info->reshape_progress); used_disks = imsm_num_data_members(dev, 1); if (used_disks > 0) { @@ -3039,8 +3176,8 @@ static int load_imsm_mpb(int fd, struct intel_super *super, char *devname) if (lseek64(fd, dsize - (512 * 2), SEEK_SET) < 0) { if (devname) - fprintf(stderr, - Name ": Cannot seek to anchor block on %s: %s\n", + fprintf(stderr, Name + ": Cannot seek to anchor block on %s: %s\n", devname, strerror(errno)); return 1; } @@ -3837,16 +3974,17 @@ static int load_super_imsm(struct supertype *st, int fd, char *devname) } /* load migration record */ - load_imsm_migr_rec(super, NULL); - - /* Check for unsupported migration features */ - if (check_mpb_migr_compatibility(super) != 0) { - fprintf(stderr, Name ": Unsupported migration detected"); - if (devname) - fprintf(stderr, " on %s\n", devname); - else - fprintf(stderr, " (IMSM).\n"); - return 3; + if (load_imsm_migr_rec(super, NULL) == 0) { + /* Check for unsupported migration features */ + if (check_mpb_migr_compatibility(super) != 0) { + fprintf(stderr, + Name ": Unsupported migration detected"); + if (devname) + fprintf(stderr, " on %s\n", devname); + else + fprintf(stderr, " (IMSM).\n"); + return 3; + } } return 0; @@ -4199,7 +4337,7 @@ static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk, devname); return 1; } - set_imsm_ord_tbl_ent(map, dk->number, dl->index); + set_imsm_ord_tbl_ent(map, dk->raid_disk, dl->index); dl->disk.status = CONFIGURED_DISK; /* if we are creating the first raid device update the family number */ @@ -4219,7 +4357,7 @@ static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk, mpb->family_num = __cpu_to_le32(sum); mpb->orig_family_num = mpb->family_num; } - + super->current_disk = dl; return 0; } @@ -4385,8 +4523,6 @@ static int write_super_imsm_spares(struct intel_super *super, int doclose) return 0; } -static int is_gen_migration(struct imsm_dev *dev); - static int write_super_imsm(struct supertype *st, int doclose) { struct intel_super *super = st->sb; @@ -4458,7 +4594,8 @@ static int write_super_imsm(struct supertype *st, int doclose) get_dev_size(d->fd, NULL, &dsize); if (lseek64(d->fd, dsize - 512, SEEK_SET) >= 0) { - write(d->fd, super->migr_rec_buf, 512); + if (write(d->fd, super->migr_rec_buf, 512) != 512) + perror("Write migr_rec failed"); } } if (doclose) { @@ -4785,6 +4922,15 @@ static int is_raid_level_supported(const struct imsm_orom *orom, int level, int return 0; } +static int imsm_default_chunk(const struct imsm_orom *orom) +{ + /* up to 512 if the plaform supports it, otherwise the platform max. + * 128 if no platform detected + */ + int fs = max(7, orom ? fls(orom->sss) : 0); + + return min(512, (1 << fs)); +} #define pr_vrb(fmt, arg...) (void) (verbose && fprintf(stderr, Name fmt, ##arg)) /* @@ -4813,15 +4959,16 @@ validate_geometry_imsm_orom(struct intel_super *super, int level, int layout, level, raiddisks, raiddisks > 1 ? "s" : ""); return 0; } - if (super->orom && level != 1) { - if (chunk && (*chunk == 0 || *chunk == UnSet)) - *chunk = imsm_orom_default_chunk(super->orom); - else if (chunk && !imsm_orom_has_chunk(super->orom, *chunk)) { - pr_vrb(": platform does not support a chunk size of: " - "%d\n", *chunk); - return 0; - } + + if (chunk && (*chunk == 0 || *chunk == UnSet)) + *chunk = imsm_default_chunk(super->orom); + + if (super->orom && chunk && !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"); @@ -5171,9 +5318,8 @@ static void default_geometry_imsm(struct supertype *st, int *level, int *layout, if (level && layout && *layout == UnSet) *layout = imsm_level_to_layout(*level); - if (chunk && (*chunk == UnSet || *chunk == 0) && - super && super->orom) - *chunk = imsm_orom_default_chunk(super->orom); + if (chunk && (*chunk == UnSet || *chunk == 0)) + *chunk = imsm_default_chunk(super->orom); } static void handle_missing(struct intel_super *super, struct imsm_dev *dev); @@ -5306,6 +5452,9 @@ static int update_subarray_imsm(struct supertype *st, char *subarray, static int is_gen_migration(struct imsm_dev *dev) { + if (dev == NULL) + return 0; + if (!dev->vol.migr_state) return 0; @@ -5366,7 +5515,9 @@ static void update_recovery_start(struct intel_super *super, rebuild->recovery_start = units * blocks_per_migr_unit(super, dev); } +#ifndef MDASSEMBLE static int recover_backup_imsm(struct supertype *st, struct mdinfo *info); +#endif static struct mdinfo *container_content_imsm(struct supertype *st, char *subarray) { @@ -5387,6 +5538,13 @@ static struct mdinfo *container_content_imsm(struct supertype *st, char *subarra struct dl *d; int spare_disks = 0; + /* do not assemble arrays when not all attributes are supported */ + if (imsm_check_attributes(mpb->attributes) == 0) { + fprintf(stderr, Name ": IMSM metadata loading not allowed " + "due to attributes incompatibility.\n"); + return NULL; + } + /* check for bad blocks */ if (imsm_bbm_log_size(super->anchor)) bbm_errors = 1; @@ -5446,11 +5604,10 @@ static struct mdinfo *container_content_imsm(struct supertype *st, char *subarra sizeof(*this)); break; } - memset(this, 0, sizeof(*this)); - this->next = rest; super->current_vol = i; getinfo_super_imsm_volume(st, this, NULL); + this->next = rest; for (slot = 0 ; slot < map->num_members; slot++) { unsigned long long recovery_start; struct mdinfo *info_d; @@ -5531,10 +5688,11 @@ static struct mdinfo *container_content_imsm(struct supertype *st, char *subarra update_recovery_start(super, dev, this); this->array.spare_disks += spare_disks; +#ifndef MDASSEMBLE /* check for reshape */ if (this->reshape_active == 1) recover_backup_imsm(st, this); - +#endif rest = this; } @@ -5850,14 +6008,18 @@ static int imsm_set_array_state(struct active_array *a, int consistent) } else { if (a->last_checkpoint == 0 && a->prev_action == reshape) { /* for some reason we aborted the reshape. - * Better clean up + * + * disable automatic metadata rollback + * user action is required to recover process */ + if (0) { struct imsm_map *map2 = get_imsm_map(dev, 1); dev->vol.migr_state = 0; dev->vol.migr_type = 0; dev->vol.curr_migr_unit = 0; memcpy(map, map2, sizeof_imsm_map(map2)); super->updates_pending++; + } } if (a->last_checkpoint >= a->info.component_size) { unsigned long long array_blocks; @@ -6866,7 +7028,7 @@ static int apply_takeover_update(struct imsm_update_takeover *u, for (du = super->missing; du; du = du->next) if (du->index >= 0) { set_imsm_ord_tbl_ent(map, du->index, du->index); - mark_missing(dev_new, &du->disk, du->index); + mark_missing(dv->dev, &du->disk, du->index); } return 1; @@ -6914,6 +7076,24 @@ static void imsm_process_update(struct supertype *st, mpb = super->anchor; switch (type) { + case update_general_migration_checkpoint: { + struct intel_dev *id; + struct imsm_update_general_migration_checkpoint *u = + (void *)update->buf; + + dprintf("imsm: process_update() " + "for update_general_migration_checkpoint called\n"); + + /* find device under general migration */ + for (id = super->devlist ; id; id = id->next) { + if (is_gen_migration(id->dev)) { + id->dev->vol.curr_migr_unit = + __cpu_to_le32(u->curr_migr_unit); + super->updates_pending++; + } + } + break; + } case update_takeover: { struct imsm_update_takeover *u = (void *)update->buf; if (apply_takeover_update(u, super, &update->space_list)) { @@ -7251,6 +7431,10 @@ static void imsm_prepare_update(struct supertype *st, size_t len = 0; switch (type) { + case update_general_migration_checkpoint: + dprintf("imsm: prepare_update() " + "for update_general_migration_checkpoint called\n"); + break; case update_takeover: { struct imsm_update_takeover *u = (void *)update->buf; if (u->direction == R0_TO_R10) { @@ -7535,7 +7719,7 @@ static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned ind __free_imsm_disk(dl); } } - +#endif /* MDASSEMBLE */ /******************************************************************************* * Function: open_backup_targets * Description: Function opens file descriptors for all devices given in @@ -7575,6 +7759,7 @@ int open_backup_targets(struct mdinfo *info, int raid_disks, int *raid_fds) return 0; } +#ifndef MDASSEMBLE /******************************************************************************* * Function: init_migr_record_imsm * Description: Function inits imsm migration record @@ -7599,10 +7784,7 @@ void init_migr_record_imsm(struct supertype *st, struct imsm_dev *dev, struct imsm_map *map_dest = get_imsm_map(dev, 0); struct imsm_map *map_src = get_imsm_map(dev, 1); unsigned long long num_migr_units; - - unsigned long long array_blocks = - (((unsigned long long)__le32_to_cpu(dev->size_high)) << 32) + - __le32_to_cpu(dev->size_low); + unsigned long long array_blocks; memset(migr_rec, 0, sizeof(struct migr_record)); migr_rec->family_num = __cpu_to_le32(super->anchor->family_num); @@ -7618,7 +7800,7 @@ void init_migr_record_imsm(struct supertype *st, struct imsm_dev *dev, __cpu_to_le32(migr_rec->dest_depth_per_unit * new_data_disks); migr_rec->dest_depth_per_unit = __cpu_to_le32(migr_rec->dest_depth_per_unit); - + array_blocks = info->component_size * new_data_disks; num_migr_units = array_blocks / __le32_to_cpu(migr_rec->blocks_per_unit); @@ -7658,9 +7840,9 @@ void init_migr_record_imsm(struct supertype *st, struct imsm_dev *dev, * and to write it to the Copy Area. * Parameters: * st : supertype information + * dev : imsm device that backup is saved for * info : general array info * buf : input buffer - * write_offset : address of data to backup * length : length of data to backup (blocks_per_unit) * Returns: * 0 : success @@ -7670,7 +7852,6 @@ int save_backup_imsm(struct supertype *st, struct imsm_dev *dev, struct mdinfo *info, void *buf, - int new_data, int length) { int rv = -1; @@ -7680,34 +7861,48 @@ int save_backup_imsm(struct supertype *st, int i; struct imsm_map *map_dest = get_imsm_map(dev, 0); int new_disks = map_dest->num_members; + int dest_layout = 0; + int dest_chunk; + unsigned long long start; + int data_disks = imsm_num_data_members(dev, 0); targets = malloc(new_disks * sizeof(int)); if (!targets) goto abort; + for (i = 0; i < new_disks; i++) + targets[i] = -1; + target_offsets = malloc(new_disks * sizeof(unsigned long long)); if (!target_offsets) goto abort; + start = info->reshape_progress * 512; for (i = 0; i < new_disks; i++) { - targets[i] = -1; target_offsets[i] = (unsigned long long) __le32_to_cpu(super->migr_rec->ckpt_area_pba) * 512; + /* move back copy area adderss, it will be moved forward + * in restore_stripes() using start input variable + */ + target_offsets[i] -= start/data_disks; } if (open_backup_targets(info, new_disks, targets)) goto abort; + dest_layout = imsm_level_to_layout(map_dest->raid_level); + dest_chunk = __le16_to_cpu(map_dest->blocks_per_strip) * 512; + if (restore_stripes(targets, /* list of dest devices */ target_offsets, /* migration record offsets */ new_disks, - info->new_chunk, - info->new_level, - info->new_layout, - -1, /* source backup file descriptor */ - 0, /* input buf offset - * always 0 buf is already offset */ - 0, + dest_chunk, + map_dest->raid_level, + dest_layout, + -1, /* source backup file descriptor */ + 0, /* input buf offset + * always 0 buf is already offseted */ + start, length, buf) != 0) { fprintf(stderr, Name ": Error restoring stripes\n"); @@ -7738,23 +7933,40 @@ abort: * Returns: * 0: success * 1: failure + * 2: failure, means no valid migration record + * / no general migration in progress / ******************************************************************************/ int save_checkpoint_imsm(struct supertype *st, struct mdinfo *info, int state) { struct intel_super *super = st->sb; - load_imsm_migr_rec(super, info); - if (__le32_to_cpu(super->migr_rec->blocks_per_unit) == 0) { - dprintf("ERROR: blocks_per_unit = 0!!!\n"); + unsigned long long blocks_per_unit; + unsigned long long curr_migr_unit; + + if (load_imsm_migr_rec(super, info) != 0) { + dprintf("imsm: ERROR: Cannot read migration record " + "for checkpoint save.\n"); return 1; } + blocks_per_unit = __le32_to_cpu(super->migr_rec->blocks_per_unit); + if (blocks_per_unit == 0) { + dprintf("imsm: no migration in progress.\n"); + return 2; + } + curr_migr_unit = info->reshape_progress / blocks_per_unit; + /* check if array is alligned to copy area + * if it is not alligned, add one to current migration unit value + * this can happend on array reshape finish only + */ + if (info->reshape_progress % blocks_per_unit) + curr_migr_unit++; + super->migr_rec->curr_migr_unit = - __cpu_to_le32(info->reshape_progress / - __le32_to_cpu(super->migr_rec->blocks_per_unit)); + __cpu_to_le32(curr_migr_unit); super->migr_rec->rec_status = __cpu_to_le32(state); super->migr_rec->dest_1st_member_lba = - __cpu_to_le32((__le32_to_cpu(super->migr_rec->curr_migr_unit)) - * __le32_to_cpu(super->migr_rec->dest_depth_per_unit)); + __cpu_to_le32(curr_migr_unit * + __le32_to_cpu(super->migr_rec->dest_depth_per_unit)); if (write_imsm_migr_rec(st) < 0) { dprintf("imsm: Cannot write migration record " "outside backup area\n"); @@ -7764,9 +7976,6 @@ int save_checkpoint_imsm(struct supertype *st, struct mdinfo *info, int state) return 0; } -static __u64 blocks_per_migr_unit(struct intel_super *super, - struct imsm_dev *dev); - /******************************************************************************* * Function: recover_backup_imsm * Description: Function recovers critical data from the Migration Copy Area @@ -7793,8 +8002,9 @@ int recover_backup_imsm(struct supertype *st, struct mdinfo *info) int retval = 1; unsigned long curr_migr_unit = __le32_to_cpu(migr_rec->curr_migr_unit); unsigned long num_migr_units = __le32_to_cpu(migr_rec->num_migr_units); - int ascending = __le32_to_cpu(migr_rec->ascending_migr); char buffer[20]; + int skipped_disks = 0; + int max_degradation; err = sysfs_get_str(info, NULL, "array_state", (char *)buffer, 20); if (err < 1) @@ -7818,13 +8028,14 @@ int recover_backup_imsm(struct supertype *st, struct mdinfo *info) map_dest = get_imsm_map(id->dev, 0); new_disks = map_dest->num_members; + max_degradation = new_disks - imsm_num_data_members(id->dev, 0); read_offset = (unsigned long long) __le32_to_cpu(migr_rec->ckpt_area_pba) * 512; write_offset = ((unsigned long long) __le32_to_cpu(migr_rec->dest_1st_member_lba) + - info->data_offset) * 512; + __le32_to_cpu(map_dest->pba_of_lba0)) * 512; unit_len = __le32_to_cpu(migr_rec->dest_depth_per_unit) * 512; if (posix_memalign((void **)&buf, 512, unit_len) != 0) @@ -7836,13 +8047,17 @@ int recover_backup_imsm(struct supertype *st, struct mdinfo *info) open_backup_targets(info, new_disks, targets); for (i = 0; i < new_disks; i++) { + if (targets[i] < 0) { + skipped_disks++; + continue; + } if (lseek64(targets[i], read_offset, SEEK_SET) < 0) { fprintf(stderr, Name ": Cannot seek to block: %s\n", strerror(errno)); goto abort; } - if (read(targets[i], buf, unit_len) != unit_len) { + if ((unsigned)read(targets[i], buf, unit_len) != unit_len) { fprintf(stderr, Name ": Cannot read copy area block: %s\n", strerror(errno)); @@ -7854,7 +8069,7 @@ int recover_backup_imsm(struct supertype *st, struct mdinfo *info) strerror(errno)); goto abort; } - if (write(targets[i], buf, unit_len) != unit_len) { + if ((unsigned)write(targets[i], buf, unit_len) != unit_len) { fprintf(stderr, Name ": Cannot restore block: %s\n", strerror(errno)); @@ -7862,16 +8077,20 @@ int recover_backup_imsm(struct supertype *st, struct mdinfo *info) } } - if (ascending && curr_migr_unit < (num_migr_units-1)) - curr_migr_unit++; + if (skipped_disks > max_degradation) { + fprintf(stderr, + Name ": Cannot restore data from backup." + " Too many failed disks\n"); + goto abort; + } - migr_rec->curr_migr_unit = __le32_to_cpu(curr_migr_unit); - super->migr_rec->rec_status = __cpu_to_le32(UNIT_SRC_NORMAL); - if (write_imsm_migr_rec(st) == 0) { - __u64 blocks_per_unit = blocks_per_migr_unit(super, id->dev); - info->reshape_progress = curr_migr_unit * blocks_per_unit; + if (save_checkpoint_imsm(st, info, UNIT_SRC_NORMAL)) { + /* ignore error == 2, this can mean end of reshape here + */ + dprintf("imsm: Cannot write checkpoint to " + "migration record (UNIT_SRC_NORMAL) during restart\n"); + } else retval = 0; - } abort: if (targets) { @@ -8101,6 +8320,7 @@ static int imsm_create_metadata_update_for_reshape( || delta_disks > spares->array.spare_disks) { fprintf(stderr, Name ": imsm: ERROR: Cannot get spare devices " "for %s.\n", geo->dev_name); + i = -1; goto abort; } @@ -8252,7 +8472,6 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, int chunk; getinfo_super_imsm_volume(st, &info, NULL); - if ((geo->level != info.array.level) && (geo->level >= 0) && (geo->level != UnSet)) { @@ -8260,6 +8479,14 @@ enum imsm_reshape_type imsm_analyze_change(struct supertype *st, case 0: if (geo->level == 5) { change = CH_MIGRATION; + if (geo->layout != ALGORITHM_LEFT_ASYMMETRIC) { + fprintf(stderr, + Name " Error. Requested Layout " + "not supported (left-asymmetric layout " + "is supported only)!\n"); + change = -1; + goto analyse_change_exit; + } check_devs = 1; } if (geo->level == 10) { @@ -8382,30 +8609,6 @@ int imsm_takeover(struct supertype *st, struct geo_params *geo) return 0; } -static int warn_user_about_risk(void) -{ - int rv = 0; - - fprintf(stderr, - "\nThis is an experimental feature. Data on the RAID volume(s) " - "can be lost!!!\n\n" - "To continue command execution please make sure that\n" - "the grow process will not be interrupted. Use safe power\n" - "supply to avoid unexpected system reboot. Make sure that\n" - "reshaped container is not assembled automatically during\n" - "system boot.\n" - "If reshape is interrupted, assemble array manually\n" - "using e.g. '-Ac' option and up to date mdadm.conf file.\n" - "Assembly in scan mode is not possible in such case.\n" - "Growing container with boot array is not possible.\n" - "If boot array reshape is interrupted, whole file system\n" - "can be lost.\n\n"); - rv = ask("Do you want to continue? "); - fprintf(stderr, "\n"); - - return rv; -} - static int imsm_reshape_super(struct supertype *st, long long size, int level, int layout, int chunksize, int raid_disks, int delta_disks, char *backup, char *dev, @@ -8439,13 +8642,6 @@ static int imsm_reshape_super(struct supertype *st, long long size, int level, dprintf("imsm: info: Container operation\n"); int old_raid_disks = 0; - /* this warning will be removed when imsm checkpointing - * will be implemented, and restoring from check-point - * operation will be transparent for reboot process - */ - if (warn_user_about_risk() == 0) - return ret_val; - if (imsm_reshape_is_allowed_on_container( st, &geo, &old_raid_disks)) { struct imsm_update_reshape *u = NULL; @@ -8484,8 +8680,9 @@ static int imsm_reshape_super(struct supertype *st, long long size, int level, dprintf("imsm: info: Volume operation\n"); /* find requested device */ while (dev) { - imsm_find_array_minor_by_subdev(dev->index, st->container_dev, &devnum); - if (devnum == geo.dev_id) + if (imsm_find_array_minor_by_subdev( + dev->index, st->container_dev, &devnum) == 0 + && devnum == geo.dev_id) break; dev = dev->next; } @@ -8536,56 +8733,66 @@ exit_imsm_reshape_super: * reshape process reach new position * Parameters: * sra : general array info - * to_complete : new sync_max position * ndata : number of disks in new array's layout * Returns: * 0 : success, * 1 : there is no reshape in progress, * -1 : fail ******************************************************************************/ -int wait_for_reshape_imsm(struct mdinfo *sra, unsigned long long to_complete, - int ndata) +int wait_for_reshape_imsm(struct mdinfo *sra, int ndata) { int fd = sysfs_get_fd(sra, NULL, "reshape_position"); unsigned long long completed; + /* to_complete : new sync_max position */ + unsigned long long to_complete = sra->reshape_progress; + unsigned long long position_to_set = to_complete / ndata; - struct timeval timeout; - - if (fd < 0) + if (fd < 0) { + dprintf("imsm: wait_for_reshape_imsm() " + "cannot open reshape_position\n"); return 1; + } - sysfs_fd_get_ll(fd, &completed); + if (sysfs_fd_get_ll(fd, &completed) < 0) { + dprintf("imsm: wait_for_reshape_imsm() " + "cannot read reshape_position (no reshape in progres)\n"); + close(fd); + return 0; + } - if (to_complete == 0) {/* reshape till the end of array */ - sysfs_set_str(sra, NULL, "sync_max", "max"); - to_complete = MaxSector; - } else { - if (completed > to_complete) - return -1; - if (sysfs_set_num(sra, NULL, "sync_max", - to_complete / ndata) != 0) { - close(fd); - return -1; - } + if (completed > to_complete) { + dprintf("imsm: wait_for_reshape_imsm() " + "wrong next position to set %llu (%llu)\n", + to_complete, completed); + close(fd); + return -1; + } + dprintf("Position set: %llu\n", position_to_set); + if (sysfs_set_num(sra, NULL, "sync_max", + position_to_set) != 0) { + dprintf("imsm: wait_for_reshape_imsm() " + "cannot set reshape position to %llu\n", + position_to_set); + close(fd); + return -1; } - /* FIXME should not need a timeout at all */ - timeout.tv_sec = 30; - timeout.tv_usec = 0; do { char action[20]; fd_set rfds; FD_ZERO(&rfds); FD_SET(fd, &rfds); - select(fd+1, NULL, NULL, &rfds, &timeout); + select(fd+1, &rfds, NULL, NULL, NULL); + if (sysfs_get_str(sra, NULL, "sync_action", + action, 20) > 0 && + strncmp(action, "reshape", 7) != 0) + break; if (sysfs_fd_get_ll(fd, &completed) < 0) { + dprintf("imsm: wait_for_reshape_imsm() " + "cannot read reshape_position (in loop)\n"); close(fd); return 1; } - if (sysfs_get_str(sra, NULL, "sync_action", - action, 20) > 0 && - strncmp(action, "reshape", 7) != 0) - break; } while (completed < to_complete); close(fd); return 0; @@ -8669,7 +8876,7 @@ static int imsm_manage_reshape( struct intel_super *super = st->sb; struct intel_dev *dv = NULL; struct imsm_dev *dev = NULL; - struct imsm_map *map_src, *map_dest; + struct imsm_map *map_src; int migr_vol_qan = 0; int ndata, odata; /* [bytes] */ int chunk; /* [bytes] */ @@ -8679,13 +8886,13 @@ static int imsm_manage_reshape( unsigned long long max_position; /* array size [bytes] */ unsigned long long next_step; /* [blocks]/[bytes] */ unsigned long long old_data_stripe_length; - unsigned long long new_data_stripe_length; unsigned long long start_src; /* [bytes] */ unsigned long long start; /* [bytes] */ unsigned long long start_buf_shift; /* [bytes] */ int degraded = 0; + int source_layout = 0; - if (!fds || !offsets || !destfd || !destoffsets || !sra) + if (!fds || !offsets || !sra) goto abort; /* Find volume during the reshape */ @@ -8707,24 +8914,25 @@ static int imsm_manage_reshape( map_src = get_imsm_map(dev, 1); if (map_src == NULL) goto abort; - map_dest = get_imsm_map(dev, 0); ndata = imsm_num_data_members(dev, 0); odata = imsm_num_data_members(dev, 1); - chunk = map_src->blocks_per_strip * 512; + chunk = __le16_to_cpu(map_src->blocks_per_strip) * 512; old_data_stripe_length = odata * chunk; migr_rec = super->migr_rec; - /* [bytes] */ - sra->new_chunk = __le16_to_cpu(map_dest->blocks_per_strip) * 512; - sra->new_level = map_dest->raid_level; - new_data_stripe_length = sra->new_chunk * ndata; - /* initialize migration record for start condition */ if (sra->reshape_progress == 0) init_migr_record_imsm(st, dev, sra); + else { + if (__le32_to_cpu(migr_rec->rec_status) != UNIT_SRC_NORMAL) { + dprintf("imsm: cannot restart migration when data " + "are present in copy area.\n"); + goto abort; + } + } /* size for data */ buf_size = __le32_to_cpu(migr_rec->blocks_per_unit) * 512; @@ -8737,10 +8945,8 @@ static int imsm_manage_reshape( goto abort; } - max_position = - __le32_to_cpu(migr_rec->post_migr_vol_cap) + - ((unsigned long long)__le32_to_cpu( - migr_rec->post_migr_vol_cap_hi) << 32); + max_position = sra->component_size * ndata; + source_layout = imsm_level_to_layout(map_src->raid_level); while (__le32_to_cpu(migr_rec->curr_migr_unit) < __le32_to_cpu(migr_rec->num_migr_units)) { @@ -8764,8 +8970,7 @@ static int imsm_manage_reshape( if ((current_position + next_step) > max_position) next_step = max_position - current_position; - start = (map_src->pba_of_lba0 + dev->reserved_blocks + - current_position) * 512; + start = current_position * 512; /* allign reading start to old geometry */ start_buf_shift = start % old_data_stripe_length; @@ -8798,8 +9003,8 @@ static int imsm_manage_reshape( start_buf_shift, next_step_filler); if (save_stripes(fds, offsets, map_src->num_members, - chunk, sra->array.level, - sra->array.layout, 0, NULL, start_src, + chunk, map_src->raid_level, + source_layout, 0, NULL, start_src, copy_length + next_step_filler + start_buf_shift, buf)) { @@ -8811,8 +9016,7 @@ static int imsm_manage_reshape( * in backup general migration area */ if (save_backup_imsm(st, dev, sra, - buf + start_buf_shift, - ndata, copy_length)) { + buf + start_buf_shift, copy_length)) { dprintf("imsm: Cannot save stripes to " "target devices\n"); goto abort; @@ -8823,28 +9027,32 @@ static int imsm_manage_reshape( "migration record (UNIT_SRC_IN_CP_AREA)\n"); goto abort; } - /* decrease backup_blocks */ - if (backup_blocks > (unsigned long)next_step) - backup_blocks -= next_step; - else - backup_blocks = 0; + } else { + /* set next step to use whole border area */ + border /= next_step; + if (border > 1) + next_step *= border; } /* When data backed up, checkpoint stored, * kick the kernel to reshape unit of data */ next_step = next_step + sra->reshape_progress; + /* limit next step to array max position */ + if (next_step > max_position) + next_step = max_position; sysfs_set_num(sra, NULL, "suspend_lo", sra->reshape_progress); sysfs_set_num(sra, NULL, "suspend_hi", next_step); + sra->reshape_progress = next_step; /* wait until reshape finish */ - if (wait_for_reshape_imsm(sra, next_step, ndata) < 0) { + if (wait_for_reshape_imsm(sra, ndata) < 0) { dprintf("wait_for_reshape_imsm returned error!\n"); goto abort; } - sra->reshape_progress = next_step; - - if (save_checkpoint_imsm(st, sra, UNIT_SRC_NORMAL)) { + if (save_checkpoint_imsm(st, sra, UNIT_SRC_NORMAL) == 1) { + /* ignore error == 2, this can mean end of reshape here + */ dprintf("imsm: Cannot write checkpoint to " "migration record (UNIT_SRC_NORMAL)\n"); goto abort; @@ -8882,6 +9090,7 @@ struct superswitch super_imsm = { .get_disk_controller_domain = imsm_get_disk_controller_domain, .reshape_super = imsm_reshape_super, .manage_reshape = imsm_manage_reshape, + .recover_backup = recover_backup_imsm, #endif .match_home = match_home_imsm, .uuid_from_super= uuid_from_super_imsm, @@ -8901,7 +9110,6 @@ struct superswitch super_imsm = { .match_metadata_desc = match_metadata_desc_imsm, .container_content = container_content_imsm, - .recover_backup = recover_backup_imsm, .external = 1, .name = "imsm",