[XFS] kill xfs_get_dir_entry

Instead of of xfs_get_dir_entry use a macro to get the xfs_inode from the
dentry in the callers and grab the reference manually.

Only grab the reference once as it's fine to keep it over the dmapi calls.
(And even that reference is actually superflous in Linux but I'll leave
that for another patch)

SGI-PV: 976035
SGI-Modid: xfs-linux-melb:xfs-kern:30531a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>

diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index f200e02440827d8e4beb925b4dd18ee81560abb9..2022318282831cfab9d6b5bc45c9bf1b33a19701 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -227,7 +227,7 @@ static inline bhv_vnode_t *vn_grab(bhv_vnode_t *vp)
  */
 #define VNAME(dentry)          ((char *) (dentry)->d_name.name)
 #define VNAMELEN(dentry)       ((dentry)->d_name.len)
-#define VNAME_TO_VNODE(dentry) (vn_from_inode((dentry)->d_inode))
+#define VNAME_TO_INODE(dentry) (XFS_I((dentry)->d_inode))
 
 /*
  * Dealing with bad inodes

diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index 1c6d40ed6816b51dd78df0bd0115fb7b4f05d01b..fd1244cf50a7b16a66dd8992a2daac473ea3c691 100644 (file)
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -93,7 +93,8 @@ xfs_lock_for_rename(
        xfs_inode_t     **i_tab,/* array of inode returned, sorted */
        int             *num_inodes)  /* number of inodes in array */
 {
-       xfs_inode_t             *ip1, *ip2, *temp;
+       xfs_inode_t             *ip1 = VNAME_TO_INODE(vname1);
+       xfs_inode_t             *ip2, *temp;
        xfs_ino_t               inum1, inum2;
        int                     error;
        int                     i, j;
@@ -109,16 +110,11 @@ xfs_lock_for_rename(
         * to see if we still have the right inodes, directories, etc.
         */
        lock_mode = xfs_ilock_map_shared(dp1);
-       error = xfs_get_dir_entry(vname1, &ip1);
-       if (error) {
-               xfs_iunlock_map_shared(dp1, lock_mode);
-               return error;
-       }
+       IHOLD(ip1);
+       xfs_itrace_ref(ip1);
 
        inum1 = ip1->i_ino;
 
-       ASSERT(ip1);
-       xfs_itrace_ref(ip1);
 
        /*
         * Unlock dp1 and lock dp2 if they are different.

diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 18a85e7466802ff3b0341006a38d5852d4f4e3e4..47c45ff4a067fa2deb2405cb7db3ee660590c9f1 100644 (file)
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -40,28 +40,6 @@
 #include "xfs_itable.h"
 #include "xfs_utils.h"
 
-/*
- * xfs_get_dir_entry is used to get a reference to an inode given
- * its parent directory inode and the name of the file.         It does
- * not lock the child inode, and it unlocks the directory before
- * returning.  The directory's generation number is returned for
- * use by a later call to xfs_lock_dir_and_entry.
- */
-int
-xfs_get_dir_entry(
-       bhv_vname_t     *dentry,
-       xfs_inode_t     **ipp)
-{
-       bhv_vnode_t     *vp;
-
-       vp = VNAME_TO_VNODE(dentry);
-
-       *ipp = xfs_vtoi(vp);
-       if (!*ipp)
-               return XFS_ERROR(ENOENT);
-       VN_HOLD(vp);
-       return 0;
-}
 
 int
 xfs_dir_lookup_int(

diff --git a/fs/xfs/xfs_utils.h b/fs/xfs/xfs_utils.h
index f857fcccb723ca75373be0e2524d201e74074060..c4c4a6aa65490c1d4a0f55cc11b3d69a4120b99f 100644 (file)
--- a/fs/xfs/xfs_utils.h
+++ b/fs/xfs/xfs_utils.h
@@ -21,7 +21,6 @@
 #define IRELE(ip)      VN_RELE(XFS_ITOV(ip))
 #define IHOLD(ip)      VN_HOLD(XFS_ITOV(ip))
 
-extern int xfs_get_dir_entry (bhv_vname_t *, xfs_inode_t **);
 extern int xfs_dir_lookup_int (xfs_inode_t *, uint, bhv_vname_t *, xfs_ino_t *,
                                xfs_inode_t **);
 extern int xfs_truncate_file (xfs_mount_t *, xfs_inode_t *);

diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 5390d124ad35a84caa2f8cf053b577f11001c088..4765e7c4b75d7155cdbfbd4077c79a22eb4674d4 100644 (file)
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -2270,41 +2270,30 @@ xfs_remove(
        bhv_vnode_t             *dir_vp = XFS_ITOV(dp);
        char                    *name = VNAME(dentry);
        xfs_mount_t             *mp = dp->i_mount;
-       xfs_inode_t             *ip;
+       xfs_inode_t             *ip = VNAME_TO_INODE(dentry);
+       int                     namelen = VNAMELEN(dentry);
        xfs_trans_t             *tp = NULL;
        int                     error = 0;
        xfs_bmap_free_t         free_list;
        xfs_fsblock_t           first_block;
        int                     cancel_flags;
        int                     committed;
-       int                     dm_di_mode = 0;
        int                     link_zero;
        uint                    resblks;
-       int                     namelen;
 
        xfs_itrace_entry(dp);
 
        if (XFS_FORCED_SHUTDOWN(mp))
                return XFS_ERROR(EIO);
 
-       namelen = VNAMELEN(dentry);
-
-       if (!xfs_get_dir_entry(dentry, &ip)) {
-               dm_di_mode = ip->i_d.di_mode;
-               IRELE(ip);
-       }
-
        if (DM_EVENT_ENABLED(dp, DM_EVENT_REMOVE)) {
                error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE, dir_vp,
                                        DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
-                                       name, NULL, dm_di_mode, 0, 0);
+                                       name, NULL, ip->i_d.di_mode, 0, 0);
                if (error)
                        return error;
        }
 
-       /* From this point on, return through std_return */
-       ip = NULL;
-
        /*
         * We need to get a reference to ip before we get our log
         * reservation. The reason for this is that we cannot call
@@ -2317,13 +2306,7 @@ xfs_remove(
         * when we call xfs_iget.  Instead we get an unlocked reference
         * to the inode before getting our log reservation.
         */
-       error = xfs_get_dir_entry(dentry, &ip);
-       if (error) {
-               REMOVE_DEBUG_TRACE(__LINE__);
-               goto std_return;
-       }
-
-       dm_di_mode = ip->i_d.di_mode;
+       IHOLD(ip);
 
        xfs_itrace_entry(ip);
        xfs_itrace_ref(ip);
@@ -2459,7 +2442,7 @@ xfs_remove(
                (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
                                dir_vp, DM_RIGHT_NULL,
                                NULL, DM_RIGHT_NULL,
-                               name, NULL, dm_di_mode, error, 0);
+                               name, NULL, ip->i_d.di_mode, error, 0);
        }
        return error;
 
@@ -2868,14 +2851,13 @@ xfs_rmdir(
        char                    *name = VNAME(dentry);
        int                     namelen = VNAMELEN(dentry);
        xfs_mount_t             *mp = dp->i_mount;
-       xfs_inode_t             *cdp;   /* child directory */
+       xfs_inode_t             *cdp = VNAME_TO_INODE(dentry);
        xfs_trans_t             *tp;
        int                     error;
        xfs_bmap_free_t         free_list;
        xfs_fsblock_t           first_block;
        int                     cancel_flags;
        int                     committed;
-       int                     dm_di_mode = S_IFDIR;
        int                     last_cdp_link;
        uint                    resblks;
 
@@ -2884,24 +2866,15 @@ xfs_rmdir(
        if (XFS_FORCED_SHUTDOWN(mp))
                return XFS_ERROR(EIO);
 
-       if (!xfs_get_dir_entry(dentry, &cdp)) {
-               dm_di_mode = cdp->i_d.di_mode;
-               IRELE(cdp);
-       }
-
        if (DM_EVENT_ENABLED(dp, DM_EVENT_REMOVE)) {
                error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE,
                                        dir_vp, DM_RIGHT_NULL,
                                        NULL, DM_RIGHT_NULL,
-                                       name, NULL, dm_di_mode, 0, 0);
+                                       name, NULL, cdp->i_d.di_mode, 0, 0);
                if (error)
                        return XFS_ERROR(error);
        }
 
-       /* Return through std_return after this point. */
-
-       cdp = NULL;
-
        /*
         * We need to get a reference to cdp before we get our log
         * reservation.  The reason for this is that we cannot call
@@ -2914,13 +2887,7 @@ xfs_rmdir(
         * when we call xfs_iget.  Instead we get an unlocked reference
         * to the inode before getting our log reservation.
         */
-       error = xfs_get_dir_entry(dentry, &cdp);
-       if (error) {
-               REMOVE_DEBUG_TRACE(__LINE__);
-               goto std_return;
-       }
-       mp = dp->i_mount;
-       dm_di_mode = cdp->i_d.di_mode;
+       IHOLD(cdp);
 
        /*
         * Get the dquots for the inodes.
@@ -3077,7 +3044,7 @@ xfs_rmdir(
                (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE,
                                        dir_vp, DM_RIGHT_NULL,
                                        NULL, DM_RIGHT_NULL,
-                                       name, NULL, dm_di_mode,
+                                       name, NULL, cdp->i_d.di_mode,
                                        error, 0);
        }
        return error;