improve busy extent handling and add async discard support V2
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 V1:
- address various feedback from Brian
PATCH 1/4 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/4 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/4 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
@@ -632,9 +632,17 @@ xfs_extent_busy_flush(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
PATCH 4/4 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
@@ -1072,6 +1072,7 @@ xfs_unmountfs(* need to force the log first. */ xfs_log_force (mp,XFS_LOG_SYNC ); +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