xfs: avoid transaction reservation recursion
Subsystems (6)
v10 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, which is introduced in
commit 7dea19f9ee63 ("mm: introduce memalloc_nofs_{save,restore} API"), instead of using PF_MEMALLOC_NOFS directly in XFS.
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]
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 | 24 +++++++++++------------- fs/xfs/xfs_trans.h | 37 +++++++++++++++++++++++++++++++++++++ include/linux/sched/mm.h | 23 +++++++++++++++++++++++ mm/vmscan.c | 16 +--------------- 8 files changed, 99 insertions(+), 47 deletions(-)
Signature · 1 line
2.18.4
PATCH v10 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 v10 2/4 xfs: use memalloc_nofs_{save,restore} in xfs transaction
In reply to Yafang Shaomemalloc_nofs_{save,restore} API is introduced in
commit 7dea19f9ee63 ("mm: introduce memalloc_nofs_{save,restore} API"), which gives a better abstraction of the usage around PF_MEMALLOC_NOFS. We'd better use this API in XFS instead of using PF_MEMALLOC_NOFS directly as well.
To prepare for the followup patch, two new helpers are introduced in XFS to wrap the memalloc_nofs_{save,restore} API, as follows,
static inline voidxfs_trans_context_set(struct xfs_trans *tp)
{
tp->t_pflags = memalloc_nofs_save();
}static inline voidxfs_trans_context_clear(struct xfs_trans *tp)
{
memalloc_nofs_restore(tp->t_pflags);
}These two new helpers are added into xfs_tans.h as they are used in xfs transaction only.
--- 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
Re: [PATCH v10 2/4] xfs: use memalloc_nofs_{save,restore} in xfs transaction
Quoted 15 lines · Yafang Shao
memalloc_nofs_{save,restore} API is introduced in
commit7dea19f9ee63("mm: introduce memalloc_nofs_{save,restore} API"), which gives a better abstraction of the usage aroundPF_MEMALLOC_NOFS. We'd better use this API in XFS instead of usingPF_MEMALLOC_NOFSdirectly as well.To prepare for the followup patch, two new helpers are introduced in XFS to wrap the memalloc_nofs_{save,restore} API, as follows,
static inline void
xfs_trans_context_set(struct xfs_trans *tp){ tp->t_pflags = memalloc_nofs_save(); }
Quoted 5 lines
static inline void
xfs_trans_context_clear(struct xfs_trans *tp){ memalloc_nofs_restore(tp->t_pflags); }
Don't repeat the contents of the patch in the changelog.
Also, this ordering of patches doesn't make sense. If I saw this patch by itself instead of part of the series, there's no good reason to replace one xfs-specific wrapper (current_set_flags_nested) with another (xfs_trans_context_set).
If the changelog here said something like ...
Introduce a new API to mark the start and end of XFS transactions. For now, just save and restore the memalloc_nofs flags.
... then it might make more sense to do things in this order.
Quoted 137 lines
These two new helpers are added into
xfs_tans.has they are used in xfs transaction only.Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Cc Michal Hocko <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- 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
Re: [PATCH v10 2/4] xfs: use memalloc_nofs_{save,restore} in xfs transaction
Quoted 17 lines · Matthew Wilcox
Quoted 15 lines · Yafang Shao
memalloc_nofs_{save,restore} API is introduced in
commit7dea19f9ee63("mm: introduce memalloc_nofs_{save,restore} API"), which gives a better abstraction of the usage aroundPF_MEMALLOC_NOFS. We'd better use this API in XFS instead of usingPF_MEMALLOC_NOFSdirectly as well.To prepare for the followup patch, two new helpers are introduced in XFS to wrap the memalloc_nofs_{save,restore} API, as follows,
static inline void
xfs_trans_context_set(struct xfs_trans *tp){ tp->t_pflags = memalloc_nofs_save(); }
Quoted 8 lines
Quoted 5 lines
static inline void
xfs_trans_context_clear(struct xfs_trans *tp){ memalloc_nofs_restore(tp->t_pflags); }Don't repeat the contents of the patch in the changelog.
Sure.
Quoted 5 lines
Also, this ordering of patches doesn't make sense. If I saw this patch by itself instead of part of the series, there's no good reason to replace one xfs-specific wrapper (
current_set_flags_nested) with another (xfs_trans_context_set).
Quoted 7 lines
If the changelog here said something like ...
Introduce a new API to mark the start and end of XFS transactions. For now, just save and restore the
memalloc_nofsflags.... then it might make more sense to do things in this order.
Thanks. I will update it in the next version.
Quoted 137 lines
Quoted 137 lines
These two new helpers are added into
xfs_tans.has they are used in xfs transaction only.Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Cc Michal Hocko <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- 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
-1@@ -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__ */ --2.18.4
Signature · 2 lines
Thanks Yafang
PATCH v10 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 | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-)
fs/xfs/xfs_trans.c +7 -13
@@ -67,6 +67,9 @@ 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. */ +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 +156,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 +163,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 +240,6 @@ xfs_trans_reserve( tp->t_blk_res =0 ; } -xfs_trans_context_clear (tp); -return error; }
@@ -284,6 +281,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 +877,6 @@ __xfs_trans_commit(xfs_log_commit_cil (mp, tp, &commit_lsn, regrant); -xfs_trans_context_clear (tp);xfs_trans_free (tp);/*
@@ -911,7 +909,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 +968,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
PATCH v10 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 | 3 +++ fs/xfs/xfs_trans.h | 25 +++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 7 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 (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 (xfs_trans_context_active ()) +return 0 ; +return iomap_writepages (mapping, wbc, &wpc.ctx, &xfs_writeback_ops); }
fs/xfs/xfs_trans.c +3 -0
@@ -124,6 +124,9 @@ xfs_trans_dup( 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 +25 -0
@@ -268,16 +268,41 @@ 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 */ +if (WARN_ON_ONCE (current->journal_info !=NULL )) +return true; + +return false; +} +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); + current->journal_info = ntp; +} +#endif /* __XFS_TRANS_H__ */
Signature · 1 line
2.18.4
Re: [PATCH v10 4/4] xfs: use current->journal_info to avoid transaction reservation recursion
Quoted 17 lines · Yafang Shao
fs/iomap/buffered-io.c +0
-7-/* -* 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 +0
-0@@ -568,6 +568,16 @@ xfs_vm_writepage( {struct xfs_writepage_ctx wpc = { };
fs/xfs/xfs_aops.c xfs_vm_writepage( · line 579
Quoted 10 lines
fs/xfs/xfs_aops.c +9
-0+/* +* Given that we do not allow direct reclaim to call us, we should +* never be called while in a filesystem transaction. +*/ +if (xfs_trans_context_active ()) { +redirty_page_for_writepage (wbc, page); +unlock_page (page); +return 0 ; + }
Dave specifically asked for this one to WARN too.
Re: [PATCH v10 4/4] xfs: use current->journal_info to avoid transaction reservation recursion
Quoted 20 lines · Matthew Wilcox
Quoted 18 lines · Yafang Shao
fs/iomap/buffered-io.c +0
-7-/* -* 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 +0
-0@@ -568,6 +568,16 @@ xfs_vm_writepage( {struct xfs_writepage_ctx wpc = { };
Quoted 11 lines
fs/xfs/xfs_aops.c xfs_vm_writepage( · line 579
Quoted 9 lines
fs/xfs/xfs_aops.c +9
-0+/* +* Given that we do not allow direct reclaim to call us, we should +* never be called while in a filesystem transaction. +*/ +if (xfs_trans_context_active ()) { +redirty_page_for_writepage (wbc, page); +unlock_page (page); +return 0 ; + }Dave specifically asked for this one to WARN too.
I put the warn in xfs_trans_context_active(), pls. see the definition of it. Is that okay ?
Signature · 2 lines
Thanks Yafang
Re: [PATCH v10 4/4] xfs: use current->journal_info to avoid transaction reservation recursion
In reply to Yafang ShaoQuoted 61 lines · Yafang Shao
PF_FSTRANSwhich is used to avoid transaction reservation recursion, is dropped since commit9070733b4efa("xfs: abstractPF_FSTRANStoPF_MEMALLOC_NOFS") and commit7dea19f9ee63("mm: introduce memalloc_nofs_{save,restore} API") and replaced byPF_MEMALLOC_NOFSwhich means to avoid filesystem reclaim recursion.As these two flags have different meanings, we'd better reintroduce
PF_FSTRANSback. To avoid wasting the space of PF_* flags intask_struct, we can reuse thecurrent->journal_infoto do that, per Willy. As the check of transaction reservation recursion is used by XFS only, we can move the check intoxfs_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 transactionThese two new helpers are instroduced in
xfs_trans.h.Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Cc Michal Hocko <[email protected]>Cc David Howells <[email protected]>Cc Jeff Layton <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- fs/iomap/buffered-io.c | 7 ------- fs/xfs/xfs_aops.c | 17 +++++++++++++++++ fs/xfs/xfs_trans.c | 3 +++ fs/xfs/xfs_trans.h | 25 +++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 7 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 +0
-0@@ -568,6 +568,16 @@ xfs_vm_writepage( {struct xfs_writepage_ctx wpc = { };
fs/xfs/xfs_aops.c xfs_vm_writepage( · line 579
Quoted 10 lines
fs/xfs/xfs_aops.c +9
-0+/* +* Given that we do not allow direct reclaim to call us, we should +* never be called while in a filesystem transaction. +*/ +if (xfs_trans_context_active ()) { +redirty_page_for_writepage (wbc, page); +unlock_page (page); +return 0 ; + }
hmmm. Missing warning....
Quoted 7 lines
fs/xfs/xfs_trans.h +0
-0@@ -268,16 +268,41 @@ xfs_trans_item_relog(return lip->li_ops->iop_relog (lip, tp); }
fs/xfs/xfs_trans.h xfs_trans_item_relog( · line 279
Quoted 10 lines
fs/xfs/xfs_trans.h +9
-0+static inline bool +xfs_trans_context_active (void ) +{ +/* Use journal_info to indicate current is in a transaction */ +if (WARN_ON_ONCE (current->journal_info !=NULL )) +return true; + +return false; +}
Ah, this is wrong. The call sites should be:
if (WARN_ON_ONCE(xfs_trans_context_active())) {
/* do error handling */
return error_value;
}because we might want to use xfs_trans_context_active() to check if we are in a transaction context or not and that should not generate a warning. Also, placing the warning at the call site gives a more accurate indication of which IO path generated the warning....
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH v10 4/4] xfs: use current->journal_info to avoid transaction reservation recursion
Quoted 101 lines · Dave Chinner
Quoted 61 lines · Yafang Shao
PF_FSTRANSwhich is used to avoid transaction reservation recursion, is dropped since commit9070733b4efa("xfs: abstractPF_FSTRANStoPF_MEMALLOC_NOFS") and commit7dea19f9ee63("mm: introduce memalloc_nofs_{save,restore} API") and replaced byPF_MEMALLOC_NOFSwhich means to avoid filesystem reclaim recursion.As these two flags have different meanings, we'd better reintroduce
PF_FSTRANSback. To avoid wasting the space of PF_* flags intask_struct, we can reuse thecurrent->journal_infoto do that, per Willy. As the check of transaction reservation recursion is used by XFS only, we can move the check intoxfs_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 transactionThese two new helpers are instroduced in
xfs_trans.h.Cc Darrick J. Wong <[email protected]>Cc Matthew Wilcox (Oracle) <[email protected]>Cc Christoph Hellwig <[email protected]>Cc Dave Chinner <[email protected]>Cc Michal Hocko <[email protected]>Cc David Howells <[email protected]>Cc Jeff Layton <[email protected]>Signed-off-by Yafang Shao <[email protected]>--- fs/iomap/buffered-io.c | 7 ------- fs/xfs/xfs_aops.c | 17 +++++++++++++++++ fs/xfs/xfs_trans.c | 3 +++ fs/xfs/xfs_trans.h | 25 +++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 7 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 +0
-0@@ -568,6 +568,16 @@ xfs_vm_writepage( {struct xfs_writepage_ctx wpc = { };fs/xfs/xfs_aops.c xfs_vm_writepage( · line 579
Quoted 10 lines
fs/xfs/xfs_aops.c +9
-0+/* +* Given that we do not allow direct reclaim to call us, we should +* never be called while in a filesystem transaction. +*/ +if (xfs_trans_context_active ()) { +redirty_page_for_writepage (wbc, page); +unlock_page (page); +return 0 ; + }hmmm. Missing warning....
Quoted 7 lines
fs/xfs/xfs_trans.h +0
-0@@ -268,16 +268,41 @@ xfs_trans_item_relog(return lip->li_ops->iop_relog (lip, tp); }fs/xfs/xfs_trans.h xfs_trans_item_relog( · line 279
Quoted 10 lines
fs/xfs/xfs_trans.h +9
-0+static inline bool +xfs_trans_context_active (void ) +{ +/* Use journal_info to indicate current is in a transaction */ +if (WARN_ON_ONCE (current->journal_info !=NULL )) +return true; + +return false; +}Ah, this is wrong. The call sites should be:
if (WARN_ON_ONCE(xfs_trans_context_active())) { /* do error handling */ return error_value; }
Quoted 5 lines
because we might want to use
xfs_trans_context_active()to check if we are in a transaction context or not and that should not generate a warning. Also, placing the warning at the call site gives a more accurate indication of which IO path generated the warning....
Thanks for the explanation. I will update it in the next version.
Signature · 2 lines
Thanks Yafang