improve busy extent handling and add async discard support V3
This series improves the busy extent handling so hat we don't break the guarantee of being able to complete an allocation after fixing the freelist, and once this is sorted out adds support for submitting discard requests without blocking the log commit handler, which significantly stresses the busy extent handling.
Changes since V2:
- make sure all busy extents are gone at umount time
- document the busy_gen handling
Changes since V1:
- address various feedback from Brian
PATCH 1/5 xfs: don't fail xfs_extent_busy allocation
We don't just need the structure to track busy extents which can be avoided with a synchronous transaction, but also to keep track of pending discard.
--- fs/xfs/xfs_extent_busy.c | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-)
fs/xfs/xfs_extent_busy.c +1 -12
@@ -45,18 +45,7 @@ xfs_extent_busy_insert(struct rb_node **rbp;struct rb_node *parent =NULL ; - new =kmem_zalloc (sizeof (struct xfs_extent_busy ),KM_MAYFAIL ); -if (!new) { -/* -* No Memory! Since it is now not possible to track the free -* block, make this a synchronous transaction to insure that -* the block is not reused before this transaction commits. -*/ -trace_xfs_extent_busy_enomem (tp->t_mountp, agno, bno, len); -xfs_trans_set_sync (tp); -return ; - } - + new =kmem_zalloc (sizeof (struct xfs_extent_busy ),KM_SLEEP ); new->agno = agno; new->bno = bno; new->length = len;
Signature · 1 line
2.11.0
PATCH 2/5 xfs: improve handling of busy extents in the low-level allocator
In reply to Christoph HellwigCurrently we force the log and simply try again if we hit a busy extent, but especially with online discard enabled it might take a while after the log force for the busy extents to disappear, and we might have already completed our second pass.
So instead we add a new waitqueue and a generation counter to the pag structure so that we can do wakeups once we've removed busy extents, and we replace the single retry with an unconditional one - after all we hold the AGF buffer lock, so no other allocations or frees can be racing with us in this AG.
--- fs/xfs/libxfs/xfs_alloc.c | 93 +++++++++++++++++++++------------------- fs/xfs/xfs_extent_busy.c | 107 +++++++++++++++++++++++++++++++++------------- fs/xfs/xfs_extent_busy.h | 8 +++- fs/xfs/xfs_mount.c | 1 + fs/xfs/xfs_mount.h | 2 + 5 files changed, 135 insertions(+), 76 deletions(-)
fs/xfs/libxfs/xfs_alloc.c +49 -44
@@ -221,20 +221,22 @@ xfs_alloc_get_rec(* Compute aligned version of the found extent. * Takes alignment and min length into account. */ -STATIC void +STATIC boolxfs_alloc_compute_aligned (xfs_alloc_arg_t *args,/* allocation argument structure */ xfs_agblock_t foundbno,/* starting block in found extent */ xfs_extlen_t foundlen,/* length in found extent */ xfs_agblock_t *resbno,/* result block number */ -xfs_extlen_t *reslen)/* result length */ +xfs_extlen_t *reslen,/* result length */ +unsigned *busy_gen) { -xfs_agblock_t bno; -xfs_extlen_t len; +xfs_agblock_t bno = foundbno; +xfs_extlen_t len = foundlen;xfs_extlen_t diff; +bool busy;/* Trim busy sections out of found extent */ -xfs_extent_busy_trim (args, foundbno, foundlen, &bno, &len); + busy =xfs_extent_busy_trim (args, &bno, &len, busy_gen);/* * If we have a largish extent that happens to start before min_agbno,
@@ -259,6 +261,8 @@ xfs_alloc_compute_aligned( *resbno = bno; *reslen = len; } + +return busy; }/*
@@ -737,10 +741,11 @@ xfs_alloc_ag_vextent_exact(int error;xfs_agblock_t fbno;/* start block of found extent */ xfs_extlen_t flen;/* length of found extent */ -xfs_agblock_t tbno;/* start block of trimmed extent */ -xfs_extlen_t tlen;/* length of trimmed extent */ -xfs_agblock_t tend;/* end block of trimmed extent */ +xfs_agblock_t tbno;/* start block of busy extent */ +xfs_extlen_t tlen;/* length of busy extent */ +xfs_agblock_t tend;/* end block of busy extent */ int i;/* success/failure of operation */ +unsigned busy_gen;ASSERT (args->alignment ==1 );
@@ -773,7 +778,9 @@ xfs_alloc_ag_vextent_exact(/* * Check for overlapping busy extents. */ -xfs_extent_busy_trim (args, fbno, flen, &tbno, &tlen); + tbno = fbno; + tlen = flen; +xfs_extent_busy_trim (args, &tbno, &tlen, &busy_gen);/* * Give up if the start of the extent is busy, or the freespace isn't
@@ -853,6 +860,7 @@ xfs_alloc_find_best_extent(xfs_agblock_t sdiff;int error;int i; +unsigned busy_gen;/* The good extent is perfect, no need to search. */ if (!gdiff)
@@ -866,7 +874,8 @@ xfs_alloc_find_best_extent(if (error) goto error0;XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); -xfs_alloc_compute_aligned (args, *sbno, *slen, sbnoa, slena); +xfs_alloc_compute_aligned (args, *sbno, *slen, + sbnoa, slena, &busy_gen);/* * The good extent is closer than this one.
@@ -955,7 +964,8 @@ xfs_alloc_ag_vextent_near(xfs_extlen_t ltlena;/* aligned ... */ xfs_agblock_t ltnew;/* useful start bno of left side */ xfs_extlen_t rlen;/* length of returned extent */ -int forced =0 ; +bool busy; +unsigned busy_gen;#ifdef DEBUG /* * Randomly don't execute the first algorithm.
@@ -982,6 +992,7 @@ xfs_alloc_ag_vextent_near( ltlen =0 ; gtlena =0 ; ltlena =0 ; + busy = false;/* * Get a cursor for the by-size btree.
@@ -1064,8 +1075,8 @@ xfs_alloc_ag_vextent_near(if ((error =xfs_alloc_get_rec (cnt_cur, <bno, <len, &i))) goto error0;XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); -xfs_alloc_compute_aligned (args, ltbno, ltlen, - <bnoa, <lena); + busy =xfs_alloc_compute_aligned (args, ltbno, ltlen, + <bnoa, <lena, &busy_gen);if (ltlena < args->minlen)continue ;if (ltbnoa < args->min_agbno || ltbnoa > args->max_agbno)
@@ -1183,8 +1194,8 @@ xfs_alloc_ag_vextent_near(if ((error =xfs_alloc_get_rec (bno_cur_lt, <bno, <len, &i))) goto error0;XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); -xfs_alloc_compute_aligned (args, ltbno, ltlen, - <bnoa, <lena); + busy |=xfs_alloc_compute_aligned (args, ltbno, ltlen, + <bnoa, <lena, &busy_gen);if (ltlena >= args->minlen && ltbnoa >= args->min_agbno)break ;if ((error =xfs_btree_decrement (bno_cur_lt,0 , &i)))
@@ -1199,8 +1210,8 @@ xfs_alloc_ag_vextent_near(if ((error =xfs_alloc_get_rec (bno_cur_gt, >bno, >len, &i))) goto error0;XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); -xfs_alloc_compute_aligned (args, gtbno, gtlen, - >bnoa, >lena); + busy |=xfs_alloc_compute_aligned (args, gtbno, gtlen, + >bnoa, >lena, &busy_gen);if (gtlena >= args->minlen && gtbnoa <= args->max_agbno)break ;if ((error =xfs_btree_increment (bno_cur_gt,0 , &i)))
@@ -1261,9 +1272,9 @@ xfs_alloc_ag_vextent_near(if (bno_cur_lt ==NULL && bno_cur_gt ==NULL ) {xfs_btree_del_cursor (cnt_cur,XFS_BTREE_NOERROR ); -if (!forced++) { +if (busy) {trace_xfs_alloc_near_busy (args); -xfs_log_force (args->mp,XFS_LOG_SYNC ); +xfs_extent_busy_flush (args->mp, args->pag, busy_gen); goto restart; }trace_xfs_alloc_size_neither (args);
@@ -1344,7 +1355,8 @@ xfs_alloc_ag_vextent_size(int i;/* temp status variable */ xfs_agblock_t rbno;/* returned block number */ xfs_extlen_t rlen;/* length of returned extent */ -int forced =0 ; +bool busy; +unsigned busy_gen; restart:/*
@@ -1353,6 +1365,7 @@ xfs_alloc_ag_vextent_size( cnt_cur =xfs_allocbt_init_cursor (args->mp, args->tp, args->agbp, args->agno,XFS_BTNUM_CNT ); bno_cur =NULL ; + busy = false;/* * Look for an entry >= maxlen+alignment-1 blocks.
@@ -1362,14 +1375,13 @@ xfs_alloc_ag_vextent_size( goto error0;/* -* If none or we have busy extents that we cannot allocate from, then -* we have to settle for a smaller extent. In the case that there are -* no large extents, this will return the last entry in the tree unless -* the tree is empty. In the case that there are only busy large -* extents, this will return the largest small extent unless there +* If none then we have to settle for a smaller extent. In the case that +* there are no large extents, this will return the last entry in the +* tree unless the tree is empty. In the case that there are only busy +* large extents, this will return the largest small extent unless there * are no smaller extents available. */ -if (!i || forced >1 ) { +if (!i) { error =xfs_alloc_ag_vextent_small (args, cnt_cur, &fbno, &flen, &i);if (error)
@@ -1380,13 +1392,11 @@ xfs_alloc_ag_vextent_size(return 0 ; }ASSERT (i ==1 ); -xfs_alloc_compute_aligned (args, fbno, flen, &rbno, &rlen); + busy =xfs_alloc_compute_aligned (args, fbno, flen, &rbno, + &rlen, &busy_gen); }else {/* * Search for a non-busy extent that is large enough. -* If we are at low space, don't check, or if we fall of -* the end of the btree, turn off the busy check and -* restart. */ for (;;) { error =xfs_alloc_get_rec (cnt_cur, &fbno, &flen, &i);
@@ -1394,8 +1404,8 @@ xfs_alloc_ag_vextent_size( goto error0;XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); -xfs_alloc_compute_aligned (args, fbno, flen, - &rbno, &rlen); + busy =xfs_alloc_compute_aligned (args, fbno, flen, + &rbno, &rlen, &busy_gen);if (rlen >= args->maxlen)break ;
@@ -1407,18 +1417,13 @@ xfs_alloc_ag_vextent_size(/* * Our only valid extents must have been busy. * Make it unbusy by forcing the log out and -* retrying. If we've been here before, forcing -* the log isn't making the extents available, -* which means they have probably been freed in -* this transaction. In that case, we have to -* give up on them and we'll attempt a minlen -* allocation the next time around. +* retrying. */ xfs_btree_del_cursor (cnt_cur,XFS_BTREE_NOERROR );trace_xfs_alloc_size_busy (args); -if (!forced++) -xfs_log_force (args->mp,XFS_LOG_SYNC ); +xfs_extent_busy_flush (args->mp, + args->pag, busy_gen); goto restart; } }
@@ -1454,8 +1459,8 @@ xfs_alloc_ag_vextent_size(XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);if (flen < bestrlen)break ; -xfs_alloc_compute_aligned (args, fbno, flen, - &rbno, &rlen); + busy =xfs_alloc_compute_aligned (args, fbno, flen, + &rbno, &rlen, &busy_gen); rlen =XFS_EXTLEN_MIN (args->maxlen, rlen); XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 || (rlen <= flen && rbno + rlen <= fbno + flen),
@@ -1484,10 +1489,10 @@ xfs_alloc_ag_vextent_size(*/ args->len = rlen;if (rlen < args->minlen) { -if (!forced++) { +if (busy) {xfs_btree_del_cursor (cnt_cur,XFS_BTREE_NOERROR );trace_xfs_alloc_size_busy (args); -xfs_log_force (args->mp,XFS_LOG_SYNC ); +xfs_extent_busy_flush (args->mp, args->pag, busy_gen); goto restart; } goto out_nominleft;
fs/xfs/xfs_extent_busy.c +77 -30
161 lines not on this page · raw message
fs/xfs/xfs_extent_busy.h +6 -2
@@ -58,9 +58,13 @@ void xfs_extent_busy_reuse(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t fbno, xfs_extlen_t flen, bool userdata); +bool +xfs_extent_busy_trim (struct xfs_alloc_arg *args,xfs_agblock_t *bno, +xfs_extlen_t *len,unsigned *busy_gen); +void -xfs_extent_busy_trim (struct xfs_alloc_arg *args,xfs_agblock_t bno, -xfs_extlen_t len,xfs_agblock_t *rbno,xfs_extlen_t *rlen); +xfs_extent_busy_flush (struct xfs_mount *mp,struct xfs_perag *pag, +unsigned discards);int xfs_extent_busy_ag_cmp (void *priv,struct list_head *a,struct list_head *b);
fs/xfs/xfs_mount.c +1 -0
@@ -215,6 +215,7 @@ xfs_initialize_perag(INIT_RADIX_TREE (&pag->pag_ici_root,GFP_ATOMIC );if (xfs_buf_hash_init (pag)) goto out_unwind; +init_waitqueue_head (&pag->pagb_wait);if (radix_tree_preload (GFP_NOFS )) goto out_unwind;
fs/xfs/xfs_mount.h +2 -0
@@ -384,6 +384,8 @@ typedef struct xfs_perag {xfs_agino_t pagl_rightrec;spinlock_t pagb_lock;/* lock for pagb_tree */ struct rb_root pagb_tree;/* ordered tree of busy extents */ +unsigned int pagb_gen;/* generation count for pagb_tree */ +wait_queue_head_t pagb_wait;/* woken when pagb_gen changes */ atomic_t pagf_fstrms;/* # of filestreams active in this AG */
Signature · 1 line
2.11.0
PATCH 3/5 xfs: improve handling of busy extents in the low-level allocator
In reply to Christoph HellwigCurrently we force the log and simply try again if we hit a busy extent, but especially with online discard enabled it might take a while after the log force for the busy extents to disappear, and we might have already completed our second pass.
So instead we add a new waitqueue and a generation counter to the pag structure so that we can do wakeups once we've removed busy extents, and we replace the single retry with an unconditional one - after all we hold the AGF buffer lock, so no other allocations or frees can be racing with us in this AG.
--- fs/xfs/xfs_extent_busy.c | 32 ++++++++++++++++++++++++++++---- fs/xfs/xfs_extent_busy.h | 5 ++++- fs/xfs/xfs_mount.c | 7 +++++++ 3 files changed, 39 insertions(+), 5 deletions(-)
fs/xfs/xfs_extent_busy.c +28 -4
@@ -335,10 +335,11 @@ xfs_extent_busy_reuse(* args->minlen no suitable extent could be found, and the higher level * code needs to force out the log and retry the allocation. * -* Return the current discard generation for the AG if the file system -* has online discard enabled. This value can be used to wait for -* the trimmed extent to become fully available if the AG is running out -* of space. +* Return the current busy generation for the AG if the extent is busy. This +* value can be used to wait for at least one of the currently busy extents +* to be cleared. Note that the busy list is not guaranteed to be empty after +* the gen is woken. The state of a specific extent must always be confirmed +* with another call to xfs_extent_busy_trim() before it can be used. */ bool xfs_extent_busy_trim(
@@ -510,6 +511,7 @@ xfs_extent_busy_trim( flen = fend - fbno; } out: +if (fbno != *bno || flen != *len) {trace_xfs_extent_busy_trim (args->mp, args->agno, *bno, *len, fbno, flen);
@@ -626,6 +628,28 @@ xfs_extent_busy_flush(finish_wait (&pag->pagb_wait, &wait); } +void +xfs_extent_busy_wait_all ( +struct xfs_mount *mp) +{ +DEFINE_WAIT (wait); +xfs_agnumber_t agno; + +for (agno =0 ; agno < mp->m_sb.sb_agcount; agno++) { +struct xfs_perag *pag =xfs_perag_get (mp, agno); + +do { +prepare_to_wait (&pag->pagb_wait, &wait,TASK_KILLABLE ); +if (RB_EMPTY_ROOT (&pag->pagb_tree)) +break ; +schedule (); + }while (1 ); +finish_wait (&pag->pagb_wait, &wait); + +xfs_perag_put (pag); + } +} +/* * Callback for list_sort to sort busy extents by the AG they reside in. */
fs/xfs/xfs_extent_busy.h +4 -1
@@ -64,7 +64,10 @@ xfs_extent_busy_trim(struct xfs_alloc_arg *args, xfs_agblock_t *bno,void xfs_extent_busy_flush (struct xfs_mount *mp,struct xfs_perag *pag, -unsigned discards); +unsigned busy_gen); + +void +xfs_extent_busy_wait_all (struct xfs_mount *mp);int xfs_extent_busy_ag_cmp (void *priv,struct list_head *a,struct list_head *b);
fs/xfs/xfs_mount.c +7 -0
@@ -45,6 +45,7 @@#include "xfs_rmap_btree.h" #include "xfs_refcount_btree.h" #include "xfs_reflink.h" +#include "xfs_extent_busy.h" static DEFINE_MUTEX (xfs_uuid_table_mutex);
@@ -1074,6 +1075,12 @@ xfs_unmountfs(xfs_log_force (mp,XFS_LOG_SYNC );/* +* Wait for all busy extents to be freed, including completion of +* any discard operation. +*/ +xfs_extent_busy_wait_all (mp); + +/* * We now need to tell the world we are unmounting. This will allow * us to detect that the filesystem is going away and we should error * out anything that we have been retrying in the background. This will
Signature · 1 line
2.11.0
Re: [PATCH 3/5] xfs: improve handling of busy extents in the low-level allocator
Quoted 10 lines · Christoph Hellwig
Currently we force the log and simply try again if we hit a busy extent, but especially with online discard enabled it might take a while after the log force for the busy extents to disappear, and we might have already completed our second pass.
So instead we add a new waitqueue and a generation counter to the pag structure so that we can do wakeups once we've removed busy extents, and we replace the single retry with an unconditional one - after all we hold the AGF buffer lock, so no other allocations or frees can be racing with us in this AG.
Um... is this patch supposed to be merged with the previous one? They have the same subject/commit message.
(Patch itself looks fine, I think.)
--D
Quoted 113 lines
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_extent_busy.c | 32 ++++++++++++++++++++++++++++---- fs/xfs/xfs_extent_busy.h | 5 ++++- fs/xfs/xfs_mount.c | 7 +++++++ 3 files changed, 39 insertions(+), 5 deletions(-)fs/xfs/xfs_extent_busy.c +28
-4@@ -335,10 +335,11 @@ xfs_extent_busy_reuse(* args->minlen no suitable extent could be found, and the higher level * code needs to force out the log and retry the allocation. * -* Return the current discard generation for the AG if the file system -* has online discard enabled. This value can be used to wait for -* the trimmed extent to become fully available if the AG is running out -* of space. +* Return the current busy generation for the AG if the extent is busy. This +* value can be used to wait for at least one of the currently busy extents +* to be cleared. Note that the busy list is not guaranteed to be empty after +* the gen is woken. The state of a specific extent must always be confirmed +* with another call to xfs_extent_busy_trim() before it can be used. */ bool xfs_extent_busy_trim(@@ -510,6 +511,7 @@ xfs_extent_busy_trim( flen = fend - fbno; } out: +if (fbno != *bno || flen != *len) {trace_xfs_extent_busy_trim (args->mp, args->agno, *bno, *len, fbno, flen);@@ -626,6 +628,28 @@ xfs_extent_busy_flush(finish_wait (&pag->pagb_wait, &wait); } +void +xfs_extent_busy_wait_all ( +struct xfs_mount *mp) +{ +DEFINE_WAIT (wait); +xfs_agnumber_t agno; + +for (agno =0 ; agno < mp->m_sb.sb_agcount; agno++) { +struct xfs_perag *pag =xfs_perag_get (mp, agno); + +do { +prepare_to_wait (&pag->pagb_wait, &wait,TASK_KILLABLE ); +if (RB_EMPTY_ROOT (&pag->pagb_tree)) +break ; +schedule (); + }while (1 ); +finish_wait (&pag->pagb_wait, &wait); + +xfs_perag_put (pag); + } +} +/* * Callback for list_sort to sort busy extents by the AG they reside in. */ fs/xfs/xfs_extent_busy.h +4
-1@@ -64,7 +64,10 @@ xfs_extent_busy_trim(struct xfs_alloc_arg *args, xfs_agblock_t *bno,void xfs_extent_busy_flush (struct xfs_mount *mp,struct xfs_perag *pag, -unsigned discards); +unsigned busy_gen); + +void +xfs_extent_busy_wait_all (struct xfs_mount *mp);int xfs_extent_busy_ag_cmp (void *priv,struct list_head *a,struct list_head *b);fs/xfs/xfs_mount.c +7
-0@@ -45,6 +45,7 @@#include "xfs_rmap_btree.h" #include "xfs_refcount_btree.h" #include "xfs_reflink.h" +#include "xfs_extent_busy.h" static DEFINE_MUTEX (xfs_uuid_table_mutex);@@ -1074,6 +1075,12 @@ xfs_unmountfs(xfs_log_force (mp,XFS_LOG_SYNC );/* +* Wait for all busy extents to be freed, including completion of +* any discard operation. +*/ +xfs_extent_busy_wait_all (mp); + +/* * We now need to tell the world we are unmounting. This will allow * us to detect that the filesystem is going away and we should error * out anything that we have been retrying in the background. This will Signature · 6 lines
2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-xfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 3/5] xfs: improve handling of busy extents in the low-level allocator
Quoted 8 lines · Darrick J. Wong
Quoted 5 lines
So instead we add a new waitqueue and a generation counter to the pag structure so that we can do wakeups once we've removed busy extents, and we replace the single retry with an unconditional one - after all we hold the AGF buffer lock, so no other allocations or frees can be racing with us in this AG.
Um... is this patch supposed to be merged with the previous one? They have the same subject/commit message.
It is - but git rebase keeps duplicating patches when you try to fold a patch into the previous one and there is any kind of conflict. In that case it needs another pass to really fold it which I missed for this series.
PATCH 4/5 xfs: improve busy extent sorting
In reply to Christoph HellwigSort busy extents by the full block number instead of just the AGNO so that we can issue consecutive discard requests that the block layer could merge (although we'll need additional block layer fixes for fast devices).
--- fs/xfs/xfs_extent_busy.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
fs/xfs/xfs_extent_busy.c +12 -4
@@ -656,9 +656,17 @@ xfs_extent_busy_wait_all(int xfs_extent_busy_ag_cmp (void *priv, -struct list_head *a, -struct list_head *b) +struct list_head *l1, +struct list_head *l2) { - return container_of(a, struct xfs_extent_busy, list)->agno - - container_of(b, struct xfs_extent_busy, list)->agno; +struct xfs_extent_busy *b1 = + container_of(l1, struct xfs_extent_busy, list); +struct xfs_extent_busy *b2 = + container_of(l2, struct xfs_extent_busy, list); +s32 diff; + + diff = b1->agno - b2->agno; +if (!diff) + diff = b1->bno - b2->bno; +return diff; }
Signature · 1 line
2.11.0
Re: [PATCH 4/5] xfs: improve busy extent sorting
Quoted 5 lines · Christoph Hellwig
Sort busy extents by the full block number instead of just the AGNO so that we can issue consecutive discard requests that the block layer could merge (although we'll need additional block layer fixes for fast devices).
Signed-off-by Christoph Hellwig <[email protected]>
Looks ok,
--D
Quoted 37 lines
--- fs/xfs/xfs_extent_busy.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)fs/xfs/xfs_extent_busy.c +12
-4@@ -656,9 +656,17 @@ xfs_extent_busy_wait_all(int xfs_extent_busy_ag_cmp (void *priv, -struct list_head *a, -struct list_head *b) +struct list_head *l1, +struct list_head *l2) { - return container_of(a, struct xfs_extent_busy, list)->agno - - container_of(b, struct xfs_extent_busy, list)->agno; +struct xfs_extent_busy *b1 = + container_of(l1, struct xfs_extent_busy, list); +struct xfs_extent_busy *b2 = + container_of(l2, struct xfs_extent_busy, list); +s32 diff; + + diff = b1->agno - b2->agno; +if (!diff) + diff = b1->bno - b2->bno; +return diff; }Signature · 6 lines
2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-xfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 5/5 xfs: don't block the log commit handler for discards
In reply to Christoph HellwigInstead we submit the discard requests and use another workqueue to release the extents from the extent busy list.
--- fs/xfs/xfs_discard.c | 29 ------------------ fs/xfs/xfs_discard.h | 1 - fs/xfs/xfs_log_cil.c | 84 ++++++++++++++++++++++++++++++++++++++++++++++----- fs/xfs/xfs_log_priv.h | 1 + fs/xfs/xfs_mount.c | 1 + fs/xfs/xfs_super.c | 8 +++++ fs/xfs/xfs_super.h | 2 ++ 7 files changed, 88 insertions(+), 38 deletions(-)
fs/xfs/xfs_discard.c +0 -29
@@ -208,32 +208,3 @@ xfs_ioc_trim(return -EFAULT ;return 0 ; } - -int -xfs_discard_extents ( -struct xfs_mount *mp, -struct list_head *list) -{ -struct xfs_extent_busy *busyp; -int error =0 ; - -list_for_each_entry (busyp, list, list) { -trace_xfs_discard_extent (mp, busyp->agno, busyp->bno, - busyp->length); - - error =blkdev_issue_discard (mp->m_ddev_targp->bt_bdev, -XFS_AGB_TO_DADDR (mp, busyp->agno, busyp->bno), -XFS_FSB_TO_BB (mp, busyp->length), -GFP_NOFS ,0 ); -if (error && error != -EOPNOTSUPP ) { -xfs_info (mp, -"discard failed for extent [0x%llx,%u], error %d" , - (unsigned long long )busyp->bno, - busyp->length, - error); -return error; - } - } - -return 0 ; -}
fs/xfs/xfs_discard.h +0 -1
@@ -5,6 +5,5 @@ struct fstrim_range;struct list_head ;extern int xfs_ioc_trim (struct xfs_mount *,struct fstrim_range __user *); -extern int xfs_discard_extents (struct xfs_mount *,struct list_head *);#endif /* XFS_DISCARD_H */
fs/xfs/xfs_log_cil.c +76 -8
102 lines not on this page · raw message
fs/xfs/xfs_log_priv.h +1 -0
@@ -257,6 +257,7 @@ struct xfs_cil_ctx {struct xfs_log_vec *lv_chain;/* logvecs being pushed */ struct xfs_log_callback log_cb;/* completion callback hook. */ struct list_head committing;/* ctx committing list */ +struct work_struct discard_endio_work; };/*
fs/xfs/xfs_mount.c +1 -0
@@ -1079,6 +1079,7 @@ xfs_unmountfs(* any discard operation. */ xfs_extent_busy_wait_all (mp); +flush_workqueue (xfs_discard_wq);/* * We now need to tell the world we are unmounting. This will allow
fs/xfs/xfs_super.c +8 -0
@@ -1957,12 +1957,20 @@ xfs_init_workqueues(void)if (!xfs_alloc_wq)return -ENOMEM ; + xfs_discard_wq =alloc_workqueue ("xfsdiscard" ,WQ_UNBOUND ,0 ); +if (!xfs_discard_wq) + goto out_free_alloc_wq; +return 0 ; +out_free_alloc_wq: +destroy_workqueue (xfs_alloc_wq); +return -ENOMEM ; } STATIC voidxfs_destroy_workqueues (void ) { +destroy_workqueue (xfs_discard_wq);destroy_workqueue (xfs_alloc_wq); }
fs/xfs/xfs_super.h +2 -0
@@ -73,6 +73,8 @@ extern const struct quotactl_ops xfs_quotactl_operations;extern void xfs_reinit_percpu_counters (struct xfs_mount *mp); +extern struct workqueue_struct *xfs_discard_wq; +#define XFS_M (sb) ((struct xfs_mount *)((sb)->s_fs_info))#endif /* __XFS_SUPER_H__ */
Signature · 1 line
2.11.0