Commit 0ec49e7e authored by Andreas Gruenbacher's avatar Andreas Gruenbacher
Browse files

gfs2: Introduce glock_{type,number,sbd} helpers 



Introduce glock_type(), glock_number(), and glock_sbd() helpers for
accessing a glock's type, number, and super block pointer more easily.

Created with Coccinelle using the following semantic patch:

@@ struct gfs2_glock *gl; @@
- gl->gl_name.ln_type
+ glock_type(gl)

@@ struct gfs2_glock *gl; @@
- gl->gl_name.ln_number
+ glock_number(gl)

@@ struct gfs2_glock *gl; @@
- gl->gl_name.ln_sbd
+ glock_sbd(gl)

glock_sbd() is a macro because it is used with const as well as
non-const struct gfs2_glock * arguments.

Instances in macro definitions, particularly in tracepoint definitions,
replaced by hand.

Signed-off-by: default avatarAndreas Gruenbacher <agruenba@redhat.com>
parent d3b39fcb

fs/gfs2/glock.c

+41 −41
Original line number Diff line number Diff line
@@ -147,7 +147,7 @@ static void __gfs2_glock_free(struct gfs2_glock *gl) 
}



void gfs2_glock_free(struct gfs2_glock *gl) {

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	__gfs2_glock_free(gl);

	if (atomic_dec_and_test(&sdp->sd_glock_disposal))
@@ -155,7 +155,7 @@ void gfs2_glock_free(struct gfs2_glock *gl) { 
}



void gfs2_glock_free_later(struct gfs2_glock *gl) {

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	spin_lock(&lru_lock);

	list_add(&gl->gl_lru, &sdp->sd_dead_glocks);
@@ -219,7 +219,7 @@ static void gfs2_glock_remove_from_lru(struct gfs2_glock *gl) 
 * work queue.

 */

static void gfs2_glock_queue_work(struct gfs2_glock *gl, unsigned long delay) {

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	if (!queue_delayed_work(sdp->sd_glock_wq, &gl->gl_work, delay)) {

		/*
@@ -235,7 +235,7 @@ static void gfs2_glock_queue_work(struct gfs2_glock *gl, unsigned long delay) { 


static void __gfs2_glock_put(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct address_space *mapping = gfs2_glock2aspace(gl);



	lockref_mark_dead(&gl->gl_lockref);
@@ -357,7 +357,7 @@ static void gfs2_holder_wake(struct gfs2_holder *gh) 
	smp_mb__after_atomic();

	wake_up_bit(&gh->gh_iflags, HIF_WAIT);

	if (gh->gh_flags & GL_ASYNC) {

		struct gfs2_sbd *sdp = gh->gh_gl->gl_name.ln_sbd;

		struct gfs2_sbd *sdp = glock_sbd(gh->gh_gl);



		wake_up(&sdp->sd_async_glock_wait);

	}
@@ -459,7 +459,7 @@ int gfs2_instantiate(struct gfs2_holder *gh) 


static void do_promote(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct gfs2_holder *gh, *current_gh;



	if (gfs2_withdrawn(sdp)) {
@@ -539,7 +539,7 @@ static void state_change(struct gfs2_glock *gl, unsigned int new_state) 


static void gfs2_set_demote(int nr, struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	set_bit(nr, &gl->gl_flags);

	smp_mb();
@@ -611,9 +611,9 @@ static void finish_xmote(struct gfs2_glock *gl, unsigned int ret) 
			do_xmote(gl, gh, LM_ST_UNLOCKED, false);

			break;

		default: /* Everything else */

			fs_err(gl->gl_name.ln_sbd,

			fs_err(glock_sbd(gl),

			       "glock %u:%llu requested=%u ret=%u\n",

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

			       glock_type(gl), glock_number(gl),

			       gl->gl_req, ret);

			GLOCK_BUG_ON(gl, 1);

		}
@@ -659,7 +659,7 @@ __releases(&gl->gl_lockref.lock) 
__acquires(&gl->gl_lockref.lock)

{

	const struct gfs2_glock_operations *glops = gl->gl_ops;

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct lm_lockstruct *ls = &sdp->sd_lockstruct;

	int ret;
@@ -819,7 +819,7 @@ void glock_set_object(struct gfs2_glock *gl, void *object) 
	prev_object = gl->gl_object;

	gl->gl_object = object;

	spin_unlock(&gl->gl_lockref.lock);

	if (gfs2_assert_warn(gl->gl_name.ln_sbd, prev_object == NULL))

	if (gfs2_assert_warn(glock_sbd(gl), prev_object == NULL))

		gfs2_dump_glock(NULL, gl, true);

}
@@ -836,7 +836,7 @@ void glock_clear_object(struct gfs2_glock *gl, void *object) 
	prev_object = gl->gl_object;

	gl->gl_object = NULL;

	spin_unlock(&gl->gl_lockref.lock);

	if (gfs2_assert_warn(gl->gl_name.ln_sbd, prev_object == object))

	if (gfs2_assert_warn(glock_sbd(gl), prev_object == object))

		gfs2_dump_glock(NULL, gl, true);

}
@@ -926,7 +926,7 @@ static void gfs2_try_to_evict(struct gfs2_glock *gl) 


bool gfs2_queue_try_to_evict(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	if (test_and_set_bit(GLF_TRY_TO_EVICT, &gl->gl_flags))

		return false;
@@ -935,7 +935,7 @@ bool gfs2_queue_try_to_evict(struct gfs2_glock *gl) 


bool gfs2_queue_verify_delete(struct gfs2_glock *gl, bool later)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	unsigned long delay;



	if (test_and_set_bit(GLF_VERIFY_DELETE, &gl->gl_flags))
@@ -948,7 +948,7 @@ static void delete_work_func(struct work_struct *work) 
{

	struct delayed_work *dwork = to_delayed_work(work);

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

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	bool verify_delete = test_and_clear_bit(GLF_VERIFY_DELETE, &gl->gl_flags);



	/*
@@ -961,7 +961,7 @@ static void delete_work_func(struct work_struct *work) 
		gfs2_try_to_evict(gl);



	if (verify_delete) {

		u64 no_addr = gl->gl_name.ln_number;

		u64 no_addr = glock_number(gl);

		struct inode *inode;



		inode = gfs2_lookup_by_inum(sdp, no_addr, gl->gl_no_formal_ino,
@@ -995,7 +995,7 @@ static void glock_work_func(struct work_struct *work) 
	if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&

	    gl->gl_state != LM_ST_UNLOCKED &&

	    gl->gl_demote_state != LM_ST_EXCLUSIVE) {

		if (gl->gl_name.ln_type == LM_TYPE_INODE) {

		if (glock_type(gl) == LM_TYPE_INODE) {

			unsigned long holdtime, now = jiffies;



			holdtime = gl->gl_tchange + gl->gl_hold_time;
@@ -1137,7 +1137,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	gl->gl_object = NULL;

	gl->gl_hold_time = GL_GLOCK_DFT_HOLD;

	INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);

	if (gl->gl_name.ln_type == LM_TYPE_IOPEN)

	if (glock_type(gl) == LM_TYPE_IOPEN)

		INIT_DELAYED_WORK(&gl->gl_delete, delete_work_func);



	mapping = gfs2_glock2aspace(gl);
@@ -1295,7 +1295,7 @@ static int glocks_pending(unsigned int num_gh, struct gfs2_holder *ghs) 
int gfs2_glock_async_wait(unsigned int num_gh, struct gfs2_holder *ghs,

			  unsigned int retries)

{

	struct gfs2_sbd *sdp = ghs[0].gh_gl->gl_name.ln_sbd;

	struct gfs2_sbd *sdp = glock_sbd(ghs[0].gh_gl);

	unsigned long start_time = jiffies;

	int i, ret = 0;

	long timeout;
@@ -1437,7 +1437,7 @@ static inline bool pid_is_meaningful(const struct gfs2_holder *gh) 
static inline void add_to_queue(struct gfs2_holder *gh)

{

	struct gfs2_glock *gl = gh->gh_gl;

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct gfs2_holder *gh2;



	GLOCK_BUG_ON(gl, gh->gh_owner_pid == NULL);
@@ -1470,11 +1470,11 @@ static inline void add_to_queue(struct gfs2_holder *gh) 
	fs_err(sdp, "original: %pSR\n", (void *)gh2->gh_ip);

	fs_err(sdp, "pid: %d\n", pid_nr(gh2->gh_owner_pid));

	fs_err(sdp, "lock type: %d req lock state : %d\n",

	       gh2->gh_gl->gl_name.ln_type, gh2->gh_state);

	       glock_type(gh2->gh_gl), gh2->gh_state);

	fs_err(sdp, "new: %pSR\n", (void *)gh->gh_ip);

	fs_err(sdp, "pid: %d\n", pid_nr(gh->gh_owner_pid));

	fs_err(sdp, "lock type: %d req lock state : %d\n",

	       gh->gh_gl->gl_name.ln_type, gh->gh_state);

	       glock_type(gh->gh_gl), gh->gh_state);

	gfs2_dump_glock(NULL, gl, true);

	BUG();

}
@@ -1491,7 +1491,7 @@ static inline void add_to_queue(struct gfs2_holder *gh) 
int gfs2_glock_nq(struct gfs2_holder *gh)

{

	struct gfs2_glock *gl = gh->gh_gl;

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	int error;



	if (gfs2_withdrawn(sdp))
@@ -1580,7 +1580,7 @@ static void __gfs2_glock_dq(struct gfs2_holder *gh) 
		gl->gl_lockref.count++;

		if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&

		    !test_bit(GLF_DEMOTE, &gl->gl_flags) &&

		    gl->gl_name.ln_type == LM_TYPE_INODE)

		    glock_type(gl) == LM_TYPE_INODE)

			delay = gl->gl_hold_time;

		gfs2_glock_queue_work(gl, delay);

	}
@@ -1624,7 +1624,7 @@ void gfs2_glock_dq(struct gfs2_holder *gh) 


		set_bit(GLF_CANCELING, &gl->gl_flags);

		spin_unlock(&gl->gl_lockref.lock);

		gl->gl_name.ln_sbd->sd_lockstruct.ls_ops->lm_cancel(gl);

		glock_sbd(gl)->sd_lockstruct.ls_ops->lm_cancel(gl);

		wait_on_bit(&gh->gh_iflags, HIF_WAIT, TASK_UNINTERRUPTIBLE);

		spin_lock(&gl->gl_lockref.lock);

		clear_bit(GLF_CANCELING, &gl->gl_flags);
@@ -1798,7 +1798,7 @@ void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state) 
	gfs2_glock_hold(gl);

	spin_lock(&gl->gl_lockref.lock);

	if (!list_empty(&gl->gl_holders) &&

	    gl->gl_name.ln_type == LM_TYPE_INODE) {

	    glock_type(gl) == LM_TYPE_INODE) {

		unsigned long now = jiffies;

		unsigned long holdtime;
@@ -1855,7 +1855,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_name.ln_sbd->sd_lockstruct;

	struct lm_lockstruct *ls = &glock_sbd(gl)->sd_lockstruct;



	spin_lock(&gl->gl_lockref.lock);

	clear_bit(GLF_MAY_CANCEL, &gl->gl_flags);
@@ -1883,9 +1883,9 @@ static int glock_cmp(void *priv, const struct list_head *a, 
	gla = list_entry(a, struct gfs2_glock, gl_lru);

	glb = list_entry(b, struct gfs2_glock, gl_lru);



	if (gla->gl_name.ln_number > glb->gl_name.ln_number)

	if (glock_number(gla) > glock_number(glb))

		return 1;

	if (gla->gl_name.ln_number < glb->gl_name.ln_number)

	if (glock_number(gla) < glock_number(glb))

		return -1;



	return 0;
@@ -1893,7 +1893,7 @@ static int glock_cmp(void *priv, const struct list_head *a, 


static bool can_free_glock(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	return !test_bit(GLF_LOCK, &gl->gl_flags) &&

	       !gl->gl_lockref.count &&
@@ -2015,7 +2015,7 @@ static void glock_hash_walk(glock_examiner examiner, const struct gfs2_sbd *sdp) 
		rhashtable_walk_start(&iter);



		while ((gl = rhashtable_walk_next(&iter)) && !IS_ERR(gl)) {

			if (gl->gl_name.ln_sbd == sdp)

			if (glock_sbd(gl) == sdp)

				examiner(gl);

		}
@@ -2035,8 +2035,8 @@ void gfs2_cancel_delete_work(struct gfs2_glock *gl) 


static void flush_delete_work(struct gfs2_glock *gl)

{

	if (gl->gl_name.ln_type == LM_TYPE_IOPEN) {

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

	if (glock_type(gl) == LM_TYPE_IOPEN) {

		struct gfs2_sbd *sdp = glock_sbd(gl);



		if (cancel_delayed_work(&gl->gl_delete)) {

			queue_delayed_work(sdp->sd_delete_wq,
@@ -2321,7 +2321,7 @@ void gfs2_dump_glock(struct seq_file *seq, struct gfs2_glock *gl, bool fsid) 
	unsigned long long dtime;

	const struct gfs2_holder *gh;

	char gflags_buf[32];

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	char fs_id_buf[sizeof(sdp->sd_fsname) + 7];

	unsigned long nrpages = 0;
@@ -2340,8 +2340,8 @@ void gfs2_dump_glock(struct seq_file *seq, struct gfs2_glock *gl, bool fsid) 
	gfs2_print_dbg(seq, "%sG:  s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d "

		       "v:%d r:%d m:%ld p:%lu\n",

		       fs_id_buf, state2str(gl->gl_state),

		       gl->gl_name.ln_type,

		       (unsigned long long)gl->gl_name.ln_number,

		       glock_type(gl),

		       (unsigned long long) glock_number(gl),

		       gflags2str(gflags_buf, gl),

		       state2str(gl->gl_target),

		       state2str(gl->gl_demote_state), dtime,
@@ -2361,8 +2361,8 @@ static int gfs2_glstats_seq_show(struct seq_file *seq, void *iter_ptr) 
	struct gfs2_glock *gl = iter_ptr;



	seq_printf(seq, "G: n:%u/%llx rtt:%llu/%llu rttb:%llu/%llu irt:%llu/%llu dcnt: %llu qcnt: %llu\n",

		   gl->gl_name.ln_type,

		   (unsigned long long)gl->gl_name.ln_number,

		   glock_type(gl),

		   (unsigned long long) glock_number(gl),

		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTT],

		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTVAR],

		   (unsigned long long)gl->gl_stats.stats[GFS2_LKS_SRTTB],
@@ -2478,7 +2478,7 @@ static void gfs2_glock_iter_next(struct gfs2_glock_iter *gi, loff_t n) 
			gl = NULL;

			break;

		}

		if (gl->gl_name.ln_sbd != gi->sdp)

		if (glock_sbd(gl) != gi->sdp)

			continue;

		if (n <= 1) {

			if (!lockref_get_not_dead(&gl->gl_lockref))
@@ -2774,8 +2774,8 @@ static int gfs2_glockfd_seq_show(struct seq_file *seq, void *iter_ptr) 
	gl = GFS2_I(inode)->i_iopen_gh.gh_gl;

	if (gl) {

		seq_printf(seq, "%d %u %u/%llx\n",

			   i->tgid, i->fd, gl->gl_name.ln_type,

			   (unsigned long long)gl->gl_name.ln_number);

			   i->tgid, i->fd, glock_type(gl),

			   (unsigned long long) glock_number(gl));

	}

	gfs2_glockfd_seq_show_flock(seq, i);

	inode_unlock_shared(inode);

fs/gfs2/glock.h

+2 −2
Original line number Diff line number Diff line
@@ -222,11 +222,11 @@ void gfs2_dump_glock(struct seq_file *seq, struct gfs2_glock *gl, 
			BUG(); } } while(0)

#define gfs2_glock_assert_warn(gl, x) do { if (unlikely(!(x))) {	\

			gfs2_dump_glock(NULL, gl, true);		\

			gfs2_assert_warn((gl)->gl_name.ln_sbd, (x)); } } \

			gfs2_assert_warn(glock_sbd(gl), (x)); } } \

	while (0)

#define gfs2_glock_assert_withdraw(gl, x) do { if (unlikely(!(x))) {	\

			gfs2_dump_glock(NULL, gl, true);		\

			gfs2_assert_withdraw((gl)->gl_name.ln_sbd, (x)); } } \

			gfs2_assert_withdraw(glock_sbd(gl), (x)); } } \

	while (0)



__printf(2, 3)

fs/gfs2/glops.c

+17 −17
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ struct workqueue_struct *gfs2_freeze_wq; 


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

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	fs_err(sdp,

	       "AIL buffer %p: blocknr %llu state 0x%08lx mapping %p page "
@@ -40,7 +40,7 @@ static void gfs2_ail_error(struct gfs2_glock *gl, const struct buffer_head *bh) 
	       bh, (unsigned long long)bh->b_blocknr, bh->b_state,

	       bh->b_folio->mapping, bh->b_folio->flags.f);

	fs_err(sdp, "AIL glock %u:%llu mapping %p\n",

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

	       glock_type(gl), glock_number(gl),

	       gfs2_glock2aspace(gl));

	gfs2_lm(sdp, "AIL error\n");

	gfs2_withdraw(sdp);
@@ -58,7 +58,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_name.ln_sbd;

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct list_head *head = &gl->gl_ail_list;

	struct gfs2_bufdata *bd, *tmp;

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


static int gfs2_ail_empty_gl(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct gfs2_trans tr;

	unsigned int revokes;

	int ret = 0;
@@ -139,7 +139,7 @@ static int gfs2_ail_empty_gl(struct gfs2_glock *gl) 


void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

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

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


static int gfs2_rgrp_metasync(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct address_space *metamapping = gfs2_aspace(sdp);

	struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(gl);

	const unsigned bsize = sdp->sd_sb.sb_bsize;
@@ -191,7 +191,7 @@ static int gfs2_rgrp_metasync(struct gfs2_glock *gl) 


static int rgrp_go_sync(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(gl);

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


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

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct address_space *mapping = gfs2_aspace(sdp);

	struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(gl);

	const unsigned bsize = sdp->sd_sb.sb_bsize;
@@ -290,7 +290,7 @@ int gfs2_inode_metasync(struct gfs2_glock *gl) 
	filemap_fdatawrite(metamapping);

	error = filemap_fdatawait(metamapping);

	if (error)

		gfs2_io_error(gl->gl_name.ln_sbd);

		gfs2_io_error(glock_sbd(gl));

	return error;

}
@@ -317,7 +317,7 @@ static int inode_go_sync(struct gfs2_glock *gl) 


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



	gfs2_log_flush(gl->gl_name.ln_sbd, gl, GFS2_LOG_HEAD_FLUSH_NORMAL |

	gfs2_log_flush(glock_sbd(gl), gl, GFS2_LOG_HEAD_FLUSH_NORMAL |

		       GFS2_LFC_INODE_GO_SYNC);

	filemap_fdatawrite(metamapping);

	if (isreg) {
@@ -359,7 +359,7 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags) 
{

	struct gfs2_inode *ip = gfs2_glock2inode(gl);



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

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



	if (flags & DIO_METADATA) {

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

	}



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

		gfs2_log_flush(gl->gl_name.ln_sbd, NULL,

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

		gfs2_log_flush(glock_sbd(gl), NULL,

			       GFS2_LOG_HEAD_FLUSH_NORMAL |

			       GFS2_LFC_INODE_GO_INVAL);

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

		glock_sbd(gl)->sd_rindex_uptodate = 0;

	}

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

		truncate_inode_pages(ip->i_inode.i_mapping, 0);
@@ -567,7 +567,7 @@ static void inode_go_dump(struct seq_file *seq, const struct gfs2_glock *gl, 


static void freeze_go_callback(struct gfs2_glock *gl, bool remote)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct super_block *sb = sdp->sd_vfs;



	if (!remote ||
@@ -596,7 +596,7 @@ static void freeze_go_callback(struct gfs2_glock *gl, bool remote) 
 */

static int freeze_go_xmote_bh(struct gfs2_glock *gl)

{

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

	struct gfs2_sbd *sdp = glock_sbd(gl);

	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;
@@ -626,7 +626,7 @@ static int freeze_go_xmote_bh(struct gfs2_glock *gl) 
static void iopen_go_callback(struct gfs2_glock *gl, bool remote)

{

	struct gfs2_inode *ip = gl->gl_object;

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

	struct gfs2_sbd *sdp = glock_sbd(gl);



	if (!remote || test_bit(SDF_KILL, &sdp->sd_flags))

		return;

fs/gfs2/incore.h

+14 −2
Original line number Diff line number Diff line
@@ -369,6 +369,16 @@ struct gfs2_glock { 
	struct rhash_head gl_node;

};



static inline unsigned int glock_type(const struct gfs2_glock *gl)

{

	return gl->gl_name.ln_type;

}



static inline u64 glock_number(const struct gfs2_glock *gl)

{

	return gl->gl_name.ln_number;

}



enum {

	GIF_QD_LOCKED		= 1,

	GIF_SW_PAGED		= 3,
@@ -839,6 +849,8 @@ struct gfs2_sbd { 
	struct dentry *debugfs_dir;    /* debugfs directory */

};



#define glock_sbd(gl) ((gl)->gl_name.ln_sbd)



#define GFS2_BAD_INO 1



static inline struct address_space *gfs2_aspace(struct gfs2_sbd *sdp)
@@ -853,9 +865,9 @@ 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_name.ln_sbd;

	const struct gfs2_sbd *sdp = glock_sbd(gl);

	preempt_disable();

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

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

	preempt_enable();

}

fs/gfs2/lock_dlm.c

+14 −14
Original line number Diff line number Diff line
@@ -74,13 +74,13 @@ static inline void gfs2_update_reply_times(struct gfs2_glock *gl, 
					   bool blocking)

{

	struct gfs2_pcpu_lkstats *lks;

	const unsigned gltype = gl->gl_name.ln_type;

	const unsigned gltype = glock_type(gl);

	unsigned index = blocking ? GFS2_LKS_SRTTB : GFS2_LKS_SRTT;

	s64 rtt;



	preempt_disable();

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

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

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

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

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

	preempt_enable();
@@ -100,7 +100,7 @@ static inline void gfs2_update_reply_times(struct gfs2_glock *gl, 
static inline void gfs2_update_request_times(struct gfs2_glock *gl)

{

	struct gfs2_pcpu_lkstats *lks;

	const unsigned gltype = gl->gl_name.ln_type;

	const unsigned gltype = glock_type(gl);

	ktime_t dstamp;

	s64 irt;
@@ -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_name.ln_sbd->sd_lkstats);

	lks = this_cpu_ptr(glock_sbd(gl)->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();
@@ -195,7 +195,7 @@ static void gdlm_bast(void *arg, int mode) 
		gfs2_glock_cb(gl, LM_ST_SHARED);

		break;

	default:

		fs_err(gl->gl_name.ln_sbd, "unknown bast mode %d\n", mode);

		fs_err(glock_sbd(gl), "unknown bast mode %d\n", mode);

		BUG();

	}

}
@@ -276,7 +276,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_name.ln_sbd->sd_lockstruct;

	struct lm_lockstruct *ls = &glock_sbd(gl)->sd_lockstruct;

	bool blocking;

	int cur, req;

	u32 lkf;
@@ -284,8 +284,8 @@ static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state, 
	int error;



	gl->gl_req = req_state;

	cur = make_mode(gl->gl_name.ln_sbd, gl->gl_state);

	req = make_mode(gl->gl_name.ln_sbd, req_state);

	cur = make_mode(glock_sbd(gl), gl->gl_state);

	req = make_mode(glock_sbd(gl), req_state);

	blocking = !down_conversion(cur, req) &&

		   !(flags & (LM_FLAG_TRY|LM_FLAG_TRY_1CB));

	lkf = make_flags(gl, flags, req, blocking);
@@ -296,8 +296,8 @@ static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state, 
	if (test_bit(GLF_INITIAL, &gl->gl_flags)) {

		memset(strname, ' ', GDLM_STRNAME_BYTES - 1);

		strname[GDLM_STRNAME_BYTES - 1] = '\0';

		gfs2_reverse_hex(strname + 7, gl->gl_name.ln_type);

		gfs2_reverse_hex(strname + 23, gl->gl_name.ln_number);

		gfs2_reverse_hex(strname + 7, glock_type(gl));

		gfs2_reverse_hex(strname + 23, glock_number(gl));

		gl->gl_dstamp = ktime_get_real();

	} else {

		gfs2_update_request_times(gl);
@@ -323,7 +323,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_name.ln_sbd;

	struct gfs2_sbd *sdp = glock_sbd(gl);

	struct lm_lockstruct *ls = &sdp->sd_lockstruct;

	uint32_t flags = 0;

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


	if (error) {

		fs_err(sdp, "gdlm_unlock %x,%llx err=%d\n",

		       gl->gl_name.ln_type,

		       (unsigned long long)gl->gl_name.ln_number, error);

		       glock_type(gl),

		       (unsigned long long) glock_number(gl), error);

	}

}



static void gdlm_cancel(struct gfs2_glock *gl)

{

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

	struct lm_lockstruct *ls = &glock_sbd(gl)->sd_lockstruct;



	down_read(&ls->ls_sem);

	if (likely(ls->ls_dlm != NULL)) {