Commit 547c43d7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull xfs updates from Darrick Wong:
 "Here's the first round of fixes for XFS for 4.17.

  The biggest new features this time around are the addition of lazytime
  support, further enhancement of the on-disk inode metadata verifiers,
  and a patch to smooth over some of the AGFL padding problems that have
  intermittently plagued users since 4.5. I forsee sending a second pull
  request next week with further bug fixes and speedups in the online
  scrub code and elsewhere.

  This series has been run through a full xfstests run over the weekend
  and through a quick xfstests run against this morning's master, with
  no major failures reported.

  Summary of changes for this release:

   - Various cleanups and code fixes

   - Implement lazytime as a mount option

   - Convert various on-disk metadata checks from asserts to -EFSCORRUPTED

   - Fix accounting problems with the rmap per-ag reservations

   - Refactorings and cleanups for xfs_log_force

   - Various bugfixes for the reflink code

   - Work around v5 AGFL padding problems to prevent fs shutdowns

   - Establish inode fork verifiers to inspect on-disk metadata
     correctness

   - Various online scrub fixes

   - Fix v5 swapext blowing up on deleted inodes"

* tag 'xfs-4.17-merge-1' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (49 commits)
  xfs: do not log/recover swapext extent owner changes for deleted inodes
  xfs: clean up xfs_mount allocation and dynamic initializers
  xfs: remove dead inode version setting code
  xfs: catch inode allocation state mismatch corruption
  xfs: xfs_scrub_iallocbt_xref_rmap_inodes should use xref_set_corrupt
  xfs: flag inode corruption if parent ptr doesn't get us a real inode
  xfs: don't accept inode buffers with suspicious unlinked chains
  xfs: move inode extent size hint validation to libxfs
  xfs: record inode buf errors as a xref error in inobt scrubber
  xfs: remove xfs_buf parameter from inode scrub methods
  xfs: inode scrubber shouldn't bother with raw checks
  xfs: bmap scrubber should do rmap xref with bmap for sparse files
  xfs: refactor inode buffer verifier error logging
  xfs: refactor inode verifier error logging
  xfs: refactor bmap record validation
  xfs: sanity-check the unused space before trying to use it
  xfs: detect agfl count corruption and reset agfl
  xfs: unwind the try_again loop in xfs_log_force
  xfs: refactor xfs_log_force_lsn
  xfs: minor cleanup for xfs_reflink_end_cow
  ...
parents 2e08edc5 dc1baa71

fs/inode.c

+8 −4
Original line number Diff line number Diff line
@@ -346,9 +346,8 @@ void inc_nlink(struct inode *inode) 
}

EXPORT_SYMBOL(inc_nlink);



void address_space_init_once(struct address_space *mapping)

static void __address_space_init_once(struct address_space *mapping)

{

	memset(mapping, 0, sizeof(*mapping));

	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC | __GFP_ACCOUNT);

	spin_lock_init(&mapping->tree_lock);

	init_rwsem(&mapping->i_mmap_rwsem);
@@ -356,6 +355,12 @@ void address_space_init_once(struct address_space *mapping) 
	spin_lock_init(&mapping->private_lock);

	mapping->i_mmap = RB_ROOT_CACHED;

}



void address_space_init_once(struct address_space *mapping)

{

	memset(mapping, 0, sizeof(*mapping));

	__address_space_init_once(mapping);

}

EXPORT_SYMBOL(address_space_init_once);



