commit 2ac3e54d005e9fdd3103bf5a78502f92ac8a4aec
Author: Bob Peterson <bob@ganesha.peterson>
Date:   Tue Jan 19 18:00:45 2010 -0600

    libgfs2: Consistent naming for blockmap functions
    
    This patch provides for better consistency in naming of the
    functions that operate on the blockmap in memory.  Before,
    there were functions like gfs2_bitmap_set and gfs2_set_bitmap
    but one operated on the rgrp bitmap and the other operated
    on the blockmap in memory.  This patch makes the code more
    readable and understandable. It also paves the way for later
    simplification of blockmap querying and separating out the
    duplicate reference management for performance purposes.
    
    rhbz#455300

diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 3017aa5..77ec485 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -621,9 +621,9 @@ void savemeta(char *out_fn, int saveoption)
 			log_debug("RG at %"PRIu64" is %u long\n",
 				  rgd->ri.ri_addr, rgd->ri.ri_length);
 			for (i = 0; i < rgd->ri.ri_length; i++) {
-				if(gfs2_block_set(&sbd, blocklist,
-						  rgd->ri.ri_addr + i,
-						  gfs2_meta_other))
+				if(gfs2_blockmap_set(&sbd, blocklist,
+						     rgd->ri.ri_addr + i,
+						     gfs2_meta_other))
 					break;
 			}
 			first = 1;
diff --git a/gfs2/fsck/eattr.c b/gfs2/fsck/eattr.c
index af9d474..68829d2 100644
--- a/gfs2/fsck/eattr.c
+++ b/gfs2/fsck/eattr.c
@@ -32,7 +32,7 @@ static int clear_blk_nodup(struct gfs2_sbd *sbp, uint64_t block)
 		return 1;
 	}
 
-	gfs2_block_set(sbp, bl, block, gfs2_block_free);
+	gfs2_blockmap_set(sbp, bl, block, gfs2_block_free);
 
 	return 0;
 
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index 333409a..07850de 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -60,7 +60,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
 			 * directory or just found an old one, and we
 			 * used that instead of the block_type to run
 			 * this */
-			gfs2_block_set(ip->i_sbd, bl,
+			gfs2_blockmap_set(ip->i_sbd, bl,
 				       lf_dip->i_di.di_num.no_addr, gfs2_inode_dir);
 			increment_link(ip->i_sbd,
 						   ip->i_sbd->md.rooti->i_di.di_num.no_addr);
diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c
index 48a8070..6d19146 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -185,7 +185,7 @@ static int check_system_inode(struct gfs2_inode *sysinode, const char *filename,
 		/* Just reuse the inode and fix the bitmap.         */
 		if (ds.q.block_type == gfs2_block_free) {
 			log_info( _("The inode exists but the block is not marked 'in use'; fixing it.\n"));
-			gfs2_block_set(sysinode->i_sbd, bl,
+			gfs2_blockmap_set(sysinode->i_sbd, bl,
 				       sysinode->i_di.di_num.no_addr,
 				       mark);
 			ds.q.block_type = mark;
@@ -204,7 +204,7 @@ static int check_system_inode(struct gfs2_inode *sysinode, const char *filename,
 		log_err( _("Invalid or missing %s system inode.\n"), filename);
 		if (query(_("Create new %s system inode? (y/n) "), filename)) {
 			builder(sysinode->i_sbd);
-			gfs2_block_set(sysinode->i_sbd, bl,
+			gfs2_blockmap_set(sysinode->i_sbd, bl,
 				       sysinode->i_di.di_num.no_addr,
 				       mark);
 			ds.q.block_type = mark;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 4d1985f..e5d33b1 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -608,7 +608,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
 						/* Endianness doesn't matter
 						   in this case because it's
 						   a single byte. */
-						gfs2_block_set(sdp, bl,
+						gfs2_blockmap_set(sdp, bl,
 							     ip->i_di.di_eattr,
 							     gfs2_meta_eattr);
 						log_err( _("The EA was "
@@ -762,7 +762,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
 				if (indirect_buf->b_changed)
 					gfs2_set_bitmap(sdp, indirect,
 							GFS2_BLKST_FREE);
-				gfs2_block_set(sdp, bl, indirect,
+				gfs2_blockmap_set(sdp, bl, indirect,
 					       gfs2_block_free);
 				error = 1;
 			}
@@ -1203,7 +1203,7 @@ int delete_blocks(struct gfs2_inode *ip, uint64_t 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);
-			gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_free);
+			gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_block_free);
 			gfs2_free_block(ip->i_sbd, block);
 		}
 	}
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 33f2dba..341a10b 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -89,7 +89,7 @@ static int leaf(struct gfs2_inode *ip, uint64_t block,
 
 	log_debug( _("\tLeaf block at %15" PRIu64 " (0x%" PRIx64 ")\n"),
 			  block, block);
-	gfs2_block_set(ip->i_sbd, bl, block, gfs2_leaf_blk);
+	gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_leaf_blk);
 	bc->indir_count++;
 	return 0;
 }
@@ -105,7 +105,7 @@ 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 */
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
 			       gfs2_bad_block);
 		log_debug( _("Bad indirect block pointer (out of range).\n"));
 
@@ -127,7 +127,7 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
 		log_debug( _("Bad indirect block pointer (points to "
 			     "something that is not an indirect block).\n"));
 		if(!found_dup) {
-			gfs2_block_set(ip->i_sbd, bl, block, gfs2_meta_inval);
+			gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_meta_inval);
 			brelse(nbh);
 			return 1;
 		}
@@ -138,7 +138,7 @@ static int check_metalist(struct gfs2_inode *ip, uint64_t block,
 	if (!found_dup) {
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to indirect "
 			     "block.\n"), block, block);
-		gfs2_block_set(ip->i_sbd, bl, block, gfs2_indir_blk);
+		gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_indir_blk);
 	}
 	bc->indir_count++;
 
@@ -160,7 +160,7 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
 		/* Mark the owner of this block with the bad_block
 		 * designator so we know to check it for out of range
 		 * blocks later */
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
 			       gfs2_bad_block);
 		return 1;
 	}
