cluster: RHEL6 - fsck.gfs2: take hash table start boundaries into account
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=78c9f0a7eaa...
Commit: 78c9f0a7eaa2c2aecb7ecbef518fb53a2bb6a871
Parent: bf9a851204b747f850a3a95a907cd8101bc2b726
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Fri Apr 19 09:25:51 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:33:36 2013 -0500
fsck.gfs2: take hash table start boundaries into account
When checking the hash table in pass2, we can't just keep doubling
the length for each consecutive check because the number of pointer
copies (aka length) is also tied to the starting offset. If the
starting offset is invalid for the length, it might treat a chunk of
the hash table as bigger than it should, eventually overwriting good
entries. Along the same lines, while we're trying to determine the
length, it's not good enough to double the length and check if the
hash table entry matches. The reason is: there can be several values
overwritten with the same value, 0x00, that indicates places where
pass1 found an invalid leaf block pointer. To avoid that, we need to
check intermediate values as well, and stop if we find a gap.
rhbz#902920
---
gfs2/fsck/metawalk.c | 5 +++--
gfs2/fsck/pass2.c | 43 ++++++++++++++++++++++++++++++++++---------
2 files changed, 37 insertions(+), 11 deletions(-)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 78047ec..1d56490 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -471,11 +471,12 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
if ((char *)dent + de.de_rec_len >= bh_end){
log_debug( _("Last entry processed for %lld->%lld "
- "(0x%llx->0x%llx).\n"),
+ "(0x%llx->0x%llx), di_blocks=%llu.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)bh->b_blocknr,
(unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)bh->b_blocknr);
+ (unsigned long long)bh->b_blocknr,
+ (unsigned long long)ip->i_di.di_blocks);
break;
}
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 4b3a5c0..4b3efd9 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -368,9 +368,10 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry,
gfs2_get_leaf_nr(ip, hash_index, &real_leaf);
if (real_leaf != planned_leaf) {
log_err(_("The planned leaf was split. The new leaf "
- "is: %llu (0x%llx)"),
+ "is: %llu (0x%llx). di_blocks=%llu\n"),
(unsigned long long)real_leaf,
- (unsigned long long)real_leaf);
+ (unsigned long long)real_leaf,
+ (unsigned long long)ip->i_di.di_blocks);
fsck_blockmap_set(ip, real_leaf, _("split leaf"),
gfs2_indir_blk);
}
@@ -1030,6 +1031,7 @@ static int basic_check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
log_err( _("Bad directory entry '%s' cleared.\n"), tmp_name);
return 1;
} else {
+ (*count)++;
return 0;
}
}
@@ -1148,11 +1150,13 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
/* Look at the first dirent and check its hash value to see if it's
at the proper starting offset. */
hash_index = hash_table_index(dentry.de_hash, ip);
+ /* Need to use len here, not *proper_len because the leaf block may
+ be valid within the range, but starts too soon in the hash table. */
if (hash_index < lindex || hash_index > lindex + len) {
log_err(_("This leaf block has hash index %d, which is out of "
"bounds for where it appears in the hash table "
"(%d - %d)\n"),
- hash_index, lindex, lindex + len);
+ hash_index, lindex, lindex + *proper_len);
error = lost_leaf(ip, tbl, leafblk, len, lindex, lbh);
brelse(lbh);
return error;
@@ -1289,6 +1293,8 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
struct gfs2_buffer_head *lbh;
int factor;
uint32_t proper_start;
+ uint32_t next_proper_start;
+ int anomaly;
lindex = 0;
while (lindex < hsize) {
@@ -1297,10 +1303,23 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
len = 1;
factor = 0;
leafblk = be64_to_cpu(tbl[lindex]);
+ next_proper_start = lindex;
+ anomaly = 0;
while (lindex + (len << 1) - 1 < hsize) {
if (be64_to_cpu(tbl[lindex + (len << 1) - 1]) !=
leafblk)
break;
+ next_proper_start = (lindex & ~((len << 1) - 1));
+ if (lindex != next_proper_start)
+ anomaly = 1;
+ /* Check if there are other values written between
+ here and the next factor. */
+ for (i = len; !anomaly && i + lindex < hsize &&
+ i < (len << 1); i++)
+ if (be64_to_cpu(tbl[lindex + i]) != leafblk)
+ anomaly = 1;
+ if (anomaly)
+ break;
len <<= 1;
factor++;
}
@@ -1342,8 +1361,10 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
proper_start = (lindex & ~(proper_len - 1));
if (lindex != proper_start) {
log_debug(_("lindex 0x%llx is not a proper starting "
- "point for this leaf: 0x%llx\n"),
+ "point for leaf %llu (0x%llx): 0x%llx\n"),
(unsigned long long)lindex,
+ (unsigned long long)leafblk,
+ (unsigned long long)leafblk,
(unsigned long long)proper_start);
changes = fix_hashtable(ip, tbl, hsize, leafblk,
lindex, proper_start, len,
@@ -1366,9 +1387,11 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
depth, and adjust the hash table accordingly. */
if (len != proper_len) {
log_err(_("Length %d (0x%x) is not a proper length "
- "for this leaf. Valid boundary assumed to "
- "be %d (0x%x).\n"),
- len, len, proper_len, proper_len);
+ "for leaf %llu (0x%llx). Valid boundary "
+ "assumed to be %d (0x%x).\n"), len, len,
+ (unsigned long long)leafblk,
+ (unsigned long long)leafblk,
+ proper_len, proper_len);
lbh = bread(ip->i_sbd, leafblk);
gfs2_leaf_in(&leaf, lbh);
if (gfs2_check_meta(lbh, GFS2_METATYPE_LF) ||
@@ -1417,8 +1440,10 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth);
if (proper_len != len) {
log_debug(_("Length 0x%x is not proper for "
- "this leaf: 0x%x"),
- len, proper_len);
+ "leaf %llu (0x%llx): 0x%x"),
+ len, (unsigned long long)leafblk,
+ (unsigned long long)leafblk,
+ proper_len);
changes = fix_hashtable(ip, tbl, hsize,
leafblk, lindex,
lindex, len,
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: Don't allocate leaf blocks in pass1
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=bf9a851204b...
Commit: bf9a851204b747f850a3a95a907cd8101bc2b726
Parent: 100e0e1961e7f26c72ae59b57f5c86873053eb2f
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Wed Apr 17 14:09:30 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:33:01 2013 -0500
fsck.gfs2: Don't allocate leaf blocks in pass1
Before this patch, if leaf blocks were found to be corrupt, pass1
tried to fix them by allocating new leaf blocks in place of the bad
ones. That's a bad idea, because pass1 populates the blockmap and
sets the bitmap accordingly. In other words, it's dynamically changing.
Say, for example, that you're checking a directory a dinode 0x1234, and
it has a corrupt hash table, and needs new leaf blocks inserted.
Now suppose you have a second directory that occurs later in the bitmap,
say at block 0x2345, and it references leaf block 0x2346, but for some
reason that block (0x2346) is improperly set to "free" in the bitmap.
If pass1 goes out looking for a free block in order to allocate a new
leaf for 0x1234, it will naturally find block 0x2346, because it's
marked free. It writes a new leaf at that block and adds a new
reference in the hash table of 0x1234. Later, when pass1 processes
directory 0x2345, it discovers the reference to 0x2346. Not only has
it wiped out the perfectly good leaf block, it has also created a
duplicate block reference that it needs to sort out in pass1b, which
will likely keep the replaced reference and throw the good one we
had. Thus, we introduced corruption into the file system when we
should have kept the only good reference to 0x2346 and fixed the
bitmap.
The solution provided by this patch is to simply zero out the bad
hash table entries when pass1 comes across them. Later, when pass2
discovers the zero leaf blocks, it can safely allocate new blocks
(since pass1 synced the bitmap according to the blockmap) for the new
leaf blocks and replace the zeros with valid block references.
rhbz#902920
---
gfs2/fsck/metawalk.c | 31 ++++++++++++++++++++++++++++++-
gfs2/fsck/metawalk.h | 2 +-
gfs2/fsck/pass1.c | 9 ++-------
gfs2/fsck/pass2.c | 2 +-
4 files changed, 34 insertions(+), 10 deletions(-)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 37b2d4b..78047ec 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -1954,7 +1954,7 @@ int write_new_leaf(struct gfs2_inode *dip, int start_lindex, int num_copies,
* leaf a bit, but it's better than deleting the whole directory,
* which is what used to happen before. */
int repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, int lindex,
- int ref_count, const char *msg)
+ int ref_count, const char *msg, int allow_alloc)
{
int new_leaf_blks = 0, error, refs;
uint64_t bn = 0;
@@ -1969,6 +1969,35 @@ int repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, int lindex,
log_err( _("Bad leaf left in place.\n"));
goto out;
}
+ if (!allow_alloc) {
+ uint64_t *cpyptr;
+ char *padbuf;
+ int pad_size, i;
+
+ padbuf = malloc(ref_count * sizeof(uint64_t));
+ cpyptr = (uint64_t *)padbuf;
+ for (i = 0; i < ref_count; i++) {
+ *cpyptr = 0;
+ cpyptr++;
+ }
+ pad_size = ref_count * sizeof(uint64_t);
+ log_err(_("Writing zeros to the hash table of directory %lld "
+ "(0x%llx) at index: 0x%x for 0x%x pointers.\n"),
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ lindex, ref_count);
+ if (ip->i_sbd->gfs1)
+ gfs1_writei(ip, padbuf, lindex * sizeof(uint64_t),
+ pad_size);
+ else
+ gfs2_writei(ip, padbuf, lindex * sizeof(uint64_t),
+ pad_size);
+ free(padbuf);
+ log_err( _("Directory Inode %llu (0x%llx) patched.\n"),
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)ip->i_di.di_num.no_addr);
+ goto out;
+ }
/* We can only write leafs in quantities that are factors of
two, since leaves are doubled, not added sequentially.
So if we have a hole that's not a factor of 2, we have to
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index aacb962..a5a51c2 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -61,7 +61,7 @@ extern int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
int num_copies, const char *before_or_after,
uint64_t *bn);
extern int repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, int lindex,
- int ref_count, const char *msg);
+ int ref_count, const char *msg, int allow_alloc);
#define is_duplicate(dblock) ((dupfind(dblock)) ? 1 : 0)
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 2355de2..7208335 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -83,13 +83,8 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
int lindex, int ref_count, const char *msg,
void *private)
{
- struct block_count *bc = (struct block_count *)private;
- int new_leaf_blks;
-
- new_leaf_blks = repair_leaf(ip, leaf_no, lindex, ref_count, msg);
- bc->indir_count += new_leaf_blks;
-
- return new_leaf_blks;
+ repair_leaf(ip, leaf_no, lindex, ref_count, msg, 0);
+ return 0;
}
struct metawalk_fxns pass1_fxns = {
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 02fa577..4b3a5c0 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -1038,7 +1038,7 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
int lindex, int ref_count, const char *msg,
void *private)
{
- return repair_leaf(ip, leaf_no, lindex, ref_count, msg);
+ return repair_leaf(ip, leaf_no, lindex, ref_count, msg, 1);
}
/* The purpose of leafck_fxns is to provide a means for function fix_hashtable
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: Stop "undo" process when error data block is reached
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=100e0e1961e...
Commit: 100e0e1961e7f26c72ae59b57f5c86873053eb2f
Parent: ed5f3f4009893b393817ac7c45189cd34bbbf429
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Fri Apr 12 08:31:30 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:32:01 2013 -0500
fsck.gfs2: Stop "undo" process when error data block is reached
When fsck.gfs2 discovers a data block in error, it flags the error
and especially in pass1, it tries to "undo" the block designations
it previously marked in the blockmap. Before this patch, the "undo"
functions didn't know when to stop. So it could "undo" designations
in the blockmap that it hadn't "done" in the first place. With this
patch, if an error is encountered while processing data blocks
(not counting duplicate references--for example, blocks marked as
'data' that are really dinodes which it hasn't gotten to yet) it
saves off the block where the error occurred. Later, during the
"undo" processing, it stops when it reaches the block that flagged
the error.
rhbz#902920
---
gfs2/fsck/metawalk.c | 36 +++++++++++++++++++++++++++---------
gfs2/fsck/pass1.c | 2 +-
2 files changed, 28 insertions(+), 10 deletions(-)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index d3decd5..37b2d4b 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -1323,7 +1323,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
*/
static int check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
struct gfs2_buffer_head *bh, int head_size,
- uint64_t *blks_checked)
+ uint64_t *blks_checked, uint64_t *error_blk)
{
int error = 0, rc = 0;
uint64_t block, *ptr;
@@ -1347,8 +1347,13 @@ static int check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
rc = pass->check_data(ip, metablock, block, pass->private);
if (!error && rc) {
error = rc;
- log_info(_("\nUnrecoverable data block error %d on "
- "block %llu (0x%llx).\n"), rc,
+ log_info("\n");
+ if (rc < 0) {
+ *error_blk = block;
+ log_info(_("Unrecoverable "));
+ }
+ log_info(_("data block error %d on block %llu "
+ "(0x%llx).\n"), rc,
(unsigned long long)block,
(unsigned long long)block);
}
@@ -1360,7 +1365,8 @@ static int check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
}
static int undo_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
- uint64_t *ptr_start, char *ptr_end)
+ uint64_t *ptr_start, char *ptr_end,
+ uint64_t error_blk)
{
int rc = 0;
uint64_t block, *ptr;
@@ -1373,6 +1379,8 @@ static int undo_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
if (skip_this_pass || fsck_abort)
return 1;
block = be64_to_cpu(*ptr);
+ if (block == error_blk)
+ return 1;
rc = pass->undo_check_data(ip, block, pass->private);
if (rc < 0)
return rc;
@@ -1413,6 +1421,8 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
uint64_t blks_checked = 0;
int error, rc;
int metadata_clean = 0;
+ uint64_t error_blk = 0;
+ int hit_error_blk = 0;
if (!height && !is_dir(&ip->i_di, ip->i_sbd->gfs1))
return 0;
@@ -1458,7 +1468,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (pass->check_data)
error = check_data(ip, pass, bh, head_size,
- &blks_checked);
+ &blks_checked, &error_blk);
if (pass->big_file_msg && ip->i_di.di_blocks > COMFORTABLE_BLKS)
pass->big_file_msg(ip, blks_checked);
@@ -1497,12 +1507,20 @@ undo_metalist:
i, pass->private);
else
rc = 0;
- if (metadata_clean && rc == 0 && i == height - 1) {
+ if (metadata_clean && rc == 0 && i == height - 1 &&
+ !hit_error_blk) {
head_size = hdr_size(bh, height);
- if (head_size)
- undo_check_data(ip, pass, (uint64_t *)
+ if (head_size) {
+ rc = undo_check_data(ip, pass,
+ (uint64_t *)
(bh->b_data + head_size),
- (bh->b_data + ip->i_sbd->bsize));
+ (bh->b_data + ip->i_sbd->bsize),
+ error_blk);
+ if (rc > 0) {
+ hit_error_blk = 1;
+ rc = 0;
+ }
+ }
}
if (bh == ip->i_bh)
osi_list_del(&bh->b_altlist);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index fbeca0b..2355de2 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -461,7 +461,7 @@ static int check_data(struct gfs2_inode *ip, uint64_t metablock,
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
_("bad (out of range) data"),
gfs2_bad_block);
- return 1;
+ return -1;
}
bc->data_count++; /* keep the count sane anyway */
q = block_type(block);
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: Trivial typo fix
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=ed5f3f40098...
Commit: ed5f3f4009893b393817ac7c45189cd34bbbf429
Parent: 3cb08a8cf18e513cae007d987edc39fb3b1ef61f
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Fri Apr 12 06:47:07 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:31:02 2013 -0500
fsck.gfs2: Trivial typo fix
Fix a typo in u64cmp
rhbz#902920
---
gfs2/fsck/metawalk.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 8fc445e..d3decd5 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -626,7 +626,7 @@ static int u64cmp(const void *p1, const void *p2)
if (a > b)
return 1;
- if (b < b)
+ if (a < b)
return -1;
return 0;
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: double-check transitions from dinode to data
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=3cb08a8cf18...
Commit: 3cb08a8cf18e513cae007d987edc39fb3b1ef61f
Parent: 47739c96de94d8de07ee1e8d92cf845d083cb422
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Thu Apr 11 13:45:39 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:30:57 2013 -0500
fsck.gfs2: double-check transitions from dinode to data
If a corrupt dinode references a bunch of blocks as data blocks,
and those blocks occur later in the bitmap (as is usually the case)
but they're really dinodes, we have a problem. Before it finds the
corruption, it can change the bitmap markings from 'dinode' to 'data'
blocks. Later, when it determines the dinode is corrupt. It tries
to "undo" all those data blocks, but since pass1 hasn't processed
them yet, it marks them as 'free' in the bitmap, and we've lost the
fact that they're dinodes. The result is that the files/dinodes
being improperly referenced are deleted by mistake.
This patch adds a check for bitmap transitions in pass1 from 'dinode'
to 'data', where the block hasn't been checked yet. We don't care about
transitions from dinode to free because that's a normal delete of a
dinode. We also don't care about transitions between dinode to
metadata, because all those checks validate that the metadata type is
the correct type of metadata, so we know we're making the right
decision. So the only issue are data blocks referencing dinodes.
What this patch does is: when the bitmap is making a transition from
'dinode' to 'data' in pass1, it basically puts up a red flag.
The block is read in and checked to see if it really looks like a
dinode. We have to be careful here, because customer data is allowed
to look like a dinode. If the block really seems to be a dinode, we
DO NOT want to treat it as a data block and assume the duplicate
reference handler in pass1b will handle it, because the dinode's
metadata blocks will not have been checked in pass1.
Instead, we want to flag it as corruption in the referencing file
dinode, not change the bitmap or blockmap, and allow pass1 to treat
it properly as a dinode when it gets there. The corrupt dinode
referencing the dinode as 'data' should be deleted and the work done
thusfar should be backed out by the pass1 'undo' functions.
rhbz#902920
---
gfs2/fsck/metawalk.c | 21 +++++++++++++---
gfs2/fsck/metawalk.h | 14 +++++++----
gfs2/fsck/pass1.c | 65 +++++++++++++++++++++++++++++++++++++++++++++----
gfs2/fsck/pass1b.c | 2 +-
gfs2/fsck/pass2.c | 2 +-
gfs2/fsck/pass3.c | 4 +-
6 files changed, 89 insertions(+), 19 deletions(-)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 15bdf7a..8fc445e 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -25,7 +25,7 @@
is used to set the latter. The two must be kept in sync, otherwise
you'll get bitmap mismatches. This function checks the status of the
bitmap whenever the blockmap changes, and fixes it accordingly. */
-int check_n_fix_bitmap(struct gfs2_sbd *sdp, uint64_t blk,
+int check_n_fix_bitmap(struct gfs2_sbd *sdp, uint64_t blk, int error_on_dinode,
enum gfs2_mark_block new_blockmap_state)
{
int old_bitmap_state, new_bitmap_state;
@@ -47,6 +47,16 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, uint64_t blk,
/* gfs1 descriptions: */
{"free", "data", "free meta", "metadata", "reserved"}};
+ if (error_on_dinode && old_bitmap_state == GFS2_BLKST_DINODE &&
+ new_bitmap_state != GFS2_BLKST_FREE) {
+ log_debug(_("Reference as '%s' to block %llu (0x%llx) "
+ "which was marked as dinode. Needs "
+ "further investigation.\n"),
+ allocdesc[sdp->gfs1][new_bitmap_state],
+ (unsigned long long)blk,
+ (unsigned long long)blk);
+ return 1;
+ }
/* Keep these messages as short as possible, or the output
gets to be huge and unmanageable. */
log_err( _("Block %llu (0x%llx) was '%s', should be %s.\n"),
@@ -104,6 +114,7 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, uint64_t blk,
*/
int _fsck_blockmap_set(struct gfs2_inode *ip, uint64_t bblock,
const char *btype, enum gfs2_mark_block mark,
+ int error_on_dinode,
const char *caller, int fline)
{
int error;
@@ -162,9 +173,11 @@ int _fsck_blockmap_set(struct gfs2_inode *ip, uint64_t bblock,
/* First, check the rgrp bitmap against what we think it should be.
If that fails, it's an invalid block--part of an rgrp. */
- error = check_n_fix_bitmap(ip->i_sbd, bblock, mark);
+ error = check_n_fix_bitmap(ip->i_sbd, bblock, error_on_dinode, mark);
if (error) {
- log_err( _("This block is not represented in the bitmap.\n"));
+ if (error < 0)
+ log_err( _("This block is not represented in the "
+ "bitmap.\n"));
return error;
}
@@ -515,7 +528,7 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
if (pass->check_leaf) {
error = pass->check_leaf(ip, *leaf_no, pass->private);
- if (error) {
+ if (error == -EEXIST) {
log_info(_("Previous reference to leaf %lld (0x%llx) "
"has already checked it; skipping.\n"),
(unsigned long long)*leaf_no,
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index 56f57d9..aacb962 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -45,10 +45,12 @@ extern int delete_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
void *private);
extern int _fsck_blockmap_set(struct gfs2_inode *ip, uint64_t bblock,
- const char *btype, enum gfs2_mark_block mark,
- const char *caller, int line);
+ const char *btype, enum gfs2_mark_block mark,
+ int error_on_dinode,
+ const char *caller, int line);
extern int check_n_fix_bitmap(struct gfs2_sbd *sdp, uint64_t blk,
- enum gfs2_mark_block new_blockmap_state);
+ int error_on_dinode,
+ enum gfs2_mark_block new_blockmap_state);
extern void reprocess_inode(struct gfs2_inode *ip, const char *desc);
extern struct duptree *dupfind(uint64_t block);
extern struct gfs2_inode *fsck_system_inode(struct gfs2_sbd *sdp,
@@ -63,8 +65,10 @@ extern int repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, int lindex,
#define is_duplicate(dblock) ((dupfind(dblock)) ? 1 : 0)
-#define fsck_blockmap_set(ip, b, bt, m) _fsck_blockmap_set(ip, b, bt, m, \
- __FUNCTION__, __LINE__)
+#define fsck_blockmap_set(ip, b, bt, m) \
+ _fsck_blockmap_set(ip, b, bt, m, 0, __FUNCTION__, __LINE__)
+#define fsck_blkmap_set_noino(ip, b, bt, m) \
+ _fsck_blockmap_set(ip, b, bt, m, 1, __FUNCTION__, __LINE__)
enum meta_check_rc {
meta_error = -1,
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 90e3829..fbeca0b 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -149,7 +149,7 @@ static int resuscitate_metalist(struct gfs2_inode *ip, uint64_t block,
if (fsck_system_inode(ip->i_sbd, block))
fsck_blockmap_set(ip, block, _("system file"), gfs2_indir_blk);
else
- check_n_fix_bitmap(ip->i_sbd, block, gfs2_indir_blk);
+ check_n_fix_bitmap(ip->i_sbd, block, 0, gfs2_indir_blk);
bc->indir_count++;
return meta_is_good;
}
@@ -203,7 +203,7 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (fsck_system_inode(sdp, block))
fsck_blockmap_set(ip, block, _("system file"), dinode_type);
else
- check_n_fix_bitmap(sdp, block, dinode_type);
+ check_n_fix_bitmap(sdp, block, 0, dinode_type);
/* Return the number of leaf entries so metawalk doesn't flag this
leaf as having none. */
*count = be16_to_cpu(((struct gfs2_leaf *)bh->b_data)->lf_entries);
@@ -338,6 +338,8 @@ static int undo_reference(struct gfs2_inode *ip, uint64_t block, int meta,
struct block_count *bc = (struct block_count *)private;
struct duptree *dt;
struct inode_with_dups *id;
+ int old_bitmap_state = 0;
+ struct rgrp_tree *rgd;
if (!valid_block(ip->i_sbd, block)) { /* blk outside of FS */
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
@@ -366,6 +368,12 @@ static int undo_reference(struct gfs2_inode *ip, uint64_t block, int meta,
return 1;
}
}
+ if (!meta) {
+ rgd = gfs2_blk2rgrpd(ip->i_sbd, block);
+ old_bitmap_state = gfs2_get_bitmap(ip->i_sbd, block, rgd);
+ if (old_bitmap_state == GFS2_BLKST_DINODE)
+ return -1;
+ }
fsck_blockmap_set(ip, block,
meta ? _("bad indirect") : _("referenced data"),
gfs2_block_free);
@@ -384,6 +392,51 @@ static int undo_check_data(struct gfs2_inode *ip, uint64_t block,
return undo_reference(ip, block, 0, private);
}
+/* blockmap_set_as_data - set block as 'data' in the blockmap, if not dinode
+ *
+ * This function tries to set a block that's referenced as data as 'data'
+ * in the fsck blockmap. But if that block is marked as 'dinode' in the
+ * rgrp bitmap, it does additional checks to see if it looks like a dinode.
+ * Note that previous checks were done for duplicate references, so this
+ * is checking for dinodes that we haven't processed yet.
+ */
+static int blockmap_set_as_data(struct gfs2_inode *ip, uint64_t block)
+{
+ int error;
+ struct gfs2_buffer_head *bh;
+ struct gfs2_dinode *di;
+
+ error = fsck_blkmap_set_noino(ip, block, _("data"), gfs2_block_used);
+ if (!error)
+ return 0;
+
+ error = 0;
+ /* The bitmap says it's a dinode, but a block reference begs to differ.
+ So which is it? */
+ bh = bread(ip->i_sbd, block);
+ if (gfs2_check_meta(bh, GFS2_METATYPE_DI) != 0)
+ goto out;
+
+ /* The meta header agrees it's a dinode. But it might be data in
+ disguise, so do some extra checks. */
+ di = (struct gfs2_dinode *)bh->b_data;
+ if (be64_to_cpu(di->di_num.no_addr) != block)
+ goto out;
+
+ log_err(_("Inode %lld (0x%llx) has a reference to block %lld (0x%llx) "
+ "as a data block, but it appears to be a dinode we "
+ "haven't checked yet.\n"),
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)block, (unsigned long long)block);
+ error = -1;
+out:
+ if (!error)
+ fsck_blockmap_set(ip, block, _("data"), gfs2_block_used);
+ brelse(bh);
+ return error;
+}
+
static int check_data(struct gfs2_inode *ip, uint64_t metablock,
uint64_t block, void *private)
{
@@ -468,7 +521,7 @@ static int check_data(struct gfs2_inode *ip, uint64_t metablock,
(unsigned long long)block, (unsigned long long)block);
fsck_blockmap_set(ip, block, _("jdata"), gfs2_jdata);
} else
- fsck_blockmap_set(ip, block, _("data"), gfs2_block_used);
+ return blockmap_set_as_data(ip, block);
return 0;
}
@@ -1195,7 +1248,7 @@ static int check_system_inode(struct gfs2_sbd *sdp,
(unsigned long long)iblock,
(unsigned long long)iblock);
gfs2_blockmap_set(bl, iblock, gfs2_block_free);
- check_n_fix_bitmap(sdp, iblock, gfs2_block_free);
+ check_n_fix_bitmap(sdp, iblock, 0, gfs2_block_free);
inode_put(sysinode);
}
}
@@ -1442,7 +1495,7 @@ int pass1(struct gfs2_sbd *sdp)
}
/* rgrps and bitmaps don't have bits to represent
their blocks, so don't do this:
- check_n_fix_bitmap(sdp, rgd->ri.ri_addr + i,
+ check_n_fix_bitmap(sdp, rgd->ri.ri_addr + i, 0,
gfs2_meta_rgrp);*/
}
@@ -1556,7 +1609,7 @@ int pass1(struct gfs2_sbd *sdp)
"block #%llu (0x%llx)\n"),
(unsigned long long)block,
(unsigned long long)block);
- check_n_fix_bitmap(sdp, block,
+ check_n_fix_bitmap(sdp, block, 0,
gfs2_block_free);
}
} else if (handle_di(sdp, bh) < 0) {
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index bf26c2c..224a5d0 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -499,7 +499,7 @@ static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *dt)
dup_delete(dh.dt);
/* Now fix the block type of the block in question. */
gfs2_blockmap_set(bl, dup_blk, gfs2_block_free);
- check_n_fix_bitmap(sdp, dup_blk, gfs2_block_free);
+ check_n_fix_bitmap(sdp, dup_blk, 0, gfs2_block_free);
}
}
return 0;
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 99481c9..02fa577 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -1706,7 +1706,7 @@ int pass2(struct gfs2_sbd *sdp)
/* Can't use fsck_blockmap_set here because we don't
have an inode in memory. */
gfs2_blockmap_set(bl, dirblk, gfs2_inode_invalid);
- check_n_fix_bitmap(sdp, dirblk, gfs2_inode_invalid);
+ check_n_fix_bitmap(sdp, dirblk, 0, gfs2_inode_invalid);
}
ip = fsck_load_inode(sdp, dirblk);
if (!ds.dotdir) {
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index f5f38c5..6a6305a 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -273,7 +273,7 @@ int pass3(struct gfs2_sbd *sdp)
gfs2_blockmap_set(bl, di->dinode.no_addr,
gfs2_block_free);
check_n_fix_bitmap(sdp, di->dinode.no_addr,
- gfs2_block_free);
+ 0, gfs2_block_free);
break;
} else
log_err( _("Unlinked directory with bad block remains\n"));
@@ -297,7 +297,7 @@ int pass3(struct gfs2_sbd *sdp)
because we don't have ip */
gfs2_blockmap_set(bl, di->dinode.no_addr,
gfs2_block_free);
- check_n_fix_bitmap(sdp, di->dinode.no_addr,
+ check_n_fix_bitmap(sdp, di->dinode.no_addr, 0,
gfs2_block_free);
log_err( _("The block was cleared\n"));
break;
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: Remove unused variable
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=47739c96de9...
Commit: 47739c96de94d8de07ee1e8d92cf845d083cb422
Parent: d2c1adbcd728fc611b59292e1ac7aca6699af5a2
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Tue May 14 15:00:22 2013 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:30:51 2013 -0500
fsck.gfs2: Remove unused variable
This patch removes a variable that wasn't being used.
rhbz#902920
---
gfs2/fsck/pass1b.c | 2 --
1 files changed, 0 insertions(+), 2 deletions(-)
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index c7889f6..bf26c2c 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -144,7 +144,6 @@ static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
enum dup_ref_type this_ref;
struct inode_info *ii;
int found_good_ref = 0;
- uint64_t dup_block;
uint8_t q;
osi_list_foreach_safe(tmp, ref_list, x) {
@@ -226,7 +225,6 @@ static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
(unsigned long long)id->block_no,
(unsigned long long)id->block_no);
- dup_block = id->block_no;
ip = fsck_load_inode(sdp, id->block_no);
/* If we've already deleted this dinode, don't try to delete
it again. That could free blocks that used to be duplicate
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: Remove all bad eattr blocks
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=d2c1adbcd72...
Commit: d2c1adbcd728fc611b59292e1ac7aca6699af5a2
Parent: 73cd9def968ad89bc28e02a8c8f8d630e1114c5b
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Wed Apr 3 11:52:05 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:30:46 2013 -0500
fsck.gfs2: Remove all bad eattr blocks
Before this patch, bad extended attributes were not properly removed
from a dinode, and blocks were not freed. This patch properly
removes them all.
rhbz#902920
---
gfs2/fsck/pass1.c | 12 ++++++++----
gfs2/fsck/pass1c.c | 8 +++++++-
gfs2/fsck/pass2.c | 18 ++++++++++--------
3 files changed, 25 insertions(+), 13 deletions(-)
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 85ad49a..90e3829 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -486,6 +486,8 @@ static int remove_inode_eattr(struct gfs2_inode *ip, struct block_count *bc)
static int ask_remove_inode_eattr(struct gfs2_inode *ip,
struct block_count *bc)
{
+ if (ip->i_di.di_eattr == 0)
+ return 0; /* eattr was removed prior to this call */
log_err( _("Inode %lld (0x%llx) has unrecoverable Extended Attribute "
"errors.\n"), (unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
@@ -1073,11 +1075,13 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
if (fsck_abort)
return 0;
- error = check_inode_eattr(ip, &pass1_fxns);
+ if (!error) {
+ error = check_inode_eattr(ip, &pass1_fxns);
- if (error &&
- !(ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT))
- ask_remove_inode_eattr(ip, &bc);
+ if (error &&
+ !(ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT))
+ ask_remove_inode_eattr(ip, &bc);
+ }
if (ip->i_di.di_blocks !=
(1 + bc.indir_count + bc.data_count + bc.ea_count)) {
diff --git a/gfs2/fsck/pass1c.c b/gfs2/fsck/pass1c.c
index f9bfa6a..16e3db3 100644
--- a/gfs2/fsck/pass1c.c
+++ b/gfs2/fsck/pass1c.c
@@ -10,6 +10,12 @@
#include "util.h"
#include "metawalk.h"
+struct metawalk_fxns pass1c_fxns_delete = {
+ .private = NULL,
+ .check_eattr_indir = delete_eattr_indir,
+ .check_eattr_leaf = delete_eattr_leaf,
+};
+
static int remove_eattr_entry(struct gfs2_sbd *sdp,
struct gfs2_buffer_head *leaf_bh,
struct gfs2_ea_header *curr,
@@ -60,7 +66,7 @@ static int ask_remove_eattr_entry(struct gfs2_sbd *sdp,
static int ask_remove_eattr(struct gfs2_inode *ip)
{
if (query( _("Remove the bad Extended Attribute? (y/n) "))) {
- ip->i_di.di_eattr = 0;
+ check_inode_eattr(ip, &pass1c_fxns_delete);
bmodified(ip->i_bh);
log_err( _("Bad Extended Attribute removed.\n"));
return 1;
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 11ceab9..99481c9 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -18,11 +18,13 @@
#define MAX_FILENAME 256
-struct metawalk_fxns clear_eattrs = {
+struct metawalk_fxns pass2_fxns;
+
+struct metawalk_fxns delete_eattrs = {
.check_eattr_indir = delete_eattr_indir,
.check_eattr_leaf = delete_eattr_leaf,
- .check_eattr_entry = clear_eattr_entry,
- .check_eattr_extentry = clear_eattr_extentry,
+ .check_eattr_entry = delete_eattr_entry,
+ .check_eattr_extentry = delete_eattr_extentry,
};
/* Set children's parent inode in dir_info structure - ext2 does not set
@@ -597,7 +599,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry->no_addr);
- check_inode_eattr(entry_ip, &clear_eattrs);
+ check_inode_eattr(entry_ip, &delete_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
return 1;
@@ -681,7 +683,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
- check_inode_eattr(entry_ip, &clear_eattrs);
+ check_inode_eattr(entry_ip, &delete_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
goto nuke_dentry;
@@ -712,7 +714,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
- check_inode_eattr(entry_ip, &clear_eattrs);
+ check_inode_eattr(entry_ip, &delete_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
goto nuke_dentry;
@@ -742,7 +744,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
- check_inode_eattr(entry_ip, &clear_eattrs);
+ check_inode_eattr(entry_ip, &delete_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
@@ -762,7 +764,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
- check_inode_eattr(entry_ip, &clear_eattrs);
+ check_inode_eattr(entry_ip, &delete_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: major duplicate reference reform
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=73cd9def968...
Commit: 73cd9def968ad89bc28e02a8c8f8d630e1114c5b
Parent: ebf7e17895b0ba7b4bf97af9714e52d7ea63efa0
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Wed Apr 3 10:50:24 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:30:23 2013 -0500
fsck.gfs2: major duplicate reference reform
This patch is a large set of changes designed to rework how pass1b
resolves duplicate block references. There are basically two major
changes with this patch:
First, the metawalk functions were trying to attribute too much
information to the return codes of its callback functions: (1) Was
there an error? (2) Was the inode valid? (3) Was a duplicate block
reference encountered? (4) Should we keep going and process more of
its metadata? This often led to bad decisions made by metawalk:
For example, it would stop processing metadata when it should have
continued, thereby forgetting to mark blocks free that were no longer
in use. This patch introduces two new variables to the metatree
functions, *is_valid and *was_duplicate. The first one indicates
whether the dinode was valid or whether there is good cause to
delete it. The second indicates whether a duplicate block reference
was encountered. With this patch, the return code indicates simply
whether metadata processing should be skipped or not, and nothing
more. This is especially useful in pass1. For example, if it
encounters major corruption in a dinode, it doesn't do any good to
mark all its blocks as duplicates and have the undo functions try
to reverse all those decisions.
The second major change with this patch has to do with the
philosophy of how duplicate references are resolved. Before, pass1
would flag the duplicates and pass1b would try to resolve them all,
marking dinodes that should be deleted as "bad", and pass2 would
delete the bad dinodes. This becomes very problematic and messy
in pass1b, especially in cases where you have a number of duplicate
references that are common between multiple dinodes. For example,
suppose files A, B and C share some of the same blocks, but not
others:
A - 0x3000 0x3001 0x1233 0x1234 0x3004
B - 0x4000 0x4001 0x4002 0x1234 0x1235
C - 0x1231 0x1232 0x1233 0x1234 0x1235
The old strategy that got us into trouble was to log the three
duplicate blocks, delete invalid dinodes A and B, but leave the
duplicate reference structure around for 0x1233, 0x1234 and 0x1235
so that C would be left intact with the only references to all five
blocks. But in cleaning up the leftover duplicate structure often
led to bad decisions where C wouldn't have all its blocks marked
as referenced. Often, you would end up with blocks that were marked
as free which were still in use, and blocks that were marked as
in use that should have been freed, and it was all due to the
existence of those duplicate structures that were still on the list
until pass2.
The new strategy is to resolve-as-you-go. In other words, pass1b
considers the three duplicate blocks, but when it decides that
file A should be deleted, it removes all its references from the
list, thereby making the decision between B and C easier: it no
longer has to worry about block 1233, and there's only one thing
to consider about block 0x1234 and 0x1235. When B is deleted, it
removes all its duplicate references, so block 0x1235 is no longer
considered to be in conflict. Once a file is deleted, all its
duplicate reference structures are removed so as not to confuse
other duplicates being resolved. The duplicate handler structure,
struct dup_handler, is revised with every reference that's resolved
so it's not working off a long list of possibles, most of
which were already taken care of by previous actions.
rhbz#902920
---
gfs2/fsck/fsck.h | 2 -
gfs2/fsck/initialize.c | 2 +-
gfs2/fsck/metawalk.c | 217 +++++++++----
gfs2/fsck/metawalk.h | 31 ++-
gfs2/fsck/pass1.c | 101 ++++---
gfs2/fsck/pass1b.c | 808 ++++++++++++++++++++----------------------------
gfs2/fsck/pass2.c | 60 ----
gfs2/fsck/util.c | 37 ++-
gfs2/fsck/util.h | 3 +-
9 files changed, 611 insertions(+), 650 deletions(-)
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 87d0a04..cc86268 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -112,11 +112,9 @@ extern int pass4(struct gfs2_sbd *sdp);
extern int pass5(struct gfs2_sbd *sdp);
extern int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count,
int *sane);
-extern void gfs2_dup_free(void);
extern int fsck_query(const char *format, ...)
__attribute__((format(printf,1,2)));
extern struct dir_info *dirtree_find(uint64_t block);
-extern void dup_listent_delete(struct inode_with_dups *id);
extern void dup_delete(struct duptree *dt);
extern void dirtree_delete(struct dir_info *b);
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 79e295b..0676426 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -64,7 +64,7 @@ static int block_mounters(struct gfs2_sbd *sdp, int block_em)
return 0;
}
-void gfs2_dup_free(void)
+static void gfs2_dup_free(void)
{
struct osi_node *n;
struct duptree *dt;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 7ce8524..15bdf7a 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -948,7 +948,8 @@ int delete_block(struct gfs2_inode *ip, uint64_t block,
/**
* find_remove_dup - find out if this is a duplicate ref. If so, remove it.
- * Returns: 0 if not a duplicate reference, 1 if it is.
+ *
+ * Returns: 1 if there are any remaining references to this block, else 0.
*/
int find_remove_dup(struct gfs2_inode *ip, uint64_t block, const char *btype)
{
@@ -962,41 +963,18 @@ int find_remove_dup(struct gfs2_inode *ip, uint64_t block, const char *btype)
/* remove the inode reference id structure for this reference. */
id = find_dup_ref_inode(dt, ip);
if (!id)
- return 0;
+ goto more_refs;
- dup_listent_delete(id);
- log_err( _("Removing duplicate status of block %llu (0x%llx) "
- "referenced as %s by dinode %llu (0x%llx)\n"),
- (unsigned long long)block, (unsigned long long)block,
- btype, (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- dt->refs--; /* one less reference */
- if (dt->refs == 1) {
- log_info( _("This leaves only one reference: it's "
- "no longer a duplicate.\n"));
+ dup_listent_delete(dt, id);
+ if (dt->refs == 0) {
+ log_info( _("This was the last reference: it's no longer a "
+ "duplicate.\n"));
dup_delete(dt); /* not duplicate now */
- } else
- log_info( _("%d block reference(s) remain.\n"),
- dt->refs);
- return 1; /* but the original ref still exists so do not free it. */
-}
-
-/**
- * free_block_if_notdup - free blocks associated with an inode, but if it's a
- * duplicate, just remove that designation instead.
- * Returns: 1 if the block was freed, 0 if a duplicate reference was removed
- * Note: The return code is handled this way because there are places in
- * metawalk.c that assume "1" means "change was made" and "0" means
- * change was not made.
- */
-int free_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
- const char *btype)
-{
- if (!find_remove_dup(ip, block, btype)) { /* not a dup */
- fsck_blockmap_set(ip, block, btype, gfs2_block_free);
- return meta_skip_further;
+ return 0;
}
- return meta_is_good;
+more_refs:
+ log_info( _("%d block reference(s) remain.\n"), dt->refs);
+ return 1; /* references still exist so do not free the block. */
}
/**
@@ -1008,7 +986,8 @@ int free_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
*/
static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh,
- const char *btype, void *private)
+ const char *btype, int *was_duplicate,
+ void *private)
{
uint8_t q;
@@ -1025,7 +1004,19 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
(unsigned long long)ip->i_di.di_num.no_addr);
return meta_is_good;
}
- return free_block_if_notdup(ip, block, btype);
+ if (find_remove_dup(ip, block, btype)) { /* a dup */
+ if (was_duplicate)
+ *was_duplicate = 1;
+ log_err( _("Not clearing duplicate reference in inode "
+ "at block #%llu (0x%llx) to block #%llu (0x%llx) "
+ "because it's referenced by another inode.\n"),
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)block, (unsigned long long)block);
+ } else {
+ fsck_blockmap_set(ip, block, btype, gfs2_block_free);
+ }
+ return meta_is_good;
}
/**
@@ -1195,7 +1186,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
osi_list_t *prev_list, *cur_list, *tmp;
int h, head_size, iblk_type;
uint64_t *ptr, block;
- int error = 0, err;
+ int error, was_duplicate, is_valid;
osi_list_add(&metabh->b_altlist, &mlp[0]);
@@ -1209,7 +1200,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
/* if (<there are no indirect blocks to check>) */
if (height < 2)
- return 0;
+ return meta_is_good;
for (h = 1; h < height; h++) {
if (h > 1) {
if (is_dir(&ip->i_di, ip->i_sbd->gfs1) &&
@@ -1241,7 +1232,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
ptr++) {
if (skip_this_pass || fsck_abort) {
free_metalist(ip, mlp);
- return FSCK_OK;
+ return meta_is_good;
}
nbh = NULL;
@@ -1249,19 +1240,41 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
continue;
block = be64_to_cpu(*ptr);
- err = pass->check_metalist(ip, block, &nbh, h,
- pass->private);
+ was_duplicate = 0;
+ error = pass->check_metalist(ip, block, &nbh,
+ h, &is_valid,
+ &was_duplicate,
+ pass->private);
/* check_metalist should hold any buffers
it gets with "bread". */
- if (err == meta_error) {
+ if (error == meta_error) {
stack;
- error = err;
+ log_info(_("\nSerious metadata "
+ "error on block %llu "
+ "(0x%llx).\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
return error;
}
- if (err == meta_skip_further) {
- if (!error)
- error = err;
- log_debug( _("Skipping block %llu (0x%llx)\n"),
+ if (error == meta_skip_further) {
+ log_info(_("\nUnrecoverable metadata "
+ "error on block %llu "
+ "(0x%llx). Further metadata"
+ " will be skipped.\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
+ return error;
+ }
+ if (!is_valid) {
+ log_debug( _("Skipping rejected block "
+ "%llu (0x%llx)\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
+ continue;
+ }
+ if (was_duplicate) {
+ log_debug( _("Skipping duplicate %llu "
+ "(0x%llx)\n"),
(unsigned long long)block,
(unsigned long long)block);
continue;
@@ -1589,34 +1602,52 @@ int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,
}
int delete_metadata(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private)
+ struct gfs2_buffer_head **bh, int h, int *is_valid,
+ int *was_duplicate, void *private)
{
- return delete_block_if_notdup(ip, block, bh, _("metadata"), private);
+ *is_valid = 1;
+ *was_duplicate = 0;
+ return delete_block_if_notdup(ip, block, bh, _("metadata"),
+ was_duplicate, private);
}
int delete_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
{
- return delete_block_if_notdup(ip, block, NULL, _("leaf"), private);
+ return delete_block_if_notdup(ip, block, NULL, _("leaf"), NULL,
+ private);
}
int delete_data(struct gfs2_inode *ip, uint64_t metablock,
uint64_t block, void *private)
{
- return delete_block_if_notdup(ip, block, NULL, _("data"), private);
+ return delete_block_if_notdup(ip, block, NULL, _("data"), NULL,
+ private);
}
-int delete_eattr_indir(struct gfs2_inode *ip, uint64_t block, uint64_t parent,
- struct gfs2_buffer_head **bh, void *private)
+static int del_eattr_generic(struct gfs2_inode *ip, uint64_t block,
+ uint64_t parent, struct gfs2_buffer_head **bh,
+ void *private, const char *eatype)
{
- int ret;
+ int ret = 0;
+ int was_free = 0;
+ uint8_t q;
- ret = delete_block_if_notdup(ip, block, NULL,
- _("indirect extended attribute"),
- private);
+ if (valid_block(ip->i_sbd, block)) {
+ q = block_type(block);
+ if (q == gfs2_block_free)
+ was_free = 1;
+ ret = delete_block_if_notdup(ip, block, NULL, eatype,
+ NULL, private);
+ if (!ret) {
+ *bh = bread(ip->i_sbd, block);
+ if (!was_free)
+ ip->i_di.di_blocks--;
+ bmodified(ip->i_bh);
+ }
+ }
/* Even if it's a duplicate reference, we want to eliminate the
reference itself, and adjust di_blocks accordingly. */
if (ip->i_di.di_eattr) {
- ip->i_di.di_blocks--;
if (block == ip->i_di.di_eattr)
ip->i_di.di_eattr = 0;
bmodified(ip->i_bh);
@@ -1624,24 +1655,74 @@ int delete_eattr_indir(struct gfs2_inode *ip, uint64_t block, uint64_t parent,
return ret;
}
+int delete_eattr_indir(struct gfs2_inode *ip, uint64_t block, uint64_t parent,
+ struct gfs2_buffer_head **bh, void *private)
+{
+ return del_eattr_generic(ip, block, parent, bh, private,
+ _("extended attribute"));
+}
+
int delete_eattr_leaf(struct gfs2_inode *ip, uint64_t block, uint64_t parent,
struct gfs2_buffer_head **bh, void *private)
{
- int ret;
+ return del_eattr_generic(ip, block, parent, bh, private,
+ _("indirect extended attribute"));
+}
- ret = delete_block_if_notdup(ip, block, NULL, _("extended attribute"),
- private);
- if (ip->i_di.di_eattr) {
- ip->i_di.di_blocks--;
- if (block == ip->i_di.di_eattr)
- ip->i_di.di_eattr = 0;
- bmodified(ip->i_bh);
+int delete_eattr_entry(struct gfs2_inode *ip, struct gfs2_buffer_head *leaf_bh,
+ struct gfs2_ea_header *ea_hdr,
+ struct gfs2_ea_header *ea_hdr_prev, void *private)
+{
+ struct gfs2_sbd *sdp = ip->i_sbd;
+ char ea_name[256];
+ uint32_t avail_size;
+ int max_ptrs;
+
+ if (!ea_hdr->ea_name_len){
+ /* Skip this entry for now */
+ return 1;
}
- return ret;
+
+ memset(ea_name, 0, sizeof(ea_name));
+ strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
+ ea_hdr->ea_name_len);
+
+ if (!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
+ ((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){
+ /* Skip invalid entry */
+ return 1;
+ }
+
+ if (!ea_hdr->ea_num_ptrs)
+ return 0;
+
+ avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
+ max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /
+ avail_size;
+
+ if (max_ptrs > ea_hdr->ea_num_ptrs)
+ return 1;
+
+ log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"),
+ max_ptrs, ea_hdr->ea_num_ptrs);
+
+ return 0;
+}
+
+int delete_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
+ struct gfs2_buffer_head *leaf_bh,
+ struct gfs2_ea_header *ea_hdr,
+ struct gfs2_ea_header *ea_hdr_prev, void *private)
+{
+ uint64_t block = be64_to_cpu(*ea_data_ptr);
+
+ return delete_block_if_notdup(ip, block, NULL, _("extended attribute"),
+ NULL, private);
}
static int alloc_metalist(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private)
+ struct gfs2_buffer_head **bh, int h, int *is_valid,
+ int *was_duplicate, void *private)
{
uint8_t q;
const char *desc = (const char *)private;
@@ -1649,6 +1730,8 @@ static int alloc_metalist(struct gfs2_inode *ip, uint64_t block,
/* No need to range_check here--if it was added, it's in range. */
/* We can't check the bitmap here because this function is called
after the bitmap has been set but before the blockmap has. */
+ *is_valid = 1;
+ *was_duplicate = 0;
*bh = bread(ip->i_sbd, block);
q = block_type(block);
if (blockmap_to_bitmap(q, ip->i_sbd->gfs1) == GFS2_BLKST_FREE) {
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index 49217cc..56f57d9 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -24,7 +24,8 @@ extern int delete_block(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, const char *btype,
void *private);
extern int delete_metadata(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private);
+ struct gfs2_buffer_head **bh, int h, int *is_valid,
+ int *was_duplicate, void *private);
extern int delete_leaf(struct gfs2_inode *ip, uint64_t block, void *private);
extern int delete_data(struct gfs2_inode *ip, uint64_t metablock,
uint64_t block, void *private);
@@ -32,6 +33,17 @@ extern int delete_eattr_indir(struct gfs2_inode *ip, uint64_t block, uint64_t pa
struct gfs2_buffer_head **bh, void *private);
extern int delete_eattr_leaf(struct gfs2_inode *ip, uint64_t block, uint64_t parent,
struct gfs2_buffer_head **bh, void *private);
+extern int delete_eattr_entry(struct gfs2_inode *ip,
+ struct gfs2_buffer_head *leaf_bh,
+ struct gfs2_ea_header *ea_hdr,
+ struct gfs2_ea_header *ea_hdr_prev,
+ void *private);
+extern int delete_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
+ struct gfs2_buffer_head *leaf_bh,
+ struct gfs2_ea_header *ea_hdr,
+ struct gfs2_ea_header *ea_hdr_prev,
+ void *private);
+
extern int _fsck_blockmap_set(struct gfs2_inode *ip, uint64_t bblock,
const char *btype, enum gfs2_mark_block mark,
const char *caller, int line);
@@ -48,8 +60,6 @@ extern int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
uint64_t *bn);
extern int repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, int lindex,
int ref_count, const char *msg);
-extern int free_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
- const char *btype);
#define is_duplicate(dblock) ((dupfind(dblock)) ? 1 : 0)
@@ -83,8 +93,23 @@ struct metawalk_fxns {
int ref_count, struct gfs2_buffer_head *lbh);
int (*check_leaf) (struct gfs2_inode *ip, uint64_t block,
void *private);
+ /* parameters to the check_metalist sub-functions:
+ ip: incore inode pointer
+ block: block number of the metadata block to be checked
+ bh: buffer_head to be returned
+ h: height
+ is_valid: returned as 1 if the metadata block is valid and should
+ be added to the metadata list for further processing.
+ was_duplicate: returns as 1 if the metadata block was determined
+ to be a duplicate reference, in which case we want to
+ skip adding it to the metadata list.
+ private: Pointer to pass-specific data
+ returns: 0 - everything is good, but there may be duplicates
+ 1 - skip further processing
+ */
int (*check_metalist) (struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
+ int *is_valid, int *was_duplicate,
void *private);
int (*check_data) (struct gfs2_inode *ip, uint64_t metablock,
uint64_t block, void *private);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 564f75d..85ad49a 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -36,7 +36,8 @@ struct block_count {
static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private);
static int check_metalist(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private);
+ struct gfs2_buffer_head **bh, int h, int *is_valid,
+ int *was_duplicate, void *private);
static int undo_check_metalist(struct gfs2_inode *ip, uint64_t block,
int h, void *private);
static int check_data(struct gfs2_inode *ip, uint64_t metablock,
@@ -63,6 +64,7 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,
int leaf_pointer_errors, void *private);
static int invalidate_metadata(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
+ int *is_valid, int *was_duplicate,
void *private);
static int invalidate_leaf(struct gfs2_inode *ip, uint64_t block,
void *private);
@@ -126,10 +128,13 @@ struct metawalk_fxns invalidate_fxns = {
*/
static int resuscitate_metalist(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
+ int *is_valid, int *was_duplicate,
void *private)
{
struct block_count *bc = (struct block_count *)private;
+ *is_valid = 1;
+ *was_duplicate = 0;
*bh = NULL;
if (!valid_block(ip->i_sbd, block)){ /* blk outside of FS */
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
@@ -138,7 +143,8 @@ static int resuscitate_metalist(struct gfs2_inode *ip, uint64_t block,
"range) found in system inode %lld (0x%llx).\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- return meta_skip_further;
+ *is_valid = 0;
+ return meta_is_good;
}
if (fsck_system_inode(ip->i_sbd, block))
fsck_blockmap_set(ip, block, _("system file"), gfs2_indir_blk);
@@ -240,16 +246,19 @@ static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
}
static int check_metalist(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private)
+ struct gfs2_buffer_head **bh, int h, int *is_valid,
+ int *was_duplicate, void *private)
{
uint8_t q;
- int found_dup = 0, iblk_type;
+ int iblk_type;
struct gfs2_buffer_head *nbh;
struct block_count *bc = (struct block_count *)private;
const char *blktypedesc;
*bh = NULL;
+ *was_duplicate = 0;
+ *is_valid = 0;
if (!valid_block(ip->i_sbd, block)) { /* blk outside of FS */
/* The bad dinode should be invalidated later due to
"unrecoverable" errors. The inode itself should be
@@ -281,12 +290,13 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr, q,
block_type_string(q));
- add_duplicate_ref(ip, block, ref_as_meta, 0, INODE_VALID);
- found_dup = 1;
+ *was_duplicate = 1;
}
nbh = bread(ip->i_sbd, block);
- if (gfs2_check_meta(nbh, iblk_type)){
+ *is_valid = (gfs2_check_meta(nbh, iblk_type) == 0);
+
+ if (!(*is_valid)) {
log_err( _("Inode %lld (0x%llx) has a bad indirect block "
"pointer %lld (0x%llx) (points to something "
"that is not %s).\n"),
@@ -294,31 +304,23 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)block,
(unsigned long long)block, blktypedesc);
- if (!found_dup) {
- fsck_blockmap_set(ip, block, _("bad indirect"),
- gfs2_meta_inval);
- brelse(nbh);
- nbh = NULL;
- return meta_skip_further;
- }
brelse(nbh);
- nbh = NULL;
- } else /* blk check ok */
- *bh = nbh;
+ return meta_skip_further;
+ }
bc->indir_count++;
- if (found_dup) {
- if (nbh) {
- brelse(nbh);
- nbh = NULL;
- *bh = NULL;
- }
- return meta_skip_further; /* don't process the metadata again */
- } else
- fsck_blockmap_set(ip, block, _("indirect"),
- gfs2_indir_blk);
+ if (*was_duplicate) {
+ add_duplicate_ref(ip, block, ref_as_meta, 0,
+ *is_valid ? INODE_VALID : INODE_INVALID);
+ brelse(nbh);
+ } else {
+ *bh = nbh;
+ fsck_blockmap_set(ip, block, _("indirect"), gfs2_indir_blk);
+ }
- return meta_is_good;
+ if (*is_valid)
+ return meta_is_good;
+ return meta_skip_further;
}
/* undo_reference - undo previously processed data or metadata
@@ -353,7 +355,7 @@ static int undo_reference(struct gfs2_inode *ip, uint64_t block, int meta,
if (!id)
break;
- dup_listent_delete(id);
+ dup_listent_delete(dt, id);
} while (id);
if (dt->refs) {
@@ -826,7 +828,8 @@ static int check_eattr_entries(struct gfs2_inode *ip,
* delete_block_if_notdup.
*/
static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
- enum dup_ref_type reftype, const char *btype)
+ enum dup_ref_type reftype, const char *btype,
+ int *is_valid, int *was_duplicate)
{
uint8_t q;
@@ -837,11 +840,20 @@ static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
* referenced elsewhere (duplicates) won't be flagged as such,
* and as a result, they'll be freed when this dinode is deleted,
* despite being used by another dinode as a valid block. */
- if (!valid_block(ip->i_sbd, block))
+ if (is_valid)
+ *is_valid = 1;
+ if (was_duplicate)
+ *was_duplicate = 0;
+ if (!valid_block(ip->i_sbd, block)) {
+ if (is_valid)
+ *is_valid = 0;
return meta_is_good;
+ }
q = block_type(block);
if (q != gfs2_block_free) {
+ if (was_duplicate)
+ *was_duplicate = 1;
add_duplicate_ref(ip, block, reftype, 0, INODE_INVALID);
log_info( _("%s block %lld (0x%llx), part of inode "
"%lld (0x%llx), was previously referenced so "
@@ -858,21 +870,27 @@ static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
static int invalidate_metadata(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
+ int *is_valid, int *was_duplicate,
void *private)
{
- return mark_block_invalid(ip, block, ref_as_meta, _("metadata"));
+ *is_valid = 1;
+ *was_duplicate = 0;
+ return mark_block_invalid(ip, block, ref_as_meta, _("metadata"),
+ is_valid, was_duplicate);
}
static int invalidate_leaf(struct gfs2_inode *ip, uint64_t block,
void *private)
{
- return mark_block_invalid(ip, block, ref_as_meta, _("leaf"));
+ return mark_block_invalid(ip, block, ref_as_meta, _("leaf"),
+ NULL, NULL);
}
static int invalidate_data(struct gfs2_inode *ip, uint64_t metablock,
uint64_t block, void *private)
{
- return mark_block_invalid(ip, block, ref_as_data, _("data"));
+ return mark_block_invalid(ip, block, ref_as_data, _("data"),
+ NULL, NULL);
}
static int invalidate_eattr_indir(struct gfs2_inode *ip, uint64_t block,
@@ -880,7 +898,8 @@ static int invalidate_eattr_indir(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, void *private)
{
return mark_block_invalid(ip, block, ref_as_ea,
- _("indirect extended attribute"));
+ _("indirect extended attribute"),
+ NULL, NULL);
}
static int invalidate_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
@@ -888,7 +907,8 @@ static int invalidate_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
void *private)
{
return mark_block_invalid(ip, block, ref_as_ea,
- _("extended attribute"));
+ _("extended attribute"),
+ NULL, NULL);
}
/**
@@ -923,7 +943,7 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
if ((*bad_pointers) <= BAD_POINTER_TOLERANCE)
- return meta_skip_further;
+ return meta_is_good;
else
return meta_error; /* Exits check_metatree quicker */
}
@@ -938,7 +958,7 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
if ((*bad_pointers) <= BAD_POINTER_TOLERANCE)
- return meta_skip_further;
+ return meta_is_good;
else
return meta_error; /* Exits check_metatree quicker */
}
@@ -947,8 +967,11 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
static int rangecheck_metadata(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
+ int *is_valid, int *was_duplicate,
void *private)
{
+ *is_valid = 1;
+ *was_duplicate = 0;
return rangecheck_block(ip, block, bh, btype_meta, private);
}
@@ -1047,7 +1070,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
/* We there was an error, we return 0 because we want fsck to continue
and analyze the other dinodes as well. */
- if (fsck_abort || error != 0)
+ if (fsck_abort)
return 0;
error = check_inode_eattr(ip, &pass1_fxns);
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index 03e47ec..c7889f6 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -21,384 +21,10 @@ struct fxn_info {
struct dup_handler {
struct duptree *dt;
- struct inode_with_dups *id;
int ref_inode_count;
int ref_count;
};
-static int check_leaf_refs(struct gfs2_inode *ip, uint64_t block, void *private);
-static int check_metalist(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private);
-static int check_data(struct gfs2_inode *ip, uint64_t metablock,
- uint64_t block, void *private);
-static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private);
-static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private);
-static int check_eattr_entry(struct gfs2_inode *ip,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private);
-static int check_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private);
-static int find_dentry(struct gfs2_inode *ip, struct gfs2_dirent *de,
- struct gfs2_dirent *prev, struct gfs2_buffer_head *bh,
- char *filename, uint32_t *count, int lindex,
- void *priv);
-
-struct metawalk_fxns find_refs = {
- .private = NULL,
- .check_leaf = check_leaf_refs,
- .check_metalist = check_metalist,
- .check_data = check_data,
- .check_eattr_indir = check_eattr_indir,
- .check_eattr_leaf = check_eattr_leaf,
- .check_dentry = NULL,
- .check_eattr_entry = check_eattr_entry,
- .check_eattr_extentry = check_eattr_extentry,
-};
-
-struct metawalk_fxns find_dirents = {
- .private = NULL,
- .check_leaf = NULL,
- .check_metalist = NULL,
- .check_data = NULL,
- .check_eattr_indir = NULL,
- .check_eattr_leaf = NULL,
- .check_dentry = find_dentry,
- .check_eattr_entry = NULL,
- .check_eattr_extentry = NULL,
-};
-
-static int check_leaf_refs(struct gfs2_inode *ip, uint64_t block, void *private)
-{
- return add_duplicate_ref(ip, block, ref_as_meta, 1, INODE_VALID);
-}
-
-static int check_metalist(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h, void *private)
-{
- return add_duplicate_ref(ip, block, ref_as_meta, 1, INODE_VALID);
-}
-
-static int check_data(struct gfs2_inode *ip, uint64_t metablock,
- uint64_t block, void *private)
-{
- return add_duplicate_ref(ip, block, ref_as_data, 1, INODE_VALID);
-}
-
-static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private)
-{
- struct gfs2_sbd *sdp = ip->i_sbd;
- int error;
-
- error = add_duplicate_ref(ip, block, ref_as_ea, 1, INODE_VALID);
- if (!error)
- *bh = bread(sdp, block);
-
- return error;
-}
-
-static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private)
-{
- struct gfs2_sbd *sdp = ip->i_sbd;
- int error;
-
- error = add_duplicate_ref(ip, block, ref_as_ea, 1, INODE_VALID);
- if (!error)
- *bh = bread(sdp, block);
- return error;
-}
-
-static int check_eattr_entry(struct gfs2_inode *ip,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev, void *private)
-{
- return 0;
-}
-
-static int check_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private)
-{
- uint64_t block = be64_to_cpu(*ea_data_ptr);
-
- return add_duplicate_ref(ip, block, ref_as_ea, 1, INODE_VALID);
-}
-
-/*
- * check_dir_dup_ref - check for a directory entry duplicate reference
- * and if found, set the name into the id.
- * Returns: 1 if filename was found, otherwise 0
- */
-static int check_dir_dup_ref(struct gfs2_inode *ip, struct gfs2_dirent *de,
- osi_list_t *tmp2, char *filename)
-{
- struct inode_with_dups *id;
-
- id = osi_list_entry(tmp2, struct inode_with_dups, list);
- if (id->name)
- /* We can only have one parent of inodes that contain duplicate
- * blocks...no need to keep looking for this one. */
- return 1;
- if (id->block_no == de->de_inum.no_addr) {
- id->name = strdup(filename);
- id->parent = ip->i_di.di_num.no_addr;
- log_debug( _("Duplicate block %llu (0x%llx"
- ") is in file or directory %llu"
- " (0x%llx) named %s\n"),
- (unsigned long long)id->block_no,
- (unsigned long long)id->block_no,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- filename);
- /* If there are duplicates of duplicates, I guess we'll miss
- them here. */
- return 1;
- }
- return 0;
-}
-
-static int find_dentry(struct gfs2_inode *ip, struct gfs2_dirent *de,
- struct gfs2_dirent *prev,
- struct gfs2_buffer_head *bh, char *filename,
- uint32_t *count, int lindex, void *priv)
-{
- struct osi_node *n, *next = NULL;
- osi_list_t *tmp2;
- struct duptree *dt;
- int found;
-
- for (n = osi_first(&dup_blocks); n; n = next) {
- next = osi_next(n);
- dt = (struct duptree *)n;
- found = 0;
- osi_list_foreach(tmp2, &dt->ref_invinode_list) {
- if (check_dir_dup_ref(ip, de, tmp2, filename)) {
- found = 1;
- break;
- }
- }
- if (!found) {
- osi_list_foreach(tmp2, &dt->ref_inode_list) {
- if (check_dir_dup_ref(ip, de, tmp2, filename))
- break;
- }
- }
- }
- /* Return the number of leaf entries so metawalk doesn't flag this
- leaf as having none. */
- *count = be16_to_cpu(((struct gfs2_leaf *)bh->b_data)->lf_entries);
- return 0;
-}
-
-static int clear_dup_metalist(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head **bh, int h,
- void *private)
-{
- struct dup_handler *dh = (struct dup_handler *) private;
- struct duptree *dt;
-
- if (!valid_block(ip->i_sbd, block))
- return meta_is_good;
-
- /* This gets tricky. We're traversing a metadata tree trying to
- delete an inode based on it having a duplicate block reference
- somewhere in its metadata. We know this block is listed as data
- or metadata for this inode, but it may or may not be one of the
- actual duplicate references that caused the problem. If it's not
- a duplicate, it's normal metadata that isn't referenced anywhere
- else, but we're deleting the inode out from under it, so we need
- to delete it altogether. If the block is a duplicate referenced
- block, we need to keep its type intact and let the caller sort
- it out once we're down to a single reference. */
- dt = dupfind(block);
- if (!dt) {
- fsck_blockmap_set(ip, block, _("no longer valid"),
- gfs2_block_free);
- return meta_is_good;
- }
- /* This block, having failed the above test, is duplicated somewhere */
- if (block == dh->dt->block) {
- log_err( _("Not clearing duplicate reference in inode \"%s\" "
- "at block #%llu (0x%llx) to block #%llu (0x%llx) "
- "because it's valid for another inode.\n"),
- dh->id->name ? dh->id->name : _("unknown name"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
- log_err( _("Inode %s is in directory %"PRIu64" (0x%" PRIx64 ")\n"),
- dh->id->name ? dh->id->name : "", dh->id->parent,
- dh->id->parent);
- }
- /* We return 1 not 0 because we need build_and_check_metalist to
- bypass adding the metadata below it to the metalist. If that
- were to happen, all the indirect blocks pointed to by the
- duplicate block would be processed twice, which means it might
- be mistakenly freed as "no longer valid" (in this function above)
- even though it's valid metadata for a different inode. Returning
- 1 ensures that the metadata isn't processed again. */
- return meta_skip_further;
-}
-
-static int clear_dup_data(struct gfs2_inode *ip, uint64_t metablock,
- uint64_t block, void *private)
-{
- return clear_dup_metalist(ip, block, NULL, 0, private);
-}
-
-static int clear_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
-{
- return clear_dup_metalist(ip, block, NULL, 0, private);
-}
-
-static int clear_dup_eattr_indir(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private)
-{
- return clear_dup_metalist(ip, block, NULL, 0, private);
-}
-
-static int clear_dup_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private)
-{
- return clear_dup_metalist(ip, block, NULL, 0, private);
-}
-
-static int clear_eattr_entry (struct gfs2_inode *ip,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private)
-{
- struct gfs2_sbd *sdp = ip->i_sbd;
- char ea_name[256];
-
- if (!ea_hdr->ea_name_len){
- /* Skip this entry for now */
- return 1;
- }
-
- memset(ea_name, 0, sizeof(ea_name));
- strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
- ea_hdr->ea_name_len);
-
- if (!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
- ((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){
- /* Skip invalid entry */
- return 1;
- }
-
- if (ea_hdr->ea_num_ptrs){
- uint32_t avail_size;
- int max_ptrs;
-
- avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
- max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /
- avail_size;
-
- if (max_ptrs > ea_hdr->ea_num_ptrs)
- return 1;
- else {
- log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"),
- max_ptrs, ea_hdr->ea_num_ptrs);
- }
- }
- return 0;
-}
-
-static int clear_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private)
-{
- uint64_t block = be64_to_cpu(*ea_data_ptr);
-
- return clear_dup_metalist(ip, block, NULL, 0, private);
-}
-
-/* Finds all references to duplicate blocks in the metadata */
-static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode)
-{
- struct gfs2_inode *ip;
- int error = 0;
-
- ip = fsck_load_inode(sdp, inode); /* bread, inode_get */
- /* double-check the meta header just to be sure it's metadata */
- if (ip->i_di.di_header.mh_magic != GFS2_MAGIC ||
- ip->i_di.di_header.mh_type != GFS2_METATYPE_DI) {
- log_debug( _("Block %lld (0x%llx) is not gfs2 metadata.\n"),
- (unsigned long long)inode,
- (unsigned long long)inode);
- return 1;
- }
- /* Check to see if this inode was referenced by another by mistake */
- add_duplicate_ref(ip, inode, ref_is_inode, 1, INODE_VALID);
-
- /* Check this dinode's metadata for references to known duplicates */
- error = check_metatree(ip, &find_refs);
- if (error < 0) {
- stack;
- fsck_inode_put(&ip); /* out, brelse, free */
- return error;
- }
-
- /* Exhash dir leafs will be checked by check_metatree (right after
- the "end:" label.) But if this is a linear directory we need to
- check the dir with check_linear_dir. */
- if (is_dir(&ip->i_di, sdp->gfs1) &&
- !(ip->i_di.di_flags & GFS2_DIF_EXHASH))
- error = check_linear_dir(ip, ip->i_bh, &find_dirents);
-
- /* Check for ea references in the inode */
- if (!error)
- error = check_inode_eattr(ip, &find_refs);
-
- fsck_inode_put(&ip); /* out, brelse, free */
-
- return error;
-}
-
-/* get_ref_type - figure out if all duplicate references from this inode
- are the same type, and if so, return the type. */
-static enum dup_ref_type get_ref_type(struct inode_with_dups *id)
-{
- enum dup_ref_type t, i;
- int found_type_with_ref;
- int found_other_types;
-
- for (t = ref_as_data; t < ref_types; t++) {
- found_type_with_ref = 0;
- found_other_types = 0;
- for (i = ref_as_data; i < ref_types; i++) {
- if (id->reftypecount[i]) {
- if (t == i)
- found_type_with_ref = 1;
- else
- found_other_types = 1;
- }
- }
- if (found_type_with_ref)
- return found_other_types ? ref_types : t;
- }
- return ref_types;
-}
-
static void log_inode_reference(struct duptree *dt, osi_list_t *tmp, int inval)
{
char reftypestring[32];
@@ -422,12 +48,74 @@ static void log_inode_reference(struct duptree *dt, osi_list_t *tmp, int inval)
(unsigned long long)dt->block,
(unsigned long long)dt->block, reftypestring);
}
+
+/* delete_all_dups - delete all duplicate records for a given inode */
+static void delete_all_dups(struct gfs2_inode *ip)
+{
+ struct osi_node *n, *next;
+ struct duptree *dt;
+ osi_list_t *tmp, *x;
+ struct inode_with_dups *id;
+ int found;
+
+ for (n = osi_first(&dup_blocks); n; n = next) {
+ next = osi_next(n);
+ dt = (struct duptree *)n;
+
+ found = 0;
+ id = NULL;
+
+ osi_list_foreach_safe(tmp, &dt->ref_invinode_list, x) {
+ id = osi_list_entry(tmp, struct inode_with_dups, list);
+ if (id->block_no == ip->i_di.di_num.no_addr) {
+ dup_listent_delete(dt, id);
+ found = 1;
+ }
+ }
+ osi_list_foreach_safe(tmp, &dt->ref_inode_list, x) {
+ id = osi_list_entry(tmp, struct inode_with_dups, list);
+ if (id->block_no == ip->i_di.di_num.no_addr) {
+ dup_listent_delete(dt, id);
+ found = 1;
+ }
+ }
+ if (!found)
+ continue;
+
+ if (dt->refs == 0) {
+ log_debug(_("This was the last reference: 0x%llx is "
+ "no longer a duplicate.\n"),
+ (unsigned long long)dt->block);
+ dup_delete(dt); /* not duplicate now */
+ } else {
+ log_debug(_("%d references remain to 0x%llx\n"),
+ dt->refs, (unsigned long long)dt->block);
+ if (dt->refs > 1)
+ continue;
+
+ id = NULL;
+ osi_list_foreach(tmp, &dt->ref_invinode_list)
+ id = osi_list_entry(tmp,
+ struct inode_with_dups,
+ list);
+ osi_list_foreach(tmp, &dt->ref_inode_list)
+ id = osi_list_entry(tmp,
+ struct inode_with_dups,
+ list);
+ if (id)
+ log_debug("Last reference is from inode "
+ "0x%llx\n",
+ (unsigned long long)id->block_no);
+ }
+ }
+}
+
/*
* resolve_dup_references - resolve all but the last dinode that has a
* duplicate reference to a given block.
*
* @sdp - pointer to the superblock structure
- * @b - pointer to the duplicate reference rbtree to use
+ * @dt - pointer to the duplicate reference rbtree to use
* @ref_list - list of duplicate references to be resolved (invalid or valid)
* @dh - duplicate handler
* inval - The references on this ref_list are invalid. We prefer to delete
@@ -435,40 +123,42 @@ static void log_inode_reference(struct duptree *dt, osi_list_t *tmp, int inval)
* acceptable_ref - Delete dinodes that reference the given block as anything
* _but_ this type. Try to save references as this type.
*/
-static int resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
- osi_list_t *ref_list, struct dup_handler *dh,
- int inval, int acceptable_ref)
+static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
+ osi_list_t *ref_list,
+ struct dup_handler *dh,
+ int inval, int acceptable_ref)
{
struct gfs2_inode *ip;
struct inode_with_dups *id;
osi_list_t *tmp, *x;
- struct metawalk_fxns clear_dup_fxns = {
+ struct metawalk_fxns pass1b_fxns_delete = {
.private = NULL,
- .check_leaf = clear_leaf,
- .check_metalist = clear_dup_metalist,
- .check_data = clear_dup_data,
- .check_eattr_indir = clear_dup_eattr_indir,
- .check_eattr_leaf = clear_dup_eattr_leaf,
- .check_dentry = NULL,
- .check_eattr_entry = clear_eattr_entry,
- .check_eattr_extentry = clear_eattr_extentry,
+ .check_metalist = delete_metadata,
+ .check_data = delete_data,
+ .check_leaf = delete_leaf,
+ .check_eattr_indir = delete_eattr_indir,
+ .check_eattr_leaf = delete_eattr_leaf,
+ .check_eattr_entry = delete_eattr_entry,
+ .check_eattr_extentry = delete_eattr_extentry,
};
enum dup_ref_type this_ref;
struct inode_info *ii;
int found_good_ref = 0;
+ uint64_t dup_block;
+ uint8_t q;
osi_list_foreach_safe(tmp, ref_list, x) {
if (skip_this_pass || fsck_abort)
- return FSCK_OK;
+ return;
id = osi_list_entry(tmp, struct inode_with_dups, list);
dh->dt = dt;
- dh->id = id;
if (dh->ref_inode_count == 1) /* down to the last reference */
- return 1;
+ return;
this_ref = get_ref_type(id);
+ q = block_type(id->block_no);
if (inval)
log_warn( _("Invalid "));
/* FIXME: If we already found an acceptable reference to this
@@ -480,11 +170,8 @@ static int resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
type and */
this_ref == acceptable_ref && /* this ref is acceptable */
!found_good_ref) { /* We haven't found a good reference */
- uint8_t q;
-
/* If this is an invalid inode, but not on the invalid
list, it's better to delete it. */
- q = block_type(id->block_no);
if (q != gfs2_inode_invalid) {
found_good_ref = 1;
log_warn( _("Inode %s (%lld/0x%llx)'s "
@@ -522,69 +209,124 @@ static int resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
(unsigned long long)id->block_no))) {
log_warn( _("The bad inode was not cleared."));
/* delete the list entry so we don't leak memory but
- leave the reference count. If the decrement the
+ leave the reference count. If we decrement the
ref count, we could get down to 1 and the dinode
would be changed without a 'Yes' answer. */
/* (dh->ref_inode_count)--;*/
- dup_listent_delete(id);
+ dup_listent_delete(dt, id);
continue;
}
- log_warn( _("Clearing inode %lld (0x%llx)...\n"),
- (unsigned long long)id->block_no,
- (unsigned long long)id->block_no);
-
+ if (q == gfs2_block_free)
+ log_warn( _("Inode %lld (0x%llx) was previously "
+ "deleted.\n"),
+ (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no);
+ else
+ log_warn(_("Pass1b is deleting inode %lld (0x%llx).\n"),
+ (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no);
+
+ dup_block = id->block_no;
ip = fsck_load_inode(sdp, id->block_no);
- if (id->reftypecount[ref_as_data] ||
- id->reftypecount[ref_as_meta]) {
- ii = inodetree_find(ip->i_di.di_num.no_addr);
- if (ii)
- inodetree_delete(ii);
- }
- clear_dup_fxns.private = (void *) dh;
- /* Clear the EAs for the inode first */
- check_inode_eattr(ip, &clear_dup_fxns);
- /* If the dup was in data or metadata, clear the dinode */
- if (id->reftypecount[ref_as_data] ||
- id->reftypecount[ref_as_meta]) {
- check_metatree(ip, &clear_dup_fxns);
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("duplicate referencing bad"),
- gfs2_inode_invalid);
+ /* If we've already deleted this dinode, don't try to delete
+ it again. That could free blocks that used to be duplicate
+ references that are now resolved (and gone). */
+ if (q != gfs2_block_free) {
+ /* Clear the EAs for the inode first */
+ check_inode_eattr(ip, &pass1b_fxns_delete);
+ /* If the reference was as metadata or data, we've got
+ a corrupt dinode that will be deleted. */
+ if (inval || id->reftypecount[ref_as_data] ||
+ id->reftypecount[ref_as_meta]) {
+ /* Remove the inode from the inode tree */
+ ii = inodetree_find(ip->i_di.di_num.no_addr);
+ if (ii)
+ inodetree_delete(ii);
+ fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
+ _("duplicate referencing bad"),
+ gfs2_inode_invalid);
+ /* We delete the dup_handler inode count and
+ duplicate id BEFORE clearing the metadata,
+ because if this is the last reference to
+ this metadata block, we need to traverse the
+ tree and free the data blocks it references.
+ However, we don't want to delete other
+ duplicates that may be used by other
+ dinodes. */
+ (dh->ref_inode_count)--;
+ /* FIXME: other option should be to duplicate
+ the block for each duplicate and point the
+ metadata at the cloned blocks */
+ check_metatree(ip, &pass1b_fxns_delete);
+ }
}
+ /* Now we've got to go through an delete any other duplicate
+ references from this dinode we're deleting. If we don't,
+ pass1b will discover the other duplicate record, try to
+ delete this dinode a second time, and this time its earlier
+ duplicate references won't be seen as duplicates anymore
+ (because they were eliminated earlier in pass1b). And so
+ the blocks will be mistakenly freed, when, in fact, they're
+ still being referenced by a valid dinode. */
+ delete_all_dups(ip);
fsck_inode_put(&ip); /* out, brelse, free */
- (dh->ref_inode_count)--;
- /* FIXME: other option should be to duplicate the
- * block for each duplicate and point the metadata at
- * the cloned blocks */
- dup_listent_delete(id);
}
- if (dh->ref_inode_count == 1) /* down to the last reference */
- return 1;
- return 0;
+ return;
}
-static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *dt)
+/* revise_dup_handler - get current information about a duplicate reference
+ *
+ * Function resolve_dup_references can delete dinodes that reference blocks
+ * which may have duplicate references. Therefore, the duplicate tree is
+ * constantly being changed. This function revises the duplicate handler so
+ * that it accurately matches what's in the duplicate tree regarding this block
+ */
+static void revise_dup_handler(uint64_t dup_blk, struct dup_handler *dh)
{
- struct gfs2_inode *ip;
osi_list_t *tmp;
+ struct duptree *dt;
struct inode_with_dups *id;
- struct dup_handler dh = {0};
- int last_reference = 0;
- struct gfs2_buffer_head *bh;
- uint32_t cmagic, ctype;
- enum dup_ref_type acceptable_ref;
+ dh->ref_inode_count = 0;
+ dh->ref_count = 0;
+ dh->dt = NULL;
+
+ dt = dupfind(dup_blk);
+ if (!dt)
+ return;
+
+ dh->dt = dt;
/* Count the duplicate references, both valid and invalid */
osi_list_foreach(tmp, &dt->ref_invinode_list) {
id = osi_list_entry(tmp, struct inode_with_dups, list);
- dh.ref_inode_count++;
- dh.ref_count += id->dup_count;
+ dh->ref_inode_count++;
+ dh->ref_count += id->dup_count;
}
osi_list_foreach(tmp, &dt->ref_inode_list) {
id = osi_list_entry(tmp, struct inode_with_dups, list);
- dh.ref_inode_count++;
- dh.ref_count += id->dup_count;
+ dh->ref_inode_count++;
+ dh->ref_count += id->dup_count;
}
+}
+
+/* handle_dup_blk - handle a duplicate block reference.
+ *
+ * This function should resolve and delete the duplicate block reference given,
+ * iow dt.
+ */
+static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *dt)
+{
+ osi_list_t *tmp;
+ struct gfs2_inode *ip;
+ struct inode_with_dups *id;
+ struct dup_handler dh = {0};
+ struct gfs2_buffer_head *bh;
+ uint32_t cmagic, ctype;
+ enum dup_ref_type acceptable_ref;
+ uint64_t dup_blk;
+
+ dup_blk = dt->block;
+ revise_dup_handler(dup_blk, &dh);
/* Log the duplicate references */
log_notice( _("Block %llu (0x%llx) has %d inodes referencing it"
@@ -638,77 +380,67 @@ static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *dt)
invalidated for other reasons, such as bad pointers. So we need to
make sure at this point that any inode deletes reverse out any
duplicate reference before we get to this point. */
- if (dh.ref_count == 1)
- last_reference = 1;
/* Step 1 - eliminate references from inodes that are not valid.
* This may be because they were deleted due to corruption.
* All block types are unacceptable, so we use ref_types.
*/
- if (!last_reference) {
+ if (dh.ref_count > 1) {
log_debug( _("----------------------------------------------\n"
"Step 1: Eliminate references to block %llu "
"(0x%llx) that were previously marked "
"invalid.\n"),
(unsigned long long)dt->block,
(unsigned long long)dt->block);
- last_reference = resolve_dup_references(sdp, dt,
- &dt->ref_invinode_list,
- &dh, 1, ref_types);
+ resolve_dup_references(sdp, dt, &dt->ref_invinode_list,
+ &dh, 1, ref_types);
+ revise_dup_handler(dup_blk, &dh);
}
/* Step 2 - eliminate reference from inodes that reference it as the
* wrong type. For example, a data file referencing it as
* a data block, but it's really a metadata block. Or a
* directory inode referencing a data block as a leaf block.
*/
- if (!last_reference) {
+ if (dh.ref_count > 1) {
log_debug( _("----------------------------------------------\n"
"Step 2: Eliminate references to block %llu "
"(0x%llx) that need the wrong block type.\n"),
(unsigned long long)dt->block,
(unsigned long long)dt->block);
- last_reference = resolve_dup_references(sdp, dt,
- &dt->ref_inode_list,
- &dh, 0,
- acceptable_ref);
+ resolve_dup_references(sdp, dt, &dt->ref_inode_list, &dh, 0,
+ acceptable_ref);
+ revise_dup_handler(dup_blk, &dh);
}
/* Step 3 - We have multiple dinodes referencing it as the correct
* type. Just blast one of them.
* All block types are fair game, so we use ref_types.
*/
- if (!last_reference) {
+ if (dh.ref_count > 1) {
log_debug( _("----------------------------------------------\n"
"Step 3: Choose one reference to block %llu "
"(0x%llx) to keep.\n"),
(unsigned long long)dt->block,
(unsigned long long)dt->block);
- last_reference = resolve_dup_references(sdp, dt,
- &dt->ref_inode_list,
- &dh, 0, ref_types);
- }
- /* Now fix the block type of the block in question. */
- if (osi_list_empty(&dt->ref_inode_list)) {
- log_notice( _("Block %llu (0x%llx) has no more references; "
- "Marking as 'free'.\n"),
- (unsigned long long)dt->block,
- (unsigned long long)dt->block);
- gfs2_blockmap_set(bl, dt->block, gfs2_block_free);
- check_n_fix_bitmap(sdp, dt->block, gfs2_block_free);
- return 0;
+ resolve_dup_references(sdp, dt, &dt->ref_inode_list, &dh, 0,
+ ref_types);
+ revise_dup_handler(dup_blk, &dh);
}
- if (last_reference) {
+ /* If there's still a last remaining reference, and it's a valid
+ reference, use it to determine the correct block type for our
+ blockmap and bitmap. */
+ if (dh.ref_count == 1 && !osi_list_empty(&dt->ref_inode_list)) {
uint8_t q;
log_notice( _("Block %llu (0x%llx) has only one remaining "
- "reference.\n"),
- (unsigned long long)dt->block,
- (unsigned long long)dt->block);
+ "valid reference.\n"),
+ (unsigned long long)dup_blk,
+ (unsigned long long)dup_blk);
/* If we're down to a single reference (and not all references
deleted, which may be the case of an inode that has only
itself and a reference), we need to reset the block type
from invalid to data or metadata. Start at the first one
in the list, not the structure's place holder. */
- tmp = (&dt->ref_inode_list)->next;
+ tmp = dt->ref_inode_list.next;
id = osi_list_entry(tmp, struct inode_with_dups, list);
log_debug( _("----------------------------------------------\n"
"Step 4. Set block type based on the remaining "
@@ -749,13 +481,147 @@ static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *dt)
"attribute"),
gfs2_meta_eattr);
fsck_inode_put(&ip); /* out, brelse, free */
+ log_debug(_("Done with duplicate reference to block 0x%llx\n"),
+ (unsigned long long)dt->block);
+ dup_delete(dt);
} else {
/* They may have answered no and not fixed all references. */
- log_debug( _("All duplicate references were processed.\n"));
+ log_debug( _("All duplicate references to block 0x%llx were "
+ "processed.\n"), (unsigned long long)dup_blk);
+ if (dh.ref_count) {
+ log_debug(_("Done with duplicate reference to block "
+ "0x%llx, but %d references remain.\n"),
+ (unsigned long long)dup_blk, dh.ref_count);
+ } else {
+ log_notice( _("Block %llu (0x%llx) has no more "
+ "references; Marking as 'free'.\n"),
+ (unsigned long long)dup_blk,
+ (unsigned long long)dup_blk);
+ if (dh.dt)
+ dup_delete(dh.dt);
+ /* Now fix the block type of the block in question. */
+ gfs2_blockmap_set(bl, dup_blk, gfs2_block_free);
+ check_n_fix_bitmap(sdp, dup_blk, gfs2_block_free);
+ }
}
return 0;
}
+static int check_leaf_refs(struct gfs2_inode *ip, uint64_t block,
+ void *private)
+{
+ return add_duplicate_ref(ip, block, ref_as_meta, 1, INODE_VALID);
+}
+
+static int check_metalist_refs(struct gfs2_inode *ip, uint64_t block,
+ struct gfs2_buffer_head **bh, int h,
+ int *is_valid, int *was_duplicate,
+ void *private)
+{
+ *was_duplicate = 0;
+ *is_valid = 1;
+ return add_duplicate_ref(ip, block, ref_as_meta, 1, INODE_VALID);
+}
+
+static int check_data_refs(struct gfs2_inode *ip, uint64_t metablock,
+ uint64_t block, void *private)
+{
+ return add_duplicate_ref(ip, block, ref_as_data, 1, INODE_VALID);
+}
+
+static int check_eattr_indir_refs(struct gfs2_inode *ip, uint64_t block,
+ uint64_t parent,
+ struct gfs2_buffer_head **bh, void *private)
+{
+ struct gfs2_sbd *sdp = ip->i_sbd;
+ int error;
+
+ error = add_duplicate_ref(ip, block, ref_as_ea, 1, INODE_VALID);
+ if (!error)
+ *bh = bread(sdp, block);
+
+ return error;
+}
+
+static int check_eattr_leaf_refs(struct gfs2_inode *ip, uint64_t block,
+ uint64_t parent, struct gfs2_buffer_head **bh,
+ void *private)
+{
+ struct gfs2_sbd *sdp = ip->i_sbd;
+ int error;
+
+ error = add_duplicate_ref(ip, block, ref_as_ea, 1, INODE_VALID);
+ if (!error)
+ *bh = bread(sdp, block);
+ return error;
+}
+
+static int check_eattr_entry_refs(struct gfs2_inode *ip,
+ struct gfs2_buffer_head *leaf_bh,
+ struct gfs2_ea_header *ea_hdr,
+ struct gfs2_ea_header *ea_hdr_prev,
+ void *private)
+{
+ return 0;
+}
+
+static int check_eattr_extentry_refs(struct gfs2_inode *ip,
+ uint64_t *ea_data_ptr,
+ struct gfs2_buffer_head *leaf_bh,
+ struct gfs2_ea_header *ea_hdr,
+ struct gfs2_ea_header *ea_hdr_prev,
+ void *private)
+{
+ uint64_t block = be64_to_cpu(*ea_data_ptr);
+
+ return add_duplicate_ref(ip, block, ref_as_ea, 1, INODE_VALID);
+}
+
+/* Finds all references to duplicate blocks in the metadata */
+/* Finds all references to duplicate blocks in the metadata */
+static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode)
+{
+ struct gfs2_inode *ip;
+ int error = 0;
+ struct metawalk_fxns find_refs = {
+ .private = NULL,
+ .check_leaf = check_leaf_refs,
+ .check_metalist = check_metalist_refs,
+ .check_data = check_data_refs,
+ .check_eattr_indir = check_eattr_indir_refs,
+ .check_eattr_leaf = check_eattr_leaf_refs,
+ .check_eattr_entry = check_eattr_entry_refs,
+ .check_eattr_extentry = check_eattr_extentry_refs,
+ };
+
+ ip = fsck_load_inode(sdp, inode); /* bread, inode_get */
+
+ /* double-check the meta header just to be sure it's metadata */
+ if (ip->i_di.di_header.mh_magic != GFS2_MAGIC ||
+ ip->i_di.di_header.mh_type != GFS2_METATYPE_DI) {
+ log_debug( _("Block %lld (0x%llx) is not gfs2 metadata.\n"),
+ (unsigned long long)inode,
+ (unsigned long long)inode);
+ error = 1;
+ goto out;
+ }
+ /* Check to see if this inode was referenced by another by mistake */
+ add_duplicate_ref(ip, inode, ref_is_inode, 1, INODE_VALID);
+
+ /* Check this dinode's metadata for references to known duplicates */
+ error = check_metatree(ip, &find_refs);
+ if (error < 0)
+ stack;
+
+ /* Check for ea references in the inode */
+ if (!error)
+ error = check_inode_eattr(ip, &find_refs);
+
+out:
+ fsck_inode_put(&ip); /* out, brelse, free */
+ return error;
+}
+
/* Pass 1b handles finding the previous inode for a duplicate block
* When found, store the inodes pointing to the duplicate block for
* use in pass2 */
@@ -764,7 +630,7 @@ int pass1b(struct gfs2_sbd *sdp)
struct duptree *dt;
uint64_t i;
uint8_t q;
- struct osi_node *n, *next = NULL;
+ struct osi_node *n;
int rc = FSCK_OK;
log_info( _("Looking for duplicate blocks...\n"));
@@ -815,17 +681,11 @@ int pass1b(struct gfs2_sbd *sdp)
* it later */
log_info( _("Handling duplicate blocks\n"));
out:
- for (n = osi_first(&dup_blocks); n; n = next) {
- next = osi_next(n);
+ /* Resolve all duplicates by clearing out the dup tree */
+ while ((n = osi_first(&dup_blocks))) {
dt = (struct duptree *)n;
if (!skip_this_pass && !rc) /* no error & not asked to skip the rest */
handle_dup_blk(sdp, dt);
- /* Do not attempt to free the dup_blocks list or its parts
- here because any func that calls check_metatree needs
- to check duplicate status based on this linked list.
- This is especially true for pass2 where it may delete "bad"
- inodes, and we can't delete an inode's indirect block if
- it was a duplicate (therefore in use by another dinode). */
}
return rc;
}
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 81d4710..11ceab9 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -167,59 +167,6 @@ static int check_file_type(uint8_t de_type, uint8_t blk_type, int gfs1)
return 0;
}
-static int delete_eattr_entry (struct gfs2_inode *ip,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private)
-{
- struct gfs2_sbd *sdp = ip->i_sbd;
- char ea_name[256];
-
- if (!ea_hdr->ea_name_len){
- /* Skip this entry for now */
- return 1;
- }
-
- memset(ea_name, 0, sizeof(ea_name));
- strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
- ea_hdr->ea_name_len);
-
- if (!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
- ((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){
- /* Skip invalid entry */
- return 1;
- }
-
- if (ea_hdr->ea_num_ptrs){
- uint32_t avail_size;
- int max_ptrs;
-
- avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
- max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /
- avail_size;
-
- if (max_ptrs > ea_hdr->ea_num_ptrs)
- return 1;
- else {
- log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"),
- max_ptrs, ea_hdr->ea_num_ptrs);
- }
- }
- return 0;
-}
-
-static int delete_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
- struct gfs2_buffer_head *leaf_bh,
- struct gfs2_ea_header *ea_hdr,
- struct gfs2_ea_header *ea_hdr_prev,
- void *private)
-{
- uint64_t block = be64_to_cpu(*ea_data_ptr);
-
- return delete_metadata(ip, block, NULL, 0, private);
-}
-
struct metawalk_fxns pass2_fxns_delete = {
.private = NULL,
.check_metalist = delete_metadata,
@@ -1829,12 +1776,5 @@ int pass2(struct gfs2_sbd *sdp)
}
fsck_inode_put(&ip); /* does a gfs2_dinode_out, brelse */
}
- /* Now that we've deleted the inodes marked "bad" we can safely
- get rid of the duplicate block list. If we do it any sooner,
- we won't discover that a given block is a duplicate and avoid
- deleting it from both inodes referencing it. Note: The other
- returns from this function are premature exits of the program
- and gfs2_block_list_destroy should get rid of the list for us. */
- gfs2_dup_free();
return FSCK_OK;
}
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index f40aeb3..d4d9034 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -384,8 +384,39 @@ struct dir_info *dirtree_find(uint64_t block)
return NULL;
}
-void dup_listent_delete(struct inode_with_dups *id)
+/* get_ref_type - figure out if all duplicate references from this inode
+ are the same type, and if so, return the type. */
+enum dup_ref_type get_ref_type(struct inode_with_dups *id)
{
+ enum dup_ref_type t, i;
+ int found_type_with_ref;
+ int found_other_types;
+
+ for (t = ref_as_data; t < ref_types; t++) {
+ found_type_with_ref = 0;
+ found_other_types = 0;
+ for (i = ref_as_data; i < ref_types; i++) {
+ if (id->reftypecount[i]) {
+ if (t == i)
+ found_type_with_ref = 1;
+ else
+ found_other_types = 1;
+ }
+ }
+ if (found_type_with_ref)
+ return found_other_types ? ref_types : t;
+ }
+ return ref_types;
+}
+
+void dup_listent_delete(struct duptree *dt, struct inode_with_dups *id)
+{
+ log_err( _("Removing duplicate reference to block %llu (0x%llx) "
+ "referenced as %s by dinode %llu (0x%llx)\n"),
+ (unsigned long long)dt->block, (unsigned long long)dt->block,
+ reftypes[get_ref_type(id)], (unsigned long long)id->block_no,
+ (unsigned long long)id->block_no);
+ dt->refs--; /* one less reference */
if (id->name)
free(id->name);
osi_list_del(&id->list);
@@ -400,12 +431,12 @@ void dup_delete(struct duptree *dt)
while (!osi_list_empty(&dt->ref_invinode_list)) {
tmp = (&dt->ref_invinode_list)->next;
id = osi_list_entry(tmp, struct inode_with_dups, list);
- dup_listent_delete(id);
+ dup_listent_delete(dt, id);
}
while (!osi_list_empty(&dt->ref_inode_list)) {
tmp = (&dt->ref_inode_list)->next;
id = osi_list_entry(tmp, struct inode_with_dups, list);
- dup_listent_delete(id);
+ dup_listent_delete(dt, id);
}
osi_erase(&dt->node, &dup_blocks);
free(dt);
diff --git a/gfs2/fsck/util.h b/gfs2/fsck/util.h
index a4ff437..940f500 100644
--- a/gfs2/fsck/util.h
+++ b/gfs2/fsck/util.h
@@ -19,7 +19,7 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
enum dup_ref_type reftype, int first, int inode_valid);
extern struct inode_with_dups *find_dup_ref_inode(struct duptree *dt,
struct gfs2_inode *ip);
-extern void dup_listent_delete(struct inode_with_dups *id);
+extern void dup_listent_delete(struct duptree *dt, struct inode_with_dups *id);
extern const char *reftypes[ref_types + 1];
@@ -174,6 +174,7 @@ static inline uint32_t gfs_to_gfs2_mode(struct gfs2_inode *ip)
}
}
+extern enum dup_ref_type get_ref_type(struct inode_with_dups *id);
extern struct gfs2_bmap *gfs2_bmap_create(struct gfs2_sbd *sdp, uint64_t size,
uint64_t *addl_mem_needed);
extern void *gfs2_bmap_destroy(struct gfs2_sbd *sdp, struct gfs2_bmap *il);
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: When flagging a duplicate reference, show valid or invalid
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=ebf7e17895b...
Commit: ebf7e17895b0ba7b4bf97af9714e52d7ea63efa0
Parent: 8c4b34b4afcb4b51d927f5e2dfebeb0a60ece4cb
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Wed Apr 3 10:03:49 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:29:20 2013 -0500
fsck.gfs2: When flagging a duplicate reference, show valid or invalid
This patch changes the logging when duplicate block references are
flagged. The idea is to print whether or not the inode with the reference
is valid or invalid, which helps in diagnosing problems when duplicate
block references are resolved.
rhbz#902920
---
gfs2/fsck/util.c | 3 ++-
1 files changed, 2 insertions(+), 1 deletions(-)
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 48c4b33..f40aeb3 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -317,9 +317,10 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
id->reftypecount[reftype]++;
id->dup_count++;
log_info( _("Found %d reference(s) to block %llu"
- " (0x%llx) as %s in inode #%llu (0x%llx)\n"),
+ " (0x%llx) as %s in %s inode #%llu (0x%llx)\n"),
id->dup_count, (unsigned long long)block,
(unsigned long long)block, reftypes[reftype],
+ inode_valid ? _("valid") : _("invalid"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
if (first)
10 years, 11 months
- 1
- 0
cluster: RHEL6 - fsck.gfs2: check for duplicate first references
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=8c4b34b4afc...
Commit: 8c4b34b4afcb4b51d927f5e2dfebeb0a60ece4cb
Parent: 7e2edea6c24a396abd88ea92e8cc405f5f03cf82
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Wed Apr 3 09:47:31 2013 -0700
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri May 17 15:29:16 2013 -0500
fsck.gfs2: check for duplicate first references
Before this patch, fsck.gfs2 could get into situations where it's
in pass1b searching for the first reference to a block that it knows
has been referenced twice. However, for one reason or another, the
first reference has been deleted. It may seem unlikely because pass1
tries to "undo" its references when it deletes a bad dinode. But
it can still happen, for example, when pass1b decides to delete a
dinode because of a _different_ duplicate reference within the same
dinode. If the first reference was deleted prior to searching for the
original reference, pass1b won't find the original reference. So
prior to this patch, it would just keep on looking, until it found
the second reference. In other words, it would mistake the second
reference for the first reference. Then it would get confused and
treat the reference as a duplicate of itself. Later, it would choose
which reference to delete, and delete its dinode. But since they're
the same reference, it could delete a dinode with a perfectly good
reference (the first invalid reference having already been deleted).
The solution that this patch implements is to check if the first
reference we found is actually the second reference, and if so,
treat it as a first reference. That way, it avoids creating a
second duplicate reference structure, and later when it resolves
the references, it finds there's only one, and it doesn't need to
delete the valid dinode.
rhbz#902920
---
gfs2/fsck/util.c | 24 ++++++++++++++++++++++--
1 files changed, 22 insertions(+), 2 deletions(-)
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 2111684..48c4b33 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -248,6 +248,28 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
if (dt->first_ref_found)
return meta_is_good;
+ /* Check for a previous reference to this duplicate */
+ id = find_dup_ref_inode(dt, ip);
+
+ /* We have to be careful here. The original referencing dinode may have
+ deemed to be bad and deleted/freed in pass1. In that case, pass1b
+ wouldn't discover the correct [deleted] original reference. In
+ that case, we don't want to be confused and consider this second
+ reference the same as the first. If we do, we'll never be able to
+ resolve it. The first reference can't be the second reference. */
+ if (id && first && !dt->first_ref_found) {
+ log_info(_("Original reference to block %llu (0x%llx) was "
+ "previously found to be bad and deleted.\n"),
+ (unsigned long long)block,
+ (unsigned long long)block);
+ log_info(_("I'll consider the reference from inode %llu "
+ "(0x%llx) the first reference.\n"),
+ (unsigned long long)ip->i_di.di_num.no_addr,
+ (unsigned long long)ip->i_di.di_num.no_addr);
+ dt->first_ref_found = 1;
+ return meta_is_good;
+ }
+
/* The first time this is called from pass1 is actually the second
reference. When we go back in pass1b looking for the original
reference, we don't want to increment the reference count because
@@ -259,8 +281,6 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
dt->refs++;
}
- /* Check for a previous reference to this duplicate */
- id = find_dup_ref_inode(dt, ip);
if (id == NULL) {
/* Check for the inode on the invalid inode reference list. */
uint8_t q;
10 years, 11 months
- 1
- 0