[gfs2-utils] 04/07: libgfs2: Remove bi_bh from struct gfs2_bitmap

This is an automated email from the git hooks/post-receive script.

andyp pushed a commit to branch master
in repository gfs2-utils.

commit 8c292eae4c057437096c61fdfe152b5a52ecbd4c
Author: Andrew Price <anprice(a)redhat.com&gt;
AuthorDate: Tue May 5 22:30:14 2020 +0100

    libgfs2: Remove bi_bh from struct gfs2_bitmap
    
    Replace bi_bh with a pointer to the start of the block within the
    multi-block buffer containing the whole resource group. That way we can
    allocate and read the whole resource group in one go and we're not
    limited to single-block i/o's. The bh.b_modified flag has been pushed
    down into the gfs2_bitmap as bi_modified. This could be obsoleted in
    future using more deterministic writeback strategies.
    
    Signed-off-by: Andrew Price <anprice(a)redhat.com&gt;
---
 gfs2/convert/gfs2_convert.c |  48 ++++++++-------
 gfs2/edit/hexedit.c         |  46 +++++++--------
 gfs2/edit/journal.c         |   8 +--
 gfs2/edit/savemeta.c        |  32 +++++-----
 gfs2/fsck/fs_recovery.c     |  10 ++--
 gfs2/fsck/initialize.c      |  30 +++++-----
 gfs2/fsck/metawalk.c        |   6 +-
 gfs2/fsck/pass5.c           |   7 ++-
 gfs2/fsck/rgrepair.c        | 126 ++++++++++++++++++++++-----------------
 gfs2/fsck/util.c            |   5 +-
 gfs2/libgfs2/fs_bits.c      |   8 +--
 gfs2/libgfs2/fs_geometry.c  |  25 +-------
 gfs2/libgfs2/fs_ops.c       |  24 ++++----
 gfs2/libgfs2/gfs2l.c        |   2 +-
 gfs2/libgfs2/lang.c         |   2 +-
 gfs2/libgfs2/libgfs2.h      |  15 ++---
 gfs2/libgfs2/rgrp.c         | 141 +++++++++++++++++++-------------------------
 gfs2/libgfs2/structures.c   |   3 +-
 gfs2/libgfs2/super.c        |   2 +-
 tests/check_rgrp.c          |   6 +-
 20 files changed, 266 insertions(+), 280 deletions(-)

diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 17217ce..7de0f92 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -149,11 +149,10 @@ static void convert_bitmaps(struct gfs2_sbd *sdp, struct rgrp_tree
*rg)
 		bi = &rg->bits[blk];
 		for (; x < sdp->bsize; x++)
 			for (y = 0; y < GFS2_NBBY; y++) {
-				state = (bi->bi_bh->b_data[x] >>
-					 (GFS2_BIT_SIZE * y)) & 0x03;
+				state = (bi->bi_data[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
 				if (state == 0x02) {/* unallocated metadata state invalid */
-					bi->bi_bh->b_data[x] &= ~(0x02 << (GFS2_BIT_SIZE * y));
-					bmodified(bi->bi_bh);
+					bi->bi_data[x] &= ~(0x02 << (GFS2_BIT_SIZE * y));
+					bi->bi_modified = 1;
 				}
 			}
 	}
@@ -190,8 +189,8 @@ static int convert_rgs(struct gfs2_sbd *sbp)
 		sbp->dinodes_alloced += rgd1->rg_useddi;
 		convert_bitmaps(sbp, rgd);
 		/* Write the updated rgrp to the gfs2 buffer */
-		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-		bmodified(rgd->bits[0].bi_bh);
+		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+		rgd->bits[0].bi_modified = 1;
 		rgs++;
 		if (rgs % 100 == 0) {
 			printf(".");
@@ -986,7 +985,7 @@ static int next_rg_meta(struct rgrp_tree *rgd, uint64_t *block, int
first)
 	}
 	for (; i < length; i++){
 		bits = &rgd->bits[i];
-		blk = gfs2_bitfit((uint8_t *)bits->bi_bh->b_data + bits->bi_offset,
+		blk = gfs2_bitfit((uint8_t *)bits->bi_data + bits->bi_offset,
 		                   bits->bi_len, blk, GFS2_BLKST_DINODE);
 		if(blk != BFITNOENT){
 			*block = blk + (bits->bi_start * GFS2_NBBY) +
@@ -1096,11 +1095,11 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t
root_inode_addr, osi_li
 						sizeof(struct gfs2_rgrp);
 					/* if it's on this page */
 					if (buf_offset + bitmap_byte < sbp->bsize) {
-						bi->bi_bh->b_data[buf_offset + bitmap_byte] &=
-							~(0x03 << (GFS2_BIT_SIZE * byte_bit));
-						bi->bi_bh->b_data[buf_offset + bitmap_byte] |=
-							(0x01 << (GFS2_BIT_SIZE * byte_bit));
-						bmodified(bi->bi_bh);
+						bi->bi_data[buf_offset + bitmap_byte] &=
+						           ~(0x03 << (GFS2_BIT_SIZE * byte_bit));
+						bi->bi_data[buf_offset + bitmap_byte] |=
+						            (0x01 << (GFS2_BIT_SIZE * byte_bit));
+						bi->bi_modified = 1;
 						break;
 					}
 					bitmap_byte -= (sbp->bsize - buf_offset);
@@ -1806,7 +1805,7 @@ static uint64_t rgrp_length(uint64_t size, struct gfs2_sbd *sdp)
 static int journ_space_to_rg(struct gfs2_sbd *sdp)
 {
 	int error = 0;
-	int j, x;
+	int j;
 	struct gfs_jindex *jndx;
 	struct rgrp_tree *rgd, *rgdhigh;
 	struct osi_node *n, *next = NULL;
@@ -1873,16 +1872,21 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
 			exit(-1);
 		}
 
-		for (x = 0; x < rgd->ri.ri_length; x++)
-			rgd->bits[x].bi_bh = bget(sdp, rgd->ri.ri_addr + x);
+		rgd->bits[0].bi_data = calloc(rgd->ri.ri_length, sdp->bsize);
+		if (rgd->bits[0].bi_data == NULL) {
+			perror("");
+			exit(-1);
+		}
+		for (unsigned i = 1; i < rgd->ri.ri_length; i++)
+			rgd->bits[i].bi_data = rgd->bits[0].bi_data + (i * sdp->bsize);
 
 		convert_bitmaps(sdp, rgd);
-		for (x = 0; x < rgd->ri.ri_length; x++) {
-			if (x)
-				gfs2_meta_header_out(&mh, rgd->bits[x].bi_bh->b_data);
-			else
-				gfs2_rgrp_out(&rgd->rg, rgd->bits[x].bi_bh->b_data);
-			bmodified(rgd->bits[x].bi_bh);
+		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+		rgd->bits[0].bi_modified = 1;
+
+		for (unsigned i = 1; i < rgd->ri.ri_length; i++) {
+			gfs2_meta_header_out(&mh, rgd->bits[i].bi_data);
+			rgd->bits[i].bi_modified = 1;
 		}
 	} /* for each journal */
 	return error;
@@ -2341,7 +2345,7 @@ int main(int argc, char **argv)
 		fsync(sb2.device_fd); /* write the buffers to disk */
 
 		/* Now free all the in memory */
-		gfs2_rgrp_free(&sb2.rgtree);
+		gfs2_rgrp_free(&sb2, &sb2.rgtree);
 		log_notice(_("Committing changes to disk.\n"));
 		fflush(stdout);
 		/* Set filesystem type in superblock to gfs2.  We do this at the */
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index ff357fc..b31acd8 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -485,7 +485,7 @@ int display_block_type(struct gfs2_buffer_head *dbh, int
from_restore)
 			}
 		}
 		if (rgd)
-			gfs2_rgrp_relse(rgd);
+			gfs2_rgrp_relse(&sbd, rgd);
  	}
 	if (block == sbd.sd_sb.sb_root_dir.no_addr)
 		print_gfs2("--------------- Root directory ------------------");
@@ -761,7 +761,7 @@ static void rgcount(void)
 	       (unsigned long long)sbd.md.riinode->i_di.di_size /
 	       sizeof(struct gfs2_rindex));
 	inode_put(&sbd.md.riinode);
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	exit(EXIT_SUCCESS);
 }
 
