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>

8 files changed, 55 insertions, 50 deletions

diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
index 9345802c99f7..999ad8d00d43 100644
--- 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 e9eb4b2768f2..b715668886a4 100644
--- 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 d5672ab58b1f..332eefa2700b 100644
--- 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 a8f6db735d5d..fcf0d17405d8 100644
--- 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 7fbf8af0b159..9b25e7a0df47 100644
--- 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 1aaa01c97517..d9eab657b63e 100644
--- 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 e7d06295338d..8ed885507dd8 100644
--- 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 6d32838aa184..e21ed0294e5c 100644
--- a/fs/xfs/libxfs/xfs_rmap.h
+++ b/fs/xfs/libxfs/xfs_rmap.h
@@ -7,16 +7,6 @@
 #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,
         xfs_ino_t               ino,
@@ -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__ */