Commit f6e1e1d1 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'gfs2-for-5.12' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2 

Pull gfs2 updates from Andreas Gruenbacher:

 - Log space and revoke accounting rework to fix some failed asserts.

 - Local resource group glock sharing for better local performance.

 - Add support for version 1802 filesystems: trusted xattr support and
   '-o rgrplvb' mounts by default.

 - Actually synchronize on the inode glock's FREEING bit during withdraw
   ("gfs2: fix glock confusion in function signal_our_withdraw").

 - Fix parallel recovery of multiple journals ("gfs2: keep bios separate
   for each journal").

 - Various other bug fixes.

* tag 'gfs2-for-5.12' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2: (49 commits)
  gfs2: Don't get stuck with I/O plugged in gfs2_ail1_flush
  gfs2: Per-revoke accounting in transactions
  gfs2: Rework the log space allocation logic
  gfs2: Minor calc_reserved cleanup
  gfs2: Use resource group glock sharing
  gfs2: Allow node-wide exclusive glock sharing
  gfs2: Add local resource group locking
  gfs2: Add per-reservation reserved block accounting
  gfs2: Rename rs_{free -> requested} and rd_{reserved -> requested}
  gfs2: Check for active reservation in gfs2_release
  gfs2: Don't search for unreserved space twice
  gfs2: Only pass reservation down to gfs2_rbm_find
  gfs2: Also reflect single-block allocations in rgd->rd_extfail_pt
  gfs2: Recursive gfs2_quota_hold in gfs2_iomap_end
  gfs2: Add trusted xattr support
  gfs2: Enable rgrplvb for sb_fs_format 1802
  gfs2: Don't skip dlm unlock if glock has an lvb
  gfs2: Lock imbalance on error path in gfs2_recover_one
  gfs2: Move function gfs2_ail_empty_tr
  gfs2: Get rid of current_tail()
  ...
parents 7d6beb71 17d77684

fs/gfs2/bmap.c

+5 −5
Original line number Diff line number Diff line
@@ -1230,6 +1230,9 @@ static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length, 


	gfs2_inplace_release(ip);



	if (ip->i_qadata && ip->i_qadata->qa_qd_num)

		gfs2_quota_unlock(ip);



	if (length != written && (iomap->flags & IOMAP_F_NEW)) {

		/* Deallocate blocks that were just allocated. */

		loff_t blockmask = i_blocksize(inode) - 1;
@@ -1242,9 +1245,6 @@ static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length, 
		}

	}



	if (ip->i_qadata && ip->i_qadata->qa_qd_num)

		gfs2_quota_unlock(ip);



	if (unlikely(!written))

		goto out_unlock;
@@ -1538,13 +1538,13 @@ static int sweep_bh_for_rgrps(struct gfs2_inode *ip, struct gfs2_holder *rd_gh, 
				goto out;

			}

			ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,

						 0, rd_gh);

						 LM_FLAG_NODE_SCOPE, rd_gh);

			if (ret)

				goto out;



			/* Must be done with the rgrp glock held: */

			if (gfs2_rs_active(&ip->i_res) &&

			    rgd == ip->i_res.rs_rbm.rgd)

			    rgd == ip->i_res.rs_rgd)

				gfs2_rs_deltree(&ip->i_res);

		}

fs/gfs2/file.c

+4 −4
Original line number Diff line number Diff line
@@ -716,10 +716,10 @@ static int gfs2_release(struct inode *inode, struct file *file) 
	kfree(file->private_data);

	file->private_data = NULL;



	if (file->f_mode & FMODE_WRITE) {

	if (gfs2_rs_active(&ip->i_res))

		gfs2_rs_delete(ip, &inode->i_writecount);

	if (file->f_mode & FMODE_WRITE)

		gfs2_qa_put(ip);

	}

	return 0;

}
@@ -1112,8 +1112,8 @@ static long __gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t 
			goto out_qunlock;



		/* check if the selected rgrp limits our max_blks further */

		if (ap.allowed && ap.allowed < max_blks)

			max_blks = ap.allowed;

		if (ip->i_res.rs_reserved < max_blks)

			max_blks = ip->i_res.rs_reserved;



		/* Almost done. Calculate bytes that can be written using

		 * max_blks. We also recompute max_bytes, data_blocks and

fs/gfs2/glock.c

+19 −3
Original line number Diff line number Diff line
@@ -313,9 +313,23 @@ void gfs2_glock_put(struct gfs2_glock *gl) 
static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh)

{

	const struct gfs2_holder *gh_head = list_first_entry(&gl->gl_holders, const struct gfs2_holder, gh_list);



	if (gh != gh_head) {

		/**

		 * Here we make a special exception to grant holders who agree

		 * to share the EX lock with other holders who also have the

		 * bit set. If the original holder has the LM_FLAG_NODE_SCOPE bit

		 * is set, we grant more holders with the bit set.

		 */

		if (gh_head->gh_state == LM_ST_EXCLUSIVE &&

		    (gh_head->gh_flags & LM_FLAG_NODE_SCOPE) &&

		    gh->gh_state == LM_ST_EXCLUSIVE &&

		    (gh->gh_flags & LM_FLAG_NODE_SCOPE))

			return 1;

		if ((gh->gh_state == LM_ST_EXCLUSIVE ||

	     gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head)

		     gh_head->gh_state == LM_ST_EXCLUSIVE))

			return 0;

	}

	if (gl->gl_state == gh->gh_state)

		return 1;

	if (gh->gh_flags & GL_EXACT)