@@ -1256,7 +1256,7 @@ static uint64_t find_metablockoftype_slow(uint64_t startblk, int
metatype, int p
 		else
 			printf("%llu\n", (unsigned long long)blk);
 	}
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	if (print)
 		exit(0);
 	return blk;
@@ -1320,7 +1320,7 @@ static uint64_t find_metablockoftype_rg(uint64_t startblk, int
metatype, int pri
 	if (!rgd) {
 		if (print)
 			printf("0\n");
-		gfs2_rgrp_free(&sbd.rgtree);
+		gfs2_rgrp_free(&sbd, &sbd.rgtree);
 		if (print)
 			exit(-1);
 	}
@@ -1334,7 +1334,7 @@ static uint64_t find_metablockoftype_rg(uint64_t startblk, int
metatype, int pri
 		if (found)
 			break;
 
-		gfs2_rgrp_relse(rgd);
+		gfs2_rgrp_relse(&sbd, rgd);
 	}
 
 	if (!found)
@@ -1345,7 +1345,7 @@ static uint64_t find_metablockoftype_rg(uint64_t startblk, int
metatype, int pri
 		else
 			printf("%llu\n", (unsigned long long)blk);
 	}
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	if (print)
 		exit(0);
 	return blk;
@@ -1379,7 +1379,7 @@ static uint64_t find_metablockoftype(const char *strtype, int
print)
 			"specified: must be one of:\n");
 		fprintf(stderr, "sb rg rb di in lf jd lh ld"
 			" ea ed lb 13 qc\n");
-		gfs2_rgrp_free(&sbd.rgtree);
+		gfs2_rgrp_free(&sbd, &sbd.rgtree);
 		exit(-1);
 	}
 	return blk;
@@ -1695,7 +1695,7 @@ static void find_print_block_type(void)
 	type = get_block_type(lbh, NULL);
 	print_block_type(tblock, type, "");
 	brelse(lbh);
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	exit(0);
 }
 
@@ -1738,7 +1738,7 @@ static void find_print_block_rg(int bitmap)
 			printf("-1 (block invalid or part of an rgrp).\n");
 		}
 	}
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	exit(0);
 }
 
@@ -1759,7 +1759,7 @@ static void find_change_block_alloc(int *newval)
 		       *newval);
 		for (i = GFS2_BLKST_FREE; i <= GFS2_BLKST_DINODE; i++)
 			printf("%d - %s\n", i, allocdesc[sbd.gfs1][i]);
-		gfs2_rgrp_free(&sbd.rgtree);
+		gfs2_rgrp_free(&sbd, &sbd.rgtree);
 		exit(-1);
 	}
 	ablock = blockstack[blockhist % BLOCK_STACK_SIZE].block;
@@ -1783,14 +1783,14 @@ static void find_change_block_alloc(int *newval)
 				}
 				printf("%d (%s)\n", type, allocdesc[sbd.gfs1][type]);
 			}
-			gfs2_rgrp_relse(rgd);
+			gfs2_rgrp_relse(&sbd, rgd);
 		} else {
-			gfs2_rgrp_free(&sbd.rgtree);
+			gfs2_rgrp_free(&sbd, &sbd.rgtree);
 			printf("-1 (block invalid or part of an rgrp).\n");
 			exit(-1);
 		}
 	}
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	if (newval)
 		fsync(sbd.device_fd);
 	exit(0);