@@ -201,7 +201,7 @@ static int check_data(struct gfs2_inode *ip, uint64_t block, void *private)
 	/* This is also confusing, so I'll clarify.  There are two bitmaps:
 	   (1) The gfs2_bmap that fsck uses to keep track of what block
 	   type has been discovered, and (2) The rgrp bitmap.  Function
-	   gfs2_block_set is used to set the former and gfs2_set_bitmap
+	   gfs2_blockmap_set is used to set the former and gfs2_set_bitmap
 	   is used to set the latter.  In this function we need to set both
 	   because we found a "data" block that could be "meta" in the rgrp
 	   bitmap.  If we don't we could run into the data block again as
@@ -239,7 +239,7 @@ static int remove_inode_eattr(struct gfs2_inode *ip, struct block_count *bc,
 	if (!duplicate) {
 		gfs2_set_bitmap(ip->i_sbd, ip->i_di.di_eattr,
 				GFS2_BLKST_FREE);
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_eattr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_eattr,
 			       gfs2_block_free);
 	}
 	ip->i_di.di_eattr = 0;
@@ -300,7 +300,7 @@ static int clear_eas(struct gfs2_inode *ip, struct block_count *bc,
 			log_err( _("The bad extended attribute was "
 				   "removed.\n"));
 		} else if (!duplicate) {
-			gfs2_block_set(sdp, bl, block, gfs2_block_free);
+			gfs2_blockmap_set(sdp, bl, block, gfs2_block_free);
 			gfs2_set_bitmap(sdp, block, GFS2_BLKST_FREE);
 			log_err( _("The bad Extended Attribute was "
 				   "removed.\n"));
@@ -327,7 +327,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
 	if(gfs2_check_range(sdp, indirect)) {
 		/*log_warn("EA indirect block #%"PRIu64" is out of range.\n",
 			indirect);
-			gfs2_block_set(sdp, bl, parent, bad_block);*/
+			gfs2_blockmap_set(sdp, bl, parent, bad_block);*/
 		/* Doesn't help to mark this here - this gets checked
 		 * in pass1c */
 		return 1;
