xfs: remove xfs_iread

There is not much point in the xfs_iread function, as it has a single
caller and not a whole lot of code.  Move it into the only caller,
and trim down the overdocumentation to just documenting the important
"why" instead of a lot of redundant "what".

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

diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 329534eebbdcca89f6b61696925d7863a98d1dc9..05f939adea9446bc1b806f063837e8075fa190f3 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -614,79 +614,6 @@ xfs_dinode_calc_crc(
        dip->di_crc = xfs_end_cksum(crc);
 }
 
-/*
- * Read the disk inode attributes into the in-core inode structure.
- *
- * For version 5 superblocks, if we are initialising a new inode and we are not
- * utilising the XFS_MOUNT_IKEEP inode cluster mode, we can simple build the new
- * inode core with a random generation number. If we are keeping inodes around,
- * we need to read the inode cluster to get the existing generation number off
- * disk. Further, if we are using version 4 superblocks (i.e. v1/v2 inode
- * format) then log recovery is dependent on the di_flushiter field being
- * initialised from the current on-disk value and hence we must also read the
- * inode off disk.
- */
-int
-xfs_iread(
-       xfs_mount_t     *mp,
-       xfs_trans_t     *tp,
-       xfs_inode_t     *ip,
-       uint            iget_flags)
-{
-       xfs_buf_t       *bp;
-       xfs_dinode_t    *dip;
-       int             error;
-
-       /*
-        * Fill in the location information in the in-core inode.
-        */
-       error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, iget_flags);
-       if (error)
-               return error;
-
-       /* shortcut IO on inode allocation if possible */
-       if ((iget_flags & XFS_IGET_CREATE) &&
-           xfs_sb_version_has_v3inode(&mp->m_sb) &&
-           !(mp->m_flags & XFS_MOUNT_IKEEP)) {
-               VFS_I(ip)->i_generation = prandom_u32();
-               return 0;
-       }
-
-       /*
-        * Get pointers to the on-disk inode and the buffer containing it.
-        */
-       error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &bp, 0);
-       if (error)
-               return error;
-
-       error = xfs_inode_from_disk(ip, dip);
-       if (error)
-               goto out_brelse;
-
-       /*
-        * Mark the buffer containing the inode as something to keep
-        * around for a while.  This helps to keep recently accessed
-        * meta-data in-core longer.
-        */
-       xfs_buf_set_ref(bp, XFS_INO_REF);
-
-       /*
-        * Use xfs_trans_brelse() to release the buffer containing the on-disk
-        * inode, because it was acquired with xfs_trans_read_buf() in
-        * xfs_imap_to_bp() above.  If tp is NULL, this is just a normal
-        * brelse().  If we're within a transaction, then xfs_trans_brelse()
-        * will only release the buffer if it is not dirty within the
-        * transaction.  It will be OK to release the buffer in this case,
-        * because inodes on disk are never destroyed and we will be locking the
-        * new in-core inode before putting it in the cache where other
-        * processes can find it.  Thus we don't have to worry about the inode
-        * being changed just because we released the buffer.
-        */
- out_brelse:
-       xfs_trans_brelse(tp, bp);
-       return error;
-}
-
 /*
  * Validate di_extsize hint.
  *

diff --git a/fs/xfs/libxfs/xfs_inode_buf.h b/fs/xfs/libxfs/xfs_inode_buf.h
index 0fbb99224ec73a09f4c79a0eca06a9bef226fe9f..e4cbcaf62a32b7ddf0a8a4202ae3d5f3e6ecc747 100644 (file)
--- a/fs/xfs/libxfs/xfs_inode_buf.h
+++ b/fs/xfs/libxfs/xfs_inode_buf.h
@@ -49,8 +49,6 @@ struct xfs_imap {
 int    xfs_imap_to_bp(struct xfs_mount *, struct xfs_trans *,
                       struct xfs_imap *, struct xfs_dinode **,
                       struct xfs_buf **, uint);
-int    xfs_iread(struct xfs_mount *, struct xfs_trans *,
-                 struct xfs_inode *, uint);
 void   xfs_dinode_calc_crc(struct xfs_mount *, struct xfs_dinode *);
 void   xfs_inode_to_disk(struct xfs_inode *ip, struct xfs_dinode *to,
                          xfs_lsn_t lsn);

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 922a29032e374406cc18f1b736f97d0dcd3d434a..af5748f5d927111c538541d1bd5c6c5957367c79 100644 (file)
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -22,6 +22,7 @@
 #include "xfs_dquot_item.h"
 #include "xfs_dquot.h"
 #include "xfs_reflink.h"
+#include "xfs_ialloc.h"
 
 #include <linux/iversion.h>
 
@@ -508,10 +509,40 @@ xfs_iget_cache_miss(
        if (!ip)
                return -ENOMEM;
 
-       error = xfs_iread(mp, tp, ip, flags);
+       error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, flags);
        if (error)
                goto out_destroy;
 
+       /*
+        * For version 5 superblocks, if we are initialising a new inode and we
+        * are not utilising the XFS_MOUNT_IKEEP inode cluster mode, we can
+        * simply build the new inode core with a random generation number.
+        *
+        * For version 4 (and older) superblocks, log recovery is dependent on
+        * the di_flushiter field being initialised from the current on-disk
+        * value and hence we must also read the inode off disk even when
+        * initializing new inodes.
+        */
+       if (xfs_sb_version_has_v3inode(&mp->m_sb) &&
+           (flags & XFS_IGET_CREATE) && !(mp->m_flags & XFS_MOUNT_IKEEP)) {
+               VFS_I(ip)->i_generation = prandom_u32();
+       } else {
+               struct xfs_dinode       *dip;
+               struct xfs_buf          *bp;
+
+               error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &dip, &bp, 0);
+               if (error)
+                       goto out_destroy;
+
+               error = xfs_inode_from_disk(ip, dip);
+               if (!error)
+                       xfs_buf_set_ref(bp, XFS_INO_REF);
+               xfs_trans_brelse(tp, bp);
+
+               if (error)
+                       goto out_destroy;
+       }
+
        if (!xfs_inode_verify_forks(ip)) {
                error = -EFSCORRUPTED;
                goto out_destroy;