]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/commitdiff
xfs: remove xfs_btnum_t
authorChristoph Hellwig <hch@lst.de>
Mon, 22 Apr 2024 17:01:06 +0000 (10:01 -0700)
committerDarrick J. Wong <djwong@kernel.org>
Mon, 3 Jun 2024 18:37:39 +0000 (11:37 -0700)
Source kernel commit: ec793e690f801d97a7ae2a0d429fea1fee4d44aa

The last checks for bc_btnum can be replaced with helpers that check
the btree ops.  This allows adding new btrees to XFS without having
to update a global enum.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
[djwong: complete the ops predicates]
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
13 files changed:
libxfs/xfs_alloc.c
libxfs/xfs_alloc_btree.c
libxfs/xfs_bmap_btree.c
libxfs/xfs_btree.c
libxfs/xfs_btree.h
libxfs/xfs_ialloc.c
libxfs/xfs_ialloc_btree.c
libxfs/xfs_refcount_btree.c
libxfs/xfs_rmap_btree.c
libxfs/xfs_shared.h
libxfs/xfs_types.h
repair/agbtree.c
repair/phase5.c

index 599271e5c22e93b9c4e83749df6d80147712da00..0eefb16cc47eb96152b9d310abb3dd95661cde74 100644 (file)
@@ -914,7 +914,7 @@ xfs_alloc_cur_check(
        bool                    busy;
        unsigned                busy_gen = 0;
        bool                    deactivate = false;
-       bool                    isbnobt = cur->bc_btnum == XFS_BTNUM_BNO;
+       bool                    isbnobt = xfs_btree_is_bno(cur->bc_ops);
 
        *new = 0;
 
@@ -4022,7 +4022,7 @@ xfs_alloc_query_range(
        union xfs_btree_irec                    high_brec = { .a = *high_rec };
        struct xfs_alloc_query_range_info       query = { .priv = priv, .fn = fn };
 
-       ASSERT(cur->bc_btnum == XFS_BTNUM_BNO);
+       ASSERT(xfs_btree_is_bno(cur->bc_ops));
        return xfs_btree_query_range(cur, &low_brec, &high_brec,
                        xfs_alloc_query_range_helper, &query);
 }
@@ -4036,7 +4036,7 @@ xfs_alloc_query_all(
 {
        struct xfs_alloc_query_range_info       query;
 
-       ASSERT(cur->bc_btnum == XFS_BTNUM_BNO);
+       ASSERT(xfs_btree_is_bno(cur->bc_ops));
        query.priv = priv;
        query.fn = fn;
        return xfs_btree_query_all(cur, xfs_alloc_query_range_helper, &query);
index b219dc6ac136cf3551c053440a2b380224623db8..35d3dde426b1ae2bd2f8bc225555d7c77bc7c1bc 100644 (file)
@@ -49,7 +49,7 @@ xfs_allocbt_set_root(
 
        ASSERT(ptr->s != 0);
 
-       if (cur->bc_btnum == XFS_BTNUM_BNO) {
+       if (xfs_btree_is_bno(cur->bc_ops)) {
                agf->agf_bno_root = ptr->s;
                be32_add_cpu(&agf->agf_bno_level, inc);
                cur->bc_ag.pag->pagf_bno_level += inc;
@@ -129,7 +129,7 @@ xfs_allocbt_update_lastrec(
        __be32                  len;
        int                     numrecs;
 
-       ASSERT(cur->bc_btnum == XFS_BTNUM_CNT);
+       ASSERT(!xfs_btree_is_bno(cur->bc_ops));
 
        switch (reason) {
        case LASTREC_UPDATE:
@@ -239,7 +239,7 @@ xfs_allocbt_init_ptr_from_cur(
 
        ASSERT(cur->bc_ag.pag->pag_agno == be32_to_cpu(agf->agf_seqno));
 
-       if (cur->bc_btnum == XFS_BTNUM_BNO)
+       if (xfs_btree_is_bno(cur->bc_ops))
                ptr->s = agf->agf_bno_root;
        else
                ptr->s = agf->agf_cnt_root;
@@ -552,7 +552,7 @@ xfs_bnobt_init_cursor(
 {
        struct xfs_btree_cur    *cur;
 
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_BNO, &xfs_bnobt_ops,
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_bnobt_ops,
                        mp->m_alloc_maxlevels, xfs_allocbt_cur_cache);
        cur->bc_ag.pag = xfs_perag_hold(pag);
        cur->bc_ag.agbp = agbp;
@@ -578,7 +578,7 @@ xfs_cntbt_init_cursor(
 {
        struct xfs_btree_cur    *cur;
 
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_CNT, &xfs_cntbt_ops,
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_cntbt_ops,
                        mp->m_alloc_maxlevels, xfs_allocbt_cur_cache);
        cur->bc_ag.pag = xfs_perag_hold(pag);
        cur->bc_ag.agbp = agbp;
@@ -605,7 +605,7 @@ xfs_allocbt_commit_staged_btree(
 
        ASSERT(cur->bc_flags & XFS_BTREE_STAGING);
 
-       if (cur->bc_btnum == XFS_BTNUM_BNO) {
+       if (xfs_btree_is_bno(cur->bc_ops)) {
                agf->agf_bno_root = cpu_to_be32(afake->af_root);
                agf->agf_bno_level = cpu_to_be32(afake->af_levels);
        } else {
index 12b94c74ecb10120e85b4b2b1438c35f3a237882..eede6ffd62ea9917fd67a7422d27962b11a45ea7 100644 (file)
@@ -573,8 +573,8 @@ xfs_bmbt_init_cursor(
                maxlevels = mp->m_bm_maxlevels[whichfork];
                break;
        }
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_BMAP, &xfs_bmbt_ops,
-                       maxlevels, xfs_bmbt_cur_cache);
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_bmbt_ops, maxlevels,
+                       xfs_bmbt_cur_cache);
        cur->bc_ino.ip = ip;
        cur->bc_ino.whichfork = whichfork;
        cur->bc_bmap.allocated = 0;
index 95f77fbe7111ef134df3e46224caf61e442c530d..0b6d8d6f1de37f7c06a09768e4100b612b32e4e7 100644 (file)
@@ -451,7 +451,7 @@ xfs_btree_del_cursor(
         * zero, then we should be shut down or on our way to shutdown due to
         * cancelling a dirty transaction on error.
         */
-       ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP || cur->bc_bmap.allocated == 0 ||
+       ASSERT(!xfs_btree_is_bmap(cur->bc_ops) || cur->bc_bmap.allocated == 0 ||
               xfs_is_shutdown(cur->bc_mp) || error != 0);
 
        switch (cur->bc_ops->type) {
@@ -3013,7 +3013,7 @@ xfs_btree_split(
        struct xfs_btree_split_args     args;
        DECLARE_COMPLETION_ONSTACK(done);
 
-       if (cur->bc_btnum != XFS_BTNUM_BMAP ||
+       if (!xfs_btree_is_bmap(cur->bc_ops) ||
            cur->bc_tp->t_highest_agno == NULLAGNUMBER)
                return __xfs_btree_split(cur, level, ptrp, key, curp, stat);
 
index 6e5fd0c06453d3da34033b8b92343145d686770a..9a264ffee30363b619fe7319fcafabdbe64f4bf4 100644 (file)
@@ -55,14 +55,6 @@ union xfs_btree_rec {
 #define        XFS_LOOKUP_LE   ((xfs_lookup_t)XFS_LOOKUP_LEi)
 #define        XFS_LOOKUP_GE   ((xfs_lookup_t)XFS_LOOKUP_GEi)
 
-#define        XFS_BTNUM_BNO   ((xfs_btnum_t)XFS_BTNUM_BNOi)
-#define        XFS_BTNUM_CNT   ((xfs_btnum_t)XFS_BTNUM_CNTi)
-#define        XFS_BTNUM_BMAP  ((xfs_btnum_t)XFS_BTNUM_BMAPi)
-#define        XFS_BTNUM_INO   ((xfs_btnum_t)XFS_BTNUM_INOi)
-#define        XFS_BTNUM_FINO  ((xfs_btnum_t)XFS_BTNUM_FINOi)
-#define        XFS_BTNUM_RMAP  ((xfs_btnum_t)XFS_BTNUM_RMAPi)
-#define        XFS_BTNUM_REFC  ((xfs_btnum_t)XFS_BTNUM_REFCi)
-
 struct xfs_btree_ops;
 uint32_t xfs_btree_magic(struct xfs_mount *mp, const struct xfs_btree_ops *ops);
 
@@ -272,7 +264,6 @@ struct xfs_btree_cur
        const struct xfs_btree_ops *bc_ops;
        struct kmem_cache       *bc_cache; /* cursor cache */
        unsigned int            bc_flags; /* btree features - below */
-       xfs_btnum_t             bc_btnum; /* identifies which btree type */
        union xfs_btree_irec    bc_rec; /* current insert/search record value */
        uint8_t                 bc_nlevels; /* number of levels in the tree */
        uint8_t                 bc_maxlevels; /* maximum levels for this btree type */
@@ -726,7 +717,6 @@ static inline struct xfs_btree_cur *
 xfs_btree_alloc_cursor(
        struct xfs_mount        *mp,
        struct xfs_trans        *tp,
-       xfs_btnum_t             btnum,
        const struct xfs_btree_ops *ops,
        uint8_t                 maxlevels,
        struct kmem_cache       *cache)
@@ -742,7 +732,6 @@ xfs_btree_alloc_cursor(
        cur->bc_ops = ops;
        cur->bc_tp = tp;
        cur->bc_mp = mp;
-       cur->bc_btnum = btnum;
        cur->bc_maxlevels = maxlevels;
        cur->bc_cache = cache;
 
index 296548bc1d4598751d32dc1a5f64d99796b40b9a..c30e76830bb1b7f581033ce5b3cd4e6467b5826b 100644 (file)
@@ -2843,7 +2843,7 @@ xfs_ialloc_count_inodes(
        struct xfs_ialloc_count_inodes  ci = {0};
        int                             error;
 
-       ASSERT(cur->bc_btnum == XFS_BTNUM_INO);
+       ASSERT(xfs_btree_is_ino(cur->bc_ops));
        error = xfs_btree_query_all(cur, xfs_ialloc_count_inodes_rec, &ci);
        if (error)
                return error;
index 2f095862e153d7bd2b5abfb6da7044dc17caac18..cb0a7c7792a1cba146c79c9f8ea54f158bb7955d 100644 (file)
@@ -89,9 +89,9 @@ xfs_inobt_mod_blockcount(
        if (!xfs_has_inobtcounts(cur->bc_mp))
                return;
 
-       if (cur->bc_btnum == XFS_BTNUM_FINO)
+       if (xfs_btree_is_fino(cur->bc_ops))
                be32_add_cpu(&agi->agi_fblocks, howmuch);
-       else if (cur->bc_btnum == XFS_BTNUM_INO)
+       else
                be32_add_cpu(&agi->agi_iblocks, howmuch);
        xfs_ialloc_log_agi(cur->bc_tp, agbp, XFS_AGI_IBLOCKS);
 }
@@ -480,7 +480,7 @@ xfs_inobt_init_cursor(
        struct xfs_mount        *mp = pag->pag_mount;
        struct xfs_btree_cur    *cur;
 
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_INO, &xfs_inobt_ops,
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_inobt_ops,
                        M_IGEO(mp)->inobt_maxlevels, xfs_inobt_cur_cache);
        cur->bc_ag.pag = xfs_perag_hold(pag);
        cur->bc_ag.agbp = agbp;
@@ -506,7 +506,7 @@ xfs_finobt_init_cursor(
        struct xfs_mount        *mp = pag->pag_mount;
        struct xfs_btree_cur    *cur;
 
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_FINO, &xfs_finobt_ops,
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_finobt_ops,
                        M_IGEO(mp)->inobt_maxlevels, xfs_inobt_cur_cache);
        cur->bc_ag.pag = xfs_perag_hold(pag);
        cur->bc_ag.agbp = agbp;
@@ -534,7 +534,7 @@ xfs_inobt_commit_staged_btree(
 
        ASSERT(cur->bc_flags & XFS_BTREE_STAGING);
 
-       if (cur->bc_btnum == XFS_BTNUM_INO) {
+       if (xfs_btree_is_ino(cur->bc_ops)) {
                fields = XFS_AGI_ROOT | XFS_AGI_LEVEL;
                agi->agi_root = cpu_to_be32(afake->af_root);
                agi->agi_level = cpu_to_be32(afake->af_levels);
index 31ef879badb84ab7f38153e7b1562f9f9cb356f0..6ec0e36e58198b24bb5e5025b0bff1cb32235712 100644 (file)
@@ -363,9 +363,8 @@ xfs_refcountbt_init_cursor(
 
        ASSERT(pag->pag_agno < mp->m_sb.sb_agcount);
 
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_REFC,
-                       &xfs_refcountbt_ops, mp->m_refc_maxlevels,
-                       xfs_refcountbt_cur_cache);
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_refcountbt_ops,
+                       mp->m_refc_maxlevels, xfs_refcountbt_cur_cache);
        cur->bc_ag.pag = xfs_perag_hold(pag);
        cur->bc_refc.nr_ops = 0;
        cur->bc_refc.shape_changes = 0;
index c7ca2004354b14cc10a004f3b8650aa05c147a3e..18168db6ed0ee9174475b472b086a6cf68f197a8 100644 (file)
@@ -516,7 +516,7 @@ xfs_rmapbt_init_cursor(
 {
        struct xfs_btree_cur    *cur;
 
-       cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_RMAP, &xfs_rmapbt_ops,
+       cur = xfs_btree_alloc_cursor(mp, tp, &xfs_rmapbt_ops,
                        mp->m_rmap_maxlevels, xfs_rmapbt_cur_cache);
        cur->bc_ag.pag = xfs_perag_hold(pag);
        cur->bc_ag.agbp = agbp;
index 518ea9456ebae6160df5e97288239f9b42e18998..6b8bc276d46167a076463b279a32b626022e51f1 100644 (file)
@@ -52,6 +52,41 @@ extern const struct xfs_btree_ops xfs_bmbt_ops;
 extern const struct xfs_btree_ops xfs_refcountbt_ops;
 extern const struct xfs_btree_ops xfs_rmapbt_ops;
 
+static inline bool xfs_btree_is_bno(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_bnobt_ops;
+}
+
+static inline bool xfs_btree_is_cnt(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_cntbt_ops;
+}
+
+static inline bool xfs_btree_is_bmap(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_bmbt_ops;
+}
+
+static inline bool xfs_btree_is_ino(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_inobt_ops;
+}
+
+static inline bool xfs_btree_is_fino(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_finobt_ops;
+}
+
+static inline bool xfs_btree_is_refcount(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_refcountbt_ops;
+}
+
+static inline bool xfs_btree_is_rmap(const struct xfs_btree_ops *ops)
+{
+       return ops == &xfs_rmapbt_ops;
+}
+
 /* log size calculation functions */
 int    xfs_log_calc_unit_res(struct xfs_mount *mp, int unit_bytes);
 int    xfs_log_calc_minimum_size(struct xfs_mount *);
index f577247b748d342070777c8c47c46861046a76fb..76eb9e328835f8be1a7135d15704462e2365aa42 100644 (file)
@@ -116,15 +116,6 @@ typedef enum {
        { XFS_LOOKUP_LEi,       "le" }, \
        { XFS_LOOKUP_GEi,       "ge" }
 
-/*
- * This enum is used in string mapping in xfs_trace.h and scrub/trace.h;
- * please keep the TRACE_DEFINE_ENUMs for it up to date.
- */
-typedef enum {
-       XFS_BTNUM_BNOi, XFS_BTNUM_CNTi, XFS_BTNUM_RMAPi, XFS_BTNUM_BMAPi,
-       XFS_BTNUM_INOi, XFS_BTNUM_FINOi, XFS_BTNUM_REFCi, XFS_BTNUM_MAX
-} xfs_btnum_t;
-
 struct xfs_name {
        const unsigned char     *name;
        int                     len;
index 7d772715113e25035075ef2943db26a19dc47cbe..1a3e40cca68cc0e4e72184988f270e40b737af7b 100644 (file)
@@ -204,7 +204,7 @@ get_bno_rec(
 {
        xfs_agnumber_t          agno = cur->bc_ag.pag->pag_agno;
 
-       if (cur->bc_btnum == XFS_BTNUM_BNO) {
+       if (xfs_btree_is_bno(cur->bc_ops)) {
                if (!prev_value)
                        return findfirst_bno_extent(agno);
                return findnext_bno_extent(prev_value);
@@ -378,7 +378,7 @@ get_ino_rec(
 {
        xfs_agnumber_t          agno = cur->bc_ag.pag->pag_agno;
 
-       if (cur->bc_btnum == XFS_BTNUM_INO) {
+       if (xfs_btree_is_ino(cur->bc_ops)) {
                if (!prev_value)
                        return findfirst_inode_rec(agno);
                return next_ino_rec(prev_value);
index 6ae2ea575582df0e086e055da33a17efad448497..b689a4234143d461a23bc3b33df8c32942d0706a 100644 (file)
@@ -304,11 +304,9 @@ build_agf_agfl(
        }
 
 #ifdef XR_BLD_FREE_TRACE
-       fprintf(stderr, "bno root = %u, bcnt root = %u, indices = %u %u\n",
+       fprintf(stderr, "bno root = %u, bcnt root = %u\n",
                        be32_to_cpu(agf->agf_bno_root),
-                       be32_to_cpu(agf->agf_cnt_root),
-                       XFS_BTNUM_BNO,
-                       XFS_BTNUM_CNT);
+                       be32_to_cpu(agf->agf_cnt_root));
 #endif
 
        if (xfs_has_crc(mp))