xfs: fold xfs_alloc_ag_vextent() into callers

We don't need the multiplexing xfs_alloc_ag_vextent() provided
anymore - we can just call the exact/near/size variants directly.
This allows us to remove args->type completely and stop using
args->fsbno as an input to the allocator algorithms.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index afc6bd4..50eb448 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -36,10 +36,6 @@ struct workqueue_struct *xfs_alloc_wq;
 #define        XFSA_FIXUP_BNO_OK       1
 #define        XFSA_FIXUP_CNT_OK       2
 
-STATIC int xfs_alloc_ag_vextent_exact(xfs_alloc_arg_t *);
-STATIC int xfs_alloc_ag_vextent_near(xfs_alloc_arg_t *);
-STATIC int xfs_alloc_ag_vextent_size(xfs_alloc_arg_t *);
-
 /*
  * Size of the AGFL.  For CRC-enabled filesystes we steal a couple of slots in
  * the beginning of the block for a proper header with the location information
@@ -772,8 +768,6 @@ xfs_alloc_cur_setup(
        int                     error;
        int                     i;
 
-       ASSERT(args->alignment == 1 || args->type != XFS_ALLOCTYPE_THIS_BNO);
-
        acur->cur_len = args->maxlen;
        acur->rec_bno = 0;
        acur->rec_len = 0;
@@ -887,7 +881,6 @@ xfs_alloc_cur_check(
         * We have an aligned record that satisfies minlen and beats or matches
         * the candidate extent size. Compare locality for near allocation mode.
         */
-       ASSERT(args->type == XFS_ALLOCTYPE_NEAR_BNO);
        diff = xfs_alloc_compute_diff(args->agbno, args->len,
                                      args->alignment, args->datatype,
                                      bnoa, lena, &bnew);