/*
@@ -371,7 +376,7 @@ void inode_init_once(struct inode *inode) 
	INIT_LIST_HEAD(&inode->i_io_list);

	INIT_LIST_HEAD(&inode->i_wb_list);

	INIT_LIST_HEAD(&inode->i_lru);

	address_space_init_once(&inode->i_data);

	__address_space_init_once(&inode->i_data);

	i_size_ordered_init(inode);

}

EXPORT_SYMBOL(inode_init_once);
@@ -1533,7 +1538,6 @@ retry: 
	if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock)) {

		if (inode->i_nlink && (inode->i_state & I_DIRTY_TIME)) {

			atomic_inc(&inode->i_count);

			inode->i_state &= ~I_DIRTY_TIME;

			spin_unlock(&inode->i_lock);

			trace_writeback_lazytime_iput(inode);

			mark_inode_dirty_sync(inode);

fs/sync.c

+1 −5
Original line number Diff line number Diff line
@@ -192,12 +192,8 @@ int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync) 


	if (!file->f_op->fsync)

		return -EINVAL;

	if (!datasync && (inode->i_state & I_DIRTY_TIME)) {

		spin_lock(&inode->i_lock);

		inode->i_state &= ~I_DIRTY_TIME;

		spin_unlock(&inode->i_lock);

	if (!datasync && (inode->i_state & I_DIRTY_TIME))

		mark_inode_dirty_sync(inode);

	}

	return file->f_op->fsync(file, start, end, datasync);

}

EXPORT_SYMBOL(vfs_fsync_range);

fs/xfs/kmem.c

+3 −3
Original line number Diff line number Diff line
@@ -46,13 +46,13 @@ kmem_alloc(size_t size, xfs_km_flags_t flags) 
}



void *

kmem_zalloc_large(size_t size, xfs_km_flags_t flags)

kmem_alloc_large(size_t size, xfs_km_flags_t flags)

{

	unsigned nofs_flag = 0;

	void	*ptr;

	gfp_t	lflags;



	ptr = kmem_zalloc(size, flags | KM_MAYFAIL);

	ptr = kmem_alloc(size, flags | KM_MAYFAIL);

	if (ptr)

		return ptr;
@@ -67,7 +67,7 @@ kmem_zalloc_large(size_t size, xfs_km_flags_t flags) 
		nofs_flag = memalloc_nofs_save();



	lflags = kmem_flags_convert(flags);

	ptr = __vmalloc(size, lflags | __GFP_ZERO, PAGE_KERNEL);

	ptr = __vmalloc(size, lflags, PAGE_KERNEL);



	if (flags & KM_NOFS)

		memalloc_nofs_restore(nofs_flag);

fs/xfs/kmem.h

+7 −1
Original line number Diff line number Diff line
@@ -71,7 +71,7 @@ kmem_flags_convert(xfs_km_flags_t flags) 
}



extern void *kmem_alloc(size_t, xfs_km_flags_t);

extern void *kmem_zalloc_large(size_t size, xfs_km_flags_t);

extern void *kmem_alloc_large(size_t size, xfs_km_flags_t);

extern void *kmem_realloc(const void *, size_t, xfs_km_flags_t);

static inline void  kmem_free(const void *ptr)

{
@@ -85,6 +85,12 @@ kmem_zalloc(size_t size, xfs_km_flags_t flags) 
	return kmem_alloc(size, flags | KM_ZERO);

}



static inline void *

kmem_zalloc_large(size_t size, xfs_km_flags_t flags)

{

	return kmem_alloc_large(size, flags | KM_ZERO);

}



/*

 * Zone interfaces

 */

fs/xfs/libxfs/xfs_ag_resv.c

