1 files changed, 41 insertions, 12 deletions

diff --git a/fs/dcache.c b/fs/dcache.c
index c23f78a9d156..d54a99baf4f3 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -530,6 +530,38 @@ failed:
         return dentry; /* try again with same dentry */
 }
 
+static inline struct dentry *lock_parent(struct dentry *dentry)
+{
+        struct dentry *parent = dentry->d_parent;
+        if (IS_ROOT(dentry))
+                return NULL;
+        if (likely(spin_trylock(&parent->d_lock)))
+                return parent;
+        spin_unlock(&dentry->d_lock);
+        rcu_read_lock();
+again:
+        parent = ACCESS_ONCE(dentry->d_parent);
+        spin_lock(&parent->d_lock);
+        /*
+         * We can't blindly lock dentry until we are sure
+         * that we won't violate the locking order.
+         * Any changes of dentry->d_parent must have
+         * been done with parent->d_lock held, so
+         * spin_lock() above is enough of a barrier
+         * for checking if it's still our child.
+         */
+        if (unlikely(parent != dentry->d_parent)) {
+                spin_unlock(&parent->d_lock);
+                goto again;
+        }
+        rcu_read_unlock();
+        if (parent != dentry)
+                spin_lock(&dentry->d_lock);
+        else
+                parent = NULL;
+        return parent;
+}
+
 /* 
  * This is dput
  *
@@ -804,6 +836,8 @@ static void shrink_dentry_list(struct list_head *list)
                 struct inode *inode;
                 dentry = list_entry(list->prev, struct dentry, d_lru);
                 spin_lock(&dentry->d_lock);
+                parent = lock_parent(dentry);
+
                 /*
                  * The dispose list is isolated and dentries are not accounted
                  * to the LRU here, so we can simply remove it from the list
@@ -817,6 +851,8 @@ static void shrink_dentry_list(struct list_head *list)
                  */
                 if ((int)dentry->d_lockref.count > 0) {
                         spin_unlock(&dentry->d_lock);
+                        if (parent)
+                                spin_unlock(&parent->d_lock);
                         continue;
                 }
 
@@ -824,6 +860,8 @@ static void shrink_dentry_list(struct list_head *list)
                 if (unlikely(dentry->d_flags & DCACHE_DENTRY_KILLED)) {
                         bool can_free = dentry->d_flags & DCACHE_MAY_FREE;
                         spin_unlock(&dentry->d_lock);
+                        if (parent)
+                                spin_unlock(&parent->d_lock);
                         if (can_free)
                                 dentry_free(dentry);
                         continue;
@@ -833,22 +871,13 @@ static void shrink_dentry_list(struct list_head *list)
                 if (inode && unlikely(!spin_trylock(&inode->i_lock))) {
                         d_shrink_add(dentry, list);
                         spin_unlock(&dentry->d_lock);
+                        if (parent)
+                                spin_unlock(&parent->d_lock);
                         continue;
                 }
 
-                parent = NULL;
-                if (!IS_ROOT(dentry)) {
-                        parent = dentry->d_parent;
-                        if (unlikely(!spin_trylock(&parent->d_lock))) {
-                                if (inode)
-                                        spin_unlock(&inode->i_lock);
-                                d_shrink_add(dentry, list);
-                                spin_unlock(&dentry->d_lock);
-                                continue;
-                        }
-                }
-
                 __dentry_kill(dentry);
+
                 /*
                  * We need to prune ancestors too. This is necessary to prevent
                  * quadratic behavior of shrink_dcache_parent(), but is also