xfs: remove xfs_rmap_ag_owner and friends

Owner information for static fs metadata can be defined readonly at
build time because it never changes across filesystems.  This enables us
to reduce stack usage (particularly in scrub) because we can use the
statically defined oinfo structures.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>

diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
index 9345802c99f7b131e1b96394146762e57de96280..999ad8d00d433b278554e7df259c076dec95f14e 100644 (file)
--- a/fs/xfs/libxfs/xfs_ag.c
+++ b/fs/xfs/libxfs/xfs_ag.c
@@ -414,7 +414,6 @@ xfs_ag_extend_space(
        struct aghdr_init_data  *id,
        xfs_extlen_t            len)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_buf          *bp;
        struct xfs_agi          *agi;
        struct xfs_agf          *agf;
@@ -448,17 +447,17 @@ xfs_ag_extend_space(
        /*
         * Free the new space.
         *
-        * XFS_RMAP_OWN_NULL is used here to tell the rmap btree that
+        * XFS_RMAP_OINFO_SKIP_UPDATE is used here to tell the rmap btree that
         * this doesn't actually exist in the rmap btree.
         */
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
        error = xfs_rmap_free(tp, bp, id->agno,
                                be32_to_cpu(agf->agf_length) - len,
-                               len, &oinfo);
+                               len, &XFS_RMAP_OINFO_SKIP_UPDATE);
        if (error)
                return error;
 
        return  xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, id->agno,
                                        be32_to_cpu(agf->agf_length) - len),
-                               len, &oinfo, XFS_AG_RESV_NONE);
+                               len, &XFS_RMAP_OINFO_SKIP_UPDATE,
+                               XFS_AG_RESV_NONE);
 }

diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index e9eb4b2768f26065edd461508f9d171728586ab7..b715668886a4824adf8a1c4527236469afed89fe 100644 (file)
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -1594,7 +1594,6 @@ xfs_alloc_ag_vextent_small(
        xfs_extlen_t    *flenp, /* result length */
        int             *stat)  /* status: 0-freelist, 1-normal/none */
 {
-       struct xfs_owner_info   oinfo;
        int             error;
        xfs_agblock_t   fbno;
        xfs_extlen_t    flen;
@@ -1648,9 +1647,8 @@ xfs_alloc_ag_vextent_small(
                         * doesn't live in the free space, we need to clear
                         * out the OWN_AG rmap.
                         */
-                       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
                        error = xfs_rmap_free(args->tp, args->agbp, args->agno,
-                                       fbno, 1, &oinfo);
+                                       fbno, 1, &XFS_RMAP_OINFO_AG);
                        if (error)
                                goto error0;
 
@@ -2314,10 +2312,11 @@ xfs_alloc_fix_freelist(
         * repair/rmap.c in xfsprogs for details.
         */
        memset(&targs, 0, sizeof(targs));
+       /* struct copy below */
        if (flags & XFS_ALLOC_FLAG_NORMAP)
-               xfs_rmap_skip_owner_update(&targs.oinfo);
+               targs.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
        else
-               xfs_rmap_ag_owner(&targs.oinfo, XFS_RMAP_OWN_AG);
+               targs.oinfo = XFS_RMAP_OINFO_AG;
        while (!(flags & XFS_ALLOC_FLAG_NOSHRINK) && pag->pagf_flcount > need) {
                error = xfs_alloc_get_freelist(tp, agbp, &bno, 0);
                if (error)

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index d5672ab58b1f299e4cd2741841c93b4783480849..332eefa2700ba7c86e480533b4d0de45339f26f8 100644 (file)
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -564,7 +564,7 @@ __xfs_bmap_add_free(
        if (oinfo)
                new->xefi_oinfo = *oinfo;
        else
-               xfs_rmap_skip_owner_update(&new->xefi_oinfo);
+               new->xefi_oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
        new->xefi_skip_discard = skip_discard;
        trace_xfs_bmap_free_defer(tp->t_mountp,
                        XFS_FSB_TO_AGNO(tp->t_mountp, bno), 0,
@@ -3453,7 +3453,7 @@ xfs_bmap_btalloc(
        args.tp = ap->tp;
        args.mp = mp;
        args.fsbno = ap->blkno;
-       xfs_rmap_skip_owner_update(&args.oinfo);
+       args.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
 
        /* Trim the allocation back to the maximum an AG can fit. */
        args.maxlen = min(ap->length, mp->m_ag_max_usable);

diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index a8f6db735d5d129b146c4cdd8b2c2f1915de2ab5..fcf0d17405d8782920a9b6ac8d2a0cd809b4381e 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -641,7 +641,7 @@ xfs_ialloc_ag_alloc(
        args.tp = tp;
        args.mp = tp->t_mountp;
        args.fsbno = NULLFSBLOCK;
-       xfs_rmap_ag_owner(&args.oinfo, XFS_RMAP_OWN_INODES);
+       args.oinfo = XFS_RMAP_OINFO_INODES;
 
 #ifdef DEBUG
        /* randomly do sparse inode allocations */
@@ -1849,14 +1849,12 @@ xfs_difree_inode_chunk(
        int                             nextbit;
        xfs_agblock_t                   agbno;
        int                             contigblk;
-       struct xfs_owner_info           oinfo;
        DECLARE_BITMAP(holemask, XFS_INOBT_HOLEMASK_BITS);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
 
        if (!xfs_inobt_issparse(rec->ir_holemask)) {
                /* not sparse, calculate extent info directly */
                xfs_bmap_add_free(tp, XFS_AGB_TO_FSB(mp, agno, sagbno),
-                                 mp->m_ialloc_blks, &oinfo);
+                                 mp->m_ialloc_blks, &XFS_RMAP_OINFO_INODES);
                return;
        }
 
@@ -1900,7 +1898,7 @@ xfs_difree_inode_chunk(
                ASSERT(agbno % mp->m_sb.sb_spino_align == 0);
                ASSERT(contigblk % mp->m_sb.sb_spino_align == 0);
                xfs_bmap_add_free(tp, XFS_AGB_TO_FSB(mp, agno, agbno),
-                                 contigblk, &oinfo);
+                                 contigblk, &XFS_RMAP_OINFO_INODES);
 
                /* reset range to current bit and carry on... */
                startidx = endidx = nextbit;

diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 7fbf8af0b15949fb1e329e270cf66ef9f519eb3f..9b25e7a0df470b6e5552d7e841a74082681a8cf8 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -84,7 +84,7 @@ __xfs_inobt_alloc_block(
        memset(&args, 0, sizeof(args));
        args.tp = cur->bc_tp;
        args.mp = cur->bc_mp;
-       xfs_rmap_ag_owner(&args.oinfo, XFS_RMAP_OWN_INOBT);
+       args.oinfo = XFS_RMAP_OINFO_INOBT;
        args.fsbno = XFS_AGB_TO_FSB(args.mp, cur->bc_private.a.agno, sbno);
        args.minlen = 1;
        args.maxlen = 1;
@@ -136,12 +136,9 @@ __xfs_inobt_free_block(
        struct xfs_buf          *bp,
        enum xfs_ag_resv_type   resv)
 {
-       struct xfs_owner_info   oinfo;
-
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
        return xfs_free_extent(cur->bc_tp,
                        XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1,
-                       &oinfo, resv);
+                       &XFS_RMAP_OINFO_INOBT, resv);
 }
 
 STATIC int

diff --git a/fs/xfs/libxfs/xfs_refcount_btree.c b/fs/xfs/libxfs/xfs_refcount_btree.c
index 1aaa01c9751729bdb9c1415c0de163d61afff286..d9eab657b63e4212ee6e731771b32244f65d7876 100644 (file)
--- a/fs/xfs/libxfs/xfs_refcount_btree.c
+++ b/fs/xfs/libxfs/xfs_refcount_btree.c
@@ -70,7 +70,7 @@ xfs_refcountbt_alloc_block(
        args.type = XFS_ALLOCTYPE_NEAR_BNO;
        args.fsbno = XFS_AGB_TO_FSB(cur->bc_mp, cur->bc_private.a.agno,
                        xfs_refc_block(args.mp));
-       xfs_rmap_ag_owner(&args.oinfo, XFS_RMAP_OWN_REFC);
+       args.oinfo = XFS_RMAP_OINFO_REFC;
        args.minlen = args.maxlen = args.prod = 1;
        args.resv = XFS_AG_RESV_METADATA;
 
@@ -106,15 +106,13 @@ xfs_refcountbt_free_block(
        struct xfs_buf          *agbp = cur->bc_private.a.agbp;
        struct xfs_agf          *agf = XFS_BUF_TO_AGF(agbp);
        xfs_fsblock_t           fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));
-       struct xfs_owner_info   oinfo;
        int                     error;
 
        trace_xfs_refcountbt_free_block(cur->bc_mp, cur->bc_private.a.agno,
                        XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno), 1);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_REFC);
        be32_add_cpu(&agf->agf_refcount_blocks, -1);
        xfs_alloc_log_agf(cur->bc_tp, agbp, XFS_AGF_REFCOUNT_BLOCKS);
-       error = xfs_free_extent(cur->bc_tp, fsbno, 1, &oinfo,
+       error = xfs_free_extent(cur->bc_tp, fsbno, 1, &XFS_RMAP_OINFO_REFC,
                        XFS_AG_RESV_METADATA);
        if (error)
                return error;

diff --git a/fs/xfs/libxfs/xfs_rmap.c b/fs/xfs/libxfs/xfs_rmap.c
index e7d06295338db273a70ffd2b7f804a963d702f93..8ed885507dd82c9e5d156e434373f9e3630b3dfd 100644 (file)
--- a/fs/xfs/libxfs/xfs_rmap.c
+++ b/fs/xfs/libxfs/xfs_rmap.c
@@ -2550,3 +2550,31 @@ xfs_rmap_has_other_keys(
        *has_rmap = rks.has_rmap;
        return error;
 }
+
+const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE = {
+       .oi_owner = XFS_RMAP_OWN_NULL,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER = {
+       .oi_owner = XFS_RMAP_OWN_UNKNOWN,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_FS = {
+       .oi_owner = XFS_RMAP_OWN_FS,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_LOG = {
+       .oi_owner = XFS_RMAP_OWN_LOG,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_AG = {
+       .oi_owner = XFS_RMAP_OWN_AG,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_INOBT = {
+       .oi_owner = XFS_RMAP_OWN_INOBT,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_INODES = {
+       .oi_owner = XFS_RMAP_OWN_INODES,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_REFC = {
+       .oi_owner = XFS_RMAP_OWN_REFC,
+};
+const struct xfs_owner_info XFS_RMAP_OINFO_COW = {
+       .oi_owner = XFS_RMAP_OWN_COW,
+};

diff --git a/fs/xfs/libxfs/xfs_rmap.h b/fs/xfs/libxfs/xfs_rmap.h
index 6d32838aa184f0a9aae6be5b9c5d5ff1fe641dd5..e21ed0294e5c9898584eb688b700692273718706 100644 (file)
--- a/fs/xfs/libxfs/xfs_rmap.h
+++ b/fs/xfs/libxfs/xfs_rmap.h
@@ -6,16 +6,6 @@
 #ifndef __XFS_RMAP_H__
 #define __XFS_RMAP_H__
 
-static inline void
-xfs_rmap_ag_owner(
-       struct xfs_owner_info   *oi,
-       uint64_t                owner)
-{
-       oi->oi_owner = owner;
-       oi->oi_offset = 0;
-       oi->oi_flags = 0;
-}
-
 static inline void
 xfs_rmap_ino_bmbt_owner(
        struct xfs_owner_info   *oi,
@@ -43,13 +33,6 @@ xfs_rmap_ino_owner(
                oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
 }
 
-static inline void
-xfs_rmap_skip_owner_update(
-       struct xfs_owner_info   *oi)
-{
-       xfs_rmap_ag_owner(oi, XFS_RMAP_OWN_NULL);
-}
-
 static inline bool
 xfs_rmap_should_skip_owner_update(
        const struct xfs_owner_info     *oi)
@@ -57,13 +40,6 @@ xfs_rmap_should_skip_owner_update(
        return oi->oi_owner == XFS_RMAP_OWN_NULL;
 }
 
-static inline void
-xfs_rmap_any_owner_update(
-       struct xfs_owner_info   *oi)
-{
-       xfs_rmap_ag_owner(oi, XFS_RMAP_OWN_UNKNOWN);
-}
-
 /* Reverse mapping functions. */
 
 struct xfs_buf;
@@ -225,4 +201,14 @@ int xfs_rmap_has_other_keys(struct xfs_btree_cur *cur, xfs_agblock_t bno,
                bool *has_rmap);
 int xfs_rmap_map_raw(struct xfs_btree_cur *cur, struct xfs_rmap_irec *rmap);
 
+extern const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_FS;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_LOG;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_AG;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_INOBT;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_INODES;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_REFC;
+extern const struct xfs_owner_info XFS_RMAP_OINFO_COW;
+
 #endif /* __XFS_RMAP_H__ */

diff --git a/fs/xfs/scrub/agheader.c b/fs/xfs/scrub/agheader.c
index 3068a9382febd5f230f9d47137f8adb4f0aa8521..90955ab1e89599303e64effcfa237cb8f25e5e73 100644 (file)
--- a/fs/xfs/scrub/agheader.c
+++ b/fs/xfs/scrub/agheader.c
@@ -32,7 +32,6 @@ xchk_superblock_xref(
        struct xfs_scrub        *sc,
        struct xfs_buf          *bp)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_mount        *mp = sc->mp;
        xfs_agnumber_t          agno = sc->sm->sm_agno;
        xfs_agblock_t           agbno;
@@ -49,8 +48,7 @@ xchk_superblock_xref(
 
        xchk_xref_is_used_space(sc, agbno, 1);
        xchk_xref_is_not_inode_chunk(sc, agbno, 1);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
-       xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
+       xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
        xchk_xref_is_not_shared(sc, agbno, 1);
 
        /* scrub teardown will take care of sc->sa for us */
@@ -484,7 +482,6 @@ STATIC void
 xchk_agf_xref(
        struct xfs_scrub        *sc)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_mount        *mp = sc->mp;
        xfs_agblock_t           agbno;
        int                     error;
@@ -502,8 +499,7 @@ xchk_agf_xref(
        xchk_agf_xref_freeblks(sc);
        xchk_agf_xref_cntbt(sc);
        xchk_xref_is_not_inode_chunk(sc, agbno, 1);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
-       xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
+       xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
        xchk_agf_xref_btreeblks(sc);
        xchk_xref_is_not_shared(sc, agbno, 1);
        xchk_agf_xref_refcblks(sc);
@@ -598,7 +594,6 @@ out:
 /* AGFL */
 
 struct xchk_agfl_info {
-       struct xfs_owner_info   oinfo;
        unsigned int            sz_entries;
        unsigned int            nr_entries;
        xfs_agblock_t           *entries;
@@ -609,15 +604,14 @@ struct xchk_agfl_info {
 STATIC void
 xchk_agfl_block_xref(
        struct xfs_scrub        *sc,
-       xfs_agblock_t           agbno,
-       struct xfs_owner_info   *oinfo)
+       xfs_agblock_t           agbno)
 {
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
 
        xchk_xref_is_used_space(sc, agbno, 1);
        xchk_xref_is_not_inode_chunk(sc, agbno, 1);
-       xchk_xref_is_owned_by(sc, agbno, 1, oinfo);
+       xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_AG);
        xchk_xref_is_not_shared(sc, agbno, 1);
 }
 
@@ -638,7 +632,7 @@ xchk_agfl_block(
        else
                xchk_block_set_corrupt(sc, sc->sa.agfl_bp);
 
-       xchk_agfl_block_xref(sc, agbno, priv);
+       xchk_agfl_block_xref(sc, agbno);
 
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return XFS_BTREE_QUERY_RANGE_ABORT;
@@ -662,7 +656,6 @@ STATIC void
 xchk_agfl_xref(
        struct xfs_scrub        *sc)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_mount        *mp = sc->mp;
        xfs_agblock_t           agbno;
        int                     error;
@@ -678,8 +671,7 @@ xchk_agfl_xref(
 
        xchk_xref_is_used_space(sc, agbno, 1);
        xchk_xref_is_not_inode_chunk(sc, agbno, 1);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
-       xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
+       xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
        xchk_xref_is_not_shared(sc, agbno, 1);
 
        /*
@@ -732,7 +724,6 @@ xchk_agfl(
        }
 
        /* Check the blocks in the AGFL. */
-       xfs_rmap_ag_owner(&sai.oinfo, XFS_RMAP_OWN_AG);
        error = xfs_agfl_walk(sc->mp, XFS_BUF_TO_AGF(sc->sa.agf_bp),
                        sc->sa.agfl_bp, xchk_agfl_block, &sai);
        if (error == XFS_BTREE_QUERY_RANGE_ABORT) {
@@ -791,7 +782,6 @@ STATIC void
 xchk_agi_xref(
        struct xfs_scrub        *sc)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_mount        *mp = sc->mp;
        xfs_agblock_t           agbno;
        int                     error;
@@ -808,8 +798,7 @@ xchk_agi_xref(
        xchk_xref_is_used_space(sc, agbno, 1);
        xchk_xref_is_not_inode_chunk(sc, agbno, 1);
        xchk_agi_xref_icounts(sc);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
-       xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
+       xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_FS);
        xchk_xref_is_not_shared(sc, agbno, 1);
 
        /* scrub teardown will take care of sc->sa for us */

diff --git a/fs/xfs/scrub/agheader_repair.c b/fs/xfs/scrub/agheader_repair.c
index f7568a4b5fe58f5aecef931c3928d3c9ec0564fd..03d1e15ccebaa3364226a9985955d224cf9724a7 100644 (file)
--- a/fs/xfs/scrub/agheader_repair.c
+++ b/fs/xfs/scrub/agheader_repair.c
@@ -646,7 +646,6 @@ int
 xrep_agfl(
        struct xfs_scrub        *sc)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_bitmap       agfl_extents;
        struct xfs_mount        *mp = sc->mp;
        struct xfs_buf          *agf_bp;
@@ -708,8 +707,8 @@ xrep_agfl(
                goto err;
 
        /* Dump any AGFL overflow. */
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
-       return xrep_reap_extents(sc, &agfl_extents, &oinfo, XFS_AG_RESV_AGFL);
+       return xrep_reap_extents(sc, &agfl_extents, &XFS_RMAP_OINFO_AG,
+                       XFS_AG_RESV_AGFL);
 err:
        xfs_bitmap_destroy(&agfl_extents);
        return error;

diff --git a/fs/xfs/scrub/alloc.c b/fs/xfs/scrub/alloc.c
index 376bcb585ae6916e8ca089009d37f6e79b4bed19..44883e9112ad06b9db9bdee40a4cdd96ec8b31af 100644 (file)
--- a/fs/xfs/scrub/alloc.c
+++ b/fs/xfs/scrub/alloc.c
@@ -125,12 +125,10 @@ xchk_allocbt(
        struct xfs_scrub        *sc,
        xfs_btnum_t             which)
 {
-       struct xfs_owner_info   oinfo;
        struct xfs_btree_cur    *cur;
 
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
        cur = which == XFS_BTNUM_BNO ? sc->sa.bno_cur : sc->sa.cnt_cur;
-       return xchk_btree(sc, cur, xchk_allocbt_rec, &oinfo, NULL);
+       return xchk_btree(sc, cur, xchk_allocbt_rec, &XFS_RMAP_OINFO_AG, NULL);
 }
 
 int

diff --git a/fs/xfs/scrub/ialloc.c b/fs/xfs/scrub/ialloc.c
index 224dba937492aa188e457a050c752577f825b4bb..72f45b298fa55b2617eb8ca26650747176d1ad17 100644 (file)
--- a/fs/xfs/scrub/ialloc.c
+++ b/fs/xfs/scrub/ialloc.c
@@ -82,15 +82,12 @@ xchk_iallocbt_chunk_xref(
        xfs_agblock_t                   agbno,
        xfs_extlen_t                    len)
 {
-       struct xfs_owner_info           oinfo;
-
        if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
                return;
 
        xchk_xref_is_used_space(sc, agbno, len);
        xchk_iallocbt_chunk_xref_other(sc, irec, agino);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
-       xchk_xref_is_owned_by(sc, agbno, len, &oinfo);
+       xchk_xref_is_owned_by(sc, agbno, len, &XFS_RMAP_OINFO_INODES);
        xchk_xref_is_not_shared(sc, agbno, len);
 }
 
@@ -186,7 +183,6 @@ xchk_iallocbt_check_freemask(
        struct xchk_btree               *bs,
        struct xfs_inobt_rec_incore     *irec)
 {
-       struct xfs_owner_info           oinfo;
        struct xfs_imap                 imap;
        struct xfs_mount                *mp = bs->cur->bc_mp;
        struct xfs_dinode               *dip;
@@ -205,7 +201,6 @@ xchk_iallocbt_check_freemask(
        /* Make sure the freemask matches the inode records. */
        blks_per_cluster = xfs_icluster_size_fsb(mp);
        nr_inodes = XFS_OFFBNO_TO_AGINO(mp, blks_per_cluster, 0);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
 
        for (agino = irec->ir_startino;
             agino < irec->ir_startino + XFS_INODES_PER_CHUNK;
@@ -230,12 +225,13 @@ xchk_iallocbt_check_freemask(
                /* If any part of this is a hole, skip it. */
                if (ir_holemask) {
                        xchk_xref_is_not_owned_by(bs->sc, agbno,
-                                       blks_per_cluster, &oinfo);
+                                       blks_per_cluster,
+                                       &XFS_RMAP_OINFO_INODES);
                        continue;
                }
 
                xchk_xref_is_owned_by(bs->sc, agbno, blks_per_cluster,
-                               &oinfo);
+                               &XFS_RMAP_OINFO_INODES);
 
                /* Grab the inode cluster buffer. */
                imap.im_blkno = XFS_AGB_TO_DADDR(mp, bs->cur->bc_private.a.agno,
@@ -366,7 +362,6 @@ xchk_iallocbt_xref_rmap_btreeblks(
        struct xfs_scrub        *sc,
        int                     which)
 {
-       struct xfs_owner_info   oinfo;
        xfs_filblks_t           blocks;
        xfs_extlen_t            inobt_blocks = 0;
        xfs_extlen_t            finobt_blocks = 0;
@@ -388,9 +383,8 @@ xchk_iallocbt_xref_rmap_btreeblks(
                        return;
        }
 
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
-       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
-                       &blocks);
+       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur,
+                       &XFS_RMAP_OINFO_INOBT, &blocks);
        if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
                return;
        if (blocks != inobt_blocks + finobt_blocks)
@@ -407,7 +401,6 @@ xchk_iallocbt_xref_rmap_inodes(
        int                     which,
        xfs_filblks_t           inode_blocks)
 {
-       struct xfs_owner_info   oinfo;
        xfs_filblks_t           blocks;
        int                     error;
 
@@ -415,9 +408,8 @@ xchk_iallocbt_xref_rmap_inodes(
                return;
 
        /* Check that we saw as many inode blocks as the rmap knows about. */
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
-       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
-                       &blocks);
+       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur,
+                       &XFS_RMAP_OINFO_INODES, &blocks);
        if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
                return;
        if (blocks != inode_blocks)
@@ -431,13 +423,11 @@ xchk_iallocbt(
        xfs_btnum_t             which)
 {
        struct xfs_btree_cur    *cur;
-       struct xfs_owner_info   oinfo;
        xfs_filblks_t           inode_blocks = 0;
        int                     error;
 
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
        cur = which == XFS_BTNUM_INO ? sc->sa.ino_cur : sc->sa.fino_cur;
-       error = xchk_btree(sc, cur, xchk_iallocbt_rec, &oinfo,
+       error = xchk_btree(sc, cur, xchk_iallocbt_rec, &XFS_RMAP_OINFO_INOBT,
                        &inode_blocks);
        if (error)
                return error;

diff --git a/fs/xfs/scrub/inode.c b/fs/xfs/scrub/inode.c
index e386c9b0b4ab7de6bc2d42fddcf204539d8d2a28..e213efc194a1d6e2417f941da0be04691befb3f7 100644 (file)
--- a/fs/xfs/scrub/inode.c
+++ b/fs/xfs/scrub/inode.c
@@ -509,7 +509,6 @@ xchk_inode_xref(
        xfs_ino_t               ino,
        struct xfs_dinode       *dip)
 {
-       struct xfs_owner_info   oinfo;
        xfs_agnumber_t          agno;
        xfs_agblock_t           agbno;
        int                     error;
@@ -526,8 +525,7 @@ xchk_inode_xref(
 
        xchk_xref_is_used_space(sc, agbno, 1);
        xchk_inode_xref_finobt(sc, ino);
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
-       xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
+       xchk_xref_is_owned_by(sc, agbno, 1, &XFS_RMAP_OINFO_INODES);
        xchk_xref_is_not_shared(sc, agbno, 1);
        xchk_inode_xref_bmap(sc, dip);
 

diff --git a/fs/xfs/scrub/refcount.c b/fs/xfs/scrub/refcount.c
index b7ade620acee146523e36b8d6e429ebfc91612cf..708b4158eb903b40fe7d577148f4adee8bdb554d 100644 (file)
--- a/fs/xfs/scrub/refcount.c
+++ b/fs/xfs/scrub/refcount.c
@@ -385,7 +385,6 @@ xchk_refcount_xref_rmap(
        struct xfs_scrub        *sc,
        xfs_filblks_t           cow_blocks)
 {
-       struct xfs_owner_info   oinfo;
        xfs_extlen_t            refcbt_blocks = 0;
        xfs_filblks_t           blocks;
        int                     error;
@@ -394,21 +393,19 @@ xchk_refcount_xref_rmap(
                return;
 
        /* Check that we saw as many refcbt blocks as the rmap knows about. */
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_REFC);
        error = xfs_btree_count_blocks(sc->sa.refc_cur, &refcbt_blocks);
        if (!xchk_btree_process_error(sc, sc->sa.refc_cur, 0, &error))
                return;
-       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
-                       &blocks);
+       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur,
+                       &XFS_RMAP_OINFO_REFC, &blocks);
        if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
                return;
        if (blocks != refcbt_blocks)
                xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
 
        /* Check that we saw as many cow blocks as the rmap knows about. */
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_COW);
-       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
-                       &blocks);
+       error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur,
+                       &XFS_RMAP_OINFO_COW, &blocks);
        if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
                return;
        if (blocks != cow_blocks)
@@ -420,13 +417,11 @@ int
 xchk_refcountbt(
        struct xfs_scrub        *sc)
 {
-       struct xfs_owner_info   oinfo;
        xfs_agblock_t           cow_blocks = 0;
        int                     error;
 
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_REFC);
        error = xchk_btree(sc, sc->sa.refc_cur, xchk_refcountbt_rec,
-                       &oinfo, &cow_blocks);
+                       &XFS_RMAP_OINFO_REFC, &cow_blocks);
        if (error)
                return error;
 

diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
index 90ae9e173de7f568e3c9c77c2ae429e55e86da37..1c8eecfe52b85688b48fd2507ceeeee18fe64878 100644 (file)
--- a/fs/xfs/scrub/repair.c
+++ b/fs/xfs/scrub/repair.c
@@ -505,7 +505,6 @@ xrep_put_freelist(
        struct xfs_scrub        *sc,
        xfs_agblock_t           agbno)
 {
-       struct xfs_owner_info   oinfo;
        int                     error;
 
        /* Make sure there's space on the freelist. */
@@ -518,9 +517,8 @@ xrep_put_freelist(
         * create an rmap for the block prior to merging it or else other
         * parts will break.
         */
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
        error = xfs_rmap_alloc(sc->tp, sc->sa.agf_bp, sc->sa.agno, agbno, 1,
-                       &oinfo);
+                       &XFS_RMAP_OINFO_AG);
        if (error)
                return error;
 

diff --git a/fs/xfs/scrub/rmap.c b/fs/xfs/scrub/rmap.c
index 8a5bf15d544d0cbd29c3e639fcd4f530352800e8..92a140c5b55e32c3b6b4620104b78cac7ddd68f3 100644 (file)
--- a/fs/xfs/scrub/rmap.c
+++ b/fs/xfs/scrub/rmap.c
@@ -174,11 +174,8 @@ int
 xchk_rmapbt(
        struct xfs_scrub        *sc)
 {
-       struct xfs_owner_info   oinfo;
-
-       xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
        return xchk_btree(sc, sc->sa.rmap_cur, xchk_rmapbt_rec,
-                       &oinfo, NULL);
+                       &XFS_RMAP_OINFO_AG, NULL);
 }
 
 /* xref check that the extent is owned by a given owner */

diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index d9da66c718bb652d87ba41baf37bd1554908a685..74ddf66f4cfe463264cdcd2d7ea1dd9fb11bb8f9 100644 (file)
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -494,7 +494,6 @@ xfs_efi_recover(
        int                     error = 0;
        xfs_extent_t            *extp;
        xfs_fsblock_t           startblock_fsb;
-       struct xfs_owner_info   oinfo;
 
        ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
 
@@ -526,11 +525,11 @@ xfs_efi_recover(
                return error;
        efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
 
-       xfs_rmap_any_owner_update(&oinfo);
        for (i = 0; i < efip->efi_format.efi_nextents; i++) {
                extp = &efip->efi_format.efi_extents[i];
                error = xfs_trans_free_extent(tp, efdp, extp->ext_start,
-                                             extp->ext_len, &oinfo, false);
+                                             extp->ext_len,
+                                             &XFS_RMAP_OINFO_ANY_OWNER, false);
                if (error)
                        goto abort_error;