xfs: remove unnecessary int returns from deferred refcount functions

Remove the return value from the functions that schedule deferred
refcount operations since they never fail and do not return status.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

5 files changed, 36 insertions, 61 deletions

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index e82a3ff345af..fca226ce78fc 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -4393,12 +4393,9 @@ xfs_bmapi_write(
                          * If this is a CoW allocation, record the data in
                          * the refcount btree for orphan recovery.
                          */
-                        if (whichfork == XFS_COW_FORK) {
-                                error = xfs_refcount_alloc_cow_extent(tp,
-                                                bma.blkno, bma.length);
-                                if (error)
-                                        goto error0;
-                        }
+                        if (whichfork == XFS_COW_FORK)
+                                xfs_refcount_alloc_cow_extent(tp, bma.blkno,
+                                                bma.length);
                 }
 
                 /* Deal with the allocated space we found.  */
@@ -4532,12 +4529,8 @@ xfs_bmapi_convert_delalloc(
         *imap = bma.got;
         *seq = READ_ONCE(ifp->if_seq);
 
-        if (whichfork == XFS_COW_FORK) {
-                error = xfs_refcount_alloc_cow_extent(tp, bma.blkno,
-                                bma.length);
-                if (error)
-                        goto out_finish;
-        }
+        if (whichfork == XFS_COW_FORK)
+                xfs_refcount_alloc_cow_extent(tp, bma.blkno, bma.length);
 
         error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
                         whichfork);