@@ -2330,7 +2330,7 @@ static void rg_repair(void)
 	for (n = osi_first(&sbd.rgtree); n; n = osi_next(n)) {
 		rgd = (struct rgrp_tree *)n;
 		if (gfs2_rgrp_read(&sbd, rgd) == 0) { /* was read in okay */
-			gfs2_rgrp_relse(rgd);
+			gfs2_rgrp_relse(&sbd, rgd);
 			continue; /* ignore it */
 		}
 		/* If we get here, it's because we have an rgrp in the rindex
@@ -2522,7 +2522,7 @@ static void process_parameters(int argc, char *argv[], int pass)
 				printf("Error: field not specified.\n");
 				printf("Format is: %s -p <block> field "
 				       "<field> [newvalue]\n", argv[0]);
-				gfs2_rgrp_free(&sbd.rgtree);
+				gfs2_rgrp_free(&sbd, &sbd.rgtree);
 				exit(EXIT_FAILURE);
 			}
 			process_field(argv[i], argv[i + 1]);
@@ -2555,7 +2555,7 @@ static void process_parameters(int argc, char *argv[], int pass)
 				printf("Error: rg # not specified.\n");
 				printf("Format is: %s rgflags rgnum"
 				       "[newvalue]\n", argv[0]);
-				gfs2_rgrp_free(&sbd.rgtree);
+				gfs2_rgrp_free(&sbd, &sbd.rgtree);
 				exit(EXIT_FAILURE);
 			}
 			if (argv[i][0]=='0' && argv[i][1]=='x')
@@ -2572,16 +2572,16 @@ static void process_parameters(int argc, char *argv[], int pass)
 					new_flags = atoi(argv[i]);
 			}
 			set_rgrp_flags(rg, new_flags, set, FALSE);
-			gfs2_rgrp_free(&sbd.rgtree);
+			gfs2_rgrp_free(&sbd, &sbd.rgtree);
 			exit(EXIT_SUCCESS);
 		} else if (!strcmp(argv[i], "rg")) {
 			int rg;
-				
+
 			i++;
 			if (i >= argc - 1) {
 				printf("Error: rg # not specified.\n");
 				printf("Format is: %s rg rgnum\n", argv[0]);
-				gfs2_rgrp_free(&sbd.rgtree);
+				gfs2_rgrp_free(&sbd, &sbd.rgtree);
 				exit(EXIT_FAILURE);
 			}
 			rg = atoi(argv[i]);
@@ -2590,7 +2590,7 @@ static void process_parameters(int argc, char *argv[], int pass)
 				push_block(temp_blk);
 			} else {
 				set_rgrp_flags(rg, 0, FALSE, TRUE);
-				gfs2_rgrp_free(&sbd.rgtree);
+				gfs2_rgrp_free(&sbd, &sbd.rgtree);
 				exit(EXIT_SUCCESS);
 			}
 		} else if (!strcmp(argv[i], "rgbitmaps")) {
@@ -2603,7 +2603,7 @@ static void process_parameters(int argc, char *argv[], int pass)
 				printf("Error: rg # not specified.\n");
 				printf("Format is: %s rgbitmaps rgnum\n",
 				       argv[0]);
-				gfs2_rgrp_free(&sbd.rgtree);
+				gfs2_rgrp_free(&sbd, &sbd.rgtree);
 				exit(EXIT_FAILURE);
 			}
 			rg = atoi(argv[i]);
@@ -2611,7 +2611,7 @@ static void process_parameters(int argc, char *argv[], int pass)
 			rgd = gfs2_blk2rgrpd(&sbd, rgblk);
 			if (rgd == NULL) {
 				printf("Error: rg # is invalid.\n");
-				gfs2_rgrp_free(&sbd.rgtree);
+				gfs2_rgrp_free(&sbd, &sbd.rgtree);
 				exit(EXIT_FAILURE);
 			}
 			for (bmap = 0; bmap < rgd->ri.ri_length; bmap++)
@@ -2717,6 +2717,6 @@ int main(int argc, char *argv[])
 	close(fd);
 	if (indirect)
 		free(indirect);
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
  	exit(EXIT_SUCCESS);
 }
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 6364761..9139855 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -253,7 +253,7 @@ static int print_ld_blks(const uint64_t *b, const char *end, int
start_line,
 			if (tblk && rgd && (be64_to_cpu(*b) == bitblk)) {
 				int type, bmap = 0;
 				uint64_t o;
-				struct gfs2_buffer_head *save_bh;
+				char *save_ptr;
 
 				found_bblk = 1;
 				print_gfs2("<-------------------------");
@@ -266,17 +266,17 @@ static int print_ld_blks(const uint64_t *b, const char *end, int
start_line,
 						      sizeof(struct gfs2_meta_header))
 							* GFS2_NBBY;
 					bmap = o / sbd.sd_blocks_per_bitmap;
-					save_bh = rgd->bits[bmap].bi_bh;
+					save_ptr = rgd->bits[bmap].bi_data;
 					j_bmap_bh = bread(&sbd, abs_block +
 							  bcount);
-					rgd->bits[bmap].bi_bh = j_bmap_bh;
+					rgd->bits[bmap].bi_data = j_bmap_bh->b_data;
 					type = lgfs2_get_bitmap(&sbd, tblk, rgd);
 					brelse(j_bmap_bh);
 					if (type < 0) {
 						perror("Error printing log descriptor blocks");
 						exit(1);
 					}
-					rgd->bits[bmap].bi_bh = save_bh;
+					rgd->bits[bmap].bi_data = save_ptr;
 					print_gfs2("bit for blk 0x%llx is %d "
 						   "(%s)",
 						   (unsigned long long)tblk,
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 846b615..11c8355 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -896,28 +896,28 @@ static void save_allocated(struct rgrp_tree *rgd, struct metafd
*mfd)
    want to save rgrp headers even if they're corrupt. */
 static int rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
 {
-	unsigned x, length = rgd->ri.ri_length;
-	struct gfs2_buffer_head **bhs;
+	unsigned length = rgd->ri.ri_length * sdp->bsize;
+	off_t off = rgd->ri.ri_addr * sdp->bsize;
+	char *buf;
 
 	if (length == 0 || gfs2_check_range(sdp, rgd->ri.ri_addr))
 		return -1;
 
-	bhs = calloc(length, sizeof(struct gfs2_buffer_head *));
-	if (bhs == NULL)
+	buf = calloc(1, length);
+	if (buf == NULL)
 		return -1;
 
-	if (breadm(sdp, bhs, length, rgd->ri.ri_addr)) {
-		free(bhs);
+	if (pread(sdp->device_fd, buf, length, off) != length) {
+		free(buf);
 		return -1;
 	}
-	for (x = 0; x < length; x++)
-		rgd->bits[x].bi_bh = bhs[x];
+	for (unsigned i = 0; i < rgd->ri.ri_length; i++)
+		rgd->bits[i].bi_data = buf + (i * sdp->bsize);
 
 	if (sdp->gfs1)
-		gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+		gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 	else
-		gfs2_rgrp_in(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-	free(bhs);
+		gfs2_rgrp_in(&rgd->rg, rgd->bits[0].bi_data);
 	return 0;
 }
 
@@ -932,13 +932,17 @@ static void save_rgrp(struct metafd *mfd, struct rgrp_tree *rgd, int
withcontent
 		  addr, addr, rgd->ri.ri_length);
 	/* Save the rg and bitmaps */
 	for (i = 0; i < rgd->ri.ri_length; i++) {
+		struct gfs2_buffer_head tmpbh = {
+			.b_data = rgd->bits[i].bi_data,
+			.b_blocknr = rgd->ri.ri_addr + i
+		};
 		warm_fuzzy_stuff(rgd->ri.ri_addr + i, FALSE);
-		save_bh(mfd, rgd->bits[i].bi_bh, 0, NULL);
+		save_bh(mfd, &tmpbh, 0, NULL);
 	}
 	/* Save the other metadata: inodes, etc. if mode is not 'savergs' */
 	if (withcontents)
 		save_allocated(rgd, mfd);
-	gfs2_rgrp_relse(rgd);
+	gfs2_rgrp_relse(&sbd, rgd);
 }
 
 static int save_header(struct metafd *mfd, uint64_t fsbytes)
@@ -1054,7 +1058,7 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
 	close(sbd.device_fd);
 	destroy_per_node_lookup();
 	free(indirect);
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	exit(0);
 }
 
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 0e029db..bc9fec3 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -104,16 +104,16 @@ static void refresh_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd,
 	log_debug(_("Block is part of rgrp 0x%llx; refreshing the rgrp.\n"),
 		  (unsigned long long)rgd->ri.ri_addr);
 	for (i = 0; i < rgd->ri.ri_length; i++) {
-		if (rgd->bits[i].bi_bh->b_blocknr != blkno)
+		if (rgd->ri.ri_addr + i != blkno)
 			continue;
 
-		memcpy(rgd->bits[i].bi_bh->b_data, bh->b_data, sdp->bsize);
-		bmodified(rgd->bits[i].bi_bh);
+		memcpy(rgd->bits[i].bi_data, bh->b_data, sdp->bsize);
+		rgd->bits[i].bi_modified = 1;
 		if (i == 0) { /* this is the rgrp itself */
 			if (sdp->gfs1)
-				gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+				gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 			else
-				gfs2_rgrp_in(&rgd->rg, rgd->bits[0].bi_bh->b_data);
+				gfs2_rgrp_in(&rgd->rg, rgd->bits[0].bi_data);
 		}
 		break;
 	}
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 374117b..ecda56e 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -113,7 +113,7 @@ static void gfs2_inodetree_free(void)
 static void empty_super_block(struct gfs2_sbd *sdp)
 {
 	log_info( _("Freeing buffers.\n"));
-	gfs2_rgrp_free(&sdp->rgtree);
+	gfs2_rgrp_free(sdp, &sdp->rgtree);
 
 	gfs2_inodetree_free();
 	gfs2_dirtree_free();
@@ -223,7 +223,7 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 		for (x = 0; x < bytes_to_check; x++) {
 			unsigned char *byte;
 
-			byte = (unsigned char *)&rgd->bits[rgb].bi_bh->b_data[off + x];
+			byte = (unsigned char *)&rgd->bits[rgb].bi_data[off + x];
 			if (*byte == 0x55) {
 				diblock += GFS2_NBBY;
 				continue;
@@ -287,7 +287,7 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 				}
 				*byte &= ~(GFS2_BIT_MASK <<
 					   (GFS2_BIT_SIZE * y));
-				bmodified(rgd->bits[rgb].bi_bh);
+				rgd->bits[rgb].bi_modified = 1;
 				rg_reclaimed++;
 				rg_free++;
 				rgd->rg.rg_free++;
@@ -324,10 +324,10 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 	   will be reported. */
 	if (rg_reclaimed && *fixit) {
 		if (sdp->gfs1)
-			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 		else
-			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-		bmodified(rgd->bits[0].bi_bh);
+			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+		rgd->bits[0].bi_modified = 1;
 		*this_rg_cleaned = 1;
 		log_info( _("The rgrp at %lld (0x%llx) was cleaned of %d "
 			    "free metadata blocks.\n"),
@@ -346,10 +346,10 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 		if (query( _("Fix the rgrp free blocks count? (y/n)"))) {
 			rgd->rg.rg_free = rg_free;
 			if (sdp->gfs1)
-				gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+				gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 			else
-				gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-			bmodified(rgd->bits[0].bi_bh);
+				gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+			rgd->bits[0].bi_modified = 1;
 			*this_rg_fixed = 1;
 			log_err( _("The rgrp was fixed.\n"));
 		} else
@@ -368,8 +368,8 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 			 gfs1rg->rg_freemeta, rg_unlinked);
 		if (query( _("Fix the rgrp free meta blocks count? (y/n)"))) {
 			gfs1rg->rg_freemeta = rg_unlinked;
-			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
-			bmodified(rgd->bits[0].bi_bh);
+			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+			rgd->bits[0].bi_modified = 1;
 			*this_rg_fixed = 1;
 			log_err( _("The rgrp was fixed.\n"));
 		} else
@@ -385,8 +385,8 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 			 gfs1rg->rg_useddi, rg_useddi);
 		if (query( _("Fix the rgrp used dinode block count? (y/n)"))) {
 			gfs1rg->rg_useddi = rg_useddi;
-			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
-			bmodified(rgd->bits[0].bi_bh);
+			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+			rgd->bits[0].bi_modified = 1;
 			*this_rg_fixed = 1;
 			log_err( _("The rgrp was fixed.\n"));
 		} else
@@ -402,8 +402,8 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
 			 gfs1rg->rg_usedmeta, rg_usedmeta);
 		if (query( _("Fix the rgrp used meta blocks count? (y/n)"))) {
 			gfs1rg->rg_usedmeta = rg_usedmeta;
-			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
-			bmodified(rgd->bits[0].bi_bh);
+			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+			rgd->bits[0].bi_modified = 1;
 			*this_rg_fixed = 1;
 			log_err( _("The rgrp was fixed.\n"));
 		} else
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 8729d48..265fa76 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -155,10 +155,10 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
 	}
 	if (rewrite_rgrp) {
 		if (sdp->gfs1)
-			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 		else
-			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-		bmodified(rgd->bits[0].bi_bh);
+			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+		rgd->bits[0].bi_modified = 1;
 	}
 	log_err( _("The bitmap was fixed.\n"));
 	return 0;
diff --git a/gfs2/fsck/pass5.c b/gfs2/fsck/pass5.c
index 8e3f37c..33265bf 100644
--- a/gfs2/fsck/pass5.c
+++ b/gfs2/fsck/pass5.c
@@ -139,7 +139,7 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgp,
 		bits = &rgp->bits[i];
 
 		/* update the bitmaps */
-		if (check_block_status(sdp, bl, bits->bi_bh->b_data + bits->bi_offset,
+		if (check_block_status(sdp, bl, bits->bi_data + bits->bi_offset,
 		                       bits->bi_len, &rg_block, rgp->ri.ri_data0, count))
 			return;
 		if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
@@ -201,9 +201,10 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgp,
 			log_warn( _("Resource group counts updated\n"));
 			/* write out the rgrp */
 			if (sdp->gfs1)
-				gfs_rgrp_out(gfs1rg, rgp->bits[0].bi_bh->b_data);
+				gfs_rgrp_out(gfs1rg, rgp->bits[0].bi_data);
 			else
-				gfs2_rgrp_out(&rgp->rg, rgp->bits[0].bi_bh->b_data);
+				gfs2_rgrp_out(&rgp->rg, rgp->bits[0].bi_data);
+			rgp->bits[0].bi_modified = 1;
 		} else
 			log_err( _("Resource group counts left inconsistent\n"));
 	}
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 97d3a90..ce0e48e 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -490,8 +490,8 @@ static uint64_t hunt_and_peck(struct gfs2_sbd *sdp, uint64_t blk,
 }
 
 /*
- * gfs2_rindex_rebuild - rebuild a corrupt Resource Group (RG) index manually
- *                        where trust_lvl == distrust
+ * rindex_rebuild - rebuild a corrupt Resource Group (RG) index manually
+ *                  where trust_lvl == distrust
  *
  * If this routine is called, it means we have RGs in odd/unexpected places,
  * and there is a corrupt RG or RG index entry.  It also means we can't trust
@@ -517,8 +517,7 @@ static uint64_t hunt_and_peck(struct gfs2_sbd *sdp, uint64_t blk,
  * from gfs1 to gfs2 after a gfs_grow operation.  In that case, the rgrps
  * will not be on predictable boundaries.
  */
-static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
-			       int gfs_grow)
+static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int gfs_grow)
 {
 	struct osi_node *n, *next = NULL;
 	struct gfs2_buffer_head *bh;
@@ -601,8 +600,7 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 			else
 				break; /* end of bitmap, so call it quits. */
 		} /* for subsequent bitmaps */
