X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=super-ddf.c;h=bc0ce2c0fd253609d47341666f19ce6093bebf86;hb=47c4331d1fe9c68e9d8dd0a7d94ee8e70b285a0b;hp=bff420cd784b6af836f0e094b5da4c1d55d44bd7;hpb=f5ded78768f691e6a401185f8aef00b0c92967d7;p=thirdparty%2Fmdadm.git diff --git a/super-ddf.c b/super-ddf.c index bff420cd..bc0ce2c0 100644 --- a/super-ddf.c +++ b/super-ddf.c @@ -1,7 +1,7 @@ /* * mdadm - manage Linux "md" devices aka RAID arrays. * - * Copyright (C) 2006-2009 Neil Brown + * Copyright (C) 2006-2014 Neil Brown * * * This program is free software; you can redistribute it and/or modify @@ -21,7 +21,7 @@ * Author: Neil Brown * Email: * - * Specifications for DDF takes from Common RAID DDF Specification Revision 1.2 + * Specifications for DDF taken from Common RAID DDF Specification Revision 1.2 * (July 28 2006). Reused by permission of SNIA. */ @@ -30,6 +30,7 @@ #include "mdmon.h" #include "sha1.h" #include +#include /* a non-official T10 name for creation GUIDs */ static char T10[] = "Linux-MD"; @@ -47,6 +48,10 @@ unsigned long crc32( #define DDF_NOTFOUND (~0U) #define DDF_CONTAINER (DDF_NOTFOUND-1) +/* Default for safe_mode_delay. Same value as for IMSM. + */ +static const int DDF_SAFE_MODE_DELAY = 4000; + /* The DDF metadata handling. * DDF metadata lives at the end of the device. * The last 512 byte block provides an 'anchor' which is used to locate @@ -58,6 +63,46 @@ unsigned long crc32( * */ +typedef struct __be16 { + __u16 _v16; +} be16; +#define be16_eq(x, y) ((x)._v16 == (y)._v16) +#define be16_and(x, y) ((x)._v16 & (y)._v16) +#define be16_or(x, y) ((x)._v16 | (y)._v16) +#define be16_clear(x, y) ((x)._v16 &= ~(y)._v16) +#define be16_set(x, y) ((x)._v16 |= (y)._v16) + +typedef struct __be32 { + __u32 _v32; +} be32; +#define be32_eq(x, y) ((x)._v32 == (y)._v32) + +typedef struct __be64 { + __u64 _v64; +} be64; +#define be64_eq(x, y) ((x)._v64 == (y)._v64) + +#define be16_to_cpu(be) __be16_to_cpu((be)._v16) +static inline be16 cpu_to_be16(__u16 x) +{ + be16 be = { ._v16 = __cpu_to_be16(x) }; + return be; +} + +#define be32_to_cpu(be) __be32_to_cpu((be)._v32) +static inline be32 cpu_to_be32(__u32 x) +{ + be32 be = { ._v32 = __cpu_to_be32(x) }; + return be; +} + +#define be64_to_cpu(be) __be64_to_cpu((be)._v64) +static inline be64 cpu_to_be64(__u64 x) +{ + be64 be = { ._v64 = __cpu_to_be64(x) }; + return be; +} + /* Primary Raid Level (PRL) */ #define DDF_RAID0 0x00 #define DDF_RAID1 0x01 @@ -95,28 +140,28 @@ unsigned long crc32( #define DDF_2SPANNED 0x03 /* This is also weird - be careful */ /* Magic numbers */ -#define DDF_HEADER_MAGIC __cpu_to_be32(0xDE11DE11) -#define DDF_CONTROLLER_MAGIC __cpu_to_be32(0xAD111111) -#define DDF_PHYS_RECORDS_MAGIC __cpu_to_be32(0x22222222) -#define DDF_PHYS_DATA_MAGIC __cpu_to_be32(0x33333333) -#define DDF_VIRT_RECORDS_MAGIC __cpu_to_be32(0xDDDDDDDD) -#define DDF_VD_CONF_MAGIC __cpu_to_be32(0xEEEEEEEE) -#define DDF_SPARE_ASSIGN_MAGIC __cpu_to_be32(0x55555555) -#define DDF_VU_CONF_MAGIC __cpu_to_be32(0x88888888) -#define DDF_VENDOR_LOG_MAGIC __cpu_to_be32(0x01dBEEF0) -#define DDF_BBM_LOG_MAGIC __cpu_to_be32(0xABADB10C) +#define DDF_HEADER_MAGIC cpu_to_be32(0xDE11DE11) +#define DDF_CONTROLLER_MAGIC cpu_to_be32(0xAD111111) +#define DDF_PHYS_RECORDS_MAGIC cpu_to_be32(0x22222222) +#define DDF_PHYS_DATA_MAGIC cpu_to_be32(0x33333333) +#define DDF_VIRT_RECORDS_MAGIC cpu_to_be32(0xDDDDDDDD) +#define DDF_VD_CONF_MAGIC cpu_to_be32(0xEEEEEEEE) +#define DDF_SPARE_ASSIGN_MAGIC cpu_to_be32(0x55555555) +#define DDF_VU_CONF_MAGIC cpu_to_be32(0x88888888) +#define DDF_VENDOR_LOG_MAGIC cpu_to_be32(0x01dBEEF0) +#define DDF_BBM_LOG_MAGIC cpu_to_be32(0xABADB10C) #define DDF_GUID_LEN 24 #define DDF_REVISION_0 "01.00.00" #define DDF_REVISION_2 "01.02.00" struct ddf_header { - __u32 magic; /* DDF_HEADER_MAGIC */ - __u32 crc; + be32 magic; /* DDF_HEADER_MAGIC */ + be32 crc; char guid[DDF_GUID_LEN]; char revision[8]; /* 01.02.00 */ - __u32 seq; /* starts at '1' */ - __u32 timestamp; + be32 seq; /* starts at '1' */ + be32 timestamp; __u8 openflag; __u8 foreignflag; __u8 enforcegroups; @@ -124,38 +169,38 @@ struct ddf_header { __u8 pad1[12]; /* 12 * 0xff */ /* 64 bytes so far */ __u8 header_ext[32]; /* reserved: fill with 0xff */ - __u64 primary_lba; - __u64 secondary_lba; + be64 primary_lba; + be64 secondary_lba; __u8 type; __u8 pad2[3]; /* 0xff */ - __u32 workspace_len; /* sectors for vendor space - + be32 workspace_len; /* sectors for vendor space - * at least 32768(sectors) */ - __u64 workspace_lba; - __u16 max_pd_entries; /* one of 15, 63, 255, 1023, 4095 */ - __u16 max_vd_entries; /* 2^(4,6,8,10,12)-1 : i.e. as above */ - __u16 max_partitions; /* i.e. max num of configuration + be64 workspace_lba; + be16 max_pd_entries; /* one of 15, 63, 255, 1023, 4095 */ + be16 max_vd_entries; /* 2^(4,6,8,10,12)-1 : i.e. as above */ + be16 max_partitions; /* i.e. max num of configuration record entries per disk */ - __u16 config_record_len; /* 1 +ROUNDUP(max_primary_element_entries + be16 config_record_len; /* 1 +ROUNDUP(max_primary_element_entries *12/512) */ - __u16 max_primary_element_entries; /* 16, 64, 256, 1024, or 4096 */ + be16 max_primary_element_entries; /* 16, 64, 256, 1024, or 4096 */ __u8 pad3[54]; /* 0xff */ /* 192 bytes so far */ - __u32 controller_section_offset; - __u32 controller_section_length; - __u32 phys_section_offset; - __u32 phys_section_length; - __u32 virt_section_offset; - __u32 virt_section_length; - __u32 config_section_offset; - __u32 config_section_length; - __u32 data_section_offset; - __u32 data_section_length; - __u32 bbm_section_offset; - __u32 bbm_section_length; - __u32 diag_space_offset; - __u32 diag_space_length; - __u32 vendor_offset; - __u32 vendor_length; + be32 controller_section_offset; + be32 controller_section_length; + be32 phys_section_offset; + be32 phys_section_length; + be32 virt_section_offset; + be32 virt_section_length; + be32 config_section_offset; + be32 config_section_length; + be32 data_section_offset; + be32 data_section_length; + be32 bbm_section_offset; + be32 bbm_section_length; + be32 diag_space_offset; + be32 diag_space_length; + be32 vendor_offset; + be32 vendor_length; /* 256 bytes so far */ __u8 pad4[256]; /* 0xff */ }; @@ -167,14 +212,14 @@ struct ddf_header { /* The content of the 'controller section' - global scope */ struct ddf_controller_data { - __u32 magic; /* DDF_CONTROLLER_MAGIC */ - __u32 crc; + be32 magic; /* DDF_CONTROLLER_MAGIC */ + be32 crc; char guid[DDF_GUID_LEN]; struct controller_type { - __u16 vendor_id; - __u16 device_id; - __u16 sub_vendor_id; - __u16 sub_device_id; + be16 vendor_id; + be16 device_id; + be16 sub_vendor_id; + be16 sub_device_id; } type; char product_id[16]; __u8 pad[8]; /* 0xff */ @@ -183,18 +228,21 @@ struct ddf_controller_data { /* The content of phys_section - global scope */ struct phys_disk { - __u32 magic; /* DDF_PHYS_RECORDS_MAGIC */ - __u32 crc; - __u16 used_pdes; - __u16 max_pdes; + be32 magic; /* DDF_PHYS_RECORDS_MAGIC */ + be32 crc; + be16 used_pdes; /* This is a counter, not a max - the list + * of used entries may not be dense */ + be16 max_pdes; __u8 pad[52]; struct phys_disk_entry { char guid[DDF_GUID_LEN]; - __u32 refnum; - __u16 type; - __u16 state; - __u64 config_size; /* DDF structures must be after here */ - char path[18]; /* another horrible structure really */ + be32 refnum; + be16 type; + be16 state; + be64 config_size; /* DDF structures must be after here */ + char path[18]; /* Another horrible structure really + * but is "used for information + * purposes only" */ __u8 pad[6]; } entries[0]; }; @@ -224,17 +272,17 @@ struct phys_disk { /* The content of the virt_section global scope */ struct virtual_disk { - __u32 magic; /* DDF_VIRT_RECORDS_MAGIC */ - __u32 crc; - __u16 populated_vdes; - __u16 max_vdes; + be32 magic; /* DDF_VIRT_RECORDS_MAGIC */ + be32 crc; + be16 populated_vdes; + be16 max_vdes; __u8 pad[52]; struct virtual_entry { char guid[DDF_GUID_LEN]; - __u16 unit; + be16 unit; __u16 pad0; /* 0xffff */ - __u16 guid_crc; - __u16 type; + be16 guid_crc; + be16 type; __u8 state; __u8 init_state; __u8 pad1[14]; @@ -278,25 +326,28 @@ struct virtual_disk { */ struct vd_config { - __u32 magic; /* DDF_VD_CONF_MAGIC */ - __u32 crc; + be32 magic; /* DDF_VD_CONF_MAGIC */ + be32 crc; char guid[DDF_GUID_LEN]; - __u32 timestamp; - __u32 seqnum; + be32 timestamp; + be32 seqnum; __u8 pad0[24]; - __u16 prim_elmnt_count; + be16 prim_elmnt_count; __u8 chunk_shift; /* 0 == 512, 1==1024 etc */ __u8 prl; __u8 rlq; __u8 sec_elmnt_count; __u8 sec_elmnt_seq; __u8 srl; - __u64 blocks; /* blocks per component could be different + be64 blocks; /* blocks per component could be different * on different component devices...(only * for concat I hope) */ - __u64 array_blocks; /* blocks in array */ + be64 array_blocks; /* blocks in array */ __u8 pad1[8]; - __u32 spare_refs[8]; + be32 spare_refs[8]; /* This is used to detect missing spares. + * As we don't have an interface for that + * the values are ignored. + */ __u8 cache_pol[8]; __u8 bg_rate; __u8 pad2[3]; @@ -307,11 +358,11 @@ struct vd_config { __u8 v2[16]; /* reserved- 0xff */ __u8 v3[16]; /* reserved- 0xff */ __u8 vendor[32]; - __u32 phys_refnum[0]; /* refnum of each disk in sequence */ + be32 phys_refnum[0]; /* refnum of each disk in sequence */ /*__u64 lba_offset[0]; LBA offset in each phys. Note extents in a bvd are always the same size */ }; -#define LBA_OFFSET(ddf, vd) ((__u64 *) &(vd)->phys_refnum[(ddf)->mppe]) +#define LBA_OFFSET(ddf, vd) ((be64 *) &(vd)->phys_refnum[(ddf)->mppe]) /* vd_config.cache_pol[7] is a bitmap */ #define DDF_cache_writeback 1 /* else writethrough */ @@ -323,17 +374,17 @@ struct vd_config { #define DDF_cache_rallowed 64 /* enable read caching */ struct spare_assign { - __u32 magic; /* DDF_SPARE_ASSIGN_MAGIC */ - __u32 crc; - __u32 timestamp; + be32 magic; /* DDF_SPARE_ASSIGN_MAGIC */ + be32 crc; + be32 timestamp; __u8 reserved[7]; __u8 type; - __u16 populated; /* SAEs used */ - __u16 max; /* max SAEs */ + be16 populated; /* SAEs used */ + be16 max; /* max SAEs */ __u8 pad[8]; struct spare_assign_entry { char guid[DDF_GUID_LEN]; - __u16 secondary_element; + be16 secondary_element; __u8 pad[6]; } spare_ents[0]; }; @@ -345,10 +396,10 @@ struct spare_assign { /* The data_section contents - local scope */ struct disk_data { - __u32 magic; /* DDF_PHYS_DATA_MAGIC */ - __u32 crc; + be32 magic; /* DDF_PHYS_DATA_MAGIC */ + be32 crc; char guid[DDF_GUID_LEN]; - __u32 refnum; /* crc of some magic drive data ... */ + be32 refnum; /* crc of some magic drive data ... */ __u8 forced_ref; /* set when above was not result of magic */ __u8 forced_guid; /* set if guid was forced rather than magic */ __u8 vendor[32]; @@ -357,16 +408,16 @@ struct disk_data { /* bbm_section content */ struct bad_block_log { - __u32 magic; - __u32 crc; - __u16 entry_count; - __u32 spare_count; + be32 magic; + be32 crc; + be16 entry_count; + be32 spare_count; __u8 pad[10]; - __u64 first_spare; + be64 first_spare; struct mapped_block { - __u64 defective_start; - __u32 replacement_start; - __u16 remap_count; + be64 defective_start; + be32 replacement_start; + be16 remap_count; __u8 pad[2]; } entries[0]; }; @@ -388,27 +439,34 @@ struct bad_block_log { * and reconstructed for writing. This means that we only need * to make config changes once and they are automatically * propagated to all devices. - * Note that the ddf_super has space of the conf and disk data - * for this disk and also for a list of all such data. - * The list is only used for the superblock that is being - * built in Create or Assemble to describe the whole array. + * The global (config and disk data) records are each in a list + * of separate data structures. When writing we find the entry + * or entries applicable to the particular device. */ struct ddf_super { - struct ddf_header anchor, primary, secondary; + struct ddf_header anchor, primary, secondary; struct ddf_controller_data controller; - struct ddf_header *active; + struct ddf_header *active; struct phys_disk *phys; struct virtual_disk *virt; - int pdsize, vdsize; - unsigned int max_part, mppe, conf_rec_len; - int currentdev; - int updates_pending; + char *conf; + int pdsize, vdsize; + unsigned int max_part, mppe, conf_rec_len; + int currentdev; + int updates_pending; struct vcl { union { char space[512]; struct { struct vcl *next; unsigned int vcnum; /* index into ->virt */ + /* For an array with a secondary level there are + * multiple vd_config structures, all with the same + * guid but with different sec_elmnt_seq. + * One of these structures is in 'conf' below. + * The others are in other_bvds, not in any + * particular order. + */ struct vd_config **other_bvds; __u64 *block_sizes; /* NULL if all the same */ }; @@ -424,9 +482,9 @@ struct ddf_super { char *devname; int fd; unsigned long long size; /* sectors */ - unsigned long long primary_lba; /* sectors */ - unsigned long long secondary_lba; /* sectors */ - unsigned long long workspace_lba; /* sectors */ + be64 primary_lba; /* sectors */ + be64 secondary_lba; /* sectors */ + be64 workspace_lba; /* sectors */ int pdnum; /* index in ->phys */ struct spare_assign *spare; void *mdupdate; /* hold metadata update */ @@ -434,6 +492,7 @@ struct ddf_super { /* These fields used by auto-layout */ int raiddisk; /* slot to fill in autolayout */ __u64 esize; + int displayed; }; }; struct disk_data disk; @@ -441,17 +500,49 @@ struct ddf_super { } *dlist, *add_list; }; -#ifndef offsetof -#define offsetof(t,f) ((size_t)&(((t*)0)->f)) +#ifndef MDASSEMBLE +static int load_super_ddf_all(struct supertype *st, int fd, + void **sbp, char *devname); +static int get_svd_state(const struct ddf_super *, const struct vcl *); +static int +validate_geometry_ddf_container(struct supertype *st, + int level, int layout, int raiddisks, + int chunk, unsigned long long size, + unsigned long long data_offset, + char *dev, unsigned long long *freesize, + int verbose); + +static int validate_geometry_ddf_bvd(struct supertype *st, + int level, int layout, int raiddisks, + int *chunk, unsigned long long size, + unsigned long long data_offset, + char *dev, unsigned long long *freesize, + int verbose); #endif -#if DEBUG +static void free_super_ddf(struct supertype *st); static int all_ff(const char *guid); +static unsigned int get_pd_index_from_refnum(const struct vcl *vc, + be32 refnum, unsigned int nmax, + const struct vd_config **bvd, + unsigned int *idx); +static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map); +static void uuid_from_ddf_guid(const char *guid, int uuid[4]); +static void uuid_from_super_ddf(struct supertype *st, int uuid[4]); +static void _ddf_array_name(char *name, const struct ddf_super *ddf, int i); +static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map); +static int init_super_ddf_bvd(struct supertype *st, + mdu_array_info_t *info, + unsigned long long size, + char *name, char *homehost, + int *uuid, unsigned long long data_offset); + +#if DEBUG static void pr_state(struct ddf_super *ddf, const char *msg) { unsigned int i; dprintf("%s/%s: ", __func__, msg); - for (i = 0; i < __be16_to_cpu(ddf->active->max_vd_entries); i++) { + for (i = 0; i < be16_to_cpu(ddf->active->max_vd_entries); i++) { if (all_ff(ddf->virt->entries[i].guid)) continue; dprintf("%u(s=%02x i=%02x) ", i, @@ -464,28 +555,36 @@ static void pr_state(struct ddf_super *ddf, const char *msg) static void pr_state(const struct ddf_super *ddf, const char *msg) {} #endif -#define ddf_set_updates_pending(x) \ - do { (x)->updates_pending = 1; pr_state(x, __func__); } while (0) +static void _ddf_set_updates_pending(struct ddf_super *ddf, struct vd_config *vc, + const char *func) +{ + if (vc) { + vc->timestamp = cpu_to_be32(time(0)-DECADE); + vc->seqnum = cpu_to_be32(be32_to_cpu(vc->seqnum) + 1); + } + if (ddf->updates_pending) + return; + ddf->updates_pending = 1; + ddf->active->seq = cpu_to_be32((be32_to_cpu(ddf->active->seq)+1)); + pr_state(ddf, func); +} -static unsigned int get_pd_index_from_refnum(const struct vcl *vc, - __u32 refnum, unsigned int nmax, - const struct vd_config **bvd, - unsigned int *idx); +#define ddf_set_updates_pending(x,v) _ddf_set_updates_pending((x), (v), __func__) -static unsigned int calc_crc(void *buf, int len) +static be32 calc_crc(void *buf, int len) { /* crcs are always at the same place as in the ddf_header */ struct ddf_header *ddf = buf; - __u32 oldcrc = ddf->crc; + be32 oldcrc = ddf->crc; __u32 newcrc; - ddf->crc = 0xffffffff; + ddf->crc = cpu_to_be32(0xffffffff); newcrc = crc32(0, buf, len); ddf->crc = oldcrc; - /* The crc is store (like everything) bigendian, so convert + /* The crc is stored (like everything) bigendian, so convert * here for simplicity */ - return __cpu_to_be32(newcrc); + return cpu_to_be32(newcrc); } #define DDF_INVALID_LEVEL 0xff @@ -494,13 +593,13 @@ static int err_bad_md_layout(const mdu_array_info_t *array) { pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n", array->level, array->layout, array->raid_disks); - return DDF_INVALID_LEVEL; + return -1; } static int layout_md2ddf(const mdu_array_info_t *array, struct vd_config *conf) { - __u16 prim_elmnt_count = __cpu_to_be16(array->raid_disks); + be16 prim_elmnt_count = cpu_to_be16(array->raid_disks); __u8 prl = DDF_INVALID_LEVEL, rlq = 0; __u8 sec_elmnt_count = 1; __u8 srl = DDF_NO_SECONDARY; @@ -569,17 +668,25 @@ static int layout_md2ddf(const mdu_array_info_t *array, case 10: if (array->raid_disks % 2 == 0 && array->layout == 0x102) { rlq = DDF_RAID1_SIMPLE; - prim_elmnt_count = __cpu_to_be16(2); + prim_elmnt_count = cpu_to_be16(2); sec_elmnt_count = array->raid_disks / 2; + srl = DDF_2SPANNED; + prl = DDF_RAID1; } else if (array->raid_disks % 3 == 0 && array->layout == 0x103) { rlq = DDF_RAID1_MULTI; - prim_elmnt_count = __cpu_to_be16(3); + prim_elmnt_count = cpu_to_be16(3); sec_elmnt_count = array->raid_disks / 3; + srl = DDF_2SPANNED; + prl = DDF_RAID1; + } else if (array->layout == 0x201) { + prl = DDF_RAID1E; + rlq = DDF_RAID1E_OFFSET; + } else if (array->layout == 0x102) { + prl = DDF_RAID1E; + rlq = DDF_RAID1E_ADJACENT; } else return err_bad_md_layout(array); - srl = DDF_2SPANNED; - prl = DDF_RAID1; break; default: return err_bad_md_layout(array); @@ -595,7 +702,7 @@ static int layout_md2ddf(const mdu_array_info_t *array, static int err_bad_ddf_layout(const struct vd_config *conf) { pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n", - conf->prl, conf->rlq, __be16_to_cpu(conf->prim_elmnt_count)); + conf->prl, conf->rlq, be16_to_cpu(conf->prim_elmnt_count)); return -1; } @@ -604,7 +711,7 @@ static int layout_ddf2md(const struct vd_config *conf, { int level = LEVEL_UNSUPPORTED; int layout = 0; - int raiddisks = __be16_to_cpu(conf->prim_elmnt_count); + int raiddisks = be16_to_cpu(conf->prim_elmnt_count); if (conf->sec_elmnt_count > 1) { /* see also check_secondary() */ @@ -640,6 +747,15 @@ static int layout_ddf2md(const struct vd_config *conf, return err_bad_ddf_layout(conf); level = 1; break; + case DDF_RAID1E: + if (conf->rlq == DDF_RAID1E_ADJACENT) + layout = 0x102; + else if (conf->rlq == DDF_RAID1E_OFFSET) + layout = 0x201; + else + return err_bad_ddf_layout(conf); + level = 10; + break; case DDF_RAID4: if (conf->rlq != DDF_RAID4_N) return err_bad_ddf_layout(conf); @@ -708,28 +824,34 @@ static int load_ddf_header(int fd, unsigned long long lba, if (read(fd, hdr, 512) != 512) return 0; - if (hdr->magic != DDF_HEADER_MAGIC) + if (!be32_eq(hdr->magic, DDF_HEADER_MAGIC)) { + pr_err("%s: bad header magic\n", __func__); return 0; - if (calc_crc(hdr, 512) != hdr->crc) + } + if (!be32_eq(calc_crc(hdr, 512), hdr->crc)) { + pr_err("%s: bad CRC\n", __func__); return 0; + } if (memcmp(anchor->guid, hdr->guid, DDF_GUID_LEN) != 0 || memcmp(anchor->revision, hdr->revision, 8) != 0 || - anchor->primary_lba != hdr->primary_lba || - anchor->secondary_lba != hdr->secondary_lba || + !be64_eq(anchor->primary_lba, hdr->primary_lba) || + !be64_eq(anchor->secondary_lba, hdr->secondary_lba) || hdr->type != type || memcmp(anchor->pad2, hdr->pad2, 512 - - offsetof(struct ddf_header, pad2)) != 0) + offsetof(struct ddf_header, pad2)) != 0) { + pr_err("%s: header mismatch\n", __func__); return 0; + } /* Looks good enough to me... */ return 1; } static void *load_section(int fd, struct ddf_super *super, void *buf, - __u32 offset_be, __u32 len_be, int check) + be32 offset_be, be32 len_be, int check) { - unsigned long long offset = __be32_to_cpu(offset_be); - unsigned long long len = __be32_to_cpu(len_be); + unsigned long long offset = be32_to_cpu(offset_be); + unsigned long long len = be32_to_cpu(len_be); int dofree = (buf == NULL); if (check) @@ -739,20 +861,16 @@ static void *load_section(int fd, struct ddf_super *super, void *buf, if (len > 1024) return NULL; - if (buf) { - /* All pre-allocated sections are a single block */ - if (len != 1) - return NULL; - } else if (posix_memalign(&buf, 512, len<<9) != 0) + if (!buf && posix_memalign(&buf, 512, len<<9) != 0) buf = NULL; if (!buf) return NULL; if (super->active->type == 1) - offset += __be64_to_cpu(super->active->primary_lba); + offset += be64_to_cpu(super->active->primary_lba); else - offset += __be64_to_cpu(super->active->secondary_lba); + offset += be64_to_cpu(super->active->secondary_lba); if ((unsigned long long)lseek64(fd, offset<<9, 0) != (offset<<9)) { if (dofree) @@ -785,13 +903,13 @@ static int load_ddf_headers(int fd, struct ddf_super *super, char *devname) devname, strerror(errno)); return 1; } - if (super->anchor.magic != DDF_HEADER_MAGIC) { + if (!be32_eq(super->anchor.magic, DDF_HEADER_MAGIC)) { if (devname) pr_err("no DDF anchor found on %s\n", devname); return 2; } - if (calc_crc(&super->anchor, 512) != super->anchor.crc) { + if (!be32_eq(calc_crc(&super->anchor, 512), super->anchor.crc)) { if (devname) pr_err("bad CRC on anchor on %s\n", devname); @@ -806,7 +924,7 @@ static int load_ddf_headers(int fd, struct ddf_super *super, char *devname) return 2; } super->active = NULL; - if (load_ddf_header(fd, __be64_to_cpu(super->anchor.primary_lba), + if (load_ddf_header(fd, be64_to_cpu(super->anchor.primary_lba), dsize >> 9, 1, &super->primary, &super->anchor) == 0) { if (devname) @@ -814,19 +932,21 @@ static int load_ddf_headers(int fd, struct ddf_super *super, char *devname) "on %s\n", devname); } else super->active = &super->primary; - if (load_ddf_header(fd, __be64_to_cpu(super->anchor.secondary_lba), + + if (load_ddf_header(fd, be64_to_cpu(super->anchor.secondary_lba), dsize >> 9, 2, &super->secondary, &super->anchor)) { - if ((__be32_to_cpu(super->primary.seq) - < __be32_to_cpu(super->secondary.seq) && - !super->secondary.openflag) - || (__be32_to_cpu(super->primary.seq) - == __be32_to_cpu(super->secondary.seq) && + if (super->active == NULL + || (be32_to_cpu(super->primary.seq) + < be32_to_cpu(super->secondary.seq) && + !super->secondary.openflag) + || (be32_to_cpu(super->primary.seq) + == be32_to_cpu(super->secondary.seq) && super->primary.openflag && !super->secondary.openflag) - || super->active == NULL ) super->active = &super->secondary; - } else if (devname) + } else if (devname && + be64_to_cpu(super->anchor.secondary_lba) != ~(__u64)0) pr_err("Failed to load secondary DDF header on %s\n", devname); if (super->active == NULL) @@ -845,13 +965,13 @@ static int load_ddf_global(int fd, struct ddf_super *super, char *devname) super->active->phys_section_offset, super->active->phys_section_length, 1); - super->pdsize = __be32_to_cpu(super->active->phys_section_length) * 512; + super->pdsize = be32_to_cpu(super->active->phys_section_length) * 512; super->virt = load_section(fd, super, NULL, super->active->virt_section_offset, super->active->virt_section_length, 1); - super->vdsize = __be32_to_cpu(super->active->virt_section_length) * 512; + super->vdsize = be32_to_cpu(super->active->virt_section_length) * 512; if (!ok || !super->phys || !super->virt) { @@ -864,9 +984,9 @@ static int load_ddf_global(int fd, struct ddf_super *super, char *devname) super->conflist = NULL; super->dlist = NULL; - super->max_part = __be16_to_cpu(super->active->max_partitions); - super->mppe = __be16_to_cpu(super->active->max_primary_element_entries); - super->conf_rec_len = __be16_to_cpu(super->active->config_record_len); + super->max_part = be16_to_cpu(super->active->max_partitions); + super->mppe = be16_to_cpu(super->active->max_primary_element_entries); + super->conf_rec_len = be16_to_cpu(super->active->config_record_len); return 0; } @@ -902,7 +1022,8 @@ static void add_other_bvd(struct vcl *vcl, struct vd_config *vd, break; if (i < vcl->conf.sec_elmnt_count-1) { - if (vd->seqnum <= vcl->other_bvds[i]->seqnum) + if (be32_to_cpu(vd->seqnum) <= + be32_to_cpu(vcl->other_bvds[i]->seqnum)) return; } else { for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++) @@ -926,15 +1047,16 @@ static int load_ddf_local(int fd, struct ddf_super *super, unsigned int i; unsigned int confsec; int vnum; - unsigned int max_virt_disks = __be16_to_cpu(super->active->max_vd_entries); + unsigned int max_virt_disks = + be16_to_cpu(super->active->max_vd_entries); unsigned long long dsize; /* First the local disk info */ if (posix_memalign((void**)&dl, 512, - sizeof(*dl) + - (super->max_part) * sizeof(dl->vlist[0])) != 0) { + sizeof(*dl) + + (super->max_part) * sizeof(dl->vlist[0])) != 0) { pr_err("%s could not allocate disk info buffer\n", - __func__); + __func__); return 1; } @@ -965,7 +1087,7 @@ static int load_ddf_local(int fd, struct ddf_super *super, dl->vlist[i] = NULL; super->dlist = dl; dl->pdnum = -1; - for (i = 0; i < __be16_to_cpu(super->active->max_pd_entries); i++) + for (i = 0; i < be16_to_cpu(super->active->max_pd_entries); i++) if (memcmp(super->phys->entries[i].guid, dl->disk.guid, DDF_GUID_LEN) == 0) dl->pdnum = i; @@ -976,24 +1098,24 @@ static int load_ddf_local(int fd, struct ddf_super *super, * the conflist */ - conf = load_section(fd, super, NULL, + conf = load_section(fd, super, super->conf, super->active->config_section_offset, super->active->config_section_length, 0); - + super->conf = conf; vnum = 0; for (confsec = 0; - confsec < __be32_to_cpu(super->active->config_section_length); + confsec < be32_to_cpu(super->active->config_section_length); confsec += super->conf_rec_len) { struct vd_config *vd = (struct vd_config *)((char*)conf + confsec*512); struct vcl *vcl; - if (vd->magic == DDF_SPARE_ASSIGN_MAGIC) { + if (be32_eq(vd->magic, DDF_SPARE_ASSIGN_MAGIC)) { if (dl->spare) continue; if (posix_memalign((void**)&dl->spare, 512, - super->conf_rec_len*512) != 0) { + super->conf_rec_len*512) != 0) { pr_err("%s could not allocate spare info buf\n", __func__); return 1; @@ -1002,8 +1124,10 @@ static int load_ddf_local(int fd, struct ddf_super *super, memcpy(dl->spare, vd, super->conf_rec_len*512); continue; } - if (vd->magic != DDF_VD_CONF_MAGIC) + if (!be32_eq(vd->magic, DDF_VD_CONF_MAGIC)) + /* Must be vendor-unique - I cannot handle those */ continue; + for (vcl = super->conflist; vcl; vcl = vcl->next) { if (memcmp(vcl->conf.guid, vd->guid, DDF_GUID_LEN) == 0) @@ -1017,13 +1141,13 @@ static int load_ddf_local(int fd, struct ddf_super *super, add_other_bvd(vcl, vd, super->conf_rec_len*512); continue; } - if (__be32_to_cpu(vd->seqnum) <= - __be32_to_cpu(vcl->conf.seqnum)) + if (be32_to_cpu(vd->seqnum) <= + be32_to_cpu(vcl->conf.seqnum)) continue; } else { if (posix_memalign((void**)&vcl, 512, - (super->conf_rec_len*512 + - offsetof(struct vcl, conf))) != 0) { + (super->conf_rec_len*512 + + offsetof(struct vcl, conf))) != 0) { pr_err("%s could not allocate vcl buf\n", __func__); return 1; @@ -1048,18 +1172,10 @@ static int load_ddf_local(int fd, struct ddf_super *super, if (i < max_virt_disks) vcl->vcnum = i; } - free(conf); return 0; } -#ifndef MDASSEMBLE -static int load_super_ddf_all(struct supertype *st, int fd, - void **sbp, char *devname); -#endif - -static void free_super_ddf(struct supertype *st); - static int load_super_ddf(struct supertype *st, int fd, char *devname) { @@ -1070,7 +1186,7 @@ static int load_super_ddf(struct supertype *st, int fd, if (get_dev_size(fd, devname, &dsize) == 0) return 1; - if (!st->ignore_hw_compat && test_partition(fd)) + if (test_partition(fd)) /* DDF is not allowed on partitions */ return 1; @@ -1146,6 +1262,7 @@ static void free_super_ddf(struct supertype *st) return; free(ddf->phys); free(ddf->virt); + free(ddf->conf); while (ddf->conflist) { struct vcl *v = ddf->conflist; ddf->conflist = v->next; @@ -1183,7 +1300,7 @@ static void free_super_ddf(struct supertype *st) static struct supertype *match_metadata_desc_ddf(char *arg) { - /* 'ddf' only support containers */ + /* 'ddf' only supports containers */ struct supertype *st; if (strcmp(arg, "ddf") != 0 && strcmp(arg, "default") != 0 @@ -1259,6 +1376,22 @@ static int all_ff(const char *guid) return 1; } +static const char *guid_str(const char *guid) +{ + static char buf[DDF_GUID_LEN*2+1]; + int i; + char *p = buf; + for (i = 0; i < DDF_GUID_LEN; i++) { + unsigned char c = guid[i]; + if (c >= 32 && c < 127) + p += sprintf(p, "%c", c); + else + p += sprintf(p, "%02x", c); + } + *p = '\0'; + return (const char *) buf; +} + #ifndef MDASSEMBLE static void print_guid(char *guid, int tstamp) { @@ -1296,17 +1429,6 @@ static void print_guid(char *guid, int tstamp) printf(")"); } -static const char *guid_str(const char *guid) -{ - static char buf[DDF_GUID_LEN*2+1]; - int i; - char *p = buf; - for (i = 0; i < DDF_GUID_LEN; i++) - p += sprintf(p, "%02x", (unsigned char)guid[i]); - *p = '\0'; - return (const char *) buf; -} - static void examine_vd(int n, struct ddf_super *sb, char *guid) { int crl = sb->conf_rec_len; @@ -1316,25 +1438,27 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid) unsigned int i; struct vd_config *vc = &vcl->conf; - if (calc_crc(vc, crl*512) != vc->crc) + if (!be32_eq(calc_crc(vc, crl*512), vc->crc)) continue; if (memcmp(vc->guid, guid, DDF_GUID_LEN) != 0) continue; /* Ok, we know about this VD, let's give more details */ printf(" Raid Devices[%d] : %d (", n, - __be16_to_cpu(vc->prim_elmnt_count)); - for (i = 0; i < __be16_to_cpu(vc->prim_elmnt_count); i++) { + be16_to_cpu(vc->prim_elmnt_count)); + for (i = 0; i < be16_to_cpu(vc->prim_elmnt_count); i++) { int j; - int cnt = __be16_to_cpu(sb->phys->used_pdes); + int cnt = be16_to_cpu(sb->phys->max_pdes); for (j=0; jphys_refnum[i] == sb->phys->entries[j].refnum) + if (be32_eq(vc->phys_refnum[i], + sb->phys->entries[j].refnum)) break; if (i) printf(" "); if (j < cnt) printf("%d", j); else printf("--"); + printf("@%lluK", (unsigned long long) be64_to_cpu(LBA_OFFSET(sb, vc)[i])/2); } printf(")\n"); if (vc->chunk_shift != 255) @@ -1349,34 +1473,34 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid) map_num(ddf_sec_level, vc->srl) ?: "-unknown-"); } printf(" Device Size[%d] : %llu\n", n, - (unsigned long long)__be64_to_cpu(vc->blocks)/2); + be64_to_cpu(vc->blocks)/2); printf(" Array Size[%d] : %llu\n", n, - (unsigned long long)__be64_to_cpu(vc->array_blocks)/2); + be64_to_cpu(vc->array_blocks)/2); } } static void examine_vds(struct ddf_super *sb) { - int cnt = __be16_to_cpu(sb->virt->populated_vdes); + int cnt = be16_to_cpu(sb->virt->populated_vdes); unsigned int i; printf(" Virtual Disks : %d\n", cnt); - for (i = 0; i < __be16_to_cpu(sb->virt->max_vdes); i++) { + for (i = 0; i < be16_to_cpu(sb->virt->max_vdes); i++) { struct virtual_entry *ve = &sb->virt->entries[i]; if (all_ff(ve->guid)) continue; printf("\n"); printf(" VD GUID[%d] : ", i); print_guid(ve->guid, 1); printf("\n"); - printf(" unit[%d] : %d\n", i, __be16_to_cpu(ve->unit)); + printf(" unit[%d] : %d\n", i, be16_to_cpu(ve->unit)); printf(" state[%d] : %s, %s%s\n", i, map_num(ddf_state, ve->state & 7), - (ve->state & 8) ? "Morphing, ": "", - (ve->state & 16)? "Not Consistent" : "Consistent"); + (ve->state & DDF_state_morphing) ? "Morphing, ": "", + (ve->state & DDF_state_inconsistent)? "Not Consistent" : "Consistent"); printf(" init state[%d] : %s\n", i, - map_num(ddf_init_state, ve->init_state&3)); + map_num(ddf_init_state, ve->init_state&DDF_initstate_mask)); printf(" access[%d] : %s\n", i, - map_num(ddf_access, (ve->init_state>>6) & 3)); + map_num(ddf_access, (ve->init_state & DDF_access_mask) >> 6)); printf(" Name[%d] : %.16s\n", i, ve->name); examine_vd(i, sb, ve->guid); } @@ -1385,25 +1509,32 @@ static void examine_vds(struct ddf_super *sb) static void examine_pds(struct ddf_super *sb) { - int cnt = __be16_to_cpu(sb->phys->used_pdes); + int cnt = be16_to_cpu(sb->phys->max_pdes); int i; struct dl *dl; + int unlisted = 0; printf(" Physical Disks : %d\n", cnt); printf(" Number RefNo Size Device Type/State\n"); + for (dl = sb->dlist; dl; dl = dl->next) + dl->displayed = 0; + for (i=0 ; iphys->entries[i]; - int type = __be16_to_cpu(pd->type); - int state = __be16_to_cpu(pd->state); + int type = be16_to_cpu(pd->type); + int state = be16_to_cpu(pd->state); + if (be32_to_cpu(pd->refnum) == 0xffffffff) + /* Not in use */ + continue; //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0); //printf("\n"); printf(" %3d %08x ", i, - __be32_to_cpu(pd->refnum)); + be32_to_cpu(pd->refnum)); printf("%8lluK ", - (unsigned long long)__be64_to_cpu(pd->config_size)>>1); + be64_to_cpu(pd->config_size)>>1); for (dl = sb->dlist; dl ; dl = dl->next) { - if (dl->disk.refnum == pd->refnum) { + if (be32_eq(dl->disk.refnum, pd->refnum)) { char *dv = map_dev(dl->major, dl->minor, 0); if (dv) { printf("%-15s", dv); @@ -1413,6 +1544,8 @@ static void examine_pds(struct ddf_super *sb) } if (!dl) printf("%15s",""); + else + dl->displayed = 1; printf(" %s%s%s%s%s", (type&2) ? "active":"", (type&4) ? "Global-Spare":"", @@ -1432,30 +1565,39 @@ static void examine_pds(struct ddf_super *sb) (state&64)? ", Missing" : ""); printf("\n"); } + for (dl = sb->dlist; dl; dl = dl->next) { + char *dv; + if (dl->displayed) + continue; + if (!unlisted) + printf(" Physical disks not in metadata!:\n"); + unlisted = 1; + dv = map_dev(dl->major, dl->minor, 0); + printf(" %08x %s\n", be32_to_cpu(dl->disk.refnum), + dv ? dv : "-unknown-"); + } + if (unlisted) + printf("\n"); } static void examine_super_ddf(struct supertype *st, char *homehost) { struct ddf_super *sb = st->sb; - printf(" Magic : %08x\n", __be32_to_cpu(sb->anchor.magic)); + printf(" Magic : %08x\n", be32_to_cpu(sb->anchor.magic)); printf(" Version : %.8s\n", sb->anchor.revision); printf("Controller GUID : "); print_guid(sb->controller.guid, 0); printf("\n"); printf(" Container GUID : "); print_guid(sb->anchor.guid, 1); printf("\n"); - printf(" Seq : %08x\n", __be32_to_cpu(sb->active->seq)); - printf(" Redundant hdr : %s\n", sb->secondary.magic == DDF_HEADER_MAGIC - ?"yes" : "no"); + printf(" Seq : %08x\n", be32_to_cpu(sb->active->seq)); + printf(" Redundant hdr : %s\n", (be32_eq(sb->secondary.magic, + DDF_HEADER_MAGIC) + ?"yes" : "no")); examine_vds(sb); examine_pds(sb); } -static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map); - -static void uuid_from_ddf_guid(const char *guid, int uuid[4]); -static void uuid_from_super_ddf(struct supertype *st, int uuid[4]); - static unsigned int get_vd_num_of_subarray(struct supertype *st) { /* @@ -1481,7 +1623,7 @@ static unsigned int get_vd_num_of_subarray(struct supertype *st) if (sub != NULL) vcnum = strtoul(sub + 1, &end, 10); if (sub == NULL || *sub == '\0' || *end != '\0' || - vcnum >= __be16_to_cpu(ddf->active->max_vd_entries)) + vcnum >= be16_to_cpu(ddf->active->max_vd_entries)) return DDF_NOTFOUND; return vcnum; @@ -1501,7 +1643,8 @@ static void brief_examine_super_ddf(struct supertype *st, int verbose) static void brief_examine_subarrays_ddf(struct supertype *st, int verbose) { - /* We just write a generic DDF ARRAY entry + /* We write a DDF ARRAY member entry for each vd, identifying container + * by uuid and member by unit number and uuid. */ struct ddf_super *ddf = st->sb; struct mdinfo info; @@ -1510,17 +1653,21 @@ static void brief_examine_subarrays_ddf(struct supertype *st, int verbose) getinfo_super_ddf(st, &info, NULL); fname_from_uuid(st, &info, nbuf, ':'); - for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) { + for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) { struct virtual_entry *ve = &ddf->virt->entries[i]; struct vcl vcl; char nbuf1[64]; + char namebuf[17]; if (all_ff(ve->guid)) continue; memcpy(vcl.conf.guid, ve->guid, DDF_GUID_LEN); ddf->currentconf =&vcl; + vcl.vcnum = i; uuid_from_super_ddf(st, info.uuid); fname_from_uuid(st, &info, nbuf1, ':'); - printf("ARRAY container=%s member=%d UUID=%s\n", + _ddf_array_name(namebuf, ddf, i); + printf("ARRAY%s%s container=%s member=%d UUID=%s\n", + namebuf[0] == '\0' ? "" : " /dev/md/", namebuf, nbuf+5, i, nbuf1+5); } } @@ -1534,6 +1681,8 @@ static void export_examine_super_ddf(struct supertype *st) printf("MD_METADATA=ddf\n"); printf("MD_LEVEL=container\n"); printf("MD_UUID=%s\n", nbuf+5); + printf("MD_DEVICES=%u\n", + be16_to_cpu(((struct ddf_super *)st->sb)->phys->used_pdes)); } static int copy_metadata_ddf(struct supertype *st, int from, int to) @@ -1549,7 +1698,7 @@ static int copy_metadata_ddf(struct supertype *st, int from, int to) * So it is easiest to find the earliest of primary and * secondary, and copy everything from there. * - * Anchor is 512 from end It contains primary_lba and secondary_lba + * Anchor is 512 from end. It contains primary_lba and secondary_lba * we choose one of those */ @@ -1564,17 +1713,17 @@ static int copy_metadata_ddf(struct supertype *st, int from, int to) if (read(from, buf, 512) != 512) goto err; ddf = buf; - if (ddf->magic != DDF_HEADER_MAGIC || - calc_crc(ddf, 512) != ddf->crc || + if (!be32_eq(ddf->magic, DDF_HEADER_MAGIC) || + !be32_eq(calc_crc(ddf, 512), ddf->crc) || (memcmp(ddf->revision, DDF_REVISION_0, 8) != 0 && memcmp(ddf->revision, DDF_REVISION_2, 8) != 0)) goto err; offset = dsize - 512; - if ((__be64_to_cpu(ddf->primary_lba) << 9) < offset) - offset = __be64_to_cpu(ddf->primary_lba) << 9; - if ((__be64_to_cpu(ddf->secondary_lba) << 9) < offset) - offset = __be64_to_cpu(ddf->secondary_lba) << 9; + if ((be64_to_cpu(ddf->primary_lba) << 9) < offset) + offset = be64_to_cpu(ddf->primary_lba) << 9; + if ((be64_to_cpu(ddf->secondary_lba) << 9) < offset) + offset = be64_to_cpu(ddf->secondary_lba) << 9; bytes = dsize - offset; @@ -1600,14 +1749,63 @@ err: static void detail_super_ddf(struct supertype *st, char *homehost) { - /* FIXME later - * Could print DDF GUID - * Need to find which array - * If whole, briefly list all arrays - * If one, give name + struct ddf_super *sb = st->sb; + int cnt = be16_to_cpu(sb->virt->populated_vdes); + + printf(" Container GUID : "); print_guid(sb->anchor.guid, 1); + printf("\n"); + printf(" Seq : %08x\n", be32_to_cpu(sb->active->seq)); + printf(" Virtual Disks : %d\n", cnt); + printf("\n"); +} +#endif + +static const char *vendors_with_variable_volume_UUID[] = { + "LSI ", +}; + +static int volume_id_is_reliable(const struct ddf_super *ddf) +{ + int n = ARRAY_SIZE(vendors_with_variable_volume_UUID); + int i; + for (i = 0; i < n; i++) + if (!memcmp(ddf->controller.guid, + vendors_with_variable_volume_UUID[i], 8)) + return 0; + return 1; +} + +static void uuid_of_ddf_subarray(const struct ddf_super *ddf, + unsigned int vcnum, int uuid[4]) +{ + char buf[DDF_GUID_LEN+18], sha[20], *p; + struct sha1_ctx ctx; + if (volume_id_is_reliable(ddf)) { + uuid_from_ddf_guid(ddf->virt->entries[vcnum].guid, uuid); + return; + } + /* + * Some fake RAID BIOSes (in particular, LSI ones) change the + * VD GUID at every boot. These GUIDs are not suitable for + * identifying an array. Luckily the header GUID appears to + * remain constant. + * We construct a pseudo-UUID from the header GUID and those + * properties of the subarray that we expect to remain constant. */ + memset(buf, 0, sizeof(buf)); + p = buf; + memcpy(p, ddf->anchor.guid, DDF_GUID_LEN); + p += DDF_GUID_LEN; + memcpy(p, ddf->virt->entries[vcnum].name, 16); + p += 16; + *((__u16 *) p) = vcnum; + sha1_init_ctx(&ctx); + sha1_process_bytes(buf, sizeof(buf), &ctx); + sha1_finish_ctx(&ctx, sha); + memcpy(uuid, sha, 4*4); } +#ifndef MDASSEMBLE static void brief_detail_super_ddf(struct supertype *st) { struct mdinfo info; @@ -1619,7 +1817,7 @@ static void brief_detail_super_ddf(struct supertype *st) else if (vcnum == DDF_NOTFOUND) return; else - uuid_from_ddf_guid(ddf->virt->entries[vcnum].guid, info.uuid); + uuid_of_ddf_subarray(ddf, vcnum, info.uuid); fname_from_uuid(st, &info, nbuf,':'); printf(" UUID=%s", nbuf + 5); } @@ -1629,7 +1827,8 @@ static int match_home_ddf(struct supertype *st, char *homehost) { /* It matches 'this' host if the controller is a * Linux-MD controller with vendor_data matching - * the hostname + * the hostname. It would be nice if we could + * test against controller found in /sys or somewhere... */ struct ddf_super *ddf = st->sb; unsigned int len; @@ -1650,12 +1849,15 @@ static int find_index_in_bvd(const struct ddf_super *ddf, unsigned int *n_bvd) { /* - * Find the index of the n-th valid physical disk in this BVD + * Find the index of the n-th valid physical disk in this BVD. + * Unused entries can be sprinkled in with the used entries, + * but don't count. */ unsigned int i, j; - for (i = 0, j = 0; i < ddf->mppe && - j < __be16_to_cpu(conf->prim_elmnt_count); i++) { - if (conf->phys_refnum[i] != 0xffffffff) { + for (i = 0, j = 0; + i < ddf->mppe && j < be16_to_cpu(conf->prim_elmnt_count); + i++) { + if (be32_to_cpu(conf->phys_refnum[i]) != 0xffffffff) { if (n == j) { *n_bvd = i; return 1; @@ -1664,10 +1866,17 @@ static int find_index_in_bvd(const struct ddf_super *ddf, } } dprintf("%s: couldn't find BVD member %u (total %u)\n", - __func__, n, __be16_to_cpu(conf->prim_elmnt_count)); + __func__, n, be16_to_cpu(conf->prim_elmnt_count)); return 0; } +/* Given a member array instance number, and a raid disk within that instance, + * find the vd_config structure. The offset of the given disk in the phys_refnum + * table is returned in n_bvd. + * For two-level members with a secondary raid level the vd_config for + * the appropriate BVD is returned. + * The return value is always &vlc->conf, where vlc is returned in last pointer. + */ static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst, unsigned int n, unsigned int *n_bvd, struct vcl **vcl) @@ -1675,7 +1884,7 @@ static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst, struct vcl *v; for (v = ddf->conflist; v; v = v->next) { - unsigned int nsec, ibvd; + unsigned int nsec, ibvd = 0; struct vd_config *conf; if (inst != v->vcnum) continue; @@ -1692,7 +1901,7 @@ static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst, __func__, conf->sec_elmnt_count); goto bad; } - nsec = n / __be16_to_cpu(conf->prim_elmnt_count); + nsec = n / be16_to_cpu(conf->prim_elmnt_count); if (conf->sec_elmnt_seq != nsec) { for (ibvd = 1; ibvd < conf->sec_elmnt_count; ibvd++) { if (v->other_bvds[ibvd-1]->sec_elmnt_seq @@ -1707,7 +1916,7 @@ static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst, n - nsec*conf->sec_elmnt_count, n_bvd)) goto bad; dprintf("%s: found disk %u as member %u in bvd %d of array %u\n" - , __func__, n, *n_bvd, ibvd-1, inst); + , __func__, n, *n_bvd, ibvd, inst); *vcl = v; return conf; } @@ -1717,14 +1926,14 @@ bad: } #endif -static int find_phys(const struct ddf_super *ddf, __u32 phys_refnum) +static int find_phys(const struct ddf_super *ddf, be32 phys_refnum) { /* Find the entry in phys_disk which has the given refnum * and return it's index */ unsigned int i; - for (i = 0; i < __be16_to_cpu(ddf->phys->max_pdes); i++) - if (ddf->phys->entries[i].refnum == phys_refnum) + for (i = 0; i < be16_to_cpu(ddf->phys->max_pdes); i++) + if (be32_eq(ddf->phys->entries[i].refnum, phys_refnum)) return i; return -1; } @@ -1762,17 +1971,13 @@ static void uuid_from_super_ddf(struct supertype *st, int uuid[4]) */ struct ddf_super *ddf = st->sb; struct vcl *vcl = ddf->currentconf; - char *guid; if (vcl) - guid = vcl->conf.guid; + uuid_of_ddf_subarray(ddf, vcl->vcnum, uuid); else - guid = ddf->anchor.guid; - uuid_from_ddf_guid(guid, uuid); + uuid_from_ddf_guid(ddf->anchor.guid, uuid); } -static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map); - static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map) { struct ddf_super *ddf = st->sb; @@ -1785,33 +1990,44 @@ static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *m } memset(info, 0, sizeof(*info)); - info->array.raid_disks = __be16_to_cpu(ddf->phys->used_pdes); + info->array.raid_disks = be16_to_cpu(ddf->phys->used_pdes); info->array.level = LEVEL_CONTAINER; info->array.layout = 0; info->array.md_minor = -1; cptr = (__u32 *)(ddf->anchor.guid + 16); info->array.ctime = DECADE + __be32_to_cpu(*cptr); - info->array.utime = 0; info->array.chunk_size = 0; info->container_enough = 1; - info->disk.major = 0; - info->disk.minor = 0; + info->disk.major = 0; + info->disk.minor = 0; if (ddf->dlist) { - info->disk.number = __be32_to_cpu(ddf->dlist->disk.refnum); + struct phys_disk_entry *pde = NULL; + info->disk.number = be32_to_cpu(ddf->dlist->disk.refnum); info->disk.raid_disk = find_phys(ddf, ddf->dlist->disk.refnum); - info->data_offset = __be64_to_cpu(ddf->phys-> + info->data_offset = be64_to_cpu(ddf->phys-> entries[info->disk.raid_disk]. config_size); info->component_size = ddf->dlist->size - info->data_offset; + if (info->disk.raid_disk >= 0) + pde = ddf->phys->entries + info->disk.raid_disk; + if (pde && + !(be16_to_cpu(pde->state) & DDF_Failed) && + !(be16_to_cpu(pde->state) & DDF_Missing)) + info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE); + else + info->disk.state = 1 << MD_DISK_FAULTY; + } else { + /* There should always be a dlist, but just in case...*/ info->disk.number = -1; info->disk.raid_disk = -1; -// info->disk.raid_disk = find refnum in the table and use index; + info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE); } - info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE); + info->events = be32_to_cpu(ddf->active->seq); + info->array.utime = DECADE + be32_to_cpu(ddf->active->timestamp); info->recovery_start = MaxSector; info->reshape_active = 0; @@ -1826,11 +2042,15 @@ static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *m uuid_from_super_ddf(st, info->uuid); if (map) { - int i; - for (i = 0 ; i < map_disks; i++) { - if (i < info->array.raid_disks && - (__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Online) && - !(__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Failed)) + int i, e = 0; + int max = be16_to_cpu(ddf->phys->max_pdes); + for (i = e = 0 ; i < map_disks ; i++, e++) { + while (e < max && + be32_to_cpu(ddf->phys->entries[e].refnum) == 0xffffffff) + e++; + if (i < info->array.raid_disks && e < max && + !(be16_to_cpu(ddf->phys->entries[e].state) + & DDF_Failed)) map[i] = 1; else map[i] = 0; @@ -1838,6 +2058,17 @@ static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *m } } +/* size of name must be at least 17 bytes! */ +static void _ddf_array_name(char *name, const struct ddf_super *ddf, int i) +{ + int j; + memcpy(name, ddf->virt->entries[i].name, 16); + name[16] = 0; + for(j = 0; j < 16; j++) + if (name[j] == ' ') + name[j] = 0; +} + static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map) { struct ddf_super *ddf = st->sb; @@ -1845,7 +2076,7 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha int cd = ddf->currentdev; int n_prim; int j; - struct dl *dl; + struct dl *dl = NULL; int map_disks = info->array.raid_disks; __u32 *cptr; struct vd_config *conf; @@ -1856,12 +2087,12 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha info->array.md_minor = -1; cptr = (__u32 *)(vc->conf.guid + 16); info->array.ctime = DECADE + __be32_to_cpu(*cptr); - info->array.utime = DECADE + __be32_to_cpu(vc->conf.timestamp); + info->array.utime = DECADE + be32_to_cpu(vc->conf.timestamp); info->array.chunk_size = 512 << vc->conf.chunk_shift; - info->custom_array_size = 0; + info->custom_array_size = be64_to_cpu(vc->conf.array_blocks); conf = &vc->conf; - n_prim = __be16_to_cpu(conf->prim_elmnt_count); + n_prim = be16_to_cpu(conf->prim_elmnt_count); if (conf->sec_elmnt_count > 1 && cd >= n_prim) { int ibvd = cd / n_prim - 1; cd %= n_prim; @@ -1870,26 +2101,32 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha if (cd >= 0 && (unsigned)cd < ddf->mppe) { info->data_offset = - __be64_to_cpu(LBA_OFFSET(ddf, &vc->conf)[cd]); + be64_to_cpu(LBA_OFFSET(ddf, conf)[cd]); if (vc->block_sizes) info->component_size = vc->block_sizes[cd]; else - info->component_size = __be64_to_cpu(vc->conf.blocks); - } + info->component_size = be64_to_cpu(conf->blocks); - for (dl = ddf->dlist; dl ; dl = dl->next) - if (dl->disk.refnum == conf->phys_refnum[cd]) - break; + for (dl = ddf->dlist; dl ; dl = dl->next) + if (be32_eq(dl->disk.refnum, conf->phys_refnum[cd])) + break; + } info->disk.major = 0; info->disk.minor = 0; info->disk.state = 0; - if (dl) { + if (dl && dl->pdnum >= 0) { info->disk.major = dl->major; info->disk.minor = dl->minor; - info->disk.raid_disk = dl->raiddisk; + info->disk.raid_disk = cd + conf->sec_elmnt_seq + * be16_to_cpu(conf->prim_elmnt_count); info->disk.number = dl->pdnum; - info->disk.state = (1<disk.state = 0; + if (info->disk.number >= 0 && + (be16_to_cpu(ddf->phys->entries[info->disk.number].state) & DDF_Online) && + !(be16_to_cpu(ddf->phys->entries[info->disk.number].state) & DDF_Failed)) + info->disk.state = (1<events = be32_to_cpu(ddf->active->seq); } info->container_member = ddf->currentconf->vcnum; @@ -1912,13 +2149,9 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha sprintf(info->text_version, "/%s/%d", st->container_devnm, info->container_member); - info->safe_mode_delay = 200; + info->safe_mode_delay = DDF_SAFE_MODE_DELAY; - memcpy(info->name, ddf->virt->entries[info->container_member].name, 16); - info->name[16]=0; - for(j=0; j<16; j++) - if (info->name[j] == ' ') - info->name[j] = 0; + _ddf_array_name(info->name, ddf, info->container_member); if (map) for (j = 0; j < map_disks; j++) { @@ -1926,8 +2159,10 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha if (j < info->array.raid_disks) { int i = find_phys(ddf, vc->conf.phys_refnum[j]); if (i >= 0 && - (__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Online) && - !(__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Failed)) + (be16_to_cpu(ddf->phys->entries[i].state) + & DDF_Online) && + !(be16_to_cpu(ddf->phys->entries[i].state) + & DDF_Failed)) map[i] = 1; } } @@ -1968,7 +2203,7 @@ static int update_super_ddf(struct supertype *st, struct mdinfo *info, // struct virtual_entry *ve = find_ve(ddf); /* we don't need to handle "force-*" or "assemble" as - * there is no need to 'trick' the kernel. We the metadata is + * there is no need to 'trick' the kernel. When the metadata is * first updated to activate the array, all the implied modifications * will just happen. */ @@ -2004,7 +2239,7 @@ static int update_super_ddf(struct supertype *st, struct mdinfo *info, static void make_header_guid(char *guid) { - __u32 stamp; + be32 stamp; /* Create a DDF Header of Virtual Disk GUID */ /* 24 bytes of fiction required. @@ -2013,20 +2248,20 @@ static void make_header_guid(char *guid) * Remaining 8 random number plus timestamp */ memcpy(guid, T10, sizeof(T10)); - stamp = __cpu_to_be32(0xdeadbeef); + stamp = cpu_to_be32(0xdeadbeef); memcpy(guid+8, &stamp, 4); - stamp = __cpu_to_be32(0); + stamp = cpu_to_be32(0); memcpy(guid+12, &stamp, 4); - stamp = __cpu_to_be32(time(0) - DECADE); + stamp = cpu_to_be32(time(0) - DECADE); memcpy(guid+16, &stamp, 4); - stamp = random32(); + stamp._v32 = random32(); memcpy(guid+20, &stamp, 4); } static unsigned int find_unused_vde(const struct ddf_super *ddf) { unsigned int i; - for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) { + for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) { if (all_ff(ddf->virt->entries[i].guid)) return i; } @@ -2039,7 +2274,7 @@ static unsigned int find_vde_by_name(const struct ddf_super *ddf, unsigned int i; if (name == NULL) return DDF_NOTFOUND; - for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) { + for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) { if (all_ff(ddf->virt->entries[i].guid)) continue; if (!strncmp(name, ddf->virt->entries[i].name, @@ -2049,23 +2284,19 @@ static unsigned int find_vde_by_name(const struct ddf_super *ddf, return DDF_NOTFOUND; } +#ifndef MDASSEMBLE static unsigned int find_vde_by_guid(const struct ddf_super *ddf, const char *guid) { unsigned int i; if (guid == NULL || all_ff(guid)) return DDF_NOTFOUND; - for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) + for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) if (!memcmp(ddf->virt->entries[i].guid, guid, DDF_GUID_LEN)) return i; return DDF_NOTFOUND; } - -static int init_super_ddf_bvd(struct supertype *st, - mdu_array_info_t *info, - unsigned long long size, - char *name, char *homehost, - int *uuid, unsigned long long data_offset); +#endif static int init_super_ddf(struct supertype *st, mdu_array_info_t *info, @@ -2083,12 +2314,12 @@ static int init_super_ddf(struct supertype *st, * We need to create the entire 'ddf' structure which includes: * DDF headers - these are easy. * Controller data - a Sector describing this controller .. not that - * this is a controller exactly. + * this is a controller exactly. * Physical Disk Record - one entry per device, so - * leave plenty of space. + * leave plenty of space. * Virtual Disk Records - again, just leave plenty of space. - * This just lists VDs, doesn't give details - * Config records - describes the VDs that use this disk + * This just lists VDs, doesn't give details. + * Config records - describe the VDs that use this disk * DiskData - describes 'this' device. * BadBlockManagement - empty * Diag Space - empty @@ -2106,11 +2337,6 @@ static int init_super_ddf(struct supertype *st, struct phys_disk *pd; struct virtual_disk *vd; - if (data_offset != INVALID_SECTORS) { - pr_err("data-offset not supported by DDF\n"); - return 0; - } - if (st->sb) return init_super_ddf_bvd(st, info, size, name, homehost, uuid, data_offset); @@ -2120,8 +2346,6 @@ static int init_super_ddf(struct supertype *st, return 0; } memset(ddf, 0, sizeof(*ddf)); - ddf->dlist = NULL; /* no physical disks yet */ - ddf->conflist = NULL; /* No virtual disks yet */ st->sb = ddf; if (info == NULL) { @@ -2133,45 +2357,44 @@ static int init_super_ddf(struct supertype *st, * start 32MB from the end, and put the primary header there. * Don't do secondary for now. * We don't know exactly where that will be yet as it could be - * different on each device. To just set up the lengths. - * + * different on each device. So just set up the lengths. */ ddf->anchor.magic = DDF_HEADER_MAGIC; make_header_guid(ddf->anchor.guid); memcpy(ddf->anchor.revision, DDF_REVISION_2, 8); - ddf->anchor.seq = __cpu_to_be32(1); - ddf->anchor.timestamp = __cpu_to_be32(time(0) - DECADE); + ddf->anchor.seq = cpu_to_be32(1); + ddf->anchor.timestamp = cpu_to_be32(time(0) - DECADE); ddf->anchor.openflag = 0xFF; ddf->anchor.foreignflag = 0; ddf->anchor.enforcegroups = 0; /* Is this best?? */ ddf->anchor.pad0 = 0xff; memset(ddf->anchor.pad1, 0xff, 12); memset(ddf->anchor.header_ext, 0xff, 32); - ddf->anchor.primary_lba = ~(__u64)0; - ddf->anchor.secondary_lba = ~(__u64)0; + ddf->anchor.primary_lba = cpu_to_be64(~(__u64)0); + ddf->anchor.secondary_lba = cpu_to_be64(~(__u64)0); ddf->anchor.type = DDF_HEADER_ANCHOR; memset(ddf->anchor.pad2, 0xff, 3); - ddf->anchor.workspace_len = __cpu_to_be32(32768); /* Must be reserved */ - ddf->anchor.workspace_lba = ~(__u64)0; /* Put this at bottom - of 32M reserved.. */ - max_phys_disks = 1023; /* Should be enough */ - ddf->anchor.max_pd_entries = __cpu_to_be16(max_phys_disks); - max_virt_disks = 255; - ddf->anchor.max_vd_entries = __cpu_to_be16(max_virt_disks); /* ?? */ - ddf->anchor.max_partitions = __cpu_to_be16(64); /* ?? */ + ddf->anchor.workspace_len = cpu_to_be32(32768); /* Must be reserved */ + /* Put this at bottom of 32M reserved.. */ + ddf->anchor.workspace_lba = cpu_to_be64(~(__u64)0); + max_phys_disks = 1023; /* Should be enough, 4095 is also allowed */ + ddf->anchor.max_pd_entries = cpu_to_be16(max_phys_disks); + max_virt_disks = 255; /* 15, 63, 255, 1024, 4095 are all allowed */ + ddf->anchor.max_vd_entries = cpu_to_be16(max_virt_disks); ddf->max_part = 64; - ddf->mppe = 256; + ddf->anchor.max_partitions = cpu_to_be16(ddf->max_part); + ddf->mppe = 256; /* 16, 64, 256, 1024, 4096 are all allowed */ ddf->conf_rec_len = 1 + ROUND_UP(ddf->mppe * (4+8), 512)/512; - ddf->anchor.config_record_len = __cpu_to_be16(ddf->conf_rec_len); - ddf->anchor.max_primary_element_entries = __cpu_to_be16(ddf->mppe); + ddf->anchor.config_record_len = cpu_to_be16(ddf->conf_rec_len); + ddf->anchor.max_primary_element_entries = cpu_to_be16(ddf->mppe); memset(ddf->anchor.pad3, 0xff, 54); - /* controller sections is one sector long immediately + /* Controller section is one sector long immediately * after the ddf header */ sector = 1; - ddf->anchor.controller_section_offset = __cpu_to_be32(sector); - ddf->anchor.controller_section_length = __cpu_to_be32(1); + ddf->anchor.controller_section_offset = cpu_to_be32(sector); + ddf->anchor.controller_section_length = cpu_to_be32(1); sector += 1; /* phys is 8 sectors after that */ @@ -2182,9 +2405,9 @@ static int init_super_ddf(struct supertype *st, case 2: case 8: case 32: case 128: case 512: break; default: abort(); } - ddf->anchor.phys_section_offset = __cpu_to_be32(sector); + ddf->anchor.phys_section_offset = cpu_to_be32(sector); ddf->anchor.phys_section_length = - __cpu_to_be32(pdsize/512); /* max_primary_element_entries/8 */ + cpu_to_be32(pdsize/512); /* max_primary_element_entries/8 */ sector += pdsize/512; /* virt is another 32 sectors */ @@ -2195,26 +2418,26 @@ static int init_super_ddf(struct supertype *st, case 2: case 8: case 32: case 128: case 512: break; default: abort(); } - ddf->anchor.virt_section_offset = __cpu_to_be32(sector); + ddf->anchor.virt_section_offset = cpu_to_be32(sector); ddf->anchor.virt_section_length = - __cpu_to_be32(vdsize/512); /* max_vd_entries/8 */ + cpu_to_be32(vdsize/512); /* max_vd_entries/8 */ sector += vdsize/512; clen = ddf->conf_rec_len * (ddf->max_part+1); - ddf->anchor.config_section_offset = __cpu_to_be32(sector); - ddf->anchor.config_section_length = __cpu_to_be32(clen); + ddf->anchor.config_section_offset = cpu_to_be32(sector); + ddf->anchor.config_section_length = cpu_to_be32(clen); sector += clen; - ddf->anchor.data_section_offset = __cpu_to_be32(sector); - ddf->anchor.data_section_length = __cpu_to_be32(1); + ddf->anchor.data_section_offset = cpu_to_be32(sector); + ddf->anchor.data_section_length = cpu_to_be32(1); sector += 1; - ddf->anchor.bbm_section_length = __cpu_to_be32(0); - ddf->anchor.bbm_section_offset = __cpu_to_be32(0xFFFFFFFF); - ddf->anchor.diag_space_length = __cpu_to_be32(0); - ddf->anchor.diag_space_offset = __cpu_to_be32(0xFFFFFFFF); - ddf->anchor.vendor_length = __cpu_to_be32(0); - ddf->anchor.vendor_offset = __cpu_to_be32(0xFFFFFFFF); + ddf->anchor.bbm_section_length = cpu_to_be32(0); + ddf->anchor.bbm_section_offset = cpu_to_be32(0xFFFFFFFF); + ddf->anchor.diag_space_length = cpu_to_be32(0); + ddf->anchor.diag_space_offset = cpu_to_be32(0xFFFFFFFF); + ddf->anchor.vendor_length = cpu_to_be32(0); + ddf->anchor.vendor_offset = cpu_to_be32(0xFFFFFFFF); memset(ddf->anchor.pad4, 0xff, 256); @@ -2243,10 +2466,10 @@ static int init_super_ddf(struct supertype *st, for (i = strlen(T10) ; i+hostlen < 24; i++) ddf->controller.guid[i] = ' '; - ddf->controller.type.vendor_id = __cpu_to_be16(0xDEAD); - ddf->controller.type.device_id = __cpu_to_be16(0xBEEF); - ddf->controller.type.sub_vendor_id = 0; - ddf->controller.type.sub_device_id = 0; + ddf->controller.type.vendor_id = cpu_to_be16(0xDEAD); + ddf->controller.type.device_id = cpu_to_be16(0xBEEF); + ddf->controller.type.sub_vendor_id = cpu_to_be16(0); + ddf->controller.type.sub_device_id = cpu_to_be16(0); memcpy(ddf->controller.product_id, "What Is My PID??", 16); memset(ddf->controller.pad, 0xff, 8); memset(ddf->controller.vendor_data, 0xff, 448); @@ -2263,8 +2486,8 @@ static int init_super_ddf(struct supertype *st, memset(pd, 0xff, pdsize); memset(pd, 0, sizeof(*pd)); pd->magic = DDF_PHYS_RECORDS_MAGIC; - pd->used_pdes = __cpu_to_be16(0); - pd->max_pdes = __cpu_to_be16(max_phys_disks); + pd->used_pdes = cpu_to_be16(0); + pd->max_pdes = cpu_to_be16(max_phys_disks); memset(pd->pad, 0xff, 52); for (i = 0; i < max_phys_disks; i++) memset(pd->entries[i].guid, 0xff, DDF_GUID_LEN); @@ -2277,15 +2500,15 @@ static int init_super_ddf(struct supertype *st, ddf->vdsize = vdsize; memset(vd, 0, vdsize); vd->magic = DDF_VIRT_RECORDS_MAGIC; - vd->populated_vdes = __cpu_to_be16(0); - vd->max_vdes = __cpu_to_be16(max_virt_disks); + vd->populated_vdes = cpu_to_be16(0); + vd->max_vdes = cpu_to_be16(max_virt_disks); memset(vd->pad, 0xff, 52); for (i=0; ientries[i], 0xff, sizeof(struct virtual_entry)); st->sb = ddf; - ddf_set_updates_pending(ddf); + ddf_set_updates_pending(ddf, NULL); return 1; } @@ -2311,16 +2534,21 @@ static int cmp_extent(const void *av, const void *bv) static struct extent *get_extents(struct ddf_super *ddf, struct dl *dl) { - /* find a list of used extents on the give physical device + /* Find a list of used extents on the given physical device * (dnum) of the given ddf. * Return a malloced array of 'struct extent' - - * FIXME ignore DDF_Legacy devices? - */ struct extent *rv; int n = 0; unsigned int i; + __u16 state; + + if (dl->pdnum < 0) + return NULL; + state = be16_to_cpu(ddf->phys->entries[dl->pdnum].state); + + if ((state & (DDF_Online|DDF_Failed|DDF_Missing)) != DDF_Online) + return NULL; rv = xmalloc(sizeof(struct extent) * (ddf->max_part + 2)); @@ -2332,16 +2560,64 @@ static struct extent *get_extents(struct ddf_super *ddf, struct dl *dl) get_pd_index_from_refnum(v, dl->disk.refnum, ddf->mppe, &bvd, &ibvd) == DDF_NOTFOUND) continue; - rv[n].start = __be64_to_cpu(LBA_OFFSET(ddf, bvd)[ibvd]); - rv[n].size = __be64_to_cpu(bvd->blocks); + rv[n].start = be64_to_cpu(LBA_OFFSET(ddf, bvd)[ibvd]); + rv[n].size = be64_to_cpu(bvd->blocks); n++; } qsort(rv, n, sizeof(*rv), cmp_extent); - rv[n].start = __be64_to_cpu(ddf->phys->entries[dl->pdnum].config_size); + rv[n].start = be64_to_cpu(ddf->phys->entries[dl->pdnum].config_size); rv[n].size = 0; return rv; } + +static unsigned long long find_space( + struct ddf_super *ddf, struct dl *dl, + unsigned long long data_offset, + unsigned long long *size) +{ + /* Find if the requested amount of space is available. + * If it is, return start. + * If not, set *size to largest space. + * If data_offset != INVALID_SECTORS, then the space must start + * at this location. + */ + struct extent *e = get_extents(ddf, dl); + int i = 0; + unsigned long long pos = 0; + unsigned long long max_size = 0; + + if (!e) { + *size = 0; + return INVALID_SECTORS; + } + do { + unsigned long long esize = e[i].start - pos; + if (data_offset != INVALID_SECTORS && + pos <= data_offset && + e[i].start > data_offset) { + pos = data_offset; + esize = e[i].start - pos; + } + if (data_offset != INVALID_SECTORS && + pos != data_offset) { + i++; + continue; + } + if (esize >= *size) { + /* Found! */ + free(e); + return pos; + } + if (esize > max_size) + max_size = esize; + pos = e[i].start + e[i].size; + i++; + } while (e[i-1].size); + *size = max_size; + free(e); + return INVALID_SECTORS; +} #endif static int init_super_ddf_bvd(struct supertype *st, @@ -2375,10 +2651,11 @@ static int init_super_ddf_bvd(struct supertype *st, * timestamp, random number */ make_header_guid(ve->guid); - ve->unit = __cpu_to_be16(info->md_minor); + ve->unit = cpu_to_be16(info->md_minor); ve->pad0 = 0xFFFF; - ve->guid_crc = crc32(0, (unsigned char*)ddf->anchor.guid, DDF_GUID_LEN); - ve->type = 0; + ve->guid_crc._v16 = crc32(0, (unsigned char *)ddf->anchor.guid, + DDF_GUID_LEN); + ve->type = cpu_to_be16(0); ve->state = DDF_state_degraded; /* Will be modified as devices are added */ if (info->state & 1) /* clean */ ve->init_state = DDF_init_full; @@ -2390,7 +2667,7 @@ static int init_super_ddf_bvd(struct supertype *st, if (name) strncpy(ve->name, name, 16); ddf->virt->populated_vdes = - __cpu_to_be16(__be16_to_cpu(ddf->virt->populated_vdes)+1); + cpu_to_be16(be16_to_cpu(ddf->virt->populated_vdes)+1); /* Now create a new vd_config */ if (posix_memalign((void**)&vcl, 512, @@ -2404,12 +2681,12 @@ static int init_super_ddf_bvd(struct supertype *st, vc->magic = DDF_VD_CONF_MAGIC; memcpy(vc->guid, ve->guid, DDF_GUID_LEN); - vc->timestamp = __cpu_to_be32(time(0)-DECADE); - vc->seqnum = __cpu_to_be32(1); + vc->timestamp = cpu_to_be32(time(0)-DECADE); + vc->seqnum = cpu_to_be32(1); memset(vc->pad0, 0xff, 24); vc->chunk_shift = chunk_to_shift(info->chunk_size); if (layout_md2ddf(info, vc) == -1 || - __be16_to_cpu(vc->prim_elmnt_count) > ddf->mppe) { + be16_to_cpu(vc->prim_elmnt_count) > ddf->mppe) { pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n", __func__, info->level, info->layout, info->raid_disks); free(vcl); @@ -2422,19 +2699,19 @@ static int init_super_ddf_bvd(struct supertype *st, free(vcl); return 0; } - vc->blocks = __cpu_to_be64(info->size * 2); - vc->array_blocks = __cpu_to_be64( + vc->blocks = cpu_to_be64(info->size * 2); + vc->array_blocks = cpu_to_be64( calc_array_size(info->level, info->raid_disks, info->layout, info->chunk_size, info->size*2)); memset(vc->pad1, 0xff, 8); - vc->spare_refs[0] = 0xffffffff; - vc->spare_refs[1] = 0xffffffff; - vc->spare_refs[2] = 0xffffffff; - vc->spare_refs[3] = 0xffffffff; - vc->spare_refs[4] = 0xffffffff; - vc->spare_refs[5] = 0xffffffff; - vc->spare_refs[6] = 0xffffffff; - vc->spare_refs[7] = 0xffffffff; + vc->spare_refs[0] = cpu_to_be32(0xffffffff); + vc->spare_refs[1] = cpu_to_be32(0xffffffff); + vc->spare_refs[2] = cpu_to_be32(0xffffffff); + vc->spare_refs[3] = cpu_to_be32(0xffffffff); + vc->spare_refs[4] = cpu_to_be32(0xffffffff); + vc->spare_refs[5] = cpu_to_be32(0xffffffff); + vc->spare_refs[6] = cpu_to_be32(0xffffffff); + vc->spare_refs[7] = cpu_to_be32(0xffffffff); memset(vc->cache_pol, 0, 8); vc->bg_rate = 0x80; memset(vc->pad2, 0xff, 3); @@ -2457,17 +2734,16 @@ static int init_super_ddf_bvd(struct supertype *st, vcl->next = ddf->conflist; ddf->conflist = vcl; ddf->currentconf = vcl; - ddf_set_updates_pending(ddf); + ddf_set_updates_pending(ddf, NULL); return 1; } -static int get_svd_state(const struct ddf_super *, const struct vcl *); - #ifndef MDASSEMBLE static void add_to_super_ddf_bvd(struct supertype *st, - mdu_disk_info_t *dk, int fd, char *devname) + mdu_disk_info_t *dk, int fd, char *devname, + unsigned long long data_offset) { - /* fd and devname identify a device with-in the ddf container (st). + /* fd and devname identify a device within the ddf container (st). * dk identifies a location in the new BVD. * We need to find suitable free space in that device and update * the phys_refnum and lba_offset for the newly created vd_config. @@ -2481,8 +2757,7 @@ static void add_to_super_ddf_bvd(struct supertype *st, struct ddf_super *ddf = st->sb; struct vd_config *vc; unsigned int i; - unsigned long long blocks, pos, esize; - struct extent *ex; + unsigned long long blocks, pos; unsigned int raid_disk = dk->raid_disk; if (fd == -1) { @@ -2495,41 +2770,28 @@ static void add_to_super_ddf_bvd(struct supertype *st, dl->minor == dk->minor) break; } - if (!dl || ! (dk->state & (1<pdnum < 0 || ! (dk->state & (1<currentconf->conf; if (vc->sec_elmnt_count > 1) { - unsigned int n = __be16_to_cpu(vc->prim_elmnt_count); + unsigned int n = be16_to_cpu(vc->prim_elmnt_count); if (raid_disk >= n) vc = ddf->currentconf->other_bvds[raid_disk / n - 1]; raid_disk %= n; } - ex = get_extents(ddf, dl); - if (!ex) - return; - - i = 0; pos = 0; - blocks = __be64_to_cpu(vc->blocks); + blocks = be64_to_cpu(vc->blocks); if (ddf->currentconf->block_sizes) blocks = ddf->currentconf->block_sizes[dk->raid_disk]; - do { - esize = ex[i].start - pos; - if (esize >= blocks) - break; - pos = ex[i].start + ex[i].size; - i++; - } while (ex[i-1].size); - - free(ex); - if (esize < blocks) + pos = find_space(ddf, dl, data_offset, &blocks); + if (pos == INVALID_SECTORS) return; ddf->currentdev = dk->raid_disk; vc->phys_refnum[raid_disk] = dl->disk.refnum; - LBA_OFFSET(ddf, vc)[raid_disk] = __cpu_to_be64(pos); + LBA_OFFSET(ddf, vc)[raid_disk] = cpu_to_be64(pos); for (i = 0; i < ddf->max_part ; i++) if (dl->vlist[i] == NULL) @@ -2548,22 +2810,55 @@ static void add_to_super_ddf_bvd(struct supertype *st, ddf->virt->entries[i].state = (ddf->virt->entries[i].state & ~DDF_state_mask) | get_svd_state(ddf, ddf->currentconf); - ddf->phys->entries[dl->pdnum].type &= ~__cpu_to_be16(DDF_Global_Spare); - ddf->phys->entries[dl->pdnum].type |= __cpu_to_be16(DDF_Active_in_VD); - ddf_set_updates_pending(ddf); + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + be16_set(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD)); + dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n", + __func__, dl->pdnum, be32_to_cpu(dl->disk.refnum), + ddf->currentconf->vcnum, guid_str(vc->guid), + dk->raid_disk); + ddf_set_updates_pending(ddf, vc); } static unsigned int find_unused_pde(const struct ddf_super *ddf) { unsigned int i; - for (i = 0; i < __be16_to_cpu(ddf->phys->max_pdes); i++) { + for (i = 0; i < be16_to_cpu(ddf->phys->max_pdes); i++) { if (all_ff(ddf->phys->entries[i].guid)) return i; } return DDF_NOTFOUND; } -/* add a device to a container, either while creating it or while +static void _set_config_size(struct phys_disk_entry *pde, const struct dl *dl) +{ + __u64 cfs, t; + cfs = min(dl->size - 32*1024*2ULL, be64_to_cpu(dl->primary_lba)); + t = be64_to_cpu(dl->secondary_lba); + if (t != ~(__u64)0) + cfs = min(cfs, t); + /* + * Some vendor DDF structures interpret workspace_lba + * very differently than we do: Make a sanity check on the value. + */ + t = be64_to_cpu(dl->workspace_lba); + if (t < cfs) { + __u64 wsp = cfs - t; + if (wsp > 1024*1024*2ULL && wsp > dl->size / 16) { + pr_err("%s: %x:%x: workspace size 0x%llx too big, ignoring\n", + __func__, dl->major, dl->minor, + (unsigned long long)wsp); + } else + cfs = t; + } + pde->config_size = cpu_to_be64(cfs); + dprintf("%s: %x:%x config_size %llx, DDF structure is %llx blocks\n", + __func__, dl->major, dl->minor, + (unsigned long long)cfs, (unsigned long long)(dl->size-cfs)); +} + +/* Add a device to a container, either while creating it or while * expanding a pre-existing container */ static int add_to_super_ddf(struct supertype *st, @@ -2581,7 +2876,7 @@ static int add_to_super_ddf(struct supertype *st, __u32 *tptr; if (ddf->currentconf) { - add_to_super_ddf_bvd(st, dk, fd, devname); + add_to_super_ddf_bvd(st, dk, fd, devname, data_offset); return 0; } @@ -2627,10 +2922,11 @@ static int add_to_super_ddf(struct supertype *st, do { /* Cannot be bothered finding a CRC of some irrelevant details*/ - dd->disk.refnum = random32(); - for (i = __be16_to_cpu(ddf->active->max_pd_entries); + dd->disk.refnum._v32 = random32(); + for (i = be16_to_cpu(ddf->active->max_pd_entries); i > 0; i--) - if (ddf->phys->entries[i-1].refnum == dd->disk.refnum) + if (be32_eq(ddf->phys->entries[i-1].refnum, + dd->disk.refnum)) break; } while (i > 0); @@ -2651,17 +2947,17 @@ static int add_to_super_ddf(struct supertype *st, pd = xmalloc(len); pd->magic = DDF_PHYS_RECORDS_MAGIC; - pd->used_pdes = __cpu_to_be16(n); + pd->used_pdes = cpu_to_be16(n); pde = &pd->entries[0]; dd->mdupdate = pd; } else - ddf->phys->used_pdes = __cpu_to_be16( - 1 + __be16_to_cpu(ddf->phys->used_pdes)); + ddf->phys->used_pdes = cpu_to_be16( + 1 + be16_to_cpu(ddf->phys->used_pdes)); memcpy(pde->guid, dd->disk.guid, DDF_GUID_LEN); pde->refnum = dd->disk.refnum; - pde->type = __cpu_to_be16(DDF_Forced_PD_GUID | DDF_Global_Spare); - pde->state = __cpu_to_be16(DDF_Online); + pde->type = cpu_to_be16(DDF_Forced_PD_GUID | DDF_Global_Spare); + pde->state = cpu_to_be16(DDF_Online); dd->size = size; /* * If there is already a device in dlist, try to reserve the same @@ -2671,18 +2967,20 @@ static int add_to_super_ddf(struct supertype *st, #define __calc_lba(new, old, lba, mb) do { \ unsigned long long dif; \ if ((old) != NULL) \ - dif = (old)->size - __be64_to_cpu((old)->lba); \ + dif = (old)->size - be64_to_cpu((old)->lba); \ else \ dif = (new)->size; \ if ((new)->size > dif) \ - (new)->lba = __cpu_to_be64((new)->size - dif); \ + (new)->lba = cpu_to_be64((new)->size - dif); \ else \ - (new)->lba = __cpu_to_be64((new)->size - (mb*1024*2)); \ + (new)->lba = cpu_to_be64((new)->size - (mb*1024*2)); \ } while (0) __calc_lba(dd, ddf->dlist, workspace_lba, 32); __calc_lba(dd, ddf->dlist, primary_lba, 16); - __calc_lba(dd, ddf->dlist, secondary_lba, 32); - pde->config_size = dd->workspace_lba; + if (ddf->dlist == NULL || + be64_to_cpu(ddf->dlist->secondary_lba) != ~(__u64)0) + __calc_lba(dd, ddf->dlist, secondary_lba, 32); + _set_config_size(pde, dd); sprintf(pde->path, "%17.17s","Information: nil") ; memset(pde->pad, 0xff, 6); @@ -2693,7 +2991,7 @@ static int add_to_super_ddf(struct supertype *st, } else { dd->next = ddf->dlist; ddf->dlist = dd; - ddf_set_updates_pending(ddf); + ddf_set_updates_pending(ddf, NULL); } return 0; @@ -2716,7 +3014,7 @@ static int remove_from_super_ddf(struct supertype *st, mdu_disk_info_t *dk) if (dl->major == dk->major && dl->minor == dk->minor) break; - if (!dl) + if (!dl || dl->pdnum < 0) return -1; if (st->update_tail) { @@ -2726,42 +3024,44 @@ static int remove_from_super_ddf(struct supertype *st, mdu_disk_info_t *dk) pd = xmalloc(len); pd->magic = DDF_PHYS_RECORDS_MAGIC; - pd->used_pdes = __cpu_to_be16(dl->pdnum); - pd->entries[0].state = __cpu_to_be16(DDF_Missing); + pd->used_pdes = cpu_to_be16(dl->pdnum); + pd->entries[0].state = cpu_to_be16(DDF_Missing); append_metadata_update(st, pd, len); } return 0; } +#endif /* * This is the write_init_super method for a ddf container. It is * called when creating a container or adding another device to a * container. */ -#define NULL_CONF_SZ 4096 -static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type, - char *null_aligned) +static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type) { unsigned long long sector; struct ddf_header *header; - int fd, i, n_config, conf_size; + int fd, i, n_config, conf_size, buf_size; int ret = 0; + char *conf; fd = d->fd; switch (type) { case DDF_HEADER_PRIMARY: header = &ddf->primary; - sector = __be64_to_cpu(header->primary_lba); + sector = be64_to_cpu(header->primary_lba); break; case DDF_HEADER_SECONDARY: header = &ddf->secondary; - sector = __be64_to_cpu(header->secondary_lba); + sector = be64_to_cpu(header->secondary_lba); break; default: return 0; } + if (sector == ~(__u64)0) + return 0; header->type = type; header->openflag = 1; @@ -2785,6 +3085,13 @@ static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type, /* Now write lots of config records. */ n_config = ddf->max_part; conf_size = ddf->conf_rec_len * 512; + conf = ddf->conf; + buf_size = conf_size * (n_config + 1); + if (!conf) { + if (posix_memalign((void**)&conf, 512, buf_size) != 0) + goto out; + ddf->conf = conf; + } for (i = 0 ; i <= n_config ; i++) { struct vcl *c; struct vd_config *vdc = NULL; @@ -2802,26 +3109,17 @@ static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type, (const struct vd_config **)&vdc, &dummy); } - if (c) { + if (vdc) { dprintf("writing conf record %i on disk %08x for %s/%u\n", - i, d->disk.refnum, guid_str(vdc->guid), + i, be32_to_cpu(d->disk.refnum), + guid_str(vdc->guid), vdc->sec_elmnt_seq); - vdc->seqnum = header->seq; vdc->crc = calc_crc(vdc, conf_size); - if (write(fd, vdc, conf_size) < 0) - break; - } else { - unsigned int togo = conf_size; - while (togo > NULL_CONF_SZ) { - if (write(fd, null_aligned, NULL_CONF_SZ) < 0) - break; - togo -= NULL_CONF_SZ; - } - if (write(fd, null_aligned, togo) < 0) - break; - } + memcpy(conf + i*conf_size, vdc, conf_size); + } else + memset(conf + i*conf_size, 0xff, conf_size); } - if (i <= n_config) + if (write(fd, conf, buf_size) != buf_size) goto out; d->disk.crc = calc_crc(&d->disk, 512); @@ -2840,79 +3138,75 @@ out: return ret; } +static int _write_super_to_disk(struct ddf_super *ddf, struct dl *d) +{ + unsigned long long size; + int fd = d->fd; + if (fd < 0) + return 0; + + /* We need to fill in the primary, (secondary) and workspace + * lba's in the headers, set their checksums, + * Also checksum phys, virt.... + * + * Then write everything out, finally the anchor is written. + */ + get_dev_size(fd, NULL, &size); + size /= 512; + memcpy(&ddf->anchor, ddf->active, 512); + if (be64_to_cpu(d->workspace_lba) != 0ULL) + ddf->anchor.workspace_lba = d->workspace_lba; + else + ddf->anchor.workspace_lba = + cpu_to_be64(size - 32*1024*2); + if (be64_to_cpu(d->primary_lba) != 0ULL) + ddf->anchor.primary_lba = d->primary_lba; + else + ddf->anchor.primary_lba = + cpu_to_be64(size - 16*1024*2); + if (be64_to_cpu(d->secondary_lba) != 0ULL) + ddf->anchor.secondary_lba = d->secondary_lba; + else + ddf->anchor.secondary_lba = + cpu_to_be64(size - 32*1024*2); + ddf->anchor.timestamp = cpu_to_be32(time(0) - DECADE); + memcpy(&ddf->primary, &ddf->anchor, 512); + memcpy(&ddf->secondary, &ddf->anchor, 512); + + ddf->anchor.openflag = 0xFF; /* 'open' means nothing */ + ddf->anchor.seq = cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */ + ddf->anchor.crc = calc_crc(&ddf->anchor, 512); + + if (!__write_ddf_structure(d, ddf, DDF_HEADER_PRIMARY)) + return 0; + + if (!__write_ddf_structure(d, ddf, DDF_HEADER_SECONDARY)) + return 0; + + lseek64(fd, (size-1)*512, SEEK_SET); + if (write(fd, &ddf->anchor, 512) < 0) + return 0; + + return 1; +} + +#ifndef MDASSEMBLE static int __write_init_super_ddf(struct supertype *st) { struct ddf_super *ddf = st->sb; struct dl *d; int attempts = 0; int successes = 0; - unsigned long long size; - char *null_aligned; - __u32 seq; pr_state(ddf, __func__); - if (posix_memalign((void**)&null_aligned, 4096, NULL_CONF_SZ) != 0) { - return -ENOMEM; - } - memset(null_aligned, 0xff, NULL_CONF_SZ); - - seq = ddf->active->seq + 1; /* try to write updated metadata, * if we catch a failure move on to the next disk */ for (d = ddf->dlist; d; d=d->next) { - int fd = d->fd; - - if (fd < 0) - continue; - attempts++; - /* We need to fill in the primary, (secondary) and workspace - * lba's in the headers, set their checksums, - * Also checksum phys, virt.... - * - * Then write everything out, finally the anchor is written. - */ - get_dev_size(fd, NULL, &size); - size /= 512; - if (d->workspace_lba != 0) - ddf->anchor.workspace_lba = d->workspace_lba; - else - ddf->anchor.workspace_lba = - __cpu_to_be64(size - 32*1024*2); - if (d->primary_lba != 0) - ddf->anchor.primary_lba = d->primary_lba; - else - ddf->anchor.primary_lba = - __cpu_to_be64(size - 16*1024*2); - if (d->secondary_lba != 0) - ddf->anchor.secondary_lba = d->secondary_lba; - else - ddf->anchor.secondary_lba = - __cpu_to_be64(size - 32*1024*2); - ddf->anchor.seq = seq; - memcpy(&ddf->primary, &ddf->anchor, 512); - memcpy(&ddf->secondary, &ddf->anchor, 512); - - ddf->anchor.openflag = 0xFF; /* 'open' means nothing */ - ddf->anchor.seq = 0xFFFFFFFF; /* no sequencing in anchor */ - ddf->anchor.crc = calc_crc(&ddf->anchor, 512); - - if (!__write_ddf_structure(d, ddf, DDF_HEADER_PRIMARY, - null_aligned)) - continue; - - if (!__write_ddf_structure(d, ddf, DDF_HEADER_SECONDARY, - null_aligned)) - continue; - - lseek64(fd, (size-1)*512, SEEK_SET); - if (write(fd, &ddf->anchor, 512) < 0) - continue; - successes++; + successes += _write_super_to_disk(ddf, d); } - free(null_aligned); return attempts != successes; } @@ -2922,16 +3216,18 @@ static int write_init_super_ddf(struct supertype *st) struct ddf_super *ddf = st->sb; struct vcl *currentconf = ddf->currentconf; - /* we are done with currentconf reset it to point st at the container */ + /* We are done with currentconf - reset it so st refers to the container */ ddf->currentconf = NULL; if (st->update_tail) { /* queue the virtual_disk and vd_config as metadata updates */ struct virtual_disk *vd; struct vd_config *vc; - int len; + int len, tlen; + unsigned int i; if (!currentconf) { + /* Must be adding a physical disk to the container */ int len = (sizeof(struct phys_disk) + sizeof(struct phys_disk_entry)); @@ -2951,22 +3247,28 @@ static int write_init_super_ddf(struct supertype *st) vd = xmalloc(len); *vd = *ddf->virt; vd->entries[0] = ddf->virt->entries[currentconf->vcnum]; - vd->populated_vdes = __cpu_to_be16(currentconf->vcnum); + vd->populated_vdes = cpu_to_be16(currentconf->vcnum); append_metadata_update(st, vd, len); /* Then the vd_config */ len = ddf->conf_rec_len * 512; - vc = xmalloc(len); + tlen = len * currentconf->conf.sec_elmnt_count; + vc = xmalloc(tlen); memcpy(vc, ¤tconf->conf, len); - append_metadata_update(st, vc, len); + for (i = 1; i < currentconf->conf.sec_elmnt_count; i++) + memcpy((char *)vc + i*len, currentconf->other_bvds[i-1], + len); + append_metadata_update(st, vc, tlen); - /* FIXME I need to close the fds! */ return 0; } else { struct dl *d; if (!currentconf) for (d = ddf->dlist; d; d=d->next) while (Kill(d->devname, NULL, 0, -1, 1) == 0); + /* Note: we don't close the fd's now, but a subsequent + * ->free_super() will + */ return __write_init_super_ddf(st); } } @@ -2986,12 +3288,14 @@ static __u64 avail_size_ddf(struct supertype *st, __u64 devsize, static int reserve_space(struct supertype *st, int raiddisks, unsigned long long size, int chunk, + unsigned long long data_offset, unsigned long long *freesize) { /* Find 'raiddisks' spare extents at least 'size' big (but * only caring about multiples of 'chunk') and remember - * them. - * If the cannot be found, fail. + * them. If size==0, find the largest size possible. + * Report available size in *freesize + * If space cannot be found, fail. */ struct dl *dl; struct ddf_super *ddf = st->sb; @@ -3003,32 +3307,13 @@ static int reserve_space(struct supertype *st, int raiddisks, } /* Now find largest extent on each device */ for (dl = ddf->dlist ; dl ; dl=dl->next) { - struct extent *e = get_extents(ddf, dl); - unsigned long long pos = 0; - int i = 0; - int found = 0; - unsigned long long minsize = size; + unsigned long long minsize = ULLONG_MAX; - if (size == 0) - minsize = chunk; - - if (!e) - continue; - do { - unsigned long long esize; - esize = e[i].start - pos; - if (esize >= minsize) { - found = 1; - minsize = esize; - } - pos = e[i].start + e[i].size; - i++; - } while (e[i-1].size); - if (found) { + find_space(ddf, dl, data_offset, &minsize); + if (minsize >= size && minsize >= (unsigned)chunk) { cnt++; dl->esize = minsize; } - free(e); } if (cnt < raiddisks) { pr_err("not enough devices with space to create array.\n"); @@ -3071,21 +3356,6 @@ static int reserve_space(struct supertype *st, int raiddisks, return 1; } -static int -validate_geometry_ddf_container(struct supertype *st, - int level, int layout, int raiddisks, - int chunk, unsigned long long size, - unsigned long long data_offset, - char *dev, unsigned long long *freesize, - int verbose); - -static int validate_geometry_ddf_bvd(struct supertype *st, - int level, int layout, int raiddisks, - int *chunk, unsigned long long size, - unsigned long long data_offset, - char *dev, unsigned long long *freesize, - int verbose); - static int validate_geometry_ddf(struct supertype *st, int level, int layout, int raiddisks, int *chunk, unsigned long long size, @@ -3104,14 +3374,15 @@ static int validate_geometry_ddf(struct supertype *st, * If given BVDs, we make an SVD, changing all the GUIDs in the process. */ - if (chunk && *chunk == UnSet) + if (*chunk == UnSet) *chunk = DEFAULT_CHUNK; - if (level == -1000000) level = LEVEL_CONTAINER; + if (level == LEVEL_NONE) + level = LEVEL_CONTAINER; if (level == LEVEL_CONTAINER) { /* Must be a fresh device to add to a container */ return validate_geometry_ddf_container(st, level, layout, - raiddisks, chunk?*chunk:0, + raiddisks, *chunk, size, data_offset, dev, freesize, verbose); @@ -3119,7 +3390,8 @@ static int validate_geometry_ddf(struct supertype *st, if (!dev) { mdu_array_info_t array = { - .level = level, .layout = layout, + .level = level, + .layout = layout, .raid_disks = raiddisks }; struct vd_config conf; @@ -3139,7 +3411,8 @@ static int validate_geometry_ddf(struct supertype *st, * chosen so that add_to_super/getinfo_super * can return them. */ - return reserve_space(st, raiddisks, size, chunk?*chunk:0, freesize); + return reserve_space(st, raiddisks, size, *chunk, + data_offset, freesize); } return 1; } @@ -3163,17 +3436,8 @@ static int validate_geometry_ddf(struct supertype *st, */ fd = open(dev, O_RDONLY|O_EXCL, 0); if (fd >= 0) { - sra = sysfs_read(fd, NULL, GET_VERSION); close(fd); - if (sra && sra->array.major_version == -1 && - strcmp(sra->text_version, "ddf") == 0) { - - /* load super */ - /* find space for 'n' devices. */ - /* remember the devices */ - /* Somehow return the fact that we have enough */ - } - + /* Just a bare device, no good to us */ if (verbose) pr_err("ddf: Cannot create this array " "on device %s - a container is required.\n", @@ -3266,10 +3530,7 @@ static int validate_geometry_ddf_bvd(struct supertype *st, struct stat stb; struct ddf_super *ddf = st->sb; struct dl *dl; - unsigned long long pos = 0; unsigned long long maxsize; - struct extent *e; - int i; /* ddf/bvd supports lots of things, but not containers */ if (level == LEVEL_CONTAINER) { if (verbose) @@ -3288,25 +3549,10 @@ static int validate_geometry_ddf_bvd(struct supertype *st, int dcnt = 0; if (minsize == 0) minsize = 8; - for (dl = ddf->dlist; dl ; dl = dl->next) - { - int found = 0; - pos = 0; - - i = 0; - e = get_extents(ddf, dl); - if (!e) continue; - do { - unsigned long long esize; - esize = e[i].start - pos; - if (esize >= minsize) - found = 1; - pos = e[i].start + e[i].size; - i++; - } while (e[i-1].size); - if (found) + for (dl = ddf->dlist; dl ; dl = dl->next) { + if (find_space(ddf, dl, data_offset, &minsize) + != INVALID_SECTORS) dcnt++; - free(e); } if (dcnt < raiddisks) { if (verbose) @@ -3334,19 +3580,9 @@ static int validate_geometry_ddf_bvd(struct supertype *st, dev); return 0; } - e = get_extents(ddf, 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); + maxsize = ULLONG_MAX; + find_space(ddf, dl, data_offset, &maxsize); *freesize = maxsize; - // FIXME here I am return 1; } @@ -3384,7 +3620,7 @@ static int load_super_ddf_all(struct supertype *st, int fd, rv = load_ddf_headers(dfd, super, NULL); close(dfd); if (rv == 0) { - seq = __be32_to_cpu(super->active->seq); + seq = be32_to_cpu(super->active->seq); if (super->active->openflag) seq--; if (!best || seq > bestseq) { @@ -3479,7 +3715,7 @@ static int check_secondary(const struct vcl *vc) pr_err("Different RAID levels for BVDs are unsupported\n"); return -1; } - if (bvd->prim_elmnt_count != conf->prim_elmnt_count) { + if (!be16_eq(bvd->prim_elmnt_count, conf->prim_elmnt_count)) { pr_err("All BVDs must have the same number of primary elements\n"); return -1; } @@ -3487,7 +3723,7 @@ static int check_secondary(const struct vcl *vc) pr_err("Different strip sizes for BVDs are unsupported\n"); return -1; } - if (bvd->array_blocks != conf->array_blocks) { + if (!be64_eq(bvd->array_blocks, conf->array_blocks)) { pr_err("Different BVD sizes are unsupported\n"); return -1; } @@ -3495,7 +3731,7 @@ static int check_secondary(const struct vcl *vc) } for (i = 0; i < conf->sec_elmnt_count; i++) { if (!__was_sec_seen(i)) { - pr_err("BVD %d is missing\n", i); + /* pr_err("BVD %d is missing\n", i); */ return -1; } } @@ -3503,24 +3739,24 @@ static int check_secondary(const struct vcl *vc) } static unsigned int get_pd_index_from_refnum(const struct vcl *vc, - __u32 refnum, unsigned int nmax, + be32 refnum, unsigned int nmax, const struct vd_config **bvd, unsigned int *idx) { unsigned int i, j, n, sec, cnt; - cnt = __be16_to_cpu(vc->conf.prim_elmnt_count); + cnt = be16_to_cpu(vc->conf.prim_elmnt_count); sec = (vc->conf.sec_elmnt_count == 1 ? 0 : vc->conf.sec_elmnt_seq); for (i = 0, j = 0 ; i < nmax ; i++) { /* j counts valid entries for this BVD */ - if (vc->conf.phys_refnum[i] != 0xffffffff) - j++; - if (vc->conf.phys_refnum[i] == refnum) { + if (be32_eq(vc->conf.phys_refnum[i], refnum)) { *bvd = &vc->conf; *idx = i; - return sec * cnt + j - 1; + return sec * cnt + j; } + if (be32_to_cpu(vc->conf.phys_refnum[i]) != 0xffffffff) + j++; } if (vc->other_bvds == NULL) goto bad; @@ -3531,13 +3767,13 @@ static unsigned int get_pd_index_from_refnum(const struct vcl *vc, if (sec == DDF_UNUSED_BVD) continue; for (i = 0, j = 0 ; i < nmax ; i++) { - if (vd->phys_refnum[i] != 0xffffffff) - j++; - if (vd->phys_refnum[i] == refnum) { + if (be32_eq(vd->phys_refnum[i], refnum)) { *bvd = vd; *idx = i; - return sec * cnt + j - 1; + return sec * cnt + j; } + if (be32_to_cpu(vd->phys_refnum[i]) != 0xffffffff) + j++; } } bad: @@ -3559,10 +3795,8 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray struct mdinfo *rest = NULL; struct vcl *vc; - for (vc = ddf->conflist ; vc ; vc=vc->next) - { + for (vc = ddf->conflist ; vc ; vc=vc->next) { unsigned int i; - unsigned int j; struct mdinfo *this; char *ep; __u32 *cptr; @@ -3587,10 +3821,11 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray this->array.md_minor = -1; this->array.major_version = -1; this->array.minor_version = -2; + this->safe_mode_delay = DDF_SAFE_MODE_DELAY; cptr = (__u32 *)(vc->conf.guid + 16); this->array.ctime = DECADE + __be32_to_cpu(*cptr); this->array.utime = DECADE + - __be32_to_cpu(vc->conf.timestamp); + be32_to_cpu(vc->conf.timestamp); this->array.chunk_size = 512 << vc->conf.chunk_shift; i = vc->vcnum; @@ -3603,16 +3838,11 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray this->array.state = 1; this->resync_start = MaxSector; } - memcpy(this->name, ddf->virt->entries[i].name, 16); - this->name[16]=0; - for(j=0; j<16; j++) - if (this->name[j] == ' ') - this->name[j] = 0; - + _ddf_array_name(this->name, ddf, i); memset(this->uuid, 0, sizeof(this->uuid)); - this->component_size = __be64_to_cpu(vc->conf.blocks); - this->array.size = this->component_size / 2; - this->container_member = i; + this->component_size = be64_to_cpu(vc->conf.blocks); + this->array.size = this->component_size / 2; + this->container_member = i; ddf->currentconf = vc; uuid_from_super_ddf(st, this->uuid); @@ -3622,17 +3852,18 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray sprintf(this->text_version, "/%s/%d", st->container_devnm, this->container_member); - for (pd = 0; pd < __be16_to_cpu(ddf->phys->used_pdes); pd++) { + for (pd = 0; pd < be16_to_cpu(ddf->phys->max_pdes); pd++) { struct mdinfo *dev; struct dl *d; const struct vd_config *bvd; unsigned int iphys; int stt; - if (ddf->phys->entries[pd].refnum == 0xFFFFFFFF) + if (be32_to_cpu(ddf->phys->entries[pd].refnum) + == 0xFFFFFFFF) continue; - stt = __be16_to_cpu(ddf->phys->entries[pd].state); + stt = be16_to_cpu(ddf->phys->entries[pd].state); if ((stt & (DDF_Online|DDF_Failed|DDF_Rebuilding)) != DDF_Online) continue; @@ -3646,28 +3877,28 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray this->array.working_disks++; for (d = ddf->dlist; d ; d=d->next) - if (d->disk.refnum == - ddf->phys->entries[pd].refnum) + if (be32_eq(d->disk.refnum, + ddf->phys->entries[pd].refnum)) break; if (d == NULL) /* Haven't found that one yet, maybe there are others */ continue; dev = xcalloc(1, sizeof(*dev)); - dev->next = this->devs; - this->devs = dev; + dev->next = this->devs; + this->devs = dev; - dev->disk.number = __be32_to_cpu(d->disk.refnum); - dev->disk.major = d->major; - dev->disk.minor = d->minor; + dev->disk.number = be32_to_cpu(d->disk.refnum); + dev->disk.major = d->major; + dev->disk.minor = d->minor; dev->disk.raid_disk = i; - dev->disk.state = (1<disk.state = (1<recovery_start = MaxSector; - dev->events = __be32_to_cpu(ddf->primary.seq); + dev->events = be32_to_cpu(ddf->active->seq); dev->data_offset = - __be64_to_cpu(LBA_OFFSET(ddf, bvd)[iphys]); - dev->component_size = __be64_to_cpu(bvd->blocks); + be64_to_cpu(LBA_OFFSET(ddf, bvd)[iphys]); + dev->component_size = be64_to_cpu(bvd->blocks); if (d->devname) strcpy(dev->name, d->devname); } @@ -3708,17 +3939,9 @@ static int store_super_ddf(struct supertype *st, int fd) (int)minor(sta.st_rdev)); return 1; } - /* - For DDF, writing to just one disk makes no sense. - We would run the risk of writing inconsistent meta data - to the devices. So just call __write_init_super_ddf and - write to all devices, including this one. - Use the fd passed to this function, just in case dl->fd - is invalid. - */ ofd = dl->fd; dl->fd = fd; - ret = __write_init_super_ddf(st); + ret = (_write_super_to_disk(ddf, dl) != 1); dl->fd = ofd; return ret; } @@ -3740,7 +3963,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) /* * return: * 0 same, or first was empty, and second was copied - * 1 second had wrong number + * 1 second had wrong magic number - but that isn't possible * 2 wrong uuid * 3 wrong other info */ @@ -3759,51 +3982,25 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) if (memcmp(first->anchor.guid, second->anchor.guid, DDF_GUID_LEN) != 0) return 2; - if (first->anchor.seq != second->anchor.seq) { - dprintf("%s: sequence number mismatch %u/%u\n", __func__, - __be32_to_cpu(first->anchor.seq), - __be32_to_cpu(second->anchor.seq)); - return 3; - } - if (first->max_part != second->max_part || - first->phys->used_pdes != second->phys->used_pdes || - first->virt->populated_vdes != second->virt->populated_vdes) { - dprintf("%s: PD/VD number mismatch\n", __func__); - return 3; - } - - max_pds = __be16_to_cpu(first->phys->used_pdes); - for (dl2 = second->dlist; dl2; dl2 = dl2->next) { - for (pd = 0; pd < max_pds; pd++) - if (first->phys->entries[pd].refnum == dl2->disk.refnum) - break; - if (pd == max_pds) { - dprintf("%s: no match for disk %08x\n", __func__, - __be32_to_cpu(dl2->disk.refnum)); - return 3; - } - } + /* It is only OK to compare info in the anchor. Anything else + * could be changing due to a reconfig so must be ignored. + * guid really should be enough anyway. + */ - max_vds = __be16_to_cpu(first->active->max_vd_entries); - for (vl2 = second->conflist; vl2; vl2 = vl2->next) { - if (vl2->conf.magic != DDF_VD_CONF_MAGIC) - continue; - for (vd = 0; vd < max_vds; vd++) - if (!memcmp(first->virt->entries[vd].guid, - vl2->conf.guid, DDF_GUID_LEN)) - break; - if (vd == max_vds) { - dprintf("%s: no match for VD config\n", __func__); - return 3; - } + if (!be32_eq(first->active->seq, second->active->seq)) { + dprintf("%s: sequence number mismatch %u<->%u\n", __func__, + be32_to_cpu(first->active->seq), + be32_to_cpu(second->active->seq)); + return 0; } - /* FIXME should I look at anything else? */ /* - At this point we are fairly sure that the meta data matches. - But the new disk may contain additional local data. - Add it to the super block. + * At this point we are fairly sure that the meta data matches. + * But the new disk may contain additional local data. + * Add it to the super block. */ + max_vds = be16_to_cpu(first->active->max_vd_entries); + max_pds = be16_to_cpu(first->phys->max_pdes); for (vl2 = second->conflist; vl2; vl2 = vl2->next) { for (vl1 = first->conflist; vl1; vl1 = vl1->next) if (!memcmp(vl1->conf.guid, vl2->conf.guid, @@ -3849,7 +4046,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) for (dl2 = second->dlist; dl2; dl2 = dl2->next) { for (dl1 = first->dlist; dl1; dl1 = dl1->next) - if (dl1->disk.refnum == dl2->disk.refnum) + if (be32_eq(dl1->disk.refnum, dl2->disk.refnum)) break; if (dl1) continue; @@ -3866,9 +4063,10 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) dl1->next = first->dlist; dl1->fd = -1; for (pd = 0; pd < max_pds; pd++) - if (first->phys->entries[pd].refnum == dl1->disk.refnum) + if (be32_eq(first->phys->entries[pd].refnum, + dl1->disk.refnum)) break; - dl1->pdnum = pd; + dl1->pdnum = pd < max_pds ? (int)pd : -1; if (dl2->spare) { if (posix_memalign((void **)&dl1->spare, 512, first->conf_rec_len*512) != 0) { @@ -3893,7 +4091,7 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) } first->dlist = dl1; dprintf("%s: added disk %d: %08x\n", __func__, dl1->pdnum, - dl1->disk.refnum); + be32_to_cpu(dl1->disk.refnum)); } return 0; @@ -3910,15 +4108,92 @@ static int ddf_open_new(struct supertype *c, struct active_array *a, char *inst) { struct ddf_super *ddf = c->sb; int n = atoi(inst); + struct mdinfo *dev; + struct dl *dl; + static const char faulty[] = "faulty"; + if (all_ff(ddf->virt->entries[n].guid)) { pr_err("%s: subarray %d doesn't exist\n", __func__, n); return -ENODEV; } - dprintf("ddf: open_new %d\n", n); + dprintf("%s: new subarray %d, GUID: %s\n", __func__, n, + guid_str(ddf->virt->entries[n].guid)); + for (dev = a->info.devs; dev; dev = dev->next) { + for (dl = ddf->dlist; dl; dl = dl->next) + if (dl->major == dev->disk.major && + dl->minor == dev->disk.minor) + break; + if (!dl || dl->pdnum < 0) { + pr_err("%s: device %d/%d of subarray %d not found in meta data\n", + __func__, dev->disk.major, dev->disk.minor, n); + return -1; + } + if ((be16_to_cpu(ddf->phys->entries[dl->pdnum].state) & + (DDF_Online|DDF_Missing|DDF_Failed)) != DDF_Online) { + pr_err("%s: new subarray %d contains broken device %d/%d (%02x)\n", + __func__, n, dl->major, dl->minor, + be16_to_cpu( + ddf->phys->entries[dl->pdnum].state)); + if (write(dev->state_fd, faulty, sizeof(faulty)-1) != + sizeof(faulty) - 1) + pr_err("Write to state_fd failed\n"); + dev->curr_state = DS_FAULTY; + } + } a->info.container_member = n; return 0; } +static void handle_missing(struct ddf_super *ddf, struct active_array *a, int inst) +{ + /* This member array is being activated. If any devices + * are missing they must now be marked as failed. + */ + struct vd_config *vc; + unsigned int n_bvd; + struct vcl *vcl; + struct dl *dl; + int pd; + int n; + int state; + + for (n = 0; ; n++) { + vc = find_vdcr(ddf, inst, n, &n_bvd, &vcl); + if (!vc) + break; + for (dl = ddf->dlist; dl; dl = dl->next) + if (be32_eq(dl->disk.refnum, vc->phys_refnum[n_bvd])) + break; + if (dl) + /* Found this disk, so not missing */ + continue; + + /* Mark the device as failed/missing. */ + pd = find_phys(ddf, vc->phys_refnum[n_bvd]); + if (pd >= 0 && be16_and(ddf->phys->entries[pd].state, + cpu_to_be16(DDF_Online))) { + be16_clear(ddf->phys->entries[pd].state, + cpu_to_be16(DDF_Online)); + be16_set(ddf->phys->entries[pd].state, + cpu_to_be16(DDF_Failed|DDF_Missing)); + vc->phys_refnum[n_bvd] = cpu_to_be32(0); + ddf_set_updates_pending(ddf, vc); + } + + /* Mark the array as Degraded */ + state = get_svd_state(ddf, vcl); + if (ddf->virt->entries[inst].state != + ((ddf->virt->entries[inst].state & ~DDF_state_mask) + | state)) { + ddf->virt->entries[inst].state = + (ddf->virt->entries[inst].state & ~DDF_state_mask) + | state; + a->check_degraded = 1; + ddf_set_updates_pending(ddf, vc); + } + } +} + /* * The array 'a' is to be marked clean in the metadata. * If '->resync_start' is not ~(unsigned long long)0, then the array is only @@ -3934,7 +4209,7 @@ static int ddf_set_array_state(struct active_array *a, int consistent) int inst = a->info.container_member; int old = ddf->virt->entries[inst].state; if (consistent == 2) { - /* Should check if a recovery should be started FIXME */ + handle_missing(ddf, a, inst); consistent = 1; if (!is_resync_complete(&a->info)) consistent = 0; @@ -3944,7 +4219,7 @@ static int ddf_set_array_state(struct active_array *a, int consistent) else ddf->virt->entries[inst].state |= DDF_state_inconsistent; if (old != ddf->virt->entries[inst].state) - ddf_set_updates_pending(ddf); + ddf_set_updates_pending(ddf, NULL); old = ddf->virt->entries[inst].init_state; ddf->virt->entries[inst].init_state &= ~DDF_initstate_mask; @@ -3955,7 +4230,7 @@ static int ddf_set_array_state(struct active_array *a, int consistent) else ddf->virt->entries[inst].init_state |= DDF_init_quick; if (old != ddf->virt->entries[inst].init_state) - ddf_set_updates_pending(ddf); + ddf_set_updates_pending(ddf, NULL); dprintf("ddf mark %d/%s (%d) %s %llu\n", inst, guid_str(ddf->virt->entries[inst].guid), a->curr_state, @@ -3968,18 +4243,25 @@ static int get_bvd_state(const struct ddf_super *ddf, const struct vd_config *vc) { unsigned int i, n_bvd, working = 0; - unsigned int n_prim = __be16_to_cpu(vc->prim_elmnt_count); + unsigned int n_prim = be16_to_cpu(vc->prim_elmnt_count); int pd, st, state; + char *avail = xcalloc(1, n_prim); + mdu_array_info_t array; + + layout_ddf2md(vc, &array); + for (i = 0; i < n_prim; i++) { if (!find_index_in_bvd(ddf, vc, i, &n_bvd)) continue; pd = find_phys(ddf, vc->phys_refnum[n_bvd]); if (pd < 0) continue; - st = __be16_to_cpu(ddf->phys->entries[pd].state); + st = be16_to_cpu(ddf->phys->entries[pd].state); if ((st & (DDF_Online|DDF_Failed|DDF_Rebuilding)) - == DDF_Online) + == DDF_Online) { working++; + avail[i] = 1; + } } state = DDF_state_degraded; @@ -3998,6 +4280,10 @@ static int get_bvd_state(const struct ddf_super *ddf, else if (working >= 2) state = DDF_state_part_optimal; break; + case DDF_RAID1E: + if (!enough(10, n_prim, array.layout, 1, avail)) + state = DDF_state_failed; + break; case DDF_RAID4: case DDF_RAID5: if (working < n_prim - 1) @@ -4069,7 +4355,9 @@ static void ddf_set_disk(struct active_array *a, int n, int state) int pd; struct mdinfo *mdi; struct dl *dl; + int update = 0; + dprintf("%s: %d to %x\n", __func__, n, state); if (vc == NULL) { dprintf("ddf: cannot find instance %d!!\n", inst); return; @@ -4078,8 +4366,11 @@ static void ddf_set_disk(struct active_array *a, int n, int state) for (mdi = a->info.devs; mdi; mdi = mdi->next) if (mdi->disk.raid_disk == n) break; - if (!mdi) + if (!mdi) { + pr_err("%s: cannot find raid disk %d\n", + __func__, n); return; + } /* and find the 'dl' entry corresponding to that. */ for (dl = ddf->dlist; dl; dl = dl->next) @@ -4087,8 +4378,12 @@ static void ddf_set_disk(struct active_array *a, int n, int state) mdi->disk.major == dl->major && mdi->disk.minor == dl->minor) break; - if (!dl) + if (!dl) { + pr_err("%s: cannot find raid disk %d (%d/%d)\n", + __func__, n, + mdi->disk.major, mdi->disk.minor); return; + } pd = find_phys(ddf, vc->phys_refnum[n_bvd]); if (pd < 0 || pd != dl->pdnum) { @@ -4096,33 +4391,40 @@ static void ddf_set_disk(struct active_array *a, int n, int state) * If it is now in_sync, insert it. */ dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n", __func__, dl->pdnum, dl->major, dl->minor, - dl->disk.refnum); + be32_to_cpu(dl->disk.refnum)); dprintf("%s: array %u disk %u ref %08x pd %d\n", - __func__, inst, n_bvd, vc->phys_refnum[n_bvd], pd); - if ((state & DS_INSYNC) && ! (state & DS_FAULTY)) { - pd = dl->pdnum; /* FIXME: is this really correct ? */ + __func__, inst, n_bvd, + be32_to_cpu(vc->phys_refnum[n_bvd]), pd); + if ((state & DS_INSYNC) && ! (state & DS_FAULTY) && + dl->pdnum >= 0) { + pd = dl->pdnum; vc->phys_refnum[n_bvd] = dl->disk.refnum; LBA_OFFSET(ddf, vc)[n_bvd] = - __cpu_to_be64(mdi->data_offset); - ddf->phys->entries[pd].type &= - ~__cpu_to_be16(DDF_Global_Spare); - ddf->phys->entries[pd].type |= - __cpu_to_be16(DDF_Active_in_VD); - ddf_set_updates_pending(ddf); + cpu_to_be64(mdi->data_offset); + be16_clear(ddf->phys->entries[pd].type, + cpu_to_be16(DDF_Global_Spare)); + be16_set(ddf->phys->entries[pd].type, + cpu_to_be16(DDF_Active_in_VD)); + update = 1; } } else { - int old = ddf->phys->entries[pd].state; + be16 old = ddf->phys->entries[pd].state; if (state & DS_FAULTY) - ddf->phys->entries[pd].state |= __cpu_to_be16(DDF_Failed); + be16_set(ddf->phys->entries[pd].state, + cpu_to_be16(DDF_Failed)); if (state & DS_INSYNC) { - ddf->phys->entries[pd].state |= __cpu_to_be16(DDF_Online); - ddf->phys->entries[pd].state &= __cpu_to_be16(~DDF_Rebuilding); + be16_set(ddf->phys->entries[pd].state, + cpu_to_be16(DDF_Online)); + be16_clear(ddf->phys->entries[pd].state, + cpu_to_be16(DDF_Rebuilding)); } - if (old != ddf->phys->entries[pd].state) - ddf_set_updates_pending(ddf); + if (!be16_eq(old, ddf->phys->entries[pd].state)) + update = 1; } - dprintf("ddf: set_disk %d to %x\n", n, state); + dprintf("ddf: set_disk %d (%08x) to %x->%02x\n", n, + be32_to_cpu(dl->disk.refnum), state, + be16_to_cpu(ddf->phys->entries[pd].state)); /* Now we need to check the state of the array and update * virtual_disk.entries[n].state. @@ -4134,18 +4436,17 @@ static void ddf_set_disk(struct active_array *a, int n, int state) if (ddf->virt->entries[inst].state != ((ddf->virt->entries[inst].state & ~DDF_state_mask) | state)) { - ddf->virt->entries[inst].state = (ddf->virt->entries[inst].state & ~DDF_state_mask) | state; - ddf_set_updates_pending(ddf); + update = 1; } - + if (update) + ddf_set_updates_pending(ddf, vc); } static void ddf_sync_metadata(struct supertype *st) { - /* * Write all data to all devices. * Later, we might be able to track whether only local changes @@ -4208,8 +4509,9 @@ static int kill_subarray_ddf(struct supertype *st) */ struct vcl *victim = ddf->currentconf; struct vd_config *conf; - ddf->currentconf = NULL; unsigned int vdnum; + + ddf->currentconf = NULL; if (!victim) { pr_err("%s: nothing to kill\n", __func__); return -1; @@ -4233,16 +4535,331 @@ static int kill_subarray_ddf(struct supertype *st) } memset(vd, 0 , len); vd->magic = DDF_VIRT_RECORDS_MAGIC; - vd->populated_vdes = 0; + vd->populated_vdes = cpu_to_be16(0); memcpy(vd->entries[0].guid, conf->guid, DDF_GUID_LEN); /* we use DDF_state_deleted as marker */ vd->entries[0].state = DDF_state_deleted; append_metadata_update(st, vd, len); - } else + } else { _kill_subarray_ddf(ddf, conf->guid); + ddf_set_updates_pending(ddf, NULL); + ddf_sync_metadata(st); + } return 0; } +static void copy_matching_bvd(struct ddf_super *ddf, + struct vd_config *conf, + const struct metadata_update *update) +{ + unsigned int mppe = + be16_to_cpu(ddf->anchor.max_primary_element_entries); + unsigned int len = ddf->conf_rec_len * 512; + char *p; + struct vd_config *vc; + for (p = update->buf; p < update->buf + update->len; p += len) { + vc = (struct vd_config *) p; + if (vc->sec_elmnt_seq == conf->sec_elmnt_seq) { + memcpy(conf->phys_refnum, vc->phys_refnum, + mppe * (sizeof(__u32) + sizeof(__u64))); + return; + } + } + pr_err("%s: no match for BVD %d of %s in update\n", __func__, + conf->sec_elmnt_seq, guid_str(conf->guid)); +} + +static void ddf_process_phys_update(struct supertype *st, + struct metadata_update *update) +{ + struct ddf_super *ddf = st->sb; + struct phys_disk *pd; + unsigned int ent; + + pd = (struct phys_disk*)update->buf; + ent = be16_to_cpu(pd->used_pdes); + if (ent >= be16_to_cpu(ddf->phys->max_pdes)) + return; + if (be16_and(pd->entries[0].state, cpu_to_be16(DDF_Missing))) { + struct dl **dlp; + /* removing this disk. */ + be16_set(ddf->phys->entries[ent].state, + cpu_to_be16(DDF_Missing)); + for (dlp = &ddf->dlist; *dlp; dlp = &(*dlp)->next) { + struct dl *dl = *dlp; + if (dl->pdnum == (signed)ent) { + close(dl->fd); + dl->fd = -1; + *dlp = dl->next; + update->space = dl->devname; + *(void**)dl = update->space_list; + update->space_list = (void**)dl; + break; + } + } + ddf_set_updates_pending(ddf, NULL); + return; + } + if (!all_ff(ddf->phys->entries[ent].guid)) + return; + ddf->phys->entries[ent] = pd->entries[0]; + ddf->phys->used_pdes = cpu_to_be16 + (1 + be16_to_cpu(ddf->phys->used_pdes)); + ddf_set_updates_pending(ddf, NULL); + if (ddf->add_list) { + struct active_array *a; + struct dl *al = ddf->add_list; + ddf->add_list = al->next; + + al->next = ddf->dlist; + ddf->dlist = al; + + /* As a device has been added, we should check + * for any degraded devices that might make + * use of this spare */ + for (a = st->arrays ; a; a=a->next) + a->check_degraded = 1; + } +} + +static void ddf_process_virt_update(struct supertype *st, + struct metadata_update *update) +{ + struct ddf_super *ddf = st->sb; + struct virtual_disk *vd; + unsigned int ent; + + vd = (struct virtual_disk*)update->buf; + + if (vd->entries[0].state == DDF_state_deleted) { + if (_kill_subarray_ddf(ddf, vd->entries[0].guid)) + return; + } else { + ent = find_vde_by_guid(ddf, vd->entries[0].guid); + if (ent != DDF_NOTFOUND) { + dprintf("%s: VD %s exists already in slot %d\n", + __func__, guid_str(vd->entries[0].guid), + ent); + return; + } + ent = find_unused_vde(ddf); + if (ent == DDF_NOTFOUND) + return; + ddf->virt->entries[ent] = vd->entries[0]; + ddf->virt->populated_vdes = + cpu_to_be16( + 1 + be16_to_cpu( + ddf->virt->populated_vdes)); + dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n", + __func__, guid_str(vd->entries[0].guid), ent, + ddf->virt->entries[ent].state, + ddf->virt->entries[ent].init_state); + } + ddf_set_updates_pending(ddf, NULL); +} + +static void ddf_remove_failed(struct ddf_super *ddf) +{ + /* Now remove any 'Failed' devices that are not part + * of any VD. They will have the Transition flag set. + * Once done, we need to update all dl->pdnum numbers. + */ + unsigned int pdnum; + unsigned int pd2 = 0; + struct dl *dl; + + for (pdnum = 0; pdnum < be16_to_cpu(ddf->phys->max_pdes); + pdnum++) { + if (be32_to_cpu(ddf->phys->entries[pdnum].refnum) == + 0xFFFFFFFF) + continue; + if (be16_and(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Failed)) + && be16_and(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Transition))) { + /* skip this one unless in dlist*/ + for (dl = ddf->dlist; dl; dl = dl->next) + if (dl->pdnum == (int)pdnum) + break; + if (!dl) + continue; + } + if (pdnum == pd2) + pd2++; + else { + ddf->phys->entries[pd2] = + ddf->phys->entries[pdnum]; + for (dl = ddf->dlist; dl; dl = dl->next) + if (dl->pdnum == (int)pdnum) + dl->pdnum = pd2; + pd2++; + } + } + ddf->phys->used_pdes = cpu_to_be16(pd2); + while (pd2 < pdnum) { + memset(ddf->phys->entries[pd2].guid, 0xff, + DDF_GUID_LEN); + pd2++; + } +} + +static void ddf_update_vlist(struct ddf_super *ddf, struct dl *dl) +{ + struct vcl *vcl; + unsigned int vn = 0; + int in_degraded = 0; + + if (dl->pdnum < 0) + return; + for (vcl = ddf->conflist; vcl ; vcl = vcl->next) { + unsigned int dn, ibvd; + const struct vd_config *conf; + int vstate; + dn = get_pd_index_from_refnum(vcl, + dl->disk.refnum, + ddf->mppe, + &conf, &ibvd); + if (dn == DDF_NOTFOUND) + continue; + dprintf("dev %d/%08x has %s (sec=%u) at %d\n", + dl->pdnum, + be32_to_cpu(dl->disk.refnum), + guid_str(conf->guid), + conf->sec_elmnt_seq, vn); + /* Clear the Transition flag */ + if (be16_and + (ddf->phys->entries[dl->pdnum].state, + cpu_to_be16(DDF_Failed))) + be16_clear(ddf->phys + ->entries[dl->pdnum].state, + cpu_to_be16(DDF_Transition)); + dl->vlist[vn++] = vcl; + vstate = ddf->virt->entries[vcl->vcnum].state + & DDF_state_mask; + if (vstate == DDF_state_degraded || + vstate == DDF_state_part_optimal) + in_degraded = 1; + } + while (vn < ddf->max_part) + dl->vlist[vn++] = NULL; + if (dl->vlist[0]) { + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + if (!be16_and(ddf->phys + ->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD))) { + be16_set(ddf->phys + ->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD)); + if (in_degraded) + be16_set(ddf->phys + ->entries[dl->pdnum] + .state, + cpu_to_be16 + (DDF_Rebuilding)); + } + } + if (dl->spare) { + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + be16_set(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Spare)); + } + if (!dl->vlist[0] && !dl->spare) { + be16_set(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare)); + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Spare)); + be16_clear(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Active_in_VD)); + } +} + +static void ddf_process_conf_update(struct supertype *st, + struct metadata_update *update) +{ + struct ddf_super *ddf = st->sb; + struct vd_config *vc; + struct vcl *vcl; + struct dl *dl; + unsigned int ent; + unsigned int pdnum, len; + + vc = (struct vd_config*)update->buf; + len = ddf->conf_rec_len * 512; + if ((unsigned int)update->len != len * vc->sec_elmnt_count) { + pr_err("%s: %s: insufficient data (%d) for %u BVDs\n", + __func__, guid_str(vc->guid), update->len, + vc->sec_elmnt_count); + return; + } + for (vcl = ddf->conflist; vcl ; vcl = vcl->next) + if (memcmp(vcl->conf.guid, vc->guid, DDF_GUID_LEN) == 0) + break; + dprintf("%s: conf update for %s (%s)\n", __func__, + guid_str(vc->guid), (vcl ? "old" : "new")); + if (vcl) { + /* An update, just copy the phys_refnum and lba_offset + * fields + */ + unsigned int i; + unsigned int k; + copy_matching_bvd(ddf, &vcl->conf, update); + for (k = 0; k < be16_to_cpu(vc->prim_elmnt_count); k++) + dprintf("BVD %u has %08x at %llu\n", 0, + be32_to_cpu(vcl->conf.phys_refnum[k]), + be64_to_cpu(LBA_OFFSET(ddf, + &vcl->conf)[k])); + for (i = 1; i < vc->sec_elmnt_count; i++) { + copy_matching_bvd(ddf, vcl->other_bvds[i-1], + update); + for (k = 0; k < be16_to_cpu( + vc->prim_elmnt_count); k++) + dprintf("BVD %u has %08x at %llu\n", i, + be32_to_cpu + (vcl->other_bvds[i-1]-> + phys_refnum[k]), + be64_to_cpu + (LBA_OFFSET + (ddf, + vcl->other_bvds[i-1])[k])); + } + } else { + /* A new VD_CONF */ + unsigned int i; + if (!update->space) + return; + vcl = update->space; + update->space = NULL; + vcl->next = ddf->conflist; + memcpy(&vcl->conf, vc, len); + ent = find_vde_by_guid(ddf, vc->guid); + if (ent == DDF_NOTFOUND) + return; + vcl->vcnum = ent; + ddf->conflist = vcl; + for (i = 1; i < vc->sec_elmnt_count; i++) + memcpy(vcl->other_bvds[i-1], + update->buf + len * i, len); + } + /* Set DDF_Transition on all Failed devices - to help + * us detect those that are no longer in use + */ + for (pdnum = 0; pdnum < be16_to_cpu(ddf->phys->max_pdes); + pdnum++) + if (be16_and(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Failed))) + be16_set(ddf->phys->entries[pdnum].state, + cpu_to_be16(DDF_Transition)); + + /* Now make sure vlist is correct for each dl. */ + for (dl = ddf->dlist; dl; dl = dl->next) + ddf_update_vlist(ddf, dl); + ddf_remove_failed(ddf); + + ddf_set_updates_pending(ddf, vc); +} + static void ddf_process_update(struct supertype *st, struct metadata_update *update) { @@ -4273,255 +4890,100 @@ static void ddf_process_update(struct supertype *st, * and offset. This will also mark the spare as active with * a spare-assignment record. */ - struct ddf_super *ddf = st->sb; - __u32 *magic = (__u32*)update->buf; - struct phys_disk *pd; - struct virtual_disk *vd; - struct vd_config *vc; - struct vcl *vcl; - struct dl *dl; - unsigned int mppe; - unsigned int ent; - unsigned int pdnum, pd2; - - dprintf("Process update %x\n", *magic); + be32 *magic = (be32 *)update->buf; - switch (*magic) { - case DDF_PHYS_RECORDS_MAGIC: + dprintf("Process update %x\n", be32_to_cpu(*magic)); - if (update->len != (sizeof(struct phys_disk) + + if (be32_eq(*magic, DDF_PHYS_RECORDS_MAGIC)) { + if (update->len == (sizeof(struct phys_disk) + sizeof(struct phys_disk_entry))) - return; - pd = (struct phys_disk*)update->buf; - - ent = __be16_to_cpu(pd->used_pdes); - if (ent >= __be16_to_cpu(ddf->phys->max_pdes)) - return; - if (pd->entries[0].state & __cpu_to_be16(DDF_Missing)) { - struct dl **dlp; - /* removing this disk. */ - ddf->phys->entries[ent].state |= __cpu_to_be16(DDF_Missing); - for (dlp = &ddf->dlist; *dlp; dlp = &(*dlp)->next) { - struct dl *dl = *dlp; - if (dl->pdnum == (signed)ent) { - close(dl->fd); - dl->fd = -1; - /* FIXME this doesn't free - * dl->devname */ - update->space = dl; - *dlp = dl->next; - break; - } - } - ddf_set_updates_pending(ddf); - return; - } - if (!all_ff(ddf->phys->entries[ent].guid)) - return; - ddf->phys->entries[ent] = pd->entries[0]; - ddf->phys->used_pdes = __cpu_to_be16(1 + - __be16_to_cpu(ddf->phys->used_pdes)); - ddf_set_updates_pending(ddf); - if (ddf->add_list) { - struct active_array *a; - struct dl *al = ddf->add_list; - ddf->add_list = al->next; - - al->next = ddf->dlist; - ddf->dlist = al; - - /* As a device has been added, we should check - * for any degraded devices that might make - * use of this spare */ - for (a = st->arrays ; a; a=a->next) - a->check_degraded = 1; - } - break; - - case DDF_VIRT_RECORDS_MAGIC: - - if (update->len != (sizeof(struct virtual_disk) + + ddf_process_phys_update(st, update); + } else if (be32_eq(*magic, DDF_VIRT_RECORDS_MAGIC)) { + if (update->len == (sizeof(struct virtual_disk) + sizeof(struct virtual_entry))) - return; - vd = (struct virtual_disk*)update->buf; - - if (vd->entries[0].state == DDF_state_deleted) { - if (_kill_subarray_ddf(ddf, vd->entries[0].guid)) - return; - } else { - - ent = find_unused_vde(ddf); - if (ent == DDF_NOTFOUND) - return; - ddf->virt->entries[ent] = vd->entries[0]; - ddf->virt->populated_vdes = - __cpu_to_be16( - 1 + __be16_to_cpu( - ddf->virt->populated_vdes)); - } - ddf_set_updates_pending(ddf); - break; - - case DDF_VD_CONF_MAGIC: - dprintf("len %d %d\n", update->len, ddf->conf_rec_len); - - mppe = __be16_to_cpu(ddf->anchor.max_primary_element_entries); - if ((unsigned)update->len != ddf->conf_rec_len * 512) - return; - vc = (struct vd_config*)update->buf; - for (vcl = ddf->conflist; vcl ; vcl = vcl->next) - if (memcmp(vcl->conf.guid, vc->guid, DDF_GUID_LEN) == 0) - break; - dprintf("vcl = %p\n", vcl); - if (vcl) { - /* An update, just copy the phys_refnum and lba_offset - * fields - */ - struct vd_config *conf = &vcl->conf; - if (vcl->other_bvds != NULL && - conf->sec_elmnt_seq != vc->sec_elmnt_seq) { - unsigned int i; - for (i = 1; i < conf->sec_elmnt_count; i++) - if (vcl->other_bvds[i-1]->sec_elmnt_seq - == vc->sec_elmnt_seq) - break; - if (i == conf->sec_elmnt_count) { - pr_err("%s/DDF_VD_CONF_MAGIC: BVD %u not found\n", - __func__, vc->sec_elmnt_seq); - return; - } - conf = vcl->other_bvds[i-1]; - } - memcpy(conf->phys_refnum, vc->phys_refnum, - mppe * (sizeof(__u32) + sizeof(__u64))); - } else { - /* A new VD_CONF */ - if (!update->space) - return; - vcl = update->space; - update->space = NULL; - vcl->next = ddf->conflist; - memcpy(&vcl->conf, vc, update->len); - ent = find_vde_by_guid(ddf, vc->guid); - if (ent == DDF_NOTFOUND) - return; - vcl->vcnum = ent; - ddf->conflist = vcl; - } - /* Set DDF_Transition on all Failed devices - to help - * us detect those that are no longer in use - */ - for (pdnum = 0; pdnum < __be16_to_cpu(ddf->phys->used_pdes); pdnum++) - if (ddf->phys->entries[pdnum].state - & __be16_to_cpu(DDF_Failed)) - ddf->phys->entries[pdnum].state - |= __be16_to_cpu(DDF_Transition); - /* Now make sure vlist is correct for each dl. */ - for (dl = ddf->dlist; dl; dl = dl->next) { - unsigned int vn = 0; - int in_degraded = 0; - for (vcl = ddf->conflist; vcl ; vcl = vcl->next) { - unsigned int dn, ibvd; - const struct vd_config *conf; - int vstate; - dn = get_pd_index_from_refnum(vcl, - dl->disk.refnum, - ddf->mppe, - &conf, &ibvd); - if (dn == DDF_NOTFOUND) - continue; - dprintf("dev %d/%08x has %s (sec=%u) at %d\n", - dl->pdnum, dl->disk.refnum, - guid_str(conf->guid), - conf->sec_elmnt_seq, vn); - /* Clear the Transition flag */ - if (ddf->phys->entries[dl->pdnum].state - & __be16_to_cpu(DDF_Failed)) - ddf->phys->entries[dl->pdnum].state &= - ~__be16_to_cpu(DDF_Transition); - dl->vlist[vn++] = vcl; - vstate = ddf->virt->entries[vcl->vcnum].state - & DDF_state_mask; - if (vstate == DDF_state_degraded || - vstate == DDF_state_part_optimal) - in_degraded = 1; - } - while (vn < ddf->max_part) - dl->vlist[vn++] = NULL; - if (dl->vlist[0]) { - ddf->phys->entries[dl->pdnum].type &= - ~__cpu_to_be16(DDF_Global_Spare); - if (!(ddf->phys->entries[dl->pdnum].type & - __cpu_to_be16(DDF_Active_in_VD))) { - ddf->phys->entries[dl->pdnum].type |= - __cpu_to_be16(DDF_Active_in_VD); - if (in_degraded) - ddf->phys->entries[dl->pdnum].state |= - __cpu_to_be16(DDF_Rebuilding); - } - } - if (dl->spare) { - ddf->phys->entries[dl->pdnum].type &= - ~__cpu_to_be16(DDF_Global_Spare); - ddf->phys->entries[dl->pdnum].type |= - __cpu_to_be16(DDF_Spare); - } - if (!dl->vlist[0] && !dl->spare) { - ddf->phys->entries[dl->pdnum].type |= - __cpu_to_be16(DDF_Global_Spare); - ddf->phys->entries[dl->pdnum].type &= - ~__cpu_to_be16(DDF_Spare | - DDF_Active_in_VD); - } - } - - /* Now remove any 'Failed' devices that are not part - * of any VD. They will have the Transition flag set. - * Once done, we need to update all dl->pdnum numbers. - */ - pd2 = 0; - for (pdnum = 0; pdnum < __be16_to_cpu(ddf->phys->used_pdes); pdnum++) - if ((ddf->phys->entries[pdnum].state - & __be16_to_cpu(DDF_Failed)) - && (ddf->phys->entries[pdnum].state - & __be16_to_cpu(DDF_Transition))) - /* skip this one */; - else if (pdnum == pd2) - pd2++; - else { - ddf->phys->entries[pd2] = ddf->phys->entries[pdnum]; - for (dl = ddf->dlist; dl; dl = dl->next) - if (dl->pdnum == (int)pdnum) - dl->pdnum = pd2; - pd2++; - } - ddf->phys->used_pdes = __cpu_to_be16(pd2); - while (pd2 < pdnum) { - memset(ddf->phys->entries[pd2].guid, 0xff, DDF_GUID_LEN); - pd2++; - } - - ddf_set_updates_pending(ddf); - break; - case DDF_SPARE_ASSIGN_MAGIC: - default: break; + ddf_process_virt_update(st, update); + } else if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { + ddf_process_conf_update(st, update); } + /* case DDF_SPARE_ASSIGN_MAGIC */ } -static void ddf_prepare_update(struct supertype *st, - struct metadata_update *update) +static int ddf_prepare_update(struct supertype *st, + struct metadata_update *update) { /* This update arrived at managemon. * We are about to pass it to monitor. * If a malloc is needed, do it here. */ struct ddf_super *ddf = st->sb; - __u32 *magic = (__u32*)update->buf; - if (*magic == DDF_VD_CONF_MAGIC) + be32 *magic; + if (update->len < 4) + return 0; + magic = (be32 *)update->buf; + if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { + struct vcl *vcl; + struct vd_config *conf; + if (update->len < (int)sizeof(*conf)) + return 0; + conf = (struct vd_config *) update->buf; if (posix_memalign(&update->space, 512, offsetof(struct vcl, conf) - + ddf->conf_rec_len * 512) != 0) + + ddf->conf_rec_len * 512) != 0) { update->space = NULL; + return 0; + } + vcl = update->space; + vcl->conf.sec_elmnt_count = conf->sec_elmnt_count; + if (alloc_other_bvds(ddf, vcl) != 0) { + free(update->space); + update->space = NULL; + return 0; + } + } + return 1; +} + +/* + * Check degraded state of a RAID10. + * returns 2 for good, 1 for degraded, 0 for failed, and -1 for error + */ +static int raid10_degraded(struct mdinfo *info) +{ + int n_prim, n_bvds; + int i; + struct mdinfo *d; + char *found; + int ret = -1; + + n_prim = info->array.layout & ~0x100; + n_bvds = info->array.raid_disks / n_prim; + found = xmalloc(n_bvds); + if (found == NULL) + return ret; + memset(found, 0, n_bvds); + for (d = info->devs; d; d = d->next) { + i = d->disk.raid_disk / n_prim; + if (i >= n_bvds) { + pr_err("%s: BUG: invalid raid disk\n", __func__); + goto out; + } + if (d->state_fd > 0) + found[i]++; + } + ret = 2; + for (i = 0; i < n_bvds; i++) + if (!found[i]) { + dprintf("%s: BVD %d/%d failed\n", __func__, i, n_bvds); + ret = 0; + goto out; + } else if (found[i] < n_prim) { + dprintf("%s: BVD %d/%d degraded\n", __func__, i, + n_bvds); + ret = 1; + } +out: + free(found); + return ret; } /* @@ -4530,7 +4992,7 @@ static void ddf_prepare_update(struct supertype *st, * arrange for their inclusion. * We only choose devices which are not already in the array, * and prefer those with a spare-assignment to this array. - * otherwise we choose global spares - assuming always that + * Otherwise we choose global spares - assuming always that * there is enough room. * For each spare that we assign, we return an 'mdinfo' which * describes the position for the device in the array. @@ -4551,6 +5013,7 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, struct metadata_update *mu; struct dl *dl; int i; + unsigned int j; struct vcl *vcl; struct vd_config *vc; unsigned int n_bvd; @@ -4564,7 +5027,8 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, working ++; } - dprintf("ddf_activate: working=%d (%d) level=%d\n", working, a->info.array.raid_disks, + dprintf("%s: working=%d (%d) level=%d\n", __func__, working, + a->info.array.raid_disks, a->info.array.level); if (working == a->info.array.raid_disks) return NULL; /* array not degraded */ @@ -4582,6 +5046,10 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, if (working < a->info.array.raid_disks - 2) return NULL; /* failed */ break; + case 10: + if (raid10_degraded(&a->info) < 1) + return NULL; + break; default: /* concat or stripe */ return NULL; /* failed */ } @@ -4604,26 +5072,40 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, struct mdinfo *d2; int is_global = 0; int is_dedicated = 0; - struct extent *ex; - unsigned int j; + be16 state; + + if (dl->pdnum < 0) + continue; + state = ddf->phys->entries[dl->pdnum].state; + if (be16_and(state, + cpu_to_be16(DDF_Failed|DDF_Missing)) || + !be16_and(state, + cpu_to_be16(DDF_Online))) + continue; + /* If in this array, skip */ for (d2 = a->info.devs ; d2 ; d2 = d2->next) if (d2->state_fd >= 0 && d2->disk.major == dl->major && d2->disk.minor == dl->minor) { - dprintf("%x:%x already in array\n", dl->major, dl->minor); + dprintf("%x:%x (%08x) already in array\n", + dl->major, dl->minor, + be32_to_cpu(dl->disk.refnum)); break; } if (d2) continue; - if (ddf->phys->entries[dl->pdnum].type & - __cpu_to_be16(DDF_Spare)) { + if (be16_and(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Spare))) { /* Check spare assign record */ if (dl->spare) { if (dl->spare->type & DDF_spare_dedicated) { /* check spare_ents for guid */ + unsigned int j; for (j = 0 ; - j < __be16_to_cpu(dl->spare->populated); + j < be16_to_cpu + (dl->spare + ->populated); j++) { if (memcmp(dl->spare->spare_ents[j].guid, ddf->virt->entries[a->info.container_member].guid, @@ -4633,11 +5115,12 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, } else is_global = 1; } - } else if (ddf->phys->entries[dl->pdnum].type & - __cpu_to_be16(DDF_Global_Spare)) { + } else if (be16_and(ddf->phys->entries[dl->pdnum].type, + cpu_to_be16(DDF_Global_Spare))) { is_global = 1; - } else if (!(ddf->phys->entries[dl->pdnum].state & - __cpu_to_be16(DDF_Failed))) { + } else if (!be16_and(ddf->phys + ->entries[dl->pdnum].state, + cpu_to_be16(DDF_Failed))) { /* we can possibly use some of this */ is_global = 1; } @@ -4650,23 +5133,9 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, /* We are allowed to use this device - is there space? * We need a->info.component_size sectors */ - ex = get_extents(ddf, dl); - if (!ex) { - dprintf("cannot get extents\n"); - continue; - } - j = 0; pos = 0; - esize = 0; + esize = a->info.component_size; + pos = find_space(ddf, dl, INVALID_SECTORS, &esize); - do { - esize = ex[j].start - pos; - if (esize >= a->info.component_size) - break; - pos = ex[j].start + ex[j].size; - j++; - } while (ex[j-1].size); - - free(ex); if (esize < a->info.component_size) { dprintf("%x:%x has no room: %llu %llu\n", dl->major, dl->minor, @@ -4685,11 +5154,11 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, di->recovery_start = 0; di->data_offset = pos; di->component_size = a->info.component_size; - di->container_member = dl->pdnum; di->next = rv; rv = di; - dprintf("%x:%x to be %d at %llu\n", dl->major, dl->minor, - i, pos); + dprintf("%x:%x (%08x) to be %d at %llu\n", + dl->major, dl->minor, + be32_to_cpu(dl->disk.refnum), i, pos); break; } @@ -4708,26 +5177,51 @@ static struct mdinfo *ddf_activate_spare(struct active_array *a, * Create a metadata_update record to update the * phys_refnum and lba_offset values */ + vc = find_vdcr(ddf, a->info.container_member, rv->disk.raid_disk, + &n_bvd, &vcl); + if (vc == NULL) + return NULL; + mu = xmalloc(sizeof(*mu)); if (posix_memalign(&mu->space, 512, sizeof(struct vcl)) != 0) { free(mu); mu = NULL; } - mu->buf = xmalloc(ddf->conf_rec_len * 512); - mu->len = ddf->conf_rec_len * 512; + + mu->len = ddf->conf_rec_len * 512 * vcl->conf.sec_elmnt_count; + mu->buf = xmalloc(mu->len); mu->space = NULL; mu->space_list = NULL; mu->next = *updates; - vc = find_vdcr(ddf, a->info.container_member, di->disk.raid_disk, - &n_bvd, &vcl); - memcpy(mu->buf, vc, ddf->conf_rec_len * 512); + memcpy(mu->buf, &vcl->conf, ddf->conf_rec_len * 512); + for (j = 1; j < vcl->conf.sec_elmnt_count; j++) + memcpy(mu->buf + j * ddf->conf_rec_len * 512, + vcl->other_bvds[j-1], ddf->conf_rec_len * 512); vc = (struct vd_config*)mu->buf; for (di = rv ; di ; di = di->next) { - vc->phys_refnum[di->disk.raid_disk] = - ddf->phys->entries[dl->pdnum].refnum; - LBA_OFFSET(ddf, vc)[di->disk.raid_disk] - = __cpu_to_be64(di->data_offset); + unsigned int i_sec, i_prim; + i_sec = di->disk.raid_disk + / be16_to_cpu(vcl->conf.prim_elmnt_count); + i_prim = di->disk.raid_disk + % be16_to_cpu(vcl->conf.prim_elmnt_count); + vc = (struct vd_config *)(mu->buf + + i_sec * ddf->conf_rec_len * 512); + for (dl = ddf->dlist; dl; dl = dl->next) + if (dl->major == di->disk.major + && dl->minor == di->disk.minor) + break; + if (!dl || dl->pdnum < 0) { + pr_err("%s: BUG: can't find disk %d (%d/%d)\n", + __func__, di->disk.raid_disk, + di->disk.major, di->disk.minor); + return NULL; + } + vc->phys_refnum[i_prim] = ddf->phys->entries[dl->pdnum].refnum; + LBA_OFFSET(ddf, vc)[i_prim] = cpu_to_be64(di->data_offset); + dprintf("BVD %u gets %u: %08x at %llu\n", i_sec, i_prim, + be32_to_cpu(vc->phys_refnum[i_prim]), + be64_to_cpu(LBA_OFFSET(ddf, vc)[i_prim])); } *updates = mu; return rv; @@ -4774,6 +5268,7 @@ struct superswitch super_ddf = { .remove_from_super = remove_from_super_ddf, .load_container = load_container_ddf, .copy_metadata = copy_metadata_ddf, + .kill_subarray = kill_subarray_ddf, #endif .match_home = match_home_ddf, .uuid_from_super= uuid_from_super_ddf, @@ -4791,7 +5286,6 @@ struct superswitch super_ddf = { .match_metadata_desc = match_metadata_desc_ddf, .container_content = container_content_ddf, .default_geometry = default_geometry_ddf, - .kill_subarray = kill_subarray_ddf, .external = 1,