xfs: prepare rmap btree tracepoints for widening

Prepare the rmap btree tracepoints for use with realtime rmap btrees by
making them take the btree cursor object as a parameter.  This will save
us a lot of trouble later on.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>

diff --git a/libxfs/xfs_rmap.c b/libxfs/xfs_rmap.c
index 74a30ed81e7a4cca259b19128c1f17fffe49ddc4..46bee57cc140f7424d55ded4a84d0348eda71c6e 100644 (file)
--- a/libxfs/xfs_rmap.c
+++ b/libxfs/xfs_rmap.c
@@ -99,8 +99,7 @@ xfs_rmap_update(
        union xfs_btree_rec     rec;
        int                     error;
 
-       trace_xfs_rmap_update(cur->bc_mp, cur->bc_ag.pag->pag_agno,
-                       irec->rm_startblock, irec->rm_blockcount,
+       trace_xfs_rmap_update(cur, irec->rm_startblock, irec->rm_blockcount,
                        irec->rm_owner, irec->rm_offset, irec->rm_flags);
 
        rec.rmap.rm_startblock = cpu_to_be32(irec->rm_startblock);
@@ -126,8 +125,7 @@ xfs_rmap_insert(
        int                     i;
        int                     error;
 
-       trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_ag.pag->pag_agno, agbno,
-                       len, owner, offset, flags);
+       trace_xfs_rmap_insert(rcur, agbno, len, owner, offset, flags);
 
        error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
        if (error)
@@ -169,8 +167,7 @@ xfs_rmap_delete(
        int                     i;
        int                     error;
 
-       trace_xfs_rmap_delete(rcur->bc_mp, rcur->bc_ag.pag->pag_agno, agbno,
-                       len, owner, offset, flags);
+       trace_xfs_rmap_delete(rcur, agbno, len, owner, offset, flags);
 
        error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
        if (error)
@@ -338,8 +335,7 @@ xfs_rmap_find_left_neighbor_helper(
 {
        struct xfs_find_left_neighbor_info      *info = priv;
 
-       trace_xfs_rmap_find_left_neighbor_candidate(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, rec->rm_startblock,
+       trace_xfs_rmap_find_left_neighbor_candidate(cur, rec->rm_startblock,
                        rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
                        rec->rm_flags);
 
@@ -389,8 +385,8 @@ xfs_rmap_find_left_neighbor(
        info.high.rm_blockcount = 0;
        info.irec = irec;
 
-       trace_xfs_rmap_find_left_neighbor_query(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, bno, 0, owner, offset, flags);
+       trace_xfs_rmap_find_left_neighbor_query(cur, bno, 0, owner, offset,
+                       flags);
 
        /*
         * Historically, we always used the range query to walk every reverse
@@ -421,8 +417,7 @@ xfs_rmap_find_left_neighbor(
                return error;
 
        *stat = 1;
-       trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, irec->rm_startblock,
+       trace_xfs_rmap_find_left_neighbor_result(cur, irec->rm_startblock,
                        irec->rm_blockcount, irec->rm_owner, irec->rm_offset,
                        irec->rm_flags);
        return 0;
@@ -437,8 +432,7 @@ xfs_rmap_lookup_le_range_helper(
 {
        struct xfs_find_left_neighbor_info      *info = priv;
 
-       trace_xfs_rmap_lookup_le_range_candidate(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, rec->rm_startblock,
+       trace_xfs_rmap_lookup_le_range_candidate(cur, rec->rm_startblock,
                        rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
                        rec->rm_flags);
 
@@ -485,8 +479,7 @@ xfs_rmap_lookup_le_range(
        *stat = 0;
        info.irec = irec;
 
-       trace_xfs_rmap_lookup_le_range(cur->bc_mp, cur->bc_ag.pag->pag_agno,
-                       bno, 0, owner, offset, flags);
+       trace_xfs_rmap_lookup_le_range(cur, bno, 0, owner, offset, flags);
 
        /*
         * Historically, we always used the range query to walk every reverse
@@ -517,8 +510,7 @@ xfs_rmap_lookup_le_range(
                return error;
 
        *stat = 1;
-       trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, irec->rm_startblock,
+       trace_xfs_rmap_lookup_le_range_result(cur, irec->rm_startblock,
                        irec->rm_blockcount, irec->rm_owner, irec->rm_offset,
                        irec->rm_flags);
        return 0;
@@ -630,8 +622,7 @@ xfs_rmap_unmap(
                        (flags & XFS_RMAP_BMBT_BLOCK);
        if (unwritten)
                flags |= XFS_RMAP_UNWRITTEN;
-       trace_xfs_rmap_unmap(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_unmap(cur, bno, len, unwritten, oinfo);
 
        /*
         * We should always have a left record because there's a static record
@@ -647,10 +638,9 @@ xfs_rmap_unmap(
                goto out_error;
        }
 
-       trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, ltrec.rm_startblock,
-                       ltrec.rm_blockcount, ltrec.rm_owner,
-                       ltrec.rm_offset, ltrec.rm_flags);
+       trace_xfs_rmap_lookup_le_range_result(cur, ltrec.rm_startblock,
+                       ltrec.rm_blockcount, ltrec.rm_owner, ltrec.rm_offset,
+                       ltrec.rm_flags);
        ltoff = ltrec.rm_offset;
 
        /*
@@ -717,10 +707,9 @@ xfs_rmap_unmap(
 
        if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
                /* exact match, simply remove the record from rmap tree */
-               trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
-                               ltrec.rm_startblock, ltrec.rm_blockcount,
-                               ltrec.rm_owner, ltrec.rm_offset,
-                               ltrec.rm_flags);
+               trace_xfs_rmap_delete(cur, ltrec.rm_startblock,
+                               ltrec.rm_blockcount, ltrec.rm_owner,
+                               ltrec.rm_offset, ltrec.rm_flags);
                error = xfs_btree_delete(cur, &i);
                if (error)
                        goto out_error;
@@ -796,8 +785,7 @@ xfs_rmap_unmap(
                else
                        cur->bc_rec.r.rm_offset = offset + len;
                cur->bc_rec.r.rm_flags = flags;
-               trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno,
-                               cur->bc_rec.r.rm_startblock,
+               trace_xfs_rmap_insert(cur, cur->bc_rec.r.rm_startblock,
                                cur->bc_rec.r.rm_blockcount,
                                cur->bc_rec.r.rm_owner,
                                cur->bc_rec.r.rm_offset,
@@ -808,8 +796,7 @@ xfs_rmap_unmap(
        }
 
 out_done:
-       trace_xfs_rmap_unmap_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_unmap_done(cur, bno, len, unwritten, oinfo);
 out_error:
        if (error)
                trace_xfs_rmap_unmap_error(cur, error, _RET_IP_);
@@ -982,8 +969,7 @@ xfs_rmap_map(
                        (flags & XFS_RMAP_BMBT_BLOCK);
        if (unwritten)
                flags |= XFS_RMAP_UNWRITTEN;
-       trace_xfs_rmap_map(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_map(cur, bno, len, unwritten, oinfo);
        ASSERT(!xfs_rmap_should_skip_owner_update(oinfo));
 
        /*
@@ -996,8 +982,7 @@ xfs_rmap_map(
        if (error)
                goto out_error;
        if (have_lt) {
-               trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
-                               cur->bc_ag.pag->pag_agno, ltrec.rm_startblock,
+               trace_xfs_rmap_lookup_le_range_result(cur, ltrec.rm_startblock,
                                ltrec.rm_blockcount, ltrec.rm_owner,
                                ltrec.rm_offset, ltrec.rm_flags);
 
@@ -1035,10 +1020,10 @@ xfs_rmap_map(
                        error = -EFSCORRUPTED;
                        goto out_error;
                }
-               trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, gtrec.rm_startblock,
-                       gtrec.rm_blockcount, gtrec.rm_owner,
-                       gtrec.rm_offset, gtrec.rm_flags);
+               trace_xfs_rmap_find_right_neighbor_result(cur,
+                               gtrec.rm_startblock, gtrec.rm_blockcount,
+                               gtrec.rm_owner, gtrec.rm_offset,
+                               gtrec.rm_flags);
                if (!xfs_rmap_is_mergeable(&gtrec, owner, flags))
                        have_gt = 0;
        }
@@ -1075,12 +1060,9 @@ xfs_rmap_map(
                         * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
                         */
                        ltrec.rm_blockcount += gtrec.rm_blockcount;
-                       trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
-                                       gtrec.rm_startblock,
-                                       gtrec.rm_blockcount,
-                                       gtrec.rm_owner,
-                                       gtrec.rm_offset,
-                                       gtrec.rm_flags);
+                       trace_xfs_rmap_delete(cur, gtrec.rm_startblock,
+                                       gtrec.rm_blockcount, gtrec.rm_owner,
+                                       gtrec.rm_offset, gtrec.rm_flags);
                        error = xfs_btree_delete(cur, &i);
                        if (error)
                                goto out_error;
@@ -1127,8 +1109,7 @@ xfs_rmap_map(
                cur->bc_rec.r.rm_owner = owner;
                cur->bc_rec.r.rm_offset = offset;
                cur->bc_rec.r.rm_flags = flags;
-               trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       owner, offset, flags);
+               trace_xfs_rmap_insert(cur, bno, len, owner, offset, flags);
                error = xfs_btree_insert(cur, &i);
                if (error)
                        goto out_error;
@@ -1139,8 +1120,7 @@ xfs_rmap_map(
                }
        }
 
-       trace_xfs_rmap_map_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_map_done(cur, bno, len, unwritten, oinfo);
 out_error:
        if (error)
                trace_xfs_rmap_map_error(cur, error, _RET_IP_);
@@ -1217,8 +1197,7 @@ xfs_rmap_convert(
                        (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
        oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
        new_endoff = offset + len;
-       trace_xfs_rmap_convert(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_convert(cur, bno, len, unwritten, oinfo);
 
        /*
         * For the initial lookup, look for an exact match or the left-adjacent
@@ -1234,10 +1213,9 @@ xfs_rmap_convert(
                goto done;
        }
 
-       trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, PREV.rm_startblock,
-                       PREV.rm_blockcount, PREV.rm_owner,
-                       PREV.rm_offset, PREV.rm_flags);
+       trace_xfs_rmap_lookup_le_range_result(cur, PREV.rm_startblock,
+                       PREV.rm_blockcount, PREV.rm_owner, PREV.rm_offset,
+                       PREV.rm_flags);
 
        ASSERT(PREV.rm_offset <= offset);
        ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
@@ -1278,10 +1256,9 @@ xfs_rmap_convert(
                        error = -EFSCORRUPTED;
                        goto done;
                }
-               trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
-                               cur->bc_ag.pag->pag_agno, LEFT.rm_startblock,
-                               LEFT.rm_blockcount, LEFT.rm_owner,
-                               LEFT.rm_offset, LEFT.rm_flags);
+               trace_xfs_rmap_find_left_neighbor_result(cur,
+                               LEFT.rm_startblock, LEFT.rm_blockcount,
+                               LEFT.rm_owner, LEFT.rm_offset, LEFT.rm_flags);
                if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&
                    LEFT.rm_offset + LEFT.rm_blockcount == offset &&
                    xfs_rmap_is_mergeable(&LEFT, owner, newext))
@@ -1319,10 +1296,10 @@ xfs_rmap_convert(
                        error = -EFSCORRUPTED;
                        goto done;
                }
-               trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
-                               cur->bc_ag.pag->pag_agno, RIGHT.rm_startblock,
-                               RIGHT.rm_blockcount, RIGHT.rm_owner,
-                               RIGHT.rm_offset, RIGHT.rm_flags);
+               trace_xfs_rmap_find_right_neighbor_result(cur,
+                               RIGHT.rm_startblock, RIGHT.rm_blockcount,
+                               RIGHT.rm_owner, RIGHT.rm_offset,
+                               RIGHT.rm_flags);
                if (bno + len == RIGHT.rm_startblock &&
                    offset + len == RIGHT.rm_offset &&
                    xfs_rmap_is_mergeable(&RIGHT, owner, newext))
@@ -1369,10 +1346,9 @@ xfs_rmap_convert(
                        error = -EFSCORRUPTED;
                        goto done;
                }
-               trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
-                               RIGHT.rm_startblock, RIGHT.rm_blockcount,
-                               RIGHT.rm_owner, RIGHT.rm_offset,
-                               RIGHT.rm_flags);
+               trace_xfs_rmap_delete(cur, RIGHT.rm_startblock,
+                               RIGHT.rm_blockcount, RIGHT.rm_owner,
+                               RIGHT.rm_offset, RIGHT.rm_flags);
                error = xfs_btree_delete(cur, &i);
                if (error)
                        goto done;
@@ -1389,10 +1365,9 @@ xfs_rmap_convert(
                        error = -EFSCORRUPTED;
                        goto done;
                }
-               trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
-                               PREV.rm_startblock, PREV.rm_blockcount,
-                               PREV.rm_owner, PREV.rm_offset,
-                               PREV.rm_flags);
+               trace_xfs_rmap_delete(cur, PREV.rm_startblock,
+                               PREV.rm_blockcount, PREV.rm_owner,
+                               PREV.rm_offset, PREV.rm_flags);
                error = xfs_btree_delete(cur, &i);
                if (error)
                        goto done;
@@ -1421,10 +1396,9 @@ xfs_rmap_convert(
                 * Setting all of a previous oldext extent to newext.
                 * The left neighbor is contiguous, the right is not.
                 */
-               trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
-                               PREV.rm_startblock, PREV.rm_blockcount,
-                               PREV.rm_owner, PREV.rm_offset,
-                               PREV.rm_flags);
+               trace_xfs_rmap_delete(cur, PREV.rm_startblock,
+                               PREV.rm_blockcount, PREV.rm_owner,
+                               PREV.rm_offset, PREV.rm_flags);
                error = xfs_btree_delete(cur, &i);
                if (error)
                        goto done;
@@ -1461,10 +1435,9 @@ xfs_rmap_convert(
                        error = -EFSCORRUPTED;
                        goto done;
                }
-               trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
-                               RIGHT.rm_startblock, RIGHT.rm_blockcount,
-                               RIGHT.rm_owner, RIGHT.rm_offset,
-                               RIGHT.rm_flags);
+               trace_xfs_rmap_delete(cur, RIGHT.rm_startblock,
+                               RIGHT.rm_blockcount, RIGHT.rm_owner,
+                               RIGHT.rm_offset, RIGHT.rm_flags);
                error = xfs_btree_delete(cur, &i);
                if (error)
                        goto done;
@@ -1542,8 +1515,7 @@ xfs_rmap_convert(
                NEW.rm_blockcount = len;
                NEW.rm_flags = newext;
                cur->bc_rec.r = NEW;
-               trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno,
-                               len, owner, offset, newext);
+               trace_xfs_rmap_insert(cur, bno, len, owner, offset, newext);
                error = xfs_btree_insert(cur, &i);
                if (error)
                        goto done;
@@ -1601,8 +1573,7 @@ xfs_rmap_convert(
                NEW.rm_blockcount = len;
                NEW.rm_flags = newext;
                cur->bc_rec.r = NEW;
-               trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno,
-                               len, owner, offset, newext);
+               trace_xfs_rmap_insert(cur, bno, len, owner, offset, newext);
                error = xfs_btree_insert(cur, &i);
                if (error)
                        goto done;
@@ -1633,9 +1604,8 @@ xfs_rmap_convert(
                NEW = PREV;
                NEW.rm_blockcount = offset - PREV.rm_offset;
                cur->bc_rec.r = NEW;
-               trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno,
-                               NEW.rm_startblock, NEW.rm_blockcount,
-                               NEW.rm_owner, NEW.rm_offset,
+               trace_xfs_rmap_insert(cur, NEW.rm_startblock,
+                               NEW.rm_blockcount, NEW.rm_owner, NEW.rm_offset,
                                NEW.rm_flags);
                error = xfs_btree_insert(cur, &i);
                if (error)
@@ -1662,8 +1632,7 @@ xfs_rmap_convert(
                /* new middle extent - newext */
                cur->bc_rec.r.rm_flags &= ~XFS_RMAP_UNWRITTEN;
                cur->bc_rec.r.rm_flags |= newext;
-               trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                               owner, offset, newext);
+               trace_xfs_rmap_insert(cur, bno, len, owner, offset, newext);
                error = xfs_btree_insert(cur, &i);
                if (error)
                        goto done;
@@ -1687,8 +1656,7 @@ xfs_rmap_convert(
                ASSERT(0);
        }
 
-       trace_xfs_rmap_convert_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_convert_done(cur, bno, len, unwritten, oinfo);
 done:
        if (error)
                trace_xfs_rmap_convert_error(cur, error, _RET_IP_);
@@ -1727,8 +1695,7 @@ xfs_rmap_convert_shared(
                        (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
        oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
        new_endoff = offset + len;
-       trace_xfs_rmap_convert(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_convert(cur, bno, len, unwritten, oinfo);
 
        /*
         * For the initial lookup, look for and exact match or the left-adjacent
@@ -1797,10 +1764,10 @@ xfs_rmap_convert_shared(
                        error = -EFSCORRUPTED;
                        goto done;
                }
-               trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
-                               cur->bc_ag.pag->pag_agno, RIGHT.rm_startblock,
-                               RIGHT.rm_blockcount, RIGHT.rm_owner,
-                               RIGHT.rm_offset, RIGHT.rm_flags);
+               trace_xfs_rmap_find_right_neighbor_result(cur,
+                               RIGHT.rm_startblock, RIGHT.rm_blockcount,
+                               RIGHT.rm_owner, RIGHT.rm_offset,
+                               RIGHT.rm_flags);
                if (xfs_rmap_is_mergeable(&RIGHT, owner, newext))
                        state |= RMAP_RIGHT_CONTIG;
        }
@@ -2112,8 +2079,7 @@ xfs_rmap_convert_shared(
                ASSERT(0);
        }
 
-       trace_xfs_rmap_convert_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_convert_done(cur, bno, len, unwritten, oinfo);
 done:
        if (error)
                trace_xfs_rmap_convert_error(cur, error, _RET_IP_);
@@ -2154,8 +2120,7 @@ xfs_rmap_unmap_shared(
        xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
        if (unwritten)
                flags |= XFS_RMAP_UNWRITTEN;
-       trace_xfs_rmap_unmap(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_unmap(cur, bno, len, unwritten, oinfo);
 
        /*
         * We should always have a left record because there's a static record
@@ -2311,8 +2276,7 @@ xfs_rmap_unmap_shared(
                        goto out_error;
        }
 
-       trace_xfs_rmap_unmap_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_unmap_done(cur, bno, len, unwritten, oinfo);
 out_error:
        if (error)
                trace_xfs_rmap_unmap_error(cur, error, _RET_IP_);
@@ -2350,8 +2314,7 @@ xfs_rmap_map_shared(
        xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
        if (unwritten)
                flags |= XFS_RMAP_UNWRITTEN;
-       trace_xfs_rmap_map(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_map(cur, bno, len, unwritten, oinfo);
 
        /* Is there a left record that abuts our range? */
        error = xfs_rmap_find_left_neighbor(cur, bno, owner, offset, flags,
@@ -2376,10 +2339,10 @@ xfs_rmap_map_shared(
                        error = -EFSCORRUPTED;
                        goto out_error;
                }
-               trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
-                       cur->bc_ag.pag->pag_agno, gtrec.rm_startblock,
-                       gtrec.rm_blockcount, gtrec.rm_owner,
-                       gtrec.rm_offset, gtrec.rm_flags);
+               trace_xfs_rmap_find_right_neighbor_result(cur,
+                               gtrec.rm_startblock, gtrec.rm_blockcount,
+                               gtrec.rm_owner, gtrec.rm_offset,
+                               gtrec.rm_flags);
 
                if (!xfs_rmap_is_mergeable(&gtrec, owner, flags))
                        have_gt = 0;
@@ -2471,8 +2434,7 @@ xfs_rmap_map_shared(
                        goto out_error;
        }
 
-       trace_xfs_rmap_map_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
-                       unwritten, oinfo);
+       trace_xfs_rmap_map_done(cur, bno, len, unwritten, oinfo);
 out_error:
        if (error)
                trace_xfs_rmap_map_error(cur, error, _RET_IP_);