-		
-		gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, calc_rgd);
+
 		calc_rgd->ri.ri_data0 = calc_rgd->ri.ri_addr +
 			calc_rgd->ri.ri_length;
 		if (prev_rgd) {
@@ -700,6 +698,7 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 out:
 	for (j = 0; j < sdp->md.journals; j++)
 		inode_put(&sdp->md.journal[j]);
+	inode_put(&sdp->md.jiinode);
 	free(sdp->md.journal);
 	return error;
 }
@@ -865,7 +864,7 @@ static int gfs2_rindex_calculate(struct gfs2_sbd *sdp, int *num_rgs)
 	}
 	/* Compute the default resource group layout as mkfs would have done */
 	compute_rgrp_layout(sdp, &sdp->rgcalc, TRUE);
-	if (build_rgrps(sdp, FALSE)) { /* FALSE = calc but don't write to disk. */
+	if (build_rgrps(sdp)) { /* Calculate but don't write to disk. */
 		fprintf(stderr, _("Failed to build resource groups\n"));
 		exit(-1);
 	}
@@ -884,41 +883,60 @@ static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree
*rg,
 {
 	int x = errblock - rg->ri.ri_addr;
 	const char *typedesc = x ? "GFS2_METATYPE_RB" : "GFS2_METATYPE_RG";
+	ssize_t ret;
+	char *buf;
 
 	log_err( _("Block #%lld (0x%llx) (%d of %d) is not %s.\n"),
 		 (unsigned long long)rg->ri.ri_addr + x,
 		 (unsigned long long)rg->ri.ri_addr + x,
 		 (int)x+1, (int)rg->ri.ri_length, typedesc);
-	if (query( _("Fix the Resource Group? (y/n)"))) {
-		log_err( _("Attempting to repair the rgrp.\n"));
-		rg->bits[x].bi_bh = bread(sdp, rg->ri.ri_addr + x);
-		if (x) {
-			struct gfs2_meta_header mh;
-
-			mh.mh_magic = GFS2_MAGIC;
-			mh.mh_type = GFS2_METATYPE_RB;
-			mh.mh_format = GFS2_FORMAT_RB;
-			gfs2_meta_header_out(&mh, rg->bits[x].bi_bh->b_data);
-		} else {
-			if (sdp->gfs1)
-				memset(&rg->rg, 0, sizeof(struct gfs_rgrp));
-			else
-				memset(&rg->rg, 0, sizeof(struct gfs2_rgrp));
-			rg->rg.rg_header.mh_magic = GFS2_MAGIC;
-			rg->rg.rg_header.mh_type = GFS2_METATYPE_RG;
-			rg->rg.rg_header.mh_format = GFS2_FORMAT_RG;
-			rg->rg.rg_free = rg->ri.ri_data;
-			if (sdp->gfs1)
-				gfs_rgrp_out((struct gfs_rgrp *)&rg->rg, rg->bits[x].bi_bh->b_data);
-			else
-				gfs2_rgrp_out(&rg->rg, rg->bits[x].bi_bh->b_data);
-		}
-		bmodified(rg->bits[x].bi_bh);
-		brelse(rg->bits[x].bi_bh);
-		rg->bits[x].bi_bh = NULL;
-		return 0;
+	if (!query( _("Fix the resource group? (y/n)")))
+		return 1;
+
+	log_err(_("Attempting to repair the resource group.\n"));
+
+	buf = calloc(1, sdp->bsize);
+	if (buf == NULL) {
+		log_err(_("Failed to allocate resource group block: %s"), strerror(errno));
+		return 1;
 	}
-	return 1;
+	ret = pread(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
+	if (ret != sdp->bsize) {
+		log_err(_("Failed to read resource group block %"PRIu64": %s\n"),
+		        errblock, strerror(errno));
+		free(buf);
+		return 1;
+	}
+	if (x) {
+		struct gfs2_meta_header mh = {
+			.mh_magic = GFS2_MAGIC,
+			.mh_type = GFS2_METATYPE_RB,
+			.mh_format = GFS2_FORMAT_RB
+		};
+		gfs2_meta_header_out(&mh, buf);
+	} else {
+		if (sdp->gfs1)
+			memset(&rg->rg, 0, sizeof(struct gfs_rgrp));
+		else
+			memset(&rg->rg, 0, sizeof(struct gfs2_rgrp));
+		rg->rg.rg_header.mh_magic = GFS2_MAGIC;
+		rg->rg.rg_header.mh_type = GFS2_METATYPE_RG;
+		rg->rg.rg_header.mh_format = GFS2_FORMAT_RG;
+		rg->rg.rg_free = rg->ri.ri_data;
+		if (sdp->gfs1)
+			gfs_rgrp_out((struct gfs_rgrp *)&rg->rg, buf);
+		else
+			gfs2_rgrp_out(&rg->rg, buf);
+	}
+	ret = pwrite(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
+	if (ret != sdp->bsize) {
+		log_err(_("Failed to write resource group block %"PRIu64": %s\n"),
+		        errblock, strerror(errno));
+		free(buf);
+		return 1;
+	}
+	free(buf);
+	return 0;
 }
 
 /*
@@ -982,37 +1000,37 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count,
int *sane)
 		}
 		error = expect_rindex_sanity(sdp, &calc_rg_count);
 		if (error) {
-			gfs2_rgrp_free(&sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
 			return error;
 		}
 	} else if (trust_lvl == open_minded) { /* If we can't trust RG index */
 		/* Free previous incarnations in memory, if any. */
-		gfs2_rgrp_free(&sdp->rgtree);
+		gfs2_rgrp_free(sdp, &sdp->rgtree);
 
 		/* Calculate our own RG index for comparison */
 		error = gfs2_rindex_calculate(sdp, &calc_rg_count);
 		if (error) { /* If calculated RGs don't match the fs */
-			gfs2_rgrp_free(&sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
 			return -1;
 		}
 	} else if (trust_lvl == distrust) { /* If we can't trust RG index */
 		/* Free previous incarnations in memory, if any. */
-		gfs2_rgrp_free(&sdp->rgtree);
+		gfs2_rgrp_free(sdp, &sdp->rgtree);
 
-		error = gfs2_rindex_rebuild(sdp, &calc_rg_count, 0);
+		error = rindex_rebuild(sdp, &calc_rg_count, 0);
 		if (error) {
 			log_crit( _("Error rebuilding rgrp list.\n"));
-			gfs2_rgrp_free(&sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
 			return -1;
 		}
 	} else if (trust_lvl == indignation) { /* If we can't trust anything */
 		/* Free previous incarnations in memory, if any. */
-		gfs2_rgrp_free(&sdp->rgtree);
+		gfs2_rgrp_free(sdp, &sdp->rgtree);
 
-		error = gfs2_rindex_rebuild(sdp, &calc_rg_count, 1);
+		error = rindex_rebuild(sdp, &calc_rg_count, 1);
 		if (error) {
 			log_crit( _("Error rebuilding rgrp list.\n"));
-			gfs2_rgrp_free(&sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
 			return -1;
 		}
 	}
@@ -1023,8 +1041,8 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count,
int *sane)
 		log_warn( _("WARNING: rindex file has an invalid size.\n"));
 		if (!query( _("Truncate the rindex size? (y/n)"))) {
 			log_err(_("The rindex was not repaired.\n"));
-			gfs2_rgrp_free(&sdp->rgcalc);
-			gfs2_rgrp_free(&sdp->rgtree);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgtree);
 			return -1;
 		}
 		sdp->md.riinode->i_di.di_size /= sizeof(struct gfs2_rindex);
@@ -1048,8 +1066,8 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count,
int *sane)
 		   then try again with a little more distrust. */
 		if ((trust_lvl < distrust) ||
 		    !query( _("Attempt to use what rgrps we can? (y/n)"))) {
-			gfs2_rgrp_free(&sdp->rgcalc);
-			gfs2_rgrp_free(&sdp->rgtree);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgtree);
 			log_err(_("The rindex was not repaired.\n"));
 			return -1;
 		}
@@ -1118,8 +1136,8 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count,
int *sane)
 			log_warn( _("%d out of %d rgrps (%d percent) did not "
 				    "match what was expected.\n"),
 				  discrepancies, rg, percent);
-			gfs2_rgrp_free(&sdp->rgcalc);
-			gfs2_rgrp_free(&sdp->rgtree);
+			gfs2_rgrp_free(sdp, &sdp->rgcalc);
+			gfs2_rgrp_free(sdp, &sdp->rgtree);
 			return -1;
 		}
 	}