@@ -2030,6 +2044,8 @@ static const char *hflags2str(char *buf, u16 flags, unsigned long iflags) 
		*p++ = 'A';

	if (flags & LM_FLAG_PRIORITY)

		*p++ = 'p';

	if (flags & LM_FLAG_NODE_SCOPE)

		*p++ = 'n';

	if (flags & GL_ASYNC)

		*p++ = 'a';

	if (flags & GL_EXACT)

fs/gfs2/glock.h

+6 −0
Original line number Diff line number Diff line
@@ -75,6 +75,11 @@ enum { 
 * request and directly join the other shared lock.  A shared lock request

 * without the priority flag might be forced to wait until the deferred

 * requested had acquired and released the lock.

 *

 * LM_FLAG_NODE_SCOPE

 * This holder agrees to share the lock within this node. In other words,

 * the glock is held in EX mode according to DLM, but local holders on the

 * same node can share it.

 */



#define LM_FLAG_TRY		0x0001
@@ -82,6 +87,7 @@ enum { 
#define LM_FLAG_NOEXP		0x0004

#define LM_FLAG_ANY		0x0008

#define LM_FLAG_PRIORITY	0x0010

#define LM_FLAG_NODE_SCOPE	0x0020

#define GL_ASYNC		0x0040

#define GL_EXACT		0x0080

#define GL_SKIP			0x0100

fs/gfs2/glops.c

+12 −26
Original line number Diff line number Diff line
@@ -86,16 +86,12 @@ static int gfs2_ail_empty_gl(struct gfs2_glock *gl) 
{

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

	struct gfs2_trans tr;

	unsigned int revokes;

	int ret;



	memset(&tr, 0, sizeof(tr));

	INIT_LIST_HEAD(&tr.tr_buf);

	INIT_LIST_HEAD(&tr.tr_databuf);

	INIT_LIST_HEAD(&tr.tr_ail1_list);

	INIT_LIST_HEAD(&tr.tr_ail2_list);

	tr.tr_revokes = atomic_read(&gl->gl_ail_count);

	revokes = atomic_read(&gl->gl_ail_count);



	if (!tr.tr_revokes) {

	if (!revokes) {

		bool have_revokes;

		bool log_in_flight;
@@ -122,20 +118,14 @@ static int gfs2_ail_empty_gl(struct gfs2_glock *gl) 
		return 0;

	}



	/* A shortened, inline version of gfs2_trans_begin()

         * tr->alloced is not set since the transaction structure is

         * on the stack */

	tr.tr_reserved = 1 + gfs2_struct2blk(sdp, tr.tr_revokes);

	tr.tr_ip = _RET_IP_;

	ret = gfs2_log_reserve(sdp, tr.tr_reserved);

	if (ret < 0)

		return ret;

	WARN_ON_ONCE(current->journal_info);

	current->journal_info = &tr;



	__gfs2_ail_flush(gl, 0, tr.tr_revokes);



	memset(&tr, 0, sizeof(tr));

	set_bit(TR_ONSTACK, &tr.tr_flags);

	ret = __gfs2_trans_begin(&tr, sdp, 0, revokes, _RET_IP_);

	if (ret)

		goto flush;

	__gfs2_ail_flush(gl, 0, revokes);

	gfs2_trans_end(sdp);



flush:

	gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |

		       GFS2_LFC_AIL_EMPTY_GL);
@@ -146,19 +136,15 @@ void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync) 
{

	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;



	if (!revokes)

		return;



	while (revokes > max_revokes)

		max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64);



	ret = gfs2_trans_begin(sdp, 0, max_revokes);

	ret = gfs2_trans_begin(sdp, 0, revokes);

	if (ret)

		return;

	__gfs2_ail_flush(gl, fsync, max_revokes);

	__gfs2_ail_flush(gl, fsync, revokes);

	gfs2_trans_end(sdp);

	gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |

		       GFS2_LFC_AIL_FLUSH);