@@ -373,7 +373,7 @@ static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
 		log_debug( _("Setting #%" PRIu64 " (0x%" PRIx64
 			  ") to indirect Extended Attribute block\n"),
 			   indirect, indirect);
-		gfs2_block_set(sdp, bl, indirect, gfs2_indir_blk);
+		gfs2_blockmap_set(sdp, bl, indirect, gfs2_indir_blk);
 		bc->ea_count++;
 	}
 	return ret;
@@ -463,7 +463,7 @@ static int check_leaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
 	/* Point of confusion: We've got to set the ea block itself to
 	   gfs2_meta_eattr here.  Elsewhere we mark the inode with
 	   gfs2_eattr_block meaning it contains an eattr for pass1c. */
-	gfs2_block_set(sdp, bl, block, gfs2_meta_eattr);
+	gfs2_blockmap_set(sdp, bl, block, gfs2_meta_eattr);
 	bc->ea_count++;
 	*bh = leaf_bh;
 	return 0;
@@ -501,7 +501,7 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, uint64_t *data_ptr,
 			 (unsigned long long)ip->i_di.di_eattr,
 			 (unsigned long long)el_blk,
 			 (unsigned long long)el_blk);
-		gfs2_block_set(sdp, bl, ip->i_di.di_eattr, gfs2_bad_block);
+		gfs2_blockmap_set(sdp, bl, ip->i_di.di_eattr, gfs2_bad_block);
 		return 1;
 	}
 	error = check_leaf_block(ip, el_blk, GFS2_METATYPE_ED, &bh, private);
@@ -532,7 +532,7 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
 			 (unsigned long long)ip->i_di.di_num.no_addr,
 			 (unsigned long long)ip->i_di.di_num.no_addr,
 			 (unsigned long long)block, (unsigned long long)block);
-		gfs2_block_set(sdp, bl, ip->i_di.di_eattr, gfs2_bad_block);
+		gfs2_blockmap_set(sdp, bl, ip->i_di.di_eattr, gfs2_bad_block);
 		return 1;
 	}
 	return check_leaf_block(ip, block, GFS2_METATYPE_EA, bh, private);
@@ -591,7 +591,7 @@ static int clear_metalist(struct gfs2_inode *ip, uint64_t block,
 		return -1;
 	}
 	if(!q.dup_block) {
-		gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_free);
+		gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_block_free);
 		return 0;
 	}
 	return 0;
@@ -606,7 +606,7 @@ static int clear_data(struct gfs2_inode *ip, uint64_t block, void *private)
 		return -1;
 	}
 	if(!q.dup_block) {
-		gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_free);
+		gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_block_free);
 		return 0;
 	}
 	return 0;
@@ -628,7 +628,7 @@ static int clear_leaf(struct gfs2_inode *ip, uint64_t block,
 	if(!q.dup_block) {
 		log_crit( _("Setting leaf #%" PRIu64 " (0x%" PRIx64 ") invalid\n"),
 				 block, block);
-		if(gfs2_block_set(ip->i_sbd, bl, block, gfs2_block_free)) {
+		if(gfs2_blockmap_set(ip->i_sbd, bl, block, gfs2_block_free)) {
 			stack;
 			return -1;
 		}
@@ -720,7 +720,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFDIR:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to directory inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_dir)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_dir)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -734,7 +734,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFREG:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to file inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_file)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_file)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -743,7 +743,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFLNK:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to symlink inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_lnk)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_lnk)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -752,7 +752,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFBLK:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to block dev inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_blk)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_blk)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -761,7 +761,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFCHR:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to char dev inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_chr)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_chr)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -770,7 +770,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFIFO:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to fifo inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_fifo)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_fifo)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -779,7 +779,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	case S_IFSOCK:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to socket inode.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_inode_sock)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_inode_sock)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -788,7 +788,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 	default:
 		log_debug( _("Setting %" PRIu64 " (0x%" PRIx64 ") to invalid.\n"),
 				  block, block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_meta_inval)) {
 			stack;
 			fsck_inode_put(&ip);
 			return -1;
@@ -812,13 +812,13 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 				 compute_height(sdp, ip->i_di.di_size));
 			/* once implemented, remove continue statement */
 		log_warn( _("Marking inode invalid\n"));
