Martchus
/
mdadm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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 <jsorensen@fb.com>
This commit is contained in:
Jes Sorensen 2017-04-11 14:25:24 -04:00
parent 32141c1765
commit 46a533a90c
1 changed files with 223 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
super1.c
View File

@ -227,6 +227,7 @@ static void init_afd(struct align_fd *afd, int fd)
} }
static char abuf[4096+4096]; static char abuf[4096+4096];
static int aread(struct align_fd *afd, void *buf, int len) static int aread(struct align_fd *afd, void *buf, int len)
{ {
/* aligned read. /* aligned read.
@ -339,7 +340,8 @@ static void examine_super1(struct supertype *st, char *homehost)
strncmp(sb->set_name, homehost, l) == 0) strncmp(sb->set_name, homehost, l) == 0)
printf(" (local to host %s)", homehost); printf(" (local to host %s)", homehost);
printf("\n"); 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); printf(" Cluster Name : %-64s\n", bms->cluster_name);
atime = __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL; atime = __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL;
printf(" Creation Time : %.24s\n", ctime(&atime)); 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", printf(" Super Offset : %llu sectors\n",
(unsigned long long)__le64_to_cpu(sb->super_offset)); (unsigned long long)__le64_to_cpu(sb->super_offset));
if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_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); st->ss->getinfo_super(st, &info, NULL);
if (info.space_after != 1 && 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", printf(" Unused Space : before=%llu sectors, after=%llu sectors\n",
info.space_before, info.space_after); 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 : "); printf(" Device UUID : ");
for (i=0; i<16; i++) { 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("%02x", sb->device_uuid[i]);
} }
printf("\n"); printf("\n");
@ -410,12 +415,15 @@ static void examine_super1(struct supertype *st, char *homehost)
__le16_to_cpu(sb->ppl.offset)); __le16_to_cpu(sb->ppl.offset));
} }
if (sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)) { 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)); human_size(__le64_to_cpu(sb->reshape_position)<<9));
if (__le32_to_cpu(sb->delta_disks)) { 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", 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)); __le32_to_cpu(sb->raid_disks));
if ((int)__le32_to_cpu(sb->delta_disks) < 0) if ((int)__le32_to_cpu(sb->delta_disks) < 0)
delta_extra = -__le32_to_cpu(sb->delta_disks); 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)); c = map_num(pers, __le32_to_cpu(sb->new_level));
printf(" New Level : %s\n", c?c:"-unknown-"); 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) { 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-"); printf(" New Layout : %s\n", c?c:"-unknown-");
} }
if (__le32_to_cpu(sb->level) == 6) { 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-"); printf(" New Layout : %s\n", c?c:"-unknown-");
} }
if (__le32_to_cpu(sb->level) == 10) { if (__le32_to_cpu(sb->level) == 10) {
@ -439,8 +450,10 @@ static void examine_super1(struct supertype *st, char *homehost)
printf("\n"); printf("\n");
} }
} }
if (__le32_to_cpu(sb->new_chunk) != __le32_to_cpu(sb->chunksize)) if (__le32_to_cpu(sb->new_chunk) !=
printf(" New Chunksize : %dK\n", __le32_to_cpu(sb->new_chunk)/2); __le32_to_cpu(sb->chunksize))
printf(" New Chunksize : %dK\n",
__le32_to_cpu(sb->new_chunk)/2);
printf("\n"); printf("\n");
} }
if (sb->devflags) { 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", printf(" Bad Block Log : %d entries available at offset %ld sectors",
__le16_to_cpu(sb->bblog_size)*512/8, __le16_to_cpu(sb->bblog_size)*512/8,
(long)(int32_t)__le32_to_cpu(sb->bblog_offset)); (long)(int32_t)__le32_to_cpu(sb->bblog_offset));
if (sb->feature_map & if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
__cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
printf(" - bad blocks present."); printf(" - bad blocks present.");
printf("\n"); printf("\n");
} }
if (calc_sb_1_csum(sb) == sb->sb_csum) 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 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))); __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"); printf("\n");
if (__le32_to_cpu(sb->level) == 5) { if (__le32_to_cpu(sb->level) == 5) {
c = map_num(r5layout, __le32_to_cpu(sb->layout)); 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 5:
case 6: case 6:
case 10: 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; break;
case -1: 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; break;
default: break;
} }
printf("\n"); printf("\n");
#if 0 #if 0
/* This turns out to just be confusing */ /* This turns out to just be confusing */
printf(" Array Slot : %d (", __le32_to_cpu(sb->dev_number)); 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) if (__le16_to_cpu(sb->dev_roles[i-1]) != MD_DISK_ROLE_SPARE)
break; break;
for (d=0; d < i; d++) { for (d = 0; d < i; d++) {
int role = __le16_to_cpu(sb->dev_roles[d]); int role = __le16_to_cpu(sb->dev_roles[d]);
if (d) printf(", "); if (d)
if (role == MD_DISK_ROLE_SPARE) printf("empty"); printf(", ");
else if(role == MD_DISK_ROLE_FAULTY) printf("failed"); if (role == MD_DISK_ROLE_SPARE)
else printf("%d", role); printf("empty");
else
if(role == MD_DISK_ROLE_FAULTY)
printf("failed");
else
printf("%d", role);
} }
printf(")\n"); printf(")\n");
#endif #endif
@ -527,10 +550,10 @@ static void examine_super1(struct supertype *st, char *homehost)
printf("Active device %d\n", role); printf("Active device %d\n", role);
printf(" Array State : "); 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; int cnt = 0;
unsigned int i; 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]); unsigned int role = __le16_to_cpu(sb->dev_roles[i]);
if (role == d) if (role == d)
cnt++; cnt++;
@ -547,12 +570,13 @@ static void examine_super1(struct supertype *st, char *homehost)
#if 0 #if 0
/* This is confusing too */ /* This is confusing too */
faulty = 0; 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]); int role = __le16_to_cpu(sb->dev_roles[i]);
if (role == MD_DISK_ROLE_FAULTY) if (role == MD_DISK_ROLE_FAULTY)
faulty++; faulty++;
} }
if (faulty) printf(" %d failed", faulty); if (faulty)
printf(" %d failed", faulty);
#endif #endif
printf(" ('A' == active, '.' == missing, 'R' == replacing)"); printf(" ('A' == active, '.' == missing, 'R' == replacing)");
printf("\n"); printf("\n");
@ -564,7 +588,7 @@ static void brief_examine_super1(struct supertype *st, int verbose)
int i; int i;
unsigned long long sb_offset; unsigned long long sb_offset;
char *nm; 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, ':'); nm = strchr(sb->set_name, ':');
if (nm) if (nm)
@ -592,8 +616,9 @@ static void brief_examine_super1(struct supertype *st, int verbose)
if (verbose) if (verbose)
printf("num-devices=%d ", __le32_to_cpu(sb->raid_disks)); printf("num-devices=%d ", __le32_to_cpu(sb->raid_disks));
printf("UUID="); printf("UUID=");
for (i=0; i<16; i++) { for (i = 0; i < 16; i++) {
if ((i&3)==0 && i != 0) printf(":"); if ((i&3)==0 && i != 0)
printf(":");
printf("%02x", sb->set_uuid[i]); printf("%02x", sb->set_uuid[i]);
} }
if (sb->set_name[0]) { 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_LEVEL=%s\n", map_num(pers, __le32_to_cpu(sb->level)));
printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks)); printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks));
for (i=0; i<32; i++) for (i = 0; i < 32; i++)
if (sb->set_name[i] == '\n' || if (sb->set_name[i] == '\n' || sb->set_name[i] == '\0') {
sb->set_name[i] == '\0') {
len = i; len = i;
break; break;
} }
@ -623,10 +647,16 @@ static void export_examine_super1(struct supertype *st)
if (__le32_to_cpu(sb->level) > 0) { if (__le32_to_cpu(sb->level) > 0) {
int ddsks = 0, ddsks_denom = 1; int ddsks = 0, ddsks_denom = 1;
switch(__le32_to_cpu(sb->level)) { switch(__le32_to_cpu(sb->level)) {
case 1: ddsks=1;break; case 1:
ddsks = 1;
break;
case 4: case 4:
case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break; case 5:
case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break; ddsks = __le32_to_cpu(sb->raid_disks)-1;
break;
case 6:
ddsks = __le32_to_cpu(sb->raid_disks)-2;
break;
case 10: case 10:
layout = __le32_to_cpu(sb->layout); layout = __le32_to_cpu(sb->layout);
ddsks = __le32_to_cpu(sb->raid_disks); ddsks = __le32_to_cpu(sb->raid_disks);
@ -635,20 +665,23 @@ static void export_examine_super1(struct supertype *st)
if (ddsks) { if (ddsks) {
long long asize = __le64_to_cpu(sb->size); long long asize = __le64_to_cpu(sb->size);
asize = (asize << 9) * ddsks / ddsks_denom; 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="); printf("MD_UUID=");
for (i=0; i<16; i++) { for (i = 0; i < 16; i++) {
if ((i&3)==0 && i != 0) printf(":"); if ((i&3) == 0 && i != 0)
printf(":");
printf("%02x", sb->set_uuid[i]); printf("%02x", sb->set_uuid[i]);
} }
printf("\n"); printf("\n");
printf("MD_UPDATE_TIME=%llu\n", printf("MD_UPDATE_TIME=%llu\n",
__le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL); __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL);
printf("MD_DEV_UUID="); printf("MD_DEV_UUID=");
for (i=0; i<16; i++) { 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("%02x", sb->device_uuid[i]);
} }
printf("\n"); printf("\n");
@ -797,15 +830,16 @@ static void detail_super1(struct supertype *st, char *homehost)
int l = homehost ? strlen(homehost) : 0; int l = homehost ? strlen(homehost) : 0;
printf(" Name : %.32s", sb->set_name); printf(" Name : %.32s", sb->set_name);
if (l > 0 && l < 32 && if (l > 0 && l < 32 && sb->set_name[l] == ':' &&
sb->set_name[l] == ':' &&
strncmp(sb->set_name, homehost, l) == 0) strncmp(sb->set_name, homehost, l) == 0)
printf(" (local to host %s)", homehost); printf(" (local to host %s)", homehost);
if (bms->nodes > 0 && (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) if (bms->nodes > 0 &&
printf("\n Cluster Name : %-64s", bms->cluster_name); (__le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET))
printf("\n Cluster Name : %-64s", bms->cluster_name);
printf("\n UUID : "); printf("\n UUID : ");
for (i=0; i<16; i++) { for (i = 0; i < 16; i++) {
if ((i&3)==0 && i != 0) printf(":"); if ((i&3) == 0 && i != 0)
printf(":");
printf("%02x", sb->set_uuid[i]); printf("%02x", sb->set_uuid[i]);
} }
printf("\n Events : %llu\n\n", printf("\n Events : %llu\n\n",
@ -822,8 +856,9 @@ static void brief_detail_super1(struct supertype *st)
print_quoted(sb->set_name); print_quoted(sb->set_name);
} }
printf(" UUID="); printf(" UUID=");
for (i=0; i<16; i++) { for (i = 0; i < 16; i++) {
if ((i&3)==0 && i != 0) printf(":"); if ((i & 3) == 0 && i != 0)
printf(":");
printf("%02x", sb->set_uuid[i]); printf("%02x", sb->set_uuid[i]);
} }
} }
@ -834,9 +869,8 @@ static void export_detail_super1(struct supertype *st)
int i; int i;
int len = 32; int len = 32;
for (i=0; i<32; i++) for (i = 0; i < 32; i++)
if (sb->set_name[i] == '\n' || if (sb->set_name[i] == '\n' || sb->set_name[i] == '\0') {
sb->set_name[i] == '\0') {
len = i; len = i;
break; break;
} }
@ -852,13 +886,12 @@ static int examine_badblocks_super1(struct supertype *st, int fd, char *devname)
__u64 *bbl, *bbp; __u64 *bbl, *bbp;
int i; int i;
if (!sb->bblog_size || __le16_to_cpu(sb->bblog_size) > 100 if (!sb->bblog_size || __le16_to_cpu(sb->bblog_size) > 100 ||
|| !sb->bblog_offset){ !sb->bblog_offset){
printf("No bad-blocks list configured on %s\n", devname); printf("No bad-blocks list configured on %s\n", devname);
return 0; return 0;
} }
if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) if ((sb->feature_map & __cpu_to_le32(MD_FEATURE_BAD_BLOCKS)) == 0) {
== 0) {
printf("Bad-blocks list is empty in %s\n", devname); printf("Bad-blocks list is empty in %s\n", devname);
return 0; return 0;
} }
@ -905,8 +938,7 @@ static int match_home1(struct supertype *st, char *homehost)
struct mdp_superblock_1 *sb = st->sb; struct mdp_superblock_1 *sb = st->sb;
int l = homehost ? strlen(homehost) : 0; int l = homehost ? strlen(homehost) : 0;
return (l > 0 && l < 32 && return (l > 0 && l < 32 && sb->set_name[l] == ':' &&
sb->set_name[l] == ':' &&
strncmp(sb->set_name, homehost, l) == 0); 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; struct mdp_superblock_1 *super = st->sb;
char *cuuid = (char*)uuid; char *cuuid = (char*)uuid;
int i; int i;
for (i=0; i<16; i++) for (i = 0; i < 16; i++)
cuuid[i] = super->set_uuid[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 mdp_superblock_1 *sb = st->sb;
struct bitmap_super_s *bsb = (void*)(((char*)sb)+MAX_SB_SIZE); 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; int working = 0;
unsigned int i; unsigned int i;
unsigned int role; 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.utime = __le64_to_cpu(sb->utime);
info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512; info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512;
info->array.state = info->array.state =
(__le64_to_cpu(sb->resync_offset) == MaxSector) (__le64_to_cpu(sb->resync_offset) == MaxSector) ? 1 : 0;
? 1 : 0;
if (__le32_to_cpu(bsb->nodes) > 1) if (__le32_to_cpu(bsb->nodes) > 1)
info->array.state |= (1 << MD_SB_CLUSTERED); 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) 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) if (info->data_offset + data_size < end)
info->space_after = end - data_size - info->data_offset; 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) if (bmend > earliest)
earliest = bmend; earliest = bmend;
} else if (info->ppl_offset > 0) { } else if (info->ppl_offset > 0) {
unsigned long long pplend = info->ppl_offset + unsigned long long pplend;
info->ppl_size;
pplend = info->ppl_offset + info->ppl_size;
if (pplend > earliest) if (pplend > earliest)
earliest = pplend; 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; info->space_before = info->data_offset - earliest;
else else
info->space_before = 0; 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) { if (info->space_before == 0 && info->space_after == 0) {
/* It will look like we don't support data_offset changes, /* 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; info->disk.raid_disk = -1;
switch(role) { switch(role) {
case MD_DISK_ROLE_SPARE: 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; break;
case MD_DISK_ROLE_FAULTY: case MD_DISK_ROLE_FAULTY:
info->disk.state = (1 << MD_DISK_FAULTY); /* 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: case MD_DISK_ROLE_JOURNAL:
info->disk.state = (1 << MD_DISK_JOURNAL); info->disk.state = (1 << MD_DISK_JOURNAL);
info->disk.raid_disk = role; 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; break;
default: default:
info->disk.state = 6; /* active and in sync */ 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, static int update_super1(struct supertype *st, struct mdinfo *info,
char *update, char *update, char *devname, int verbose,
char *devname, int verbose,
int uuid_set, char *homehost) int uuid_set, char *homehost)
{ {
/* NOTE: for 'assemble' and 'force' we need to return non-zero /* 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()) { if (bms->version == BITMAP_MAJOR_CLUSTERED && dlm_funs_ready()) {
rv = cluster_get_dlmlock(&lockid); rv = cluster_get_dlmlock(&lockid);
if (rv) { 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); cluster_release_dlmlock(lockid);
return rv; return rv;
} }
@ -1178,7 +1215,9 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
* maybe need to mark it 'clean'. * maybe need to mark it 'clean'.
*/ */
switch(__le32_to_cpu(sb->level)) { switch(__le32_to_cpu(sb->level)) {
case 5: case 4: case 6: case 4:
case 5:
case 6:
/* need to force clean */ /* need to force clean */
if (sb->resync_offset != MaxSector) if (sb->resync_offset != MaxSector)
rv = 1; rv = 1;
@ -1198,17 +1237,23 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
rv = 1; rv = 1;
} }
if (info->reshape_active && 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->delta_disks >= 0 &&
info->reshape_progress < __le64_to_cpu(sb->reshape_position)) { info->reshape_progress <
sb->reshape_position = __cpu_to_le64(info->reshape_progress); __le64_to_cpu(sb->reshape_position)) {
sb->reshape_position =
__cpu_to_le64(info->reshape_progress);
rv = 1; rv = 1;
} }
if (info->reshape_active && 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->delta_disks < 0 &&
info->reshape_progress > __le64_to_cpu(sb->reshape_position)) { info->reshape_progress >
sb->reshape_position = __cpu_to_le64(info->reshape_progress); __le64_to_cpu(sb->reshape_position)) {
sb->reshape_position =
__cpu_to_le64(info->reshape_progress);
rv = 1; rv = 1;
} }
} else if (strcmp(update, "linear-grow-new") == 0) { } else if (strcmp(update, "linear-grow-new") == 0) {
@ -1216,8 +1261,9 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
int fd; int fd;
unsigned int max = __le32_to_cpu(sb->max_dev); unsigned int max = __le32_to_cpu(sb->max_dev);
for (i=0 ; i < max ; i++) for (i = 0; i < max; i++)
if (__le16_to_cpu(sb->dev_roles[i]) >= MD_DISK_ROLE_FAULTY) if (__le16_to_cpu(sb->dev_roles[i]) >=
MD_DISK_ROLE_FAULTY)
break; break;
sb->dev_number = __cpu_to_le32(i); sb->dev_number = __cpu_to_le32(i);
info->disk.number = i; info->disk.number = i;
@ -1226,8 +1272,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
random_uuid(sb->device_uuid); random_uuid(sb->device_uuid);
sb->dev_roles[i] = sb->dev_roles[i] = __cpu_to_le16(info->disk.raid_disk);
__cpu_to_le16(info->disk.raid_disk);
fd = open(devname, O_RDONLY); fd = open(devname, O_RDONLY);
if (fd >= 0) { if (fd >= 0) {
@ -1280,14 +1325,16 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
} }
if (sb_offset < data_offset) { 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; long bb_offset;
bb_offset = sb_offset + 8; bb_offset = sb_offset + 8;
if (bm_sectors && bitmap_offset > 0) if (bm_sectors && bitmap_offset > 0)
bb_offset = bitmap_offset + bm_sectors; bb_offset = bitmap_offset + bm_sectors;
while (bb_offset < (long)sb_offset + 8 + 32*2 while (bb_offset < (long)sb_offset + 8 + 32*2 &&
&& bb_offset + 8+8 <= (long)data_offset) bb_offset + 8+8 <= (long)data_offset)
/* too close to bitmap, and room to grow */ /* too close to bitmap, and room to grow */
bb_offset += 8; bb_offset += 8;
if (bb_offset + 8 <= (long)data_offset) { if (bb_offset + 8 <= (long)data_offset) {
@ -1381,8 +1428,8 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
} else } else
strncpy(sb->set_name, info->name, sizeof(sb->set_name)); strncpy(sb->set_name, info->name, sizeof(sb->set_name));
} else if (strcmp(update, "devicesize") == 0 && } else if (strcmp(update, "devicesize") == 0 &&
__le64_to_cpu(sb->super_offset) < __le64_to_cpu(sb->super_offset) <
__le64_to_cpu(sb->data_offset)) { __le64_to_cpu(sb->data_offset)) {
/* set data_size to device size less data_offset */ /* set data_size to device size less data_offset */
struct misc_dev_info *misc = (struct misc_dev_info*) struct misc_dev_info *misc = (struct misc_dev_info*)
(st->sb + MAX_SB_SIZE + BM_SUPER_SIZE); (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)); misc->device_size - __le64_to_cpu(sb->data_offset));
} else if (strncmp(update, "revert-reshape", 14) == 0) { } else if (strncmp(update, "revert-reshape", 14) == 0) {
rv = -2; 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", pr_err("No active reshape to revert on %s\n",
devname); devname);
else { else {
@ -1431,9 +1479,11 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
*/ */
if (__le32_to_cpu(sb->level) >= 4 && if (__le32_to_cpu(sb->level) >= 4 &&
__le32_to_cpu(sb->level) <= 6) { __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->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); (__le32_to_cpu(sb->level)==6 ? 2 : 1);
if (reshape_sectors % reshape_chunk) { if (reshape_sectors % reshape_chunk) {
pr_err("Reshape position is not suitably aligned.\n"); 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; return -2;
} }
} }
sb->raid_disks = __cpu_to_le32(__le32_to_cpu(sb->raid_disks) - sb->raid_disks =
__le32_to_cpu(sb->delta_disks)); __cpu_to_le32(__le32_to_cpu(sb->raid_disks) -
__le32_to_cpu(sb->delta_disks));
if (sb->delta_disks == 0) if (sb->delta_disks == 0)
sb->feature_map ^= __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS); sb->feature_map ^= __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
else else
@ -1456,19 +1507,21 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
sb->new_chunk = sb->chunksize; sb->new_chunk = sb->chunksize;
sb->chunksize = temp; sb->chunksize = temp;
if (sb->feature_map & __cpu_to_le32(MD_FEATURE_NEW_OFFSET)) { if (sb->feature_map &
long offset_delta = (int32_t)__le32_to_cpu(sb->new_offset); __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->data_offset = __cpu_to_le64(__le64_to_cpu(sb->data_offset) + offset_delta);
sb->new_offset = __cpu_to_le32(-offset_delta); sb->new_offset = __cpu_to_le32(-offset_delta);
sb->data_size = __cpu_to_le64(__le64_to_cpu(sb->data_size) - offset_delta); sb->data_size = __cpu_to_le64(__le64_to_cpu(sb->data_size) - offset_delta);
} }
done:; done:;
} }
} else if (strcmp(update, "_reshape_progress")==0) } else if (strcmp(update, "_reshape_progress") == 0)
sb->reshape_position = __cpu_to_le64(info->reshape_progress); sb->reshape_position = __cpu_to_le64(info->reshape_progress);
else if (strcmp(update, "writemostly")==0) else if (strcmp(update, "writemostly") == 0)
sb->devflags |= WriteMostly1; sb->devflags |= WriteMostly1;
else if (strcmp(update, "readwrite")==0) else if (strcmp(update, "readwrite") == 0)
sb->devflags &= ~WriteMostly1; sb->devflags &= ~WriteMostly1;
else if (strcmp(update, "failfast") == 0) else if (strcmp(update, "failfast") == 0)
sb->devflags |= FailFast1; sb->devflags |= FailFast1;
@ -1553,11 +1606,14 @@ static int init_super1(struct supertype *st, mdu_array_info_t *info,
sb->resync_offset = MaxSector; sb->resync_offset = MaxSector;
else else
sb->resync_offset = 0; 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); 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) if (s->consistency_policy == CONSISTENCY_POLICY_PPL)
sb->feature_map |= __cpu_to_le32(MD_FEATURE_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()) { if (bms->version == BITMAP_MAJOR_CLUSTERED && dlm_funs_ready()) {
rv = cluster_get_dlmlock(&lockid); rv = cluster_get_dlmlock(&lockid);
if (rv) { 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); cluster_release_dlmlock(lockid);
return rv; 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); *rp = __cpu_to_le16(dk->raid_disk);
else if (dk_state & (1<<MD_DISK_JOURNAL)) else if (dk_state & (1<<MD_DISK_JOURNAL))
*rp = MD_DISK_ROLE_JOURNAL; *rp = MD_DISK_ROLE_JOURNAL;
else if ((dk_state & ~(1<<MD_DISK_ACTIVE)) == 0) /* active or idle -> spare */ else if ((dk_state & ~(1<<MD_DISK_ACTIVE)) == 0)
/* active or idle -> spare */
*rp = MD_DISK_ROLE_SPARE; *rp = MD_DISK_ROLE_SPARE;
else else
*rp = MD_DISK_ROLE_FAULTY; *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()) { if (bms->version == BITMAP_MAJOR_CLUSTERED && dlm_funs_ready()) {
rv = cluster_get_dlmlock(&lockid); rv = cluster_get_dlmlock(&lockid);
if (rv) { 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); cluster_release_dlmlock(lockid);
return rv; return rv;
} }
@ -1911,7 +1970,8 @@ static int write_init_super1(struct supertype *st)
bm_space = calc_bitmap_size(bms, 4096) >> 9; bm_space = calc_bitmap_size(bms, 4096) >> 9;
bm_offset = (long)__le32_to_cpu(sb->bitmap_offset); bm_offset = (long)__le32_to_cpu(sb->bitmap_offset);
} else if (sb->feature_map & __cpu_to_le32(MD_FEATURE_PPL)) { } 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) if (bm_space > UINT16_MAX)
bm_space = UINT16_MAX; bm_space = UINT16_MAX;
if (st->minor_version == 0) { if (st->minor_version == 0) {
@ -1981,7 +2041,10 @@ static int write_init_super1(struct supertype *st)
rv = -EINVAL; rv = -EINVAL;
goto out; 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) { if (st->nodes > 0 || conf_get_create_info()->bblist == 0) {
sb->bblog_size = 0; sb->bblog_size = 0;
sb->bblog_offset = 0; sb->bblog_offset = 0;
@ -1997,7 +2060,8 @@ static int write_init_super1(struct supertype *st)
} }
if (rv == 0 && 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); rv = st->ss->write_bitmap(st, di->fd, NodeNumUpdate);
} else if (rv == 0 && } else if (rv == 0 &&
(__le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL)) { (__le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL)) {
@ -2014,8 +2078,7 @@ static int write_init_super1(struct supertype *st)
} }
error_out: error_out:
if (rv) if (rv)
pr_err("Failed to write metadata to %s\n", pr_err("Failed to write metadata to %s\n", di->devname);
di->devname);
out: out:
return rv; return rv;
} }
@ -2080,7 +2143,8 @@ static int load_super1(struct supertype *st, int fd, char *devname)
/* guess... choose latest ctime */ /* guess... choose latest ctime */
memset(&tst, 0, sizeof(tst)); memset(&tst, 0, sizeof(tst));
tst.ss = &super1; 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)) { switch(load_super1(&tst, fd, devname)) {
case 0: super = tst.sb; case 0: super = tst.sb;
if (bestvers == -1 || 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 (__le32_to_cpu(super->magic) != MD_SB_MAGIC) {
if (devname) if (devname)
pr_err("No super block found on %s (Expected magic %08x, got %08x)\n", 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); free(super);
return 2; 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); 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; misc->device_size = dsize;
if (st->data_offset == INVALID_SECTORS) if (st->data_offset == INVALID_SECTORS)
st->data_offset = __le64_to_cpu(super->data_offset); 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. */ /* leading zeros can be safely ignored. --detail generates them. */
while (*arg == '0') while (*arg == '0')
arg++; arg++;
if (strcmp(arg, "1.0") == 0 || if (strcmp(arg, "1.0") == 0 || strcmp(arg, "1.00") == 0) {
strcmp(arg, "1.00") == 0) {
st->minor_version = 0; st->minor_version = 0;
return st; return st;
} }
if (strcmp(arg, "1.1") == 0 || if (strcmp(arg, "1.1") == 0 || strcmp(arg, "1.01") == 0
strcmp(arg, "1.01") == 0
) { ) {
st->minor_version = 1; st->minor_version = 1;
return st; return st;
@ -2249,8 +2313,7 @@ static struct supertype *match_metadata_desc1(char *arg)
st->minor_version = 2; st->minor_version = 2;
return st; return st;
} }
if (strcmp(arg, "1") == 0 || if (strcmp(arg, "1") == 0 || strcmp(arg, "default") == 0) {
strcmp(arg, "default") == 0) {
st->minor_version = -1; st->minor_version = -1;
return st; return st;
} }
@ -2348,20 +2411,26 @@ add_internal_bitmap1(struct supertype *st,
int uuid[4]; int uuid[4];
if (__le64_to_cpu(sb->data_size) == 0) 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; creating = 1;
switch(st->minor_version) { switch(st->minor_version) {
case 0: case 0:
/* either 3K after the superblock (when hot-add), /*
* either 3K after the superblock (when hot-add),
* or some amount of space before. * or some amount of space before.
*/ */
if (creating) { 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. * been left.
*/ */
offset = 0; offset = 0;
bbl_size = 8; 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 { } else {
room = __le64_to_cpu(sb->super_offset) room = __le64_to_cpu(sb->super_offset)
- __le64_to_cpu(sb->data_offset) - __le64_to_cpu(sb->data_offset)
@ -2373,8 +2442,8 @@ add_internal_bitmap1(struct supertype *st,
if (bbl_size < -bbl_offset) if (bbl_size < -bbl_offset)
bbl_size = -bbl_offset; bbl_size = -bbl_offset;
if (!may_change || (room < 3*2 && if (!may_change ||
__le32_to_cpu(sb->max_dev) <= 384)) { (room < 3*2 && __le32_to_cpu(sb->max_dev) <= 384)) {
room = 3*2; room = 3*2;
offset = 1*2; offset = 1*2;
bbl_size = 0; bbl_size = 0;
@ -2388,13 +2457,15 @@ add_internal_bitmap1(struct supertype *st,
if (creating) { if (creating) {
offset = 4*2; offset = 4*2;
bbl_size = 8; 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 { } else {
room = __le64_to_cpu(sb->data_offset) room = __le64_to_cpu(sb->data_offset)
- __le64_to_cpu(sb->super_offset); - __le64_to_cpu(sb->super_offset);
bbl_size = __le16_to_cpu(sb->bblog_size); bbl_size = __le16_to_cpu(sb->bblog_size);
if (bbl_size) if (bbl_size)
room = __le32_to_cpu(sb->bblog_offset) + bbl_size; room =
__le32_to_cpu(sb->bblog_offset) + bbl_size;
else else
bbl_size = 8; bbl_size = 8;
@ -2453,8 +2524,8 @@ add_internal_bitmap1(struct supertype *st,
sb->bitmap_offset = (int32_t)__cpu_to_le32(offset); sb->bitmap_offset = (int32_t)__cpu_to_le32(offset);
sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) |
| MD_FEATURE_BITMAP_OFFSET); MD_FEATURE_BITMAP_OFFSET);
memset(bms, 0, sizeof(*bms)); memset(bms, 0, sizeof(*bms));
bms->magic = __cpu_to_le32(BITMAP_MAGIC); bms->magic = __cpu_to_le32(BITMAP_MAGIC);
bms->version = __cpu_to_le32(major); 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->write_behind = __cpu_to_le32(write_behind);
bms->nodes = __cpu_to_le32(st->nodes); bms->nodes = __cpu_to_le32(st->nodes);
if (st->nodes) if (st->nodes)
sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) |
| MD_FEATURE_BITMAP_VERSIONED); MD_FEATURE_BITMAP_VERSIONED);
if (st->cluster_name) { if (st->cluster_name) {
len = sizeof(bms->cluster_name); len = sizeof(bms->cluster_name);
strncpy((char *)bms->cluster_name, st->cluster_name, len); 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; break;
case NodeNumUpdate: case NodeNumUpdate:
/* cluster md only supports superblock 1.2 now */ /* 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"); pr_err("Warning: cluster md only works with superblock 1.2\n");
return -EINVAL; return -EINVAL;
} }
if (bms->version == BITMAP_MAJOR_CLUSTERED) { if (bms->version == BITMAP_MAJOR_CLUSTERED) {
if (__cpu_to_le32(st->nodes) < bms->nodes) { 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); bms->nodes = __cpu_to_le32(st->nodes);
break; break;
} }
} else { } else {
/* no need to change bms->nodes for other bitmap types */ /*
* no need to change bms->nodes for other
* bitmap types
*/
if (st->nodes) if (st->nodes)
pr_err("Warning: --nodes option is only suitable for clustered bitmap\n"); pr_err("Warning: --nodes option is only suitable for clustered bitmap\n");
break; 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); 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 = 512 * (__le64_to_cpu(sb->data_offset) -
total_bm_space = total_bm_space - 4096; /* leave another 4k for superblock */ __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) { if (bm_space_per_node * st->nodes > total_bm_space) {
pr_err("Warning: The max num of nodes can't exceed %llu\n", pr_err("Warning: The max num of nodes can't exceed %llu\n",