@@ -5148,9 +5141,7 @@ xfs_bmap_del_extent_real(
          */
         if (do_fx && !(bflags & XFS_BMAPI_REMAP)) {
                 if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
-                        error = xfs_refcount_decrease_extent(tp, del);
-                        if (error)
-                                goto done;
+                        xfs_refcount_decrease_extent(tp, del);
                 } else {
                         __xfs_bmap_add_free(tp, del->br_startblock,
                                         del->br_blockcount, NULL,
diff --git a/fs/xfs/libxfs/xfs_refcount.c b/fs/xfs/libxfs/xfs_refcount.c
index a5edac834843..9a7fadb1361c 100644
--- a/fs/xfs/libxfs/xfs_refcount.c
+++ b/fs/xfs/libxfs/xfs_refcount.c
@@ -1174,7 +1174,7 @@ out_cur:
 /*
  * Record a refcount intent for later processing.
  */
-static int
+static void
 __xfs_refcount_add(
         struct xfs_trans                *tp,
         enum xfs_refcount_intent_type   type,
@@ -1196,37 +1196,36 @@ __xfs_refcount_add(
         ri->ri_blockcount = blockcount;
 
         xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_REFCOUNT, &ri->ri_list);
-        return 0;
 }
 
 /*
  * Increase the reference count of the blocks backing a file's extent.
  */
-int
+void
 xfs_refcount_increase_extent(
         struct xfs_trans                *tp,
         struct xfs_bmbt_irec            *PREV)
 {
         if (!xfs_sb_version_hasreflink(&tp->t_mountp->m_sb))
-                return 0;
+                return;
 
-        return __xfs_refcount_add(tp, XFS_REFCOUNT_INCREASE,
-                        PREV->br_startblock, PREV->br_blockcount);
+        __xfs_refcount_add(tp, XFS_REFCOUNT_INCREASE, PREV->br_startblock,
+                        PREV->br_blockcount);
 }
 
 /*
  * Decrease the reference count of the blocks backing a file's extent.
  */
-int
+void
 xfs_refcount_decrease_extent(
         struct xfs_trans                *tp,
         struct xfs_bmbt_irec            *PREV)
 {
         if (!xfs_sb_version_hasreflink(&tp->t_mountp->m_sb))
-                return 0;
+                return;
 
-        return __xfs_refcount_add(tp, XFS_REFCOUNT_DECREASE,
-                        PREV->br_startblock, PREV->br_blockcount);
+        __xfs_refcount_add(tp, XFS_REFCOUNT_DECREASE, PREV->br_startblock,
+                        PREV->br_blockcount);
 }
 
 /*
@@ -1541,30 +1540,26 @@ __xfs_refcount_cow_free(
 }
 
 /* Record a CoW staging extent in the refcount btree. */
-int
+void
 xfs_refcount_alloc_cow_extent(
         struct xfs_trans                *tp,
         xfs_fsblock_t                   fsb,
         xfs_extlen_t                    len)
 {
         struct xfs_mount                *mp = tp->t_mountp;
-        int                             error;
 
         if (!xfs_sb_version_hasreflink(&mp->m_sb))
-                return 0;
+                return;
 
-        error = __xfs_refcount_add(tp, XFS_REFCOUNT_ALLOC_COW, fsb, len);
-        if (error)
-                return error;
+        __xfs_refcount_add(tp, XFS_REFCOUNT_ALLOC_COW, fsb, len);
 
         /* Add rmap entry */
         xfs_rmap_alloc_extent(tp, XFS_FSB_TO_AGNO(mp, fsb),
                         XFS_FSB_TO_AGBNO(mp, fsb), len, XFS_RMAP_OWN_COW);
-        return 0;
 }
 
 /* Forget a CoW staging event in the refcount btree. */
-int
+void
 xfs_refcount_free_cow_extent(
         struct xfs_trans                *tp,
         xfs_fsblock_t                   fsb,
@@ -1573,12 +1568,12 @@ xfs_refcount_free_cow_extent(
         struct xfs_mount                *mp = tp->t_mountp;
 
         if (!xfs_sb_version_hasreflink(&mp->m_sb))
-                return 0;
+                return;
 
         /* Remove rmap entry */
         xfs_rmap_free_extent(tp, XFS_FSB_TO_AGNO(mp, fsb),
                         XFS_FSB_TO_AGBNO(mp, fsb), len, XFS_RMAP_OWN_COW);
-        return __xfs_refcount_add(tp, XFS_REFCOUNT_FREE_COW, fsb, len);
+        __xfs_refcount_add(tp, XFS_REFCOUNT_FREE_COW, fsb, len);
 }
 
 struct xfs_refcount_recovery {
@@ -1676,10 +1671,8 @@ xfs_refcount_recover_cow_leftovers(
                 /* Free the orphan record */
                 agbno = rr->rr_rrec.rc_startblock - XFS_REFC_COW_START;
                 fsb = XFS_AGB_TO_FSB(mp, agno, agbno);
-                error = xfs_refcount_free_cow_extent(tp, fsb,
+                xfs_refcount_free_cow_extent(tp, fsb,
                                 rr->rr_rrec.rc_blockcount);
-                if (error)
-                        goto out_trans;
 
                 /* Free the block. */
                 xfs_bmap_add_free(tp, fsb, rr->rr_rrec.rc_blockcount, NULL);
diff --git a/fs/xfs/libxfs/xfs_refcount.h b/fs/xfs/libxfs/xfs_refcount.h
index 1d9c518575e7..209795539c8d 100644
--- a/fs/xfs/libxfs/xfs_refcount.h
+++ b/fs/xfs/libxfs/xfs_refcount.h
@@ -29,9 +29,9 @@ struct xfs_refcount_intent {
         xfs_extlen_t                            ri_blockcount;
 };
 
-extern int xfs_refcount_increase_extent(struct xfs_trans *tp,
+void xfs_refcount_increase_extent(struct xfs_trans *tp,
                 struct xfs_bmbt_irec *irec);
-extern int xfs_refcount_decrease_extent(struct xfs_trans *tp,
+void xfs_refcount_decrease_extent(struct xfs_trans *tp,
                 struct xfs_bmbt_irec *irec);
 
 extern void xfs_refcount_finish_one_cleanup(struct xfs_trans *tp,
@@ -45,10 +45,10 @@ extern int xfs_refcount_find_shared(struct xfs_btree_cur *cur,
                 xfs_agblock_t agbno, xfs_extlen_t aglen, xfs_agblock_t *fbno,
                 xfs_extlen_t *flen, bool find_end_of_shared);
 
-extern int xfs_refcount_alloc_cow_extent(struct xfs_trans *tp,
-                xfs_fsblock_t fsb, xfs_extlen_t len);
-extern int xfs_refcount_free_cow_extent(struct xfs_trans *tp,
-                xfs_fsblock_t fsb, xfs_extlen_t len);
+void xfs_refcount_alloc_cow_extent(struct xfs_trans *tp, xfs_fsblock_t fsb,
+                xfs_extlen_t len);
+void xfs_refcount_free_cow_extent(struct xfs_trans *tp, xfs_fsblock_t fsb,
+                xfs_extlen_t len);
 extern int xfs_refcount_recover_cow_leftovers(struct xfs_mount *mp,
                 xfs_agnumber_t agno);
 
diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c
index db0e0d7cffb7..2328268e6245 100644
--- a/fs/xfs/xfs_refcount_item.c
+++ b/fs/xfs/xfs_refcount_item.c
@@ -555,26 +555,24 @@ xfs_cui_recover(
                         irec.br_blockcount = new_len;
                         switch (type) {
                         case XFS_REFCOUNT_INCREASE:
-                                error = xfs_refcount_increase_extent(tp, &irec);
+                                xfs_refcount_increase_extent(tp, &irec);
                                 break;
                         case XFS_REFCOUNT_DECREASE:
-                                error = xfs_refcount_decrease_extent(tp, &irec);
+                                xfs_refcount_decrease_extent(tp, &irec);
                                 break;
                         case XFS_REFCOUNT_ALLOC_COW:
-                                error = xfs_refcount_alloc_cow_extent(tp,
+                                xfs_refcount_alloc_cow_extent(tp,
                                                 irec.br_startblock,
                                                 irec.br_blockcount);
                                 break;
                         case XFS_REFCOUNT_FREE_COW:
-                                error = xfs_refcount_free_cow_extent(tp,
+                                xfs_refcount_free_cow_extent(tp,
                                                 irec.br_startblock,
                                                 irec.br_blockcount);
                                 break;
                         default:
                                 ASSERT(0);
                         }
-                        if (error)
-                                goto abort_error;
                         requeue_only = true;
                 }
         }
diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
index edbe37b7f636..eae128ea0c12 100644
--- a/fs/xfs/xfs_reflink.c
+++ b/fs/xfs/xfs_reflink.c
@@ -495,10 +495,8 @@ xfs_reflink_cancel_cow_blocks(
                         ASSERT((*tpp)->t_firstblock == NULLFSBLOCK);
 
                         /* Free the CoW orphan record. */
-                        error = xfs_refcount_free_cow_extent(*tpp,
-                                        del.br_startblock, del.br_blockcount);
-                        if (error)
-                                break;
+                        xfs_refcount_free_cow_extent(*tpp, del.br_startblock,
+                                        del.br_blockcount);
 
                         xfs_bmap_add_free(*tpp, del.br_startblock,
                                           del.br_blockcount, NULL);
@@ -675,10 +673,7 @@ xfs_reflink_end_cow_extent(
         trace_xfs_reflink_cow_remap(ip, &del);
 
         /* Free the CoW orphan record. */
-        error = xfs_refcount_free_cow_extent(tp, del.br_startblock,
-                        del.br_blockcount);
-        if (error)
-                goto out_cancel;
+        xfs_refcount_free_cow_extent(tp, del.br_startblock, del.br_blockcount);
 
         /* Map the new blocks into the data fork. */
         error = xfs_bmap_map_extent(tp, ip, &del);
@@ -1070,9 +1065,7 @@ xfs_reflink_remap_extent(
                                 uirec.br_blockcount, uirec.br_startblock);
 
                 /* Update the refcount tree */
-                error = xfs_refcount_increase_extent(tp, &uirec);
-                if (error)
-                        goto out_cancel;
+                xfs_refcount_increase_extent(tp, &uirec);
 
                 /* Map the new blocks into the data fork. */
                 error = xfs_bmap_map_extent(tp, ip, &uirec);