-		if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_meta_inval)) {
 			stack;
-			fsck_inode_put(ip);
+			fsck_inode_put(&ip);
 			return -1;
 		}
 		gfs2_set_bitmap(sdp, block, GFS2_BLKST_FREE);
-		fsck_inode_put(ip);
+		fsck_inode_put(&ip);
 		return 0;
 	}
 
@@ -833,7 +833,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 				 (1 >> (ip->i_di.di_size/sizeof(uint64_t))));
 			/* once implemented, remove continue statement */
 			log_warn( _("Marking inode invalid\n"));
-			if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) {
+			if(gfs2_blockmap_set(sdp, bl, block, gfs2_meta_inval)) {
 				stack;
 				fsck_inode_put(&ip);
 				return -1;
@@ -857,7 +857,7 @@ static int handle_di(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 			 (unsigned long long)ip->i_di.di_num.no_addr);
 		/* FIXME: Must set all leaves invalid as well */
 		check_metatree(ip, &invalidate_metatree);
-		gfs2_block_set(sdp, bl, ip->i_di.di_num.no_addr,
+		gfs2_blockmap_set(sdp, bl, ip->i_di.di_num.no_addr,
 			       gfs2_meta_inval);
 		gfs2_set_bitmap(sdp, ip->i_di.di_num.no_addr, GFS2_BLKST_FREE);
 		fsck_inode_put(&ip);
@@ -908,7 +908,7 @@ static int scan_meta(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh,
 		log_info( _("Found invalid metadata at #%llu (0x%llx)\n"),
 			  (unsigned long long)block,
 			  (unsigned long long)block);
-		if(gfs2_block_set(sdp, bl, block, gfs2_meta_inval)) {
+		if(gfs2_blockmap_set(sdp, bl, block, gfs2_meta_inval)) {
 			stack;
 			return -1;
 		}
@@ -988,7 +988,7 @@ int pass1(struct gfs2_sbd *sbp)
 				 rg_count);
 		rgd = osi_list_entry(tmp, struct rgrp_list, list);
 		for (i = 0; i < rgd->ri.ri_length; i++) {
-			if(gfs2_block_set(sbp, bl, rgd->ri.ri_addr + i,
+			if(gfs2_blockmap_set(sbp, bl, rgd->ri.ri_addr + i,
 					  gfs2_meta_other)){
 				stack;
 				return FSCK_ERROR;
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index f529b06..c9fa04f 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -189,7 +189,7 @@ static int clear_dup_metalist(struct gfs2_inode *ip, uint64_t block,
 		inode_hash_remove(inode_hash, ip->i_di.di_num.no_addr);
 		/* Setting the block to invalid means the inode is
 		 * cleared in pass2 */
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
 			       gfs2_meta_inval);
 	}
 	return 0;
@@ -221,7 +221,7 @@ static int clear_dup_eattr_indir(struct gfs2_inode *ip, uint64_t block,
 		log_err( _("Inode %s is in directory %" PRIu64 " (0x%" PRIx64 ")\n"),
 				dh->id->name ? dh->id->name : "",
 				dh->id->parent, dh->id->parent);
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_eattr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_eattr,
 			       gfs2_meta_inval);
 	}
 
@@ -248,7 +248,7 @@ static int clear_dup_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
 				dh->id->name ? dh->id->name : "",
 				dh->id->parent, dh->id->parent);
 		/* mark the main eattr block invalid */
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_eattr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_eattr,
 			       gfs2_meta_inval);
 	}
 
@@ -319,7 +319,7 @@ static int clear_eattr_extentry(struct gfs2_inode *ip, uint64_t *ea_data_ptr,
 				dh->id->name ? dh->id->name : "",
 				dh->id->parent, dh->id->parent);
 		/* mark the main eattr block invalid */
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_eattr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_eattr,
 			       gfs2_meta_inval);
 	}
 
@@ -439,7 +439,7 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct dup_blocks *b)
 						  ip->i_di.di_num.no_addr);
 				/* Setting the block to invalid means the inode
 				   is cleared in pass2 */
