cluster: RHEL510 - fsck.gfs2: get rid of triple negative logic
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=f48938510d7...
Commit: f48938510d7b96e93b9578a68d1e854783f95e87
Parent: 3be02e038736edcaa1be6f0d68661715dedb77d6
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 14:44:46 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:59 2013 -0700
fsck.gfs2: get rid of triple negative logic
This patch changes the logic of the code from being triple-negative
to single-negative so it won't twist your brain into knots.
rhbz#877150
---
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 b93447f..119271d 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -944,7 +944,7 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
uint8_t q;
struct duptree *d;
- if (!valid_block(ip->i_sbd, block) != 0)
+ if (!valid_block(ip->i_sbd, block))
return -EFAULT;
q = block_type(block);
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: fsck.gfs2: Make dir entry count 32 bits
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=3be02e03873...
Commit: 3be02e038736edcaa1be6f0d68661715dedb77d6
Parent: dce22ab145195e3f27b9a22f66181e914da4644d
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 14:38:19 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:59 2013 -0700
fsck.gfs2: fsck.gfs2: Make dir entry count 32 bits
When counting directory links, fsck.gfs2 was using a 16-bit integer.
Therefore, if a directory had more than 65535 links, it would wrap to
zero and the counts would be damaged by fsck.gfs2. Subsequent runs would
not find the corruption, but it was there nonetheless. You would
encounter it if you tried to delete enough entries to cause the count
to become negative.
rhbz#877150
---
gfs2/fsck/fsck.h | 6 +++---
gfs2/fsck/metawalk.c | 8 ++++----
gfs2/fsck/metawalk.h | 2 +-
gfs2/fsck/pass1.c | 2 +-
gfs2/fsck/pass1b.c | 4 ++--
gfs2/fsck/pass2.c | 2 +-
6 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 867b052..701313e 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -41,9 +41,9 @@ struct inode_info
{
struct osi_node node;
uint64_t inode;
- uint16_t di_nlink; /* the number of links the inode
- * thinks it has */
- uint16_t counted_links; /* the number of links we've found */
+ uint32_t di_nlink; /* the number of links the inode
+ * thinks it has */
+ uint32_t counted_links; /* the number of links we've found */
};
struct dir_info
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 5b2eb6a..b93447f 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -314,7 +314,7 @@ static void dirblk_truncate(struct gfs2_inode *ip, struct gfs2_dirent *fixb,
* -1 - error occurred
*/
static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
- int type, uint16_t *count, struct metawalk_fxns *pass)
+ int type, uint32_t *count, struct metawalk_fxns *pass)
{
struct gfs2_leaf *leaf = NULL;
struct gfs2_dirent *dent;
@@ -611,7 +611,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
struct gfs2_buffer_head *lbh;
int lindex;
struct gfs2_sbd *sdp = ip->i_sbd;
- uint16_t count;
+ uint32_t count;
int ref_count = 0, exp_count = 0;
/* Find the first valid leaf pointer in range and use it as our "old"
@@ -1386,7 +1386,7 @@ int check_linear_dir(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
struct metawalk_fxns *pass)
{
int error = 0;
- uint16_t count = 0;
+ uint32_t count = 0;
error = check_entries(ip, bh, DIR_LINEAR, &count, pass);
if (error < 0) {
@@ -1419,7 +1419,7 @@ int check_dir(struct gfs2_sbd *sdp, uint64_t block, struct metawalk_fxns *pass)
static int remove_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
struct gfs2_dirent *prev_de,
struct gfs2_buffer_head *bh,
- char *filename, uint16_t *count, void *private)
+ char *filename, uint32_t *count, void *private)
{
/* the metawalk_fxn's private field must be set to the dentry
* block we want to clear */
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index 16a6b24..b13dcb4 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -86,7 +86,7 @@ struct metawalk_fxns {
int (*check_dentry) (struct gfs2_inode *ip, struct gfs2_dirent *de,
struct gfs2_dirent *prev,
struct gfs2_buffer_head *bh,
- char *filename, uint16_t *count, void *private);
+ char *filename, uint32_t *count, void *private);
int (*check_eattr_entry) (struct gfs2_inode *ip,
struct gfs2_buffer_head *leaf_bh,
struct gfs2_ea_header *ea_hdr,
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 26c41ee..1b40c9f 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -159,7 +159,7 @@ static int resuscitate_metalist(struct gfs2_inode *ip, uint64_t block,
static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
struct gfs2_dirent *prev_de,
struct gfs2_buffer_head *bh, char *filename,
- uint16_t *count, void *priv)
+ uint32_t *count, void *priv)
{
struct gfs2_sbd *sdp = ip->i_sbd;
struct gfs2_dirent dentry, *de;
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index 64b6ed4..d7232d3 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -62,7 +62,7 @@ static int check_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
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, uint16_t *count, void *priv);
+ char *filename, uint32_t *count, void *priv);
struct metawalk_fxns find_refs = {
.private = NULL,
@@ -182,7 +182,7 @@ static int check_dir_dup_ref(struct gfs2_inode *ip, struct gfs2_dirent *de,
static int find_dentry(struct gfs2_inode *ip, struct gfs2_dirent *de,
struct gfs2_dirent *prev,
struct gfs2_buffer_head *bh, char *filename,
- uint16_t *count, void *priv)
+ uint32_t *count, void *priv)
{
struct osi_node *n, *next = NULL;
osi_list_t *tmp2;
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 9e4c045..dd816ab 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -179,7 +179,7 @@ struct metawalk_fxns pass2_fxns_delete = {
static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
struct gfs2_dirent *prev_de,
struct gfs2_buffer_head *bh, char *filename,
- uint16_t *count, void *priv)
+ uint32_t *count, void *priv)
{
struct gfs2_sbd *sdp = ip->i_sbd;
uint8_t q;
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: fsck.gfs2: Sync di_nlink adding links for lost+found
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=dce22ab1451...
Commit: dce22ab145195e3f27b9a22f66181e914da4644d
Parent: df252765275ed2f0c2e96a90c174e3d933d4945f
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 14:21:06 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:59 2013 -0700
fsck.gfs2: fsck.gfs2: Sync di_nlink adding links for lost+found
When adding a ".." entry to a directory newly linked to lost+found
fsck.gfs2 needs to update its di_nlink value to account for the new
link. If not, it can "correct" the di_nlink value to the wrong
value and not find the error until a second fsck.gfs2 is done.
This only happens in the rare case where there is no pre-existing
".." entry that may be reused to re-link to lost+found.
rhbz#877150
---
gfs2/fsck/lost_n_found.c | 2 ++
1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index 4ef4fb9..cfc3d07 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -122,6 +122,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
dip = fsck_load_inode(sdp, di->dotdot_parent);
if (dip->i_di.di_nlink > 0) {
dip->i_di.di_nlink--;
+ set_di_nlink(dip); /* keep inode tree in sync */
log_debug(_("Decrementing its links to %d\n"),
dip->i_di.di_nlink);
bmodified(dip->i_bh);
@@ -132,6 +133,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
"Changing it to 0.\n"),
dip->i_di.di_nlink);
dip->i_di.di_nlink = 0;
+ set_di_nlink(dip); /* keep inode tree in sync */
bmodified(dip->i_bh);
}
fsck_inode_put(&dip);
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: fsck.gfs2: Rename nlink functions to be intuitive
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=df252765275...
Commit: df252765275ed2f0c2e96a90c174e3d933d4945f
Parent: 9531018a56554c83f557fab33563d92a7266d954
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 14:01:18 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:59 2013 -0700
fsck.gfs2: fsck.gfs2: Rename nlink functions to be intuitive
Part of fsck's checks is to verify the count of links for directories,
but the variable names and function names are too confusing to understand
without in-depth analysis of what the code is doing.
This patch renames the structure variable "link_count" to something that
makes more intuitive sense: di_nlink, which matches the variable name in
the dinode. That distinguishes it from the number of links that fsck is
trying to count manually. It also renames the link count functions to
make them more intuitively obvious as well: set_di_nlink sets the di_nlink
based on the value passed in from the dinode, and incr_link_count and
decr_link_count increment and decrement the counted links respectively.
rhbz#877150
---
gfs2/fsck/fsck.h | 4 ++--
gfs2/fsck/link.c | 14 ++++++++------
gfs2/fsck/link.h | 10 +++++-----
gfs2/fsck/lost_n_found.c | 29 ++++++++++++++---------------
gfs2/fsck/pass1.c | 2 +-
gfs2/fsck/pass2.c | 20 ++++++++++----------
gfs2/fsck/pass3.c | 4 ++--
gfs2/fsck/pass4.c | 18 ++++++++++--------
8 files changed, 52 insertions(+), 49 deletions(-)
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 7b20d05..867b052 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -41,8 +41,8 @@ struct inode_info
{
struct osi_node node;
uint64_t inode;
- uint16_t link_count; /* the number of links the inode
- * thinks it has */
+ uint16_t di_nlink; /* the number of links the inode
+ * thinks it has */
uint16_t counted_links; /* the number of links we've found */
};
diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c
index 4c416bd..4bb9aff 100644
--- a/gfs2/fsck/link.c
+++ b/gfs2/fsck/link.c
@@ -24,9 +24,11 @@
#include "inode_hash.h"
#include "link.h"
-int set_link_count(uint64_t inode_no, uint32_t count)
+int set_di_nlink(struct gfs2_inode *ip)
{
struct inode_info *ii;
+ uint64_t inode_no = ip->i_di.di_num.no_addr;
+
/*log_debug( _("Setting link count to %u for %" PRIu64
" (0x%" PRIx64 ")\n"), count, inode_no, inode_no);*/
/* If the list has entries, look for one that matches inode_no */
@@ -34,14 +36,14 @@ int set_link_count(uint64_t inode_no, uint32_t count)
if (!ii)
ii = inodetree_insert(inode_no);
if (ii)
- ii->link_count = count;
+ ii->di_nlink = ip->i_di.di_nlink;
else
return -1;
return 0;
}
-int increment_link(uint64_t inode_no, uint64_t referenced_from,
- const char *why)
+int incr_link_count(uint64_t inode_no, uint64_t referenced_from,
+ const char *why)
{
struct inode_info *ii = NULL;
@@ -72,8 +74,8 @@ int increment_link(uint64_t inode_no, uint64_t referenced_from,
return 0;
}
-int decrement_link(uint64_t inode_no, uint64_t referenced_from,
- const char *why)
+int decr_link_count(uint64_t inode_no, uint64_t referenced_from,
+ const char *why)
{
struct inode_info *ii = NULL;
diff --git a/gfs2/fsck/link.h b/gfs2/fsck/link.h
index c43cda3..01ddc24 100644
--- a/gfs2/fsck/link.h
+++ b/gfs2/fsck/link.h
@@ -15,10 +15,10 @@
#ifndef _LINK_H
#define _LINK_H
-int set_link_count(uint64_t inode_no, uint32_t count);
-int increment_link(uint64_t inode_no, uint64_t referenced_from,
- const char *why);
-int decrement_link(uint64_t inode_no, uint64_t referenced_from,
- const char *why);
+int set_di_nlink(struct gfs2_inode *ip);
+int incr_link_count(uint64_t inode_no, uint64_t referenced_from,
+ const char *why);
+int decr_link_count(uint64_t inode_no, uint64_t referenced_from,
+ const char *why);
#endif /* _LINK_H */
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index 41e9783..4ef4fb9 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -55,8 +55,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
the root directory. We must increment the nlink value
in the hash table to keep them in sync so that pass4 can
detect and fix any descrepancies. */
- set_link_count(sdp->sd_sb.sb_root_dir.no_addr,
- sdp->md.rooti->i_di.di_nlink);
+ set_di_nlink(sdp->md.rooti);
q = block_type(lf_dip->i_di.di_num.no_addr);
if (q != gfs2_inode_dir) {
@@ -72,15 +71,15 @@ int add_inode_to_lf(struct gfs2_inode *ip){
_("lost+found dinode"),
gfs2_inode_dir);
/* root inode links to lost+found */
- increment_link(sdp->md.rooti->i_di.di_num.no_addr,
+ incr_link_count(sdp->md.rooti->i_di.di_num.no_addr,
lf_dip->i_di.di_num.no_addr, _("root"));
/* lost+found link for '.' from itself */
- increment_link(lf_dip->i_di.di_num.no_addr,
- lf_dip->i_di.di_num.no_addr, "\".\"");
+ incr_link_count(lf_dip->i_di.di_num.no_addr,
+ lf_dip->i_di.di_num.no_addr, "\".\"");
/* lost+found link for '..' back to root */
- increment_link(lf_dip->i_di.di_num.no_addr,
- sdp->md.rooti->i_di.di_num.no_addr,
- "\"..\"");
+ incr_link_count(lf_dip->i_di.di_num.no_addr,
+ sdp->md.rooti->i_di.di_num.no_addr,
+ "\"..\"");
}
log_info( _("lost+found directory is dinode %lld (0x%llx)\n"),
(unsigned long long)lf_dip->i_di.di_num.no_addr,
@@ -117,9 +116,9 @@ int add_inode_to_lf(struct gfs2_inode *ip){
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)di->dotdot_parent,
(unsigned long long)di->dotdot_parent);
- decrement_link(di->dotdot_parent,
- ip->i_di.di_num.no_addr,
- _(".. unlinked, moving to lost+found"));
+ decr_link_count(di->dotdot_parent,
+ ip->i_di.di_num.no_addr,
+ _(".. unlinked, moving to lost+found"));
dip = fsck_load_inode(sdp, di->dotdot_parent);
if (dip->i_di.di_nlink > 0) {
dip->i_di.di_nlink--;
@@ -189,12 +188,12 @@ int add_inode_to_lf(struct gfs2_inode *ip){
reprocess_inode(lf_dip, "lost+found");
/* This inode is linked from lost+found */
- increment_link(ip->i_di.di_num.no_addr, lf_dip->i_di.di_num.no_addr,
- _("from lost+found"));
+ incr_link_count(ip->i_di.di_num.no_addr, lf_dip->i_di.di_num.no_addr,
+ _("from lost+found"));
/* If it's a directory, lost+found is back-linked to it via .. */
if (S_ISDIR(ip->i_di.di_mode))
- increment_link(lf_dip->i_di.di_num.no_addr,
- ip->i_di.di_mode, _("to lost+found"));
+ incr_link_count(lf_dip->i_di.di_num.no_addr,
+ ip->i_di.di_mode, _("to lost+found"));
log_notice( _("Added inode #%llu (0x%llx) to lost+found dir\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 0de9c90..26c41ee 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -1072,7 +1072,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
goto bad_dinode;
return 0;
}
- if (set_link_count(ip->i_di.di_num.no_addr, ip->i_di.di_nlink))
+ if (set_di_nlink(ip))
goto bad_dinode;
if (S_ISDIR(ip->i_di.di_mode) &&
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 2d42c14..9e4c045 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -223,7 +223,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
(*count)++;
ds->entry_count++;
/* can't do this because the block is out of range:
- increment_link(entryblock); */
+ incr_link_count(entryblock); */
return 0;
}
}
@@ -310,7 +310,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/* Don't decrement the link here: Here in pass2, we increment
only when we know it's okay.
- decrement_link(ip->i_di.di_num.no_addr); */
+ decr_link_count(ip->i_di.di_num.no_addr); */
/* If it was previously marked invalid (i.e. known
to be bad, not just a free block, etc.) then the temptation
would be to delete any metadata it holds. The trouble is:
@@ -508,8 +508,8 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
dentry_is_valid:
/* This directory inode links to this inode via this dentry */
- increment_link(entryblock, ip->i_di.di_num.no_addr,
- _("valid reference"));
+ incr_link_count(entryblock, ip->i_di.di_num.no_addr,
+ _("valid reference"));
(*count)++;
ds->entry_count++;
/* End of checks */
@@ -600,9 +600,9 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
if (cur_blks != sysinode->i_di.di_blocks)
reprocess_inode(sysinode, dirname);
/* This system inode is linked to itself via '.' */
- increment_link(sysinode->i_di.di_num.no_addr,
- sysinode->i_di.di_num.no_addr,
- "sysinode \".\"");
+ incr_link_count(sysinode->i_di.di_num.no_addr,
+ sysinode->i_di.di_num.no_addr,
+ "sysinode \".\"");
ds.entry_count++;
free(filename);
} else
@@ -811,9 +811,9 @@ int pass2(struct gfs2_sbd *sdp)
reprocess_inode(ip, dirname);
}
/* directory links to itself via '.' */
- increment_link(ip->i_di.di_num.no_addr,
- ip->i_di.di_num.no_addr,
- _("\". (itself)\""));
+ incr_link_count(ip->i_di.di_num.no_addr,
+ ip->i_di.di_num.no_addr,
+ _("\". (itself)\""));
ds.entry_count++;
free(filename);
log_err( _("The directory was fixed.\n"));
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index b82e7b8..4440b98 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -63,7 +63,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
if (gfs2_dirent_del(ip, filename, filename_len))
log_warn( _("Unable to remove \"..\" directory entry.\n"));
else
- decrement_link(olddotdot, block, _("old \"..\""));
+ decr_link_count(olddotdot, block, _("old \"..\""));
cur_blks = ip->i_di.di_blocks;
dir_add(ip, filename, filename_len, &pip->i_di.di_num, DT_DIR);
if (cur_blks != ip->i_di.di_blocks) {
@@ -74,7 +74,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
(unsigned long long)ip->i_di.di_num.no_addr);
reprocess_inode(ip, dirname);
}
- increment_link(newdotdot, block, _("new \"..\""));
+ incr_link_count(newdotdot, block, _("new \"..\""));
fsck_inode_put(&ip);
fsck_inode_put(&pip);
free(filename);
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index e061f0b..573a90a 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -153,11 +153,11 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
log_err( _("Unlinked inode left unlinked\n"));
fsck_inode_put(&ip);
} /* if (ii->counted_links == 0) */
- else if (ii->link_count != ii->counted_links) {
+ else if (ii->di_nlink != ii->counted_links) {
log_err( _("Link count inconsistent for inode %llu"
" (0x%llx) has %u but fsck found %u.\n"),
(unsigned long long)ii->inode,
- (unsigned long long)ii->inode, ii->link_count,
+ (unsigned long long)ii->inode, ii->di_nlink,
ii->counted_links);
/* Read in the inode, adjust the link count,
* and write it back out */
@@ -167,19 +167,21 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
(unsigned long long)ii->inode)) {
ip = fsck_load_inode(sdp, ii->inode); /* bread, inode_get */
fix_link_count(ii, ip);
- ii->link_count = ii->counted_links;
+ ii->di_nlink = ii->counted_links;
fsck_inode_put(&ip); /* out, brelse, free */
log_warn( _("Link count updated to %d for "
- "inode %" PRIu64 " (0x%"
- PRIx64 ") \n"), ii->link_count,
- ii->inode, ii->inode);
+ "inode %llu (0x%llx)\n"),
+ ii->di_nlink,
+ (unsigned long long)ii->inode,
+ (unsigned long long)ii->inode);
} else {
log_err( _("Link count for inode %" PRIu64 " (0x%" PRIx64
") still incorrect\n"), ii->inode, ii->inode);
}
}
- log_debug( _("block %" PRIu64 " (0x%" PRIx64 ") has link count %d\n"),
- ii->inode, ii->inode, ii->link_count);
+ log_debug( _("block %llu (0x%llx) has link count %d\n"),
+ (unsigned long long)ii->inode,
+ (unsigned long long)ii->inode, ii->di_nlink);
} /* osi_list_foreach(tmp, list) */
if (lf_addition) {
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: fsck.gfs2: Delete vestigial buffer_head in check_leaf
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=9531018a565...
Commit: 9531018a56554c83f557fab33563d92a7266d954
Parent: 508a5bc17b882ef71c176156f3b2321bef7cca0f
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 13:28:08 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:25 2013 -0700
fsck.gfs2: fsck.gfs2: Delete vestigial buffer_head in check_leaf
This patch eliminates a variable bh from all the check_leaf metawalk
functions because it is no longer referenced.
rhbz#877150
---
gfs2/fsck/metawalk.c | 10 ++++------
gfs2/fsck/metawalk.h | 5 ++---
gfs2/fsck/pass1.c | 14 ++++++--------
3 files changed, 12 insertions(+), 17 deletions(-)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 7e1f1ef..5b2eb6a 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -701,7 +701,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
}
gfs2_leaf_in(&leaf, lbh);
if (pass->check_leaf)
- error = pass->check_leaf(ip, leaf_no, lbh,
+ error = pass->check_leaf(ip, leaf_no,
pass->private);
/*
@@ -1475,10 +1475,9 @@ int delete_metadata(struct gfs2_inode *ip, uint64_t block,
return delete_block_if_notdup(ip, block, bh, _("metadata"), private);
}
-int delete_leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private)
+int delete_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
{
- return delete_block_if_notdup(ip, block, &bh, _("leaf"), private);
+ return delete_block_if_notdup(ip, block, NULL, _("leaf"), private);
}
int delete_data(struct gfs2_inode *ip, uint64_t block, void *private)
@@ -1541,8 +1540,7 @@ static int alloc_data(struct gfs2_inode *ip, uint64_t block, void *private)
return 0;
}
-static int alloc_leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private)
+static int alloc_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
{
uint8_t q;
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index 701add2..16a6b24 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -32,8 +32,7 @@ extern int delete_block(struct gfs2_inode *ip, uint64_t block,
void *private);
extern int delete_metadata(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h, void *private);
-extern int delete_leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, 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 block, void *private);
extern int delete_eattr_indir(struct gfs2_inode *ip, uint64_t block, uint64_t parent,
struct gfs2_buffer_head **bh, void *private);
@@ -72,7 +71,7 @@ extern struct gfs2_inode *fsck_system_inode(struct gfs2_sbd *sdp,
struct metawalk_fxns {
void *private;
int (*check_leaf) (struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private);
+ void *private);
int (*check_metalist) (struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
void *private);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 2c8fbcf..0de9c90 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -47,8 +47,7 @@ struct block_count {
uint64_t ea_count;
};
-static int leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private);
+static int 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);
static int undo_check_metalist(struct gfs2_inode *ip, uint64_t block,
@@ -79,7 +78,7 @@ static int invalidate_metadata(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, int h,
void *private);
static int invalidate_leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private);
+ void *private);
static int invalidate_data(struct gfs2_inode *ip, uint64_t block,
void *private);
static int invalidate_eattr_indir(struct gfs2_inode *ip, uint64_t block,
@@ -212,8 +211,7 @@ struct metawalk_fxns sysdir_fxns = {
.check_dentry = resuscitate_dentry,
};
-static int leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private)
+static int leaf(struct gfs2_inode *ip, uint64_t block, void *private)
{
struct block_count *bc = (struct block_count *) private;
@@ -868,7 +866,7 @@ static int invalidate_metadata(struct gfs2_inode *ip, uint64_t block,
}
static int invalidate_leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private)
+ void *private)
{
return mark_block_invalid(ip, block, ref_as_meta, _("leaf"));
}
@@ -951,9 +949,9 @@ static int rangecheck_metadata(struct gfs2_inode *ip, uint64_t block,
}
static int rangecheck_leaf(struct gfs2_inode *ip, uint64_t block,
- struct gfs2_buffer_head *bh, void *private)
+ void *private)
{
- return rangecheck_block(ip, block, &bh, _("leaf"), private);
+ return rangecheck_block(ip, block, NULL, _("leaf"), private);
}
static int rangecheck_data(struct gfs2_inode *ip, uint64_t block,
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: Rename check_leaf to check_ealeaf_block
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=508a5bc17b8...
Commit: 508a5bc17b882ef71c176156f3b2321bef7cca0f
Parent: 8da629d86e1c2d717b483c02f42016c8b49a2851
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 12:58:04 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:18 2013 -0700
fsck.gfs2: Rename check_leaf to check_ealeaf_block
This patch renames function check_leaf_block to check_ealeaf_block to
avoid confusion between directory leaf block handling and extended
attribute leaf block handling.
rhbz#877150
---
gfs2/fsck/pass1.c | 11 +++++++----
1 files changed, 7 insertions(+), 4 deletions(-)
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 7fcbbc5..2c8fbcf 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -648,8 +648,11 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,
return 1;
}
-static int check_leaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
- struct gfs2_buffer_head **bh, void *private)
+/* check_ealeaf_block
+ * checks an extended attribute (not directory) leaf block
+ */
+static int check_ealeaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
+ struct gfs2_buffer_head **bh, void *private)
{
struct gfs2_buffer_head *leaf_bh = NULL;
struct gfs2_sbd *sdp = ip->i_sbd;
@@ -740,7 +743,7 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr,
gfs2_bad_block);
return 1;
}
- error = check_leaf_block(ip, el_blk, GFS2_METATYPE_ED, &bh, private);
+ error = check_ealeaf_block(ip, el_blk, GFS2_METATYPE_ED, &bh, private);
if (bh)
brelse(bh);
return error;
@@ -781,7 +784,7 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
"Attribute leaf"), gfs2_bad_block);
return 1;
}
- return check_leaf_block(ip, block, GFS2_METATYPE_EA, bh, private);
+ return check_ealeaf_block(ip, block, GFS2_METATYPE_EA, bh, private);
}
static int check_eattr_entries(struct gfs2_inode *ip,
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: Check for blocks wrongly inside resource groups
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=8da629d86e1...
Commit: 8da629d86e1c2d717b483c02f42016c8b49a2851
Parent: 1ec5531b0f813366ffc35c9c54981cbc3c2876af
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 12:46:29 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:18 2013 -0700
fsck.gfs2: Check for blocks wrongly inside resource groups
It's not enough to range_check blocks in order to call them valid.
We also need to check whether those block collide with resource groups.
We don't want a bitmap block to ever be referenced unless it's part of
the rgrp and rindex functions. This patch changes most of the fsck code
from doing simple block range checks to doing range checks plus checks
for blocks inside the resource groups.
rhbz#877150
---
gfs2/fsck/lost_n_found.c | 2 +-
gfs2/fsck/metawalk.c | 20 +++++++-------
gfs2/fsck/pass1.c | 66 +++++++++++++++++++++++----------------------
gfs2/fsck/pass1b.c | 2 +-
gfs2/fsck/pass1c.c | 10 +++---
gfs2/fsck/pass2.c | 4 +-
gfs2/fsck/rgrepair.c | 2 +-
gfs2/fsck/util.c | 2 +-
gfs2/libgfs2/fs_bits.c | 19 ++++++++++++-
gfs2/libgfs2/libgfs2.h | 7 +++--
10 files changed, 77 insertions(+), 57 deletions(-)
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index 872b4e2..41e9783 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -108,7 +108,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
/* If there's a pre-existing .. directory entry, we have to
back out the links. */
di = dirtree_find(ip->i_di.di_num.no_addr);
- if (di && gfs2_check_range(sdp, di->dotdot_parent) == 0) {
+ if (di && !valid_block(sdp, di->dotdot_parent) == 0) {
struct gfs2_inode *dip;
log_debug(_("Directory %lld (0x%llx) already had a "
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index a098d3b..7e1f1ef 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -470,7 +470,7 @@ static void warn_and_patch(struct gfs2_inode *ip, uint64_t *leaf_no,
}
if (*leaf_no == *bad_leaf ||
query( _("Attempt to patch around it? (y/n) "))) {
- if (gfs2_check_range(ip->i_sbd, old_leaf) == 0)
+ if (!valid_block(ip->i_sbd, old_leaf) == 0)
gfs2_put_leaf_nr(ip, pindex, old_leaf);
else
gfs2_put_leaf_nr(ip, pindex, first_ok_leaf);
@@ -620,7 +620,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
first_ok_leaf = leaf_no = -1;
for(lindex = 0; lindex < (1 << ip->i_di.di_depth); lindex++) {
gfs2_get_leaf_nr(ip, lindex, &leaf_no);
- if (gfs2_check_range(ip->i_sbd, leaf_no) == 0) {
+ if (!valid_block(ip->i_sbd, leaf_no) == 0) {
lbh = bread(sdp, leaf_no);
/* Make sure it's really a valid leaf block. */
if (gfs2_check_meta(lbh, GFS2_METATYPE_LF) == 0) {
@@ -659,7 +659,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
}
do {
- if (gfs2_check_range(ip->i_sbd, old_leaf) == 0) {
+ if (!valid_block(ip->i_sbd, old_leaf) == 0) {
error = check_num_ptrs(ip, old_leaf,
&ref_count, &exp_count,
&lindex, &oldleaf);
@@ -671,7 +671,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (fsck_abort)
break;
/* Make sure the block number is in range. */
- if (gfs2_check_range(ip->i_sbd, leaf_no)){
+ if (!valid_block(ip->i_sbd, leaf_no)){
log_err( _("Leaf block #%llu (0x%llx) is out "
"of range for directory #%llu (0x%llx"
").\n"), (unsigned long long)leaf_no,
@@ -923,7 +923,7 @@ int delete_block(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, const char *btype,
void *private)
{
- if (gfs2_check_range(ip->i_sbd, block) == 0) {
+ if (!valid_block(ip->i_sbd, block) == 0) {
fsck_blockmap_set(ip, block, btype, gfs2_block_free);
return 0;
}
@@ -944,7 +944,7 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
uint8_t q;
struct duptree *d;
- if (gfs2_check_range(ip->i_sbd, block) != 0)
+ if (!valid_block(ip->i_sbd, block) != 0)
return -EFAULT;
q = block_type(block);
@@ -1203,7 +1203,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
block, block);
continue;
}
- if (gfs2_check_range(ip->i_sbd, block)) {
+ if (!valid_block(ip->i_sbd, block)) {
log_debug( _("Skipping invalid block "
"%lld (0x%llx)\n"),
(unsigned long long)block,
@@ -1250,7 +1250,7 @@ static int check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
if (skip_this_pass || fsck_abort)
return error;
block = be64_to_cpu(*ptr);
- /* It's important that we don't call gfs2_check_range and
+ /* It's important that we don't call !valid_block and
bypass calling check_data on invalid blocks because that
would defeat the rangecheck_block related functions in
pass1. Therefore the individual check_data functions
@@ -1450,8 +1450,8 @@ int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,
" (0x%llx)\n"), (unsigned long long)dentryblock,
(unsigned long long)dentryblock,
(unsigned long long)dir, (unsigned long long)dir);
- if (gfs2_check_range(sdp, dir)) {
- log_err( _("Parent directory out of range\n"));
+ if (!valid_block(sdp, dir)) {
+ log_err( _("Parent directory is invalid\n"));
return 1;
}
remove_dentry_fxns.private = &dentryblock;
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index b6208e5..7fcbbc5 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -134,11 +134,11 @@ static int resuscitate_metalist(struct gfs2_inode *ip, uint64_t block,
struct block_count *bc = (struct block_count *)private;
*bh = NULL;
- if (gfs2_check_range(ip->i_sbd, block)){ /* blk outside of FS */
+ if (!valid_block(ip->i_sbd, block)){ /* blk outside of FS */
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
_("itself"), gfs2_bad_block);
- log_err( _("Bad indirect block pointer (out of range) "
- "found in system inode %lld (0x%llx).\n"),
+ log_err( _("Bad indirect block pointer (invalid or out of "
+ "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 1;
@@ -178,10 +178,10 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
strncpy(tmp_name, filename, de->de_name_len);
else
strncpy(tmp_name, filename, sizeof(tmp_name) - 1);
- if (gfs2_check_range(sdp, block)) {
+ if (!valid_block(sdp, block)) {
log_err( _("Block # referenced by system directory entry %s "
- "in inode %lld (0x%llx) is out of range; "
- "ignored.\n"),
+ "in inode %lld (0x%llx) is invalid or out of range;"
+ " ignored.\n"),
tmp_name, (unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
return 0;
@@ -233,10 +233,10 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
*bh = NULL;
- if (gfs2_check_range(ip->i_sbd, block)){ /* blk outside of FS */
+ if (!valid_block(ip->i_sbd, block)){ /* blk outside of FS */
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
_("itself"), gfs2_bad_block);
- log_debug( _("Bad indirect block pointer (out of range) "
+ log_debug( _("Bad indirect block (invalid/out of range) "
"found in 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);
@@ -307,7 +307,7 @@ static int undo_check_metalist(struct gfs2_inode *ip, uint64_t block,
*bh = NULL;
- if (gfs2_check_range(ip->i_sbd, block)){ /* blk outside of FS */
+ if (!valid_block(ip->i_sbd, block)){ /* blk outside of FS */
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
_("itself"), gfs2_block_free);
return 1;
@@ -362,9 +362,9 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
uint8_t q;
struct block_count *bc = (struct block_count *) private;
- if (gfs2_check_range(ip->i_sbd, block)) {
+ if (!valid_block(ip->i_sbd, block)) {
log_err( _("inode %lld (0x%llx) has a bad data block pointer "
- "%lld (out of range)\n"),
+ "%lld (invalid or out of range)\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);
@@ -413,12 +413,12 @@ static int undo_check_data(struct gfs2_inode *ip, uint64_t block,
struct duptree *d;
struct block_count *bc = (struct block_count *) private;
- if (gfs2_check_range(ip->i_sbd, block)) {
+ if (!valid_block(ip->i_sbd, block)) {
/* Mark the owner of this block with the bad_block
* designator so we know to check it for out of range
* blocks later */
fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("bad (out of range) data"),
+ _("bad (invalid or out of range) data"),
gfs2_block_free);
return 1;
}
@@ -559,7 +559,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
/* This inode contains an eattr - it may be invalid, but the
* eattr attributes points to a non-zero block */
- if (gfs2_check_range(sdp, indirect)) {
+ if (!valid_block(sdp, indirect)) {
/* Doesn't help to mark this here - this gets checked
* in pass1c */
return 1;
@@ -725,10 +725,10 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr,
struct gfs2_buffer_head *bh = NULL;
int error;
- if (gfs2_check_range(sdp, el_blk)){
+ if (!valid_block(sdp, el_blk)){
log_err( _("Inode #%llu (0x%llx): Extended Attribute block "
"%llu (0x%llx) has an extended leaf block #%llu "
- "(0x%llx) that is out of range.\n"),
+ "(0x%llx) that is invalid or out of range.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_eattr,
@@ -769,9 +769,10 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
}
if (!b || b->block != ip->i_di.di_num.no_addr)
gfs2_special_add(&sdp->eattr_blocks, ip->i_di.di_num.no_addr);
- if (gfs2_check_range(sdp, block)) {
+ if (!valid_block(sdp, block)) {
log_warn( _("Inode #%llu (0x%llx): Extended Attribute leaf "
- "block #%llu (0x%llx) is out of range.\n"),
+ "block #%llu (0x%llx) is invalid or out of "
+ "range.\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);
@@ -837,15 +838,15 @@ static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
{
uint8_t q;
- if (gfs2_check_range(ip->i_sbd, block) != 0)
+ if (!valid_block(ip->i_sbd, block) != 0)
return -EFAULT;
q = block_type(block);
if (q != gfs2_block_free) {
add_duplicate_ref(ip, block, reftype, 0, INODE_INVALID);
log_info( _("%s block %lld (0x%llx), part of inode "
- "%lld (0x%llx), was free so the invalid "
- "reference is ignored.\n"),
+ "%lld (0x%llx), was previously referenced so "
+ "the invalid reference is ignored.\n"),
btype, (unsigned long long)block,
(unsigned long long)block,
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -909,13 +910,13 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
long *bad_pointers = (long *)private;
uint8_t q;
- if (gfs2_check_range(ip->i_sbd, block) != 0) {
+ if (!valid_block(ip->i_sbd, block) != 0) {
(*bad_pointers)++;
- log_debug( _("Bad %s block pointer (out of range #%ld) "
- "found in inode %lld (0x%llx).\n"), btype,
- *bad_pointers,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info( _("Bad %s block pointer (invalid or out of range "
+ "#%ld) found in inode %lld (0x%llx).\n"),
+ btype, *bad_pointers,
+ (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 ENOENT;
else
@@ -925,11 +926,12 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
q = block_type(block);
if (q != gfs2_block_free) {
(*bad_pointers)++;
- log_debug( _("Duplicated %s block pointer (violation #%ld) "
- "found in inode %lld (0x%llx).\n"), btype,
- *bad_pointers,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info( _("Duplicated %s block pointer (violation %ld, block"
+ " %lld (0x%llx)) found in inode %lld (0x%llx).\n"),
+ btype, *bad_pointers,
+ (unsigned long long)block, (unsigned long long)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 ENOENT;
else
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index 24b7a94..64b6ed4 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -219,7 +219,7 @@ static int clear_dup_metalist(struct gfs2_inode *ip, uint64_t block,
struct dup_handler *dh = (struct dup_handler *) private;
struct duptree *d;
- if (gfs2_check_range(ip->i_sbd, block) != 0)
+ if (!valid_block(ip->i_sbd, block) != 0)
return 0;
/* This gets tricky. We're traversing a metadata tree trying to
diff --git a/gfs2/fsck/pass1c.c b/gfs2/fsck/pass1c.c
index 8854787..f362e35 100644
--- a/gfs2/fsck/pass1c.c
+++ b/gfs2/fsck/pass1c.c
@@ -88,10 +88,10 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
uint8_t q;
struct gfs2_buffer_head *indir_bh = NULL;
- if (gfs2_check_range(sdp, block)) {
+ if (!valid_block(sdp, block)) {
log_err( _("Extended attributes indirect block #%llu"
" (0x%llx) for inode #%llu"
- " (0x%llx) out of range...removing\n"),
+ " (0x%llx) is invalid...removing\n"),
(unsigned long long)block,
(unsigned long long)block,
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -102,7 +102,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
if (q != gfs2_indir_blk) {
log_err( _("Extended attributes indirect block #%llu"
" (0x%llx) for inode #%llu"
- " (0x%llx) invalid.\n"),
+ " (0x%llx) is invalid.\n"),
(unsigned long long)block,
(unsigned long long)block,
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -123,9 +123,9 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
struct gfs2_sbd *sdp = ip->i_sbd;
uint8_t q;
- if (gfs2_check_range(sdp, block)) {
+ if (!valid_block(sdp, block)) {
log_err( _("Extended attributes block for inode #%llu"
- " (0x%llx) out of range.\n"),
+ " (0x%llx) is invalid.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
return ask_remove_eattr(ip);
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index ffa3a87..2d42c14 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -210,9 +210,9 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
else
strncpy(tmp_name, filename, MAX_FILENAME - 1);
- if (gfs2_check_range(ip->i_sbd, entryblock)) {
+ if (!valid_block(ip->i_sbd, entryblock)) {
log_err( _("Block # referenced by directory entry %s in inode "
- "%lld (0x%llx) is out of range\n"),
+ "%lld (0x%llx) is invalid\n"),
tmp_name, (unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
if (query( _("Clear directory entry to out of range block? "
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 510426f..2afa4ce 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -424,7 +424,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, osi_list_t *ret_list,
osi_list_t *tmp;
struct rgrp_list *exp, *rgd; /* expected, actual */
- *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex);
+ *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex) ;
osi_list_init(ret_list);
for (tmp = sdp->rglist.next; tmp != &sdp->rglist; tmp = tmp->next) {
rgd = osi_list_entry(tmp, struct rgrp_list, list);
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index b3fafe5..5c5f1aa 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -215,7 +215,7 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
struct inode_with_dups *id, *found_id;
struct duptree *dt;
- if (gfs2_check_range(ip->i_sbd, block) != 0)
+ if (!valid_block(ip->i_sbd, block) != 0)
return 0;
/* If this is not the first reference (i.e. all calls from pass1) we
need to create the duplicate reference. If this is pass1b, we want
diff --git a/gfs2/libgfs2/fs_bits.c b/gfs2/libgfs2/fs_bits.c
index 5b55cec..11b6fb2 100644
--- a/gfs2/libgfs2/fs_bits.c
+++ b/gfs2/libgfs2/fs_bits.c
@@ -156,7 +156,24 @@ int gfs2_check_range(struct gfs2_sbd *sdp, uint64_t blkno)
}
/*
- * fs_set_bitmap
+ * valid_block - check if blkno is valid and not part of our rgrps or bitmaps
+ * @sdp: super block
+ * @blkno: block number
+ *
+ * Returns: 1 if ok, 0 if out of bounds
+ */
+int valid_block(struct gfs2_sbd *sdp, uint64_t blkno)
+{
+ if((blkno > sdp->fssize) || (blkno <= sdp->sb_addr))
+ return 0;
+ /* Check if the block is one of our rgrp or bitmap blocks */
+ if (gfs2_get_bitmap(sdp, blkno, NULL) < 0)
+ return 0;
+ return 1;
+}
+
+/*
+ * gfs2_set_bitmap
* @sdp: super block
* @blkno: block number relative to file system
* @state: one of three possible states
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 2231399..2869268 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -395,9 +395,10 @@ uint32_t gfs2_blkalloc_internal(struct rgrp_list *rgd, uint32_t goal,
int gfs2_check_range(struct gfs2_sbd *sdp, uint64_t blkno);
/* functions with blk #'s that are file system relative */
-int gfs2_get_bitmap(struct gfs2_sbd *sdp, uint64_t blkno,
- struct rgrp_list *rgd);
-int gfs2_set_bitmap(struct gfs2_sbd *sdp, uint64_t blkno, int state);
+extern int valid_block(struct gfs2_sbd *sdp, uint64_t blkno);
+extern int gfs2_get_bitmap(struct gfs2_sbd *sdp, uint64_t blkno,
+ struct rgrp_list *rgd);
+extern int gfs2_set_bitmap(struct gfs2_sbd *sdp, uint64_t blkno, int state);
/* fs_geometry.c */
void rgblocks2bitblocks(unsigned int bsize, uint32_t *rgblocks,
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: Change "if(" to "if ("
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=1ec5531b0f8...
Commit: 1ec5531b0f813366ffc35c9c54981cbc3c2876af
Parent: f74b7d20ecdac9f6c709a98674dfcfdaa511aef2
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 09:04:13 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:18 2013 -0700
fsck.gfs2: Change "if(" to "if ("
This patch changes all if and while statements to have a space before
the parenthesis so they are consistent.
rhbz#877150
---
gfs2/fsck/eattr.c | 8 +-
gfs2/fsck/fs_recovery.c | 6 +-
gfs2/fsck/initialize.c | 35 ++++++------
gfs2/fsck/link.c | 2 +-
gfs2/fsck/lost_n_found.c | 10 ++--
gfs2/fsck/main.c | 16 +++---
gfs2/fsck/metawalk.c | 78 +++++++++++++------------
gfs2/fsck/pass1.c | 60 ++++++++++----------
gfs2/fsck/pass1b.c | 22 ++++----
gfs2/fsck/pass1c.c | 32 +++++-----
gfs2/fsck/pass2.c | 141 ++++++++++++++++++++++++----------------------
gfs2/fsck/pass3.c | 74 +++++++++++++-----------
gfs2/fsck/pass4.c | 51 +++++++++--------
gfs2/fsck/pass5.c | 20 +++---
gfs2/fsck/util.c | 10 ++--
15 files changed, 292 insertions(+), 273 deletions(-)
diff --git a/gfs2/fsck/eattr.c b/gfs2/fsck/eattr.c
index c0de8b6..1023f09 100644
--- a/gfs2/fsck/eattr.c
+++ b/gfs2/fsck/eattr.c
@@ -28,25 +28,25 @@ int clear_eattr_entry (struct gfs2_inode *ip,
{
struct gfs2_sbd *sdp = ip->i_sbd;
- if(!ea_hdr->ea_name_len){
+ if (!ea_hdr->ea_name_len){
/* Skip this entry for now */
return 1;
}
- if(!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
+ 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){
+ 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) {
+ if (max_ptrs > ea_hdr->ea_num_ptrs) {
return 1;
} else {
log_debug( _(" Pointers Required: %d\n"
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 3498739..8a4ff13 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -422,7 +422,7 @@ int preen_is_safe(struct gfs2_sbd *sdp, int preen, int force_check)
return 1; /* not called by rc.sysinit--we're okay to preen */
if (force_check) /* If check was forced by the user? */
return 1; /* user's responsibility--we're okay to preen */
- if(!memcmp(sdp->sd_sb.sb_lockproto + 5, "nolock", 6))
+ if (!memcmp(sdp->sd_sb.sb_lockproto + 5, "nolock", 6))
return 1; /* local file system--preen is okay */
return 0; /* might be mounted on another node--not guaranteed safe */
}
@@ -643,7 +643,7 @@ int ji_update(struct gfs2_sbd *sdp)
char journal_name[JOURNAL_NAME_SIZE];
int i;
- if(!ip) {
+ if (!ip) {
log_crit("Journal index inode not found.\n");
return -1;
}
@@ -657,7 +657,7 @@ int ji_update(struct gfs2_sbd *sdp)
else
sdp->md.journals = ip->i_di.di_entries - 2;
- if(!(sdp->md.journal = calloc(sdp->md.journals,
+ if (!(sdp->md.journal = calloc(sdp->md.journals,
sizeof(struct gfs2_inode *)))) {
log_err("Unable to allocate journal index\n");
return -1;
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 57f0d92..ee33988 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -34,7 +34,7 @@
#include "inode_hash.h"
#define CLEAR_POINTER(x) \
- if(x) { \
+ if (x) { \
free(x); \
x = NULL; \
}
@@ -52,9 +52,9 @@ static struct master_dir fix_md;
*/
static int block_mounters(struct gfs2_sbd *sdp, int block_em)
{
- if(block_em) {
+ if (block_em) {
/* verify it starts with lock_ */
- if(!strncmp(sdp->sd_sb.sb_lockproto, "lock_", 5)) {
+ if (!strncmp(sdp->sd_sb.sb_lockproto, "lock_", 5)) {
/* Change lock_ to fsck_ */
memcpy(sdp->sd_sb.sb_lockproto, "fsck_", 5);
}
@@ -63,13 +63,13 @@ static int block_mounters(struct gfs2_sbd *sdp, int block_em)
} else {
/* verify it starts with fsck_ */
/* verify it starts with lock_ */
- if(!strncmp(sdp->sd_sb.sb_lockproto, "fsck_", 5)) {
+ if (!strncmp(sdp->sd_sb.sb_lockproto, "fsck_", 5)) {
/* Change fsck_ to lock_ */
memcpy(sdp->sd_sb.sb_lockproto, "lock_", 5);
}
}
- if(write_sb(sdp)) {
+ if (write_sb(sdp)) {
stack;
return -1;
}
@@ -175,9 +175,10 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
last_data_block = rmax;
first_data_block = rmin;
- if(fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_sb.sb_bsize))){
- log_crit( _("Can't seek to last block in file system: %"
- PRIu64" (0x%" PRIx64 ")\n"), last_fs_block, last_fs_block);
+ if (fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_sb.sb_bsize))){
+ log_crit( _("Can't seek to last block in file system: %llu"
+ " (0x%llx)\n"), (unsigned long long)last_fs_block,
+ (unsigned long long)last_fs_block);
goto fail;
}
@@ -568,7 +569,7 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
/*******************************************************************
******* Now, set boundary fields in the super block *************
*******************************************************************/
- if(set_block_ranges(sdp)){
+ if (set_block_ranges(sdp)){
log_err( _("Unable to determine the boundaries of the"
" file system.\n"));
goto fail;
@@ -1061,7 +1062,7 @@ static int fill_super_block(struct gfs2_sbd *sdp)
sdp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
sdp->bsize = sdp->sd_sb.sb_bsize;
- if(sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize){
+ if (sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize){
log_crit( _("GFS superblock is larger than the blocksize!\n"));
log_debug( _("sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize\n"));
return -1;
@@ -1095,7 +1096,7 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
*all_clean = 0;
- if(opts.no)
+ if (opts.no)
open_flag = O_RDONLY;
else
open_flag = O_RDWR | O_EXCL;
@@ -1143,8 +1144,8 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
return FSCK_ERROR;
/* Change lock protocol to be fsck_* instead of lock_* */
- if(!opts.no && preen_is_safe(sdp, preen, force_check)) {
- if(block_mounters(sdp, 1)) {
+ if (!opts.no && preen_is_safe(sdp, preen, force_check)) {
+ if (block_mounters(sdp, 1)) {
log_err( _("Unable to block other mounters\n"));
return FSCK_USAGE;
}
@@ -1168,8 +1169,8 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
/* verify various things */
- if(replay_journals(sdp, preen, force_check, &clean_journals)) {
- if(!opts.no && preen_is_safe(sdp, preen, force_check))
+ if (replay_journals(sdp, preen, force_check, &clean_journals)) {
+ if (!opts.no && preen_is_safe(sdp, preen, force_check))
block_mounters(sdp, 0);
stack;
return FSCK_ERROR;
@@ -1196,8 +1197,8 @@ mount_fail:
static void destroy_sdp(struct gfs2_sbd *sdp)
{
- if(!opts.no) {
- if(block_mounters(sdp, 0)) {
+ if (!opts.no) {
+ if (block_mounters(sdp, 0)) {
log_warn( _("Unable to unblock other mounters - manual intervention required\n"));
log_warn( _("Use 'gfs2_tool sb <device> proto' to fix\n"));
}
diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c
index 0503f42..4c416bd 100644
--- a/gfs2/fsck/link.c
+++ b/gfs2/fsck/link.c
@@ -80,7 +80,7 @@ int decrement_link(uint64_t inode_no, uint64_t referenced_from,
ii = inodetree_find(inode_no);
/* If the list has entries, look for one that matches
* inode_no */
- if(ii) {
+ if (ii) {
if (!ii->counted_links) {
log_debug( _("Directory %lld (0x%llx)'s link to "
" %"PRIu64" (0x%" PRIx64 ") via %s is zero!\n"),
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index b89b25a..872b4e2 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -44,7 +44,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
struct gfs2_sbd *sdp = ip->i_sbd;
struct dir_info *di;
- if(!lf_dip) {
+ if (!lf_dip) {
uint8_t q;
log_info( _("Locating/Creating lost+found directory\n"));
@@ -59,7 +59,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
sdp->md.rooti->i_di.di_nlink);
q = block_type(lf_dip->i_di.di_num.no_addr);
- if(q != gfs2_inode_dir) {
+ if (q != gfs2_inode_dir) {
/* This is a new lost+found directory, so set its
* block type and increment link counts for
* the directories */
@@ -92,7 +92,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
di = NULL;
}
}
- if(ip->i_di.di_num.no_addr == lf_dip->i_di.di_num.no_addr) {
+ if (ip->i_di.di_num.no_addr == lf_dip->i_di.di_num.no_addr) {
log_err( _("Trying to add lost+found to itself...skipping"));
return 0;
}
@@ -142,7 +142,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
"for orphan directory %lld (0x%llx)\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(gfs2_dirent_del(ip, "..", 2))
+ if (gfs2_dirent_del(ip, "..", 2))
log_warn( _("add_inode_to_lf: Unable to remove "
"\"..\" directory entry.\n"));
@@ -192,7 +192,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
increment_link(ip->i_di.di_num.no_addr, lf_dip->i_di.di_num.no_addr,
_("from lost+found"));
/* If it's a directory, lost+found is back-linked to it via .. */
- if(S_ISDIR(ip->i_di.di_mode))
+ if (S_ISDIR(ip->i_di.di_mode))
increment_link(lf_dip->i_di.di_num.no_addr,
ip->i_di.di_mode, _("to lost+found"));
diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c
index b955c98..62852af 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -74,7 +74,7 @@ static int read_cmdline(int argc, char **argv, struct gfs2_options *gopts)
{
int c;
- while((c = getopt(argc, argv, "afhnpqvyV")) != -1) {
+ while ((c = getopt(argc, argv, "afhnpqvyV")) != -1) {
switch(c) {
case 'a':
@@ -119,10 +119,10 @@ static int read_cmdline(int argc, char **argv, struct gfs2_options *gopts)
}
}
- if(argc > optind) {
+ if (argc > optind) {
gopts->device = (argv[optind]);
- if(!gopts->device) {
- fprintf(stderr, _("Please use '-h' for usage.\n"));
+ if (!gopts->device) {
+ fprintf(stderr, _("Please use '-h' for help.\n"));
return FSCK_USAGE;
}
} else {
@@ -147,7 +147,7 @@ static void interrupt(int sig)
_("Do you want to abort gfs2_fsck, skip " \
"the rest of this pass or continue " \
"(a/s/c)?"), "asc");
- if(tolower(response) == 's') {
+ if (tolower(response) == 's') {
skip_this_pass = TRUE;
return;
}
@@ -239,7 +239,7 @@ int main(int argc, char **argv)
memset(sdp, 0, sizeof(*sdp));
- if((error = read_cmdline(argc, argv, &opts)))
+ if ((error = read_cmdline(argc, argv, &opts)))
exit(error);
setbuf(stdout, NULL);
log_notice( _("Initializing fsck\n"));
@@ -269,7 +269,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 1b";
log_notice( _("Starting pass1b\n"));
- if((error = pass1b(sdp)))
+ if ((error = pass1b(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -282,7 +282,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 1c";
log_notice( _("Starting pass1c\n"));
- if((error = pass1c(sdp)))
+ if ((error = pass1c(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index d56180c..a098d3b 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -64,7 +64,7 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, uint64_t blk,
(unsigned long long)blk, (unsigned long long)blk,
allocdesc[new_bitmap_state],
allocdesc[old_bitmap_state]);
- if(query( _("Okay to fix the bitmap? (y/n)"))) {
+ if (query( _("Okay to fix the bitmap? (y/n)"))) {
/* If the new bitmap state is free (and therefore the
old state was not) we have to add to the free
space in the rgrp. If the old bitmap state was
@@ -326,7 +326,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
bh_end = bh->b_data + ip->i_sbd->bsize;
- if(type == DIR_LINEAR) {
+ if (type == DIR_LINEAR) {
dent = (struct gfs2_dirent *)(bh->b_data + sizeof(struct gfs2_dinode));
}
else if (type == DIR_EXHASH) {
@@ -341,10 +341,10 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
}
prev = NULL;
- if(!pass->check_dentry)
+ if (!pass->check_dentry)
return 0;
- while(1) {
+ while (1) {
if (skip_this_pass || fsck_abort)
return FSCK_OK;
memset(&de, 0, sizeof(struct gfs2_dirent));
@@ -387,7 +387,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
}
}
if (!de.de_inum.no_formal_ino){
- if(first){
+ if (first){
log_debug( _("First dirent is a sentinel (place holder).\n"));
first = 0;
} else {
@@ -424,7 +424,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
error = pass->check_dentry(ip, dent, prev, bh,
filename, count,
pass->private);
- if(error < 0) {
+ if (error < 0) {
stack;
return -1;
}
@@ -443,7 +443,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
/* If we didn't clear the dentry, or if we did, but it
* was the first dentry, set prev */
- if(!error || first)
+ if (!error || first)
prev = dent;
first = 0;
dent = (struct gfs2_dirent *)((char *)dent + de.de_rec_len);
@@ -653,7 +653,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
leaf info */
ref_count++;
continue;
- } else if(old_leaf == leaf_no) {
+ } else if (old_leaf == leaf_no) {
ref_count++;
continue;
}
@@ -671,7 +671,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (fsck_abort)
break;
/* Make sure the block number is in range. */
- if(gfs2_check_range(ip->i_sbd, leaf_no)){
+ if (gfs2_check_range(ip->i_sbd, leaf_no)){
log_err( _("Leaf block #%llu (0x%llx) is out "
"of range for directory #%llu (0x%llx"
").\n"), (unsigned long long)leaf_no,
@@ -700,7 +700,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
break;
}
gfs2_leaf_in(&leaf, lbh);
- if(pass->check_leaf)
+ if (pass->check_leaf)
error = pass->check_leaf(ip, leaf_no, lbh,
pass->private);
@@ -740,13 +740,17 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (pass->check_dentry && S_ISDIR(ip->i_di.di_mode)) {
error = check_entries(ip, lbh, DIR_EXHASH,
&count, pass);
- if(error < 0) {
+
+ if (skip_this_pass || fsck_abort)
+ return 0;
+
+ if (error < 0) {
stack;
brelse(lbh);
return -1;
}
- if(count != leaf.lf_entries) {
+ if (count != leaf.lf_entries) {
brelse(lbh);
lbh = bread(sdp, leaf_no);
gfs2_leaf_in(&leaf, lbh);
@@ -763,7 +767,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
(unsigned long long)
ip->i_di.di_num.no_addr,
leaf.lf_entries, count);
- if(query( _("Update leaf entry count? (y/n) "))) {
+ if (query( _("Update leaf entry count? (y/n) "))) {
leaf.lf_entries = count;
gfs2_leaf_out(&leaf, lbh);
log_warn( _("Leaf entry count updated\n"));
@@ -779,7 +783,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
leaf_no = leaf.lf_next;
log_debug( _("Leaf chain 0x%llx detected.\n"),
(unsigned long long)leaf_no);
- } while(1); /* while we have chained leaf blocks */
+ } while (1); /* while we have chained leaf blocks */
} /* for every leaf block */
return 0;
}
@@ -794,24 +798,24 @@ static int check_eattr_entries(struct gfs2_inode *ip,
int error = 0;
uint32_t offset = (uint32_t)sizeof(struct gfs2_meta_header);
- if(!pass->check_eattr_entry)
+ if (!pass->check_eattr_entry)
return 0;
ea_hdr = (struct gfs2_ea_header *)(bh->b_data +
sizeof(struct gfs2_meta_header));
- while(1){
+ while (1){
if (ea_hdr->ea_type == GFS2_EATYPE_UNUSED)
error = 0;
else
error = pass->check_eattr_entry(ip, bh, ea_hdr,
ea_hdr_prev,
pass->private);
- if(error < 0) {
+ if (error < 0) {
stack;
return -1;
}
- if(error == 0 && pass->check_eattr_extentry &&
+ if (error == 0 && pass->check_eattr_extentry &&
ea_hdr->ea_num_ptrs) {
uint32_t tot_ealen = 0;
struct gfs2_sbd *sdp = ip->i_sbd;
@@ -828,7 +832,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
** reuse........... */
for(i = 0; i < ea_hdr->ea_num_ptrs; i++){
- if(pass->check_eattr_extentry(ip,
+ if (pass->check_eattr_extentry(ip,
ea_data_ptr,
bh, ea_hdr,
ea_hdr_prev,
@@ -861,7 +865,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
}
}
offset += be32_to_cpu(ea_hdr->ea_rec_len);
- if(ea_hdr->ea_flags & GFS2_EAFLAG_LAST ||
+ if (ea_hdr->ea_flags & GFS2_EAFLAG_LAST ||
offset >= ip->i_sbd->sd_sb.sb_bsize || ea_hdr->ea_rec_len == 0){
break;
}
@@ -890,14 +894,14 @@ static int check_leaf_eattr(struct gfs2_inode *ip, uint64_t block,
log_debug( _("Checking EA leaf block #%"PRIu64" (0x%" PRIx64 ").\n"),
block, block);
- if(pass->check_eattr_leaf) {
+ if (pass->check_eattr_leaf) {
error = pass->check_eattr_leaf(ip, block, parent, &bh,
pass->private);
- if(error < 0) {
+ if (error < 0) {
stack;
return -1;
}
- if(error > 0) {
+ if (error > 0) {
if (bh)
brelse(bh);
return 1;
@@ -1002,7 +1006,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
end = ea_leaf_ptr + ((sdp->sd_sb.sb_bsize
- sizeof(struct gfs2_meta_header)) / 8);
- while(*ea_leaf_ptr && (ea_leaf_ptr < end)){
+ while (*ea_leaf_ptr && (ea_leaf_ptr < end)){
block = be64_to_cpu(*ea_leaf_ptr);
leaf_pointers++;
error = check_leaf_eattr(ip, block, indirect, pass);
@@ -1074,15 +1078,15 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass)
{
int error = 0;
- if(!ip->i_di.di_eattr)
+ if (!ip->i_di.di_eattr)
return 0;
log_debug( _("Extended attributes exist for inode #%llu (0x%llx).\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT){
- if((error = check_indirect_eattr(ip, ip->i_di.di_eattr, pass)))
+ if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT){
+ if ((error = check_indirect_eattr(ip, ip->i_di.di_eattr, pass)))
stack;
} else {
error = check_leaf_eattr(ip, ip->i_di.di_eattr,
@@ -1145,7 +1149,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
if (S_ISDIR(ip->i_di.di_mode))
height++;
- /* if(<there are no indirect blocks to check>) */
+ /* if (<there are no indirect blocks to check>) */
if (height < 2)
return 0;
for (h = 1; h < height; h++) {
@@ -1186,12 +1190,12 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
pass->private);
/* check_metalist should hold any buffers
it gets with "bread". */
- if(err < 0) {
+ if (err < 0) {
stack;
error = err;
goto fail;
}
- if(err > 0) {
+ if (err > 0) {
if (!error)
error = err;
log_debug( _("Skipping block %" PRIu64
@@ -1206,7 +1210,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
(unsigned long long)block);
continue;
}
- if(!nbh)
+ if (!nbh)
nbh = bread(ip->i_sbd, block);
osi_list_add(&nbh->b_altlist, cur_list);
} /* for all data on the indirect block */
@@ -1385,7 +1389,7 @@ int check_linear_dir(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
uint16_t count = 0;
error = check_entries(ip, bh, DIR_LINEAR, &count, pass);
- if(error < 0) {
+ if (error < 0) {
stack;
return -1;
}
@@ -1400,12 +1404,12 @@ int check_dir(struct gfs2_sbd *sdp, uint64_t block, struct metawalk_fxns *pass)
ip = fsck_load_inode(sdp, block);
- if(ip->i_di.di_flags & GFS2_DIF_EXHASH)
+ if (ip->i_di.di_flags & GFS2_DIF_EXHASH)
error = check_leaf_blks(ip, pass);
else
error = check_linear_dir(ip, ip->i_bh, pass);
- if(error < 0)
+ if (error < 0)
stack;
fsck_inode_put(&ip); /* does a brelse */
@@ -1426,7 +1430,7 @@ static int remove_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
gfs2_dirent_in(&dentry, (char *)dent);
de = &dentry;
- if(de->de_inum.no_addr == *dentryblock)
+ if (de->de_inum.no_addr == *dentryblock)
dirent2_del(ip, bh, prev_de, dent);
else
(*count)++;
@@ -1446,7 +1450,7 @@ int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,
" (0x%llx)\n"), (unsigned long long)dentryblock,
(unsigned long long)dentryblock,
(unsigned long long)dir, (unsigned long long)dir);
- if(gfs2_check_range(sdp, dir)) {
+ if (gfs2_check_range(sdp, dir)) {
log_err( _("Parent directory out of range\n"));
return 1;
}
@@ -1454,7 +1458,7 @@ int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,
remove_dentry_fxns.check_dentry = remove_dentry;
q = block_type(dir);
- if(q != gfs2_inode_dir) {
+ if (q != gfs2_inode_dir) {
log_info( _("Parent block is not a directory...ignoring\n"));
return 1;
}
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index b83aeb4..b6208e5 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -174,11 +174,11 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
block = de->de_inum.no_addr;
/* Start of checks */
memset(tmp_name, 0, sizeof(tmp_name));
- if(de->de_name_len < sizeof(tmp_name))
+ if (de->de_name_len < sizeof(tmp_name))
strncpy(tmp_name, filename, de->de_name_len);
else
strncpy(tmp_name, filename, sizeof(tmp_name) - 1);
- if(gfs2_check_range(sdp, block)) {
+ if (gfs2_check_range(sdp, block)) {
log_err( _("Block # referenced by system directory entry %s "
"in inode %lld (0x%llx) is out of range; "
"ignored.\n"),
@@ -251,7 +251,7 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
blktypedesc = _("a journaled data block");
}
q = block_type(block);
- if(q != gfs2_block_free) {
+ if (q != gfs2_block_free) {
log_err( _("Found duplicate block %llu (0x%llx) referenced "
"as metadata in indirect block for dinode "
"%llu (0x%llx) - was marked %d (%s)\n"),
@@ -273,7 +273,7 @@ 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) {
+ if (!found_dup) {
fsck_blockmap_set(ip, block, _("bad indirect"),
gfs2_meta_inval);
brelse(nbh);
@@ -334,7 +334,7 @@ static int undo_check_metalist(struct gfs2_inode *ip, uint64_t block,
nbh = bread(ip->i_sbd, block);
if (gfs2_check_meta(nbh, iblk_type)) {
- if(!found_dup) {
+ if (!found_dup) {
fsck_blockmap_set(ip, block, _("bad indirect"),
gfs2_block_free);
brelse(nbh);
@@ -559,10 +559,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
/* This inode contains an eattr - it may be invalid, but the
* eattr attributes points to a non-zero block */
- if(gfs2_check_range(sdp, indirect)) {
- /*log_warn("EA indirect block #%"PRIu64" is out of range.\n",
- indirect);
- fsck_blockmap_set(parent, "bad", bad_block);*/
+ if (gfs2_check_range(sdp, indirect)) {
/* Doesn't help to mark this here - this gets checked
* in pass1c */
return 1;
@@ -574,8 +571,8 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
handling sort it out. If it isn't, clear it but don't
count it as a duplicate. */
*bh = bread(sdp, indirect);
- if(gfs2_check_meta(*bh, GFS2_METATYPE_IN)) {
- if(q != gfs2_block_free) { /* Duplicate? */
+ if (gfs2_check_meta(*bh, GFS2_METATYPE_IN)) {
+ if (q != gfs2_block_free) { /* Duplicate? */
add_duplicate_ref(ip, indirect, ref_as_ea, 0,
INODE_VALID);
if (!clear_eas(ip, bc, indirect, 1,
@@ -589,7 +586,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
"type"));
return 1;
}
- if(q != gfs2_block_free) { /* Duplicate? */
+ if (q != gfs2_block_free) { /* Duplicate? */
log_err( _("Inode #%llu (0x%llx): Duplicate Extended "
"Attribute indirect block found at #%llu "
"(0x%llx).\n"),
@@ -664,8 +661,8 @@ static int check_leaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
really is an EA. If it is, let duplicate handling sort it out.
If it isn't, clear it but don't count it as a duplicate. */
leaf_bh = bread(sdp, block);
- if(gfs2_check_meta(leaf_bh, btype)) {
- if(q != gfs2_block_free) { /* Duplicate? */
+ if (gfs2_check_meta(leaf_bh, btype)) {
+ if (q != gfs2_block_free) { /* Duplicate? */
add_duplicate_ref(ip, block, ref_as_ea, 0,
INODE_VALID);
clear_eas(ip, bc, block, 1,
@@ -678,7 +675,7 @@ static int check_leaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
brelse(leaf_bh);
return 1;
}
- if(q != gfs2_block_free) { /* Duplicate? */
+ if (q != gfs2_block_free) { /* Duplicate? */
log_debug( _("Duplicate block found at #%lld (0x%llx).\n"),
(unsigned long long)block,
(unsigned long long)block);
@@ -728,7 +725,7 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr,
struct gfs2_buffer_head *bh = NULL;
int error;
- if(gfs2_check_range(sdp, el_blk)){
+ if (gfs2_check_range(sdp, el_blk)){
log_err( _("Inode #%llu (0x%llx): Extended Attribute block "
"%llu (0x%llx) has an extended leaf block #%llu "
"(0x%llx) that is out of range.\n"),
@@ -795,7 +792,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
struct gfs2_sbd *sdp = ip->i_sbd;
char ea_name[256];
- if(!ea_hdr->ea_name_len){
+ if (!ea_hdr->ea_name_len){
/* Skip this entry for now */
return 1;
}
@@ -804,20 +801,20 @@ static int check_eattr_entries(struct gfs2_inode *ip,
strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
ea_hdr->ea_name_len);
- if(!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
+ 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){
+ 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) {
+ if (max_ptrs > ea_hdr->ea_num_ptrs) {
return 1;
} else {
log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"),
@@ -1021,7 +1018,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
if (fsck_blockmap_set(ip, block, _("directory"),
gfs2_inode_dir))
goto bad_dinode;
- if(!dirtree_insert(block))
+ if (!dirtree_insert(block))
goto bad_dinode;
break;
case S_IFREG:
@@ -1072,7 +1069,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
goto bad_dinode;
return 0;
}
- if(set_link_count(ip->i_di.di_num.no_addr, ip->i_di.di_nlink))
+ if (set_link_count(ip->i_di.di_num.no_addr, ip->i_di.di_nlink))
goto bad_dinode;
if (S_ISDIR(ip->i_di.di_mode) &&
@@ -1084,7 +1081,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
(unsigned long long)ip->i_di.di_num.no_addr,
ip->i_di.di_depth,
(1 >> (ip->i_di.di_size/sizeof(uint64_t))));
- if(fsck_blockmap_set(ip, block, _("bad depth"),
+ if (fsck_blockmap_set(ip, block, _("bad depth"),
gfs2_block_free))
goto bad_dinode;
return 0;
@@ -1165,10 +1162,11 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh)
ip = fsck_inode_get(sdp, bh);
q = block_type(block);
- if(q != gfs2_block_free) {
- log_err( _("Found a duplicate inode block at #%" PRIu64
- " (0x%" PRIx64 ") previously marked as a %s\n"),
- block, block, block_type_string(q));
+ if (q != gfs2_block_free) {
+ log_err( _("Found a duplicate inode block at #%llu"
+ " (0x%llx) previously marked as a %s\n"),
+ (unsigned long long)block,
+ (unsigned long long)block, block_type_string(q));
add_duplicate_ref(ip, block, ref_as_meta, 0, INODE_VALID);
fsck_inode_put(&ip);
return 0;
@@ -1180,9 +1178,9 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh)
(unsigned long long)block,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(query( _("Fix address in inode at block #%"
- PRIu64 " (0x%" PRIx64 ")? (y/n) "),
- block, block)) {
+ if (query( _("Fix address in inode at block #%llu"
+ " (0x%llx)? (y/n) "),
+ (unsigned long long)block, (unsigned long long)block)) {
ip->i_di.di_num.no_addr = ip->i_di.di_num.no_formal_ino = block;
bmodified(ip->i_bh);
} else
@@ -1247,7 +1245,7 @@ static int check_system_inode(struct gfs2_sbd *sdp,
inode and get it all setup - of course, everything will be in
lost+found then, but we *need* our system inodes before we can
do any of that. */
- if(!(*sysinode) || ds.q != mark) {
+ if (!(*sysinode) || ds.q != mark) {
log_err( _("Invalid or missing %s system inode (should be %d, "
"is %d).\n"), filename, mark, ds.q);
if (query(_("Create new %s system inode? (y/n) "), filename)) {
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index 93b4d87..24b7a94 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -157,11 +157,11 @@ static int check_dir_dup_ref(struct gfs2_inode *ip, struct gfs2_dirent *de,
struct inode_with_dups *id;
id = osi_list_entry(tmp2, struct inode_with_dups, list);
- if(id->name)
+ 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) {
+ 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"
@@ -239,7 +239,7 @@ static int clear_dup_metalist(struct gfs2_inode *ip, uint64_t block,
return 0;
}
/* This block, having failed the above test, is duplicated somewhere */
- if(block == dh->b->block) {
+ if (block == dh->b->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"),
@@ -289,7 +289,7 @@ static int clear_eattr_entry (struct gfs2_inode *ip,
struct gfs2_sbd *sdp = ip->i_sbd;
char ea_name[256];
- if(!ea_hdr->ea_name_len){
+ if (!ea_hdr->ea_name_len){
/* Skip this entry for now */
return 1;
}
@@ -298,13 +298,13 @@ static int clear_eattr_entry (struct gfs2_inode *ip,
strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
ea_hdr->ea_name_len);
- if(!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
+ 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){
+ if (ea_hdr->ea_num_ptrs){
uint32_t avail_size;
int max_ptrs;
@@ -312,7 +312,7 @@ static int clear_eattr_entry (struct gfs2_inode *ip,
max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /
avail_size;
- if(max_ptrs > ea_hdr->ea_num_ptrs)
+ if (max_ptrs > ea_hdr->ea_num_ptrs)
return 1;
else {
log_debug( _(" Pointers Required: %d\n Pointers Reported: %d\n"),
@@ -358,11 +358,11 @@ static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode)
/* 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(S_ISDIR(ip->i_di.di_mode) && !(ip->i_di.di_flags & GFS2_DIF_EXHASH))
+ if (S_ISDIR(ip->i_di.di_mode) && !(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)
+ if (!error)
error = check_inode_eattr(ip, &find_refs);
fsck_inode_put(&ip); /* out, brelse, free */
@@ -422,7 +422,7 @@ static int clear_a_reference(struct gfs2_sbd *sdp, struct duptree *b,
id = osi_list_entry(tmp, struct inode_with_dups, list);
dh->b = b;
dh->id = id;
- if(dh->ref_inode_count == 1) /* down to the last reference */
+ if (dh->ref_inode_count == 1) /* down to the last reference */
return 1;
if (!(query( _("Okay to clear %s inode %lld (0x%llx)? (y/n) "),
(inval ? _("invalidated") : ""),
@@ -452,7 +452,7 @@ static int clear_a_reference(struct gfs2_sbd *sdp, struct duptree *b,
* block for each duplicate and point the metadata at
* the cloned blocks */
}
- if(dh->ref_inode_count == 1) /* down to the last reference */
+ if (dh->ref_inode_count == 1) /* down to the last reference */
return 1;
return 0;
}
diff --git a/gfs2/fsck/pass1c.c b/gfs2/fsck/pass1c.c
index 04e20b3..8854787 100644
--- a/gfs2/fsck/pass1c.c
+++ b/gfs2/fsck/pass1c.c
@@ -88,7 +88,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
uint8_t q;
struct gfs2_buffer_head *indir_bh = NULL;
- if(gfs2_check_range(sdp, block)) {
+ if (gfs2_check_range(sdp, block)) {
log_err( _("Extended attributes indirect block #%llu"
" (0x%llx) for inode #%llu"
" (0x%llx) out of range...removing\n"),
@@ -99,7 +99,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
return ask_remove_eattr(ip);
}
q = block_type(block);
- if(q != gfs2_indir_blk) {
+ if (q != gfs2_indir_blk) {
log_err( _("Extended attributes indirect block #%llu"
" (0x%llx) for inode #%llu"
" (0x%llx) invalid.\n"),
@@ -123,7 +123,7 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
struct gfs2_sbd *sdp = ip->i_sbd;
uint8_t q;
- if(gfs2_check_range(sdp, block)) {
+ if (gfs2_check_range(sdp, block)) {
log_err( _("Extended attributes block for inode #%llu"
" (0x%llx) out of range.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -131,7 +131,7 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
return ask_remove_eattr(ip);
}
q = block_type(block);
- if(q != gfs2_meta_eattr) {
+ if (q != gfs2_meta_eattr) {
log_err( _("Extended attributes block for inode #%llu"
" (0x%llx) invalid.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -156,24 +156,24 @@ static int check_eattr_entry(struct gfs2_inode *ip,
((unsigned long)leaf_bh->b_data));
uint32_t max_size = sdp->sd_sb.sb_bsize;
- if(!ea_hdr->ea_name_len){
- log_err( _("EA has name length == 0\n"));
+ if (!ea_hdr->ea_name_len){
+ log_err( _("EA has name length of zero\n"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 1, 1);
}
- if(offset + be32_to_cpu(ea_hdr->ea_rec_len) > max_size){
+ if (offset + be32_to_cpu(ea_hdr->ea_rec_len) > max_size){
log_err( _("EA rec length too long\n"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 1, 1);
}
- if(offset + be32_to_cpu(ea_hdr->ea_rec_len) == max_size &&
+ if (offset + be32_to_cpu(ea_hdr->ea_rec_len) == max_size &&
(ea_hdr->ea_flags & GFS2_EAFLAG_LAST) == 0){
log_err( _("last EA has no last entry flag\n"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
}
- if(!ea_hdr->ea_name_len){
- log_err( _("EA has name length == 0\n"));
+ if (!ea_hdr->ea_name_len){
+ log_err( _("EA has name length of zero\n"));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
}
@@ -182,7 +182,7 @@ static int check_eattr_entry(struct gfs2_inode *ip,
strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
ea_hdr->ea_name_len);
- if(!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
+ if (!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&
((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){
log_err( _("EA (%s) type is invalid (%d > %d).\n"),
ea_name, ea_hdr->ea_type, GFS2_EATYPE_LAST);
@@ -190,14 +190,14 @@ static int check_eattr_entry(struct gfs2_inode *ip,
ea_hdr_prev, 0, 0);
}
- if(ea_hdr->ea_num_ptrs){
+ 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){
+ if (max_ptrs > ea_hdr->ea_num_ptrs){
log_err( _("EA (%s) has incorrect number of pointers.\n"), ea_name);
log_err( _(" Required: %d\n Reported: %d\n"),
max_ptrs, ea_hdr->ea_num_ptrs);
@@ -220,8 +220,8 @@ static int check_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_ptr,
struct gfs2_sbd *sdp = ip->i_sbd;
q = block_type(be64_to_cpu(*ea_ptr));
- if(q != gfs2_meta_eattr) {
- if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){
+ if (q != gfs2_meta_eattr) {
+ if (remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){
stack;
return -1;
}
@@ -270,7 +270,7 @@ int pass1c(struct gfs2_sbd *sdp)
(unsigned long long)ip->i_di.di_eattr);
/* FIXME: Handle walking the eattr here */
error = check_inode_eattr(ip, &pass1c_fxns);
- if(error < 0) {
+ if (error < 0) {
stack;
brelse(bh);
return FSCK_ERROR;
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 103e29f..ffa3a87 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -37,13 +37,15 @@ static int set_parent_dir(struct gfs2_sbd *sdp, uint64_t childblock,
struct dir_info *di;
di = dirtree_find(childblock);
- if(!di) {
- log_err( _("Unable to find block %"PRIu64" (0x%" PRIx64
- ") in dir_info list\n"), childblock, childblock);
+ if (!di) {
+ log_err( _("Unable to find block %llu (0x%llx"
+ ") in dir_info list\n"),
+ (unsigned long long)childblock,
+ (unsigned long long)childblock);
return -1;
}
- if(di->dinode == childblock) {
+ if (di->dinode == childblock) {
if (di->treewalk_parent) {
log_err( _("Another directory at block %" PRIu64
" (0x%" PRIx64 ") already contains this "
@@ -73,11 +75,11 @@ static int set_dotdot_dir(struct gfs2_sbd *sdp, uint64_t childblock,
struct dir_info *di;
di = dirtree_find(childblock);
- if(di) {
- if(di->dinode == childblock) {
+ if (di) {
+ if (di->dinode == childblock) {
/* Special case for root inode because we set
* it earlier */
- if(di->dotdot_parent && sdp->md.rooti->i_di.di_num.no_addr
+ if (di->dotdot_parent && sdp->md.rooti->i_di.di_num.no_addr
!= di->dinode) {
/* This should never happen */
log_crit( _("Dotdot parent already set for"
@@ -128,31 +130,31 @@ static int check_file_type(uint8_t de_type, uint8_t blk_type)
{
switch(blk_type) {
case gfs2_inode_dir:
- if(de_type != DT_DIR)
+ if (de_type != DT_DIR)
return 1;
break;
case gfs2_inode_file:
- if(de_type != DT_REG)
+ if (de_type != DT_REG)
return 1;
break;
case gfs2_inode_lnk:
- if(de_type != DT_LNK)
+ if (de_type != DT_LNK)
return 1;
break;
case gfs2_inode_blk:
- if(de_type != DT_BLK)
+ if (de_type != DT_BLK)
return 1;
break;
case gfs2_inode_chr:
- if(de_type != DT_CHR)
+ if (de_type != DT_CHR)
return 1;
break;
case gfs2_inode_fifo:
- if(de_type != DT_FIFO)
+ if (de_type != DT_FIFO)
return 1;
break;
case gfs2_inode_sock:
- if(de_type != DT_SOCK)
+ if (de_type != DT_SOCK)
return 1;
break;
default:
@@ -203,17 +205,17 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/* Start of checks */
memset(tmp_name, 0, MAX_FILENAME);
- if(de->de_name_len < MAX_FILENAME)
+ if (de->de_name_len < MAX_FILENAME)
strncpy(tmp_name, filename, de->de_name_len);
else
strncpy(tmp_name, filename, MAX_FILENAME - 1);
- if(gfs2_check_range(ip->i_sbd, entryblock)) {
+ if (gfs2_check_range(ip->i_sbd, entryblock)) {
log_err( _("Block # referenced by directory entry %s in inode "
"%lld (0x%llx) is out of range\n"),
tmp_name, (unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(query( _("Clear directory entry to out of range block? "
+ if (query( _("Clear directory entry to out of range block? "
"(y/n) "))) {
goto nuke_dentry;
} else {
@@ -230,7 +232,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
log_err( _("Dir entry with bad record or name length\n"
"\tRecord length = %u\n\tName length = %u\n"),
de->de_rec_len, de->de_name_len);
- if(!query( _("Clear the directory entry? (y/n) "))) {
+ if (!query( _("Clear the directory entry? (y/n) "))) {
log_err( _("Directory entry not fixed.\n"));
goto dentry_is_valid;
}
@@ -250,7 +252,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
log_err( _("\tName length found = %u\n"
"\tHash expected = %u (0x%x)\n"),
de->de_name_len, calculated_hash, calculated_hash);
- if(!query( _("Fix directory hash for %s? (y/n) "),
+ if (!query( _("Fix directory hash for %s? (y/n) "),
tmp_name)) {
log_err( _("Directory entry hash for %s not "
"fixed.\n"), tmp_name);
@@ -265,13 +267,13 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
q = block_type(entryblock);
/* Get the status of the directory inode */
- if(q == gfs2_inode_invalid || q == gfs2_bad_block) {
+ if (q == gfs2_inode_invalid || q == gfs2_bad_block) {
/* This entry's inode has bad blocks in it */
/* Handle bad blocks */
log_err( _("Found a bad directory entry: %s\n"), tmp_name);
- if(!query( _("Delete inode containing bad blocks? (y/n)"))) {
+ if (!query( _("Delete inode containing bad blocks? (y/n)"))) {
log_warn( _("Entry to inode containing bad blocks remains\n"));
goto dentry_is_valid;
}
@@ -288,7 +290,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
_("bad directory entry"), gfs2_block_free);
goto nuke_dentry;
}
- if(q < gfs2_inode_dir || q > gfs2_inode_sock) {
+ if (q < gfs2_inode_dir || q > gfs2_inode_sock) {
log_err( _("Directory entry '%s' referencing inode %llu "
"(0x%llx) in dir inode %llu (0x%llx) block type "
"%d: %s.\n"), tmp_name,
@@ -300,7 +302,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
_("was previously marked invalid") :
_("was deleted or is not an inode"));
- if(!query( _("Clear directory entry to non-inode block? "
+ if (!query( _("Clear directory entry to non-inode block? "
"(y/n) "))) {
log_err( _("Directory entry to non-inode block remains\n"));
goto dentry_is_valid;
@@ -326,7 +328,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
error = check_file_type(de->de_type, q);
- if(error < 0) {
+ if (error < 0) {
log_err( _("Error: directory entry type is "
"incompatible with block type at block %lld "
"(0x%llx) in directory inode %llu (0x%llx).\n"),
@@ -339,14 +341,14 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
stack;
return -1;
}
- if(error > 0) {
+ if (error > 0) {
log_err( _("Type '%s' in dir entry (%s, %llu/0x%llx) conflicts"
" with type '%s' in dinode. (Dir entry is stale.)\n"),
de_type_string(de->de_type), tmp_name,
(unsigned long long)entryblock,
(unsigned long long)entryblock,
block_type_string(q));
- if(!query( _("Clear stale directory entry? (y/n) "))) {
+ if (!query( _("Clear stale directory entry? (y/n) "))) {
log_err( _("Stale directory entry remains\n"));
goto dentry_is_valid;
}
@@ -360,15 +362,15 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto nuke_dentry;
}
- if(!strcmp(".", tmp_name)) {
+ if (!strcmp(".", tmp_name)) {
log_debug( _("Found . dentry\n"));
- if(ds->dotdir) {
+ if (ds->dotdir) {
log_err( _("Already found '.' entry in directory %llu"
" (0x%llx)\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(!query( _("Clear duplicate '.' entry? (y/n) "))) {
+ if (!query( _("Clear duplicate '.' entry? (y/n) "))) {
log_err( _("Duplicate '.' entry remains\n"));
/* FIXME: Should we continue on here
* and check the rest of the '.' entry? */
@@ -388,7 +390,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
* location */
/* check that '.' refers to this inode */
- if(entryblock != ip->i_di.di_num.no_addr) {
+ if (entryblock != ip->i_di.di_num.no_addr) {
log_err( _("'.' entry's value incorrect in directory %llu"
" (0x%llx). Points to %llu"
" (0x%llx) when it should point to %llu"
@@ -399,7 +401,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
(unsigned long long)entryblock,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(!query( _("Remove '.' reference? (y/n) "))) {
+ if (!query( _("Remove '.' reference? (y/n) "))) {
log_err( _("Invalid '.' reference remains\n"));
/* Not setting ds->dotdir here since
* this '.' entry is invalid */
@@ -418,14 +420,14 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
ds->dotdir = 1;
goto dentry_is_valid;
}
- if(!strcmp("..", tmp_name)) {
+ if (!strcmp("..", tmp_name)) {
log_debug( _("Found .. dentry\n"));
- if(ds->dotdotdir) {
+ if (ds->dotdotdir) {
log_err( _("Already found '..' entry in directory %llu"
"(0x%llx)\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(!query( _("Clear duplicate '..' entry? (y/n) "))) {
+ if (!query( _("Clear duplicate '..' entry? (y/n) "))) {
log_err( _("Duplicate '..' entry remains\n"));
/* FIXME: Should we continue on here
* and check the rest of the '..'
@@ -444,12 +446,12 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto nuke_dentry;
}
- if(q != gfs2_inode_dir) {
+ if (q != gfs2_inode_dir) {
log_err( _("Found '..' entry in directory %llu (0x%llx) "
"pointing to something that's not a directory"),
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(!query( _("Clear bad '..' directory entry? (y/n) "))) {
+ if (!query( _("Clear bad '..' directory entry? (y/n) "))) {
log_err( _("Bad '..' directory entry remains\n"));
goto dentry_is_valid;
}
@@ -468,7 +470,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/* Add the address this entry is pointing to
* to this inode's dotdot_parent in
* dir_info */
- if(set_dotdot_dir(sdp, ip->i_di.di_num.no_addr, entryblock)) {
+ if (set_dotdot_dir(sdp, ip->i_di.di_num.no_addr, entryblock)) {
stack;
return -1;
}
@@ -478,7 +480,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
/* After this point we're only concerned with directories */
- if(q != gfs2_inode_dir) {
+ if (q != gfs2_inode_dir) {
log_debug( _("Found non-dir inode dentry pointing to %lld "
"(0x%llx)\n"),
(unsigned long long)entryblock,
@@ -488,11 +490,13 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/*log_debug( _("Found plain directory dentry\n"));*/
error = set_parent_dir(sdp, entryblock, ip->i_di.di_num.no_addr);
- if(error > 0) {
- log_err( _("%s: Hard link to block %" PRIu64" (0x%" PRIx64
- ") detected.\n"), tmp_name, entryblock, entryblock);
+ if (error > 0) {
+ log_err( _("%s: Hard link to block %llu (0x%llx"
+ ") detected.\n"), tmp_name,
+ (unsigned long long)entryblock,
+ (unsigned long long)entryblock);
- if(query( _("Clear hard link to directory? (y/n) ")))
+ if (query( _("Clear hard link to directory? (y/n) ")))
goto nuke_dentry;
else {
log_err( _("Hard link to directory remains\n"));
@@ -548,7 +552,7 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
ds.q = block_type(iblock);
}
pass2_fxns.private = (void *) &ds;
- if(ds.q == gfs2_bad_block) {
+ if (ds.q == gfs2_bad_block) {
/* First check that the directory's metatree is valid */
error = check_metatree(sysinode, &pass2_fxns);
if (error < 0) {
@@ -557,7 +561,9 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
}
}
error = check_dir(sysinode->i_sbd, iblock, &pass2_fxns);
- if(error < 0) {
+ if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
+ return FSCK_OK;
+ if (error < 0) {
stack;
return -1;
}
@@ -565,23 +571,23 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
fsck_blockmap_set(sysinode, iblock, dirname,
gfs2_inode_invalid);
- if(check_inode_eattr(sysinode, &pass2_fxns)) {
+ if (check_inode_eattr(sysinode, &pass2_fxns)) {
stack;
return -1;
}
- if(!ds.dotdir) {
+ if (!ds.dotdir) {
log_err( _("No '.' entry found for %s directory.\n"), dirname);
if (query( _("Is it okay to add '.' entry? (y/n) "))) {
uint64_t cur_blks = sysinode->i_di.di_blocks;
sprintf(tmp_name, ".");
filename_len = strlen(tmp_name); /* no trailing NULL */
- if(!(filename = malloc(sizeof(char) * filename_len))) {
+ if (!(filename = malloc(sizeof(char) * filename_len))) {
log_err( _("Unable to allocate name string\n"));
stack;
return -1;
}
- if(!(memset(filename, 0, sizeof(char) *
+ if (!(memset(filename, 0, sizeof(char) *
filename_len))) {
log_err( _("Unable to zero name string\n"));
stack;
@@ -602,13 +608,13 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
} else
log_err( _("The directory was not fixed.\n"));
}
- if(sysinode->i_di.di_entries != ds.entry_count) {
+ if (sysinode->i_di.di_entries != ds.entry_count) {
log_err( _("%s inode %llu (0x%llx"
"): Entries is %d - should be %d\n"), dirname,
(unsigned long long)sysinode->i_di.di_num.no_addr,
(unsigned long long)sysinode->i_di.di_num.no_addr,
sysinode->i_di.di_entries, ds.entry_count);
- if(query( _("Fix entries for %s inode %llu (0x%llx)? (y/n) "),
+ if (query( _("Fix entries for %s inode %llu (0x%llx)? (y/n) "),
dirname,
(unsigned long long)sysinode->i_di.di_num.no_addr,
(unsigned long long)sysinode->i_di.di_num.no_addr)) {
@@ -698,7 +704,7 @@ int pass2(struct gfs2_sbd *sdp)
q = block_type(dirblk);
- if(q != gfs2_inode_dir)
+ if (q != gfs2_inode_dir)
continue;
log_debug( _("Checking directory inode at block %"PRIu64" (0x%"
@@ -706,7 +712,7 @@ int pass2(struct gfs2_sbd *sdp)
memset(&ds, 0, sizeof(ds));
pass2_fxns.private = (void *) &ds;
- if(ds.q == gfs2_bad_block) {
+ if (ds.q == gfs2_bad_block) {
/* First check that the directory's metatree
* is valid */
ip = fsck_load_inode(sdp, dirblk);
@@ -720,7 +726,7 @@ int pass2(struct gfs2_sbd *sdp)
error = check_dir(sdp, dirblk, &pass2_fxns);
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return FSCK_OK;
- if(error < 0) {
+ if (error < 0) {
stack;
return FSCK_ERROR;
}
@@ -728,11 +734,11 @@ int pass2(struct gfs2_sbd *sdp)
struct dir_info *di;
di = dirtree_find(dirblk);
- if(!di) {
+ if (!di) {
stack;
return FSCK_ERROR;
}
- if(query( _("Remove directory entry for bad"
+ if (query( _("Remove directory entry for bad"
" inode %llu (0x%llx) in %llu"
" (0x%llx)? (y/n)"),
(unsigned long long)dirblk,
@@ -741,17 +747,18 @@ int pass2(struct gfs2_sbd *sdp)
(unsigned long long)di->treewalk_parent)) {
error = remove_dentry_from_dir(sdp, di->treewalk_parent,
dirblk);
- if(error < 0) {
+ if (error < 0) {
stack;
return FSCK_ERROR;
}
- if(error > 0) {
- log_warn( _("Unable to find dentry for %"
- PRIu64 " (0x%" PRIx64 ") in %" PRIu64
- " (0x%" PRIx64 ")\n"),
- dirblk, dirblk,
- di->treewalk_parent,
- di->treewalk_parent);
+ if (error > 0) {
+ log_warn( _("Unable to find dentry for %llu"
+ " (0x%llx) in %llu"
+ " (0x%llx)\n"),
+ (unsigned long long)dirblk,
+ (unsigned long long)dirblk,
+ (unsigned long long)di->treewalk_parent,
+ (unsigned long long)di->treewalk_parent);
}
log_warn( _("Directory entry removed\n"));
} else
@@ -766,7 +773,7 @@ int pass2(struct gfs2_sbd *sdp)
check_n_fix_bitmap(sdp, dirblk, gfs2_inode_invalid);
}
ip = fsck_load_inode(sdp, dirblk);
- if(!ds.dotdir) {
+ if (!ds.dotdir) {
log_err(_("No '.' entry found for directory inode at "
"block %"PRIu64" (0x%" PRIx64 ")\n"),
dirblk, dirblk);
@@ -777,13 +784,13 @@ int pass2(struct gfs2_sbd *sdp)
sprintf(tmp_name, ".");
filename_len = strlen(tmp_name); /* no trailing
NULL */
- if(!(filename = malloc(sizeof(char) *
+ if (!(filename = malloc(sizeof(char) *
filename_len))) {
log_err(_("Unable to allocate name\n"));
stack;
return FSCK_ERROR;
}
- if(!memset(filename, 0, sizeof(char) *
+ if (!memset(filename, 0, sizeof(char) *
filename_len)) {
log_err( _("Unable to zero name\n"));
stack;
@@ -815,7 +822,7 @@ int pass2(struct gfs2_sbd *sdp)
}
}
- if(!fsck_abort && ip->i_di.di_entries != ds.entry_count) {
+ if (!fsck_abort && ip->i_di.di_entries != ds.entry_count) {
log_err( _("Entries is %d - should be %d for inode "
"block %llu (0x%llx)\n"),
ip->i_di.di_entries, ds.entry_count,
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index eea18ce..b82e7b8 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -45,14 +45,14 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
* this case? */
filename_len = strlen("..");
- if(!(filename = malloc((sizeof(char) * filename_len) + 1))) {
+ if (!(filename = malloc((sizeof(char) * filename_len) + 1))) {
log_err( _("Unable to allocate name\n"));
fsck_inode_put(&ip);
fsck_inode_put(&pip);
stack;
return -1;
}
- if(!memset(filename, 0, (sizeof(char) * filename_len) + 1)) {
+ if (!memset(filename, 0, (sizeof(char) * filename_len) + 1)) {
log_err( _("Unable to zero name\n"));
fsck_inode_put(&ip);
fsck_inode_put(&pip);
@@ -60,7 +60,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
return -1;
}
memcpy(filename, "..", filename_len);
- if(gfs2_dirent_del(ip, filename, filename_len))
+ if (gfs2_dirent_del(ip, filename, filename_len))
log_warn( _("Unable to remove \"..\" directory entry.\n"));
else
decrement_link(olddotdot, block, _("old \"..\""));
@@ -89,16 +89,19 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sdp,
di->checked = 1;
- if(!di->treewalk_parent)
+ if (!di->treewalk_parent)
return NULL;
- if(di->dotdot_parent != di->treewalk_parent) {
- log_warn( _("Directory '..' and treewalk connections disagree for inode %"
- PRIu64 " (0x%" PRIx64 ")\n"), di->dinode, di->dinode);
- log_notice( _("'..' has %" PRIu64" (0x%" PRIx64 "), treewalk has %"
- PRIu64" (0x%" PRIx64 ")\n"), di->dotdot_parent,
- di->dotdot_parent, di->treewalk_parent,
- di->treewalk_parent);
+ if (di->dotdot_parent != di->treewalk_parent) {
+ log_warn( _("Directory '..' and treewalk connections disagree for inode %llu"
+ " (0x%llx)\n"), (unsigned long long)di->dinode,
+ (unsigned long long)di->dinode);
+ log_notice( _("'..' has %llu (0x%llx), treewalk has %llu"
+ " (0x%llx)\n"),
+ (unsigned long long)di->dotdot_parent,
+ (unsigned long long)di->dotdot_parent,
+ (unsigned long long)di->treewalk_parent,
+ (unsigned long long)di->treewalk_parent);
q_dotdot = block_type(di->dotdot_parent);
q_treewalk = block_type(di->treewalk_parent);
/* if the dotdot entry isn't a directory, but the
@@ -108,8 +111,8 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sdp,
* choose? if neither are directories, we have a
* problem - need to move this directory into lost+found
*/
- if(q_dotdot != gfs2_inode_dir) {
- if(q_treewalk != gfs2_inode_dir) {
+ if (q_dotdot != gfs2_inode_dir) {
+ if (q_treewalk != gfs2_inode_dir) {
log_err( _("Orphaned directory, move to lost+found\n"));
return NULL;
}
@@ -123,14 +126,14 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sdp,
di->dotdot_parent = di->treewalk_parent;
}
} else {
- if(q_treewalk != gfs2_inode_dir) {
+ if (q_treewalk != gfs2_inode_dir) {
int error = 0;
log_warn( _(".. parent is valid, but treewalk"
"is bad - reattaching to lost+found"));
/* FIXME: add a dinode for this entry instead? */
- if(query( _("Remove directory entry for bad"
+ if (query( _("Remove directory entry for bad"
" inode %llu (0x%llx) in %llu"
" (0x%llx)? (y/n)"),
(unsigned long long)di->dinode,
@@ -139,15 +142,17 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sdp,
(unsigned long long)di->treewalk_parent)) {
error = remove_dentry_from_dir(sdp, di->treewalk_parent,
di->dinode);
- if(error < 0) {
+ if (error < 0) {
stack;
return NULL;
}
- if(error > 0) {
- log_warn( _("Unable to find dentry for block %"
- PRIu64" (0x%" PRIx64 ") in %" PRIu64 " (0x%"
- PRIx64 ")\n"),di->dinode, di->dinode,
- di->treewalk_parent, di->treewalk_parent);
+ if (error > 0) {
+ log_warn( _("Unable to find dentry for block %llu"
+ " (0x%llx) in %llu (0x%llx)\n"),
+ (unsigned long long)di->dinode,
+ (unsigned long long)di->dinode,
+ (unsigned long long)di->treewalk_parent,
+ (unsigned long long)di->treewalk_parent);
}
log_warn( _("Directory entry removed\n"));
} else {
@@ -170,9 +175,10 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sdp,
}
else {
q_dotdot = block_type(di->dotdot_parent);
- if(q_dotdot != gfs2_inode_dir) {
- log_err( _("Orphaned directory at block %" PRIu64 " (0x%" PRIx64
- ") moved to lost+found\n"), di->dinode, di->dinode);
+ if (q_dotdot != gfs2_inode_dir) {
+ log_err( _("Orphaned directory at block %llu (0x%llx) moved to lost+found\n"),
+ (unsigned long long)di->dinode,
+ (unsigned long long)di->dinode);
return NULL;
}
}
@@ -213,7 +219,7 @@ int pass3(struct gfs2_sbd *sdp)
for (tmp = osi_first(&dirtree); tmp; tmp = next) {
next = osi_next(tmp);
di = (struct dir_info *)tmp;
- while(!di->checked) {
+ while (!di->checked) {
/* FIXME: Change this so it returns success or
* failure and put the parent inode in a
* param */
@@ -229,10 +235,10 @@ int pass3(struct gfs2_sbd *sdp)
continue;
}
q = block_type(di->dinode);
- if(q == gfs2_bad_block) {
+ if (q == gfs2_bad_block) {
log_err( _("Found unlinked directory "
"containing bad block\n"));
- if(query(_("Clear unlinked directory "
+ if (query(_("Clear unlinked directory "
"with bad blocks? (y/n) "))) {
log_warn( _("inode %lld (0x%llx) is "
"now marked as free\n"),
@@ -250,13 +256,13 @@ int pass3(struct gfs2_sbd *sdp)
} else
log_err( _("Unlinked directory with bad block remains\n"));
}
- if(q != gfs2_inode_dir && q != gfs2_inode_file &&
+ if (q != gfs2_inode_dir && q != gfs2_inode_file &&
q != gfs2_inode_lnk && q != gfs2_inode_blk &&
q != gfs2_inode_chr && q != gfs2_inode_fifo &&
q != gfs2_inode_sock) {
log_err( _("Unlinked block marked as an inode "
"is not an inode\n"));
- if(!query(_("Clear the unlinked block?"
+ if (!query(_("Clear the unlinked block?"
" (y/n) "))) {
log_err( _("The block was not "
"cleared\n"));
@@ -281,10 +287,10 @@ int pass3(struct gfs2_sbd *sdp)
(unsigned long long)di->dinode);
ip = fsck_load_inode(sdp, di->dinode);
/* Don't skip zero size directories with eattrs */
- if(!ip->i_di.di_size && !ip->i_di.di_eattr){
+ if (!ip->i_di.di_size && !ip->i_di.di_eattr){
log_err( _("Unlinked directory has zero "
"size.\n"));
- if(query( _("Remove zero-size unlinked "
+ if (query( _("Remove zero-size unlinked "
"directory? (y/n) "))) {
fsck_blockmap_set(ip, di->dinode,
_("zero-sized unlinked inode"),
@@ -296,9 +302,9 @@ int pass3(struct gfs2_sbd *sdp)
"directory remains\n"));
}
}
- if(query( _("Add unlinked directory to "
+ if (query( _("Add unlinked directory to "
"lost+found? (y/n) "))) {
- if(add_inode_to_lf(ip)) {
+ if (add_inode_to_lf(ip)) {
fsck_inode_put(&ip);
stack;
return FSCK_ERROR;
@@ -311,7 +317,7 @@ int pass3(struct gfs2_sbd *sdp)
break;
}
}
- if(lf_dip)
+ if (lf_dip)
log_debug( _("At end of pass3, lost+found entries is %u\n"),
lf_dip->i_di.di_entries);
return FSCK_OK;
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index e2b3d19..e061f0b 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -40,7 +40,7 @@ static int fix_link_count(struct inode_info *ii, struct gfs2_inode *ip)
ip->i_di.di_nlink, ii->counted_links,
(unsigned long long)ip->i_di.di_num.no_addr,
(unsigned long long)ip->i_di.di_num.no_addr);
- if(ip->i_di.di_nlink == ii->counted_links)
+ if (ip->i_di.di_nlink == ii->counted_links)
return 0;
ip->i_di.di_nlink = ii->counted_links;
bmodified(ip->i_bh);
@@ -65,20 +65,21 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return 0;
next = osi_next(tmp);
- if(!(ii = (struct inode_info *)tmp)) {
+ if (!(ii = (struct inode_info *)tmp)) {
log_crit( _("osi_tree broken in scan_info_list!!\n"));
exit(FSCK_ERROR);
}
- if(ii->counted_links == 0) {
- log_err( _("Found unlinked inode at %" PRIu64 " (0x%" PRIx64 ")\n"),
- ii->inode, ii->inode);
+ if (ii->counted_links == 0) {
+ log_err( _("Found unlinked inode at %llu (0x%llx)\n"),
+ (unsigned long long)ii->inode,
+ (unsigned long long)ii->inode);
q = block_type(ii->inode);
- if(q == gfs2_bad_block) {
- log_err( _("Unlinked inode %llu (0x%llx) contains"
+ if (q == gfs2_bad_block) {
+ log_err( _("Unlinked inode %llu (0x%llx) contains "
"bad blocks\n"),
(unsigned long long)ii->inode,
(unsigned long long)ii->inode);
- if(query( _("Delete unlinked inode with bad "
+ if (query( _("Delete unlinked inode with bad "
"blocks? (y/n) "))) {
ip = fsck_load_inode(sdp, ii->inode);
check_inode_eattr(ip,
@@ -92,7 +93,7 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
} else
log_err( _("Unlinked inode with bad blocks not cleared\n"));
}
- if(q != gfs2_inode_dir &&
+ if (q != gfs2_inode_dir &&
q != gfs2_inode_file &&
q != gfs2_inode_lnk &&
q != gfs2_inode_blk &&
@@ -105,7 +106,7 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
(unsigned long long)ii->inode,
(unsigned long long)ii->inode, q);
ip = fsck_load_inode(sdp, ii->inode);
- if(query(_("Delete unlinked inode? (y/n) "))) {
+ if (query(_("Delete unlinked inode? (y/n) "))) {
check_inode_eattr(ip,
&pass4_fxns_delete);
check_metatree(ip, &pass4_fxns_delete);
@@ -126,9 +127,9 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
/* We don't want to clear zero-size files with
* eattrs - there might be relevent info in
* them. */
- if(!ip->i_di.di_size && !ip->i_di.di_eattr){
+ if (!ip->i_di.di_size && !ip->i_di.di_eattr){
log_err( _("Unlinked inode has zero size\n"));
- if(query(_("Clear zero-size unlinked inode? "
+ if (query(_("Clear zero-size unlinked inode? "
"(y/n) "))) {
fsck_blockmap_set(ip, ii->inode,
_("unlinked zero-length"),
@@ -138,9 +139,9 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
}
}
- if(query( _("Add unlinked inode to lost+found? "
+ if (query( _("Add unlinked inode to lost+found? "
"(y/n)"))) {
- if(add_inode_to_lf(ip)) {
+ if (add_inode_to_lf(ip)) {
stack;
fsck_inode_put(&ip);
return -1;
@@ -151,14 +152,16 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
} else
log_err( _("Unlinked inode left unlinked\n"));
fsck_inode_put(&ip);
- } /* if(ii->counted_links == 0) */
- else if(ii->link_count != ii->counted_links) {
- log_err( _("Link count inconsistent for inode %" PRIu64
- " (0x%" PRIx64 ") has %u but fsck found %u.\n"), ii->inode,
- ii->inode, ii->link_count, ii->counted_links);
+ } /* if (ii->counted_links == 0) */
+ else if (ii->link_count != ii->counted_links) {
+ log_err( _("Link count inconsistent for inode %llu"
+ " (0x%llx) has %u but fsck found %u.\n"),
+ (unsigned long long)ii->inode,
+ (unsigned long long)ii->inode, ii->link_count,
+ ii->counted_links);
/* Read in the inode, adjust the link count,
* and write it back out */
- if(query( _("Update link count for inode %llu"
+ if (query( _("Update link count for inode %llu"
" (0x%llx) ? (y/n) "),
(unsigned long long)ii->inode,
(unsigned long long)ii->inode)) {
@@ -180,7 +183,7 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
} /* osi_list_foreach(tmp, list) */
if (lf_addition) {
- if(!(ii = inodetree_find(lf_dip->i_di.di_num.no_addr))) {
+ if (!(ii = inodetree_find(lf_dip->i_di.di_num.no_addr))) {
log_crit( _("Unable to find lost+found inode in inode_hash!!\n"));
return -1;
} else {
@@ -202,16 +205,16 @@ static int scan_inode_list(struct gfs2_sbd *sdp) {
*/
int pass4(struct gfs2_sbd *sdp)
{
- if(lf_dip)
+ if (lf_dip)
log_debug( _("At beginning of pass4, lost+found entries is %u\n"),
lf_dip->i_di.di_entries);
log_info( _("Checking inode reference counts.\n"));
- if(scan_inode_list(sdp)) {
+ if (scan_inode_list(sdp)) {
stack;
return FSCK_ERROR;
}
- if(lf_dip)
+ if (lf_dip)
log_debug( _("At end of pass4, lost+found entries is %u\n"),
lf_dip->i_di.di_entries);
return FSCK_OK;
diff --git a/gfs2/fsck/pass5.c b/gfs2/fsck/pass5.c
index 1e49ba8..712cccc 100644
--- a/gfs2/fsck/pass5.c
+++ b/gfs2/fsck/pass5.c
@@ -75,7 +75,7 @@ static int check_block_status(struct gfs2_sbd *sdp, char *buffer, unsigned int b
bit = 0;
end = (unsigned char *) buffer + buflen;
- while(byte < end) {
+ while (byte < end) {
rg_status = ((*byte >> bit) & GFS2_BIT_MASK);
block = rg_data + *rg_block;
warm_fuzzy_stuff(block);
@@ -96,8 +96,8 @@ static int check_block_status(struct gfs2_sbd *sdp, char *buffer, unsigned int b
"block %llu (0x%llx).\n"),
(unsigned long long)block,
(unsigned long long)block);
- if(query(_("Do you want to fix the bitmap? (y/n) "))) {
- if(gfs2_set_bitmap(sdp, block, block_status))
+ if (query(_("Do you want to fix the bitmap? (y/n) "))) {
+ if (gfs2_set_bitmap(sdp, block, block_status))
log_err(_("Unlinked block %llu "
"(0x%llx) bitmap not fixed."
"\n"),
@@ -125,10 +125,10 @@ static int check_block_status(struct gfs2_sbd *sdp, char *buffer, unsigned int b
log_err( _("Metadata type is %u (%s)\n"), q,
block_type_string(q));
- if(query(_("Fix bitmap for block %llu (0x%llx) ? (y/n) "),
+ if (query(_("Fix bitmap for block %llu (0x%llx) ? (y/n) "),
(unsigned long long)block,
(unsigned long long)block)) {
- if(gfs2_set_bitmap(sdp, block, block_status))
+ if (gfs2_set_bitmap(sdp, block, block_status))
log_err( _("Failed.\n"));
else
log_err( _("Succeeded.\n"));
@@ -166,7 +166,7 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_list *rgp,
}
/* actually adjust counters and write out to disk */
- if(rgp->rg.rg_free != count[0]) {
+ if (rgp->rg.rg_free != count[0]) {
log_err( _("RG #%llu (0x%llx) free count inconsistent: "
"is %u should be %u\n"),
(unsigned long long)rgp->ri.ri_addr,
@@ -175,21 +175,21 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_list *rgp,
rgp->rg.rg_free = count[0];
update = 1;
}
- if(rgp->rg.rg_dinodes != count[1]) {
+ if (rgp->rg.rg_dinodes != count[1]) {
log_err( _("Inode count inconsistent: is %u should be %u\n"),
rgp->rg.rg_dinodes, count[1]);
rgp->rg.rg_dinodes = count[1];
update = 1;
}
- if((rgp->ri.ri_data - count[0] - count[1]) != count[2]) {
+ if ((rgp->ri.ri_data - count[0] - count[1]) != count[2]) {
/* FIXME not sure how to handle this case ATM - it
* means that the total number of blocks we've counted
* exceeds the blocks in the rg */
log_err( _("Internal fsck error - AAHHH!\n"));
exit(FSCK_ERROR);
}
- if(update) {
- if(query( _("Update resource group counts? (y/n) "))) {
+ if (update) {
+ if (query( _("Update resource group counts? (y/n) "))) {
log_warn( _("Resource group counts updated\n"));
/* write out the rgrp */
gfs2_rgrp_out(&rgp->rg, rgp->bh[0]);
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 924ef45..b3fafe5 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -106,11 +106,11 @@ int fsck_query(const char *format, ...)
errors_found++;
fsck_abort = 0;
- if(opts.yes) {
+ if (opts.yes) {
errors_corrected++;
return 1;
}
- if(opts.no)
+ if (opts.no)
return 0;
opts.query = TRUE;
@@ -138,7 +138,7 @@ int fsck_query(const char *format, ...)
break;
}
printf("Continuing.\n");
- } else if(tolower(response) == 'y') {
+ } else if (tolower(response) == 'y') {
errors_corrected++;
ret = 1;
break;
@@ -268,12 +268,12 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
/* Check for the inode on the invalid inode reference list. */
uint8_t q;
- if(!(found_id = malloc(sizeof(*found_id)))) {
+ if (!(found_id = malloc(sizeof(*found_id)))) {
log_crit( _("Unable to allocate "
"inode_with_dups structure\n"));
return -1;
}
- if(!(memset(found_id, 0, sizeof(*found_id)))) {
+ if (!(memset(found_id, 0, sizeof(*found_id)))) {
log_crit( _("Unable to zero inode_with_dups "
"structure\n"));
return -1;
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2: Make functions use sdp rather than sbp
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=f74b7d20ecd...
Commit: f74b7d20ecdac9f6c709a98674dfcfdaa511aef2
Parent: bdce9f370fc437774585d6a4264afdfbeebabc4b
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Mon Aug 8 08:41:36 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:18 2013 -0700
fsck.gfs2: Make functions use sdp rather than sbp
For years, the fsck.gfs2 tool used two different variable names to refer to the
same structure: sdp and sbp. This patch changes them all to sdp so they are now
consistent with the kernel code.
rhbz#877150
---
gfs2/fsck/fsck.h | 20 ++++++------
gfs2/fsck/initialize.c | 84 ++++++++++++++++++++++++------------------------
gfs2/fsck/main.c | 51 +++++++++++++++--------------
gfs2/fsck/metawalk.c | 30 +++++++++--------
gfs2/fsck/metawalk.h | 4 +-
gfs2/fsck/pass1.c | 18 +++++-----
gfs2/fsck/pass1b.c | 37 ++++++++++-----------
gfs2/fsck/pass1c.c | 31 +++++++++--------
gfs2/fsck/pass2.c | 78 +++++++++++++++++++++++++-------------------
gfs2/fsck/pass3.c | 50 +++++++++++++++-------------
gfs2/fsck/pass4.c | 21 ++++++------
gfs2/fsck/pass5.c | 22 ++++++------
12 files changed, 231 insertions(+), 215 deletions(-)
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index d92d0db..7b20d05 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -101,21 +101,21 @@ enum rgindex_trust_level { /* how far can we trust our RG index? */
gfs2_grow or something. Count the RGs by hand. */
};
-extern struct gfs2_inode *fsck_load_inode(struct gfs2_sbd *sbp, uint64_t block);
+extern struct gfs2_inode *fsck_load_inode(struct gfs2_sbd *sdp, uint64_t block);
extern struct gfs2_inode *fsck_inode_get(struct gfs2_sbd *sdp,
struct gfs2_buffer_head *bh);
extern void fsck_inode_put(struct gfs2_inode **ip);
-extern int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
+extern int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
int *all_clean);
-extern void destroy(struct gfs2_sbd *sbp);
-extern int pass1(struct gfs2_sbd *sbp);
-extern int pass1b(struct gfs2_sbd *sbp);
-extern int pass1c(struct gfs2_sbd *sbp);
-extern int pass2(struct gfs2_sbd *sbp);
-extern int pass3(struct gfs2_sbd *sbp);
-extern int pass4(struct gfs2_sbd *sbp);
-extern int pass5(struct gfs2_sbd *sbp);
+extern void destroy(struct gfs2_sbd *sdp);
+extern int pass1(struct gfs2_sbd *sdp);
+extern int pass1b(struct gfs2_sbd *sdp);
+extern int pass1c(struct gfs2_sbd *sdp);
+extern int pass2(struct gfs2_sbd *sdp);
+extern int pass3(struct gfs2_sbd *sdp);
+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);
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index f413250..57f0d92 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -50,26 +50,26 @@ static struct master_dir fix_md;
* Change the lock protocol so nobody can mount the fs
*
*/
-static int block_mounters(struct gfs2_sbd *sbp, int block_em)
+static int block_mounters(struct gfs2_sbd *sdp, int block_em)
{
if(block_em) {
/* verify it starts with lock_ */
- if(!strncmp(sbp->sd_sb.sb_lockproto, "lock_", 5)) {
+ if(!strncmp(sdp->sd_sb.sb_lockproto, "lock_", 5)) {
/* Change lock_ to fsck_ */
- memcpy(sbp->sd_sb.sb_lockproto, "fsck_", 5);
+ memcpy(sdp->sd_sb.sb_lockproto, "fsck_", 5);
}
/* FIXME: Need to do other verification in the else
* case */
} else {
/* verify it starts with fsck_ */
/* verify it starts with lock_ */
- if(!strncmp(sbp->sd_sb.sb_lockproto, "fsck_", 5)) {
+ if(!strncmp(sdp->sd_sb.sb_lockproto, "fsck_", 5)) {
/* Change fsck_ to lock_ */
- memcpy(sbp->sd_sb.sb_lockproto, "lock_", 5);
+ memcpy(sdp->sd_sb.sb_lockproto, "lock_", 5);
}
}
- if(write_sb(sbp)) {
+ if(write_sb(sdp)) {
stack;
return -1;
}
@@ -1088,7 +1088,7 @@ static int fill_super_block(struct gfs2_sbd *sdp)
* initialize - initialize superblock pointer
*
*/
-int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
+int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
int *all_clean)
{
int clean_journals = 0, open_flag;
@@ -1100,8 +1100,8 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
else
open_flag = O_RDWR | O_EXCL;
- sbp->device_fd = open(opts.device, open_flag);
- if (sbp->device_fd < 0) {
+ sdp->device_fd = open(opts.device, open_flag);
+ if (sdp->device_fd < 0) {
int is_mounted, ro;
if (open_flag == O_RDONLY || errno != EBUSY) {
@@ -1114,10 +1114,10 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
allow it.) We use is_pathname_mounted here even though
we're specifying a device name, not a path name. The
function checks for device as well. */
- strncpy(sbp->device_name, opts.device,
- sizeof(sbp->device_name));
- sbp->path_name = sbp->device_name; /* This gets overwritten */
- is_mounted = is_pathname_mounted(sbp, &ro);
+ strncpy(sdp->device_name, opts.device,
+ sizeof(sdp->device_name));
+ sdp->path_name = sdp->device_name; /* This gets overwritten */
+ is_mounted = is_pathname_mounted(sdp, &ro);
/* If the device is busy, but not because it's mounted, fail.
This protects against cases where the file system is LVM
and perhaps mounted on a different node. */
@@ -1132,49 +1132,49 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
/* The device is mounted RO, so it's likely our own root
file system. We can only do so much to protect the users
from themselves. Try opening without O_EXCL. */
- if ((sbp->device_fd = open(opts.device, O_RDWR)) < 0)
+ if ((sdp->device_fd = open(opts.device, O_RDWR)) < 0)
goto mount_fail;
was_mounted_ro = 1;
}
/* read in sb from disk */
- if (fill_super_block(sbp))
+ if (fill_super_block(sdp))
return FSCK_ERROR;
/* Change lock protocol to be fsck_* instead of lock_* */
- if(!opts.no && preen_is_safe(sbp, preen, force_check)) {
- if(block_mounters(sbp, 1)) {
+ if(!opts.no && preen_is_safe(sdp, preen, force_check)) {
+ if(block_mounters(sdp, 1)) {
log_err( _("Unable to block other mounters\n"));
return FSCK_USAGE;
}
}
/* Get master dinode */
- sbp->master_dir = inode_read(sbp, sbp->sd_sb.sb_master_dir.no_addr);
- if (sbp->master_dir->i_di.di_header.mh_magic != GFS2_MAGIC ||
- sbp->master_dir->i_di.di_header.mh_type != GFS2_METATYPE_DI ||
- !sbp->master_dir->i_di.di_size) {
- inode_put(&sbp->master_dir);
- rebuild_master(sbp);
- sbp->master_dir = inode_read(sbp,
- sbp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ if (sdp->master_dir->i_di.di_header.mh_magic != GFS2_MAGIC ||
+ sdp->master_dir->i_di.di_header.mh_type != GFS2_METATYPE_DI ||
+ !sdp->master_dir->i_di.di_size) {
+ inode_put(&sdp->master_dir);
+ rebuild_master(sdp);
+ sdp->master_dir = inode_read(sdp,
+ sdp->sd_sb.sb_master_dir.no_addr);
}
/* Look up the "per_node" inode. If there are journals missing, we
need to figure out what's missing from per_node. And we need all
our journals to be there before we can replay them. */
- lookup_per_node(sbp, 0);
+ lookup_per_node(sdp, 0);
/* verify various things */
- if(replay_journals(sbp, preen, force_check, &clean_journals)) {
- if(!opts.no && preen_is_safe(sbp, preen, force_check))
- block_mounters(sbp, 0);
+ if(replay_journals(sdp, preen, force_check, &clean_journals)) {
+ if(!opts.no && preen_is_safe(sdp, preen, force_check))
+ block_mounters(sdp, 0);
stack;
return FSCK_ERROR;
}
- if (sbp->md.journals == clean_journals)
+ if (sdp->md.journals == clean_journals)
*all_clean = 1;
else {
if (force_check || !preen)
@@ -1184,7 +1184,7 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
if (!force_check && *all_clean && preen)
return FSCK_OK;
- if (init_system_inodes(sbp))
+ if (init_system_inodes(sdp))
return FSCK_ERROR;
return FSCK_OK;
@@ -1194,30 +1194,30 @@ mount_fail:
return FSCK_USAGE;
}
-static void destroy_sbp(struct gfs2_sbd *sbp)
+static void destroy_sdp(struct gfs2_sbd *sdp)
{
if(!opts.no) {
- if(block_mounters(sbp, 0)) {
+ if(block_mounters(sdp, 0)) {
log_warn( _("Unable to unblock other mounters - manual intervention required\n"));
log_warn( _("Use 'gfs2_tool sb <device> proto' to fix\n"));
}
log_info( _("Syncing the device.\n"));
- fsync(sbp->device_fd);
+ fsync(sdp->device_fd);
}
- empty_super_block(sbp);
- close(sbp->device_fd);
+ empty_super_block(sdp);
+ close(sdp->device_fd);
if (was_mounted_ro && errors_corrected) {
- sbp->device_fd = open("/proc/sys/vm/drop_caches", O_WRONLY);
- if (sbp->device_fd >= 0) {
- write(sbp->device_fd, "2", 1);
- close(sbp->device_fd);
+ sdp->device_fd = open("/proc/sys/vm/drop_caches", O_WRONLY);
+ if (sdp->device_fd >= 0) {
+ write(sdp->device_fd, "2", 1);
+ close(sdp->device_fd);
} else
log_err( _("fsck.gfs2: Non-fatal error dropping "
"caches.\n"));
}
}
-void destroy(struct gfs2_sbd *sbp)
+void destroy(struct gfs2_sbd *sdp)
{
- destroy_sbp(sbp);
+ destroy_sdp(sdp);
}
diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c
index 259fff3..b955c98 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -229,7 +229,7 @@ static void check_statfs(struct gfs2_sbd *sdp)
int main(int argc, char **argv)
{
struct gfs2_sbd sb;
- struct gfs2_sbd *sbp = &sb;
+ struct gfs2_sbd *sdp = &sb;
int j;
int error = 0;
int all_clean = 0;
@@ -237,18 +237,18 @@ int main(int argc, char **argv)
setlocale(LC_ALL, "");
textdomain("gfs2-utils");
- memset(sbp, 0, sizeof(*sbp));
+ memset(sdp, 0, sizeof(*sdp));
if((error = read_cmdline(argc, argv, &opts)))
exit(error);
setbuf(stdout, NULL);
log_notice( _("Initializing fsck\n"));
- if ((error = initialize(sbp, force_check, preen, &all_clean)))
+ if ((error = initialize(sdp, force_check, preen, &all_clean)))
exit(error);
if (!force_check && all_clean && preen) {
log_err( _("%s: clean.\n"), opts.device);
- destroy(sbp);
+ destroy(sdp);
exit(FSCK_OK);
}
@@ -256,7 +256,7 @@ int main(int argc, char **argv)
log_notice( _("Starting pass1\n"));
pass = "pass 1";
last_reported_block = 0;
- if ((error = pass1(sbp)))
+ if ((error = pass1(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -269,7 +269,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 1b";
log_notice( _("Starting pass1b\n"));
- if((error = pass1b(sbp)))
+ if((error = pass1b(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -282,7 +282,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 1c";
log_notice( _("Starting pass1c\n"));
- if((error = pass1c(sbp)))
+ if((error = pass1c(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -295,7 +295,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 2";
log_notice( _("Starting pass2\n"));
- if ((error = pass2(sbp)))
+ if ((error = pass2(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -308,7 +308,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 3";
log_notice( _("Starting pass3\n"));
- if ((error = pass3(sbp)))
+ if ((error = pass3(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -321,7 +321,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 4";
log_notice( _("Starting pass4\n"));
- if ((error = pass4(sbp)))
+ if ((error = pass4(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -334,7 +334,7 @@ int main(int argc, char **argv)
last_reported_block = 0;
pass = "pass 5";
log_notice( _("Starting pass5\n"));
- if ((error = pass5(sbp)))
+ if ((error = pass5(sdp)))
exit(error);
if (skip_this_pass || fsck_abort) {
skip_this_pass = FALSE;
@@ -347,27 +347,28 @@ int main(int argc, char **argv)
error = FSCK_CANCELED;
}
- check_statfs(sbp);
+ if (!fsck_abort)
+ check_statfs(sdp);
/* Free up our system inodes */
- inode_put(&sbp->md.inum);
- inode_put(&sbp->md.statfs);
- for (j = 0; j < sbp->md.journals; j++)
- inode_put(&sbp->md.journal[j]);
- inode_put(&sbp->md.jiinode);
- inode_put(&sbp->md.riinode);
- inode_put(&sbp->md.qinode);
- inode_put(&sbp->md.pinode);
- inode_put(&sbp->md.rooti);
- inode_put(&sbp->master_dir);
+ inode_put(&sdp->md.inum);
+ inode_put(&sdp->md.statfs);
+ for (j = 0; j < sdp->md.journals; j++)
+ inode_put(&sdp->md.journal[j]);
+ inode_put(&sdp->md.jiinode);
+ inode_put(&sdp->md.riinode);
+ inode_put(&sdp->md.qinode);
+ inode_put(&sdp->md.pinode);
+ inode_put(&sdp->md.rooti);
+ inode_put(&sdp->master_dir);
if (lf_dip)
inode_put(&lf_dip);
if (!opts.no && errors_corrected)
log_notice( _("Writing changes to disk\n"));
- fsync(sbp->device_fd);
- destroy(sbp);
- log_notice( _("gfs2_fsck complete \n"));
+ fsync(sdp->device_fd);
+ destroy(sdp);
+ log_notice( _("gfs2_fsck complete\n"));
if (!error) {
if (!errors_found)
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 3a4e462..d56180c 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -195,14 +195,14 @@ struct gfs2_inode *fsck_system_inode(struct gfs2_sbd *sdp, uint64_t block)
/* fsck_load_inode - same as gfs2_load_inode() in libgfs2 but system inodes
get special treatment. */
-struct gfs2_inode *fsck_load_inode(struct gfs2_sbd *sbp, uint64_t block)
+struct gfs2_inode *fsck_load_inode(struct gfs2_sbd *sdp, uint64_t block)
{
struct gfs2_inode *ip = NULL;
- ip = fsck_system_inode(sbp, block);
+ ip = fsck_system_inode(sdp, block);
if (ip)
return ip;
- return inode_read(sbp, block);
+ return inode_read(sdp, block);
}
/* fsck_inode_get - same as inode_get() in libgfs2 but system inodes
@@ -610,7 +610,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
uint64_t first_ok_leaf;
struct gfs2_buffer_head *lbh;
int lindex;
- struct gfs2_sbd *sbp = ip->i_sbd;
+ struct gfs2_sbd *sdp = ip->i_sbd;
uint16_t count;
int ref_count = 0, exp_count = 0;
@@ -621,7 +621,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
for(lindex = 0; lindex < (1 << ip->i_di.di_depth); lindex++) {
gfs2_get_leaf_nr(ip, lindex, &leaf_no);
if (gfs2_check_range(ip->i_sbd, leaf_no) == 0) {
- lbh = bread(sbp, leaf_no);
+ lbh = bread(sdp, leaf_no);
/* Make sure it's really a valid leaf block. */
if (gfs2_check_meta(lbh, GFS2_METATYPE_LF) == 0) {
brelse(lbh);
@@ -688,7 +688,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
}
/* Try to read in the leaf block. */
- lbh = bread(sbp, leaf_no);
+ lbh = bread(sdp, leaf_no);
/* Make sure it's really a valid leaf block. */
if (gfs2_check_meta(lbh, GFS2_METATYPE_LF)) {
warn_and_patch(ip, &leaf_no, &bad_leaf,
@@ -748,7 +748,7 @@ static int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if(count != leaf.lf_entries) {
brelse(lbh);
- lbh = bread(sbp, leaf_no);
+ lbh = bread(sdp, leaf_no);
gfs2_leaf_in(&leaf, lbh);
log_err( _("Leaf %llu (0x%llx) entry "
@@ -1393,12 +1393,12 @@ int check_linear_dir(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
return error;
}
-int check_dir(struct gfs2_sbd *sbp, uint64_t block, struct metawalk_fxns *pass)
+int check_dir(struct gfs2_sbd *sdp, uint64_t block, struct metawalk_fxns *pass)
{
struct gfs2_inode *ip;
int error = 0;
- ip = fsck_load_inode(sbp, block);
+ ip = fsck_load_inode(sdp, block);
if(ip->i_di.di_flags & GFS2_DIF_EXHASH)
error = check_leaf_blks(ip, pass);
@@ -1435,16 +1435,18 @@ static int remove_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
-int remove_dentry_from_dir(struct gfs2_sbd *sbp, uint64_t dir,
+int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,
uint64_t dentryblock)
{
struct metawalk_fxns remove_dentry_fxns = {0};
uint8_t q;
int error;
- log_debug( _("Removing dentry %" PRIu64 " (0x%" PRIx64 ") from directory %"
- PRIu64" (0x%" PRIx64 ")\n"), dentryblock, dentryblock, dir, dir);
- if(gfs2_check_range(sbp, dir)) {
+ log_debug( _("Removing dentry %llu (0x%llx) from directory %llu"
+ " (0x%llx)\n"), (unsigned long long)dentryblock,
+ (unsigned long long)dentryblock,
+ (unsigned long long)dir, (unsigned long long)dir);
+ if(gfs2_check_range(sdp, dir)) {
log_err( _("Parent directory out of range\n"));
return 1;
}
@@ -1458,7 +1460,7 @@ int remove_dentry_from_dir(struct gfs2_sbd *sbp, uint64_t dir,
}
/* Need to run check_dir with a private var of dentryblock,
* and fxns that remove that dentry if found */
- error = check_dir(sbp, dir, &remove_dentry_fxns);
+ error = check_dir(sdp, dir, &remove_dentry_fxns);
return error;
}
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index 4489c60..701add2 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -21,11 +21,11 @@ struct metawalk_fxns;
extern int check_inode_eattr(struct gfs2_inode *ip,
struct metawalk_fxns *pass);
extern int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass);
-extern int check_dir(struct gfs2_sbd *sbp, uint64_t block,
+extern int check_dir(struct gfs2_sbd *sdp, uint64_t block,
struct metawalk_fxns *pass);
extern int check_linear_dir(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
struct metawalk_fxns *pass);
-extern int remove_dentry_from_dir(struct gfs2_sbd *sbp, uint64_t dir,
+extern int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,
uint64_t dentryblock);
extern int delete_block(struct gfs2_inode *ip, uint64_t block,
struct gfs2_buffer_head **bh, const char *btype,
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index bced051..b83aeb4 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -1201,7 +1201,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh)
static int check_system_inode(struct gfs2_sbd *sdp,
struct gfs2_inode **sysinode,
const char *filename,
- int builder(struct gfs2_sbd *sbp),
+ int builder(struct gfs2_sbd *sdp),
enum gfs2_mark_block mark)
{
uint64_t iblock = 0;
@@ -1387,7 +1387,7 @@ static int check_system_inodes(struct gfs2_sbd *sdp)
* inodes size
* dir info
*/
-int pass1(struct gfs2_sbd *sbp)
+int pass1(struct gfs2_sbd *sdp)
{
struct gfs2_buffer_head *bh;
osi_list_t *tmp;
@@ -1406,7 +1406,7 @@ int pass1(struct gfs2_sbd *sbp)
* the sweeps start that we won't find otherwise? */
/* Make sure the system inodes are okay & represented in the bitmap. */
- check_system_inodes(sbp);
+ check_system_inodes(sdp);
/* So, do we do a depth first search starting at the root
* inode, or use the rg bitmaps, or just read every fs block
@@ -1417,7 +1417,7 @@ int pass1(struct gfs2_sbd *sbp)
* uses the rg bitmaps, so maybe that's the best way to start
* things - we can change the method later if necessary.
*/
- for (tmp = sbp->rglist.next; tmp != &sbp->rglist;
+ for (tmp = sdp->rglist.next; tmp != &sdp->rglist;
tmp = tmp->next, rg_count++) {
log_debug( _("Checking metadata in Resource Group #%" PRIu64 "\n"),
rg_count);
@@ -1433,7 +1433,7 @@ int pass1(struct gfs2_sbd *sbp)
}
/* rgrps and bitmaps don't have bits to represent
their blocks, so don't do this:
- check_n_fix_bitmap(sbp, rgd->ri.ri_addr + i,
+ check_n_fix_bitmap(sdp, rgd->ri.ri_addr + i,
gfs2_meta_rgrp);*/
}
@@ -1456,7 +1456,7 @@ int pass1(struct gfs2_sbd *sbp)
skip_this_pass = FALSE;
fflush(stdout);
}
- if (fsck_system_inode(sbp, block)) {
+ if (fsck_system_inode(sdp, block)) {
log_debug(_("Already processed system inode "
"%lld (0x%llx)\n"),
(unsigned long long)block,
@@ -1464,7 +1464,7 @@ int pass1(struct gfs2_sbd *sbp)
first = 0;
continue;
}
- bh = bread(sbp, block);
+ bh = bread(sdp, block);
/*log_debug( _("Checking metadata block #%" PRIu64
" (0x%" PRIx64 ")\n"), block, block);*/
@@ -1480,9 +1480,9 @@ int pass1(struct gfs2_sbd *sbp)
brelse(bh);
return FSCK_ERROR;
}
- check_n_fix_bitmap(sbp, block,
+ check_n_fix_bitmap(sdp, block,
gfs2_block_free);
- } else if (handle_di(sbp, bh) < 0) {
+ } else if (handle_di(sdp, bh) < 0) {
stack;
brelse(bh);
return FSCK_ERROR;
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index 9abc8c1..93b4d87 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -103,12 +103,12 @@ 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 *sbp = ip->i_sbd;
+ 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(sbp, block);
+ *bh = bread(sdp, block);
return error;
}
@@ -117,12 +117,12 @@ 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 *sbp = ip->i_sbd;
+ 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(sbp, block);
+ *bh = bread(sdp, block);
return error;
}
@@ -334,15 +334,12 @@ static int clear_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
}
/* Finds all references to duplicate blocks in the metadata */
-static int find_block_ref(struct gfs2_sbd *sbp, uint64_t inode)
+static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode)
{
struct gfs2_inode *ip;
int error = 0;
- ip = fsck_load_inode(sbp, inode); /* bread, inode_get */
- /*log_debug( _("Checking inode %" PRIu64 " (0x%" PRIx64 ")'s "
- "metatree for references to duplicate blocks)\n"),
- inode, inode);*/
+ 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) {
@@ -402,7 +399,7 @@ static void log_inode_reference(struct duptree *b, osi_list_t *tmp, int inval)
(unsigned long long)b->block, reftypestring);
}
-static int clear_a_reference(struct gfs2_sbd *sbp, struct duptree *b,
+static int clear_a_reference(struct gfs2_sbd *sdp, struct duptree *b,
osi_list_t *ref_list, struct dup_handler *dh,
int inval)
{
@@ -439,7 +436,7 @@ static int clear_a_reference(struct gfs2_sbd *sbp, struct duptree *b,
(unsigned long long)id->block_no);
clear_dup_fxns.private = (void *) dh;
/* Clear the EAs for the inode first */
- ip = fsck_load_inode(sbp, id->block_no);
+ ip = fsck_load_inode(sdp, id->block_no);
check_inode_eattr(ip, &clear_dup_fxns);
/* If the dup wasn't only in the EA, clear the inode */
if (id->reftypecount[ref_as_data] ||
@@ -460,7 +457,7 @@ static int clear_a_reference(struct gfs2_sbd *sbp, struct duptree *b,
return 0;
}
-static int handle_dup_blk(struct gfs2_sbd *sbp, struct duptree *b)
+static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *b)
{
struct gfs2_inode *ip;
osi_list_t *tmp;
@@ -496,7 +493,7 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct duptree *b)
struct gfs2_buffer_head *bh;
uint32_t cmagic;
- bh = bread(sbp, b->block);
+ bh = bread(sdp, b->block);
cmagic = ((struct gfs2_meta_header *)(bh->b_data))->mh_magic;
brelse(bh);
if (be32_to_cpu(cmagic) == GFS2_MAGIC) {
@@ -518,7 +515,7 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct duptree *b)
log_warn( _("Clearing inode %lld (0x%llx)...\n"),
(unsigned long long)id->block_no,
(unsigned long long)id->block_no);
- ip = fsck_load_inode(sbp, id->block_no);
+ ip = fsck_load_inode(sdp, id->block_no);
ii = inodetree_find(ip->i_di.di_num.no_addr);
if (ii)
inodetree_delete(ii);
@@ -552,10 +549,10 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct duptree *b)
osi_list_foreach(tmp, &b->ref_inode_list)
log_inode_reference(b, tmp, 0);
- last_reference = clear_a_reference(sbp, b, &b->ref_invinode_list,
+ last_reference = clear_a_reference(sdp, b, &b->ref_invinode_list,
&dh, 1);
if (!last_reference)
- last_reference = clear_a_reference(sbp, b, &b->ref_inode_list,
+ last_reference = clear_a_reference(sdp, b, &b->ref_inode_list,
&dh, 0);
if (last_reference && !osi_list_empty(&b->ref_inode_list)) {
@@ -572,7 +569,7 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct duptree *b)
"reference in inode %lld (0x%llx).\n"),
(unsigned long long)id->block_no,
(unsigned long long)id->block_no);
- ip = fsck_load_inode(sbp, id->block_no);
+ ip = fsck_load_inode(sdp, id->block_no);
q = block_type(id->block_no);
if (q == gfs2_inode_invalid) {
@@ -613,7 +610,7 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct duptree *b)
/* 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 */
-int pass1b(struct gfs2_sbd *sbp)
+int pass1b(struct gfs2_sbd *sdp)
{
struct duptree *b;
uint64_t i;
@@ -657,7 +654,7 @@ int pass1b(struct gfs2_sbd *sbp)
(unsigned long long)i);
warm_fuzzy_stuff(i);
- if (find_block_ref(sbp, i) < 0) {
+ if (find_block_ref(sdp, i) < 0) {
stack;
rc = FSCK_ERROR;
goto out;
@@ -672,7 +669,7 @@ out:
next = osi_next(n);
b = (struct duptree *)n;
if (!skip_this_pass && !rc) /* no error & not asked to skip the rest */
- handle_dup_blk(sbp, b);
+ handle_dup_blk(sdp, b);
/* 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.
diff --git a/gfs2/fsck/pass1c.c b/gfs2/fsck/pass1c.c
index d89b3b4..04e20b3 100644
--- a/gfs2/fsck/pass1c.c
+++ b/gfs2/fsck/pass1c.c
@@ -84,11 +84,11 @@ 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 *sbp = ip->i_sbd;
+ struct gfs2_sbd *sdp = ip->i_sbd;
uint8_t q;
struct gfs2_buffer_head *indir_bh = NULL;
- if(gfs2_check_range(sbp, block)) {
+ if(gfs2_check_range(sdp, block)) {
log_err( _("Extended attributes indirect block #%llu"
" (0x%llx) for inode #%llu"
" (0x%llx) out of range...removing\n"),
@@ -110,7 +110,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t block,
return ask_remove_eattr(ip);
}
else
- indir_bh = bread(sbp, block);
+ indir_bh = bread(sdp, block);
*bh = indir_bh;
return 0;
@@ -120,10 +120,10 @@ 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 *sbp = ip->i_sbd;
+ struct gfs2_sbd *sdp = ip->i_sbd;
uint8_t q;
- if(gfs2_check_range(sbp, block)) {
+ if(gfs2_check_range(sdp, block)) {
log_err( _("Extended attributes block for inode #%llu"
" (0x%llx) out of range.\n"),
(unsigned long long)ip->i_di.di_num.no_addr,
@@ -139,7 +139,7 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
return ask_remove_eattr(ip);
}
else
- *bh = bread(sbp, block);
+ *bh = bread(sdp, block);
return 0;
}
@@ -217,11 +217,11 @@ static int check_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_ptr,
struct gfs2_ea_header *ea_hdr_prev, void *private)
{
uint8_t q;
- struct gfs2_sbd *sbp = ip->i_sbd;
+ struct gfs2_sbd *sdp = ip->i_sbd;
q = block_type(be64_to_cpu(*ea_ptr));
if(q != gfs2_meta_eattr) {
- if(remove_eattr_entry(sbp, leaf_bh, ea_hdr, ea_hdr_prev)){
+ if(remove_eattr_entry(sdp, leaf_bh, ea_hdr, ea_hdr_prev)){
stack;
return -1;
}
@@ -232,7 +232,7 @@ static int check_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_ptr,
/* Go over all inodes with extended attributes and verify the EAs are
* valid */
-int pass1c(struct gfs2_sbd *sbp)
+int pass1c(struct gfs2_sbd *sdp)
{
uint64_t block_no = 0;
struct gfs2_buffer_head *bh;
@@ -249,19 +249,20 @@ int pass1c(struct gfs2_sbd *sbp)
pass1c_fxns.private = NULL;
log_info( _("Looking for inodes containing ea blocks...\n"));
- osi_list_foreach_safe(tmp, &sbp->eattr_blocks.list, x) {
+ osi_list_foreach_safe(tmp, &sdp->eattr_blocks.list, x) {
ea_block = osi_list_entry(tmp, struct special_blocks, list);
block_no = ea_block->block;
warm_fuzzy_stuff(block_no);
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return FSCK_OK;
- bh = bread(sbp, block_no);
+ bh = bread(sdp, block_no);
if (!gfs2_check_meta(bh, GFS2_METATYPE_DI)) { /* if a dinode */
- log_info( _("EA in inode %"PRIu64" (0x%" PRIx64 ")\n"),
- block_no, block_no);
- gfs2_special_clear(&sbp->eattr_blocks, block_no);
- ip = fsck_inode_get(sbp, bh);
+ log_info( _("EA in inode %llu (0x%llx)\n"),
+ (unsigned long long)block_no,
+ (unsigned long long)block_no);
+ gfs2_special_clear(&sdp->eattr_blocks, block_no);
+ ip = fsck_inode_get(sdp, bh);
ip->bh_owned = 1;
log_debug( _("Found eattr at %llu (0x%llx)\n"),
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 67a121e..103e29f 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -31,7 +31,7 @@
/* Set children's parent inode in dir_info structure - ext2 does not set
* dotdot inode here, but instead in pass3 - should we? */
-static int set_parent_dir(struct gfs2_sbd *sbp, uint64_t childblock,
+static int set_parent_dir(struct gfs2_sbd *sdp, uint64_t childblock,
uint64_t parentblock)
{
struct dir_info *di;
@@ -67,7 +67,7 @@ static int set_parent_dir(struct gfs2_sbd *sbp, uint64_t childblock,
}
/* Set's the child's '..' directory inode number in dir_info structure */
-static int set_dotdot_dir(struct gfs2_sbd *sbp, uint64_t childblock,
+static int set_dotdot_dir(struct gfs2_sbd *sdp, uint64_t childblock,
uint64_t parentblock)
{
struct dir_info *di;
@@ -77,7 +77,7 @@ static int set_dotdot_dir(struct gfs2_sbd *sbp, uint64_t childblock,
if(di->dinode == childblock) {
/* Special case for root inode because we set
* it earlier */
- if(di->dotdot_parent && sbp->md.rooti->i_di.di_num.no_addr
+ if(di->dotdot_parent && sdp->md.rooti->i_di.di_num.no_addr
!= di->dinode) {
/* This should never happen */
log_crit( _("Dotdot parent already set for"
@@ -179,7 +179,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
struct gfs2_buffer_head *bh, char *filename,
uint16_t *count, void *priv)
{
- struct gfs2_sbd *sbp = ip->i_sbd;
+ struct gfs2_sbd *sdp = ip->i_sbd;
uint8_t q;
char tmp_name[MAX_FILENAME];
uint64_t entryblock;
@@ -279,7 +279,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (ip->i_di.di_num.no_addr == entryblock)
entry_ip = ip;
else
- entry_ip = fsck_load_inode(sbp, entryblock);
+ entry_ip = fsck_load_inode(sdp, entryblock);
check_inode_eattr(entry_ip, &pass2_fxns_delete);
check_metatree(entry_ip, &pass2_fxns_delete);
if (entry_ip != ip)
@@ -353,7 +353,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (ip->i_di.di_num.no_addr == entryblock)
entry_ip = ip;
else
- entry_ip = fsck_load_inode(sbp, entryblock);
+ entry_ip = fsck_load_inode(sdp, entryblock);
check_inode_eattr(entry_ip, &clear_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
@@ -377,7 +377,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (ip->i_di.di_num.no_addr == entryblock)
entry_ip = ip;
else
- entry_ip = fsck_load_inode(sbp, entryblock);
+ entry_ip = fsck_load_inode(sdp, entryblock);
check_inode_eattr(entry_ip, &clear_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
@@ -408,7 +408,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (ip->i_di.di_num.no_addr == entryblock)
entry_ip = ip;
else
- entry_ip = fsck_load_inode(sbp, entryblock);
+ entry_ip = fsck_load_inode(sdp, entryblock);
check_inode_eattr(entry_ip, &clear_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
@@ -436,7 +436,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (ip->i_di.di_num.no_addr == entryblock)
entry_ip = ip;
else
- entry_ip = fsck_load_inode(sbp, entryblock);
+ entry_ip = fsck_load_inode(sdp, entryblock);
check_inode_eattr(entry_ip, &clear_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
@@ -456,7 +456,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (ip->i_di.di_num.no_addr == entryblock)
entry_ip = ip;
else
- entry_ip = fsck_load_inode(sbp, entryblock);
+ entry_ip = fsck_load_inode(sdp, entryblock);
check_inode_eattr(entry_ip, &clear_eattrs);
if (entry_ip != ip)
fsck_inode_put(&entry_ip);
@@ -468,7 +468,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/* Add the address this entry is pointing to
* to this inode's dotdot_parent in
* dir_info */
- if(set_dotdot_dir(sbp, ip->i_di.di_num.no_addr, entryblock)) {
+ if(set_dotdot_dir(sdp, ip->i_di.di_num.no_addr, entryblock)) {
stack;
return -1;
}
@@ -487,7 +487,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
/*log_debug( _("Found plain directory dentry\n"));*/
- error = set_parent_dir(sbp, entryblock, ip->i_di.di_num.no_addr);
+ error = set_parent_dir(sdp, entryblock, ip->i_di.di_num.no_addr);
if(error > 0) {
log_err( _("%s: Hard link to block %" PRIu64" (0x%" PRIx64
") detected.\n"), tmp_name, entryblock, entryblock);
@@ -531,8 +531,8 @@ struct metawalk_fxns pass2_fxns = {
/* Check system directory inode */
/* Should work for all system directories: root, master, jindex, per_node */
-int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
- int builder(struct gfs2_sbd *sbp))
+static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
+ int builder(struct gfs2_sbd *sdp))
{
uint64_t iblock = 0;
struct dir_status ds = {0};
@@ -630,12 +630,12 @@ int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
/**
* is_system_dir - determine if a given block is for a system directory.
*/
-static inline int is_system_dir(struct gfs2_sbd *sbp, uint64_t block)
+static inline int is_system_dir(struct gfs2_sbd *sdp, uint64_t block)
{
- if (block == sbp->md.rooti->i_di.di_num.no_addr ||
- block == sbp->md.jiinode->i_di.di_num.no_addr ||
- block == sbp->md.pinode->i_di.di_num.no_addr ||
- block == sbp->master_dir->i_di.di_num.no_addr)
+ if (block == sdp->md.rooti->i_di.di_num.no_addr ||
+ block == sdp->md.jiinode->i_di.di_num.no_addr ||
+ block == sdp->md.pinode->i_di.di_num.no_addr ||
+ block == sdp->master_dir->i_di.di_num.no_addr)
return TRUE;
return FALSE;
}
@@ -651,7 +651,7 @@ static inline int is_system_dir(struct gfs2_sbd *sbp, uint64_t block)
* directory name length
* entries in range
*/
-int pass2(struct gfs2_sbd *sbp)
+int pass2(struct gfs2_sbd *sdp)
{
uint64_t dirblk;
uint8_t q;
@@ -663,19 +663,25 @@ int pass2(struct gfs2_sbd *sbp)
int error = 0;
/* Check all the system directory inodes. */
- if (check_system_dir(sbp->md.jiinode, "jindex", build_jindex)) {
+ if (check_system_dir(sdp->md.jiinode, "jindex", build_jindex)) {
stack;
return FSCK_ERROR;
}
- if (check_system_dir(sbp->md.pinode, "per_node", build_per_node)) {
+ if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
+ return FSCK_OK;
+ if (check_system_dir(sdp->md.pinode, "per_node", build_per_node)) {
stack;
return FSCK_ERROR;
}
- if (check_system_dir(sbp->master_dir, "master", build_master)) {
+ if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
+ return FSCK_OK;
+ if (check_system_dir(sdp->master_dir, "master", build_master)) {
stack;
return FSCK_ERROR;
}
- if (check_system_dir(sbp->md.rooti, "root", build_root)) {
+ if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
+ return FSCK_OK;
+ if (check_system_dir(sdp->md.rooti, "root", build_root)) {
stack;
return FSCK_ERROR;
}
@@ -687,7 +693,7 @@ int pass2(struct gfs2_sbd *sbp)
return FSCK_OK;
/* Skip the system inodes - they're checked above */
- if (is_system_dir(sbp, dirblk))
+ if (is_system_dir(sdp, dirblk))
continue;
q = block_type(dirblk);
@@ -703,7 +709,7 @@ int pass2(struct gfs2_sbd *sbp)
if(ds.q == gfs2_bad_block) {
/* First check that the directory's metatree
* is valid */
- ip = fsck_load_inode(sbp, dirblk);
+ ip = fsck_load_inode(sdp, dirblk);
error = check_metatree(ip, &pass2_fxns);
fsck_inode_put(&ip);
if (error < 0) {
@@ -711,7 +717,9 @@ int pass2(struct gfs2_sbd *sbp)
return error;
}
}
- error = check_dir(sbp, dirblk, &pass2_fxns);
+ error = check_dir(sdp, dirblk, &pass2_fxns);
+ if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
+ return FSCK_OK;
if(error < 0) {
stack;
return FSCK_ERROR;
@@ -725,11 +733,13 @@ int pass2(struct gfs2_sbd *sbp)
return FSCK_ERROR;
}
if(query( _("Remove directory entry for bad"
- " inode %"PRIu64" (0x%" PRIx64 ") in %"PRIu64
- " (0x%" PRIx64 ")? (y/n)"), dirblk,
- dirblk, di->treewalk_parent,
- di->treewalk_parent)) {
- error = remove_dentry_from_dir(sbp, di->treewalk_parent,
+ " inode %llu (0x%llx) in %llu"
+ " (0x%llx)? (y/n)"),
+ (unsigned long long)dirblk,
+ (unsigned long long)dirblk,
+ (unsigned long long)di->treewalk_parent,
+ (unsigned long long)di->treewalk_parent)) {
+ error = remove_dentry_from_dir(sdp, di->treewalk_parent,
dirblk);
if(error < 0) {
stack;
@@ -753,9 +763,9 @@ int pass2(struct gfs2_sbd *sbp)
/* 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(sbp, dirblk, gfs2_inode_invalid);
+ check_n_fix_bitmap(sdp, dirblk, gfs2_inode_invalid);
}
- ip = fsck_load_inode(sbp, dirblk);
+ ip = fsck_load_inode(sdp, dirblk);
if(!ds.dotdir) {
log_err(_("No '.' entry found for directory inode at "
"block %"PRIu64" (0x%" PRIx64 ")\n"),
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index 65736f1..eea18ce 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -27,7 +27,7 @@
#include "metawalk.h"
#include "util.h"
-static int attach_dotdot_to(struct gfs2_sbd *sbp, uint64_t newdotdot,
+static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
uint64_t olddotdot, uint64_t block)
{
char *filename;
@@ -35,8 +35,8 @@ static int attach_dotdot_to(struct gfs2_sbd *sbp, uint64_t newdotdot,
struct gfs2_inode *ip, *pip;
uint64_t cur_blks;
- ip = fsck_load_inode(sbp, block);
- pip = fsck_load_inode(sbp, newdotdot);
+ ip = fsck_load_inode(sdp, block);
+ pip = fsck_load_inode(sdp, newdotdot);
/* FIXME: Need to add some interactive
* options here and come up with a
* good default for non-interactive */
@@ -81,7 +81,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sbp, uint64_t newdotdot,
return 0;
}
-static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
+static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sdp,
struct dir_info *di)
{
struct dir_info *pdi;
@@ -115,10 +115,11 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
}
else {
log_warn( _("Treewalk parent is correct,"
- " fixing dotdot -> %"PRIu64" (0x%" PRIx64 ")\n"),
- di->treewalk_parent, di->treewalk_parent);
- attach_dotdot_to(sbp, di->treewalk_parent,
- di->dotdot_parent, di->dinode);
+ " fixing dotdot -> %llu (0x%llx)\n"),
+ (unsigned long long)di->treewalk_parent,
+ (unsigned long long)di->treewalk_parent);
+ attach_dotdot_to(sdp, di->treewalk_parent,
+ di->dotdot_parent, di->dinode);
di->dotdot_parent = di->treewalk_parent;
}
} else {
@@ -130,10 +131,13 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
/* FIXME: add a dinode for this entry instead? */
if(query( _("Remove directory entry for bad"
- " inode %"PRIu64" (0x%" PRIx64 ") in %"PRIu64
- " (0x%" PRIx64 ")? (y/n)"), di->dinode, di->dinode,
- di->treewalk_parent, di->treewalk_parent)) {
- error = remove_dentry_from_dir(sbp, di->treewalk_parent,
+ " inode %llu (0x%llx) in %llu"
+ " (0x%llx)? (y/n)"),
+ (unsigned long long)di->dinode,
+ (unsigned long long)di->dinode,
+ (unsigned long long)di->treewalk_parent,
+ (unsigned long long)di->treewalk_parent)) {
+ error = remove_dentry_from_dir(sdp, di->treewalk_parent,
di->dinode);
if(error < 0) {
stack;
@@ -157,7 +161,7 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
log_err( _("Both .. and treewalk parents are "
"directories, going with treewalk "
"for now...\n"));
- attach_dotdot_to(sbp, di->treewalk_parent,
+ attach_dotdot_to(sdp, di->treewalk_parent,
di->dotdot_parent,
di->dinode);
di->dotdot_parent = di->treewalk_parent;
@@ -183,19 +187,19 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
* handle disconnected directories
* handle lost+found directory errors (missing, not a directory, no space)
*/
-int pass3(struct gfs2_sbd *sbp)
+int pass3(struct gfs2_sbd *sdp)
{
struct osi_node *tmp, *next = NULL;
struct dir_info *di, *tdi;
struct gfs2_inode *ip;
uint8_t q;
- di = dirtree_find(sbp->md.rooti->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->md.rooti->i_di.di_num.no_addr);
if (di) {
log_info( _("Marking root inode connected\n"));
di->checked = 1;
}
- di = dirtree_find(sbp->master_dir->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->master_dir->i_di.di_num.no_addr);
if (di) {
log_info( _("Marking master directory inode connected\n"));
di->checked = 1;
@@ -215,7 +219,7 @@ int pass3(struct gfs2_sbd *sbp)
* param */
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return FSCK_OK;
- tdi = mark_and_return_parent(sbp, di);
+ tdi = mark_and_return_parent(sdp, di);
if (tdi) {
log_debug( _("Directory at block %" PRIu64
@@ -240,7 +244,7 @@ int pass3(struct gfs2_sbd *sbp)
because we don't have ip */
gfs2_blockmap_set(bl, di->dinode,
gfs2_block_free);
- check_n_fix_bitmap(sbp, di->dinode,
+ check_n_fix_bitmap(sdp, di->dinode,
gfs2_block_free);
break;
} else
@@ -266,16 +270,16 @@ int pass3(struct gfs2_sbd *sbp)
because we don't have ip */
gfs2_blockmap_set(bl, di->dinode,
gfs2_block_free);
- check_n_fix_bitmap(sbp, di->dinode,
+ check_n_fix_bitmap(sdp, di->dinode,
gfs2_block_free);
log_err( _("The block was cleared\n"));
break;
}
- log_err( _("Found unlinked directory at block %" PRIu64
- " (0x%" PRIx64 ")\n"), di->dinode,
- di->dinode);
- ip = fsck_load_inode(sbp, di->dinode);
+ log_err( _("Found unlinked directory at block %llu"
+ " (0x%llx)\n"), (unsigned long long)di->dinode,
+ (unsigned long long)di->dinode);
+ ip = fsck_load_inode(sdp, di->dinode);
/* Don't skip zero size directories with eattrs */
if(!ip->i_di.di_size && !ip->i_di.di_eattr){
log_err( _("Unlinked directory has zero "
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index a8d2533..e2b3d19 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -52,7 +52,7 @@ static int fix_link_count(struct inode_info *ii, struct gfs2_inode *ip)
return 0;
}
-static int scan_inode_list(struct gfs2_sbd *sbp) {
+static int scan_inode_list(struct gfs2_sbd *sdp) {
struct osi_node *tmp, *next = NULL;
struct inode_info *ii;
struct gfs2_inode *ip;
@@ -80,7 +80,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp) {
(unsigned long long)ii->inode);
if(query( _("Delete unlinked inode with bad "
"blocks? (y/n) "))) {
- ip = fsck_load_inode(sbp, ii->inode);
+ ip = fsck_load_inode(sdp, ii->inode);
check_inode_eattr(ip,
&pass4_fxns_delete);
check_metatree(ip, &pass4_fxns_delete);
@@ -104,7 +104,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp) {
"not an inode (%d)\n"),
(unsigned long long)ii->inode,
(unsigned long long)ii->inode, q);
- ip = fsck_load_inode(sbp, ii->inode);
+ ip = fsck_load_inode(sdp, ii->inode);
if(query(_("Delete unlinked inode? (y/n) "))) {
check_inode_eattr(ip,
&pass4_fxns_delete);
@@ -121,7 +121,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp) {
}
continue;
}
- ip = fsck_load_inode(sbp, ii->inode);
+ ip = fsck_load_inode(sdp, ii->inode);
/* We don't want to clear zero-size files with
* eattrs - there might be relevent info in
@@ -158,10 +158,11 @@ static int scan_inode_list(struct gfs2_sbd *sbp) {
ii->inode, ii->link_count, ii->counted_links);
/* Read in the inode, adjust the link count,
* and write it back out */
- if(query( _("Update link count for inode %" PRIu64
- " (0x%" PRIx64 ") ? (y/n) "),
- ii->inode, ii->inode)) {
- ip = fsck_load_inode(sbp, ii->inode); /* bread, inode_get */
+ if(query( _("Update link count for inode %llu"
+ " (0x%llx) ? (y/n) "),
+ (unsigned long long)ii->inode,
+ (unsigned long long)ii->inode)) {
+ ip = fsck_load_inode(sdp, ii->inode); /* bread, inode_get */
fix_link_count(ii, ip);
ii->link_count = ii->counted_links;
fsck_inode_put(&ip); /* out, brelse, free */
@@ -199,13 +200,13 @@ static int scan_inode_list(struct gfs2_sbd *sbp) {
* handle unreferenced inodes of other types
* handle bad blocks
*/
-int pass4(struct gfs2_sbd *sbp)
+int pass4(struct gfs2_sbd *sdp)
{
if(lf_dip)
log_debug( _("At beginning of pass4, lost+found entries is %u\n"),
lf_dip->i_di.di_entries);
log_info( _("Checking inode reference counts.\n"));
- if(scan_inode_list(sbp)) {
+ if(scan_inode_list(sdp)) {
stack;
return FSCK_ERROR;
}
diff --git a/gfs2/fsck/pass5.c b/gfs2/fsck/pass5.c
index e483ade..1e49ba8 100644
--- a/gfs2/fsck/pass5.c
+++ b/gfs2/fsck/pass5.c
@@ -61,7 +61,7 @@ static int convert_mark(uint8_t q, uint32_t *count)
return -1;
}
-static int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int buflen,
+static int check_block_status(struct gfs2_sbd *sdp, char *buffer, unsigned int buflen,
uint64_t *rg_block, uint64_t rg_data, uint32_t *count)
{
unsigned char *byte, *end;
@@ -97,7 +97,7 @@ static int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int b
(unsigned long long)block,
(unsigned long long)block);
if(query(_("Do you want to fix the bitmap? (y/n) "))) {
- if(gfs2_set_bitmap(sbp, block, block_status))
+ if(gfs2_set_bitmap(sdp, block, block_status))
log_err(_("Unlinked block %llu "
"(0x%llx) bitmap not fixed."
"\n"),
@@ -125,10 +125,10 @@ static int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int b
log_err( _("Metadata type is %u (%s)\n"), q,
block_type_string(q));
- if(query(_("Fix bitmap for block %" PRIu64
- " (0x%" PRIx64 ") ? (y/n) "),
- block, block)) {
- if(gfs2_set_bitmap(sbp, block, block_status))
+ if(query(_("Fix bitmap for block %llu (0x%llx) ? (y/n) "),
+ (unsigned long long)block,
+ (unsigned long long)block)) {
+ if(gfs2_set_bitmap(sdp, block, block_status))
log_err( _("Failed.\n"));
else
log_err( _("Succeeded.\n"));
@@ -147,7 +147,7 @@ static int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int b
return 0;
}
-static void update_rgrp(struct gfs2_sbd *sbp, struct rgrp_list *rgp,
+static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_list *rgp,
uint32_t *count)
{
uint32_t i;
@@ -159,7 +159,7 @@ static void update_rgrp(struct gfs2_sbd *sbp, struct rgrp_list *rgp,
bits = &rgp->bits[i];
/* update the bitmaps */
- check_block_status(sbp, rgp->bh[i]->b_data + bits->bi_offset,
+ check_block_status(sdp, rgp->bh[i]->b_data + bits->bi_offset,
bits->bi_len, &rg_block, rgp->ri.ri_data0, count);
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return;
@@ -204,7 +204,7 @@ static void update_rgrp(struct gfs2_sbd *sbp, struct rgrp_list *rgp,
* fix free block maps
* fix used inode maps
*/
-int pass5(struct gfs2_sbd *sbp)
+int pass5(struct gfs2_sbd *sdp)
{
osi_list_t *tmp;
struct rgrp_list *rgp = NULL;
@@ -212,7 +212,7 @@ int pass5(struct gfs2_sbd *sbp)
uint64_t rg_count = 0;
/* Reconcile RG bitmaps with fsck bitmap */
- for(tmp = sbp->rglist.next; tmp != &sbp->rglist; tmp = tmp->next){
+ for(tmp = sdp->rglist.next; tmp != &sdp->rglist; tmp = tmp->next){
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return FSCK_OK;
log_info( _("Verifying Resource Group #%" PRIu64 "\n"), rg_count);
@@ -221,7 +221,7 @@ int pass5(struct gfs2_sbd *sbp)
rg_count++;
/* Compare the bitmaps and report the differences */
- update_rgrp(sbp, rgp, count);
+ update_rgrp(sdp, rgp, count);
}
/* Fix up superblock info based on this - don't think there's
* anything to do here... */
11 years, 1 month
- 1
- 0
cluster: RHEL510 - fsck.gfs2 only rebuilds one missing journal at a time
by Bob Peterson
Gitweb: http://git.fedorahosted.org/git/?p=cluster.git;a=commitdiff;h=bdce9f370fc...
Commit: bdce9f370fc437774585d6a4264afdfbeebabc4b
Parent: fd8905389d16ff6f5fbaaf525b6fbcdf2d283733
Author: Bob Peterson <rpeterso(a)redhat.com>
AuthorDate: Thu Jun 16 13:50:54 2011 -0500
Committer: Bob Peterson <rpeterso(a)redhat.com>
CommitterDate: Fri Apr 5 06:24:18 2013 -0700
fsck.gfs2 only rebuilds one missing journal at a time
This patch allows fsck.gfs2 to rebuild multiple journals in a single run.
It figures out the correct number of journals based on the number of entries
in the per_node directory. If per_node is missing, it reverts to its previous
behavior of rebuilding a single journal.
rhbz#877150
---
gfs2/fsck/fs_recovery.c | 16 +++++++++---
gfs2/fsck/initialize.c | 62 ++++++++++++++++++++++++++++++++++++++++------
2 files changed, 66 insertions(+), 12 deletions(-)
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index e0706e8..3498739 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -648,20 +648,28 @@ int ji_update(struct gfs2_sbd *sdp)
return -1;
}
- if(!(sdp->md.journal = calloc(ip->i_di.di_entries - 2, sizeof(struct gfs2_inode *)))) {
+ /* The per_node directory will have 3 directory entries per node,
+ plus two for "." and "..". So we subtract the 2 and divide by 3.
+ If per_node is missing or damaged, we have to trust jindex has
+ the correct number of entries. */
+ if (sdp->md.pinode) /* if per_node was read in properly */
+ sdp->md.journals = (sdp->md.pinode->i_di.di_entries - 2) / 3;
+ else
+ sdp->md.journals = ip->i_di.di_entries - 2;
+
+ if(!(sdp->md.journal = calloc(sdp->md.journals,
+ sizeof(struct gfs2_inode *)))) {
log_err("Unable to allocate journal index\n");
return -1;
}
- sdp->md.journals = 0;
memset(journal_name, 0, sizeof(*journal_name));
- for(i = 0; i < ip->i_di.di_entries - 2; i++) {
+ for (i = 0; i < sdp->md.journals; i++) {
/* FIXME check snprintf return code */
snprintf(journal_name, JOURNAL_NAME_SIZE, "journal%u", i);
gfs2_lookupi(sdp->md.jiinode, journal_name, strlen(journal_name),
&jip);
sdp->md.journal[i] = jip;
}
- sdp->md.journals = ip->i_di.di_entries - 2;
return 0;
}
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index a26ed84..f413250 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -406,6 +406,52 @@ static int rebuild_master(struct gfs2_sbd *sdp)
}
/**
+ * lookup_per_node - Make sure the per_node directory is read in
+ *
+ * This function is used to read in the per_node directory. It is called
+ * twice. The first call tries to read in the dinode early on. That ensures
+ * that if any journals are missing, we can figure out the number of journals
+ * from per_node. However, we unfortunately can't rebuild per_node at that
+ * point in time because our resource groups aren't read in yet.
+ * The second time it's called is much later when we can rebuild it.
+ *
+ * allow_rebuild: 0 if rebuilds are not allowed
+ * 1 if rebuilds are allowed
+ */
+static void lookup_per_node(struct gfs2_sbd *sdp, int allow_rebuild)
+{
+ if (sdp->md.pinode)
+ return;
+
+ gfs2_lookupi(sdp->master_dir, "per_node", 8, &sdp->md.pinode);
+ if (sdp->md.pinode)
+ return;
+ if (!allow_rebuild) {
+ log_err( _("The gfs2 system per_node directory "
+ "inode is missing, so we might not be \nable to "
+ "rebuild missing journals this run.\n"));
+ return;
+ }
+
+ if (query( _("The gfs2 system per_node directory "
+ "inode is missing. Okay to rebuild it? (y/n) "))) {
+ int err;
+
+ err = build_per_node(sdp);
+ if (err) {
+ log_crit(_("Error rebuilding per_node directory: %s\n"),
+ strerror(err));
+ exit(-1);
+ }
+ }
+ gfs2_lookupi(sdp->master_dir, "per_node", 8, &sdp->md.pinode);
+ if (!sdp->md.pinode) {
+ log_err( _("Unable to rebuild per_node; aborting.\n"));
+ exit(-1);
+ }
+}
+
+/**
* init_system_inodes
*
* Returns: 0 on success, -1 on failure
@@ -516,14 +562,9 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
build_quota(sdp);
}
- gfs2_lookupi(sdp->master_dir, "per_node", 8, &sdp->md.pinode);
- if (!sdp->md.pinode) {
- if (query( _("The gfs2 system per_node directory inode is "
- "missing. Okay to rebuild it? (y/n) ")))
- build_per_node(sdp);
- }
-
- /* FIXME fill in per_node structure */
+ /* Try to lookup the per_node inode. If it was missing, it is now
+ safe to rebuild it. */
+ lookup_per_node(sdp, 1);
/*******************************************************************
******* Now, set boundary fields in the super block *************
*******************************************************************/
@@ -1120,6 +1161,11 @@ int initialize(struct gfs2_sbd *sbp, int force_check, int preen,
sbp->sd_sb.sb_master_dir.no_addr);
}
+ /* Look up the "per_node" inode. If there are journals missing, we
+ need to figure out what's missing from per_node. And we need all
+ our journals to be there before we can replay them. */
+ lookup_per_node(sbp, 0);
+
/* verify various things */
if(replay_journals(sbp, preen, force_check, &clean_journals)) {
11 years, 1 month
- 1
- 0