From 46a533a90c01b0492577c61d4e65de2ac4bf220c Mon Sep 17 00:00:00 2001 From: Jes Sorensen Date: Tue, 11 Apr 2017 14:25:24 -0400 Subject: [PATCH] super1: Clean up various style abuses Code is 80 characters wide, so lets try to respect that. In addition, we should never have one-line 'if () action()' statements. Fixup various whitespace abuse. Signed-off-by: Jes Sorensen --- super1.c | 363 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 223 insertions(+), 140 deletions(-) diff --git a/super1.c b/super1.c index 4db4dff..2fcb814 100644 --- a/super1.c +++ b/super1.c @@ -227,6 +227,7 @@ static void init_afd(struct align_fd *afd, int fd) } static char abuf[4096+4096]; + static int aread(struct align_fd *afd, void *buf, int len) { /* aligned read. @@ -339,7 +340,8 @@ static void examine_super1(struct supertype *st, char *homehost) strncmp(sb->set_name, homehost, l) == 0) printf(" (local to host %s)", homehost); printf("\n"); - if (bms->nodes > 0 && (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) + if (bms->nodes > 0 && + (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) printf(" Cluster Name : %-64s\n", bms->cluster_name); atime = __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL; printf(" Creation Time : %.24s\n", ctime(&atime)); @@ -385,7 +387,8 @@ static void examine_super1(struct supertype *st, char *homehost) printf(" Super Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->super_offset)); if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET) - printf("Recovery Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->recovery_offset)); + printf("Recovery Offset : %llu sectors\n", + (unsigned long long)__le64_to_cpu(sb->recovery_offset)); st->ss->getinfo_super(st, &info, NULL); if (info.space_after != 1 && @@ -393,10 +396,12 @@ static void examine_super1(struct supertype *st, char *homehost) printf(" Unused Space : before=%llu sectors, after=%llu sectors\n", info.space_before, info.space_after); - printf(" State : %s\n", (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean"); + printf(" State : %s\n", + (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean"); printf(" Device UUID : "); for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); + if ((i&3)==0 && i != 0) + printf(":"); printf("%02x", sb->device_uuid[i]); } printf("\n"); @@ -410,12 +415,15 @@ static void examine_super1(struct supertype *st, char *homehost) __le16_to_cpu(sb->ppl.offset)); } if (sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)) { - printf(" Reshape pos'n : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->reshape_position)/2, + printf(" Reshape pos'n : %llu%s\n", (unsigned long long) + __le64_to_cpu(sb->reshape_position)/2, human_size(__le64_to_cpu(sb->reshape_position)<<9)); if (__le32_to_cpu(sb->delta_disks)) { - printf(" Delta Devices : %d", __le32_to_cpu(sb->delta_disks)); + printf(" Delta Devices : %d", + __le32_to_cpu(sb->delta_disks)); printf(" (%d->%d)\n", - __le32_to_cpu(sb->raid_disks)-__le32_to_cpu(sb->delta_disks), + __le32_to_cpu(sb->raid_disks) - + __le32_to_cpu(sb->delta_disks), __le32_to_cpu(sb->raid_disks)); if ((int)__le32_to_cpu(sb->delta_disks) < 0) delta_extra = -__le32_to_cpu(sb->delta_disks); @@ -424,13 +432,16 @@ static void examine_super1(struct supertype *st, char *homehost) c = map_num(pers, __le32_to_cpu(sb->new_level)); printf(" New Level : %s\n", c?c:"-unknown-"); } - if (__le32_to_cpu(sb->new_layout) != __le32_to_cpu(sb->layout)) { + if (__le32_to_cpu(sb->new_layout) != + __le32_to_cpu(sb->layout)) { if (__le32_to_cpu(sb->level) == 5) { - c = map_num(r5layout, __le32_to_cpu(sb->new_layout)); + c = map_num(r5layout, + __le32_to_cpu(sb->new_layout)); printf(" New Layout : %s\n", c?c:"-unknown-"); } if (__le32_to_cpu(sb->level) == 6) { - c = map_num(r6layout, __le32_to_cpu(sb->new_layout)); + c = map_num(r6layout, + __le32_to_cpu(sb->new_layout)); printf(" New Layout : %s\n", c?c:"-unknown-"); } if (__le32_to_cpu(sb->level) == 10) { @@ -439,8 +450,10 @@ static void examine_super1(struct supertype *st, char *homehost) printf("\n"); } } - if (__le32_to_cpu(sb->new_chunk) != __le32_to_cpu(sb->chunksize)) - printf(" New Chunksize : %dK\n", __le32_to_cpu(sb->new_chunk)/2); + if (__le32_to_cpu(sb->new_chunk) != + __le32_to_cpu(sb->chunksize)) + printf(" New Chunksize : %dK\n", + __le32_to_cpu(sb->new_chunk)/2); printf("\n"); } if (sb->devflags) { @@ -459,18 +472,20 @@ static void examine_super1(struct supertype *st, char *homehost) printf(" Bad Block Log : %d entries available at offset %ld sectors", __le16_to_cpu(sb->bblog_size)*512/8, (long)(int32_t)__le32_to_cpu(sb->bblog_offset)); - if (sb->feature_map & - __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) + if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) printf(" - bad blocks present."); printf("\n"); } if (calc_sb_1_csum(sb) == sb->sb_csum) - printf(" Checksum : %x - correct\n", __le32_to_cpu(sb->sb_csum)); + printf(" Checksum : %x - correct\n", + __le32_to_cpu(sb->sb_csum)); else - printf(" Checksum : %x - expected %x\n", __le32_to_cpu(sb->sb_csum), + printf(" Checksum : %x - expected %x\n", + __le32_to_cpu(sb->sb_csum), __le32_to_cpu(calc_sb_1_csum(sb))); - printf(" Events : %llu\n", (unsigned long long)__le64_to_cpu(sb->events)); + printf(" Events : %llu\n", + (unsigned long long)__le64_to_cpu(sb->events)); printf("\n"); if (__le32_to_cpu(sb->level) == 5) { c = map_num(r5layout, __le32_to_cpu(sb->layout)); @@ -492,26 +507,34 @@ static void examine_super1(struct supertype *st, char *homehost) case 5: case 6: case 10: - printf(" Chunk Size : %dK\n", __le32_to_cpu(sb->chunksize)/2); + printf(" Chunk Size : %dK\n", + __le32_to_cpu(sb->chunksize)/2); break; case -1: - printf(" Rounding : %dK\n", __le32_to_cpu(sb->chunksize)/2); + printf(" Rounding : %dK\n", + __le32_to_cpu(sb->chunksize)/2); + break; + default: break; - default: break; } printf("\n"); #if 0 /* This turns out to just be confusing */ printf(" Array Slot : %d (", __le32_to_cpu(sb->dev_number)); - for (i= __le32_to_cpu(sb->max_dev); i> 0 ; i--) + for (i = __le32_to_cpu(sb->max_dev); i> 0 ; i--) if (__le16_to_cpu(sb->dev_roles[i-1]) != MD_DISK_ROLE_SPARE) break; - for (d=0; d < i; d++) { + for (d = 0; d < i; d++) { int role = __le16_to_cpu(sb->dev_roles[d]); - if (d) printf(", "); - if (role == MD_DISK_ROLE_SPARE) printf("empty"); - else if(role == MD_DISK_ROLE_FAULTY) printf("failed"); - else printf("%d", role); + if (d) + printf(", "); + if (role == MD_DISK_ROLE_SPARE) + printf("empty"); + else + if(role == MD_DISK_ROLE_FAULTY) + printf("failed"); + else + printf("%d", role); } printf(")\n"); #endif @@ -527,10 +550,10 @@ static void examine_super1(struct supertype *st, char *homehost) printf("Active device %d\n", role); printf(" Array State : "); - for (d=0; d<__le32_to_cpu(sb->raid_disks) + delta_extra; d++) { + for (d = 0; d < __le32_to_cpu(sb->raid_disks) + delta_extra; d++) { int cnt = 0; unsigned int i; - for (i=0; i< __le32_to_cpu(sb->max_dev); i++) { + for (i = 0; i < __le32_to_cpu(sb->max_dev); i++) { unsigned int role = __le16_to_cpu(sb->dev_roles[i]); if (role == d) cnt++; @@ -547,12 +570,13 @@ static void examine_super1(struct supertype *st, char *homehost) #if 0 /* This is confusing too */ faulty = 0; - for (i=0; i< __le32_to_cpu(sb->max_dev); i++) { + for (i = 0; i< __le32_to_cpu(sb->max_dev); i++) { int role = __le16_to_cpu(sb->dev_roles[i]); if (role == MD_DISK_ROLE_FAULTY) faulty++; } - if (faulty) printf(" %d failed", faulty); + if (faulty) + printf(" %d failed", faulty); #endif printf(" ('A' == active, '.' == missing, 'R' == replacing)"); printf("\n"); @@ -564,7 +588,7 @@ static void brief_examine_super1(struct supertype *st, int verbose) int i; unsigned long long sb_offset; char *nm; - char *c=map_num(pers, __le32_to_cpu(sb->level)); + char *c = map_num(pers, __le32_to_cpu(sb->level)); nm = strchr(sb->set_name, ':'); if (nm) @@ -592,8 +616,9 @@ static void brief_examine_super1(struct supertype *st, int verbose) if (verbose) printf("num-devices=%d ", __le32_to_cpu(sb->raid_disks)); printf("UUID="); - for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); + for (i = 0; i < 16; i++) { + if ((i&3)==0 && i != 0) + printf(":"); printf("%02x", sb->set_uuid[i]); } if (sb->set_name[0]) { @@ -612,9 +637,8 @@ static void export_examine_super1(struct supertype *st) printf("MD_LEVEL=%s\n", map_num(pers, __le32_to_cpu(sb->level))); printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks)); - for (i=0; i<32; i++) - if (sb->set_name[i] == '\n' || - sb->set_name[i] == '\0') { + for (i = 0; i < 32; i++) + if (sb->set_name[i] == '\n' || sb->set_name[i] == '\0') { len = i; break; } @@ -623,10 +647,16 @@ static void export_examine_super1(struct supertype *st) if (__le32_to_cpu(sb->level) > 0) { int ddsks = 0, ddsks_denom = 1; switch(__le32_to_cpu(sb->level)) { - case 1: ddsks=1;break; + case 1: + ddsks = 1; + break; case 4: - case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break; - case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break; + case 5: + ddsks = __le32_to_cpu(sb->raid_disks)-1; + break; + case 6: + ddsks = __le32_to_cpu(sb->raid_disks)-2; + break; case 10: layout = __le32_to_cpu(sb->layout); ddsks = __le32_to_cpu(sb->raid_disks); @@ -635,20 +665,23 @@ static void export_examine_super1(struct supertype *st) if (ddsks) { long long asize = __le64_to_cpu(sb->size); asize = (asize << 9) * ddsks / ddsks_denom; - printf("MD_ARRAY_SIZE=%s\n",human_size_brief(asize,JEDEC)); + printf("MD_ARRAY_SIZE=%s\n", + human_size_brief(asize, JEDEC)); } } printf("MD_UUID="); - for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); + for (i = 0; i < 16; i++) { + if ((i&3) == 0 && i != 0) + printf(":"); printf("%02x", sb->set_uuid[i]); } printf("\n"); printf("MD_UPDATE_TIME=%llu\n", __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL); printf("MD_DEV_UUID="); - for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); + for (i = 0; i < 16; i++) { + if ((i&3) == 0 && i != 0) + printf(":"); printf("%02x", sb->device_uuid[i]); } printf("\n"); @@ -797,15 +830,16 @@ static void detail_super1(struct supertype *st, char *homehost) int l = homehost ? strlen(homehost) : 0; printf(" Name : %.32s", sb->set_name); - if (l > 0 && l < 32 && - sb->set_name[l] == ':' && + if (l > 0 && l < 32 && sb->set_name[l] == ':' && strncmp(sb->set_name, homehost, l) == 0) printf(" (local to host %s)", homehost); - if (bms->nodes > 0 && (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) - printf("\n Cluster Name : %-64s", bms->cluster_name); + if (bms->nodes > 0 && + (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) + printf("\n Cluster Name : %-64s", bms->cluster_name); printf("\n UUID : "); - for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); + for (i = 0; i < 16; i++) { + if ((i&3) == 0 && i != 0) + printf(":"); printf("%02x", sb->set_uuid[i]); } printf("\n Events : %llu\n\n", @@ -822,8 +856,9 @@ static void brief_detail_super1(struct supertype *st) print_quoted(sb->set_name); } printf(" UUID="); - for (i=0; i<16; i++) { - if ((i&3)==0 && i != 0) printf(":"); + for (i = 0; i < 16; i++) { + if ((i & 3) == 0 && i != 0) + printf(":"); printf("%02x", sb->set_uuid[i]); } } @@ -834,9 +869,8 @@ static void export_detail_super1(struct supertype *st) int i; int len = 32; - for (i=0; i<32; i++) - if (sb->set_name[i] == '\n' || - sb->set_name[i] == '\0') { + for (i = 0; i < 32; i++) + if (sb->set_name[i] == '\n' || sb->set_name[i] == '\0') { len = i; break; } @@ -852,13 +886,12 @@ static int examine_badblocks_super1(struct supertype *st, int fd, char *devname) __u64 *bbl, *bbp; int i; - if (!sb->bblog_size || __le16_to_cpu(sb->bblog_size) > 100 - || !sb->bblog_offset){ + if (!sb->bblog_size || __le16_to_cpu(sb->bblog_size) > 100 || + !sb->bblog_offset){ printf("No bad-blocks list configured on %s\n", devname); return 0; } - if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) - == 0) { + if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) == 0) { printf("Bad-blocks list is empty in %s\n", devname); return 0; } @@ -905,8 +938,7 @@ static int match_home1(struct supertype *st, char *homehost) struct mdp_superblock_1 *sb = st->sb; int l = homehost ? strlen(homehost) : 0; - return (l > 0 && l < 32 && - sb->set_name[l] == ':' && + return (l > 0 && l < 32 && sb->set_name[l] == ':' && strncmp(sb->set_name, homehost, l) == 0); } @@ -915,7 +947,7 @@ static void uuid_from_super1(struct supertype *st, int uuid[4]) struct mdp_superblock_1 *super = st->sb; char *cuuid = (char*)uuid; int i; - for (i=0; i<16; i++) + for (i = 0; i < 16; i++) cuuid[i] = super->set_uuid[i]; } @@ -923,7 +955,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) { struct mdp_superblock_1 *sb = st->sb; struct bitmap_super_s *bsb = (void*)(((char*)sb)+MAX_SB_SIZE); - struct misc_dev_info *misc = (void*)(((char*)sb)+MAX_SB_SIZE+BM_SUPER_SIZE); + struct misc_dev_info *misc = + (void*)(((char*)sb)+MAX_SB_SIZE+BM_SUPER_SIZE); int working = 0; unsigned int i; unsigned int role; @@ -943,8 +976,7 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) info->array.utime = __le64_to_cpu(sb->utime); info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512; info->array.state = - (__le64_to_cpu(sb->resync_offset) == MaxSector) - ? 1 : 0; + (__le64_to_cpu(sb->resync_offset) == MaxSector) ? 1 : 0; if (__le32_to_cpu(bsb->nodes) > 1) info->array.state |= (1 << MD_SB_CLUSTERED); @@ -985,7 +1017,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) } if (super_offset + info->bitmap_offset + info->ppl_offset < end) - end = super_offset + info->bitmap_offset + info->ppl_offset; + end = super_offset + info->bitmap_offset + + info->ppl_offset; if (info->data_offset + data_size < end) info->space_after = end - data_size - info->data_offset; @@ -1002,8 +1035,9 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) if (bmend > earliest) earliest = bmend; } else if (info->ppl_offset > 0) { - unsigned long long pplend = info->ppl_offset + - info->ppl_size; + unsigned long long pplend; + + pplend = info->ppl_offset + info->ppl_size; if (pplend > earliest) earliest = pplend; } @@ -1018,7 +1052,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) info->space_before = info->data_offset - earliest; else info->space_before = 0; - info->space_after = misc->device_size - data_size - info->data_offset; + info->space_after = misc->device_size - data_size - + info->data_offset; } if (info->space_before == 0 && info->space_after == 0) { /* It will look like we don't support data_offset changes, @@ -1032,7 +1067,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) info->disk.raid_disk = -1; switch(role) { case MD_DISK_ROLE_SPARE: - info->disk.state = 0; /* spare: not active, not sync, not faulty */ + /* spare: not active, not sync, not faulty */ + info->disk.state = 0; break; case MD_DISK_ROLE_FAULTY: info->disk.state = (1 << MD_DISK_FAULTY); /* faulty */ @@ -1040,7 +1076,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map) case MD_DISK_ROLE_JOURNAL: info->disk.state = (1 << MD_DISK_JOURNAL); info->disk.raid_disk = role; - info->space_after = (misc->device_size - info->data_offset) % 8; /* journal uses all 4kB blocks*/ + /* journal uses all 4kB blocks*/ + info->space_after = (misc->device_size - info->data_offset) % 8; break; default: info->disk.state = 6; /* active and in sync */ @@ -1129,8 +1166,7 @@ static struct mdinfo *container_content1(struct supertype *st, char *subarray) } static int update_super1(struct supertype *st, struct mdinfo *info, - char *update, - char *devname, int verbose, + char *update, char *devname, int verbose, int uuid_set, char *homehost) { /* NOTE: for 'assemble' and 'force' we need to return non-zero @@ -1145,7 +1181,8 @@ static int update_super1(struct supertype *st, struct mdinfo *info, if (bms->version == BITMAP_MAJOR_CLUSTERED && dlm_funs_ready()) { rv = cluster_get_dlmlock(&lockid); if (rv) { - pr_err("Cannot get dlmlock in %s return %d\n", __func__, rv); + pr_err("Cannot get dlmlock in %s return %d\n", + __func__, rv); cluster_release_dlmlock(lockid); return rv; } @@ -1178,7 +1215,9 @@ static int update_super1(struct supertype *st, struct mdinfo *info, * maybe need to mark it 'clean'. */ switch(__le32_to_cpu(sb->level)) { - case 5: case 4: case 6: + case 4: + case 5: + case 6: /* need to force clean */ if (sb->resync_offset != MaxSector) rv = 1; @@ -1198,17 +1237,23 @@ static int update_super1(struct supertype *st, struct mdinfo *info, rv = 1; } if (info->reshape_active && - sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) && + sb->feature_map & + __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) && info->delta_disks >= 0 && - info->reshape_progress < __le64_to_cpu(sb->reshape_position)) { - sb->reshape_position = __cpu_to_le64(info->reshape_progress); + info->reshape_progress < + __le64_to_cpu(sb->reshape_position)) { + sb->reshape_position = + __cpu_to_le64(info->reshape_progress); rv = 1; } if (info->reshape_active && - sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) && + sb->feature_map & + __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) && info->delta_disks < 0 && - info->reshape_progress > __le64_to_cpu(sb->reshape_position)) { - sb->reshape_position = __cpu_to_le64(info->reshape_progress); + info->reshape_progress > + __le64_to_cpu(sb->reshape_position)) { + sb->reshape_position = + __cpu_to_le64(info->reshape_progress); rv = 1; } } else if (strcmp(update, "linear-grow-new") == 0) { @@ -1216,8 +1261,9 @@ static int update_super1(struct supertype *st, struct mdinfo *info, int fd; unsigned int max = __le32_to_cpu(sb->max_dev); - for (i=0 ; i < max ; i++) - if (__le16_to_cpu(sb->dev_roles[i]) >= MD_DISK_ROLE_FAULTY) + for (i = 0; i < max; i++) + if (__le16_to_cpu(sb->dev_roles[i]) >= + MD_DISK_ROLE_FAULTY) break; sb->dev_number = __cpu_to_le32(i); info->disk.number = i; @@ -1226,8 +1272,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info, random_uuid(sb->device_uuid); - sb->dev_roles[i] = - __cpu_to_le16(info->disk.raid_disk); + sb->dev_roles[i] = __cpu_to_le16(info->disk.raid_disk); fd = open(devname, O_RDONLY); if (fd >= 0) { @@ -1280,14 +1325,16 @@ static int update_super1(struct supertype *st, struct mdinfo *info, } if (sb_offset < data_offset) { - /* 1.1 or 1.2. Put bbl after bitmap leaving at least 32K + /* + * 1.1 or 1.2. Put bbl after bitmap leaving + * at least 32K */ long bb_offset; bb_offset = sb_offset + 8; if (bm_sectors && bitmap_offset > 0) bb_offset = bitmap_offset + bm_sectors; - while (bb_offset < (long)sb_offset + 8 + 32*2 - && bb_offset + 8+8 <= (long)data_offset) + while (bb_offset < (long)sb_offset + 8 + 32*2 && + bb_offset + 8+8 <= (long)data_offset) /* too close to bitmap, and room to grow */ bb_offset += 8; if (bb_offset + 8 <= (long)data_offset) { @@ -1381,8 +1428,8 @@ static int update_super1(struct supertype *st, struct mdinfo *info, } else strncpy(sb->set_name, info->name, sizeof(sb->set_name)); } else if (strcmp(update, "devicesize") == 0 && - __le64_to_cpu(sb->super_offset) < - __le64_to_cpu(sb->data_offset)) { + __le64_to_cpu(sb->super_offset) < + __le64_to_cpu(sb->data_offset)) { /* set data_size to device size less data_offset */ struct misc_dev_info *misc = (struct misc_dev_info*) (st->sb + MAX_SB_SIZE + BM_SUPER_SIZE); @@ -1390,7 +1437,8 @@ static int update_super1(struct supertype *st, struct mdinfo *info, misc->device_size - __le64_to_cpu(sb->data_offset)); } else if (strncmp(update, "revert-reshape", 14) == 0) { rv = -2; - if (!(sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE))) + if (!(sb->feature_map & + __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE))) pr_err("No active reshape to revert on %s\n", devname); else { @@ -1431,9 +1479,11 @@ static int update_super1(struct supertype *st, struct mdinfo *info, */ if (__le32_to_cpu(sb->level) >= 4 && __le32_to_cpu(sb->level) <= 6) { - reshape_sectors = __le64_to_cpu(sb->reshape_position); + reshape_sectors = + __le64_to_cpu(sb->reshape_position); reshape_chunk = __le32_to_cpu(sb->new_chunk); - reshape_chunk *= __le32_to_cpu(sb->raid_disks) - __le32_to_cpu(sb->delta_disks) - + reshape_chunk *= __le32_to_cpu(sb->raid_disks) - + __le32_to_cpu(sb->delta_disks) - (__le32_to_cpu(sb->level)==6 ? 2 : 1); if (reshape_sectors % reshape_chunk) { pr_err("Reshape position is not suitably aligned.\n"); @@ -1441,8 +1491,9 @@ static int update_super1(struct supertype *st, struct mdinfo *info, return -2; } } - sb->raid_disks = __cpu_to_le32(__le32_to_cpu(sb->raid_disks) - - __le32_to_cpu(sb->delta_disks)); + sb->raid_disks = + __cpu_to_le32(__le32_to_cpu(sb->raid_disks) - + __le32_to_cpu(sb->delta_disks)); if (sb->delta_disks == 0) sb->feature_map ^= __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS); else @@ -1456,19 +1507,21 @@ static int update_super1(struct supertype *st, struct mdinfo *info, sb->new_chunk = sb->chunksize; sb->chunksize = temp; - if (sb->feature_map & __cpu_to_le32(MD_FEATURE_NEW_OFFSET)) { - long offset_delta = (int32_t)__le32_to_cpu(sb->new_offset); + if (sb->feature_map & + __cpu_to_le32(MD_FEATURE_NEW_OFFSET)) { + long offset_delta = + (int32_t)__le32_to_cpu(sb->new_offset); sb->data_offset = __cpu_to_le64(__le64_to_cpu(sb->data_offset) + offset_delta); sb->new_offset = __cpu_to_le32(-offset_delta); sb->data_size = __cpu_to_le64(__le64_to_cpu(sb->data_size) - offset_delta); } done:; } - } else if (strcmp(update, "_reshape_progress")==0) + } else if (strcmp(update, "_reshape_progress") == 0) sb->reshape_position = __cpu_to_le64(info->reshape_progress); - else if (strcmp(update, "writemostly")==0) + else if (strcmp(update, "writemostly") == 0) sb->devflags |= WriteMostly1; - else if (strcmp(update, "readwrite")==0) + else if (strcmp(update, "readwrite") == 0) sb->devflags &= ~WriteMostly1; else if (strcmp(update, "failfast") == 0) sb->devflags |= FailFast1; @@ -1553,11 +1606,14 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info, sb->resync_offset = MaxSector; else sb->resync_offset = 0; - sbsize = sizeof(struct mdp_superblock_1) + 2 * (info->raid_disks + spares); + sbsize = sizeof(struct mdp_superblock_1) + + 2 * (info->raid_disks + spares); sbsize = ROUND_UP(sbsize, 512); - sb->max_dev = __cpu_to_le32((sbsize - sizeof(struct mdp_superblock_1)) / 2); + sb->max_dev = + __cpu_to_le32((sbsize - sizeof(struct mdp_superblock_1)) / 2); - memset(sb->dev_roles, 0xff, MAX_SB_SIZE - sizeof(struct mdp_superblock_1)); + memset(sb->dev_roles, 0xff, + MAX_SB_SIZE - sizeof(struct mdp_superblock_1)); if (s->consistency_policy == CONSISTENCY_POLICY_PPL) sb->feature_map |= __cpu_to_le32(MD_FEATURE_PPL); @@ -1587,7 +1643,8 @@ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk, if (bms->version == BITMAP_MAJOR_CLUSTERED && dlm_funs_ready()) { rv = cluster_get_dlmlock(&lockid); if (rv) { - pr_err("Cannot get dlmlock in %s return %d\n", __func__, rv); + pr_err("Cannot get dlmlock in %s return %d\n", + __func__, rv); cluster_release_dlmlock(lockid); return rv; } @@ -1599,7 +1656,8 @@ static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk, *rp = __cpu_to_le16(dk->raid_disk); else if (dk_state & (1< spare */ + else if ((dk_state & ~(1< spare */ *rp = MD_DISK_ROLE_SPARE; else *rp = MD_DISK_ROLE_FAULTY; @@ -1644,7 +1702,8 @@ static int store_super1(struct supertype *st, int fd) if (bms->version == BITMAP_MAJOR_CLUSTERED && dlm_funs_ready()) { rv = cluster_get_dlmlock(&lockid); if (rv) { - pr_err("Cannot get dlmlock in %s return %d\n", __func__, rv); + pr_err("Cannot get dlmlock in %s return %d\n", + __func__, rv); cluster_release_dlmlock(lockid); return rv; } @@ -1911,7 +1970,8 @@ static int write_init_super1(struct supertype *st) bm_space = calc_bitmap_size(bms, 4096) >> 9; bm_offset = (long)__le32_to_cpu(sb->bitmap_offset); } else if (sb->feature_map & __cpu_to_le32(MD_FEATURE_PPL)) { - bm_space = choose_ppl_space(__le32_to_cpu(sb->chunksize)); + bm_space = + choose_ppl_space(__le32_to_cpu(sb->chunksize)); if (bm_space > UINT16_MAX) bm_space = UINT16_MAX; if (st->minor_version == 0) { @@ -1981,7 +2041,10 @@ static int write_init_super1(struct supertype *st) rv = -EINVAL; goto out; } - /* Disable badblock log on clusters, or when explicitly requested */ + /* + * Disable badblock log on clusters, or when + * explicitly requested + */ if (st->nodes > 0 || conf_get_create_info()->bblist == 0) { sb->bblog_size = 0; sb->bblog_offset = 0; @@ -1997,7 +2060,8 @@ static int write_init_super1(struct supertype *st) } if (rv == 0 && - (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) { + (__le32_to_cpu(sb->feature_map) & + MD_FEATURE_BITMAP_OFFSET)) { rv = st->ss->write_bitmap(st, di->fd, NodeNumUpdate); } else if (rv == 0 && (__le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL)) { @@ -2014,8 +2078,7 @@ static int write_init_super1(struct supertype *st) } error_out: if (rv) - pr_err("Failed to write metadata to %s\n", - di->devname); + pr_err("Failed to write metadata to %s\n", di->devname); out: return rv; } @@ -2080,7 +2143,8 @@ static int load_super1(struct supertype *st, int fd, char *devname) /* guess... choose latest ctime */ memset(&tst, 0, sizeof(tst)); tst.ss = &super1; - for (tst.minor_version = 0; tst.minor_version <= 2 ; tst.minor_version++) { + for (tst.minor_version = 0; tst.minor_version <= 2; + tst.minor_version++) { switch(load_super1(&tst, fd, devname)) { case 0: super = tst.sb; if (bestvers == -1 || @@ -2167,7 +2231,8 @@ static int load_super1(struct supertype *st, int fd, char *devname) if (__le32_to_cpu(super->magic) != MD_SB_MAGIC) { if (devname) pr_err("No super block found on %s (Expected magic %08x, got %08x)\n", - devname, MD_SB_MAGIC, __le32_to_cpu(super->magic)); + devname, MD_SB_MAGIC, + __le32_to_cpu(super->magic)); free(super); return 2; } @@ -2190,7 +2255,8 @@ static int load_super1(struct supertype *st, int fd, char *devname) bsb = (struct bitmap_super_s *)(((char*)super)+MAX_SB_SIZE); - misc = (struct misc_dev_info*) (((char*)super)+MAX_SB_SIZE+BM_SUPER_SIZE); + misc = (struct misc_dev_info*) + (((char*)super)+MAX_SB_SIZE+BM_SUPER_SIZE); misc->device_size = dsize; if (st->data_offset == INVALID_SECTORS) st->data_offset = __le64_to_cpu(super->data_offset); @@ -2230,13 +2296,11 @@ static struct supertype *match_metadata_desc1(char *arg) /* leading zeros can be safely ignored. --detail generates them. */ while (*arg == '0') arg++; - if (strcmp(arg, "1.0") == 0 || - strcmp(arg, "1.00") == 0) { + if (strcmp(arg, "1.0") == 0 || strcmp(arg, "1.00") == 0) { st->minor_version = 0; return st; } - if (strcmp(arg, "1.1") == 0 || - strcmp(arg, "1.01") == 0 + if (strcmp(arg, "1.1") == 0 || strcmp(arg, "1.01") == 0 ) { st->minor_version = 1; return st; @@ -2249,8 +2313,7 @@ static struct supertype *match_metadata_desc1(char *arg) st->minor_version = 2; return st; } - if (strcmp(arg, "1") == 0 || - strcmp(arg, "default") == 0) { + if (strcmp(arg, "1") == 0 || strcmp(arg, "default") == 0) { st->minor_version = -1; return st; } @@ -2348,20 +2411,26 @@ add_internal_bitmap1(struct supertype *st, int uuid[4]; if (__le64_to_cpu(sb->data_size) == 0) - /* Must be creating the array, else data_size would be non-zero */ + /* + * Must be creating the array, else data_size + * would be non-zero + */ creating = 1; switch(st->minor_version) { case 0: - /* either 3K after the superblock (when hot-add), + /* + * either 3K after the superblock (when hot-add), * or some amount of space before. */ if (creating) { - /* We are creating array, so we *know* how much room has + /* + * We are creating array, so we *know* how much room has * been left. */ offset = 0; bbl_size = 8; - room = choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size; + room = + choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size; } else { room = __le64_to_cpu(sb->super_offset) - __le64_to_cpu(sb->data_offset) @@ -2373,8 +2442,8 @@ add_internal_bitmap1(struct supertype *st, if (bbl_size < -bbl_offset) bbl_size = -bbl_offset; - if (!may_change || (room < 3*2 && - __le32_to_cpu(sb->max_dev) <= 384)) { + if (!may_change || + (room < 3*2 && __le32_to_cpu(sb->max_dev) <= 384)) { room = 3*2; offset = 1*2; bbl_size = 0; @@ -2388,13 +2457,15 @@ add_internal_bitmap1(struct supertype *st, if (creating) { offset = 4*2; bbl_size = 8; - room = choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size; + room = + choose_bm_space(__le64_to_cpu(sb->size)) + bbl_size; } else { room = __le64_to_cpu(sb->data_offset) - __le64_to_cpu(sb->super_offset); bbl_size = __le16_to_cpu(sb->bblog_size); if (bbl_size) - room = __le32_to_cpu(sb->bblog_offset) + bbl_size; + room = + __le32_to_cpu(sb->bblog_offset) + bbl_size; else bbl_size = 8; @@ -2453,8 +2524,8 @@ add_internal_bitmap1(struct supertype *st, sb->bitmap_offset = (int32_t)__cpu_to_le32(offset); - sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) - | MD_FEATURE_BITMAP_OFFSET); + sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | + MD_FEATURE_BITMAP_OFFSET); memset(bms, 0, sizeof(*bms)); bms->magic = __cpu_to_le32(BITMAP_MAGIC); bms->version = __cpu_to_le32(major); @@ -2466,8 +2537,8 @@ add_internal_bitmap1(struct supertype *st, bms->write_behind = __cpu_to_le32(write_behind); bms->nodes = __cpu_to_le32(st->nodes); if (st->nodes) - sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) - | MD_FEATURE_BITMAP_VERSIONED); + sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | + MD_FEATURE_BITMAP_VERSIONED); if (st->cluster_name) { len = sizeof(bms->cluster_name); strncpy((char *)bms->cluster_name, st->cluster_name, len); @@ -2528,31 +2599,43 @@ static int write_bitmap1(struct supertype *st, int fd, enum bitmap_update update break; case NodeNumUpdate: /* cluster md only supports superblock 1.2 now */ - if (st->minor_version != 2 && bms->version == BITMAP_MAJOR_CLUSTERED) { + if (st->minor_version != 2 && + bms->version == BITMAP_MAJOR_CLUSTERED) { pr_err("Warning: cluster md only works with superblock 1.2\n"); return -EINVAL; } if (bms->version == BITMAP_MAJOR_CLUSTERED) { if (__cpu_to_le32(st->nodes) < bms->nodes) { - /* Since the nodes num is not increased, no need to check the space - * is enough or not, just update bms->nodes */ + /* + * Since the nodes num is not increased, no + * need to check the space enough or not, + * just update bms->nodes + */ bms->nodes = __cpu_to_le32(st->nodes); break; } } else { - /* no need to change bms->nodes for other bitmap types */ + /* + * no need to change bms->nodes for other + * bitmap types + */ if (st->nodes) pr_err("Warning: --nodes option is only suitable for clustered bitmap\n"); break; } - /* Each node has an independent bitmap, it is necessary to calculate the - * space is enough or not, first get how many bytes for the total bitmap */ + /* + * Each node has an independent bitmap, it is necessary to + * calculate the space is enough or not, first get how many + * bytes for the total bitmap + */ bm_space_per_node = calc_bitmap_size(bms, 4096); - total_bm_space = 512 * (__le64_to_cpu(sb->data_offset) - __le64_to_cpu(sb->super_offset)); - total_bm_space = total_bm_space - 4096; /* leave another 4k for superblock */ + total_bm_space = 512 * (__le64_to_cpu(sb->data_offset) - + __le64_to_cpu(sb->super_offset)); + /* leave another 4k for superblock */ + total_bm_space = total_bm_space - 4096; if (bm_space_per_node * st->nodes > total_bm_space) { pr_err("Warning: The max num of nodes can't exceed %llu\n",