-				gfs2_block_set(ip->i_sbd, bl,
+				gfs2_blockmap_set(ip->i_sbd, bl,
 					       ip->i_di.di_num.no_addr,
 					       gfs2_meta_inval);
 				bmodified(ip->i_bh);
@@ -487,7 +487,7 @@ static int handle_dup_blk(struct gfs2_sbd *sbp, struct dup_blocks *b)
 		if(!id->ea_only)
 			check_metatree(ip, &clear_dup_fxns);
 
-		gfs2_block_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
+		gfs2_blockmap_set(ip->i_sbd, bl, ip->i_di.di_num.no_addr,
 			       gfs2_meta_inval);
 		fsck_inode_put(&ip); /* out, brelse, free */
 		dh.ref_inode_count--;
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 2642ad8..b1eefed 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -197,7 +197,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
 			"\tName length = %u\n"),
 			de->de_rec_len,
 			de->de_name_len);
-		gfs2_block_set(sbp, bl, ip->i_di.di_num.no_addr,
+		gfs2_blockmap_set(sbp, bl, ip->i_di.di_num.no_addr,
 			       gfs2_meta_inval);
 		return 1;
 		/* FIXME: should probably delete the entry here at the
@@ -265,7 +265,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
 			bmodified(entry_ip->i_bh);
 			fsck_inode_put(&entry_ip);
 			dirent2_del(ip, bh, prev_de, dent);
-			gfs2_block_set(sbp, bl, de->de_inum.no_addr,
+			gfs2_blockmap_set(sbp, bl, de->de_inum.no_addr,
 				       gfs2_block_free);
 			bmodified(bh);
 			log_warn( _("The inode containing bad blocks was "
@@ -320,7 +320,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
 			check_metatree(entry_ip, &pass2_fxns_delete);
 			bmodified(entry_ip->i_bh);
 			fsck_inode_put(&entry_ip);
-			gfs2_block_set(sbp, bl, de->de_inum.no_addr,
+			gfs2_blockmap_set(sbp, bl, de->de_inum.no_addr,
 				       gfs2_block_free);
 
 			return 1;
@@ -584,7 +584,7 @@ int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
 		return -1;
 	}
 	if (error > 0)
-		gfs2_block_set(sysinode->i_sbd, bl, iblock, gfs2_meta_inval);
+		gfs2_blockmap_set(sysinode->i_sbd, bl, iblock, gfs2_meta_inval);
 
 	if(check_inode_eattr(sysinode, &pass2_fxns)) {
 		stack;
@@ -764,7 +764,7 @@ int pass2(struct gfs2_sbd *sbp)
 				} else
 					log_err( _("Directory entry to invalid inode remains.\n"));
 			}
-			gfs2_block_set(sbp, bl, i, gfs2_meta_inval);
+			gfs2_blockmap_set(sbp, bl, i, gfs2_meta_inval);
 		}
 		ip = fsck_load_inode(sbp, i);
 		if(!ds.dotdir) {
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index f09c2ae..3182db1 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -233,7 +233,7 @@ int pass3(struct gfs2_sbd *sbp)
 					log_err( _("Found unlinked directory containing bad block\n"));
 					if(query(
 					   _("Clear unlinked directory with bad blocks? (y/n) "))) {
-						gfs2_block_set(sbp, bl,
+						gfs2_blockmap_set(sbp, bl,
 							       di->dinode,
 							       gfs2_block_free);
 						break;
@@ -248,7 +248,7 @@ int pass3(struct gfs2_sbd *sbp)
 				   q.block_type != gfs2_inode_fifo &&
 				   q.block_type != gfs2_inode_sock) {
 					log_err( _("Unlinked block marked as inode not an inode\n"));
-					gfs2_block_set(sbp, bl, di->dinode,
+					gfs2_blockmap_set(sbp, bl, di->dinode,
 						       gfs2_block_free);
 					log_err( _("Cleared\n"));
 					break;
@@ -262,7 +262,7 @@ int pass3(struct gfs2_sbd *sbp)
 				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 directory? (y/n) "))) {
-						gfs2_block_set(sbp, bl,
+						gfs2_blockmap_set(sbp, bl,
 							       di->dinode,
 							       gfs2_block_free);
 						fsck_inode_put(&ip);
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index c6328b5..0c8f969 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -89,7 +89,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) {
 					check_metatree(ip, &pass4_fxns_delete);
 					bmodified(ip->i_bh);
 					fsck_inode_put(&ip);
-					gfs2_block_set(sbp, bl, ii->inode,
+					gfs2_blockmap_set(sbp, bl, ii->inode,
 						       gfs2_block_free);
 					continue;
 				} else
@@ -111,7 +111,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) {
 							  &pass4_fxns_delete);
 					check_metatree(ip, &pass4_fxns_delete);
 					bmodified(ip->i_bh);
-					gfs2_block_set(sbp, bl, ii->inode,
+					gfs2_blockmap_set(sbp, bl, ii->inode,
 						       gfs2_block_free);
 					log_err( _("The inode was deleted\n"));
 				} else {
@@ -129,7 +129,7 @@ static int scan_inode_list(struct gfs2_sbd *sbp, osi_list_t *list) {
 			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? (y/n) "))) {
-					gfs2_block_set(sbp, bl, ii->inode,
+					gfs2_blockmap_set(sbp, bl, ii->inode,
 						       gfs2_block_free);
 					fsck_inode_put(&ip);
 					continue;
diff --git a/gfs2/libgfs2/block_list.c b/gfs2/libgfs2/block_list.c
index 5a23351..44435ff 100644
--- a/gfs2/libgfs2/block_list.c
+++ b/gfs2/libgfs2/block_list.c
@@ -29,17 +29,13 @@ static int mark_to_gbmap[16] = {
 	BAD_BLOCK, INVALID_META
 };
 
-#define BITMAP_SIZE4(size) (size >> 1)
-#define BITMAP_BYTE_OFFSET4(x) ((x & 0x0000000000000001) << 2)
-#define BITMAP_MASK4 (0xf)
-
-static int gfs2_bitmap_create(struct gfs2_bmap *bmap, uint64_t size)
+static int gfs2_blockmap_create(struct gfs2_bmap *bmap, uint64_t size)
 {
 	bmap->size = size;
 
-	/* Have to add 1 to BITMAP_SIZE since it's 0-based and mallocs
+	/* Have to add 1 to BLOCKMAP_SIZE since it's 0-based and mallocs
 	 * must be 1-based */
-	bmap->mapsize = BITMAP_SIZE4(size);
+	bmap->mapsize = BLOCKMAP_SIZE4(size);
 
 	if(!(bmap->map = malloc(sizeof(char) * bmap->mapsize)))
 		return -ENOMEM;
@@ -51,36 +47,7 @@ static int gfs2_bitmap_create(struct gfs2_bmap *bmap, uint64_t size)
 	return 0;
 }
 
