xfs: refactor unlinked list search and mapping to a separate function

There's a loop that searches an unlinked bucket list to find the inode
that points to a given inode.  Hoist this into a separate function;
later we'll use our iunlink backref cache to bypass the slow list
operation.  No functional changes.

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

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index eb51fa33f91a7fdd1e781ab8012b4c4e1cad7f4c..d4610eee7172efc1fd35ac0c6c3579e80e767c4b 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2082,6 +2082,97 @@ xfs_iunlink(
        return xfs_iunlink_update_bucket(tp, agno, agibp, bucket_index, agino);
 }
 
+/* Return the imap, dinode pointer, and buffer for an inode. */
+STATIC int
+xfs_iunlink_map_ino(
+       struct xfs_trans        *tp,
+       xfs_agnumber_t          agno,
+       xfs_agino_t             agino,
+       struct xfs_imap         *imap,
+       struct xfs_dinode       **dipp,
+       struct xfs_buf          **bpp)
+{
+       struct xfs_mount        *mp = tp->t_mountp;
+       int                     error;
+
+       imap->im_blkno = 0;
+       error = xfs_imap(mp, tp, XFS_AGINO_TO_INO(mp, agno, agino), imap, 0);
+       if (error) {
+               xfs_warn(mp, "%s: xfs_imap returned error %d.",
+                               __func__, error);
+               return error;
+       }
+
+       error = xfs_imap_to_bp(mp, tp, imap, dipp, bpp, 0, 0);
+       if (error) {
+               xfs_warn(mp, "%s: xfs_imap_to_bp returned error %d.",
+                               __func__, error);
+               return error;
+       }
+
+       return 0;
+}
+
+/*
+ * Walk the unlinked chain from @head_agino until we find the inode that
+ * points to @target_agino.  Return the inode number, map, dinode pointer,
+ * and inode cluster buffer of that inode as @agino, @imap, @dipp, and @bpp.
+ *
+ * @tp, @pag, @head_agino, and @target_agino are input parameters.
+ * @agino, @imap, @dipp, and @bpp are all output parameters.
+ *
+ * Do not call this function if @target_agino is the head of the list.
+ */
+STATIC int
+xfs_iunlink_map_prev(
+       struct xfs_trans        *tp,
+       xfs_agnumber_t          agno,
+       xfs_agino_t             head_agino,
+       xfs_agino_t             target_agino,
+       xfs_agino_t             *agino,
+       struct xfs_imap         *imap,
+       struct xfs_dinode       **dipp,
+       struct xfs_buf          **bpp)
+{
+       struct xfs_mount        *mp = tp->t_mountp;
+       xfs_agino_t             next_agino;
+       int                     error;
+
+       ASSERT(head_agino != target_agino);
+       *bpp = NULL;
+
+       next_agino = head_agino;
+       while (next_agino != target_agino) {
+               xfs_agino_t     unlinked_agino;
+
+               if (*bpp)
+                       xfs_trans_brelse(tp, *bpp);
+
+               *agino = next_agino;
+               error = xfs_iunlink_map_ino(tp, agno, next_agino, imap, dipp,
+                               bpp);
+               if (error)
+                       return error;
+
+               unlinked_agino = be32_to_cpu((*dipp)->di_next_unlinked);
+               /*
+                * Make sure this pointer is valid and isn't an obvious
+                * infinite loop.
+                */
+               if (!xfs_verify_agino(mp, agno, unlinked_agino) ||
+                   next_agino == unlinked_agino) {
+                       XFS_CORRUPTION_ERROR(__func__,
+                                       XFS_ERRLEVEL_LOW, mp,
+                                       *dipp, sizeof(**dipp));
+                       error = -EFSCORRUPTED;
+                       return error;
+               }
+               next_agino = unlinked_agino;
+       }
+
+       return 0;
+}
+
 /*
  * Pull the on-disk inode from the AGI unlinked list.
  */
@@ -2095,7 +2186,6 @@ xfs_iunlink_remove(
        struct xfs_buf          *agibp;
        struct xfs_buf          *last_ibp;
        struct xfs_dinode       *last_dip = NULL;
-       xfs_ino_t               next_ino;
        xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
        xfs_agino_t             agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
        xfs_agino_t             next_agino;
@@ -2138,43 +2228,11 @@ xfs_iunlink_remove(
                struct xfs_imap imap;
                xfs_agino_t     prev_agino;
 
-               /*
-                * We need to search the list for the inode being freed.
-                */
-               last_ibp = NULL;
-               while (next_agino != agino) {
-                       if (last_ibp)
-                               xfs_trans_brelse(tp, last_ibp);
-
-                       imap.im_blkno = 0;
-                       next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
-
-                       error = xfs_imap(mp, tp, next_ino, &imap, 0);
-                       if (error) {
-                               xfs_warn(mp,
-       "%s: xfs_imap returned error %d.",
-                                        __func__, error);
-                               return error;
-                       }
-
-                       error = xfs_imap_to_bp(mp, tp, &imap, &last_dip,
-                                              &last_ibp, 0, 0);
-                       if (error) {
-                               xfs_warn(mp,
-       "%s: xfs_imap_to_bp returned error %d.",
-                                       __func__, error);
-                               return error;
-                       }
-
-                       prev_agino = next_agino;
-                       next_agino = be32_to_cpu(last_dip->di_next_unlinked);
-                       if (!xfs_verify_agino(mp, agno, next_agino)) {
-                               XFS_CORRUPTION_ERROR(__func__,
-                                               XFS_ERRLEVEL_LOW, mp,
-                                               last_dip, sizeof(*last_dip));
-                               return -EFSCORRUPTED;
-                       }
-               }
+               /* We need to search the list for the inode being freed. */
+               error = xfs_iunlink_map_prev(tp, agno, next_agino, agino,
+                               &prev_agino, &imap, &last_dip, &last_ibp);
+               if (error)
+                       return error;
 
                /*
                 * Now last_ibp points to the buffer previous to us on the