dcache: let the dentry count go down to zero without taking d_lock

We can be more aggressive about this, if we are clever and careful. This is subtle.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 28 insertions, 8 deletions

diff --git a/lib/lockref.c b/lib/lockref.c
index d2233de9a86e..ecb9a665ec19 100644
--- a/lib/lockref.c
+++ b/lib/lockref.c
@@ -60,7 +60,7 @@ void lockref_get(struct lockref *lockref)
 EXPORT_SYMBOL(lockref_get);
 
 /**
- * lockref_get_not_zero - Increments count unless the count is 0
+ * lockref_get_not_zero - Increments count unless the count is 0 or dead
  * @lockref: pointer to lockref structure
  * Return: 1 if count updated successfully or 0 if count was zero
  */
@@ -70,7 +70,7 @@ int lockref_get_not_zero(struct lockref *lockref)
 
         CMPXCHG_LOOP(
                 new.count++;
-                if (!old.count)
+                if (old.count <= 0)
                         return 0;
         ,
                 return 1;
@@ -78,7 +78,7 @@ int lockref_get_not_zero(struct lockref *lockref)
 
         spin_lock(&lockref->lock);
         retval = 0;
-        if (lockref->count) {
+        if (lockref->count > 0) {
                 lockref->count++;
                 retval = 1;
         }
@@ -88,7 +88,7 @@ int lockref_get_not_zero(struct lockref *lockref)
 EXPORT_SYMBOL(lockref_get_not_zero);
 
 /**
- * lockref_get_or_lock - Increments count unless the count is 0
+ * lockref_get_or_lock - Increments count unless the count is 0 or dead
  * @lockref: pointer to lockref structure
  * Return: 1 if count updated successfully or 0 if count was zero
  * and we got the lock instead.
@@ -97,14 +97,14 @@ int lockref_get_or_lock(struct lockref *lockref)
 {
         CMPXCHG_LOOP(
                 new.count++;
-                if (!old.count)
+                if (old.count <= 0)
                         break;
         ,
                 return 1;
         );
 
         spin_lock(&lockref->lock);
-        if (!lockref->count)
+        if (lockref->count <= 0)
                 return 0;
         lockref->count++;
         spin_unlock(&lockref->lock);
@@ -113,6 +113,26 @@ int lockref_get_or_lock(struct lockref *lockref)
 EXPORT_SYMBOL(lockref_get_or_lock);
 
 /**
+ * lockref_put_return - Decrement reference count if possible
+ * @lockref: pointer to lockref structure
+ *
+ * Decrement the reference count and return the new value.
+ * If the lockref was dead or locked, return an error.
+ */
+int lockref_put_return(struct lockref *lockref)
+{
+        CMPXCHG_LOOP(
+                new.count--;
+                if (old.count <= 0)
+                        return -1;
+        ,
+                return new.count;
+        );
+        return -1;
+}
+EXPORT_SYMBOL(lockref_put_return);
+
+/**
  * lockref_put_or_lock - decrements count unless count <= 1 before decrement
  * @lockref: pointer to lockref structure
  * Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
@@ -158,7 +178,7 @@ int lockref_get_not_dead(struct lockref *lockref)
 
         CMPXCHG_LOOP(
                 new.count++;
-                if ((int)old.count < 0)
+                if (old.count < 0)
                         return 0;
         ,
                 return 1;
@@ -166,7 +186,7 @@ int lockref_get_not_dead(struct lockref *lockref)
 
         spin_lock(&lockref->lock);
         retval = 0;
-        if ((int) lockref->count >= 0) {
+        if (lockref->count >= 0) {
                 lockref->count++;
                 retval = 1;
         }