Commit 28e33520 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull xfs updates from Darrick Wong:
 "There's a couple of bug fixes, some cleanups for inconsistent variable
  names and reduction of struct boxing and unboxing in the logging code.

  More work is pending, which will begin reworking allocation group
  lifetimes and finally replace confusing indirect calls to the
  allocator with actual ... function calls. But I want to let that
  experience another week of testing.

  Summary:

   - Eliminate repeated boxing and unboxing of log item parameters

   - Clean up some confusing variable names in the log item code

   - Fix a deadlock when doing unwritten extent conversion that causes a
     bmbt split when there are sustained memory shortages and the worker
     pool runs out of worker threads

   - Fix the panic_mask debug knob not being able to trigger on verifier
     errors

   - Constify kobj_type objects"

* tag 'xfs-6.3-merge-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux:
  xfs: revert commit 8954c44f
  xfs: make kobj_type structures constant
  xfs: allow setting full range of panic tags
  xfs: don't use BMBT btree split workers for IO completion
  xfs: fix confusing variable names in xfs_refcount_item.c
  xfs: pass refcount intent directly through the log intent code
  xfs: fix confusing variable names in xfs_rmap_item.c
  xfs: pass rmap space mapping directly through the log intent code
  xfs: fix confusing xfs_extent_item variable names
  xfs: pass xfs_extent_free_item directly through the log intent code
  xfs: fix confusing variable names in xfs_bmap_item.c
  xfs: pass the xfs_bmbt_irec directly through the log intent code
  xfs: use strscpy() to instead of strncpy()
parents d151e8be dd07bb8b

Documentation/admin-guide/xfs.rst

+1 −1
Original line number Diff line number Diff line
@@ -296,7 +296,7 @@ The following sysctls are available for the XFS filesystem: 
		XFS_ERRLEVEL_LOW:       1

		XFS_ERRLEVEL_HIGH:      5



  fs.xfs.panic_mask		(Min: 0  Default: 0  Max: 256)

  fs.xfs.panic_mask		(Min: 0  Default: 0  Max: 511)

	Causes certain error conditions to call BUG(). Value is a bitmask;

	OR together the tags which represent errors which should cause panics:

fs/xfs/libxfs/xfs_alloc.c

+16 −16
Original line number Diff line number Diff line
@@ -2472,20 +2472,20 @@ xfs_defer_agfl_block( 
	struct xfs_owner_info		*oinfo)

{

	struct xfs_mount		*mp = tp->t_mountp;

	struct xfs_extent_free_item	*new;		/* new element */

	struct xfs_extent_free_item	*xefi;



	ASSERT(xfs_extfree_item_cache != NULL);

	ASSERT(oinfo != NULL);



	new = kmem_cache_zalloc(xfs_extfree_item_cache,

	xefi = kmem_cache_zalloc(xfs_extfree_item_cache,

			       GFP_KERNEL | __GFP_NOFAIL);

	new->xefi_startblock = XFS_AGB_TO_FSB(mp, agno, agbno);

	new->xefi_blockcount = 1;

	new->xefi_owner = oinfo->oi_owner;

	xefi->xefi_startblock = XFS_AGB_TO_FSB(mp, agno, agbno);

	xefi->xefi_blockcount = 1;

	xefi->xefi_owner = oinfo->oi_owner;



	trace_xfs_agfl_free_defer(mp, agno, 0, agbno, 1);



	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_AGFL_FREE, &new->xefi_list);

	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_AGFL_FREE, &xefi->xefi_list);

}



/*
@@ -2500,7 +2500,7 @@ __xfs_free_extent_later( 
	const struct xfs_owner_info	*oinfo,

	bool				skip_discard)

{

	struct xfs_extent_free_item	*new;		/* new element */

	struct xfs_extent_free_item	*xefi;

#ifdef DEBUG

	struct xfs_mount		*mp = tp->t_mountp;

	xfs_agnumber_t			agno;
@@ -2519,27 +2519,27 @@ __xfs_free_extent_later( 
#endif

	ASSERT(xfs_extfree_item_cache != NULL);



	new = kmem_cache_zalloc(xfs_extfree_item_cache,

	xefi = kmem_cache_zalloc(xfs_extfree_item_cache,

			       GFP_KERNEL | __GFP_NOFAIL);

	new->xefi_startblock = bno;

	new->xefi_blockcount = (xfs_extlen_t)len;

	xefi->xefi_startblock = bno;

	xefi->xefi_blockcount = (xfs_extlen_t)len;

	if (skip_discard)

		new->xefi_flags |= XFS_EFI_SKIP_DISCARD;

		xefi->xefi_flags |= XFS_EFI_SKIP_DISCARD;

	if (oinfo) {

		ASSERT(oinfo->oi_offset == 0);



		if (oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK)

			new->xefi_flags |= XFS_EFI_ATTR_FORK;

			xefi->xefi_flags |= XFS_EFI_ATTR_FORK;

		if (oinfo->oi_flags & XFS_OWNER_INFO_BMBT_BLOCK)

			new->xefi_flags |= XFS_EFI_BMBT_BLOCK;

		new->xefi_owner = oinfo->oi_owner;

			xefi->xefi_flags |= XFS_EFI_BMBT_BLOCK;

		xefi->xefi_owner = oinfo->oi_owner;

	} else {

		new->xefi_owner = XFS_RMAP_OWN_NULL;

		xefi->xefi_owner = XFS_RMAP_OWN_NULL;

	}

	trace_xfs_bmap_free_defer(tp->t_mountp,

			XFS_FSB_TO_AGNO(tp->t_mountp, bno), 0,

			XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);

	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list);

	xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_FREE, &xefi->xefi_list);

}



