On the error return path (including -ENOENT) in link_path_walk(), we
call
unlock_nd(nd);
path_release(nd);
This is equivalent to
mntget(nd->mnt);
dget_locked(nd->dentry);
...
spin_unlock(&dcache_lock);
...
dput(nd->dentry);
mntput(nd->mnt);
The only way that this can have an effect other than bouncing the
d_count and mnt_count cachelines of the last resolved component is if
the dentry d_count reaches 0, and was either unhashed or had a
d_delete() method that returned true (in which case the dentry is thrown
away).
- Since no-one else can decrement the usage count to 0 while we hold
dcache_lock (due to the use of atomic_dec_and_lock() in dput()) this can
only occur if the usage count is zero originally (i.e. before we called
unlock_nd()).
- Since no-one else can unhash the dentry without the dcache_lock (which
we hold) the dentry must be hashed if its reference count was originally
0.
- if dentry->d_op->d_delete() exists, then plausibly it could return 1
to request that the dentry by unhashed. But this failed lookup has no
noticable side-effects (other than perhaps setting DCACHE_REFERENCED)
and might easily have not occurred (and hence d_delete() not called). So
we can't lose correctness by not calling d_delete(), (unless the
d_delete() method would have spuriously decided to kill the dentry due
to it being marked DCACHE_REFERENCED, but that seems pretty unlikely).
Hence it is safe to skip the dget_locked()/dput().
The original pointer to nd->mnt came either from
- the current root/pwd (protected by dcache_lock)
- following a mount (protected by dcache_lock)
- was in nd->mnt when we called lock_nd() (and will be released when we
call mntput() on nd->old_mnt.
Hence it is safe to skip the mntget()/mntput()
This patch adds release_locked_nd(), which skips the dget_locked() and
mntget().
Paul
--- linux-2.5.25/fs/namei.c Tue Jun 18 19:11:52 2002
+++ linux-2.5.25-dentry/fs/namei.c Mon Jul 15 00:18:18 2002
@@ -275,17 +275,22 @@
}
/*for fastwalking*/
-static inline void unlock_nd(struct nameidata *nd)
+static inline void release_locked_nd(struct nameidata *nd)
{
struct vfsmount *mnt = nd->old_mnt;
struct dentry *dentry = nd->old_dentry;
- mntget(nd->mnt);
- dget_locked(nd->dentry);
nd->old_mnt = NULL;
nd->old_dentry = NULL;
spin_unlock(&dcache_lock);
dput(dentry);
mntput(mnt);
+}
+
+static inline void unlock_nd(struct nameidata *nd)
+{
+ mntget(nd->mnt);
+ dget_locked(nd->dentry);
+ release_locked_nd(nd);
}
static inline void lock_nd(struct nameidata *nd)
@@ -737,8 +742,8 @@
mntput(pinned.mnt);
return 0;
}
- unlock_nd(nd);
- path_release(nd);
+
+ release_locked_nd(nd);
return_err:
dput(pinned.dentry);
mntput(pinned.mnt);