Gitweb: http://git.fedorahosted.org/git/cluster.git?p=cluster.git;a=commitdiff;h=... Commit: 1bb481b4baea438c86df58584c825ba735aef3d1 Parent: 1f8086a6382a337bc4febab691b83a7ce673e266 Author: Bob Peterson <bob(a)ganesha.peterson&gt; AuthorDate: Thu Jan 21 23:10:23 2010 -0600 Committer: Bob Peterson <rpeterso(a)redhat.com&gt; CommitterDate: Tue Jan 26 14:39:30 2010 -0600 fsck.gfs2: fix directories that have odd number of pointers. Directory dinodes in gfs2 use the "depth" field to determine the number of pointers in the hash table. The depth must be a factor of 2. So 2, 4, 8, 16, etc. That's because the hash table is doubled every time it gets full. The problem is, fsck.gfs2 previously had no checks for the depth being correct and/or the hash table pointers being multiples of two. Needless to say, the directory code gets very confused if this condition is not met due to corruption. This patch introduces new code to validate the depth is correct and fix the depth and/or pointers if they're not. rhbz#455300 --- gfs2/fsck/metawalk.c | 133 ++++++++++++++++++++++++++++++++++++++++++-------- 1 files changed, 113 insertions(+), 20 deletions(-) diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c index 7ba8e39..8b75311 100644 --- a/gfs2/fsck/metawalk.c +++ b/gfs2/fsck/metawalk.c @@ -332,6 +332,61 @@ static void warn_and_patch(struct gfs2_inode *ip, uint64_t *leaf_no, *leaf_no = old_leaf; } +/* + * fix_leaf_pointers - fix a directory dinode that has a number of pointers + * that is not a multiple of 2. + * dip - the directory inode having the problem + * lindex - the index of the leaf right after the problem (need to back up) + * cur_numleafs - current (incorrect) number of instances of the leaf block + * correct_numleafs - the correct number instances of the leaf block + */ +static int fix_leaf_pointers(struct gfs2_inode *dip, int *lindex, + int cur_numleafs, int correct_numleafs) +{ + int count; + char *ptrbuf; + int start_lindex = *lindex - cur_numleafs; /* start of bad ptrs */ + int tot_num_ptrs = (1 << dip->i_di.di_depth) - start_lindex; + int bufsize = tot_num_ptrs * sizeof(uint64_t); + int off_by = cur_numleafs - correct_numleafs; + + ptrbuf = malloc(bufsize); + if (!ptrbuf) { + log_err( _("Error: Cannot allocate memory to fix the leaf " + "pointers.\n")); + return -1; + } + /* Read all the pointers, starting with the first bad one */ + count = gfs2_readi(dip, ptrbuf, start_lindex * sizeof(uint64_t), + bufsize); + if (count != bufsize) { + log_err( _("Error: bad read while fixing leaf pointers.\n")); + free(ptrbuf); + return -1; + } + + bufsize -= off_by * sizeof(uint64_t); /* We need to write fewer */ + /* Write the same pointers, but offset them so they fit within the + smaller factor of 2. So if we have 12 pointers, write out only + the last 8 of them. If we have 7, write the last 4, etc. + We need to write these starting at the current lindex and adjust + lindex accordingly. */ + count = gfs2_writei(dip, ptrbuf + (off_by * sizeof(uint64_t)), + start_lindex * sizeof(uint64_t), bufsize); + if (count != bufsize) { + log_err( _("Error: bad read while fixing leaf pointers.\n")); + free(ptrbuf); + return -1; + } + /* Now zero out the hole left at the end */ + memset(ptrbuf, 0, off_by * sizeof(uint64_t)); + gfs2_writei(dip, ptrbuf, (start_lindex * sizeof(uint64_t)) + + bufsize, off_by * sizeof(uint64_t)); + free(ptrbuf); + *lindex -= off_by; /* adjust leaf index to account for the change */ + return 0; +} + /* Checks exhash directory entries */ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass) { @@ -382,33 +437,71 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass) ref_count++; continue; } - if (gfs2_check_range(ip->i_sbd, old_leaf) == 0 && - ref_count != exp_count) { - log_err( _("Dir #%llu (0x%llx) has an incorrect " - "number of pointers to leaf #%llu " - " (0x%llx)\n\tFound: %u, Expected: " - "%u\n"), (unsigned long long) - ip->i_di.di_num.no_addr, - (unsigned long long) - ip->i_di.di_num.no_addr, - (unsigned long long)old_leaf, - (unsigned long long)old_leaf, - ref_count, exp_count); - if (query( _("Attempt to fix it? (y/n) "))) { - int factor = 0, divisor = ref_count; - - lbh = bread(sbp, old_leaf); - while (divisor > 1) { - factor++; - divisor /= 2; + if (gfs2_check_range(ip->i_sbd, old_leaf) == 0) { + int factor = 0, divisor = ref_count, multiple = 1; + + /* Check to see if the number of pointers we found is + a power of 2. It needs to be and if it's not we + need to fix it.*/ + while (divisor > 1) { + factor++; + divisor /= 2; + multiple = multiple << 1; + } + if (ref_count != multiple) { + log_err( _("Directory #%llu (0x%llx) has an " + "invalid number of pointers to " + "leaf #%llu (0x%llx)\n\tFound: %u, " + "which is not a factor of 2.\n"), + (unsigned long long) + ip->i_di.di_num.no_addr, + (unsigned long long) + ip->i_di.di_num.no_addr, + (unsigned long long)old_leaf, + (unsigned long long)old_leaf, + ref_count); + if (!query( _("Attempt to fix it? (y/n) "))) { + log_err( _("Directory inode was not " + "fixed.\n")); + return 1; } + error = fix_leaf_pointers(ip, &lindex, + ref_count, multiple); + if (error) + return error; + ref_count = multiple; + log_err( _("Directory inode was fixed.\n")); + } + /* Check to see if the counted number of leaf pointers + is what we expect. */ + if (ref_count != exp_count) { + log_err( _("Directory #%llu (0x%llx) has an " + "incorrect number of pointers to " + "leaf #%llu (0x%llx)\n\tFound: " + "%u, Expected: %u\n"), + (unsigned long long) + ip->i_di.di_num.no_addr, + (unsigned long long) + ip->i_di.di_num.no_addr, + (unsigned long long)old_leaf, + (unsigned long long)old_leaf, + ref_count, exp_count); + if (!query( _("Attempt to fix it? (y/n) "))) { + log_err( _("Directory leaf was not " + "fixed.\n")); + return 1; + } + lbh = bread(sbp, old_leaf); gfs2_leaf_in(&oldleaf, lbh); + log_err( _("Leaf depth was %d, changed to " + "%d\n"), oldleaf.lf_depth, + ip->i_di.di_depth - factor); oldleaf.lf_depth = ip->i_di.di_depth - factor; gfs2_leaf_out(&oldleaf, lbh); brelse(lbh); + exp_count = ref_count; + log_err( _("Directory leaf was fixed.\n")); } - else - return 1; } ref_count = 1;