From 60931cf94ad382a7973be941e17fefaa56a45b52 Mon Sep 17 00:00:00 2001 From: "mwilck@arcor.de" Date: Sun, 21 Jul 2013 19:28:20 +0200 Subject: [PATCH] DDF: convert big endian to be32 type Part 2 of endianness-safe conversion Signed-off-by: NeilBrown --- super-ddf.c | 346 ++++++++++++++++++++++++++-------------------------- 1 file changed, 175 insertions(+), 171 deletions(-) diff --git a/super-ddf.c b/super-ddf.c index 7f28d84..6226ef7 100644 --- a/super-ddf.c +++ b/super-ddf.c @@ -131,28 +131,28 @@ static inline be64 cpu_to_be64(__u64 x) #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; @@ -164,7 +164,7 @@ struct ddf_header { __u64 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 */ @@ -176,22 +176,22 @@ struct ddf_header { __u16 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 */ }; @@ -203,8 +203,8 @@ 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; @@ -219,14 +219,14 @@ struct ddf_controller_data { /* The content of phys_section - global scope */ struct phys_disk { - __u32 magic; /* DDF_PHYS_RECORDS_MAGIC */ - __u32 crc; + be32 magic; /* DDF_PHYS_RECORDS_MAGIC */ + be32 crc; __u16 used_pdes; __u16 max_pdes; __u8 pad[52]; struct phys_disk_entry { char guid[DDF_GUID_LEN]; - __u32 refnum; + be32 refnum; __u16 type; __u16 state; __u64 config_size; /* DDF structures must be after here */ @@ -260,8 +260,8 @@ struct phys_disk { /* The content of the virt_section global scope */ struct virtual_disk { - __u32 magic; /* DDF_VIRT_RECORDS_MAGIC */ - __u32 crc; + be32 magic; /* DDF_VIRT_RECORDS_MAGIC */ + be32 crc; __u16 populated_vdes; __u16 max_vdes; __u8 pad[52]; @@ -314,11 +314,11 @@ 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; __u8 chunk_shift; /* 0 == 512, 1==1024 etc */ @@ -332,7 +332,7 @@ struct vd_config { * for concat I hope) */ __u64 array_blocks; /* blocks in array */ __u8 pad1[8]; - __u32 spare_refs[8]; + be32 spare_refs[8]; __u8 cache_pol[8]; __u8 bg_rate; __u8 pad2[3]; @@ -343,7 +343,7 @@ 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 */ }; @@ -359,9 +359,9 @@ 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 */ @@ -381,10 +381,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]; @@ -393,15 +393,15 @@ struct disk_data { /* bbm_section content */ struct bad_block_log { - __u32 magic; - __u32 crc; + be32 magic; + be32 crc; __u16 entry_count; - __u32 spare_count; + be32 spare_count; __u8 pad[10]; __u64 first_spare; struct mapped_block { __u64 defective_start; - __u32 replacement_start; + be32 replacement_start; __u16 remap_count; __u8 pad[2]; } entries[0]; @@ -503,31 +503,31 @@ static void pr_state(const struct ddf_super *ddf, const char *msg) {} static void _ddf_set_updates_pending(struct ddf_super *ddf, const char *func) { ddf->updates_pending = 1; - ddf->active->seq = __cpu_to_be32((__be32_to_cpu(ddf->active->seq)+1)); + ddf->active->seq = cpu_to_be32((be32_to_cpu(ddf->active->seq)+1)); pr_state(ddf, func); } #define ddf_set_updates_pending(x) _ddf_set_updates_pending((x), __func__) 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); -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 * here for simplicity */ - return __cpu_to_be32(newcrc); + return cpu_to_be32(newcrc); } #define DDF_INVALID_LEVEL 0xff @@ -750,9 +750,9 @@ 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)) return 0; - if (calc_crc(hdr, 512) != hdr->crc) + if (!be32_eq(calc_crc(hdr, 512), hdr->crc)) return 0; if (memcmp(anchor->guid, hdr->guid, DDF_GUID_LEN) != 0 || memcmp(anchor->revision, hdr->revision, 8) != 0 || @@ -768,10 +768,10 @@ static int load_ddf_header(int fd, unsigned long long lba, } 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) @@ -827,13 +827,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); @@ -856,15 +856,16 @@ 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), dsize >> 9, 2, &super->secondary, &super->anchor)) { if (super->active == NULL - || (__be32_to_cpu(super->primary.seq) - < __be32_to_cpu(super->secondary.seq) && + || (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) && + || (be32_to_cpu(super->primary.seq) + == be32_to_cpu(super->secondary.seq) && super->primary.openflag && !super->secondary.openflag) ) super->active = &super->secondary; @@ -887,13 +888,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) { @@ -944,7 +945,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++) @@ -1025,13 +1027,13 @@ static int load_ddf_local(int fd, struct ddf_super *super, 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, @@ -1044,7 +1046,7 @@ 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)) continue; for (vcl = super->conflist; vcl; vcl = vcl->next) { if (memcmp(vcl->conf.guid, @@ -1059,8 +1061,8 @@ 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, @@ -1363,7 +1365,7 @@ 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; @@ -1375,7 +1377,8 @@ static void examine_vd(int n, struct ddf_super *sb, char *guid) int j; int cnt = __be16_to_cpu(sb->phys->used_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) @@ -1446,11 +1449,11 @@ static void examine_pds(struct ddf_super *sb) //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); 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); @@ -1485,14 +1488,15 @@ 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 + 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); @@ -1611,8 +1615,8 @@ 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; @@ -1702,7 +1706,7 @@ static int find_index_in_bvd(const struct ddf_super *ddf, 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) { + if (be32_to_cpu(conf->phys_refnum[i]) != 0xffffffff) { if (n == j) { *n_bvd = i; return 1; @@ -1764,14 +1768,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) + if (be32_eq(ddf->phys->entries[i].refnum, phys_refnum)) return i; return -1; } @@ -1846,7 +1850,7 @@ static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *m info->disk.major = 0; info->disk.minor = 0; if (ddf->dlist) { - info->disk.number = __be32_to_cpu(ddf->dlist->disk.refnum); + 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-> @@ -1903,7 +1907,7 @@ 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; @@ -1925,7 +1929,7 @@ static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, cha } for (dl = ddf->dlist; dl ; dl = dl->next) - if (dl->disk.refnum == conf->phys_refnum[cd]) + if (be32_eq(dl->disk.refnum, conf->phys_refnum[cd])) break; info->disk.major = 0; @@ -2052,7 +2056,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. @@ -2061,13 +2065,13 @@ 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); } @@ -2189,8 +2193,8 @@ static int init_super_ddf(struct supertype *st, 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?? */ @@ -2201,7 +2205,7 @@ static int init_super_ddf(struct supertype *st, ddf->anchor.secondary_lba = ~(__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_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 */ @@ -2218,8 +2222,8 @@ static int init_super_ddf(struct supertype *st, /* controller sections 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 */ @@ -2230,9 +2234,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 */ @@ -2243,26 +2247,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); @@ -2452,8 +2456,8 @@ 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 || @@ -2475,14 +2479,14 @@ static int init_super_ddf_bvd(struct supertype *st, 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); @@ -2599,7 +2603,7 @@ static void add_to_super_ddf_bvd(struct supertype *st, 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); dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n", - __func__, dl->pdnum, __be32_to_cpu(dl->disk.refnum), + __func__, dl->pdnum, be32_to_cpu(dl->disk.refnum), ddf->currentconf->vcnum, guid_str(vc->guid), dk->raid_disk); ddf_set_updates_pending(ddf); @@ -2679,10 +2683,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(); + 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); @@ -2863,7 +2868,7 @@ static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type) } if (c) { dprintf("writing conf record %i on disk %08x for %s/%u\n", - i, __be32_to_cpu(d->disk.refnum), + i, be32_to_cpu(d->disk.refnum), guid_str(vdc->guid), vdc->sec_elmnt_seq); vdc->seqnum = header->seq; @@ -2935,7 +2940,7 @@ static int _write_super_to_disk(struct ddf_super *ddf, struct dl *d) memcpy(&ddf->secondary, &ddf->anchor, 512); ddf->anchor.openflag = 0xFF; /* 'open' means nothing */ - ddf->anchor.seq = 0xFFFFFFFF; /* no sequencing in anchor */ + 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)) @@ -3443,7 +3448,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) { @@ -3562,7 +3567,7 @@ 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) { @@ -3573,9 +3578,9 @@ static unsigned int get_pd_index_from_refnum(const struct vcl *vc, for (i = 0, j = 0 ; i < nmax ; i++) { /* j counts valid entries for this BVD */ - if (vc->conf.phys_refnum[i] != 0xffffffff) + if (be32_to_cpu(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; @@ -3590,9 +3595,9 @@ 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) + if (be32_to_cpu(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; @@ -3649,7 +3654,7 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray 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; @@ -3688,7 +3693,8 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray 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); @@ -3705,8 +3711,8 @@ 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 */ @@ -3716,14 +3722,14 @@ static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray dev->next = this->devs; this->devs = dev; - dev->disk.number = __be32_to_cpu(d->disk.refnum); + 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<recovery_start = MaxSector; - dev->events = __be32_to_cpu(ddf->primary.seq); + dev->events = be32_to_cpu(ddf->primary.seq); dev->data_offset = __be64_to_cpu(LBA_OFFSET(ddf, bvd)[iphys]); dev->component_size = __be64_to_cpu(bvd->blocks); @@ -3810,10 +3816,10 @@ 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) { + if (!be32_eq(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)); + be32_to_cpu(first->anchor.seq), + be32_to_cpu(second->anchor.seq)); return 3; } if (first->max_part != second->max_part || @@ -3826,18 +3832,19 @@ static int compare_super_ddf(struct supertype *st, struct supertype *tst) 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) + if (be32_eq(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)); + be32_to_cpu(dl2->disk.refnum)); return 3; } } 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) + if (!be32_eq(vl2->conf.magic, DDF_VD_CONF_MAGIC)) continue; for (vd = 0; vd < max_vds; vd++) if (!memcmp(first->virt->entries[vd].guid, @@ -3900,7 +3907,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; @@ -3917,7 +3924,8 @@ 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; if (dl2->spare) { @@ -3944,7 +3952,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, - __be32_to_cpu(dl1->disk.refnum)); + be32_to_cpu(dl1->disk.refnum)); } return 0; @@ -4147,9 +4155,10 @@ 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, - __be32_to_cpu(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); + __func__, inst, n_bvd, + be32_to_cpu(vc->phys_refnum[n_bvd]), pd); if ((state & DS_INSYNC) && ! (state & DS_FAULTY)) { pd = dl->pdnum; /* FIXME: is this really correct ? */ vc->phys_refnum[n_bvd] = dl->disk.refnum; @@ -4349,7 +4358,7 @@ static void ddf_process_update(struct supertype *st, * a spare-assignment record. */ struct ddf_super *ddf = st->sb; - __u32 *magic = (__u32*)update->buf; + be32 *magic = (be32 *)update->buf; struct phys_disk *pd; struct virtual_disk *vd; struct vd_config *vc; @@ -4358,10 +4367,9 @@ static void ddf_process_update(struct supertype *st, unsigned int ent; unsigned int pdnum, pd2, len; - dprintf("Process update %x\n", *magic); + dprintf("Process update %x\n", be32_to_cpu(*magic)); - switch (*magic) { - case DDF_PHYS_RECORDS_MAGIC: + if (be32_eq(*magic, DDF_PHYS_RECORDS_MAGIC)) { if (update->len != (sizeof(struct phys_disk) + sizeof(struct phys_disk_entry))) @@ -4410,9 +4418,7 @@ static void ddf_process_update(struct supertype *st, for (a = st->arrays ; a; a=a->next) a->check_degraded = 1; } - break; - - case DDF_VIRT_RECORDS_MAGIC: + } else if (be32_eq(*magic, DDF_VIRT_RECORDS_MAGIC)) { if (update->len != (sizeof(struct virtual_disk) + sizeof(struct virtual_entry))) @@ -4445,9 +4451,9 @@ static void ddf_process_update(struct supertype *st, ddf->virt->entries[ent].init_state); } ddf_set_updates_pending(ddf); - break; + } - case DDF_VD_CONF_MAGIC: + else if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { vc = (struct vd_config*)update->buf; len = ddf->conf_rec_len * 512; if ((unsigned int)update->len != len * vc->sec_elmnt_count) { @@ -4512,7 +4518,7 @@ static void ddf_process_update(struct supertype *st, continue; dprintf("dev %d/%08x has %s (sec=%u) at %d\n", dl->pdnum, - __be32_to_cpu(dl->disk.refnum), + be32_to_cpu(dl->disk.refnum), guid_str(conf->guid), conf->sec_elmnt_seq, vn); /* Clear the Transition flag */ @@ -4583,10 +4589,8 @@ static void ddf_process_update(struct supertype *st, } ddf_set_updates_pending(ddf); - break; - case DDF_SPARE_ASSIGN_MAGIC: - default: break; } + /* case DDF_SPARE_ASSIGN_MAGIC */ } static void ddf_prepare_update(struct supertype *st, @@ -4597,8 +4601,8 @@ static void ddf_prepare_update(struct supertype *st, * 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 = (be32 *)update->buf; + if (be32_eq(*magic, DDF_VD_CONF_MAGIC)) { struct vcl *vcl; struct vd_config *conf = (struct vd_config *) update->buf; if (posix_memalign(&update->space, 512,