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

Commit 15562c43 authored by Bob Peterson's avatar Bob Peterson
Browse files

GFS2: Move glock superblock pointer to field gl_name 



What uniquely identifies a glock in the glock hash table is not
gl_name, but gl_name and its superblock pointer. This patch makes
the gl_name field correspond to a unique glock identifier. That will
allow us to simplify hashing with a future patch, since the hash
algorithm can then take the gl_name and hash its components in one
operation.

Signed-off-by: default avatarBob Peterson <rpeterso@redhat.com>
Signed-off-by: default avatarAndreas Gruenbacher <agruenba@redhat.com>
Acked-by: default avatarSteven Whitehouse <swhiteho@redhat.com>
parent 81648d04

fs/gfs2/glock.c

+15 −17
Original line number Diff line number Diff line
@@ -119,7 +119,7 @@ static void gfs2_glock_dealloc(struct rcu_head *rcu) 


void gfs2_glock_free(struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;



	call_rcu(&gl->gl_rcu, gfs2_glock_dealloc);

	if (atomic_dec_and_test(&sdp->sd_glock_disposal))
@@ -192,7 +192,7 @@ static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl) 


void gfs2_glock_put(struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct address_space *mapping = gfs2_glock2aspace(gl);



	if (lockref_put_or_lock(&gl->gl_lockref))
@@ -220,7 +220,6 @@ void gfs2_glock_put(struct gfs2_glock *gl) 
 */



static struct gfs2_glock *search_bucket(unsigned int hash,

					const struct gfs2_sbd *sdp,

					const struct lm_lockname *name)

{

	struct gfs2_glock *gl;
@@ -229,8 +228,6 @@ static struct gfs2_glock *search_bucket(unsigned int hash, 
	hlist_bl_for_each_entry_rcu(gl, h, &gl_hash_table[hash], gl_list) {

		if (!lm_name_equal(&gl->gl_name, name))

			continue;

		if (gl->gl_sbd != sdp)

			continue;

		if (lockref_get_not_dead(&gl->gl_lockref))

			return gl;

	}
@@ -506,7 +503,7 @@ __releases(&gl->gl_spin) 
__acquires(&gl->gl_spin)

{

	const struct gfs2_glock_operations *glops = gl->gl_ops;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	unsigned int lck_flags = gh ? gh->gh_flags : 0;

	int ret;
@@ -628,7 +625,7 @@ __acquires(&gl->gl_spin) 
static void delete_work_func(struct work_struct *work)

{

	struct gfs2_glock *gl = container_of(work, struct gfs2_glock, gl_delete);

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct gfs2_inode *ip;

	struct inode *inode;

	u64 no_addr = gl->gl_name.ln_number;
@@ -704,14 +701,16 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
		   struct gfs2_glock **glp)

{

	struct super_block *s = sdp->sd_vfs;

	struct lm_lockname name = { .ln_number = number, .ln_type = glops->go_type };

	struct lm_lockname name = { .ln_number = number,

				    .ln_type = glops->go_type,

				    .ln_sbd = sdp };

	struct gfs2_glock *gl, *tmp;

	unsigned int hash = gl_hash(sdp, &name);

	struct address_space *mapping;

	struct kmem_cache *cachep;



	rcu_read_lock();

	gl = search_bucket(hash, sdp, &name);

	gl = search_bucket(hash, &name);

	rcu_read_unlock();



	*glp = gl;
@@ -739,7 +738,6 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	}



	atomic_inc(&sdp->sd_glock_disposal);

	gl->gl_sbd = sdp;

	gl->gl_flags = 0;

	gl->gl_name = name;

	gl->gl_lockref.count = 1;
@@ -772,7 +770,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	}



	spin_lock_bucket(hash);

	tmp = search_bucket(hash, sdp, &name);

	tmp = search_bucket(hash, &name);

	if (tmp) {

		spin_unlock_bucket(hash);

		kfree(gl->gl_lksb.sb_lvbptr);
@@ -928,7 +926,7 @@ __releases(&gl->gl_spin) 
__acquires(&gl->gl_spin)

{

	struct gfs2_glock *gl = gh->gh_gl;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct list_head *insert_pt = NULL;

	struct gfs2_holder *gh2;

	int try_futile = 0;
@@ -1006,7 +1004,7 @@ __acquires(&gl->gl_spin) 
int gfs2_glock_nq(struct gfs2_holder *gh)

{

	struct gfs2_glock *gl = gh->gh_gl;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	int error = 0;



	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
@@ -1313,7 +1311,7 @@ static int gfs2_should_freeze(const struct gfs2_glock *gl) 


void gfs2_glock_complete(struct gfs2_glock *gl, int ret)

{

	struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;

	struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;



	spin_lock(&gl->gl_spin);

	gl->gl_reply = ret;
@@ -1471,7 +1469,7 @@ static void examine_bucket(glock_examiner examiner, const struct gfs2_sbd *sdp, 


	rcu_read_lock();

	hlist_bl_for_each_entry_rcu(gl, pos, head, gl_list) {

		if ((gl->gl_sbd == sdp) && lockref_get_not_dead(&gl->gl_lockref))

		if ((gl->gl_name.ln_sbd == sdp) && lockref_get_not_dead(&gl->gl_lockref))

			examiner(gl);

	}

	rcu_read_unlock();
@@ -1569,7 +1567,7 @@ void gfs2_glock_finish_truncate(struct gfs2_inode *ip) 
	int ret;



	ret = gfs2_truncatei_resume(ip);

	gfs2_assert_withdraw(gl->gl_sbd, ret == 0);

	gfs2_assert_withdraw(gl->gl_name.ln_sbd, ret == 0);



	spin_lock(&gl->gl_spin);

	clear_bit(GLF_LOCK, &gl->gl_flags);
@@ -1872,7 +1870,7 @@ static int gfs2_glock_iter_next(struct gfs2_glock_iter *gi) 
			gi->nhash = 0;

		}

	/* Skip entries for other sb and dead entries */

	} while (gi->sdp != gi->gl->gl_sbd ||

	} while (gi->sdp != gi->gl->gl_name.ln_sbd ||

		 __lockref_is_dead(&gi->gl->gl_lockref));



	return 0;

fs/gfs2/glops.c

+20 −18
Original line number Diff line number Diff line
@@ -32,13 +32,15 @@ struct workqueue_struct *gfs2_freeze_wq; 


static void gfs2_ail_error(struct gfs2_glock *gl, const struct buffer_head *bh)

{

	fs_err(gl->gl_sbd, "AIL buffer %p: blocknr %llu state 0x%08lx mapping %p page state 0x%lx\n",

	fs_err(gl->gl_name.ln_sbd,

	       "AIL buffer %p: blocknr %llu state 0x%08lx mapping %p page "

	       "state 0x%lx\n",

	       bh, (unsigned long long)bh->b_blocknr, bh->b_state,

	       bh->b_page->mapping, bh->b_page->flags);

	fs_err(gl->gl_sbd, "AIL glock %u:%llu mapping %p\n",

	fs_err(gl->gl_name.ln_sbd, "AIL glock %u:%llu mapping %p\n",

	       gl->gl_name.ln_type, gl->gl_name.ln_number,

	       gfs2_glock2aspace(gl));

	gfs2_lm_withdraw(gl->gl_sbd, "AIL error\n");

	gfs2_lm_withdraw(gl->gl_name.ln_sbd, "AIL error\n");

}



/**
@@ -52,7 +54,7 @@ static void gfs2_ail_error(struct gfs2_glock *gl, const struct buffer_head *bh) 
static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync,

			     unsigned int nr_revokes)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct list_head *head = &gl->gl_ail_list;

	struct gfs2_bufdata *bd, *tmp;

	struct buffer_head *bh;
@@ -80,7 +82,7 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync, 


static void gfs2_ail_empty_gl(struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct gfs2_trans tr;



	memset(&tr, 0, sizeof(tr));
@@ -109,7 +111,7 @@ static void gfs2_ail_empty_gl(struct gfs2_glock *gl) 


void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	unsigned int revokes = atomic_read(&gl->gl_ail_count);

	unsigned int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64);

	int ret;
@@ -139,7 +141,7 @@ void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync) 


static void rgrp_go_sync(struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct address_space *mapping = &sdp->sd_aspace;

	struct gfs2_rgrpd *rgd;

	int error;
@@ -179,7 +181,7 @@ static void rgrp_go_sync(struct gfs2_glock *gl) 


static void rgrp_go_inval(struct gfs2_glock *gl, int flags)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct address_space *mapping = &sdp->sd_aspace;

	struct gfs2_rgrpd *rgd = gl->gl_object;
@@ -218,7 +220,7 @@ static void inode_go_sync(struct gfs2_glock *gl) 


	GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE);



	gfs2_log_flush(gl->gl_sbd, gl, NORMAL_FLUSH);

	gfs2_log_flush(gl->gl_name.ln_sbd, gl, NORMAL_FLUSH);

	filemap_fdatawrite(metamapping);

	if (ip) {

		struct address_space *mapping = ip->i_inode.i_mapping;
@@ -252,7 +254,7 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags) 
{

	struct gfs2_inode *ip = gl->gl_object;



	gfs2_assert_withdraw(gl->gl_sbd, !atomic_read(&gl->gl_ail_count));

	gfs2_assert_withdraw(gl->gl_name.ln_sbd, !atomic_read(&gl->gl_ail_count));



	if (flags & DIO_METADATA) {

		struct address_space *mapping = gfs2_glock2aspace(gl);
@@ -264,9 +266,9 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags) 
		}

	}



	if (ip == GFS2_I(gl->gl_sbd->sd_rindex)) {

		gfs2_log_flush(gl->gl_sbd, NULL, NORMAL_FLUSH);

		gl->gl_sbd->sd_rindex_uptodate = 0;

	if (ip == GFS2_I(gl->gl_name.ln_sbd->sd_rindex)) {

		gfs2_log_flush(gl->gl_name.ln_sbd, NULL, NORMAL_FLUSH);

		gl->gl_name.ln_sbd->sd_rindex_uptodate = 0;

	}

	if (ip && S_ISREG(ip->i_inode.i_mode))

		truncate_inode_pages(ip->i_inode.i_mapping, 0);
@@ -281,7 +283,7 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags) 


static int inode_go_demote_ok(const struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct gfs2_holder *gh;



	if (sdp->sd_jindex == gl->gl_object || sdp->sd_rindex == gl->gl_object)
@@ -416,7 +418,7 @@ int gfs2_inode_refresh(struct gfs2_inode *ip) 
static int inode_go_lock(struct gfs2_holder *gh)

{

	struct gfs2_glock *gl = gh->gh_gl;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct gfs2_inode *ip = gl->gl_object;

	int error = 0;
@@ -477,7 +479,7 @@ static void inode_go_dump(struct seq_file *seq, const struct gfs2_glock *gl) 
static void freeze_go_sync(struct gfs2_glock *gl)

{

	int error = 0;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;



	if (gl->gl_state == LM_ST_SHARED &&

	    test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
@@ -500,7 +502,7 @@ static void freeze_go_sync(struct gfs2_glock *gl) 


static int freeze_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);

	struct gfs2_glock *j_gl = ip->i_gl;

	struct gfs2_log_header_host head;
@@ -545,7 +547,7 @@ static int freeze_go_demote_ok(const struct gfs2_glock *gl) 
static void iopen_go_callback(struct gfs2_glock *gl, bool remote)

{

	struct gfs2_inode *ip = (struct gfs2_inode *)gl->gl_object;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;



	if (!remote || (sdp->sd_vfs->s_flags & MS_RDONLY))

		return;

fs/gfs2/incore.h

+5 −4
Original line number Diff line number Diff line
@@ -203,13 +203,15 @@ enum { 
};



struct lm_lockname {

	struct gfs2_sbd *ln_sbd;

	u64 ln_number;

	unsigned int ln_type;

};



#define lm_name_equal(name1, name2) \

        (((name1)->ln_number == (name2)->ln_number) &&	\

         ((name1)->ln_type == (name2)->ln_type))

	 ((name1)->ln_type == (name2)->ln_type) &&	\

	 ((name1)->ln_sbd == (name2)->ln_sbd))





struct gfs2_glock_operations {
@@ -327,7 +329,6 @@ enum { 


struct gfs2_glock {

	struct hlist_bl_node gl_list;

	struct gfs2_sbd *gl_sbd;

	unsigned long gl_flags;		/* GLF_... */

	struct lm_lockname gl_name;
@@ -835,7 +836,7 @@ static inline void gfs2_glstats_inc(struct gfs2_glock *gl, int which) 


static inline void gfs2_sbstats_inc(const struct gfs2_glock *gl, int which)

{

	const struct gfs2_sbd *sdp = gl->gl_sbd;

	const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	preempt_disable();

	this_cpu_ptr(sdp->sd_lkstats)->lkstats[gl->gl_name.ln_type].stats[which]++;

	preempt_enable();

fs/gfs2/lock_dlm.c

+5 −5
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ static inline void gfs2_update_reply_times(struct gfs2_glock *gl) 


	preempt_disable();

	rtt = ktime_to_ns(ktime_sub(ktime_get_real(), gl->gl_dstamp));

	lks = this_cpu_ptr(gl->gl_sbd->sd_lkstats);

	lks = this_cpu_ptr(gl->gl_name.ln_sbd->sd_lkstats);

	gfs2_update_stats(&gl->gl_stats, index, rtt);		/* Local */

	gfs2_update_stats(&lks->lkstats[gltype], index, rtt);	/* Global */

	preempt_enable();
@@ -108,7 +108,7 @@ static inline void gfs2_update_request_times(struct gfs2_glock *gl) 
	dstamp = gl->gl_dstamp;

	gl->gl_dstamp = ktime_get_real();

	irt = ktime_to_ns(ktime_sub(gl->gl_dstamp, dstamp));

	lks = this_cpu_ptr(gl->gl_sbd->sd_lkstats);

	lks = this_cpu_ptr(gl->gl_name.ln_sbd->sd_lkstats);

	gfs2_update_stats(&gl->gl_stats, GFS2_LKS_SIRT, irt);		/* Local */

	gfs2_update_stats(&lks->lkstats[gltype], GFS2_LKS_SIRT, irt);	/* Global */

	preempt_enable();
@@ -253,7 +253,7 @@ static void gfs2_reverse_hex(char *c, u64 value) 
static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state,

		     unsigned int flags)

{

	struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;

	struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;

	int req;

	u32 lkf;

	char strname[GDLM_STRNAME_BYTES] = "";
@@ -281,7 +281,7 @@ static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state, 


static void gdlm_put_lock(struct gfs2_glock *gl)

{

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct lm_lockstruct *ls = &sdp->sd_lockstruct;

	int lvb_needs_unlock = 0;

	int error;
@@ -319,7 +319,7 @@ static void gdlm_put_lock(struct gfs2_glock *gl) 


static void gdlm_cancel(struct gfs2_glock *gl)

{

	struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;

	struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;

	dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_CANCEL, NULL, gl);

}

fs/gfs2/lops.c

+3 −3
Original line number Diff line number Diff line
@@ -70,7 +70,7 @@ static bool buffer_is_rgrp(const struct gfs2_bufdata *bd) 
static void maybe_release_space(struct gfs2_bufdata *bd)

{

	struct gfs2_glock *gl = bd->bd_gl;

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	struct gfs2_rgrpd *rgd = gl->gl_object;

	unsigned int index = bd->bd_bh->b_blocknr - gl->gl_name.ln_number;

	struct gfs2_bitmap *bi = rgd->rd_bits + index;
@@ -585,7 +585,7 @@ static int buf_lo_scan_elements(struct gfs2_jdesc *jd, unsigned int start, 
static void gfs2_meta_sync(struct gfs2_glock *gl)

{

	struct address_space *mapping = gfs2_glock2aspace(gl);

	struct gfs2_sbd *sdp = gl->gl_sbd;

	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	int error;



	if (mapping == NULL)
@@ -595,7 +595,7 @@ static void gfs2_meta_sync(struct gfs2_glock *gl) 
	error = filemap_fdatawait(mapping);



	if (error)

		gfs2_io_error(gl->gl_sbd);

		gfs2_io_error(gl->gl_name.ln_sbd);

}



static void buf_lo_after_scan(struct gfs2_jdesc *jd, int error, int pass)