xfs: avoid transaction reservation recursion
Subsystems (6)
v12 cover xfs: avoid transaction reservation recursion
PF_FSTRANS which is used to avoid transaction reservation recursion, is dropped since commit 9070733b4efa ("xfs: abstract PF_FSTRANS to PF_MEMALLOC_NOFS") and commit 7dea19f9ee63 ("mm: introduce memalloc_nofs_{save,restore} API"), and replaced by PF_MEMALLOC_NOFS which means to avoid filesystem reclaim recursion.
As these two flags have different meanings, we'd better reintroduce PF_FSTRANS back. To avoid wasting the space of PF_* flags in task_struct, we can reuse the current->journal_info to do that, per Willy. As the check of transaction reservation recursion is used by XFS only, we can move the check into xfs_vm_writepage(s), per Dave.
Patch #1 and #2 are to use the memalloc_nofs_{save,restore} API Patch #1 is picked form Willy's patchset "Overhaul memalloc_no*"[1]
Patch #3 is the refactor of xfs_trans context, which is activated when xfs_trans is allocated and deactivated when xfs_trans is freed.
Patch #4 is the implementation of reussing current->journal_info to avoid transaction reservation recursion.
No obvious error occurred after running xfstests.
[1]. https://lore.kernel.org/linux-mm/[email protected]
v12:
Per Darrick's suggestion,
- add the check before calling xfs_trans_context_clear() in xfs_trans_context_free().
- move t_pflags into xfs_trans_context_swap()
v11:
- add the warning at the callsite of xfs_trans_context_active()
- improve the commit log of patch #2
v10:
- refactor the code, per Dave.
v9:
- rebase it on xfs tree.
- Darrick fixed an error occurred in xfs/141
- run xfstests, and no obvious error occurred.
v8:
- check xfs_trans_context_active() in xfs_vm_writepage(s), per Dave.
v7:
- check fstrans recursion for XFS only, by introducing a new member in struct writeback_control.
v6:
- add Michal's ack and comment in patch #1.
v5:
- pick one of Willy's patch
- introduce four new helpers, per Dave
v4:
- retitle from "xfs: introduce task->in_fstrans for transaction reservation recursion protection"
- reuse current->journal_info, per Willy
Matthew Wilcox (Oracle) (1):
mm: Add become_kswapd and restore_kswapd
Yafang Shao (3):
xfs: use memalloc_nofs_{save,restore} in xfs transaction
xfs: refactor the usage around xfs_trans_context_{set,clear}
xfs: use current->journal_info to avoid transaction reservation
recursion
fs/iomap/buffered-io.c | 7 ------- fs/xfs/libxfs/xfs_btree.c | 14 ++++++++------ fs/xfs/xfs_aops.c | 21 +++++++++++++++++++-- fs/xfs/xfs_linux.h | 4 ---- fs/xfs/xfs_trans.c | 33 +++++++++++++++++++-------------- fs/xfs/xfs_trans.h | 35 +++++++++++++++++++++++++++++++++++ include/linux/sched/mm.h | 23 +++++++++++++++++++++++ mm/vmscan.c | 16 +--------------- 8 files changed, 105 insertions(+), 48 deletions(-)
Signature · 1 line
2.18.4
PATCH v12 1/4 mm: Add become_kswapd and restore_kswapd
From: "Matthew Wilcox (Oracle)" <[email protected]>
Since XFS needs to pretend to be kswapd in some of its worker threads, create methods to save & restore kswapd state. Don't bother restoring kswapd state in kswapd -- the only time we reach this code is when we're exiting and the task_struct is about to be destroyed anyway.
--- fs/xfs/libxfs/xfs_btree.c | 14 ++++++++------ include/linux/sched/mm.h | 23 +++++++++++++++++++++++ mm/vmscan.c | 16 +--------------- 3 files changed, 32 insertions(+), 21 deletions(-)
fs/xfs/libxfs/xfs_btree.c +8 -6
@@ -2813,8 +2813,9 @@ xfs_btree_split_worker( {struct xfs_btree_split_args *args =container_of (work, struct xfs_btree_split_args, work); +bool is_kswapd = args->kswapd;unsigned long pflags; -unsigned long new_pflags =PF_MEMALLOC_NOFS ; +int memalloc_nofs;/* * we are in a transaction context here, but may also be doing work
@@ -2822,16 +2823,17 @@ xfs_btree_split_worker(* temporarily to ensure that we don't block waiting for memory reclaim * in any way. */ -if (args->kswapd) - new_pflags |=PF_MEMALLOC |PF_SWAPWRITE |PF_KSWAPD ; - -current_set_flags_nested (&pflags, new_pflags); +if (is_kswapd) + pflags =become_kswapd (); + memalloc_nofs =memalloc_nofs_save (); args->result =__xfs_btree_split (args->cur, args->level, args->ptrp, args->key, args->curp, args->stat);complete (args->done); -current_restore_flags_nested (&pflags, new_pflags); +memalloc_nofs_restore (memalloc_nofs); +if (is_kswapd) +restore_kswapd (pflags); }/*
include/linux/sched/mm.h +23 -0
@@ -278,6 +278,29 @@ static inline void memalloc_nocma_restore(unsigned int flags) }#endif +/* +* Tell the memory management code that this thread is working on behalf +* of background memory reclaim (like kswapd). That means that it will +* get access to memory reserves should it need to allocate memory in +* order to make forward progress. With this great power comes great +* responsibility to not exhaust those reserves. +*/ +#define KSWAPD_PF_FLAGS (PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD) + +static inline unsigned long become_kswapd (void ) +{ +unsigned long flags = current->flags &KSWAPD_PF_FLAGS ; + + current->flags |=KSWAPD_PF_FLAGS ; + +return flags; +} + +static inline void restore_kswapd (unsigned long flags) +{ + current->flags &= ~(flags ^KSWAPD_PF_FLAGS ); +} +#ifdef CONFIG_MEMCG DECLARE_PER_CPU(struct mem_cgroup *, int_active_memcg);/**
mm/vmscan.c +1 -15
@@ -3869,19 +3869,7 @@ static int kswapd(void *p)if (!cpumask_empty (cpumask))set_cpus_allowed_ptr (tsk, cpumask); -/* -* Tell the memory management that we're a "memory allocator", -* and that if we need more memory we should get access to it -* regardless (see "__alloc_pages()"). "kswapd" should -* never get caught in the normal page freeing logic. -* -* (Kswapd normally doesn't need memory anyway, but sometimes -* you need a small amount of memory in order to be able to -* page out something else, and this flag essentially protects -* us from recursively trying to free more memory as we're -* trying to free the first piece of memory in the first place). -*/ - tsk->flags |=PF_MEMALLOC |PF_SWAPWRITE |PF_KSWAPD ; +become_kswapd ();set_freezable ();WRITE_ONCE (pgdat->kswapd_order,0 );
@@ -3931,8 +3919,6 @@ static int kswapd(void *p) goto kswapd_try_sleep; } - tsk->flags &= ~(PF_MEMALLOC |PF_SWAPWRITE |PF_KSWAPD ); -return 0 ; }
Signature · 1 line
2.18.4
PATCH v12 2/4 xfs: use memalloc_nofs_{save,restore} in xfs transaction
In reply to Yafang ShaoIntroduce a new API to mark the start and end of XFS transactions. For now, just save and restore the memalloc_nofs flags.
The new helpers as follows,
- xfs_trans_context_set
Mark the start of XFS transactions
- xfs_trans_context_clear
Mark the end of XFS transactions
--- fs/xfs/xfs_aops.c | 4 ++-- fs/xfs/xfs_linux.h | 4 ---- fs/xfs/xfs_trans.c | 13 +++++++------ fs/xfs/xfs_trans.h | 12 ++++++++++++ 4 files changed, 21 insertions(+), 12 deletions(-)
fs/xfs/xfs_aops.c +2 -2
@@ -62,7 +62,7 @@ xfs_setfilesize_trans_alloc(* We hand off the transaction to the completion thread now, so * clear the flag here. */ -current_restore_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_clear (tp);return 0 ; }
@@ -125,7 +125,7 @@ xfs_setfilesize_ioend(* thus we need to mark ourselves as being in a transaction manually. * Similarly for freeze protection. */ -current_set_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_set (tp);__sb_writers_acquired (VFS_I (ip)->i_sb,SB_FREEZE_FS );/* we abort the update if there was an IO error */
fs/xfs/xfs_linux.h +0 -4
@@ -102,10 +102,6 @@ typedef __u32 xfs_nlink_t;#define xfs_cowb_secs xfs_params.cowb_timer.val#define current_cpu () (raw_smp_processor_id()) -#define current_set_flags_nested (sp, f) \ - (*(sp) = current->flags, current->flags |= (f)) -#define current_restore_flags_nested (sp, f) \ - (current->flags = ((current->flags & ~(f)) | (*(sp) & (f))))#define NBBY 8/* number of bits per byte */
fs/xfs/xfs_trans.c +7 -6
@@ -154,7 +154,7 @@ xfs_trans_reserve(bool rsvd = (tp->t_flags &XFS_TRANS_RESERVE ) !=0 ;/* Mark this thread as being in a transaction */ -current_set_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_set (tp);/* * Attempt to reserve the needed disk blocks by decrementing
@@ -164,7 +164,7 @@ xfs_trans_reserve(if (blocks >0 ) { error =xfs_mod_fdblocks (mp, -((int64_t )blocks), rsvd);if (error !=0 ) { -current_restore_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_clear (tp);return -ENOSPC ; } tp->t_blk_res += blocks;
@@ -241,7 +241,7 @@ xfs_trans_reserve( tp->t_blk_res =0 ; } -current_restore_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_clear (tp);return error; }
@@ -878,7 +878,7 @@ __xfs_trans_commit(xfs_log_commit_cil (mp, tp, &commit_lsn, regrant); -current_restore_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_clear (tp);xfs_trans_free (tp);/*
@@ -910,7 +910,8 @@ __xfs_trans_commit(xfs_log_ticket_ungrant (mp->m_log, tp->t_ticket); tp->t_ticket =NULL ; } -current_restore_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); + +xfs_trans_context_clear (tp);xfs_trans_free_items (tp, !!error);xfs_trans_free (tp);
@@ -971,7 +972,7 @@ xfs_trans_cancel( }/* mark this thread as no longer being in a transaction */ -current_restore_flags_nested (&tp->t_pflags,PF_MEMALLOC_NOFS ); +xfs_trans_context_clear (tp);xfs_trans_free_items (tp, dirty);xfs_trans_free (tp);
fs/xfs/xfs_trans.h +12 -0
@@ -268,4 +268,16 @@ xfs_trans_item_relog( return lip->li_ops->iop_relog(lip, tp); } +static inline void +xfs_trans_context_set (struct xfs_trans *tp) +{ + tp->t_pflags =memalloc_nofs_save (); +} + +static inline void +xfs_trans_context_clear (struct xfs_trans *tp) +{ +memalloc_nofs_restore (tp->t_pflags); +} +#endif /* __XFS_TRANS_H__ */
Signature · 1 line
2.18.4
PATCH v12 3/4 xfs: refactor the usage around xfs_trans_context_{set,clear}
In reply to Yafang ShaoThe xfs_trans context should be active after it is allocated, and deactive when it is freed.
So these two helpers are refactored as,
- xfs_trans_context_set()
Used in xfs_trans_alloc()
- xfs_trans_context_clear()
Used in xfs_trans_free()
This patch is based on Darrick's work to fix the issue in xfs/141 in the earlier version. [1]
1. https://lore.kernel.org/linux-xfs/20201104001649.GN7123@magnolia
--- fs/xfs/xfs_trans.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-)
fs/xfs/xfs_trans.c +15 -13
@@ -67,6 +67,17 @@ xfs_trans_free(xfs_extent_busy_sort (&tp->t_busy);xfs_extent_busy_clear (tp->t_mountp, &tp->t_busy, false); + +/* Detach the transaction from this thread. */ +ASSERT (current->journal_info !=NULL ); +/* +* The PF_MEMALLOC_NOFS is bound to the transaction itself instead +* of the reservation, so we need to check if tp is still the +* current transaction before clearing the flag. +*/ +if (current->journal_info == tp) +xfs_trans_context_clear (tp); +trace_xfs_trans_free (tp, _RET_IP_);if (!(tp->t_flags &XFS_TRANS_NO_WRITECOUNT ))sb_end_intwrite (tp->t_mountp->m_super);
@@ -153,9 +164,6 @@ xfs_trans_reserve(int error =0 ;bool rsvd = (tp->t_flags &XFS_TRANS_RESERVE ) !=0 ; -/* Mark this thread as being in a transaction */ -xfs_trans_context_set (tp); -/* * Attempt to reserve the needed disk blocks by decrementing * the number needed from the number available. This will
@@ -163,10 +171,9 @@ xfs_trans_reserve(*/ if (blocks >0 ) { error =xfs_mod_fdblocks (mp, -((int64_t )blocks), rsvd); -if (error !=0 ) { -xfs_trans_context_clear (tp); +if (error !=0 )return -ENOSPC ; - } + tp->t_blk_res += blocks; }
@@ -241,8 +248,6 @@ xfs_trans_reserve( tp->t_blk_res =0 ; } -xfs_trans_context_clear (tp); -return error; }
@@ -284,6 +289,8 @@ xfs_trans_alloc(INIT_LIST_HEAD (&tp->t_dfops); tp->t_firstblock =NULLFSBLOCK ; +/* Mark this thread as being in a transaction */ +xfs_trans_context_set (tp); error =xfs_trans_reserve (tp, resp, blocks, rtextents);if (error) {xfs_trans_cancel (tp);
@@ -878,7 +885,6 @@ __xfs_trans_commit(xfs_log_commit_cil (mp, tp, &commit_lsn, regrant); -xfs_trans_context_clear (tp);xfs_trans_free (tp);/*
@@ -911,7 +917,6 @@ __xfs_trans_commit( tp->t_ticket =NULL ; } -xfs_trans_context_clear (tp);xfs_trans_free_items (tp, !!error);xfs_trans_free (tp);
@@ -971,9 +976,6 @@ xfs_trans_cancel( tp->t_ticket =NULL ; } -/* mark this thread as no longer being in a transaction */ -xfs_trans_context_clear (tp); -xfs_trans_free_items (tp, dirty);xfs_trans_free (tp); }
Signature · 1 line
2.18.4
Re: [PATCH v12 3/4] xfs: refactor the usage around xfs_trans_context_{set,clear}
Quoted 30 lines · Yafang Shao
The
xfs_transcontext should be active after it is allocated, and deactive when it is freed.So these two helpers are refactored as,
-xfs_trans_context_set()
Used inxfs_trans_alloc()
-xfs_trans_context_clear()
Used inxfs_trans_free()This patch is based on Darrick's work to fix the issue in xfs/141 in the earlier version. [1]
1. https://lore.kernel.org/linux-xfs/20201104001649.GN7123@magnolia
Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- fs/xfs/xfs_trans.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-)fs/xfs/xfs_trans.c +0
-0@@ -67,6 +67,17 @@ xfs_trans_free(xfs_extent_busy_sort (&tp->t_busy);xfs_extent_busy_clear (tp->t_mountp, &tp->t_busy, false);
fs/xfs/xfs_trans.c xfs_trans_free( · line 78
Quoted 10 lines
fs/xfs/xfs_trans.c +9
-0+ +/* Detach the transaction from this thread. */ +ASSERT (current->journal_info !=NULL ); +/* +* The PF_MEMALLOC_NOFS is bound to the transaction itself instead +* of the reservation, so we need to check if tp is still the +* current transaction before clearing the flag. +*/ +if (current->journal_info == tp)
Um, you don't start setting journal_info until the next patch, so this means that someone who lands on this commit with git bisect will have a xfs with broken logic.
Because this is the patch that changes where we set and restore NOFS context, I think you have to introduce xfs_trans_context_swap here, and not in the next patch.
I also think the _swap routine has to move the old NOFS state to the new transaction's t_pflags, and then set NOFS in the old transaction's t_pflags so that when we clear the context on the old transaction we don't actually change the thread's NOFS state.
--D
Quoted 75 lines
fs/xfs/xfs_trans.c +6
-13+xfs_trans_context_clear (tp); +trace_xfs_trans_free (tp, _RET_IP_);if (!(tp->t_flags &XFS_TRANS_NO_WRITECOUNT ))sb_end_intwrite (tp->t_mountp->m_super);@@ -153,9 +164,6 @@ xfs_trans_reserve(int error =0 ;bool rsvd = (tp->t_flags &XFS_TRANS_RESERVE ) !=0 ; -/* Mark this thread as being in a transaction */ -xfs_trans_context_set (tp); -/* * Attempt to reserve the needed disk blocks by decrementing * the number needed from the number available. This will @@ -163,10 +171,9 @@ xfs_trans_reserve(*/ if (blocks >0 ) { error =xfs_mod_fdblocks (mp, -((int64_t )blocks), rsvd); -if (error !=0 ) { -xfs_trans_context_clear (tp); +if (error !=0 )return -ENOSPC ; - } + tp->t_blk_res += blocks; }@@ -241,8 +248,6 @@ xfs_trans_reserve( tp->t_blk_res =0 ; } -xfs_trans_context_clear (tp); -return error; }@@ -284,6 +289,8 @@ xfs_trans_alloc(INIT_LIST_HEAD (&tp->t_dfops); tp->t_firstblock =NULLFSBLOCK ; +/* Mark this thread as being in a transaction */ +xfs_trans_context_set (tp); error =xfs_trans_reserve (tp, resp, blocks, rtextents);if (error) {xfs_trans_cancel (tp);@@ -878,7 +885,6 @@ __xfs_trans_commit(xfs_log_commit_cil (mp, tp, &commit_lsn, regrant); -xfs_trans_context_clear (tp);xfs_trans_free (tp);/* @@ -911,7 +917,6 @@ __xfs_trans_commit( tp->t_ticket =NULL ; } -xfs_trans_context_clear (tp);xfs_trans_free_items (tp, !!error);xfs_trans_free (tp);@@ -971,9 +976,6 @@ xfs_trans_cancel( tp->t_ticket =NULL ; } -/* mark this thread as no longer being in a transaction */ -xfs_trans_context_clear (tp); -xfs_trans_free_items (tp, dirty);xfs_trans_free (tp); }Signature · 1 line
2.18.4
Re: [PATCH v12 3/4] xfs: refactor the usage around xfs_trans_context_{set,clear}
Quoted 47 lines · Darrick J. Wong
Quoted 30 lines · Yafang Shao
The
xfs_transcontext should be active after it is allocated, and deactive when it is freed.So these two helpers are refactored as,
-xfs_trans_context_set()
Used inxfs_trans_alloc()
-xfs_trans_context_clear()
Used inxfs_trans_free()This patch is based on Darrick's work to fix the issue in xfs/141 in the earlier version. [1]
1. https://lore.kernel.org/linux-xfs/20201104001649.GN7123@magnolia
Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- fs/xfs/xfs_trans.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-)fs/xfs/xfs_trans.c +0
-0@@ -67,6 +67,17 @@ xfs_trans_free(xfs_extent_busy_sort (&tp->t_busy);xfs_extent_busy_clear (tp->t_mountp, &tp->t_busy, false);fs/xfs/xfs_trans.c xfs_trans_free( · line 78
Quoted 10 lines
fs/xfs/xfs_trans.c +9
-0+ +/* Detach the transaction from this thread. */ +ASSERT (current->journal_info !=NULL ); +/* +* The PF_MEMALLOC_NOFS is bound to the transaction itself instead +* of the reservation, so we need to check if tp is still the +* current transaction before clearing the flag. +*/ +if (current->journal_info == tp)Um, you don't start setting
journal_infountil the next patch, so this means that someone who lands on this commit with git bisect will have a xfs with broken logic.
Quoted 4 lines
Because this is the patch that changes where we set and restore NOFS context, I think you have to introduce
xfs_trans_context_swaphere, and not in the next patch.
Thanks for the review. I will change it in the next version.
Quoted 2 lines
I also think the
_swaproutine has to move the old NOFS state to the new transaction'st_pflags,
Sure
Quoted 4 lines
and then set NOFS in the old transaction's
t_pflagsso that when we clear the context on the old transaction we don't actually change the thread's NOFS state.
Both thread's NOFS state and thead's journal_info state can't be changed in that case, right ?
So should it better be,
__xfs_trans_commit(tp, regrant)
xfs_trans_free(tp, regrant)
if (!regrant). // don't clear the xfs_trans_context if
regrant is true.
xfs_trans_context_clear()
Quoted 77 lines
--D
Quoted 75 lines
fs/xfs/xfs_trans.c +6
-14+xfs_trans_context_clear (tp); +trace_xfs_trans_free (tp, _RET_IP_);if (!(tp->t_flags &XFS_TRANS_NO_WRITECOUNT ))sb_end_intwrite (tp->t_mountp->m_super);@@ -153,9 +164,6 @@ xfs_trans_reserve(int error =0 ;bool rsvd = (tp->t_flags &XFS_TRANS_RESERVE ) !=0 ; -/* Mark this thread as being in a transaction */ -xfs_trans_context_set (tp); -/* * Attempt to reserve the needed disk blocks by decrementing * the number needed from the number available. This will @@ -163,10 +171,9 @@ xfs_trans_reserve(*/ if (blocks >0 ) { error =xfs_mod_fdblocks (mp, -((int64_t )blocks), rsvd); -if (error !=0 ) { -xfs_trans_context_clear (tp); +if (error !=0 )return -ENOSPC ; - } + tp->t_blk_res += blocks; }@@ -241,8 +248,6 @@ xfs_trans_reserve( tp->t_blk_res =0 ; } -xfs_trans_context_clear (tp); -return error; }@@ -284,6 +289,8 @@ xfs_trans_alloc(INIT_LIST_HEAD (&tp->t_dfops); tp->t_firstblock =NULLFSBLOCK ; +/* Mark this thread as being in a transaction */ +xfs_trans_context_set (tp); error =xfs_trans_reserve (tp, resp, blocks, rtextents);if (error) {xfs_trans_cancel (tp);@@ -878,7 +885,6 @@ __xfs_trans_commit(xfs_log_commit_cil (mp, tp, &commit_lsn, regrant); -xfs_trans_context_clear (tp);xfs_trans_free (tp);/* @@ -911,7 +917,6 @@ __xfs_trans_commit( tp->t_ticket =NULL ; } -xfs_trans_context_clear (tp);xfs_trans_free_items (tp, !!error);xfs_trans_free (tp);@@ -971,9 +976,6 @@ xfs_trans_cancel( tp->t_ticket =NULL ; } -/* mark this thread as no longer being in a transaction */ -xfs_trans_context_clear (tp); -xfs_trans_free_items (tp, dirty);xfs_trans_free (tp); } --2.18.4
Signature · 2 lines
Thanks Yafang
Re: [PATCH v12 3/4] xfs: refactor the usage around xfs_trans_context_{set,clear}
Quoted 69 lines · Yafang Shao
Quoted 47 lines · Darrick J. Wong
Quoted 30 lines · Yafang Shao
The
xfs_transcontext should be active after it is allocated, and deactive when it is freed.So these two helpers are refactored as,
-xfs_trans_context_set()
Used inxfs_trans_alloc()
-xfs_trans_context_clear()
Used inxfs_trans_free()This patch is based on Darrick's work to fix the issue in xfs/141 in the earlier version. [1]
1. https://lore.kernel.org/linux-xfs/20201104001649.GN7123@magnolia
Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- fs/xfs/xfs_trans.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-)fs/xfs/xfs_trans.c +0
-0@@ -67,6 +67,17 @@ xfs_trans_free(xfs_extent_busy_sort (&tp->t_busy);xfs_extent_busy_clear (tp->t_mountp, &tp->t_busy, false);fs/xfs/xfs_trans.c xfs_trans_free( · line 78
Quoted 10 lines
fs/xfs/xfs_trans.c +9
-0+ +/* Detach the transaction from this thread. */ +ASSERT (current->journal_info !=NULL ); +/* +* The PF_MEMALLOC_NOFS is bound to the transaction itself instead +* of the reservation, so we need to check if tp is still the +* current transaction before clearing the flag. +*/ +if (current->journal_info == tp)Um, you don't start setting
journal_infountil the next patch, so this means that someone who lands on this commit with git bisect will have a xfs with broken logic.Quoted 4 lines
Because this is the patch that changes where we set and restore NOFS context, I think you have to introduce
xfs_trans_context_swaphere, and not in the next patch.Thanks for the review. I will change it in the next version.
Quoted 2 lines
I also think the
_swaproutine has to move the old NOFS state to the new transaction'st_pflags,Sure
Quoted 4 lines
and then set NOFS in the old transaction's
t_pflagsso that when we clear the context on the old transaction we don't actually change the thread's NOFS state.Both thread's NOFS state and thead's
journal_infostate can't be changed in that case, right ?
So should it better be,
Quoted 5 lines
__xfs_trans_commit(tp, regrant)
xfs_trans_free(tp, regrant)
if (!regrant). // don't clear thexfs_trans_contextif
regrant is true.
xfs_trans_context_clear()
No. You are trying to make this way more complex than it needs to be. The logic in the core XFS code is *already correct* and all we need to do is move that logic to wrapper functions, then slightly modify the implementation inside the wrapper functions.
That is, xfs_trans_context_clear() should end up like this:
static inline voidxfs_trans_context_clear(struct xfs_trans *tp)
{
/*
* If xfs_trans_context_swap() handed the NOFS context to a
* new transaction we do not clear the context here.
*/
if (current->journal_info != tp)
return;
current->journal_info = NULL;
memalloc_nofs_restore(tp->t_pflags);
}-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v12 3/4] xfs: refactor the usage around xfs_trans_context_{set,clear}
Quoted 77 lines · Dave Chinner
Quoted 69 lines · Yafang Shao
Quoted 47 lines · Darrick J. Wong
Quoted 30 lines · Yafang Shao
The
xfs_transcontext should be active after it is allocated, and deactive when it is freed.So these two helpers are refactored as,
-xfs_trans_context_set()
Used inxfs_trans_alloc()
-xfs_trans_context_clear()
Used inxfs_trans_free()This patch is based on Darrick's work to fix the issue in xfs/141 in the earlier version. [1]
1. https://lore.kernel.org/linux-xfs/20201104001649.GN7123@magnolia
Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- fs/xfs/xfs_trans.c | 28 +++++++++++++++------------- 1 file changed, 15 insertions(+), 13 deletions(-)fs/xfs/xfs_trans.c +0
-0@@ -67,6 +67,17 @@ xfs_trans_free(xfs_extent_busy_sort (&tp->t_busy);xfs_extent_busy_clear (tp->t_mountp, &tp->t_busy, false);fs/xfs/xfs_trans.c xfs_trans_free( · line 78
Quoted 10 lines
fs/xfs/xfs_trans.c +9
-0+ +/* Detach the transaction from this thread. */ +ASSERT (current->journal_info !=NULL ); +/* +* The PF_MEMALLOC_NOFS is bound to the transaction itself instead +* of the reservation, so we need to check if tp is still the +* current transaction before clearing the flag. +*/ +if (current->journal_info == tp)Um, you don't start setting
journal_infountil the next patch, so this means that someone who lands on this commit with git bisect will have a xfs with broken logic.Quoted 4 lines
Because this is the patch that changes where we set and restore NOFS context, I think you have to introduce
xfs_trans_context_swaphere, and not in the next patch.Thanks for the review. I will change it in the next version.
Quoted 2 lines
I also think the
_swaproutine has to move the old NOFS state to the new transaction'st_pflags,Sure
Quoted 4 lines
and then set NOFS in the old transaction's
t_pflagsso that when we clear the context on the old transaction we don't actually change the thread's NOFS state.Both thread's NOFS state and thead's
journal_infostate can't be changed in that case, right ?
So should it better be,Quoted 5 lines
__xfs_trans_commit(tp, regrant)
xfs_trans_free(tp, regrant)
if (!regrant). // don't clear thexfs_trans_contextif
regrant is true.
xfs_trans_context_clear()
Quoted 5 lines
No. You are trying to make this way more complex than it needs to be. The logic in the core XFS code is *already correct* and all we need to do is move that logic to wrapper functions, then slightly modify the implementation inside the wrapper functions.
Thanks for the explanation.
Quoted 3 lines
That is,
xfs_trans_context_clear()should end up like this:
Agreed.
Quoted 8 lines
static inline void
xfs_trans_context_clear(struct xfs_trans *tp){ /* * If xfs_trans_context_swap() handed the NOFS context to a * new transaction we do not clear the context here. */ if (current->journal_info != tp)
current->journal_info hasn't been used in patch #3, that will make patch #3 a little more complex.
We have to do some workaround in patch #3. I will think about it.
Quoted 9 lines
return; current->journal_info = NULL; memalloc_nofs_restore(tp->t_pflags); }-Dave.
--
Dave Chinner
[email protected]
Signature · 2 lines
Thanks Yafang
Re: [PATCH v12 3/4] xfs: refactor the usage around xfs_trans_context_{set,clear}
Quoted 13 lines · Yafang Shao
Quoted 11 lines · Dave Chinner
Quoted 2 lines · Yafang Shao
Quoted 1 line · Darrick J. Wong
On Wed, Dec 09, 2020 at 09:11:45PM +0800, Yafang Shao wrote:
static inline void
xfs_trans_context_clear(struct xfs_trans *tp){ /* * If xfs_trans_context_swap() handed the NOFS context to a * new transaction we do not clear the context here. */ if (current->journal_info != tp)
Quoted 3 lines
current->journal_infohasn't been used in patch #3, that will make patch #3 a little more complex.
We have to do some workaround in patch #3. I will think about it.
What I wrote is how the function should look at the end of the patch series. Do not add the current->journal_info parts of it until the patch that introduces the current->journal_info tracking.
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v12 3/4] xfs: refactor the usage around xfs_trans_context_{set,clear}
Quoted 15 lines · Dave Chinner
Quoted 13 lines · Yafang Shao
Quoted 11 lines · Dave Chinner
Quoted 2 lines · Yafang Shao
Quoted 1 line · Darrick J. Wong
On Wed, Dec 09, 2020 at 09:11:45PM +0800, Yafang Shao wrote:
static inline void
xfs_trans_context_clear(struct xfs_trans *tp){ /* * If xfs_trans_context_swap() handed the NOFS context to a * new transaction we do not clear the context here. */ if (current->journal_info != tp)
Quoted 8 lines
Quoted 3 lines
current->journal_infohasn't been used in patch #3, that will make patch #3 a little more complex.
We have to do some workaround in patch #3. I will think about it.What I wrote is how the function should look at the end of the patch series. Do not add the
current->journal_infoparts of it until the patch that introduces thecurrent->journal_infotracking.
I know what you meant.
While I mean we have to do some hack, as suggested by Darrrick that "set NOFS in the old transaction'st_pflags so that when we clear the context on the old transaction we don't actually change the thread's NOFS state." in patch #3 and then remove it in patch #4.
Signature · 2 lines
Thanks Yafang
PATCH v12 4/4 xfs: use current->journal_info to avoid transaction reservation recursion
In reply to Yafang ShaoPF_FSTRANS which is used to avoid transaction reservation recursion, is dropped since commit 9070733b4efa ("xfs: abstract PF_FSTRANS to PF_MEMALLOC_NOFS") and commit 7dea19f9ee63 ("mm: introduce memalloc_nofs_{save,restore} API") and replaced by PF_MEMALLOC_NOFS which means to avoid filesystem reclaim recursion.
As these two flags have different meanings, we'd better reintroduce PF_FSTRANS back. To avoid wasting the space of PF_* flags in task_struct, we can reuse the current->journal_info to do that, per Willy. As the check of transaction reservation recursion is used by XFS only, we can move the check into xfs_vm_writepage(s), per Dave.
To better abstract that behavoir, two new helpers are introduced, as follows,
- xfs_trans_context_active
To check whehter current is in fs transcation or not
- xfs_trans_context_swap
Transfer the transaction context when rolling a permanent transaction
These two new helpers are instroduced in xfs_trans.h.
--- fs/iomap/buffered-io.c | 7 ------- fs/xfs/xfs_aops.c | 17 +++++++++++++++++ fs/xfs/xfs_trans.c | 4 +++- fs/xfs/xfs_trans.h | 23 +++++++++++++++++++++++ 4 files changed, 43 insertions(+), 8 deletions(-)
fs/iomap/buffered-io.c +0 -7
@@ -1458,13 +1458,6 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data) PF_MEMALLOC)) goto redirty; -/* -* Given that we do not allow direct reclaim to call us, we should -* never be called in a recursive filesystem reclaim context. -*/ -if (WARN_ON_ONCE (current->flags &PF_MEMALLOC_NOFS )) - goto redirty; -/* * Is this page beyond the end of the file? *
fs/xfs/xfs_aops.c +17 -0
@@ -568,6 +568,16 @@ xfs_vm_writepage( {struct xfs_writepage_ctx wpc = { }; +/* +* Given that we do not allow direct reclaim to call us, we should +* never be called while in a filesystem transaction. +*/ +if (WARN_ON_ONCE (xfs_trans_context_active ())) { +redirty_page_for_writepage (wbc, page); +unlock_page (page); +return 0 ; + } +return iomap_writepage (page, wbc, &wpc.ctx, &xfs_writeback_ops); }
@@ -579,6 +589,13 @@ xfs_vm_writepages(struct xfs_writepage_ctx wpc = { };xfs_iflags_clear (XFS_I (mapping->host),XFS_ITRUNCATED ); +/* +* Given that we do not allow direct reclaim to call us, we should +* never be called while in a filesystem transaction. +*/ +if (WARN_ON_ONCE (xfs_trans_context_active ())) +return 0 ; +return iomap_writepages (mapping, wbc, &wpc.ctx, &xfs_writeback_ops); }
fs/xfs/xfs_trans.c +3 -1
@@ -130,7 +130,9 @@ xfs_trans_dup( ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used; tp->t_rtx_res = tp->t_rtx_res_used; - ntp->t_pflags = tp->t_pflags; + +/* Associate the new transaction with this thread. */ +xfs_trans_context_swap (tp, ntp);/* move deferred ops over to the new tp */ xfs_defer_move (ntp, tp);
fs/xfs/xfs_trans.h +23 -0
@@ -268,16 +268,39 @@ xfs_trans_item_relog(return lip->li_ops->iop_relog (lip, tp); } +static inline bool +xfs_trans_context_active (void ) +{ +/* Use journal_info to indicate current is in a transaction */ +return current->journal_info !=NULL ; +} +static inline void xfs_trans_context_set (struct xfs_trans *tp) { +ASSERT (!current->journal_info); + current->journal_info = tp; tp->t_pflags =memalloc_nofs_save (); }static inline void xfs_trans_context_clear (struct xfs_trans *tp) { +ASSERT (current->journal_info == tp); + current->journal_info =NULL ;memalloc_nofs_restore (tp->t_pflags); } +/* +* Transfer the transaction context when rolling a permanent +* transaction. +*/ +static inline void +xfs_trans_context_swap (struct xfs_trans *tp,struct xfs_trans *ntp) +{ +ASSERT (current->journal_info == tp); + ntp->t_pflags = tp->t_pflags; + current->journal_info = ntp; +} +#endif /* __XFS_TRANS_H__ */
Signature · 1 line
2.18.4