#ifdef DEBUG

fs/xfs/libxfs/xfs_bmap.c

+15 −17
Original line number Diff line number Diff line
@@ -6146,39 +6146,37 @@ xfs_bmap_unmap_extent( 
int

xfs_bmap_finish_one(

	struct xfs_trans		*tp,

	struct xfs_inode		*ip,

	enum xfs_bmap_intent_type	type,

	int				whichfork,

	xfs_fileoff_t			startoff,

	xfs_fsblock_t			startblock,

	xfs_filblks_t			*blockcount,

	xfs_exntst_t			state)

	struct xfs_bmap_intent		*bi)

{

	struct xfs_bmbt_irec		*bmap = &bi->bi_bmap;

	int				error = 0;



	ASSERT(tp->t_firstblock == NULLFSBLOCK);



	trace_xfs_bmap_deferred(tp->t_mountp,

			XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type,

			XFS_FSB_TO_AGBNO(tp->t_mountp, startblock),

			ip->i_ino, whichfork, startoff, *blockcount, state);

			XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),

			bi->bi_type,

			XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),

			bi->bi_owner->i_ino, bi->bi_whichfork,

			bmap->br_startoff, bmap->br_blockcount,

			bmap->br_state);



	if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK))

	if (WARN_ON_ONCE(bi->bi_whichfork != XFS_DATA_FORK))

		return -EFSCORRUPTED;



	if (XFS_TEST_ERROR(false, tp->t_mountp,

			XFS_ERRTAG_BMAP_FINISH_ONE))

		return -EIO;



	switch (type) {

	switch (bi->bi_type) {

	case XFS_BMAP_MAP:

		error = xfs_bmapi_remap(tp, ip, startoff, *blockcount,

				startblock, 0);

		*blockcount = 0;

		error = xfs_bmapi_remap(tp, bi->bi_owner, bmap->br_startoff,

				bmap->br_blockcount, bmap->br_startblock, 0);

		bmap->br_blockcount = 0;

		break;

	case XFS_BMAP_UNMAP:

		error = __xfs_bunmapi(tp, ip, startoff, blockcount,

				XFS_BMAPI_REMAP, 1);

		error = __xfs_bunmapi(tp, bi->bi_owner, bmap->br_startoff,

				&bmap->br_blockcount, XFS_BMAPI_REMAP, 1);

		break;

	default:

		ASSERT(0);

fs/xfs/libxfs/xfs_bmap.h

+1 −4
Original line number Diff line number Diff line
@@ -234,10 +234,7 @@ struct xfs_bmap_intent { 
	struct xfs_bmbt_irec			bi_bmap;

};



int	xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_inode *ip,

		enum xfs_bmap_intent_type type, int whichfork,

		xfs_fileoff_t startoff, xfs_fsblock_t startblock,

		xfs_filblks_t *blockcount, xfs_exntst_t state);

int	xfs_bmap_finish_one(struct xfs_trans *tp, struct xfs_bmap_intent *bi);

void	xfs_bmap_map_extent(struct xfs_trans *tp, struct xfs_inode *ip,

		struct xfs_bmbt_irec *imap);

void	xfs_bmap_unmap_extent(struct xfs_trans *tp, struct xfs_inode *ip,

fs/xfs/libxfs/xfs_btree.c

+16 −2
Original line number Diff line number Diff line
@@ -2913,9 +2913,22 @@ xfs_btree_split_worker( 
}



/*

 * BMBT split requests often come in with little stack to work on. Push

 * BMBT split requests often come in with little stack to work on so we push

 * them off to a worker thread so there is lots of stack to use. For the other

 * btree types, just call directly to avoid the context switch overhead here.

 *

 * Care must be taken here - the work queue rescuer thread introduces potential

 * AGF <> worker queue deadlocks if the BMBT block allocation has to lock new

 * AGFs to allocate blocks. A task being run by the rescuer could attempt to

 * lock an AGF that is already locked by a task queued to run by the rescuer,

 * resulting in an ABBA deadlock as the rescuer cannot run the lock holder to

 * release it until the current thread it is running gains the lock.

 *

 * To avoid this issue, we only ever queue BMBT splits that don't have an AGF

 * already locked to allocate from. The only place that doesn't hold an AGF

 * locked is unwritten extent conversion at IO completion, but that has already

 * been offloaded to a worker thread and hence has no stack consumption issues

 * we have to worry about.

 */

STATIC int					/* error */

xfs_btree_split(
@@ -2929,7 +2942,8 @@ xfs_btree_split( 
	struct xfs_btree_split_args	args;

	DECLARE_COMPLETION_ONSTACK(done);



	if (cur->bc_btnum != XFS_BTNUM_BMAP)

	if (cur->bc_btnum != XFS_BTNUM_BMAP ||

	    cur->bc_tp->t_firstblock == NULLFSBLOCK)

		return __xfs_btree_split(cur, level, ptrp, key, curp, stat);



	args.cur = cur;