+22 −17
Original line number Diff line number Diff line
@@ -95,13 +95,13 @@ xfs_ag_resv_critical( 


	switch (type) {

	case XFS_AG_RESV_METADATA:

		avail = pag->pagf_freeblks - pag->pag_agfl_resv.ar_reserved;

		avail = pag->pagf_freeblks - pag->pag_rmapbt_resv.ar_reserved;

		orig = pag->pag_meta_resv.ar_asked;

		break;

	case XFS_AG_RESV_AGFL:

	case XFS_AG_RESV_RMAPBT:

		avail = pag->pagf_freeblks + pag->pagf_flcount -

			pag->pag_meta_resv.ar_reserved;

		orig = pag->pag_agfl_resv.ar_asked;

		orig = pag->pag_rmapbt_resv.ar_asked;

		break;

	default:

		ASSERT(0);
@@ -126,10 +126,10 @@ xfs_ag_resv_needed( 
{

	xfs_extlen_t			len;



	len = pag->pag_meta_resv.ar_reserved + pag->pag_agfl_resv.ar_reserved;

	len = pag->pag_meta_resv.ar_reserved + pag->pag_rmapbt_resv.ar_reserved;

	switch (type) {

	case XFS_AG_RESV_METADATA:

	case XFS_AG_RESV_AGFL:

	case XFS_AG_RESV_RMAPBT:

		len -= xfs_perag_resv(pag, type)->ar_reserved;

		break;

	case XFS_AG_RESV_NONE:
@@ -160,10 +160,11 @@ __xfs_ag_resv_free( 
	if (pag->pag_agno == 0)

		pag->pag_mount->m_ag_max_usable += resv->ar_asked;

	/*

	 * AGFL blocks are always considered "free", so whatever

	 * was reserved at mount time must be given back at umount.

	 * RMAPBT blocks come from the AGFL and AGFL blocks are always

	 * considered "free", so whatever was reserved at mount time must be

	 * given back at umount.

	 */

	if (type == XFS_AG_RESV_AGFL)

	if (type == XFS_AG_RESV_RMAPBT)

		oldresv = resv->ar_orig_reserved;

	else

		oldresv = resv->ar_reserved;
@@ -185,7 +186,7 @@ xfs_ag_resv_free( 
	int				error;

	int				err2;



	error = __xfs_ag_resv_free(pag, XFS_AG_RESV_AGFL);

	error = __xfs_ag_resv_free(pag, XFS_AG_RESV_RMAPBT);

	err2 = __xfs_ag_resv_free(pag, XFS_AG_RESV_METADATA);

	if (err2 && !error)

		error = err2;
@@ -284,15 +285,15 @@ xfs_ag_resv_init( 
		}

	}



	/* Create the AGFL metadata reservation */

	if (pag->pag_agfl_resv.ar_asked == 0) {

	/* Create the RMAPBT metadata reservation */

	if (pag->pag_rmapbt_resv.ar_asked == 0) {

		ask = used = 0;



		error = xfs_rmapbt_calc_reserves(mp, agno, &ask, &used);

		if (error)

			goto out;



		error = __xfs_ag_resv_init(pag, XFS_AG_RESV_AGFL, ask, used);

		error = __xfs_ag_resv_init(pag, XFS_AG_RESV_RMAPBT, ask, used);

		if (error)

			goto out;

	}
@@ -304,7 +305,7 @@ xfs_ag_resv_init( 
		return error;



	ASSERT(xfs_perag_resv(pag, XFS_AG_RESV_METADATA)->ar_reserved +

	       xfs_perag_resv(pag, XFS_AG_RESV_AGFL)->ar_reserved <=

	       xfs_perag_resv(pag, XFS_AG_RESV_RMAPBT)->ar_reserved <=

	       pag->pagf_freeblks + pag->pagf_flcount);

#endif

out:
@@ -325,8 +326,10 @@ xfs_ag_resv_alloc_extent( 
	trace_xfs_ag_resv_alloc_extent(pag, type, args->len);



	switch (type) {

	case XFS_AG_RESV_METADATA:

	case XFS_AG_RESV_AGFL:

		return;

	case XFS_AG_RESV_METADATA:

	case XFS_AG_RESV_RMAPBT:

		resv = xfs_perag_resv(pag, type);

		break;

	default:
@@ -341,7 +344,7 @@ xfs_ag_resv_alloc_extent( 


	len = min_t(xfs_extlen_t, args->len, resv->ar_reserved);

	resv->ar_reserved -= len;

	if (type == XFS_AG_RESV_AGFL)

	if (type == XFS_AG_RESV_RMAPBT)

		return;

	/* Allocations of reserved blocks only need on-disk sb updates... */

	xfs_trans_mod_sb(args->tp, XFS_TRANS_SB_RES_FDBLOCKS, -(int64_t)len);
@@ -365,8 +368,10 @@ xfs_ag_resv_free_extent( 
	trace_xfs_ag_resv_free_extent(pag, type, len);



	switch (type) {

	case XFS_AG_RESV_METADATA:

	case XFS_AG_RESV_AGFL:

		return;

	case XFS_AG_RESV_METADATA:

	case XFS_AG_RESV_RMAPBT:

		resv = xfs_perag_resv(pag, type);

		break;

	default:
@@ -379,7 +384,7 @@ xfs_ag_resv_free_extent( 


	leftover = min_t(xfs_extlen_t, len, resv->ar_asked - resv->ar_reserved);

	resv->ar_reserved += leftover;

	if (type == XFS_AG_RESV_AGFL)

	if (type == XFS_AG_RESV_RMAPBT)

		return;

	/* Freeing into the reserved pool only requires on-disk update... */

	xfs_trans_mod_sb(tp, XFS_TRANS_SB_RES_FDBLOCKS, len);

CRA Git | Maintained and supported by SUSTech CRA and CCSE