@@ -1224,15 +1242,15 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count,
int *sane)
 				prev_err = errblock;
 				rewrite_rg_block(sdp, rgd, errblock);
 			} else {
-				gfs2_rgrp_relse(rgd);
+				gfs2_rgrp_relse(sdp, rgd);
 				break;
 			}
 			i++;
 		} while (i < rgd->ri.ri_length);
 	}
 	*rg_count = rg;
-	gfs2_rgrp_free(&sdp->rgcalc);
-	gfs2_rgrp_free(&sdp->rgtree);
+	gfs2_rgrp_free(sdp, &sdp->rgcalc);
+	gfs2_rgrp_free(sdp, &sdp->rgtree);
 	/* We shouldn't need to worry about getting the user's permission to
 	   make changes here. If b_modified is true, they already gave their
 	   permission. */
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 1c3ed9c..0c3d68f 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -555,7 +555,6 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
 	struct gfs2_rgrp *rg;
 	unsigned int block, bn = 0, x = 0, y = 0;
 	unsigned int state;
-	struct gfs2_buffer_head *bh;
 
 	memset(&rg, 0, sizeof(rg));
 	for (n = osi_first(&sdp->rgtree); n; n = next) {
@@ -572,12 +571,12 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
 	rg = &rl->rg;
 
 	for (block = 0; block < ri->ri_length; block++) {
-		bh = rl->bits[block].bi_bh;
+		char *buf = rl->bits[block].bi_data;
 		x = (block) ? sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_rgrp);
 
 		for (; x < sdp->bsize; x++)
 			for (y = 0; y < GFS2_NBBY; y++) {
-				state = (bh->b_data[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
+				state = (buf[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
 				if (state == GFS2_BLKST_FREE)
 					return ri->ri_data0 + bn;
 				bn++;
diff --git a/gfs2/libgfs2/fs_bits.c b/gfs2/libgfs2/fs_bits.c
index e6aef55..f600f6e 100644
--- a/gfs2/libgfs2/fs_bits.c
+++ b/gfs2/libgfs2/fs_bits.c
@@ -148,7 +148,7 @@ int gfs2_set_bitmap(lgfs2_rgrp_t rgd, uint64_t blkno, int state)
 
 	if (bits == NULL)
 		return -1;
-	byte = (unsigned char *)(bits->bi_bh->b_data + bits->bi_offset) +
+	byte = (unsigned char *)(bits->bi_data + bits->bi_offset) +
 		(rgrp_block/GFS2_NBBY - bits->bi_start);
 	bit = (rgrp_block % GFS2_NBBY) * GFS2_BIT_SIZE;
 
@@ -156,7 +156,7 @@ int gfs2_set_bitmap(lgfs2_rgrp_t rgd, uint64_t blkno, int state)
 	*byte ^= cur_state << bit;
 	*byte |= state << bit;
 
-	bmodified(bits->bi_bh);
+	bits->bi_modified = 1;
 	return 0;
 }
 
@@ -207,10 +207,10 @@ int lgfs2_get_bitmap(struct gfs2_sbd *sdp, uint64_t blkno, struct
rgrp_tree *rgd
 	}
 
 	bi = &rgd->bits[i];
-	if (!bi->bi_bh)
+	if (bi->bi_data == NULL)
 		return GFS2_BLKST_FREE;
 
-	byte = (bi->bi_bh->b_data + bi->bi_offset) + (offset/GFS2_NBBY);
+	byte = (bi->bi_data + bi->bi_offset) + (offset/GFS2_NBBY);
 	bit = (offset % GFS2_NBBY) * GFS2_BIT_SIZE;
 
 	return (*byte >> bit) & GFS2_BIT_MASK;
diff --git a/gfs2/libgfs2/fs_geometry.c b/gfs2/libgfs2/fs_geometry.c
index df8a13a..7de6e77 100644
--- a/gfs2/libgfs2/fs_geometry.c
+++ b/gfs2/libgfs2/fs_geometry.c
@@ -46,24 +46,14 @@ uint32_t rgblocks2bitblocks(const unsigned int bsize, const uint32_t
rgblocks, u
  * If fd > 0, write the data to the given file handle.
  * Otherwise, use gfs2 buffering in buf.c.
  */
-int build_rgrps(struct gfs2_sbd *sdp, int do_write)
+int build_rgrps(struct gfs2_sbd *sdp)
 {
 	struct osi_node *n, *next = NULL;
 	struct rgrp_tree *rl;
 	uint32_t rgblocks, bitblocks;
 	struct gfs2_rindex *ri;
-	struct gfs2_meta_header mh;
-	unsigned int x;
 
-	mh.mh_magic = GFS2_MAGIC;
-	mh.mh_type = GFS2_METATYPE_RB;
-	mh.mh_format = GFS2_FORMAT_RB;
-	if (do_write)
-		n = osi_first(&sdp->rgtree);
-	else
-		n = osi_first(&sdp->rgcalc);
-
-	for (; n; n = next) {
+	for (n = osi_first(&sdp->rgcalc); n; n = next) {
 		next = osi_next(n);
 		rl = (struct rgrp_tree *)n;
 		ri = &rl->ri;
@@ -85,17 +75,6 @@ int build_rgrps(struct gfs2_sbd *sdp, int do_write)
 		if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rl))
 			return -1;
 
-		if (do_write) {
-			for (x = 0; x < bitblocks; x++) {
-				rl->bits[x].bi_bh = bget(sdp, rl->start + x);
-				if (x)
-					gfs2_meta_header_out(&mh, rl->bits[x].bi_bh->b_data);
-				else
-					gfs2_rgrp_out(&rl->rg, rl->bits[x].bi_bh->b_data);
-				bmodified(rl->bits[x].bi_bh);
-			}
-		}
-
 		if (cfg_debug) {
 			printf("\n");
 			gfs2_rindex_print(ri);
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index b2ea003..b5363c0 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -127,7 +127,7 @@ static uint64_t find_free_block(struct rgrp_tree *rgd)
 		unsigned long blk = 0;
 		struct gfs2_bitmap *bits = &rgd->bits[bm];
 
-		blk = gfs2_bitfit((uint8_t *)bits->bi_bh->b_data + bits->bi_offset,
+		blk = gfs2_bitfit((uint8_t *)bits->bi_data + bits->bi_offset,
 		                  bits->bi_len, blk, GFS2_BLKST_FREE);
 		if (blk != BFITNOENT) {
 			blkno = blk + (bits->bi_start * GFS2_NBBY) + rgd->ri.ri_data0;
@@ -156,10 +156,10 @@ static int blk_alloc_in_rg(struct gfs2_sbd *sdp, unsigned state,
struct rgrp_tre
 
 	rgd->rg.rg_free--;
 	if (sdp->gfs1)
-		gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+		gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 	else
-		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-	bmodified(rgd->bits[0].bi_bh);
+		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+	rgd->bits[0].bi_modified = 1;
 	sdp->blks_alloced++;
 	return 0;
 }
@@ -185,7 +185,7 @@ static int block_alloc(struct gfs2_sbd *sdp, const uint64_t blksreq,
int state,
 	if (rgt == NULL)
 		return -1;
 
-	if (rgt->bits[0].bi_bh == NULL) {
+	if (rgt->bits[0].bi_data == NULL) {
 		if (gfs2_rgrp_read(sdp, rgt))
 			return -1;
 		release = 1;
@@ -194,7 +194,7 @@ static int block_alloc(struct gfs2_sbd *sdp, const uint64_t blksreq,
int state,
 	bn = find_free_block(rgt);
 	ret = blk_alloc_in_rg(sdp, state, rgt, bn, dinode);
 	if (release)
-		gfs2_rgrp_relse(rgt);
+		gfs2_rgrp_relse(sdp, rgt);
 	*blkno = bn;
 	return ret;
 }
@@ -1928,10 +1928,10 @@ void gfs2_free_block(struct gfs2_sbd *sdp, uint64_t block)
 		gfs2_set_bitmap(rgd, block, GFS2_BLKST_FREE);
 		rgd->rg.rg_free++; /* adjust the free count */
 		if (sdp->gfs1)
-			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 		else
-			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-		bmodified(rgd->bits[0].bi_bh);
+			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+		rgd->bits[0].bi_modified = 1;
 		sdp->blks_alloced--;
 	}
 }
@@ -1998,10 +1998,10 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
 	rgd->rg.rg_free++;
 	rgd->rg.rg_dinodes--;
 	if (sdp->gfs1)
-		gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+		gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
 	else
-		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);
-	bmodified(rgd->bits[0].bi_bh);
+		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+	rgd->bits[0].bi_modified = 1;
 	sdp->dinodes_alloced--;
 	return 0;
 }
diff --git a/gfs2/libgfs2/gfs2l.c b/gfs2/libgfs2/gfs2l.c
index a8aa5fa..ba2d5f1 100644
--- a/gfs2/libgfs2/gfs2l.c
+++ b/gfs2/libgfs2/gfs2l.c
@@ -182,7 +182,7 @@ int main(int argc, char *argv[])
 		lgfs2_lang_result_free(&result);
 	}
 
-	gfs2_rgrp_free(&sbd.rgtree);
+	gfs2_rgrp_free(&sbd, &sbd.rgtree);
 	inode_put(&sbd.md.riinode);
 	inode_put(&sbd.master_dir);
 	lgfs2_lang_free(&state);
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 62ad2ab..69a98aa 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -386,7 +386,7 @@ static int ast_get_bitstate(uint64_t bn, struct gfs2_sbd *sbd)
 		return -1;
 	}
 
-	gfs2_rgrp_relse(rgd);
+	gfs2_rgrp_relse(sbd, rgd);
 	return state;
 }
 
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 0f2ddf4..cf225af 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -171,10 +171,11 @@ struct device {
 
 struct gfs2_bitmap
 {
-	struct gfs2_buffer_head *bi_bh;
-	uint32_t   bi_offset;  /* The offset in the buffer of the first byte */
-	uint32_t   bi_start;   /* The position of the first byte in this block */
-	uint32_t   bi_len;     /* The number of bytes in this block */
+	char *bi_data;
+	uint32_t bi_offset;  /* The offset in the buffer of the first byte */
+	uint32_t bi_start;   /* The position of the first byte in this block */
+	uint32_t bi_len;     /* The number of bytes in this block */
+	unsigned bi_modified:1;
 };
 
 struct gfs2_sbd;
@@ -403,7 +404,7 @@ extern int gfs2_set_bitmap(lgfs2_rgrp_t rg, uint64_t blkno, int
state);
 /* fs_geometry.c */
 extern uint32_t rgblocks2bitblocks(const unsigned int bsize, const uint32_t rgblocks,
                                     uint32_t *ri_data) __attribute__((nonnull(3)));
-extern int build_rgrps(struct gfs2_sbd *sdp, int write);
+extern int build_rgrps(struct gfs2_sbd *sdp);
 
 /* fs_ops.c */
 #define IS_LEAF     (1)
@@ -673,10 +674,10 @@ extern struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp,
uint64_t blk);
 extern int lgfs2_rgrp_crc_check(char *buf);
 extern void lgfs2_rgrp_crc_set(char *buf);
 extern uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd);
-extern void gfs2_rgrp_relse(struct rgrp_tree *rgd);
+extern void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd);
 extern struct rgrp_tree *rgrp_insert(struct osi_root *rgtree,
 				     uint64_t rgblock);
-extern void gfs2_rgrp_free(struct osi_root *rgrp_tree);
+extern void gfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root *rgrp_tree);
 /* figure out the size of the given resource group, in blocks */
 static inline unsigned int rgrp_size(struct rgrp_tree *rgrp)
 {
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index 164b341..7f7f83f 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -10,7 +10,6 @@
 #include "libgfs2.h"
 #include "rgrp.h"
 
-#define RG_SYNC_TOLERANCE 1000
 #define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
 
 static void compute_bitmaps(lgfs2_rgrp_t rg, const unsigned bsize)
@@ -61,7 +60,7 @@ int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree
*rgd)
 
 	compute_bitmaps(rgd, bsize);
 	bytes_left = rgd->ri.ri_bitbytes - (rgd->bits[rgd->ri.ri_length - 1].bi_start
+
-	                                   rgd->bits[rgd->ri.ri_length - 1].bi_len);
+	                                    rgd->bits[rgd->ri.ri_length - 1].bi_len);
 	errno = EINVAL;
 	if(bytes_left)
 		goto errbits;
@@ -110,7 +109,6 @@ struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk)
 int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
 {
 	struct gfs2_sbd *sdp = rg->rgrps->sdp;
-	struct gfs2_buffer_head *bhs;
 	size_t len = rg->ri.ri_length * sdp->bsize;
 	unsigned long io_align = sdp->bsize;
 	unsigned i;
@@ -120,23 +118,15 @@ int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
 		len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
 		io_align = rg->rgrps->align_off * sdp->bsize;
 	}
-	bhs = calloc(rg->ri.ri_length, sizeof(struct gfs2_buffer_head));
-	if (bhs == NULL)
-		return 1;
-
 	if (posix_memalign((void **)&bufs, io_align, len) != 0) {
 		errno = ENOMEM;
-		free(bhs);
 		return 1;
 	}
 	memset(bufs, 0, len);
 
 	for (i = 0; i < rg->ri.ri_length; i++) {
-		rg->bits[i].bi_bh = bhs + i;
-		rg->bits[i].bi_bh->iov.iov_base = bufs + (i * sdp->bsize);
-		rg->bits[i].bi_bh->iov.iov_len = sdp->bsize;
-		rg->bits[i].bi_bh->b_blocknr = rg->ri.ri_addr + i;
-		rg->bits[i].bi_bh->sdp = sdp;
+		rg->bits[i].bi_data = bufs + (i * sdp->bsize);
+		rg->bits[i].bi_modified = 0;
 	}
 	return 0;
 }
