Commit 8c3c0743 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-5.7-merge-12' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull more xfs updates from Darrick Wong:
 "As promised last week, this batch changes how xfs interacts with
  memory reclaim; how the log batches and throttles log items; how hard
  writes near ENOSPC will try to squeeze more space out of the
  filesystem; and hopefully fix the last of the umount hangs after a
  catastrophic failure.

  Summary:

   - Validate the realtime geometry in the superblock when mounting

   - Refactor a bunch of tricky flag handling in the log code

   - Flush the CIL more judiciously so that we don't wait until there
     are millions of log items consuming a lot of memory.

   - Throttle transaction commits to prevent the xfs frontend from
     flooding the CIL with too many log items.

   - Account metadata buffers correctly for memory reclaim.

   - Mark slabs properly for memory reclaim. These should help reclaim
     run more effectively when XFS is using a lot of memory.

   - Don't write a garbage log record at unmount time if we're trying to
     trigger summary counter recalculation at next mount.

   - Don't block the AIL on locked dquot/inode buffers; instead trigger
     its backoff mechanism to give the lock holder a chance to finish
     up.

   - Ratelimit writeback flushing when buffered writes encounter ENOSPC.

   - Other minor cleanups.

   - Make reflink a synchronous operation when the fs is mounted with
     wsync or sync, which means that now we force the log to disk to
     record the changes"

* tag 'xfs-5.7-merge-12' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (26 commits)
  xfs: reflink should force the log out if mounted with wsync
  xfs: factor out a new xfs_log_force_inode helper
  xfs: fix inode number overflow in ifree cluster helper
  xfs: remove redundant variable assignment in xfs_symlink()
  xfs: ratelimit inode flush on buffered write ENOSPC
  xfs: return locked status of inode buffer on xfsaild push
  xfs: trylock underlying buffer on dquot flush
  xfs: remove unnecessary ternary from xfs_create
  xfs: don't write a corrupt unmount record to force summary counter recalc
  xfs: factor inode lookup from xfs_ifree_cluster
  xfs: tail updates only need to occur when LSN changes
  xfs: factor common AIL item deletion code
  xfs: correctly acount for reclaimable slabs
  xfs: Improve metadata buffer reclaim accountability
  xfs: don't allow log IO to be throttled
  xfs: Throttle commits on delayed background CIL push
  xfs: Lower CIL flush limit for large logs
  xfs: remove some stale comments from the log code
  xfs: refactor unmount record writing
  xfs: merge xlog_commit_record with xlog_write_done
  ...
parents d3e5e977 5833112d

fs/xfs/libxfs/xfs_sb.c

+32 −0
Original line number Diff line number Diff line
@@ -328,6 +328,38 @@ xfs_validate_sb_common( 
		return -EFSCORRUPTED;

	}



	/* Validate the realtime geometry; stolen from xfs_repair */

	if (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE ||

	    sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) {

		xfs_notice(mp,

			"realtime extent sanity check failed");

		return -EFSCORRUPTED;

	}



	if (sbp->sb_rblocks == 0) {

		if (sbp->sb_rextents != 0 || sbp->sb_rbmblocks != 0 ||

		    sbp->sb_rextslog != 0 || sbp->sb_frextents != 0) {

			xfs_notice(mp,

				"realtime zeroed geometry check failed");

			return -EFSCORRUPTED;

		}

	} else {

		uint64_t	rexts;

		uint64_t	rbmblocks;



		rexts = div_u64(sbp->sb_rblocks, sbp->sb_rextsize);

		rbmblocks = howmany_64(sbp->sb_rextents,

				       NBBY * sbp->sb_blocksize);



		if (sbp->sb_rextents != rexts ||

		    sbp->sb_rextslog != xfs_highbit32(sbp->sb_rextents) ||

		    sbp->sb_rbmblocks != rbmblocks) {

			xfs_notice(mp,

				"realtime geometry sanity check failed");

			return -EFSCORRUPTED;

		}

	}



	if (sbp->sb_unit) {

		if (!xfs_sb_version_hasdalign(sbp) ||

		    sbp->sb_unit > sbp->sb_width ||

fs/xfs/xfs_buf.c

+8 −3
Original line number Diff line number Diff line
@@ -327,6 +327,9 @@ xfs_buf_free( 


			__free_page(page);

		}

		if (current->reclaim_state)

			current->reclaim_state->reclaimed_slab +=

							bp->b_page_count;

	} else if (bp->b_flags & _XBF_KMEM)

		kmem_free(bp->b_addr);

	_xfs_buf_free_pages(bp);
@@ -2114,9 +2117,11 @@ xfs_buf_delwri_pushbuf( 
int __init

xfs_buf_init(void)

{

	xfs_buf_zone = kmem_cache_create("xfs_buf",

					 sizeof(struct xfs_buf), 0,

					 SLAB_HWCACHE_ALIGN, NULL);

	xfs_buf_zone = kmem_cache_create("xfs_buf", sizeof(struct xfs_buf), 0,

					 SLAB_HWCACHE_ALIGN |

					 SLAB_RECLAIM_ACCOUNT |

					 SLAB_MEM_SPREAD,

					 NULL);

	if (!xfs_buf_zone)

		goto out;

fs/xfs/xfs_dquot.c

+3 −3
Original line number Diff line number Diff line
@@ -1105,8 +1105,8 @@ xfs_qm_dqflush( 
	 * Get the buffer containing the on-disk dquot

	 */

	error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,

				   mp->m_quotainfo->qi_dqchunklen, 0, &bp,

				   &xfs_dquot_buf_ops);

				   mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK,

				   &bp, &xfs_dquot_buf_ops);

	if (error)

		goto out_unlock;
@@ -1177,7 +1177,7 @@ xfs_qm_dqflush( 


out_unlock:

	xfs_dqfunlock(dqp);

	return -EIO;

	return error;

}



/*

fs/xfs/xfs_dquot_item.c

+2 −1
Original line number Diff line number Diff line
@@ -189,7 +189,8 @@ xfs_qm_dquot_logitem_push( 
		if (!xfs_buf_delwri_queue(bp, buffer_list))

			rval = XFS_ITEM_FLUSHING;

		xfs_buf_relse(bp);

	}

	} else if (error == -EAGAIN)

		rval = XFS_ITEM_LOCKED;



	spin_lock(&lip->li_ailp->ail_lock);

out_unlock:

fs/xfs/xfs_export.c

+1 −13
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ 
#include "xfs_trans.h"

#include "xfs_inode_item.h"

#include "xfs_icache.h"

#include "xfs_log.h"

#include "xfs_pnfs.h"



/*
@@ -221,18 +220,7 @@ STATIC int 
xfs_fs_nfs_commit_metadata(

	struct inode		*inode)

{

	struct xfs_inode	*ip = XFS_I(inode);

	struct xfs_mount	*mp = ip->i_mount;

	xfs_lsn_t		lsn = 0;



	xfs_ilock(ip, XFS_ILOCK_SHARED);

	if (xfs_ipincount(ip))

		lsn = ip->i_itemp->ili_last_lsn;

	xfs_iunlock(ip, XFS_ILOCK_SHARED);



	if (!lsn)

		return 0;

	return xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);

	return xfs_log_force_inode(XFS_I(inode));

}



const struct export_operations xfs_export_operations = {

CRA Git | Maintained and supported by SUSTech CRA and CCSE