xfs: make xfs_trans_get_buf return an error code

Convert xfs_trans_get_buf() to return numeric error codes like most
everywhere else in xfs.

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

diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index b22c7e928eb1cf7481bc43cfad728b924cec2a1e..2d53e5fdff70e47a544fdcc5005577f9ea1317d5 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -688,11 +688,16 @@ xfs_btree_get_bufl(
        xfs_trans_t     *tp,            /* transaction pointer */
        xfs_fsblock_t   fsbno)          /* file system block number */
 {
+       struct xfs_buf          *bp;
        xfs_daddr_t             d;              /* real disk block address */
+       int                     error;
 
        ASSERT(fsbno != NULLFSBLOCK);
        d = XFS_FSB_TO_DADDR(mp, fsbno);
-       return xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, 0);
+       error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, 0, &bp);
+       if (error)
+               return NULL;
+       return bp;
 }
 
 /*
@@ -706,12 +711,17 @@ xfs_btree_get_bufs(
        xfs_agnumber_t  agno,           /* allocation group number */
        xfs_agblock_t   agbno)          /* allocation group block number */
 {
+       struct xfs_buf          *bp;
        xfs_daddr_t             d;              /* real disk block address */
+       int                     error;
 
        ASSERT(agno != NULLAGNUMBER);
        ASSERT(agbno != NULLAGBLOCK);
        d = XFS_AGB_TO_DADDR(mp, agno, agbno);
-       return xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, 0);
+       error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, 0, &bp);
+       if (error)
+               return NULL;
+       return bp;
 }
 
 /*
@@ -1270,11 +1280,10 @@ xfs_btree_get_buf_block(
        error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
        if (error)
                return error;
-       *bpp = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d,
-                                mp->m_bsize, 0);
-
-       if (!*bpp)
-               return -ENOMEM;
+       error = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d, mp->m_bsize,
+                       0, bpp);
+       if (error)
+               return error;
 
        (*bpp)->b_ops = cur->bc_ops->buf_ops;
        *block = XFS_BUF_TO_BLOCK(*bpp);

diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 5b759af4d1652af97cc5870b68184d741e6401ae..bf161e930f1d5b6fed6d3a77cd7a4d296cfad8c8 100644 (file)
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -276,6 +276,7 @@ xfs_ialloc_inode_init(
        int                     i, j;
        xfs_daddr_t             d;
        xfs_ino_t               ino = 0;
+       int                     error;
 
        /*
         * Loop over the new block(s), filling in the inodes.  For small block
@@ -327,12 +328,11 @@ xfs_ialloc_inode_init(
                 */
                d = XFS_AGB_TO_DADDR(mp, agno, agbno +
                                (j * M_IGEO(mp)->blocks_per_cluster));
-               fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
-                                        mp->m_bsize *
-                                        M_IGEO(mp)->blocks_per_cluster,
-                                        XBF_UNMAPPED);
-               if (!fbuf)
-                       return -ENOMEM;
+               error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
+                               mp->m_bsize * M_IGEO(mp)->blocks_per_cluster,
+                               XBF_UNMAPPED, &fbuf);
+               if (error)
+                       return error;
 
                /* Initialize the inode buffers and log them appropriately. */
                fbuf->b_ops = &xfs_inode_buf_ops;

diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 6fdd007f81ab68679ae71cb9da62eb5df7342c18..2f60fc3c99a0fa378c3148f9fd883402a40510ac 100644 (file)
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -1185,13 +1185,14 @@ xfs_sb_get_secondary(
        struct xfs_buf          **bpp)
 {
        struct xfs_buf          *bp;
+       int                     error;
 
        ASSERT(agno != 0 && agno != NULLAGNUMBER);
-       bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
+       error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
                        XFS_AG_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
-                       XFS_FSS_TO_BB(mp, 1), 0);
-       if (!bp)
-               return -ENOMEM;
+                       XFS_FSS_TO_BB(mp, 1), 0, &bp);
+       if (error)
+               return error;
        bp->b_ops = &xfs_sb_buf_ops;
        xfs_buf_oneshot(bp);
        *bpp = bp;

diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
index b70a88bc975ebfa524b5a42f8a80b001d2a288aa..3df49d487940f8a527924e870263cee8b119cedf 100644 (file)
--- a/fs/xfs/scrub/repair.c
+++ b/fs/xfs/scrub/repair.c
@@ -341,13 +341,17 @@ xrep_init_btblock(
        struct xfs_trans                *tp = sc->tp;
        struct xfs_mount                *mp = sc->mp;
        struct xfs_buf                  *bp;
+       int                             error;
 
        trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),
                        XFS_FSB_TO_AGBNO(mp, fsb), btnum);
 
        ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.agno);
-       bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, XFS_FSB_TO_DADDR(mp, fsb),
-                       XFS_FSB_TO_BB(mp, 1), 0);
+       error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
+                       XFS_FSB_TO_DADDR(mp, fsb), XFS_FSB_TO_BB(mp, 1), 0,
+                       &bp);
+       if (error)
+               return error;
        xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
        xfs_btree_init_block(mp, bp, btnum, 0, 0, sc->sa.agno);
        xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF);

diff --git a/fs/xfs/xfs_attr_inactive.c b/fs/xfs/xfs_attr_inactive.c
index 8fbb841cd6fee2b550ff9209e2ca8f481d694d3c..bbfa6ba84dcd72fc6332747856e520da87dbeb23 100644 (file)
--- a/fs/xfs/xfs_attr_inactive.c
+++ b/fs/xfs/xfs_attr_inactive.c
@@ -205,11 +205,12 @@ xfs_attr3_node_inactive(
                /*
                 * Remove the subsidiary block from the cache and from the log.
                 */
-               child_bp = xfs_trans_get_buf(*trans, mp->m_ddev_targp,
+               error = xfs_trans_get_buf(*trans, mp->m_ddev_targp,
                                child_blkno,
-                               XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0);
-               if (!child_bp)
-                       return -EIO;
+                               XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0,
+                               &child_bp);
+               if (error)
+                       return error;
                error = bp->b_error;
                if (error) {
                        xfs_trans_brelse(*trans, child_bp);
@@ -298,10 +299,10 @@ xfs_attr3_root_inactive(
        /*
         * Invalidate the incore copy of the root block.
         */
-       bp = xfs_trans_get_buf(*trans, mp->m_ddev_targp, blkno,
-                       XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0);
-       if (!bp)
-               return -EIO;
+       error = xfs_trans_get_buf(*trans, mp->m_ddev_targp, blkno,
+                       XFS_FSB_TO_BB(mp, mp->m_attr_geo->fsbcount), 0, &bp);
+       if (error)
+               return error;
        error = bp->b_error;
        if (error) {
                xfs_trans_brelse(*trans, bp);

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 9cfd3209f52b9c15c815e7ba8c68f71fa0d4a1f9..d223e1ae90a65de4e6a3b26c97c258efc2ebe1ff 100644 (file)
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -320,10 +320,10 @@ xfs_dquot_disk_alloc(
        dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
 
        /* now we can just get the buffer (there's nothing to read yet) */
-       bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, dqp->q_blkno,
-                       mp->m_quotainfo->qi_dqchunklen, 0);
-       if (!bp)
-               return -ENOMEM;
+       error = xfs_trans_get_buf(tp, mp->m_ddev_targp, dqp->q_blkno,
+                       mp->m_quotainfo->qi_dqchunklen, 0, &bp);
+       if (error)
+               return error;
        bp->b_ops = &xfs_dquot_buf_ops;
 
        /*

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 1979a0055763718c64d4dafb035463efb97b1034..c5077e6326c7093d5d1230ece91b37c5bb4d1f53 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2546,6 +2546,7 @@ xfs_ifree_cluster(
        struct xfs_perag        *pag;
        struct xfs_ino_geometry *igeo = M_IGEO(mp);
        xfs_ino_t               inum;
+       int                     error;
 
        inum = xic->first_ino;
        pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
@@ -2574,12 +2575,11 @@ xfs_ifree_cluster(
                 * complete before we get a lock on it, and hence we may fail
                 * to mark all the active inodes on the buffer stale.
                 */
-               bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
-                                       mp->m_bsize * igeo->blocks_per_cluster,
-                                       XBF_UNMAPPED);
-
-               if (!bp)
-                       return -ENOMEM;
+               error = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
+                               mp->m_bsize * igeo->blocks_per_cluster,
+                               XBF_UNMAPPED, &bp);
+               if (error)
+                       return error;
 
                /*
                 * This buffer may not have been correctly initialised as we

diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index d42b5a2047e03bfcb902f284e06cbc97b69f7b84..6209e7b6b895b8f21786bc4f1b826d50a9ed47fb 100644 (file)
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -826,12 +826,10 @@ xfs_growfs_rt_alloc(
                         * Get a buffer for the block.
                         */
                        d = XFS_FSB_TO_DADDR(mp, fsbno);
-                       bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
-                               mp->m_bsize, 0);
-                       if (bp == NULL) {
-                               error = -EIO;
+                       error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
+                                       mp->m_bsize, 0, &bp);
+                       if (error)
                                goto out_trans_cancel;
-                       }
                        memset(bp->b_addr, 0, mp->m_sb.sb_blocksize);
                        xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
                        /*

diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index b94d7b9b55d0cfca1e30ba1a8b2156c8777e97ed..d762d42ed0ff976aa0e276c3688a114c1354fdc9 100644 (file)
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -280,12 +280,10 @@ xfs_symlink(
 
                        d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
                        byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
-                       bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
-                                              BTOBB(byte_cnt), 0);
-                       if (!bp) {
-                               error = -ENOMEM;
+                       error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
+                                              BTOBB(byte_cnt), 0, &bp);
+                       if (error)
                                goto out_trans_cancel;
-                       }
                        bp->b_ops = &xfs_symlink_buf_ops;
 
                        byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
@@ -423,13 +421,12 @@ xfs_inactive_symlink_rmt(
         * Invalidate the block(s). No validation is done.
         */
        for (i = 0; i < nmaps; i++) {
-               bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
-                       XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
-                       XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
-               if (!bp) {
-                       error = -ENOMEM;
+               error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
+                               XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
+                               XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0,
+                               &bp);
+               if (error)
                        goto error_trans_cancel;
-               }
                xfs_trans_binval(tp, bp);
        }
        /*

diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index a0be934ec8118d6e50a8bee6630c6acac61a11b4..752c7fef9de75c52a2776f28b43af10ab36d3040 100644 (file)
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -173,22 +173,17 @@ int xfs_trans_get_buf_map(struct xfs_trans *tp, struct xfs_buftarg *target,
                struct xfs_buf_map *map, int nmaps, xfs_buf_flags_t flags,
                struct xfs_buf **bpp);
 
-static inline struct xfs_buf *
+static inline int
 xfs_trans_get_buf(
        struct xfs_trans        *tp,
        struct xfs_buftarg      *target,
        xfs_daddr_t             blkno,
        int                     numblks,
-       uint                    flags)
+       uint                    flags,
+       struct xfs_buf          **bpp)
 {
-       struct xfs_buf          *bp;
-       int                     error;
-
        DEFINE_SINGLE_BUF_MAP(map, blkno, numblks);
-       error = xfs_trans_get_buf_map(tp, target, &map, 1, flags, &bp);
-       if (error)
-               return NULL;
-       return bp;
+       return xfs_trans_get_buf_map(tp, target, &map, 1, flags, bpp);
 }
 
 int            xfs_trans_read_buf_map(struct xfs_mount *mp,