convert XFS perag lookup to xarrays v3
Hi all,
for a project with the pending RT group code in XFS that reuses the basic perag concepts I'd much prefer to use xarrays over the old radix tree for nicer iteration semantics.
This series converts the perag code to xarrays to keep them in sync and throws in the use of kfree_rcu_mightsleep in the same area.
Changes since v2:
- fix a comment (which gets removed in a later patch)
Changes since v1:
- use xa_insert instead of reinventing it
- split API changes into separate patches
- simplify tagged iteration
- use the proper xa_mark_t type for marks to make sparse happy
Diffstat:
libxfs/xfs_ag.c | 94 +++++--------------------------------------------------- libxfs/xfs_ag.h | 14 -------- xfs_icache.c | 85 +++++++++++++++++++++++++++++++++++--------------- xfs_mount.h | 3 - xfs_super.c | 3 - xfs_trace.h | 4 +- 6 files changed, 72 insertions(+), 131 deletions(-)
PATCH 1/5 xfs: use kfree_rcu_mightsleep to free the perag structures
Using the kfree_rcu_mightsleep is simpler and removes the need for a rcu_head in the perag structure.
--- fs/xfs/libxfs/xfs_ag.c | 12 +----------- fs/xfs/libxfs/xfs_ag.h | 3 --- 2 files changed, 1 insertion(+), 14 deletions(-)
fs/xfs/libxfs/xfs_ag.c +1 -11
@@ -235,16 +235,6 @@ xfs_initialize_perag_data(return error; } -STATIC void -__xfs_free_perag ( -struct rcu_head *head) -{ - struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head); - -ASSERT (!delayed_work_pending (&pag->pag_blockgc_work)); -kfree (pag); -} -/* * Free up the per-ag resources associated with the mount structure. */
@@ -270,7 +260,7 @@ xfs_free_perag(xfs_perag_rele (pag);XFS_IS_CORRUPT (pag->pag_mount,atomic_read (&pag->pag_active_ref) !=0 ); -call_rcu (&pag->rcu_head, __xfs_free_perag); +kfree_rcu_mightsleep (pag); } }
fs/xfs/libxfs/xfs_ag.h +0 -3
@@ -63,9 +63,6 @@ struct xfs_perag {/* Blocks reserved for the reverse mapping btree. */ struct xfs_ag_resv pag_rmapbt_resv; -/* for rcu-safe freeing */ -struct rcu_head rcu_head; -/* Precalculated geometry info */ xfs_agblock_t block_count;xfs_agblock_t min_block;
Signature · 1 line
2.43.0
Re: [PATCH 1/5] xfs: use kfree_rcu_mightsleep to free the perag structures
Quoted 4 lines · Christoph Hellwig
Using the
kfree_rcu_mightsleepis simpler and removes the need for arcu_headin the perag structure.Signed-off-by Christoph Hellwig <[email protected]>
Looks good to me!
--D
Quoted 53 lines
--- fs/xfs/libxfs/xfs_ag.c | 12 +----------- fs/xfs/libxfs/xfs_ag.h | 3 --- 2 files changed, 1 insertion(+), 14 deletions(-)fs/xfs/libxfs/xfs_ag.c +1
-11@@ -235,16 +235,6 @@ xfs_initialize_perag_data(return error; } -STATIC void -__xfs_free_perag ( -struct rcu_head *head) -{ - struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head); - -ASSERT (!delayed_work_pending (&pag->pag_blockgc_work)); -kfree (pag); -} -/* * Free up the per-ag resources associated with the mount structure. */ @@ -270,7 +260,7 @@ xfs_free_perag(xfs_perag_rele (pag);XFS_IS_CORRUPT (pag->pag_mount,atomic_read (&pag->pag_active_ref) !=0 ); -call_rcu (&pag->rcu_head, __xfs_free_perag); +kfree_rcu_mightsleep (pag); } }fs/xfs/libxfs/xfs_ag.h +0
-3@@ -63,9 +63,6 @@ struct xfs_perag {/* Blocks reserved for the reverse mapping btree. */ struct xfs_ag_resv pag_rmapbt_resv; -/* for rcu-safe freeing */ -struct rcu_head rcu_head; -/* Precalculated geometry info */ xfs_agblock_t block_count;xfs_agblock_t min_block;Signature · 1 line
2.43.0
PATCH 2/5 xfs: move the tagged perag lookup helpers to xfs_icache.c
In reply to Christoph HellwigThe tagged perag helpers are only used in xfs_icache.c in the kernel code and not at all in xfsprogs. Move them to xfs_icache.c in preparation for switching to an xarray, for which I have no plan to implement the tagged lookup functions for userspace.
--- fs/xfs/libxfs/xfs_ag.c | 51 ------------------------------------- fs/xfs/libxfs/xfs_ag.h | 11 -------- fs/xfs/xfs_icache.c | 58 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 58 insertions(+), 62 deletions(-)
fs/xfs/libxfs/xfs_ag.c +0 -51
@@ -56,31 +56,6 @@ xfs_perag_get(return pag; } -/* -* search from @first to find the next perag with the given tag set. -*/ -struct xfs_perag * -xfs_perag_get_tag ( -struct xfs_mount *mp, -xfs_agnumber_t first, -unsigned int tag) -{ -struct xfs_perag *pag; -int found; - -rcu_read_lock (); - found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); -if (found <=0 ) { -rcu_read_unlock (); -return NULL ; - } -trace_xfs_perag_get_tag (pag, _RET_IP_); -atomic_inc (&pag->pag_ref); -rcu_read_unlock (); -return pag; -} -/* Get a passive reference to the given perag. */ struct xfs_perag * xfs_perag_hold(
@@ -127,32 +102,6 @@ xfs_perag_grab(return pag; } -/* -* search from @first to find the next perag with the given tag set. -*/ -struct xfs_perag * -xfs_perag_grab_tag ( -struct xfs_mount *mp, -xfs_agnumber_t first, -int tag) -{ -struct xfs_perag *pag; -int found; - -rcu_read_lock (); - found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); -if (found <=0 ) { -rcu_read_unlock (); -return NULL ; - } -trace_xfs_perag_grab_tag (pag, _RET_IP_); -if (!atomic_inc_not_zero (&pag->pag_active_ref)) - pag =NULL ; -rcu_read_unlock (); -return pag; -} -void xfs_perag_rele (struct xfs_perag *pag)
fs/xfs/libxfs/xfs_ag.h +0 -11
@@ -153,15 +153,11 @@ void xfs_free_perag(struct xfs_mount *mp);/* Passive AG references */ struct xfs_perag *xfs_perag_get (struct xfs_mount *mp,xfs_agnumber_t agno); -struct xfs_perag *xfs_perag_get_tag (struct xfs_mount *mp,xfs_agnumber_t agno, -unsigned int tag);struct xfs_perag *xfs_perag_hold (struct xfs_perag *pag);void xfs_perag_put (struct xfs_perag *pag);/* Active AG references */ struct xfs_perag *xfs_perag_grab (struct xfs_mount *,xfs_agnumber_t ); -struct xfs_perag *xfs_perag_grab_tag (struct xfs_mount *,xfs_agnumber_t , -int tag);void xfs_perag_rele (struct xfs_perag *pag);/*
@@ -263,13 +259,6 @@ xfs_perag_next( (agno) =0 ; \ for_each_perag_from((mp), (agno), (pag)) -#define for_each_perag_tag (mp, agno, pag, tag) \ - for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ - (pag) != NULL; \ - (agno) = (pag)->pag_agno + 1, \ - xfs_perag_rele(pag), \ - (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) -static inline struct xfs_perag * xfs_perag_next_wrap( struct xfs_perag *pag,
fs/xfs/xfs_icache.c +58 -0
64 lines not on this page · raw message
Signature · 1 line
2.43.0
Re: [PATCH 2/5] xfs: move the tagged perag lookup helpers to xfs_icache.c
Quoted 6 lines · Christoph Hellwig
The tagged perag helpers are only used in
xfs_icache.cin the kernel code and not at all in xfsprogs. Move them toxfs_icache.cin preparation for switching to an xarray, for which I have no plan to implement the tagged lookup functions for userspace.Signed-off-by Christoph Hellwig <[email protected]>
Not thrilled about this, but I won't hold up the rest of the conversion...
--D
Quoted 182 lines
--- fs/xfs/libxfs/xfs_ag.c | 51 ------------------------------------- fs/xfs/libxfs/xfs_ag.h | 11 -------- fs/xfs/xfs_icache.c | 58 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 58 insertions(+), 62 deletions(-)fs/xfs/libxfs/xfs_ag.c +0
-51@@ -56,31 +56,6 @@ xfs_perag_get(return pag; } -/* -* search from @first to find the next perag with the given tag set. -*/ -struct xfs_perag * -xfs_perag_get_tag ( -struct xfs_mount *mp, -xfs_agnumber_t first, -unsigned int tag) -{ -struct xfs_perag *pag; -int found; - -rcu_read_lock (); - found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); -if (found <=0 ) { -rcu_read_unlock (); -return NULL ; - } -trace_xfs_perag_get_tag (pag, _RET_IP_); -atomic_inc (&pag->pag_ref); -rcu_read_unlock (); -return pag; -} -/* Get a passive reference to the given perag. */ struct xfs_perag * xfs_perag_hold(@@ -127,32 +102,6 @@ xfs_perag_grab(return pag; } -/* -* search from @first to find the next perag with the given tag set. -*/ -struct xfs_perag * -xfs_perag_grab_tag ( -struct xfs_mount *mp, -xfs_agnumber_t first, -int tag) -{ -struct xfs_perag *pag; -int found; - -rcu_read_lock (); - found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); -if (found <=0 ) { -rcu_read_unlock (); -return NULL ; - } -trace_xfs_perag_grab_tag (pag, _RET_IP_); -if (!atomic_inc_not_zero (&pag->pag_active_ref)) - pag =NULL ; -rcu_read_unlock (); -return pag; -} -void xfs_perag_rele (struct xfs_perag *pag)fs/xfs/libxfs/xfs_ag.h +0
-11@@ -153,15 +153,11 @@ void xfs_free_perag(struct xfs_mount *mp);/* Passive AG references */ struct xfs_perag *xfs_perag_get (struct xfs_mount *mp,xfs_agnumber_t agno); -struct xfs_perag *xfs_perag_get_tag (struct xfs_mount *mp,xfs_agnumber_t agno, -unsigned int tag);struct xfs_perag *xfs_perag_hold (struct xfs_perag *pag);void xfs_perag_put (struct xfs_perag *pag);/* Active AG references */ struct xfs_perag *xfs_perag_grab (struct xfs_mount *,xfs_agnumber_t ); -struct xfs_perag *xfs_perag_grab_tag (struct xfs_mount *,xfs_agnumber_t , -int tag);void xfs_perag_rele (struct xfs_perag *pag);/* @@ -263,13 +259,6 @@ xfs_perag_next( (agno) =0 ; \ for_each_perag_from((mp), (agno), (pag)) -#define for_each_perag_tag (mp, agno, pag, tag) \ - for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ - (pag) != NULL; \ - (agno) = (pag)->pag_agno + 1, \ - xfs_perag_rele(pag), \ - (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) -static inline struct xfs_perag * xfs_perag_next_wrap( struct xfs_perag *pag,fs/xfs/xfs_icache.c +58
-0@@ -292,6 +292,64 @@ xfs_perag_clear_inode_tag(trace_xfs_perag_clear_inode_tag (pag, _RET_IP_); } +/* +* Search from @first to find the next perag with the given tag set. +*/ +static struct xfs_perag * +xfs_perag_get_tag ( +struct xfs_mount *mp, +xfs_agnumber_t first, +unsigned int tag) +{ +struct xfs_perag *pag; +int found; + +rcu_read_lock (); + found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, + (void **)&pag, first,1 , tag); +if (found <=0 ) { +rcu_read_unlock (); +return NULL ; + } +trace_xfs_perag_get_tag (pag, _RET_IP_); +atomic_inc (&pag->pag_ref); +rcu_read_unlock (); +return pag; +} + +/* +* Search from @first to find the next perag with the given tag set. +*/ +static struct xfs_perag * +xfs_perag_grab_tag ( +struct xfs_mount *mp, +xfs_agnumber_t first, +int tag) +{ +struct xfs_perag *pag; +int found; + +rcu_read_lock (); + found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, + (void **)&pag, first,1 , tag); +if (found <=0 ) { +rcu_read_unlock (); +return NULL ; + } +trace_xfs_perag_grab_tag (pag, _RET_IP_); +if (!atomic_inc_not_zero (&pag->pag_active_ref)) + pag =NULL ; +rcu_read_unlock (); +return pag; +} + +#define for_each_perag_tag (mp, agno, pag, tag) \ + for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ + (pag) != NULL; \ + (agno) = (pag)->pag_agno + 1, \ + xfs_perag_rele(pag), \ + (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) +/* * When we recycle a reclaimable inode, we need to re-initialise the VFS inode * part of the structure. This is made more complex by the fact we store Signature · 1 line
2.43.0
PATCH 3/5 xfs: simplify tagged perag iteration
In reply to Christoph HellwigPass the old perag structure to the tagged loop helpers so that they can grab the old agno before releasing the reference. This removes the need to separately track the agno and the iterator macro, and thus also obsoletes the for_each_perag_tag syntactic sugar.
--- fs/xfs/xfs_icache.c | 71 +++++++++++++++++++++------------------------ fs/xfs/xfs_trace.h | 4 +-- 2 files changed, 35 insertions(+), 40 deletions(-)
fs/xfs/xfs_icache.c +33 -38
@@ -293,63 +293,66 @@ xfs_perag_clear_inode_tag( }/* -* Search from @first to find the next perag with the given tag set. +* Find the next AG after @pag, or the first AG if @pag is NULL. */ static struct xfs_perag * -xfs_perag_get_tag ( +xfs_perag_get_next_tag (struct xfs_mount *mp, -xfs_agnumber_t first, +struct xfs_perag *pag,unsigned int tag) { -struct xfs_perag *pag; +unsigned long index =0 ;int found; +if (pag) { + index = pag->pag_agno +1 ; +xfs_perag_rele (pag); + } +rcu_read_lock (); found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); + (void **)&pag, index,1 , tag);if (found <=0 ) {rcu_read_unlock ();return NULL ; } -trace_xfs_perag_get_tag (pag, _RET_IP_); +trace_xfs_perag_get_next_tag (pag, _RET_IP_);atomic_inc (&pag->pag_ref);rcu_read_unlock ();return pag; }/* -* Search from @first to find the next perag with the given tag set. +* Find the next AG after @pag, or the first AG if @pag is NULL. */ static struct xfs_perag * -xfs_perag_grab_tag ( +xfs_perag_grab_next_tag (struct xfs_mount *mp, -xfs_agnumber_t first, +struct xfs_perag *pag,int tag) { -struct xfs_perag *pag; +unsigned long index =0 ;int found; +if (pag) { + index = pag->pag_agno +1 ; +xfs_perag_rele (pag); + } +rcu_read_lock (); found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); + (void **)&pag, index,1 , tag);if (found <=0 ) {rcu_read_unlock ();return NULL ; } -trace_xfs_perag_grab_tag (pag, _RET_IP_); +trace_xfs_perag_grab_next_tag (pag, _RET_IP_);if (!atomic_inc_not_zero (&pag->pag_active_ref)) pag =NULL ;rcu_read_unlock ();return pag; } -#define for_each_perag_tag (mp, agno, pag, tag) \ - for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ - (pag) != NULL; \ - (agno) = (pag)->pag_agno + 1, \ - xfs_perag_rele(pag), \ - (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) -/* * When we recycle a reclaimable inode, we need to re-initialise the VFS inode * part of the structure. This is made more complex by the fact we store
@@ -1077,15 +1080,11 @@ longxfs_reclaim_inodes_count ( struct xfs_mount *mp) { -struct xfs_perag *pag; -xfs_agnumber_t ag =0 ; +struct xfs_perag *pag =NULL ;long reclaimable =0 ; -while ((pag =xfs_perag_get_tag (mp, ag,XFS_ICI_RECLAIM_TAG ))) { - ag = pag->pag_agno +1 ; +while ((pag =xfs_perag_get_next_tag (mp, pag,XFS_ICI_RECLAIM_TAG ))) reclaimable += pag->pag_ici_reclaimable; -xfs_perag_put (pag); - }return reclaimable; }
@@ -1427,14 +1426,13 @@ voidxfs_blockgc_start ( struct xfs_mount *mp) { -struct xfs_perag *pag; -xfs_agnumber_t agno; +struct xfs_perag *pag =NULL ;if (xfs_set_blockgc_enabled (mp))return ;trace_xfs_blockgc_start (mp, __return_address); -for_each_perag_tag (mp, agno, pag,XFS_ICI_BLOCKGC_TAG ) +while ((pag =xfs_perag_grab_next_tag (mp, pag,XFS_ICI_BLOCKGC_TAG )))xfs_blockgc_queue (pag); }
@@ -1550,21 +1548,19 @@ intxfs_blockgc_flush_all ( struct xfs_mount *mp) { -struct xfs_perag *pag; -xfs_agnumber_t agno; +struct xfs_perag *pag =NULL ;trace_xfs_blockgc_flush_all (mp, __return_address);/* -* For each blockgc worker, move its queue time up to now. If it -* wasn't queued, it will not be requeued. Then flush whatever's -* left. +* For each blockgc worker, move its queue time up to now. If it wasn't +* queued, it will not be requeued. Then flush whatever is left. */ -for_each_perag_tag (mp, agno, pag,XFS_ICI_BLOCKGC_TAG ) +while ((pag =xfs_perag_grab_next_tag (mp, pag,XFS_ICI_BLOCKGC_TAG )))mod_delayed_work (pag->pag_mount->m_blockgc_wq, &pag->pag_blockgc_work,0 ); -for_each_perag_tag (mp, agno, pag,XFS_ICI_BLOCKGC_TAG ) +while ((pag =xfs_perag_grab_next_tag (mp, pag,XFS_ICI_BLOCKGC_TAG )))flush_delayed_work (&pag->pag_blockgc_work);return xfs_inodegc_flush (mp);
@@ -1810,12 +1806,11 @@ xfs_icwalk(enum xfs_icwalk_goal goal, struct xfs_icwalk *icw) { - struct xfs_perag *pag; + struct xfs_perag *pag = NULL;int error =0 ;int last_error =0 ; -xfs_agnumber_t agno; -for_each_perag_tag (mp, agno, pag, goal) { +while ((pag =xfs_perag_grab_next_tag (mp, pag, goal))) { error =xfs_icwalk_ag (pag, goal, icw);if (error) { last_error = error;
fs/xfs/xfs_trace.h +2 -2
@@ -210,11 +210,11 @@ DEFINE_EVENT(xfs_perag_class, name, \ TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), \ TP_ARGS(pag, caller_ip)) DEFINE_PERAG_REF_EVENT(xfs_perag_get); -DEFINE_PERAG_REF_EVENT (xfs_perag_get_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_get_next_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_hold);DEFINE_PERAG_REF_EVENT (xfs_perag_put);DEFINE_PERAG_REF_EVENT (xfs_perag_grab); -DEFINE_PERAG_REF_EVENT (xfs_perag_grab_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab_next_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_rele);DEFINE_PERAG_REF_EVENT (xfs_perag_set_inode_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_clear_inode_tag);
Signature · 1 line
2.43.0
Re: [PATCH 3/5] xfs: simplify tagged perag iteration
Quoted 6 lines · Christoph Hellwig
Pass the old perag structure to the tagged loop helpers so that they can grab the old agno before releasing the reference. This removes the need to separately track the agno and the iterator macro, and thus also obsoletes the
for_each_perag_tagsyntactic sugar.Signed-off-by Christoph Hellwig <[email protected]>
I like this change!
--D
Quoted 194 lines
--- fs/xfs/xfs_icache.c | 71 +++++++++++++++++++++------------------------ fs/xfs/xfs_trace.h | 4 +-- 2 files changed, 35 insertions(+), 40 deletions(-)fs/xfs/xfs_icache.c +33
-38@@ -293,63 +293,66 @@ xfs_perag_clear_inode_tag( }/* -* Search from @first to find the next perag with the given tag set. +* Find the next AG after @pag, or the first AG if @pag is NULL. */ static struct xfs_perag * -xfs_perag_get_tag ( +xfs_perag_get_next_tag (struct xfs_mount *mp, -xfs_agnumber_t first, +struct xfs_perag *pag,unsigned int tag) { -struct xfs_perag *pag; +unsigned long index =0 ;int found; +if (pag) { + index = pag->pag_agno +1 ; +xfs_perag_rele (pag); + } +rcu_read_lock (); found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); + (void **)&pag, index,1 , tag);if (found <=0 ) {rcu_read_unlock ();return NULL ; } -trace_xfs_perag_get_tag (pag, _RET_IP_); +trace_xfs_perag_get_next_tag (pag, _RET_IP_);atomic_inc (&pag->pag_ref);rcu_read_unlock ();return pag; }/* -* Search from @first to find the next perag with the given tag set. +* Find the next AG after @pag, or the first AG if @pag is NULL. */ static struct xfs_perag * -xfs_perag_grab_tag ( +xfs_perag_grab_next_tag (struct xfs_mount *mp, -xfs_agnumber_t first, +struct xfs_perag *pag,int tag) { -struct xfs_perag *pag; +unsigned long index =0 ;int found; +if (pag) { + index = pag->pag_agno +1 ; +xfs_perag_rele (pag); + } +rcu_read_lock (); found =radix_tree_gang_lookup_tag (&mp->m_perag_tree, - (void **)&pag, first,1 , tag); + (void **)&pag, index,1 , tag);if (found <=0 ) {rcu_read_unlock ();return NULL ; } -trace_xfs_perag_grab_tag (pag, _RET_IP_); +trace_xfs_perag_grab_next_tag (pag, _RET_IP_);if (!atomic_inc_not_zero (&pag->pag_active_ref)) pag =NULL ;rcu_read_unlock ();return pag; } -#define for_each_perag_tag (mp, agno, pag, tag) \ - for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \ - (pag) != NULL; \ - (agno) = (pag)->pag_agno + 1, \ - xfs_perag_rele(pag), \ - (pag) = xfs_perag_grab_tag((mp), (agno), (tag))) -/* * When we recycle a reclaimable inode, we need to re-initialise the VFS inode * part of the structure. This is made more complex by the fact we store @@ -1077,15 +1080,11 @@ longxfs_reclaim_inodes_count ( struct xfs_mount *mp) { -struct xfs_perag *pag; -xfs_agnumber_t ag =0 ; +struct xfs_perag *pag =NULL ;long reclaimable =0 ; -while ((pag =xfs_perag_get_tag (mp, ag,XFS_ICI_RECLAIM_TAG ))) { - ag = pag->pag_agno +1 ; +while ((pag =xfs_perag_get_next_tag (mp, pag,XFS_ICI_RECLAIM_TAG ))) reclaimable += pag->pag_ici_reclaimable; -xfs_perag_put (pag); - }return reclaimable; }@@ -1427,14 +1426,13 @@ voidxfs_blockgc_start ( struct xfs_mount *mp) { -struct xfs_perag *pag; -xfs_agnumber_t agno; +struct xfs_perag *pag =NULL ;if (xfs_set_blockgc_enabled (mp))return ;trace_xfs_blockgc_start (mp, __return_address); -for_each_perag_tag (mp, agno, pag,XFS_ICI_BLOCKGC_TAG ) +while ((pag =xfs_perag_grab_next_tag (mp, pag,XFS_ICI_BLOCKGC_TAG )))xfs_blockgc_queue (pag); }@@ -1550,21 +1548,19 @@ intxfs_blockgc_flush_all ( struct xfs_mount *mp) { -struct xfs_perag *pag; -xfs_agnumber_t agno; +struct xfs_perag *pag =NULL ;trace_xfs_blockgc_flush_all (mp, __return_address);/* -* For each blockgc worker, move its queue time up to now. If it -* wasn't queued, it will not be requeued. Then flush whatever's -* left. +* For each blockgc worker, move its queue time up to now. If it wasn't +* queued, it will not be requeued. Then flush whatever is left. */ -for_each_perag_tag (mp, agno, pag,XFS_ICI_BLOCKGC_TAG ) +while ((pag =xfs_perag_grab_next_tag (mp, pag,XFS_ICI_BLOCKGC_TAG )))mod_delayed_work (pag->pag_mount->m_blockgc_wq, &pag->pag_blockgc_work,0 ); -for_each_perag_tag (mp, agno, pag,XFS_ICI_BLOCKGC_TAG ) +while ((pag =xfs_perag_grab_next_tag (mp, pag,XFS_ICI_BLOCKGC_TAG )))flush_delayed_work (&pag->pag_blockgc_work);return xfs_inodegc_flush (mp);@@ -1810,12 +1806,11 @@ xfs_icwalk(enum xfs_icwalk_goal goal, struct xfs_icwalk *icw) { - struct xfs_perag *pag; + struct xfs_perag *pag = NULL;int error =0 ;int last_error =0 ; -xfs_agnumber_t agno; -for_each_perag_tag (mp, agno, pag, goal) { +while ((pag =xfs_perag_grab_next_tag (mp, pag, goal))) { error =xfs_icwalk_ag (pag, goal, icw);if (error) { last_error = error;fs/xfs/xfs_trace.h +2
-2@@ -210,11 +210,11 @@ DEFINE_EVENT(xfs_perag_class, name, \ TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), \ TP_ARGS(pag, caller_ip)) DEFINE_PERAG_REF_EVENT(xfs_perag_get); -DEFINE_PERAG_REF_EVENT (xfs_perag_get_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_get_next_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_hold);DEFINE_PERAG_REF_EVENT (xfs_perag_put);DEFINE_PERAG_REF_EVENT (xfs_perag_grab); -DEFINE_PERAG_REF_EVENT (xfs_perag_grab_tag); +DEFINE_PERAG_REF_EVENT (xfs_perag_grab_next_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_rele);DEFINE_PERAG_REF_EVENT (xfs_perag_set_inode_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_clear_inode_tag);Signature · 1 line
2.43.0
PATCH 4/5 xfs: convert perag lookup to xarray
In reply to Christoph HellwigConvert the perag lookup from the legacy radix tree to the xarray, which allows for much nicer iteration and bulk lookup semantics.
--- fs/xfs/libxfs/xfs_ag.c | 31 +++++++------------------- fs/xfs/xfs_icache.c | 50 +++++++++++++++++++++--------------------- fs/xfs/xfs_mount.h | 3 +-- fs/xfs/xfs_super.c | 3 +-- 4 files changed, 35 insertions(+), 52 deletions(-)
fs/xfs/libxfs/xfs_ag.c +8 -23
@@ -46,7 +46,7 @@ xfs_perag_get(struct xfs_perag *pag;rcu_read_lock (); - pag =radix_tree_lookup (&mp->m_perag_tree, agno); + pag =xa_load (&mp->m_perags, agno);if (pag) {trace_xfs_perag_get (pag, _RET_IP_);ASSERT (atomic_read (&pag->pag_ref) >=0 );
@@ -92,7 +92,7 @@ xfs_perag_grab(struct xfs_perag *pag;rcu_read_lock (); - pag =radix_tree_lookup (&mp->m_perag_tree, agno); + pag =xa_load (&mp->m_perags, agno);if (pag) {trace_xfs_perag_grab (pag, _RET_IP_);if (!atomic_inc_not_zero (&pag->pag_active_ref))
@@ -195,9 +195,7 @@ xfs_free_perag(xfs_agnumber_t agno;for (agno =0 ; agno < mp->m_sb.sb_agcount; agno++) { -spin_lock (&mp->m_perag_lock); - pag =radix_tree_delete (&mp->m_perag_tree, agno); -spin_unlock (&mp->m_perag_lock); + pag =xa_erase (&mp->m_perags, agno);ASSERT (pag);XFS_IS_CORRUPT (pag->pag_mount,atomic_read (&pag->pag_ref) !=0 );xfs_defer_drain_free (&pag->pag_intents_drain);
@@ -286,9 +284,7 @@ xfs_free_unused_perag_range(xfs_agnumber_t index;for (index = agstart; index < agend; index++) { -spin_lock (&mp->m_perag_lock); - pag =radix_tree_delete (&mp->m_perag_tree, index); -spin_unlock (&mp->m_perag_lock); + pag =xa_erase (&mp->m_perags, index);if (!pag)break ;xfs_buf_cache_destroy (&pag->pag_bcache);
@@ -329,20 +325,11 @@ xfs_initialize_perag( pag->pag_agno = index; pag->pag_mount = mp; - error =radix_tree_preload (GFP_KERNEL | __GFP_RETRY_MAYFAIL); -if (error) - goto out_free_pag; - -spin_lock (&mp->m_perag_lock); -if (radix_tree_insert (&mp->m_perag_tree, index, pag)) { -WARN_ON_ONCE (1 ); -spin_unlock (&mp->m_perag_lock); -radix_tree_preload_end (); - error = -EEXIST ; + error =xa_insert (&mp->m_perags, index, pag,GFP_KERNEL ); +if (error) { +WARN_ON_ONCE (error == -EBUSY ); goto out_free_pag; } -spin_unlock (&mp->m_perag_lock); -radix_tree_preload_end ();#ifdef __KERNEL__/* Place kernel structure only init below this point. */
@@ -390,9 +377,7 @@ xfs_initialize_perag( out_remove_pag:xfs_defer_drain_free (&pag->pag_intents_drain); -spin_lock (&mp->m_perag_lock); -radix_tree_delete (&mp->m_perag_tree, index); -spin_unlock (&mp->m_perag_lock); + pag =xa_erase (&mp->m_perags, index); out_free_pag:kfree (pag); out_unwind_new_pags:
fs/xfs/xfs_icache.c +25 -25
106 lines not on this page · raw message
fs/xfs/xfs_mount.h +1 -2
@@ -208,8 +208,7 @@ typedef struct xfs_mount {*/ atomic64_t m_allocbt_blks; -struct radix_tree_root m_perag_tree;/* per-ag accounting info */ -spinlock_t m_perag_lock;/* lock for m_perag_tree */ +struct xarray m_perags;/* per-ag accounting info */ uint64_t m_resblks;/* total reserved blocks */ uint64_t m_resblks_avail;/* available reserved blocks */ uint64_t m_resblks_save;/* reserved blks @ remount,ro */
fs/xfs/xfs_super.c +1 -2
@@ -2009,8 +2009,7 @@ static int xfs_init_fs_context(return -ENOMEM ;spin_lock_init (&mp->m_sb_lock); -INIT_RADIX_TREE (&mp->m_perag_tree,GFP_ATOMIC ); -spin_lock_init (&mp->m_perag_lock); +xa_init (&mp->m_perags);mutex_init (&mp->m_growlock);INIT_WORK (&mp->m_flush_inodes_work, xfs_flush_inodes_worker);INIT_DELAYED_WORK (&mp->m_reclaim_work, xfs_reclaim_worker);
Signature · 1 line
2.43.0
PATCH 5/5 xfs: use xas_for_each_marked in xfs_reclaim_inodes_count
In reply to Christoph Hellwigxfs_reclaim_inodes_count iterates over all AGs to sum up the reclaimable inodes counts. There is no point in grabbing a reference to the them or unlock the RCU critical section for each iteration, so switch to the more efficient xas_for_each_marked iterator.
--- fs/xfs/xfs_icache.c | 36 ++++++++---------------------------- fs/xfs/xfs_trace.h | 2 +- 2 files changed, 9 insertions(+), 29 deletions(-)
fs/xfs/xfs_icache.c +8 -28
@@ -300,32 +300,6 @@ xfs_perag_clear_inode_tag(trace_xfs_perag_clear_inode_tag (pag, _RET_IP_); } -/* -* Find the next AG after @pag, or the first AG if @pag is NULL. -*/ -static struct xfs_perag * -xfs_perag_get_next_tag ( -struct xfs_mount *mp, -struct xfs_perag *pag, -unsigned int tag) -{ -unsigned long index =0 ; - -if (pag) { - index = pag->pag_agno +1 ; -xfs_perag_rele (pag); - } - -rcu_read_lock (); - pag =xa_find (&mp->m_perags, &index,ULONG_MAX ,ici_tag_to_mark (tag)); -if (pag) { -trace_xfs_perag_get_next_tag (pag, _RET_IP_); -atomic_inc (&pag->pag_ref); - } -rcu_read_unlock (); -return pag; -} -/* * Find the next AG after @pag, or the first AG if @pag is NULL. */
@@ -1080,11 +1054,17 @@ longxfs_reclaim_inodes_count ( struct xfs_mount *mp) { -struct xfs_perag *pag =NULL ; +XA_STATE (xas, &mp->m_perags,0 );long reclaimable =0 ; +struct xfs_perag *pag; -while ((pag =xfs_perag_get_next_tag (mp, pag,XFS_ICI_RECLAIM_TAG ))) +rcu_read_lock (); +xas_for_each_marked (&xas, pag,ULONG_MAX ,XFS_PERAG_RECLAIM_MARK ) { +trace_xfs_reclaim_inodes_count (pag, _THIS_IP_); reclaimable += pag->pag_ici_reclaimable; + } +rcu_read_unlock (); +return reclaimable; }
fs/xfs/xfs_trace.h +1 -1
@@ -210,7 +210,6 @@ DEFINE_EVENT(xfs_perag_class, name, \ TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), \ TP_ARGS(pag, caller_ip)) DEFINE_PERAG_REF_EVENT(xfs_perag_get); -DEFINE_PERAG_REF_EVENT (xfs_perag_get_next_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_hold);DEFINE_PERAG_REF_EVENT (xfs_perag_put);DEFINE_PERAG_REF_EVENT (xfs_perag_grab);
@@ -218,6 +217,7 @@ DEFINE_PERAG_REF_EVENT(xfs_perag_grab_next_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_rele);DEFINE_PERAG_REF_EVENT (xfs_perag_set_inode_tag);DEFINE_PERAG_REF_EVENT (xfs_perag_clear_inode_tag); +DEFINE_PERAG_REF_EVENT (xfs_reclaim_inodes_count); TRACE_EVENT(xfs_inodegc_worker, TP_PROTO(struct xfs_mount *mp, unsigned int shrinker_hits),
Signature · 1 line
2.43.0