Attachment 585929 Details for Bug 548215 – use lvbs to track resource group space and unlinked inodes

[patch] use lvbs to track resource group space and unlinked inodes

bz548215_rgrp_lvb.patch (text/plain), 9.42 KB, created by Ben Marzinski on 2012-05-22 05:28:49 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ben Marzinski

Created: 2012-05-22 05:28:49 UTC

Size: 9.42 KB

patch

obsolete

>---
> fs/gfs2/glock.c             |    1 
> fs/gfs2/incore.h            |    1 
> fs/gfs2/rgrp.c              |  138 +++++++++++++++++++++++++++++++++++++++++---
> include/linux/gfs2_ondisk.h |   10 +++
> 4 files changed, 141 insertions(+), 9 deletions(-)
>
>Index: gfs2-3.0-nmw/fs/gfs2/glock.c
>===================================================================
>--- gfs2-3.0-nmw.orig/fs/gfs2/glock.c
>+++ gfs2-3.0-nmw/fs/gfs2/glock.c
>@@ -767,6 +767,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp,
> 	gl->gl_stats.stats[GFS2_LKS_DCOUNT] = 0;
> 	gl->gl_stats.stats[GFS2_LKS_QCOUNT] = 0;
> 	memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));
>+	memset(gl->gl_lvb, 0, 32 * sizeof(char));
> 	gl->gl_lksb.sb_lvbptr = gl->gl_lvb;
> 	gl->gl_tchange = jiffies;
> 	gl->gl_object = NULL;
>Index: gfs2-3.0-nmw/fs/gfs2/incore.h
>===================================================================
>--- gfs2-3.0-nmw.orig/fs/gfs2/incore.h
>+++ gfs2-3.0-nmw/fs/gfs2/incore.h
>@@ -89,6 +89,7 @@ struct gfs2_rgrpd {
> 	u64 rd_igeneration;
> 	struct gfs2_bitmap *rd_bits;
> 	struct gfs2_sbd *rd_sbd;
>+	struct gfs2_rgrp_lvb *rd_rgl;
> 	u32 rd_last_alloc;
> 	u32 rd_flags;
> #define GFS2_RDF_CHECK		0x10000000 /* check for unlinked inodes */
>Index: gfs2-3.0-nmw/fs/gfs2/rgrp.c
>===================================================================
>--- gfs2-3.0-nmw.orig/fs/gfs2/rgrp.c
>+++ gfs2-3.0-nmw/fs/gfs2/rgrp.c
>@@ -627,6 +627,7 @@ static int read_rindex_entry(struct gfs2
> 		goto fail;
> 
> 	rgd->rd_gl->gl_object = rgd;
>+	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lvb;
> 	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
> 	if (rgd->rd_data > sdp->sd_max_rg_data)
> 		sdp->sd_max_rg_data = rgd->rd_data;
>@@ -736,9 +737,65 @@ static void gfs2_rgrp_out(struct gfs2_rg
> 	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
> }
> 
>+static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
>+{
>+	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
>+	struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
>+
>+	if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
>+	    rgl->rl_dinodes != str->rg_dinodes ||
>+	    rgl->rl_igeneration != str->rg_igeneration)
>+		return 0;
>+	return 1;
>+}
>+
>+static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
>+{
>+	const struct gfs2_rgrp *str = buf;
>+
>+	rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
>+	rgl->rl_flags = str->rg_flags;
>+	rgl->rl_free = str->rg_free;
>+	rgl->rl_dinodes = str->rg_dinodes;
>+	rgl->rl_igeneration = str->rg_igeneration;
>+	rgl->__pad = 0UL;
>+}
>+
>+static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
>+{
>+	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
>+	u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
>+	rgl->rl_unlinked = cpu_to_be32(unlinked);
>+}
>+
>+static u32 count_unlinked(struct gfs2_rgrpd *rgd)
>+{
>+	struct gfs2_bitmap *bi;
>+	const u32 length = rgd->rd_length;
>+	const u8 *buffer = NULL;
>+	u32 i, goal, count = 0;
>+
>+	for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
>+		goal = 0;
>+		buffer = bi->bi_bh->b_data + bi->bi_offset;
>+		WARN_ON(!buffer_uptodate(bi->bi_bh));
>+		while (goal < bi->bi_len * GFS2_NBBY) {
>+			goal = gfs2_bitfit(buffer, bi->bi_len, goal,
>+					   GFS2_BLKST_UNLINKED);
>+			if (goal == BFITNOENT)
>+				break;
>+			count++;
>+			goal++;
>+		}
>+	}
>+
>+	return count;
>+}
>+
>+
> /**
>- * gfs2_rgrp_go_lock - Read in a RG's header and bitmaps
>- * @gh: The glock holder for the resource group
>+ * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
>+ * @rgd: the struct gfs2_rgrpd describing the RG to read in
>  *
>  * Read in all of a Resource Group's header and bitmap blocks.
>  * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
>@@ -746,9 +803,8 @@ static void gfs2_rgrp_out(struct gfs2_rg
>  * Returns: errno
>  */
> 
>-int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
>+int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
> {
>-	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
> 	struct gfs2_sbd *sdp = rgd->rd_sbd;
> 	struct gfs2_glock *gl = rgd->rd_gl;
> 	unsigned int length = rgd->rd_length;
>@@ -756,6 +812,9 @@ int gfs2_rgrp_go_lock(struct gfs2_holder
> 	unsigned int x, y;
> 	int error;
> 
>+	if (rgd->rd_bits[0].bi_bh != NULL)
>+		return 0;
>+
> 	for (x = 0; x < length; x++) {
> 		bi = rgd->rd_bits + x;
> 		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
>@@ -782,6 +841,18 @@ int gfs2_rgrp_go_lock(struct gfs2_holder
> 		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
> 		rgd->rd_free_clone = rgd->rd_free;
> 	}
>+	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
>+		rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
>+		gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
>+				     rgd->rd_bits[0].bi_bh->b_data);
>+	}
>+	else if (!gfs2_rgrp_lvb_valid(rgd)){
>+		gfs2_consist_rgrpd(rgd);
>+		error = -EIO;
>+		goto fail;
>+	}
>+	if (rgd->rd_rgl->rl_unlinked == 0)
>+		rgd->rd_flags &= ~GFS2_RDF_CHECK;
> 
> 	return 0;
> 
>@@ -796,6 +867,36 @@ fail:
> 	return error;
> }
> 
>+int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
>+{
>+	u32 rl_flags;
>+
>+	if (rgd->rd_flags & GFS2_RDF_UPTODATE)
>+		return 0;
>+
>+	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
>+		return gfs2_rgrp_bh_get(rgd);
>+
>+	rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
>+	rl_flags &= ~GFS2_RDF_MASK;
>+	rgd->rd_flags &= GFS2_RDF_MASK;
>+	rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
>+	if (rgd->rd_rgl->rl_unlinked == 0)
>+		rgd->rd_flags &= ~GFS2_RDF_CHECK;
>+	rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
>+	rgd->rd_free_clone = rgd->rd_free;
>+	rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
>+	rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
>+	return 0;
>+}
>+
>+int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
>+{
>+	if (gh->gh_flags & GL_SKIP)
>+		return 0;
>+	return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
>+}
>+
> /**
>  * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
>  * @gh: The glock holder for the resource group
>@@ -809,8 +910,10 @@ void gfs2_rgrp_go_unlock(struct gfs2_hol
> 
> 	for (x = 0; x < length; x++) {
> 		struct gfs2_bitmap *bi = rgd->rd_bits + x;
>-		brelse(bi->bi_bh);
>-		bi->bi_bh = NULL;
>+		if (bi->bi_bh) {
>+			brelse(bi->bi_bh);
>+			bi->bi_bh = NULL;
>+		}
> 	}
> 
> }
>@@ -954,6 +1057,7 @@ int gfs2_fitrim(struct file *filp, void 
> 				rgd->rd_flags |= GFS2_RGF_TRIMMED;
> 				gfs2_trans_add_bh(rgd->rd_gl, bh, 1);
> 				gfs2_rgrp_out(rgd, bh->b_data);
>+				gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
> 				gfs2_trans_end(sdp);
> 			}
> 		}
>@@ -1115,7 +1219,7 @@ static int get_local_rgrp(struct gfs2_in
> 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
> 	struct gfs2_rgrpd *rgd, *begin = NULL;
> 	struct gfs2_blkreserv *rs = ip->i_res;
>-	int error, rg_locked, flags = LM_FLAG_TRY;
>+	int error, rg_locked, flags = LM_FLAG_TRY | GL_SKIP;
> 	int loops = 0;
> 
> 	if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal))
>@@ -1135,22 +1239,32 @@ static int get_local_rgrp(struct gfs2_in
> 		} else {
> 			error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
> 						   flags, &rs->rs_rgd_gh);
>+			if (!error) {
>+				error = update_rgrp_lvb(rgd);
>+				if (error) {
>+					gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
>+					return error;
>+				}
>+			}
> 		}
> 		switch (error) {
> 		case 0:
> 			if (try_rgrp_fit(rgd, ip)) {
>+				gfs2_rgrp_bh_get(rgd);
> 				ip->i_rgd = rgd;
> 				return 0;
> 			}
>-			if (rgd->rd_flags & GFS2_RDF_CHECK)
>+			if (rgd->rd_flags & GFS2_RDF_CHECK) {
>+				gfs2_rgrp_bh_get(rgd);
> 				try_rgrp_unlink(rgd, last_unlinked, ip->i_no_addr);
>+			}
> 			if (!rg_locked)
> 				gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
> 			/* fall through */
> 		case GLR_TRYFAILED:
> 			rgd = gfs2_rgrpd_get_next(rgd);
> 			if (rgd == begin) {
>-				flags = 0;
>+				flags = GL_SKIP;
> 				loops++;
> 			}
> 			break;
>@@ -1542,6 +1656,7 @@ int gfs2_alloc_blocks(struct gfs2_inode 
> 
> 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
> 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
>+	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
> 
> 	gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
> 	if (dinode)
>@@ -1588,6 +1703,7 @@ void __gfs2_free_blocks(struct gfs2_inod
> 	rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
> 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
> 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
>+	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
> 
> 	/* Directories keep their data in the metadata address space */
> 	if (meta || ip->i_depth)
>@@ -1624,6 +1740,8 @@ void gfs2_unlink_di(struct inode *inode)
> 	trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
> 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
> 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
>+	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
>+	update_rgrp_lvb_unlinked(rgd, 1);
> }
> 
> static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
>@@ -1643,6 +1761,8 @@ static void gfs2_free_uninit_di(struct g
> 
> 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
> 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
>+	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
>+	update_rgrp_lvb_unlinked(rgd, -1);
> 
> 	gfs2_statfs_change(sdp, 0, +1, -1);
> }
>Index: gfs2-3.0-nmw/include/linux/gfs2_ondisk.h
>===================================================================
>--- gfs2-3.0-nmw.orig/include/linux/gfs2_ondisk.h
>+++ gfs2-3.0-nmw/include/linux/gfs2_ondisk.h
>@@ -170,6 +170,16 @@ struct gfs2_rindex {
> #define GFS2_RGF_NOALLOC	0x00000008
> #define GFS2_RGF_TRIMMED	0x00000010
> 
>+struct gfs2_rgrp_lvb {
>+	__be32 rl_magic;
>+	__be32 rl_flags;
>+	__be32 rl_free;
>+	__be32 rl_dinodes;
>+	__be64 rl_igeneration;
>+	__be32 rl_unlinked;
>+	__be32 __pad;
>+};
>+
> struct gfs2_rgrp {
> 	struct gfs2_meta_header rg_header;
>

Actions: View | Diff

Attachments on bug 548215: 565390 | 585929 | 587583