-static int gfs2_bitmap_set(struct gfs2_bmap *bmap, uint64_t offset, uint8_t val)
-{
-	static char *byte;
-	static uint64_t b;
-
-	if(offset < bmap->size) {
-		byte = bmap->map + BITMAP_SIZE4(offset);
-		b = BITMAP_BYTE_OFFSET4(offset);
-		*byte |= (val & BITMAP_MASK4) << b;
-		return 0;
-	}
-	return -1;
-}
-
-static int gfs2_bitmap_clear(struct gfs2_bmap *bmap, uint64_t offset)
-{
-	static char *byte;
-	static uint64_t b;
-
-	if(offset < bmap->size) {
-		byte = bmap->map + BITMAP_SIZE4(offset);
-		b = BITMAP_BYTE_OFFSET4(offset);
-		*byte &= ~(BITMAP_MASK4 << b);
-		return 0;
-	}
-	return -1;
-
-}
-
-static void gfs2_bitmap_destroy(struct gfs2_bmap *bmap)
+static void gfs2_blockmap_destroy(struct gfs2_bmap *bmap)
 {
 	if(bmap->map)
 		free(bmap->map);
@@ -98,7 +65,7 @@ struct gfs2_bmap *gfs2_bmap_create(struct gfs2_sbd *sdp, uint64_t size,
 	if (!il || !memset(il, 0, sizeof(*il)))
 		return NULL;
 
-	if(gfs2_bitmap_create(il, size)) {
+	if(gfs2_blockmap_create(il, size)) {
 		*addl_mem_needed = il->mapsize;
 		free(il);
 		il = NULL;
@@ -222,62 +189,69 @@ int gfs2_block_mark(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
 	if(mark == gfs2_dup_block)
 		gfs2_dup_set(&sdp->dup_blocks, block);
 	else
-		err = gfs2_bitmap_set(il, block, mark_to_gbmap[mark]);
+		err = gfs2_blockmap_set(sdp, il, block, mark_to_gbmap[mark]);
 	return err;
 }
 
 /* gfs2_block_unmark clears ONE mark for the given block */
-int gfs2_block_unmark(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
+int gfs2_block_unmark(struct gfs2_sbd *sdp, struct gfs2_bmap *bmap,
 		      uint64_t block, enum gfs2_mark_block mark)
 {
 	int err = 0;
 
 	if (mark == gfs2_dup_block)
 		gfs2_dup_clear(&sdp->dup_blocks, block);
-	else
-		err = gfs2_bitmap_clear(il, block);
+	else {
+		static unsigned char *byte;
+		static uint64_t b;
+
+		if(block > bmap->size)
+			return -1;
+
+		byte = bmap->map + BLOCKMAP_SIZE4(block);
+		b = BLOCKMAP_BYTE_OFFSET4(block);
+		*byte &= ~(BLOCKMAP_MASK4 << b);
+		return 0;
+	}
 	return err;
 }
 
-/* gfs2_block_clear clears all the marks for the given block */
-int gfs2_block_clear(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
-		     uint64_t block)
+int gfs2_blockmap_set(struct gfs2_sbd *sdp, struct gfs2_bmap *bmap,
+		      uint64_t bblock, enum gfs2_mark_block mark)
 {
-	gfs2_dup_clear(&sdp->dup_blocks, block);
-	return gfs2_bitmap_clear(il, block);
-}
+	static unsigned char *byte;
+	static uint64_t b;
 
-int gfs2_block_set(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
-		   uint64_t block, enum gfs2_mark_block mark)
-{
-	int err;
+	if(bblock > bmap->size)
+		return -1;
 
-	err = gfs2_block_clear(sdp, il, block); /* clear all block status */
-	if(!err)
-		err = gfs2_block_mark(sdp, il, block, mark);
-	return err;
+	byte = bmap->map + BLOCKMAP_SIZE4(bblock);
+	b = BLOCKMAP_BYTE_OFFSET4(bblock);
+	*byte &= ~(BLOCKMAP_MASK4 << b);
+	*byte |= (mark & BLOCKMAP_MASK4) << b;
+	return 0;
 }
 
 int gfs2_block_check(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
 		     uint64_t block, struct gfs2_block_query *val)
 {
-	static char *byte;
+	static unsigned char *byte;
 	static uint64_t b;
 
 	if(block >= il->size)
 		return -1;
 
 	val->dup_block = (dupfind(&sdp->dup_blocks, block) ? 1 : 0);
-	byte = il->map + BITMAP_SIZE4(block);
-	b = BITMAP_BYTE_OFFSET4(block);
-	val->block_type = (*byte & (BITMAP_MASK4 << b )) >> b;
+	byte = il->map + BLOCKMAP_SIZE4(block);
+	b = BLOCKMAP_BYTE_OFFSET4(block);
+	val->block_type = (*byte & (BLOCKMAP_MASK4 << b )) >> b;
 	return 0;
 }
 
 void *gfs2_bmap_destroy(struct gfs2_sbd *sdp, struct gfs2_bmap *il)
 {
 	if(il) {
-		gfs2_bitmap_destroy(il);
+		gfs2_blockmap_destroy(il);
 		free(il);
 		il = NULL;
 	}
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index 4639a23..27362e1 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -351,8 +351,10 @@ struct metapath *find_metapath(struct gfs2_inode *ip, uint64_t block)
 
 	zalloc(mp, sizeof(struct metapath));
 
-	for (i = ip->i_di.di_height; i--;)
-		mp->mp_list[i] = do_div(b, sdp->sd_inptrs);
+	for (i = ip->i_di.di_height; i--;) {
+		mp->mp_list[i] = b % sdp->sd_inptrs;
+		b /= sdp->sd_inptrs;
+	}
 
 	return mp;
 }
@@ -520,7 +522,8 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
 
 	if (isdir) {
 		lblock = offset;
-		o = do_div(lblock, sdp->sd_jbsize);
+		o = lblock % sdp->sd_jbsize;
+		lblock /= sdp->sd_jbsize;
 	} else {
 		lblock = offset >> sdp->sd_sb.sb_bsize_shift;
 		o = offset & (sdp->bsize - 1);
@@ -596,7 +599,8 @@ int gfs2_writei(struct gfs2_inode *ip, void *buf,
 
 	if (isdir) {
 		lblock = offset;
-		o = do_div(lblock, sdp->sd_jbsize);
+		o = lblock % sdp->sd_jbsize;
+		lblock /= sdp->sd_jbsize;
 	} else {
 		lblock = offset >> sdp->sd_sb.sb_bsize_shift;
 		o = offset & (sdp->bsize - 1);
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index a7bd792..41759a8 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -72,13 +72,9 @@ do { \
 
 #define DIV_RU(x, y) (((x) + (y) - 1) / (y))
 
-static __inline__ uint64_t do_div_i(uint64_t *num, unsigned int den)
-{
-	unsigned int m = *num % den;
-	*num /= den;
-	return m;
-}
-#define do_div(n, d) do_div_i(&(n), (d))
+#define BLOCKMAP_SIZE4(size) (size >> 1)
+#define BLOCKMAP_BYTE_OFFSET4(x) ((x & 0x0000000000000001) << 2)
+#define BLOCKMAP_MASK4 (0xf)
 
 #define SRANDOM do { srandom(time(NULL) ^ getpid()); } while (0)
 #define RESRANDOM do { srandom(RANDOM(1000000000)); } while (0)
@@ -268,9 +264,7 @@ extern const char *prog_name;
 struct gfs2_bmap {
         uint64_t size;
         uint64_t mapsize;
-        int chunksize;
-        int chunks_per_byte;
-        char *map;
+        unsigned char *map;
 };
 
 uint64_t gfs2_bitmap_size(struct gfs2_bmap *bmap);
@@ -324,17 +318,17 @@ extern struct gfs2_bmap *gfs2_bmap_create(struct gfs2_sbd *sdp, uint64_t size,
 extern struct special_blocks *blockfind(struct special_blocks *blist, uint64_t num);
 extern void gfs2_special_set(struct special_blocks *blocklist, uint64_t block);
 extern void gfs2_special_free(struct special_blocks *blist);
-extern int gfs2_block_mark(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
-	 		   uint64_t block, enum gfs2_mark_block mark);
-extern int gfs2_block_set(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
+extern int gfs2_blockmap_set(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
 			  uint64_t block, enum gfs2_mark_block mark);
 extern void gfs2_special_clear(struct special_blocks *blocklist,
 			       uint64_t block);
+extern int gfs2_block_mark(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
+			   uint64_t block, enum gfs2_mark_block mark);
 /* gfs2_block_unmark clears ONE mark for the given block */
 extern int gfs2_block_unmark(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
 			     uint64_t block, enum gfs2_mark_block m);
 /* gfs2_block_clear clears all the marks for the given block */
-extern int gfs2_block_clear(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
+extern int gfs2_blockmap_clear(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
 			    uint64_t block);
 extern int gfs2_block_check(struct gfs2_sbd *sdp, struct gfs2_bmap *il,
 			    uint64_t block, struct gfs2_block_query *val);
diff --git a/gfs2/libgfs2/misc.c b/gfs2/libgfs2/misc.c
index 5a4e42b..e277e27 100644
--- a/gfs2/libgfs2/misc.c
+++ b/gfs2/libgfs2/misc.c
@@ -48,8 +48,8 @@ uint32_t compute_heightsize(struct gfs2_sbd *sdp, uint64_t *heightsize,
 		uint32_t m;
 
 		space = heightsize[x - 1] * inptrs;
-		d = space;
-		m = do_div(d, inptrs);
+		m = space % inptrs;
+		d = space / inptrs;
 
 		if (d != heightsize[x - 1] || m)
 			break;