4 files changed, 10 insertions, 33 deletions

diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 16eda31fe797..0ce56d6a4922 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -1262,8 +1262,7 @@ xfs_dilocate(
 #endif /* DEBUG */
                 return XFS_ERROR(EINVAL);
         }
-        if ((mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) ||
-            !(flags & XFS_IMAP_LOOKUP)) {
+        if ((mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp))) {
                 offset = XFS_INO_TO_OFFSET(mp, ino);
                 ASSERT(offset < mp->m_sb.sb_inopblock);
                 *bno = XFS_AGB_TO_FSB(mp, agno, agbno);
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 1d5c28b144ae..663ff9e517fd 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -237,7 +237,7 @@ xfs_inotobp(
         int             error;
 
         imap.im_blkno = 0;
-        error = xfs_imap(mp, tp, ino, &imap, imap_flags | XFS_IMAP_LOOKUP);
+        error = xfs_imap(mp, tp, ino, &imap, imap_flags);
         if (error)
                 return error;
 
@@ -868,8 +868,7 @@ xfs_iread(
          * Get pointers to the on-disk inode and the buffer containing it.
          */
         imap.im_blkno = bno;
-        error = xfs_imap(mp, tp, ip->i_ino, &imap,
-                                XFS_IMAP_LOOKUP | imap_flags);
+        error = xfs_imap(mp, tp, ip->i_ino, &imap, imap_flags);
         if (error)
                 goto out_destroy_inode;
 
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index ec8b539439d3..db1f68840727 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -159,8 +159,7 @@ typedef struct xfs_icdinode {
 /*
  * Flags for xfs_inotobp, xfs_imap() and xfs_dilocate().
  */
-#define XFS_IMAP_LOOKUP         0x1
-#define XFS_IMAP_BULKSTAT       0x2
+#define XFS_IMAP_BULKSTAT       0x1
 
 /*
  * Fork handling.
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 48bdfa4dc290..bf8573b5a7d8 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2245,7 +2245,6 @@ xlog_recover_do_inode_trans(
         xfs_inode_log_format_t  *in_f;
         xfs_mount_t             *mp;
         xfs_buf_t               *bp;
-        xfs_imap_t              imap;
         xfs_dinode_t            *dip;
         xfs_ino_t               ino;
         int                     len;
@@ -2273,48 +2272,29 @@ xlog_recover_do_inode_trans(
         }
         ino = in_f->ilf_ino;
         mp = log->l_mp;
-        if (ITEM_TYPE(item) == XFS_LI_INODE) {
-                imap.im_blkno = (xfs_daddr_t)in_f->ilf_blkno;
-                imap.im_len = in_f->ilf_len;
-                imap.im_boffset = in_f->ilf_boffset;
-        } else {
-                /*
-                 * It's an old inode format record.  We don't know where
-                 * its cluster is located on disk, and we can't allow
-                 * xfs_imap() to figure it out because the inode btrees
-                 * are not ready to be used.  Therefore do not pass the
-                 * XFS_IMAP_LOOKUP flag to xfs_imap().  This will give
-                 * us only the single block in which the inode lives
-                 * rather than its cluster, so we must make sure to
-                 * invalidate the buffer when we write it out below.
-                 */
-                imap.im_blkno = 0;
-                error = xfs_imap(log->l_mp, NULL, ino, &imap, 0);
-                if (error)
-                        goto error;
-        }
 
         /*
          * Inode buffers can be freed, look out for it,
          * and do not replay the inode.
          */
-        if (xlog_check_buffer_cancelled(log, imap.im_blkno, imap.im_len, 0)) {
+        if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
+                                        in_f->ilf_len, 0)) {
                 error = 0;
                 goto error;
         }
 
-        bp = xfs_buf_read_flags(mp->m_ddev_targp, imap.im_blkno, imap.im_len,
-                                                                XFS_BUF_LOCK);
+        bp = xfs_buf_read_flags(mp->m_ddev_targp, in_f->ilf_blkno,
+                                in_f->ilf_len, XFS_BUF_LOCK);
         if (XFS_BUF_ISERROR(bp)) {
                 xfs_ioerror_alert("xlog_recover_do..(read#2)", mp,
-                                  bp, imap.im_blkno);
+                                  bp, in_f->ilf_blkno);
                 error = XFS_BUF_GETERROR(bp);
                 xfs_buf_relse(bp);
                 goto error;
         }
         error = 0;
         ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
-        dip = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
+        dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
 
         /*
          * Make sure the place we're flushing out to really looks