Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6a6b3d01 authored by David Teigland's avatar David Teigland Committed by Steven Whitehouse
Browse files

[GFS2] Patch to remove stats gathering from GFS2 



Signed-off-by: default avatarDavid Teigland <teigland@redhat.com>
Signed-off-by: default avatarSteven Whitehouse <swhiteho@redhat.com>
parent 8d3b35a4

fs/gfs2/glock.c

+2 −21
Original line number Diff line number Diff line
@@ -106,8 +106,6 @@ static void glock_free(struct gfs2_glock *gl) 
		gfs2_aspace_put(aspace);



	kmem_cache_free(gfs2_glock_cachep, gl);



	atomic_dec(&sdp->sd_glock_count);

}



/**
@@ -316,8 +314,6 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, uint64_t number, 
	if (error)

		goto fail_aspace;



	atomic_inc(&sdp->sd_glock_count);



	write_lock(&bucket->hb_lock);

	tmp = search_bucket(bucket, &name);

	if (tmp) {
@@ -836,14 +832,11 @@ static void state_change(struct gfs2_glock *gl, unsigned int new_state) 
	held2 = (new_state != LM_ST_UNLOCKED);



	if (held1 != held2) {

		if (held2) {

			atomic_inc(&sdp->sd_glock_held_count);

		if (held2)

			gfs2_glock_hold(gl);

		} else {

			atomic_dec(&sdp->sd_glock_held_count);

		else

			gfs2_glock_put(gl);

	}

	}



	gl->gl_state = new_state;

}
@@ -994,8 +987,6 @@ void gfs2_glock_xmote_th(struct gfs2_glock *gl, unsigned int state, int flags) 
	gfs2_glock_hold(gl);

	gl->gl_req_bh = xmote_bh;



	atomic_inc(&sdp->sd_lm_lock_calls);



	lck_ret = gfs2_lm_lock(sdp, gl->gl_lock, gl->gl_state, state,

			       lck_flags);
@@ -1087,8 +1078,6 @@ void gfs2_glock_drop_th(struct gfs2_glock *gl) 
	gfs2_glock_hold(gl);

	gl->gl_req_bh = drop_bh;



	atomic_inc(&sdp->sd_lm_unlock_calls);



	ret = gfs2_lm_unlock(sdp, gl->gl_lock, gl->gl_state);



	if (gfs2_assert_withdraw(sdp, !(ret & LM_OUT_ERROR)))
@@ -1313,8 +1302,6 @@ int gfs2_glock_nq(struct gfs2_holder *gh) 
	struct gfs2_sbd *sdp = gl->gl_sbd;

	int error = 0;



	atomic_inc(&sdp->sd_glock_nq_calls);



 restart:

	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {

		set_bit(HIF_ABORTED, &gh->gh_iflags);
@@ -1406,8 +1393,6 @@ void gfs2_glock_dq(struct gfs2_holder *gh) 
	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_glock_operations *glops = gl->gl_ops;



	atomic_inc(&sdp->sd_glock_dq_calls);



	if (gh->gh_flags & GL_SYNC)

		set_bit(GLF_SYNC, &gl->gl_flags);
@@ -1469,8 +1454,6 @@ void gfs2_glock_prefetch(struct gfs2_glock *gl, unsigned int state, int flags) 
	spin_unlock(&gl->gl_spin);



	glops->go_xmote_th(gl, state, flags);



	atomic_inc(&gl->gl_sbd->sd_glock_prefetch_calls);

}



/**
@@ -1916,8 +1899,6 @@ void gfs2_glock_cb(lm_fsdata_t *fsdata, unsigned int type, void *data) 
{

	struct gfs2_sbd *sdp = (struct gfs2_sbd *)fsdata;



	atomic_inc(&sdp->sd_lm_callbacks);



	switch (type) {

	case LM_CB_NEED_E:

		blocking_cb(sdp, (struct lm_lockname *)data, LM_ST_UNLOCKED);

fs/gfs2/incore.h

+0 −20
Original line number Diff line number Diff line
@@ -667,27 +667,7 @@ struct gfs2_sbd { 
	atomic_t sd_glock_count;

	atomic_t sd_glock_held_count;

	atomic_t sd_inode_count;

	atomic_t sd_bufdata_count;



	atomic_t sd_fh2dentry_misses;

	atomic_t sd_reclaimed;

	atomic_t sd_log_flush_incore;

	atomic_t sd_log_flush_ondisk;



	atomic_t sd_glock_nq_calls;

	atomic_t sd_glock_dq_calls;

	atomic_t sd_glock_prefetch_calls;

	atomic_t sd_lm_lock_calls;

	atomic_t sd_lm_unlock_calls;

	atomic_t sd_lm_callbacks;



	atomic_t sd_ops_address;

	atomic_t sd_ops_dentry;

	atomic_t sd_ops_export;

	atomic_t sd_ops_file;

	atomic_t sd_ops_inode;

	atomic_t sd_ops_super;

	atomic_t sd_ops_vm;



	char sd_fsname[GFS2_FSNAME_LEN];

	char sd_table_name[GFS2_FSNAME_LEN];

fs/gfs2/log.c

+0 −4
Original line number Diff line number Diff line
@@ -408,8 +408,6 @@ static void log_write_header(struct gfs2_sbd *sdp, uint32_t flags, int pull) 
	unsigned int tail;

	uint32_t hash;



	atomic_inc(&sdp->sd_log_flush_ondisk);



	bh = sb_getblk(sdp->sd_vfs, blkno);

	lock_buffer(bh);

	memset(bh->b_data, 0, bh->b_size);
@@ -488,8 +486,6 @@ void gfs2_log_flush_i(struct gfs2_sbd *sdp, struct gfs2_glock *gl) 
{

	struct gfs2_ail *ai;



	atomic_inc(&sdp->sd_log_flush_incore);



	ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL);

	INIT_LIST_HEAD(&ai->ai_ail1_list);

	INIT_LIST_HEAD(&ai->ai_ail2_list);

fs/gfs2/meta_io.c

+0 −3
Original line number Diff line number Diff line
@@ -146,7 +146,6 @@ static int gfs2_aspace_releasepage(struct page *page, gfp_t gfp_mask) 
			gfs2_assert_warn(sdp, list_empty(&bd->bd_le.le_list));

			gfs2_assert_warn(sdp, !bd->bd_ail);

			kmem_cache_free(gfs2_bufdata_cachep, bd);

			atomic_dec(&sdp->sd_bufdata_count);

			set_v2bd(bh, NULL);

		}
@@ -557,8 +556,6 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh, int meta 
	}



	bd = kmem_cache_alloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL),

	atomic_inc(&gl->gl_sbd->sd_bufdata_count);



	memset(bd, 0, sizeof(struct gfs2_bufdata));



	bd->bd_bh = bh;

fs/gfs2/ops_address.c

+0 −12
Original line number Diff line number Diff line
@@ -166,7 +166,6 @@ static int gfs2_writepage(struct page *page, struct writeback_control *wbc) 
	int error;

	int done_trans = 0;



	atomic_inc(&sdp->sd_ops_address);

	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {

		unlock_page(page);

		return -EIO;
@@ -265,8 +264,6 @@ static int gfs2_readpage(struct file *file, struct page *page) 
	struct gfs2_holder gh;

	int error;



	atomic_inc(&sdp->sd_ops_address);



	if (file != &gfs2_internal_file_sentinal) {

		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);

		error = gfs2_glock_nq_m_atime(1, &gh);
@@ -319,8 +316,6 @@ static int gfs2_prepare_write(struct file *file, struct page *page, 
	loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;

	struct gfs2_alloc *al;



	atomic_inc(&sdp->sd_ops_address);



	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME, &ip->i_gh);

	error = gfs2_glock_nq_m_atime(1, &ip->i_gh);

	if (error)
@@ -412,9 +407,6 @@ static int gfs2_commit_write(struct file *file, struct page *page, 
	struct buffer_head *dibh;

	struct gfs2_alloc *al = &ip->i_alloc;;



	atomic_inc(&sdp->sd_ops_address);





	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))

                goto fail_nounlock;
@@ -493,8 +485,6 @@ static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock) 
	sector_t dblock = 0;

	int error;



	atomic_inc(&ip->i_sbd->sd_ops_address);



	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);

	if (error)

		return 0;
@@ -615,8 +605,6 @@ static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb, 
	struct gfs2_inode *ip = get_v2ip(inode);

	struct gfs2_sbd *sdp = ip->i_sbd;



	atomic_inc(&sdp->sd_ops_address);



	if (rw == WRITE)

		return gfs2_direct_IO_write(iocb, iov, offset, nr_segs);