vfs: make the dentry cache use the lockref infrastructure

This just replaces the dentry count/lock combination with the lockref
structure that contains both a count and a spinlock, and does the
mechanical conversion to use the lockref infrastructure.

There are no semantic changes here, it's purely syntactic.  The
reference lockref implementation uses the spinlock exactly the same way
that the old dcache code did, and the bulk of this patch is just
expanding the internal "d_count" use in the dcache code to use
"d_lockref.count" instead.

This is purely preparation for the real change to make the reference
count updates be lockless during the 3.12 merge window.

[ As with the previous commit, this is a rewritten version of a concept
  originally from Waiman, so credit goes to him, blame for any errors
  goes to me.

  Waiman's patch had some semantic differences for taking advantage of
  the lockless update in dget_parent(), while this patch is
  intentionally a pure search-and-replace change with no semantic
  changes.     - Linus ]

Signed-off-by: Waiman Long <Waiman.Long@hp.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 9 insertions, 10 deletions

diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 4a12532da8c4..efdc94434c30 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -9,6 +9,7 @@
 #include <linux/seqlock.h>
 #include <linux/cache.h>
 #include <linux/rcupdate.h>
+#include <linux/lockref.h>
 
 struct nameidata;
 struct path;
@@ -100,6 +101,8 @@ extern unsigned int full_name_hash(const unsigned char *, unsigned int);
 # endif
 #endif
 
+#define d_lock  d_lockref.lock
+
 struct dentry {
         /* RCU lookup touched fields */
         unsigned int d_flags;           /* protected by d_lock */
@@ -112,8 +115,7 @@ struct dentry {
         unsigned char d_iname[DNAME_INLINE_LEN];        /* small names */
 
         /* Ref lookup also touches following */
-        unsigned int d_count;           /* protected by d_lock */
-        spinlock_t d_lock;              /* per dentry lock */
+        struct lockref d_lockref;       /* per-dentry lock and refcount */
         const struct dentry_operations *d_op;
         struct super_block *d_sb;       /* The root of the dentry tree */
         unsigned long d_time;           /* used by d_revalidate */
@@ -318,7 +320,7 @@ static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
         assert_spin_locked(&dentry->d_lock);
         if (!read_seqcount_retry(&dentry->d_seq, seq)) {
                 ret = 1;
-                dentry->d_count++;
+                dentry->d_lockref.count++;
         }
 
         return ret;
@@ -326,7 +328,7 @@ static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
 
 static inline unsigned d_count(const struct dentry *dentry)
 {
-        return dentry->d_count;
+        return dentry->d_lockref.count;
 }
 
 /* validate "insecure" dentry pointer */
@@ -357,17 +359,14 @@ extern char *dentry_path(struct dentry *, char *, int);
 static inline struct dentry *dget_dlock(struct dentry *dentry)
 {
         if (dentry)
-                dentry->d_count++;
+                dentry->d_lockref.count++;
         return dentry;
 }
 
 static inline struct dentry *dget(struct dentry *dentry)
 {
-        if (dentry) {
-                spin_lock(&dentry->d_lock);
-                dget_dlock(dentry);
-                spin_unlock(&dentry->d_lock);
-        }
+        if (dentry)
+                lockref_get(&dentry->d_lockref);
         return dentry;
 }