@@ -1133,40 +1126,6 @@ error:
 }
 
 /*
- * Allocate a variable extent in the allocation group agno.
- * Type and bno are used to determine where in the allocation group the
- * extent will start.
- * Extent's length (returned in *len) will be between minlen and maxlen,
- * and of the form k * prod + mod unless there's nothing that large.
- * Return the starting a.g. block, or NULLAGBLOCK if we can't do it.
- */
-static int
-xfs_alloc_ag_vextent(
-       struct xfs_alloc_arg    *args)
-{
-       int                     error = 0;
-
-       /*
-        * Branch to correct routine based on the type.
-        */
-       switch (args->type) {
-       case XFS_ALLOCTYPE_THIS_AG:
-               error = xfs_alloc_ag_vextent_size(args);
-               break;
-       case XFS_ALLOCTYPE_NEAR_BNO:
-               error = xfs_alloc_ag_vextent_near(args);
-               break;
-       case XFS_ALLOCTYPE_THIS_BNO:
-               error = xfs_alloc_ag_vextent_exact(args);
-               break;
-       default:
-               ASSERT(0);
-               /* NOTREACHED */
-       }
-       return error;
-}
-
-/*
  * Allocate a variable extent at exactly agno/bno.
  * Extent's length (returned in *len) will be between minlen and maxlen,
  * and of the form k * prod + mod unless there's nothing that large.
@@ -1351,7 +1310,6 @@ xfs_alloc_ag_vextent_locality(
        bool                    fbinc;
 
        ASSERT(acur->len == 0);
-       ASSERT(args->type == XFS_ALLOCTYPE_NEAR_BNO);
 
        *stat = 0;
 
@@ -3137,6 +3095,7 @@ xfs_alloc_vextent_check_args(
        xfs_agblock_t           agsize;
 
        args->agbno = NULLAGBLOCK;
+       args->fsbno = NULLFSBLOCK;
 
        /*
         * Just fix this up, for the case where the last a.g. is shorter
@@ -3295,8 +3254,11 @@ out_drop_perag:
 }
 
 /*
- * Allocate within a single AG only. Caller is expected to hold a
- * perag reference in args->pag.
+ * Allocate within a single AG only. This uses a best-fit length algorithm so if
+ * you need an exact sized allocation without locality constraints, this is the
+ * fastest way to do it.
+ *
+ * Caller is expected to hold a perag reference in args->pag.
  */
 int
 xfs_alloc_vextent_this_ag(
@@ -3305,7 +3267,6 @@ xfs_alloc_vextent_this_ag(
 {
        struct xfs_mount        *mp = args->mp;
        xfs_agnumber_t          minimum_agno = 0;
-       xfs_rfsblock_t          target = XFS_AGB_TO_FSB(mp, agno, 0);
        int                     error;
 
        if (args->tp->t_highest_agno != NULLAGNUMBER)
@@ -3317,7 +3278,7 @@ xfs_alloc_vextent_this_ag(
                return 0;
        }
 
-       error = xfs_alloc_vextent_check_args(args, target);
+       error = xfs_alloc_vextent_check_args(args, XFS_AGB_TO_FSB(mp, agno, 0));
        if (error) {
                if (error == -ENOSPC)
                        return 0;
@@ -3326,12 +3287,10 @@ xfs_alloc_vextent_this_ag(
 
        args->agno = agno;
        args->agbno = 0;
-       args->fsbno = target;
-       args->type = XFS_ALLOCTYPE_THIS_AG;
 
        error = xfs_alloc_vextent_prepare_ag(args);
        if (!error && args->agbp)
-               error = xfs_alloc_ag_vextent(args);
+               error = xfs_alloc_ag_vextent_size(args);
 
        return xfs_alloc_vextent_finish(args, minimum_agno, error, false);
 }
@@ -3355,6 +3314,7 @@ xfs_alloc_vextent_iterate_ags(
        struct xfs_alloc_arg    *args,
        xfs_agnumber_t          minimum_agno,
        xfs_agnumber_t          start_agno,
+       xfs_agblock_t           target_agbno,
        uint32_t                flags)
 {
        struct xfs_mount        *mp = args->mp;
@@ -3369,7 +3329,6 @@ xfs_alloc_vextent_iterate_ags(
        args->agno = start_agno;
        for (;;) {
                args->pag = xfs_perag_get(mp, args->agno);
-               args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);
                error = xfs_alloc_vextent_prepare_ag(args);
                if (error)
                        break;
@@ -3379,16 +3338,18 @@ xfs_alloc_vextent_iterate_ags(
                         * Allocation is supposed to succeed now, so break out
                         * of the loop regardless of whether we succeed or not.
                         */
-                       error = xfs_alloc_ag_vextent(args);
+                       if (args->agno == start_agno && target_agbno) {
+                               args->agbno = target_agbno;
+                               error = xfs_alloc_ag_vextent_near(args);
+                       } else {
+                               args->agbno = 0;
+                               error = xfs_alloc_ag_vextent_size(args);
+                       }
                        break;
                }
 
                trace_xfs_alloc_vextent_loopfailed(args);
 
-               if (args->agno == start_agno &&
-                   args->otype == XFS_ALLOCTYPE_NEAR_BNO)
-                       args->type = XFS_ALLOCTYPE_THIS_AG;
-
                /*
                 * If we are try-locking, we can't deadlock on AGF locks so we
                 * can wrap all the way back to the first AG. Otherwise, wrap
@@ -3412,10 +3373,8 @@ xfs_alloc_vextent_iterate_ags(
                                trace_xfs_alloc_vextent_allfailed(args);
                                break;
                        }
-
+                       args->agbno = target_agbno;
                        flags = 0;
-                       if (args->otype == XFS_ALLOCTYPE_NEAR_BNO)
-                               args->type = XFS_ALLOCTYPE_NEAR_BNO;
                }
                xfs_perag_put(args->pag);
                args->pag = NULL;
@@ -3464,13 +3423,11 @@ xfs_alloc_vextent_start_ag(
                                mp->m_sb.sb_agcount), 0);
                bump_rotor = 1;
        }
-       start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target));
-       args->agbno = XFS_FSB_TO_AGBNO(mp, target);
-       args->type = XFS_ALLOCTYPE_NEAR_BNO;
-       args->fsbno = target;
 
+       start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target));
        error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno,
-                       XFS_ALLOC_FLAG_TRYLOCK);
+                       XFS_FSB_TO_AGBNO(mp, target), XFS_ALLOC_FLAG_TRYLOCK);
+
        if (bump_rotor) {
                if (args->agno == start_agno)
                        mp->m_agfrotor = (mp->m_agfrotor + 1) %
@@ -3484,9 +3441,9 @@ xfs_alloc_vextent_start_ag(
 }
 
 /*
- * Iterate from the agno indicated from args->fsbno through to the end of the
+ * Iterate from the agno indicated via @target through to the end of the
  * filesystem attempting blocking allocation. This does not wrap or try a second
- * pass, so will not recurse into AGs lower than indicated by fsbno.
+ * pass, so will not recurse into AGs lower than indicated by the target.
  */
 int
 xfs_alloc_vextent_first_ag(
@@ -3509,10 +3466,8 @@ xfs_alloc_vextent_first_ag(
        }
 
        start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target));
-       args->type = XFS_ALLOCTYPE_THIS_AG;
-       args->fsbno = target;
-       error = xfs_alloc_vextent_iterate_ags(args, minimum_agno,
-                       start_agno, 0);
+       error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno,
+                       XFS_FSB_TO_AGBNO(mp, target), 0);
        return xfs_alloc_vextent_finish(args, minimum_agno, error, true);
 }
 
@@ -3547,12 +3502,10 @@ xfs_alloc_vextent_exact_bno(
        }
 
        args->agbno = XFS_FSB_TO_AGBNO(mp, target);
-       args->fsbno = target;
-       args->type = XFS_ALLOCTYPE_THIS_BNO;
 
        error = xfs_alloc_vextent_prepare_ag(args);
        if (!error && args->agbp)
-               error = xfs_alloc_ag_vextent(args);
+               error = xfs_alloc_ag_vextent_exact(args);
 
        return xfs_alloc_vextent_finish(args, minimum_agno, error, false);
 }
@@ -3594,11 +3547,10 @@ xfs_alloc_vextent_near_bno(
                args->pag = xfs_perag_get(mp, args->agno);
 
        args->agbno = XFS_FSB_TO_AGBNO(mp, target);
-       args->type = XFS_ALLOCTYPE_NEAR_BNO;
 
        error = xfs_alloc_vextent_prepare_ag(args);
        if (!error && args->agbp)
-               error = xfs_alloc_ag_vextent(args);
+               error = xfs_alloc_ag_vextent_near(args);
 
        return xfs_alloc_vextent_finish(args, minimum_agno, error, needs_perag);
 }

diff --git a/fs/xfs/libxfs/xfs_alloc.h b/fs/xfs/libxfs/xfs_alloc.h
index 63d5ad4..2b246d7 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.h
+++ b/fs/xfs/libxfs/xfs_alloc.h
@@ -17,21 +17,6 @@ extern struct workqueue_struct *xfs_alloc_wq;
 unsigned int xfs_agfl_size(struct xfs_mount *mp);
 
 /*
- * Freespace allocation types.  Argument to xfs_alloc_[v]extent.
- */
-#define XFS_ALLOCTYPE_THIS_AG  0x08    /* anywhere in this a.g. */
-#define XFS_ALLOCTYPE_NEAR_BNO 0x20    /* in this a.g. and near this block */
-#define XFS_ALLOCTYPE_THIS_BNO 0x40    /* at exactly this block */
-
-/* this should become an enum again when the tracing code is fixed */
-typedef unsigned int xfs_alloctype_t;
-
-#define XFS_ALLOC_TYPES \
-       { XFS_ALLOCTYPE_THIS_AG,        "THIS_AG" }, \
-       { XFS_ALLOCTYPE_NEAR_BNO,       "NEAR_BNO" }, \
-       { XFS_ALLOCTYPE_THIS_BNO,       "THIS_BNO" }
-
-/*
  * Flags for xfs_alloc_fix_freelist.
  */
 #define        XFS_ALLOC_FLAG_TRYLOCK  0x00000001  /* use trylock for buffer locking */
@@ -64,8 +49,6 @@ typedef struct xfs_alloc_arg {
        xfs_agblock_t   min_agbno;      /* set an agbno range for NEAR allocs */
        xfs_agblock_t   max_agbno;      /* ... */
        xfs_extlen_t    len;            /* output: actual size of extent */
-       xfs_alloctype_t type;           /* allocation type XFS_ALLOCTYPE_... */
-       xfs_alloctype_t otype;          /* original allocation type */
        int             datatype;       /* mask defining data type treatment */
        char            wasdel;         /* set if allocation was prev delayed */
        char            wasfromfl;      /* set if allocation is from freelist */

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index c507645..ee402ac 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -3501,7 +3501,6 @@ xfs_bmap_btalloc_at_eof(
        bool                    ag_only)
 {
        struct xfs_mount        *mp = args->mp;
-       xfs_alloctype_t         atype;
        int                     error;
 
        /*
@@ -3513,14 +3512,12 @@ xfs_bmap_btalloc_at_eof(
        if (ap->offset) {
                xfs_extlen_t    nextminlen = 0;
 
-               atype = args->type;
-               args->alignment = 1;
-
                /*
                 * Compute the minlen+alignment for the next case.  Set slop so
                 * that the value of minlen+alignment+slop doesn't go up between
                 * the calls.
                 */
+               args->alignment = 1;
                if (blen > stripe_align && blen <= args->maxlen)
                        nextminlen = blen - stripe_align;
                else
@@ -3544,17 +3541,15 @@ xfs_bmap_btalloc_at_eof(
                 * according to the original allocation specification.
                 */
                args->pag = NULL;
-               args->type = atype;
                args->alignment = stripe_align;
                args->minlen = nextminlen;
                args->minalignslop = 0;
        } else {
-               args->alignment = stripe_align;
-               atype = args->type;
                /*
                 * Adjust minlen to try and preserve alignment if we
                 * can't guarantee an aligned maxlen extent.
                 */
+               args->alignment = stripe_align;
                if (blen > args->alignment &&
                    blen <= args->maxlen + args->alignment)
                        args->minlen = blen - args->alignment;
@@ -3576,7 +3571,6 @@ xfs_bmap_btalloc_at_eof(
         * original non-aligned state so the caller can proceed on allocation
         * failure as if this function was never called.
         */
-       args->type = atype;
        args->fsbno = ap->blkno;
        args->alignment = 1;
        return 0;

diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 1d99c30..bb7ccb5 100644 (file)
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -1799,8 +1799,6 @@ DECLARE_EVENT_CLASS(xfs_alloc_class,
                __field(xfs_extlen_t, alignment)
                __field(xfs_extlen_t, minalignslop)
                __field(xfs_extlen_t, len)
-               __field(short, type)
-               __field(short, otype)
                __field(char, wasdel)
                __field(char, wasfromfl)
                __field(int, resv)
@@ -1820,8 +1818,6 @@ DECLARE_EVENT_CLASS(xfs_alloc_class,
                __entry->alignment = args->alignment;
                __entry->minalignslop = args->minalignslop;
                __entry->len = args->len;
-               __entry->type = args->type;
-               __entry->otype = args->otype;
                __entry->wasdel = args->wasdel;
                __entry->wasfromfl = args->wasfromfl;
                __entry->resv = args->resv;
@@ -1830,7 +1826,7 @@ DECLARE_EVENT_CLASS(xfs_alloc_class,
        ),
        TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u "
                  "prod %u minleft %u total %u alignment %u minalignslop %u "
-                 "len %u type %s otype %s wasdel %d wasfromfl %d resv %d "
+                 "len %u wasdel %d wasfromfl %d resv %d "
                  "datatype 0x%x highest_agno 0x%x",
                  MAJOR(__entry->dev), MINOR(__entry->dev),
                  __entry->agno,
@@ -1844,8 +1840,6 @@ DECLARE_EVENT_CLASS(xfs_alloc_class,
                  __entry->alignment,
                  __entry->minalignslop,
                  __entry->len,
-                 __print_symbolic(__entry->type, XFS_ALLOC_TYPES),
-                 __print_symbolic(__entry->otype, XFS_ALLOC_TYPES),
                  __entry->wasdel,
                  __entry->wasfromfl,
                  __entry->resv,