@@ -151,10 +141,12 @@ int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
 void lgfs2_rgrp_bitbuf_free(lgfs2_rgrp_t rg)
 {
 	unsigned i;
-	free(rg->bits[0].bi_bh->iov.iov_base);
-	free(rg->bits[0].bi_bh);
-	for (i = 0; i < rg->ri.ri_length; i++)
-		rg->bits[i].bi_bh = NULL;
+
+	free(rg->bits[0].bi_data);
+	for (i = 0; i < rg->ri.ri_length; i++) {
+		rg->bits[i].bi_data = NULL;
+		rg->bits[i].bi_modified = 0;
+	}
 }
 
 /**
@@ -201,61 +193,64 @@ void lgfs2_rgrp_crc_set(char *buf)
  */
 uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
 {
-	unsigned x, length = rgd->ri.ri_length;
-	struct gfs2_buffer_head **bhs;
+	unsigned length = rgd->ri.ri_length * sdp->bsize;
+	off_t offset = rgd->ri.ri_addr * sdp->bsize;
+	char *buf;
 
 	if (length == 0 || gfs2_check_range(sdp, rgd->ri.ri_addr))
 		return -1;
 
-	bhs = calloc(length, sizeof(struct gfs2_buffer_head *));
-	if (bhs == NULL)
+	buf = calloc(1, length);
+	if (buf == NULL)
 		return -1;
 
-	if (breadm(sdp, bhs, length, rgd->ri.ri_addr)) {
-		free(bhs);
+	if (pread(sdp->device_fd, buf, length, offset) != length) {
+		free(buf);
 		return -1;
 	}
 
-	for (x = 0; x < length; x++) {
-		struct gfs2_bitmap *bi = &rgd->bits[x];
-		int mtype = (x ? GFS2_METATYPE_RB : GFS2_METATYPE_RG);
-
-		bi->bi_bh = bhs[x];
-		if (gfs2_check_meta(bi->bi_bh->b_data, mtype)) {
-			unsigned err = x;
-			do {
-				brelse(rgd->bits[x].bi_bh);
-				rgd->bits[x].bi_bh = NULL;
-			} while (x-- != 0);
-			free(bhs);
-			return rgd->ri.ri_addr + err;
+	for (unsigned i = 0; i < rgd->ri.ri_length; i++) {
+		int mtype = (i ? GFS2_METATYPE_RB : GFS2_METATYPE_RG);
+
+		rgd->bits[i].bi_data = buf + (i * sdp->bsize);
+		if (gfs2_check_meta(rgd->bits[i].bi_data, mtype)) {
+			free(buf);
+			return rgd->ri.ri_addr + i;
 		}
 	}
 	if (sdp->gfs1)
-		gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh->b_data);
+		gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, buf);
 	else {
-		if (lgfs2_rgrp_crc_check(rgd->bits[0].bi_bh->b_data)) {
-			free(bhs);
+		if (lgfs2_rgrp_crc_check(buf)) {
+			free(buf);
 			return rgd->ri.ri_addr;
 		}
-		gfs2_rgrp_in(&rgd->rg, rgd->bits[0].bi_bh->b_data);
+		gfs2_rgrp_in(&rgd->rg, buf);
 	}
-	free(bhs);
 	return 0;
 }
 
-void gfs2_rgrp_relse(struct rgrp_tree *rgd)
+void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
 {
-	int x, length = rgd->ri.ri_length;
-
 	if (rgd->bits == NULL)
 		return;
-	for (x = 0; x < length; x++) {
-		if (rgd->bits[x].bi_bh && rgd->bits[x].bi_bh->b_data) {
-			brelse(rgd->bits[x].bi_bh);
-			rgd->bits[x].bi_bh = NULL;
+	for (unsigned i = 0; i < rgd->ri.ri_length; i++) {
+		off_t offset = sdp->bsize * (rgd->ri.ri_addr + i);
+		ssize_t ret;
+
+		if (rgd->bits[i].bi_data == NULL || !rgd->bits[i].bi_modified)
+			continue;
+
+		ret = pwrite(sdp->device_fd, rgd->bits[i].bi_data, sdp->bsize, offset);
+		if (ret != sdp->bsize) {
+			fprintf(stderr, "Failed to write modified resource group at block
%"PRIu64": %s\n",
+			        (uint64_t)rgd->ri.ri_addr, strerror(errno));
 		}
+		rgd->bits[i].bi_modified = 0;
 	}
+	free(rgd->bits[0].bi_data);
+	for (unsigned i = 0; i < rgd->ri.ri_length; i++)
+		rgd->bits[i].bi_data = NULL;
 }
 
 struct rgrp_tree *rgrp_insert(struct osi_root *rgtree, uint64_t rgblock)
@@ -287,31 +282,19 @@ struct rgrp_tree *rgrp_insert(struct osi_root *rgtree, uint64_t
rgblock)
 	return data;
 }
 
-void gfs2_rgrp_free(struct osi_root *rgrp_tree)
+void gfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root *rgrp_tree)
 {
 	struct rgrp_tree *rgd;
-	int rgs_since_sync = 0;
 	struct osi_node *n;
-	struct gfs2_sbd *sdp = NULL;
 
 	if (OSI_EMPTY_ROOT(rgrp_tree))
 		return;
 	while ((n = osi_first(rgrp_tree))) {
 		rgd = (struct rgrp_tree *)n;
 
-		if (rgd->bits) {
-			if (rgd->bits[0].bi_bh) { /* if a buffer exists */
-				rgs_since_sync++;
-				if (rgs_since_sync >= RG_SYNC_TOLERANCE) {
-					if (!sdp)
-						sdp = rgd->bits[0].bi_bh->sdp;
-					fsync(sdp->device_fd);
-					rgs_since_sync = 0;
-				}
-				gfs2_rgrp_relse(rgd); /* free them all. */
-			}
-			free(rgd->bits);
-		}
+		gfs2_rgrp_relse(sdp, rgd);
+		free(rgd->bits);
+		rgd->bits = NULL;
 		osi_erase(&rgd->node, rgrp_tree);
 		free(rgd);
 	}
@@ -530,11 +513,9 @@ void lgfs2_rgrps_free(lgfs2_rgrps_t *rgs)
 
 	while ((rg = (struct rgrp_tree *)osi_first(tree))) {
 		int i;
+		free(rg->bits[0].bi_data);
 		for (i = 0; i < rg->ri.ri_length; i++) {
-			if (rg->bits[i].bi_bh != NULL) {
-				free(rg->bits[i].bi_bh);
-				rg->bits[i].bi_bh = NULL;
-			}
+			rg->bits[i].bi_data = NULL;
 		}
 		osi_erase(&rg->node, tree);
 		free(rg);
@@ -697,21 +678,21 @@ int lgfs2_rgrp_write(int fd, const lgfs2_rgrp_t rg)
 	ssize_t ret;
 	size_t len;
 
-	if (rg->bits[0].bi_bh == NULL) {
+	if (rg->bits[0].bi_data == NULL) {
 		freebufs = 1;
 		if (lgfs2_rgrp_bitbuf_alloc(rg) != 0)
 			return -1;
 	}
-	gfs2_rgrp_out(&rg->rg, rg->bits[0].bi_bh->b_data);
-	for (i = 1; i < rg->ri.ri_length; i++)
-		gfs2_meta_header_out(&bmh, rg->bits[i].bi_bh->b_data);
+	gfs2_rgrp_out(&rg->rg, rg->bits[0].bi_data);
+	for (i = 1; i < rg->ri.ri_length; i++) {
+		gfs2_meta_header_out(&bmh, rg->bits[i].bi_data);
+	}
 
 	len = sdp->bsize * rg->ri.ri_length;
 	if (rg->rgrps->align > 0)
 		len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
 
-	ret = pwrite(sdp->device_fd, rg->bits[0].bi_bh->b_data, len,
-	             rg->bits[0].bi_bh->b_blocknr * sdp->bsize);
+	ret = pwrite(sdp->device_fd, rg->bits[0].bi_data, len, rg->ri.ri_addr *
sdp->bsize);
 
 	if (freebufs)
 		lgfs2_rgrp_bitbuf_free(rg);
@@ -754,7 +735,7 @@ lgfs2_rgrp_t lgfs2_rgrp_last(lgfs2_rgrps_t rgs)
 int lgfs2_rbm_from_block(struct lgfs2_rbm *rbm, uint64_t block)
 {
 	uint64_t rblock = block - rbm->rgd->ri.ri_data0;
-	struct gfs2_sbd *sdp = rbm_bi(rbm)->bi_bh->sdp;
+	struct gfs2_sbd *sdp = rbm->rgd->rgrps->sdp;
 
 	if (rblock > UINT_MAX) {
 		errno = EINVAL;
@@ -813,7 +794,7 @@ static int lgfs2_rbm_incr(struct lgfs2_rbm *rbm)
 static inline uint8_t lgfs2_testbit(const struct lgfs2_rbm *rbm)
 {
 	struct gfs2_bitmap *bi = rbm_bi(rbm);
-	const uint8_t *buffer = (uint8_t *)bi->bi_bh->b_data + bi->bi_offset;
+	const uint8_t *buffer = (uint8_t *)bi->bi_data + bi->bi_offset;
 	const uint8_t *byte;
 	unsigned int bit;
 
@@ -885,6 +866,7 @@ static uint32_t lgfs2_free_extlen(const struct lgfs2_rbm *rrbm,
uint32_t len)
 	uint8_t *ptr, *start, *end;
 	uint64_t block;
 	struct gfs2_bitmap *bi;
+	struct gfs2_sbd *sdp = rbm.rgd->rgrps->sdp;
 
 	if (n_unaligned &&
 	    lgfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
@@ -894,8 +876,8 @@ static uint32_t lgfs2_free_extlen(const struct lgfs2_rbm *rrbm,
uint32_t len)
 	/* Start is now byte aligned */
 	while (len > 3) {
 		bi = rbm_bi(&rbm);
-		start = (uint8_t *)bi->bi_bh->b_data;
-		end = start + bi->bi_bh->sdp->bsize;
+		start = (uint8_t *)bi->bi_data;
+		end = start + sdp->bsize;
 		start += bi->bi_offset;
 		start += (rbm.offset / GFS2_NBBY);
 		bytes = (len / GFS2_NBBY) < (end - start) ? (len / GFS2_NBBY):(end - start);
@@ -948,8 +930,7 @@ int lgfs2_rbm_find(struct lgfs2_rbm *rbm, uint8_t state, uint32_t
*minext)
 
 	for (n = 0; n < iters; n++) {
 		struct gfs2_bitmap *bi = rbm_bi(rbm);
-		struct gfs2_buffer_head *bh = bi->bi_bh;
-		uint8_t *buf = (uint8_t *)bh->b_data + bi->bi_offset;
+		uint8_t *buf = (uint8_t *)bi->bi_data + bi->bi_offset;
 		uint64_t block;
 		int ret;
 
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index b00c2a9..36e02c2 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -667,13 +667,12 @@ unsigned lgfs2_bm_scan(struct rgrp_tree *rgd, unsigned idx, uint64_t
*buf, uint8
 	uint32_t blk = 0;
 
 	while(blk < (bi->bi_len * GFS2_NBBY)) {
-		blk = gfs2_bitfit((uint8_t *)bi->bi_bh->b_data + bi->bi_offset,
+		blk = gfs2_bitfit((uint8_t *)bi->bi_data + bi->bi_offset,
 				  bi->bi_len, blk, state);
 		if (blk == BFITNOENT)
 			break;
 		buf[n++] = blk + (bi->bi_start * GFS2_NBBY) + rgd->ri.ri_data0;
 		blk++;
 	}
-
 	return n;
 }
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index 6fe29ad..f38c3d7 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -346,7 +346,7 @@ static int __ri_update(struct gfs2_sbd *sdp, int fd, int *rgcount, int
*sane,
 
  fail:
 	posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_NORMAL);
-	gfs2_rgrp_free(&sdp->rgtree);
+	gfs2_rgrp_free(sdp, &sdp->rgtree);
 	return -1;
 }
 
diff --git a/tests/check_rgrp.c b/tests/check_rgrp.c
index 0360d3c..30461a9 100644
--- a/tests/check_rgrp.c
+++ b/tests/check_rgrp.c
@@ -35,8 +35,8 @@ static lgfs2_rgrps_t mockup_rgrp(void)
 	fail_unless(rg != NULL);
 
 	for (i = 0; i < rg->ri.ri_length; i++) {
-		rg->bits[i].bi_bh = bget(sdp, rg->ri.ri_addr + i);
-		fail_unless(rg->bits[i].bi_bh != NULL);
+		rg->bits[i].bi_data = calloc(1, sdp->bsize);
+		fail_unless(rg->bits[i].bi_data != NULL);
 	}
 	return rgs;
 }
@@ -100,7 +100,7 @@ START_TEST(test_rbm_find_lastblock)
 
 	/* Flag all blocks as allocated... */
 	for (i = 0; i < rg->ri.ri_length; i++)
-		memset(rg->bits[i].bi_bh->b_data, 0xff, rgs->sdp->bsize);
+		memset(rg->bits[i].bi_data, 0xff, rgs->sdp->bsize);
 
 	/* ...except the final one */
 	err = gfs2_set_bitmap(rg, rg->ri.ri_data0 + rg->ri.ri_data - 1, GFS2_BLKST_FREE);

-- 
To stop receiving notification emails like this one, please contact
the administrator of this repository.