[Cluster-devel] [Patch 01/44] fsck.gfs2: Make functions consistently use sdp rather than sbp
Steven Whitehouse
swhiteho at redhat.com
Fri Aug 12 08:57:26 UTC 2011
Hi,
ACK. I'd suggest to get things like this pushed asap since they are
trivial and will reduce the size of the remaining patch set,
Steve.
On Thu, 2011-08-11 at 16:52 -0400, Bob Peterson wrote:
> >From f4326def0744e6a01a5e7665eb4f8261d6996af7 Mon Sep 17 00:00:00 2001
> From: Bob Peterson <rpeterso at redhat.com>
> Date: Mon, 8 Aug 2011 08:41:36 -0500
> Subject: [PATCH 01/44] fsck.gfs2: Make functions consistently 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#675723
> ---
> gfs2/fsck/fsck.h | 20 ++++++------
> gfs2/fsck/initialize.c | 84 ++++++++++++++++++++++++------------------------
> gfs2/fsck/main.c | 48 ++++++++++++++--------------
> gfs2/fsck/metawalk.c | 24 +++++++-------
> gfs2/fsck/metawalk.h | 4 +-
> gfs2/fsck/pass1.c | 18 +++++-----
> gfs2/fsck/pass1b.c | 34 ++++++++++----------
> gfs2/fsck/pass1c.c | 26 +++++++-------
> gfs2/fsck/pass2.c | 58 ++++++++++++++++----------------
> gfs2/fsck/pass3.c | 28 ++++++++--------
> gfs2/fsck/pass4.c | 14 ++++----
> gfs2/fsck/pass5.c | 16 ++++----
> 12 files changed, 187 insertions(+), 187 deletions(-)
>
> diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
> index bc14b88..25bc3b9 100644
> --- a/gfs2/fsck/fsck.h
> +++ b/gfs2/fsck/fsck.h
> @@ -92,21 +92,21 @@ enum rgindex_trust_level { /* how far can we trust our RG index? */
> must have been converted from gfs2_convert. */
> };
>
> -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 0930ba6..55a4f19 100644
> --- a/gfs2/fsck/initialize.c
> +++ b/gfs2/fsck/initialize.c
> @@ -38,26 +38,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;
> }
> @@ -1180,7 +1180,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;
> @@ -1192,8 +1192,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) {
> @@ -1207,10 +1207,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. */
> @@ -1225,49 +1225,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)
> @@ -1277,7 +1277,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;
> @@ -1287,30 +1287,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 d0aceb1..dc3f7aa 100644
> --- a/gfs2/fsck/main.c
> +++ b/gfs2/fsck/main.c
> @@ -218,7 +218,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;
> @@ -226,18 +226,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);
> }
>
> @@ -245,7 +245,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;
> @@ -258,7 +258,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;
> @@ -271,7 +271,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;
> @@ -284,7 +284,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;
> @@ -297,7 +297,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;
> @@ -310,7 +310,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;
> @@ -323,7 +323,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;
> @@ -337,26 +337,26 @@ int main(int argc, char **argv)
> }
>
> if (!fsck_abort)
> - check_statfs(sbp);
> + 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);
> + fsync(sdp->device_fd);
> + destroy(sdp);
> log_notice( _("gfs2_fsck complete\n"));
>
> if (!error) {
> diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
> index 5d48fbe..808673c 100644
> --- a/gfs2/fsck/metawalk.c
> +++ b/gfs2/fsck/metawalk.c
> @@ -183,14 +183,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
> @@ -595,7 +595,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;
>
> @@ -606,7 +606,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);
> @@ -673,7 +673,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,
> @@ -737,7 +737,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 "
> @@ -1384,12 +1384,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);
> @@ -1426,7 +1426,7 @@ 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};
> @@ -1437,7 +1437,7 @@ int remove_dentry_from_dir(struct gfs2_sbd *sbp, 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(sbp, dir)) {
> + if(gfs2_check_range(sdp, dir)) {
> log_err( _("Parent directory out of range\n"));
> return 1;
> }
> @@ -1451,7 +1451,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 3ee12fe..c1e61fb 100644
> --- a/gfs2/fsck/metawalk.h
> +++ b/gfs2/fsck/metawalk.h
> @@ -9,11 +9,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 6649ec8..ef4628c 100644
> --- a/gfs2/fsck/pass1.c
> +++ b/gfs2/fsck/pass1.c
> @@ -1189,7 +1189,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;
> @@ -1383,7 +1383,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;
> @@ -1400,7 +1400,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
> @@ -1411,7 +1411,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 #%llu\n"),
> (unsigned long long)rg_count);
> @@ -1427,7 +1427,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);*/
> }
>
> @@ -1448,7 +1448,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,
> @@ -1456,7 +1456,7 @@ int pass1(struct gfs2_sbd *sbp)
> first = 0;
> continue;
> }
> - bh = bread(sbp, block);
> + bh = bread(sdp, block);
>
> if (gfs2_check_meta(bh, GFS2_METATYPE_DI)) {
> log_err( _("Found invalid inode at block #"
> @@ -1469,9 +1469,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 5bbda7c..373b796 100644
> --- a/gfs2/fsck/pass1b.c
> +++ b/gfs2/fsck/pass1b.c
> @@ -90,12 +90,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;
> }
> @@ -104,12 +104,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;
> }
>
> @@ -321,12 +321,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 */
> + 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) {
> @@ -386,7 +386,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)
> {
> @@ -423,7 +423,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] ||
> @@ -444,7 +444,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;
> @@ -480,7 +480,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) {
> @@ -502,7 +502,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);
> @@ -536,10 +536,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)) {
> @@ -556,7 +556,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) {
> @@ -597,7 +597,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;
> @@ -642,7 +642,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;
> @@ -657,7 +657,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 781e8d5..3367e77 100644
> --- a/gfs2/fsck/pass1c.c
> +++ b/gfs2/fsck/pass1c.c
> @@ -74,11 +74,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"),
> @@ -100,7 +100,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;
> @@ -110,10 +110,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,
> @@ -129,7 +129,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;
> }
> @@ -207,11 +207,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;
> }
> @@ -222,7 +222,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;
> @@ -239,20 +239,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 %llu (0x%llx)\n"),
> (unsigned long long)block_no,
> (unsigned long long)block_no);
> - gfs2_special_clear(&sbp->eattr_blocks, block_no);
> - ip = fsck_inode_get(sbp, bh);
> + 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 d0d67ed..b4fcc1d 100644
> --- a/gfs2/fsck/pass2.c
> +++ b/gfs2/fsck/pass2.c
> @@ -20,7 +20,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;
> @@ -60,7 +60,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;
> @@ -70,7 +70,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"
> @@ -177,7 +177,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;
> @@ -277,7 +277,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)
> @@ -351,7 +351,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);
> @@ -375,7 +375,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);
> @@ -406,7 +406,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);
> @@ -434,7 +434,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);
> @@ -454,7 +454,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);
> @@ -466,7 +466,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;
> }
> @@ -485,7 +485,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 %llu (0x%llx"
> ") detected.\n"), tmp_name,
> @@ -532,7 +532,7 @@ struct metawalk_fxns pass2_fxns = {
> /* Check system directory inode */
> /* Should work for all system directories: root, master, jindex, per_node */
> static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
> - int builder(struct gfs2_sbd *sbp))
> + int builder(struct gfs2_sbd *sdp))
> {
> uint64_t iblock = 0;
> struct dir_status ds = {0};
> @@ -637,12 +637,12 @@ static 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;
> }
> @@ -658,7 +658,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;
> @@ -670,25 +670,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 (skip_this_pass || fsck_abort) /* if asked to skip the rest */
> return FSCK_OK;
> - if (check_system_dir(sbp->md.pinode, "per_node", build_per_node)) {
> + if (check_system_dir(sdp->md.pinode, "per_node", build_per_node)) {
> stack;
> return FSCK_ERROR;
> }
> if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
> return FSCK_OK;
> - if (check_system_dir(sbp->master_dir, "master", build_master)) {
> + if (check_system_dir(sdp->master_dir, "master", build_master)) {
> stack;
> return FSCK_ERROR;
> }
> if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
> return FSCK_OK;
> - if (check_system_dir(sbp->md.rooti, "root", build_root)) {
> + if (check_system_dir(sdp->md.rooti, "root", build_root)) {
> stack;
> return FSCK_ERROR;
> }
> @@ -702,7 +702,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);
> @@ -718,7 +718,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) {
> @@ -726,7 +726,7 @@ 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) {
> @@ -748,7 +748,7 @@ int pass2(struct gfs2_sbd *sbp)
> (unsigned long long)dirblk,
> (unsigned long long)di->treewalk_parent,
> (unsigned long long)di->treewalk_parent)) {
> - error = remove_dentry_from_dir(sbp, di->treewalk_parent,
> + error = remove_dentry_from_dir(sdp, di->treewalk_parent,
> dirblk);
> if(error < 0) {
> stack;
> @@ -773,9 +773,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 %llu (0x%llx)\n"),
> diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
> index 93514be..9a022ca 100644
> --- a/gfs2/fsck/pass3.c
> +++ b/gfs2/fsck/pass3.c
> @@ -16,7 +16,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;
> @@ -24,8 +24,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 */
> @@ -75,7 +75,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,7 +115,7 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
> " fixing dotdot -> %llu (0x%llx)\n"),
> (unsigned long long)di->treewalk_parent,
> (unsigned long long)di->treewalk_parent);
> - 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;
> }
> @@ -134,7 +134,7 @@ static struct dir_info *mark_and_return_parent(struct gfs2_sbd *sbp,
> (unsigned long long)di->dinode,
> (unsigned long long)di->treewalk_parent,
> (unsigned long long)di->treewalk_parent)) {
> - error = remove_dentry_from_dir(sbp, di->treewalk_parent,
> + error = remove_dentry_from_dir(sdp, di->treewalk_parent,
> di->dinode);
> if(error < 0) {
> stack;
> @@ -160,7 +160,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;
> @@ -187,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;
> @@ -219,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 %llu (0x%llx) connected\n"),
> @@ -244,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
> @@ -270,7 +270,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);
> log_err( _("The block was cleared\n"));
> break;
> @@ -279,7 +279,7 @@ int pass3(struct gfs2_sbd *sbp)
> 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(sbp, 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 3305fb3..82144f9 100644
> --- a/gfs2/fsck/pass4.c
> +++ b/gfs2/fsck/pass4.c
> @@ -41,7 +41,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;
> @@ -70,7 +70,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);
> @@ -94,7 +94,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);
> @@ -111,7 +111,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
> @@ -154,7 +154,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp) {
> " (0x%llx) ? (y/n) "),
> (unsigned long long)ii->inode,
> (unsigned long long)ii->inode)) {
> - ip = fsck_load_inode(sbp, ii->inode); /* bread, inode_get */
> + 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 */
> @@ -195,13 +195,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 685aa77..b2c9438 100644
> --- a/gfs2/fsck/pass5.c
> +++ b/gfs2/fsck/pass5.c
> @@ -50,7 +50,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;
> @@ -86,7 +86,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"),
> @@ -120,7 +120,7 @@ static int check_block_status(struct gfs2_sbd *sbp, char *buffer, unsigned int b
> if(query(_("Fix bitmap for block %llu (0x%llx) ? (y/n) "),
> (unsigned long long)block,
> (unsigned long long)block)) {
> - if(gfs2_set_bitmap(sbp, block, block_status))
> + if(gfs2_set_bitmap(sdp, block, block_status))
> log_err( _("Failed.\n"));
> else
> log_err( _("Succeeded.\n"));
> @@ -140,7 +140,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;
> @@ -152,7 +152,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;
> @@ -197,7 +197,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;
> @@ -205,7 +205,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 #%llu\n"), (unsigned long long)rg_count);
> @@ -214,7 +214,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... */
More information about the Cluster-devel
mailing list