Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull vfs pile 2 (of many) from Al Viro:
 "Mostly Miklos' series this time"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  constify dcache.c inlined helpers where possible
  fuse: drop dentry on failed revalidate
  fuse: clean up return in fuse_dentry_revalidate()
  fuse: use d_materialise_unique()
  sysfs: use check_submounts_and_drop()
  nfs: use check_submounts_and_drop()
  gfs2: use check_submounts_and_drop()
  afs: use check_submounts_and_drop()
  vfs: check unlinked ancestors before mount
  vfs: check submounts and drop atomically
  vfs: add d_walk()
  vfs: restructure d_genocide()

9 files changed, 323 insertions, 258 deletions

diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 34494fbead0a..0b74d3176ab7 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -685,16 +685,12 @@ not_found:
         spin_unlock(&dentry->d_lock);
 
 out_bad:
-        if (dentry->d_inode) {
-                /* don't unhash if we have submounts */
-                if (have_submounts(dentry))
-                        goto out_skip;
-        }
+        /* don't unhash if we have submounts */
+        if (check_submounts_and_drop(dentry) != 0)
+                goto out_skip;
 
         _debug("dropping dentry %s/%s",
                parent->d_name.name, dentry->d_name.name);
-        shrink_dcache_parent(dentry);
-        d_drop(dentry);
         dput(parent);
         key_put(key);
 
diff --git a/fs/dcache.c b/fs/dcache.c
index 5aa53bc056ba..761e31bacbc2 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1031,34 +1031,56 @@ static struct dentry *try_to_ascend(struct dentry *old, int locked, unsigned seq
         return new;
 }
 
+/**
+ * enum d_walk_ret - action to talke during tree walk
+ * @D_WALK_CONTINUE:    contrinue walk
+ * @D_WALK_QUIT:        quit walk
+ * @D_WALK_NORETRY:     quit when retry is needed
+ * @D_WALK_SKIP:        skip this dentry and its children
+ */
+enum d_walk_ret {
+        D_WALK_CONTINUE,
+        D_WALK_QUIT,
+        D_WALK_NORETRY,
+        D_WALK_SKIP,
+};
 
-/*
- * Search for at least 1 mount point in the dentry's subdirs.
- * We descend to the next level whenever the d_subdirs
- * list is non-empty and continue searching.
- */
- 
 /**
- * have_submounts - check for mounts over a dentry
- * @parent: dentry to check.
+ * d_walk - walk the dentry tree
+ * @parent:     start of walk
+ * @data:       data passed to @enter() and @finish()
+ * @enter:      callback when first entering the dentry
+ * @finish:     callback when successfully finished the walk
  *
- * Return true if the parent or its subdirectories contain
- * a mount point
+ * The @enter() and @finish() callbacks are called with d_lock held.
  */
-int have_submounts(struct dentry *parent)
+static void d_walk(struct dentry *parent, void *data,
+                   enum d_walk_ret (*enter)(void *, struct dentry *),
+                   void (*finish)(void *))
 {
         struct dentry *this_parent;
         struct list_head *next;
         unsigned seq;
         int locked = 0;
+        enum d_walk_ret ret;
+        bool retry = true;
 
         seq = read_seqbegin(&rename_lock);
 again:
         this_parent = parent;
-
-        if (d_mountpoint(parent))
-                goto positive;
         spin_lock(&this_parent->d_lock);
+
+        ret = enter(data, this_parent);
+        switch (ret) {
+        case D_WALK_CONTINUE:
+                break;
+        case D_WALK_QUIT:
+        case D_WALK_SKIP:
+                goto out_unlock;
+        case D_WALK_NORETRY:
+                retry = false;
+                break;
+        }
 repeat:
         next = this_parent->d_subdirs.next;
 resume:
@@ -1068,12 +1090,22 @@ resume:
                 next = tmp->next;
 
                 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
-                /* Have we found a mount point ? */
-                if (d_mountpoint(dentry)) {
+
+                ret = enter(data, dentry);
+                switch (ret) {
+                case D_WALK_CONTINUE:
+                        break;
+                case D_WALK_QUIT:
                         spin_unlock(&dentry->d_lock);
-                        spin_unlock(&this_parent->d_lock);
-                        goto positive;
+                        goto out_unlock;
+                case D_WALK_NORETRY:
+                        retry = false;
+                        break;
+                case D_WALK_SKIP:
+                        spin_unlock(&dentry->d_lock);
+                        continue;
                 }
+
                 if (!list_empty(&dentry->d_subdirs)) {
                         spin_unlock(&this_parent->d_lock);
                         spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
@@ -1094,29 +1126,97 @@ resume:
                 next = child->d_u.d_child.next;
                 goto resume;
         }
-        spin_unlock(&this_parent->d_lock);
-        if (!locked && read_seqretry(&rename_lock, seq))
-                goto rename_retry;
-        if (locked)
-                write_sequnlock(&rename_lock);
-        return 0; /* No mount points found in tree */
-positive:
-        if (!locked && read_seqretry(&rename_lock, seq))
+        if (!locked && read_seqretry(&rename_lock, seq)) {
+                spin_unlock(&this_parent->d_lock);
                 goto rename_retry;
+        }
+        if (finish)
+                finish(data);
+
+out_unlock:
+        spin_unlock(&this_parent->d_lock);
         if (locked)
                 write_sequnlock(&rename_lock);
-        return 1;
+        return;
 
 rename_retry:
+        if (!retry)
+                return;
         if (locked)
                 goto again;
         locked = 1;
         write_seqlock(&rename_lock);
         goto again;
 }
+
+/*
+ * Search for at least 1 mount point in the dentry's subdirs.
+ * We descend to the next level whenever the d_subdirs
+ * list is non-empty and continue searching.
+ */
+
+/**
+ * have_submounts - check for mounts over a dentry
+ * @parent: dentry to check.
+ *
+ * Return true if the parent or its subdirectories contain
+ * a mount point
+ */
+
+static enum d_walk_ret check_mount(void *data, struct dentry *dentry)
+{
+        int *ret = data;
+        if (d_mountpoint(dentry)) {
+                *ret = 1;
+                return D_WALK_QUIT;
+        }
+        return D_WALK_CONTINUE;
+}
+
+int have_submounts(struct dentry *parent)
+{
+        int ret = 0;
+
+        d_walk(parent, &ret, check_mount, NULL);
+
+        return ret;
+}
 EXPORT_SYMBOL(have_submounts);
 
 /*
+ * Called by mount code to set a mountpoint and check if the mountpoint is
+ * reachable (e.g. NFS can unhash a directory dentry and then the complete
+ * subtree can become unreachable).
+ *
+ * Only one of check_submounts_and_drop() and d_set_mounted() must succeed.  For
+ * this reason take rename_lock and d_lock on dentry and ancestors.
+ */
+int d_set_mounted(struct dentry *dentry)
+{
+        struct dentry *p;
+        int ret = -ENOENT;
+        write_seqlock(&rename_lock);
+        for (p = dentry->d_parent; !IS_ROOT(p); p = p->d_parent) {
+                /* Need exclusion wrt. check_submounts_and_drop() */
+                spin_lock(&p->d_lock);
+                if (unlikely(d_unhashed(p))) {
+                        spin_unlock(&p->d_lock);
+                        goto out;
+                }
+                spin_unlock(&p->d_lock);
+        }
+        spin_lock(&dentry->d_lock);
+        if (!d_unlinked(dentry)) {
+                dentry->d_flags |= DCACHE_MOUNTED;
+                ret = 0;
+        }
+        spin_unlock(&dentry->d_lock);
+out:
+        write_sequnlock(&rename_lock);
+        return ret;
+}
+
+/*
  * Search the dentry child list of the specified parent,
  * and move any unused dentries to the end of the unused
  * list for prune_dcache(). We descend to the next level
@@ -1130,93 +1230,46 @@ EXPORT_SYMBOL(have_submounts);
  * drop the lock and return early due to latency
  * constraints.
  */
-static int select_parent(struct dentry *parent, struct list_head *dispose)
-{
-        struct dentry *this_parent;
-        struct list_head *next;
-        unsigned seq;
-        int found = 0;
-        int locked = 0;
 
-        seq = read_seqbegin(&rename_lock);
-again:
-        this_parent = parent;
-        spin_lock(&this_parent->d_lock);
-repeat:
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct list_head *tmp = next;
-                struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
-                next = tmp->next;
-
-                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
+struct select_data {
+        struct dentry *start;
+        struct list_head dispose;
+        int found;
+};
 
-                /*
-                 * move only zero ref count dentries to the dispose list.
-                 *
-                 * Those which are presently on the shrink list, being processed
-                 * by shrink_dentry_list(), shouldn't be moved.  Otherwise the
-                 * loop in shrink_dcache_parent() might not make any progress
-                 * and loop forever.
-                 */
-                if (dentry->d_lockref.count) {
-                        dentry_lru_del(dentry);
-                } else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
-                        dentry_lru_move_list(dentry, dispose);
-                        dentry->d_flags |= DCACHE_SHRINK_LIST;
-                        found++;
-                }
-                /*
-                 * We can return to the caller if we have found some (this
-                 * ensures forward progress). We'll be coming back to find
-                 * the rest.
-                 */
-                if (found && need_resched()) {
-                        spin_unlock(&dentry->d_lock);
-                        goto out;
-                }
+static enum d_walk_ret select_collect(void *_data, struct dentry *dentry)
+{
+        struct select_data *data = _data;
+        enum d_walk_ret ret = D_WALK_CONTINUE;
 
-                /*
-                 * Descend a level if the d_subdirs list is non-empty.
-                 */
-                if (!list_empty(&dentry->d_subdirs)) {
-                        spin_unlock(&this_parent->d_lock);
-                        spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
-                        this_parent = dentry;
-                        spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
-                        goto repeat;
-                }
+        if (data->start == dentry)
+                goto out;
 
-                spin_unlock(&dentry->d_lock);
-        }
         /*
-         * All done at this level ... ascend and resume the search.
+         * move only zero ref count dentries to the dispose list.
+         *
+         * Those which are presently on the shrink list, being processed
+         * by shrink_dentry_list(), shouldn't be moved.  Otherwise the
+         * loop in shrink_dcache_parent() might not make any progress
+         * and loop forever.
          */
-        if (this_parent != parent) {
-                struct dentry *child = this_parent;
-                this_parent = try_to_ascend(this_parent, locked, seq);
-                if (!this_parent)
-                        goto rename_retry;
-                next = child->d_u.d_child.next;
-                goto resume;
+        if (dentry->d_lockref.count) {
+                dentry_lru_del(dentry);
+        } else if (!(dentry->d_flags & DCACHE_SHRINK_LIST)) {
+                dentry_lru_move_list(dentry, &data->dispose);
+                dentry->d_flags |= DCACHE_SHRINK_LIST;
+                data->found++;
+                ret = D_WALK_NORETRY;
         }
+        /*
+         * We can return to the caller if we have found some (this
+         * ensures forward progress). We'll be coming back to find
+         * the rest.
+         */
+        if (data->found && need_resched())
+                ret = D_WALK_QUIT;
 out:
-        spin_unlock(&this_parent->d_lock);
-        if (!locked && read_seqretry(&rename_lock, seq))
-                goto rename_retry;
-        if (locked)
-                write_sequnlock(&rename_lock);
-        return found;
-
-rename_retry:
-        if (found)
-                return found;
-        if (locked)
-                goto again;
-        locked = 1;
-        write_seqlock(&rename_lock);
-        goto again;
+        return ret;
 }
 
 /**
@@ -1225,18 +1278,90 @@ rename_retry:
  *
  * Prune the dcache to remove unused children of the parent dentry.
  */
-void shrink_dcache_parent(struct dentry * parent)
+void shrink_dcache_parent(struct dentry *parent)
 {
-        LIST_HEAD(dispose);
-        int found;
+        for (;;) {
+                struct select_data data;
+
+                INIT_LIST_HEAD(&data.dispose);
+                data.start = parent;
+                data.found = 0;
 
-        while ((found = select_parent(parent, &dispose)) != 0) {
-                shrink_dentry_list(&dispose);
+                d_walk(parent, &data, select_collect, NULL);
+                if (!data.found)
+                        break;
+
+                shrink_dentry_list(&data.dispose);
                 cond_resched();
         }
 }
 EXPORT_SYMBOL(shrink_dcache_parent);
 
+static enum d_walk_ret check_and_collect(void *_data, struct dentry *dentry)
+{
+        struct select_data *data = _data;
+
+        if (d_mountpoint(dentry)) {
+                data->found = -EBUSY;
+                return D_WALK_QUIT;
+        }
+
+        return select_collect(_data, dentry);
+}
+
+static void check_and_drop(void *_data)
+{
+        struct select_data *data = _data;
+
+        if (d_mountpoint(data->start))
+                data->found = -EBUSY;
+        if (!data->found)
+                __d_drop(data->start);
+}
+
+/**
+ * check_submounts_and_drop - prune dcache, check for submounts and drop
+ *
+ * All done as a single atomic operation relative to has_unlinked_ancestor().
+ * Returns 0 if successfully unhashed @parent.  If there were submounts then
+ * return -EBUSY.
+ *
+ * @dentry: dentry to prune and drop
+ */
+int check_submounts_and_drop(struct dentry *dentry)
+{
+        int ret = 0;
+
+        /* Negative dentries can be dropped without further checks */
+        if (!dentry->d_inode) {
+                d_drop(dentry);
+                goto out;
+        }
+
+        for (;;) {
+                struct select_data data;
+
+                INIT_LIST_HEAD(&data.dispose);
+                data.start = dentry;
+                data.found = 0;
+
+                d_walk(dentry, &data, check_and_collect, check_and_drop);
+                ret = data.found;
+
+                if (!list_empty(&data.dispose))
+                        shrink_dentry_list(&data.dispose);
+
+                if (ret <= 0)
+                        break;
+
+                cond_resched();
+        }
+
+out:
+        return ret;
+}
+EXPORT_SYMBOL(check_submounts_and_drop);
+
 /**
  * __d_alloc    -       allocate a dcache entry
  * @sb: filesystem it will belong to
@@ -2928,68 +3053,24 @@ int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
         return result;
 }
 
-void d_genocide(struct dentry *root)
+static enum d_walk_ret d_genocide_kill(void *data, struct dentry *dentry)
 {
-        struct dentry *this_parent;
-        struct list_head *next;
-        unsigned seq;
-        int locked = 0;
+        struct dentry *root = data;
+        if (dentry != root) {
+                if (d_unhashed(dentry) || !dentry->d_inode)
+                        return D_WALK_SKIP;
 
-        seq = read_seqbegin(&rename_lock);
-again:
-        this_parent = root;
-        spin_lock(&this_parent->d_lock);
-repeat:
-        next = this_parent->d_subdirs.next;
-resume:
-        while (next != &this_parent->d_subdirs) {
-                struct list_head *tmp = next;
-                struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child);
-                next = tmp->next;
-
-                spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
-                if (d_unhashed(dentry) || !dentry->d_inode) {
-                        spin_unlock(&dentry->d_lock);
-                        continue;
-                }
-                if (!list_empty(&dentry->d_subdirs)) {
-                        spin_unlock(&this_parent->d_lock);
-                        spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_);
-                        this_parent = dentry;
-                        spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
-                        goto repeat;
-                }
                 if (!(dentry->d_flags & DCACHE_GENOCIDE)) {
                         dentry->d_flags |= DCACHE_GENOCIDE;
                         dentry->d_lockref.count--;
                 }
-                spin_unlock(&dentry->d_lock);
-        }
-        if (this_parent != root) {
-                struct dentry *child = this_parent;
-                if (!(this_parent->d_flags & DCACHE_GENOCIDE)) {
-                        this_parent->d_flags |= DCACHE_GENOCIDE;
-                        this_parent->d_lockref.count--;
-                }
-                this_parent = try_to_ascend(this_parent, locked, seq);
-                if (!this_parent)
-                        goto rename_retry;
-                next = child->d_u.d_child.next;
-                goto resume;
         }
-        spin_unlock(&this_parent->d_lock);
-        if (!locked && read_seqretry(&rename_lock, seq))
-                goto rename_retry;
-        if (locked)
-                write_sequnlock(&rename_lock);
-        return;
+        return D_WALK_CONTINUE;
+}
 
-rename_retry:
-        if (locked)
-                goto again;
-        locked = 1;
-        write_seqlock(&rename_lock);
-        goto again;
+void d_genocide(struct dentry *parent)
+{
+        d_walk(parent, parent, d_genocide_kill, NULL);
 }
 
 void d_tmpfile(struct dentry *dentry, struct inode *inode)
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 72a5d5b04494..0e6961aae6c0 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -182,10 +182,11 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
         struct inode *inode;
         struct dentry *parent;
         struct fuse_conn *fc;
+        int ret;
 
         inode = ACCESS_ONCE(entry->d_inode);
         if (inode && is_bad_inode(inode))
-                return 0;
+                goto invalid;
         else if (fuse_dentry_time(entry) < get_jiffies_64()) {
                 int err;
                 struct fuse_entry_out outarg;
@@ -195,20 +196,23 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
 
                 /* For negative dentries, always do a fresh lookup */
                 if (!inode)
-                        return 0;
+                        goto invalid;
 
+                ret = -ECHILD;
                 if (flags & LOOKUP_RCU)
-                        return -ECHILD;
+                        goto out;
 
                 fc = get_fuse_conn(inode);
                 req = fuse_get_req_nopages(fc);
+                ret = PTR_ERR(req);
                 if (IS_ERR(req))
-                        return 0;
+                        goto out;
 
                 forget = fuse_alloc_forget();
                 if (!forget) {
                         fuse_put_request(fc, req);
-                        return 0;
+                        ret = -ENOMEM;
+                        goto out;
                 }
 
                 attr_version = fuse_get_attr_version(fc);
@@ -227,7 +231,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                         struct fuse_inode *fi = get_fuse_inode(inode);
                         if (outarg.nodeid != get_node_id(inode)) {
                                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
-                                return 0;
+                                goto invalid;
                         }
                         spin_lock(&fc->lock);
                         fi->nlookup++;
@@ -235,7 +239,7 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                 }
                 kfree(forget);
                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
-                        return 0;
+                        goto invalid;
 
                 fuse_change_attributes(inode, &outarg.attr,
                                        entry_attr_timeout(&outarg),
@@ -249,7 +253,15 @@ static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
                         dput(parent);
                 }
         }
-        return 1;
+        ret = 1;
+out:
+        return ret;
+
+invalid:
+        ret = 0;
+        if (check_submounts_and_drop(entry) != 0)
+                ret = 1;
+        goto out;
 }
 
 static int invalid_nodeid(u64 nodeid)
@@ -267,26 +279,6 @@ int fuse_valid_type(int m)
                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 }
 
-/*
- * Add a directory inode to a dentry, ensuring that no other dentry
- * refers to this inode.  Called with fc->inst_mutex.
- */
-static struct dentry *fuse_d_add_directory(struct dentry *entry,
-                                           struct inode *inode)
-{
-        struct dentry *alias = d_find_alias(inode);
-        if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
-                /* This tries to shrink the subtree below alias */
-                fuse_invalidate_entry(alias);
-                dput(alias);
-                if (!hlist_empty(&inode->i_dentry))
-                        return ERR_PTR(-EBUSY);
-        } else {
-                dput(alias);
-        }
-        return d_splice_alias(inode, entry);
-}
-
 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
                      struct fuse_entry_out *outarg, struct inode **inode)
 {
@@ -345,6 +337,24 @@ int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
         return err;
 }
 
+static struct dentry *fuse_materialise_dentry(struct dentry *dentry,
+                                              struct inode *inode)
+{
+        struct dentry *newent;
+
+        if (inode && S_ISDIR(inode->i_mode)) {
+                struct fuse_conn *fc = get_fuse_conn(inode);
+
+                mutex_lock(&fc->inst_mutex);
+                newent = d_materialise_unique(dentry, inode);
+                mutex_unlock(&fc->inst_mutex);
+        } else {
+                newent = d_materialise_unique(dentry, inode);
+        }
+
+        return newent;
+}
+
 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
                                   unsigned int flags)
 {
@@ -352,7 +362,6 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
         struct fuse_entry_out outarg;
         struct inode *inode;
         struct dentry *newent;
-        struct fuse_conn *fc = get_fuse_conn(dir);
         bool outarg_valid = true;
 
         err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
@@ -368,16 +377,10 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
         if (inode && get_node_id(inode) == FUSE_ROOT_ID)
                 goto out_iput;
 
-        if (inode && S_ISDIR(inode->i_mode)) {
-                mutex_lock(&fc->inst_mutex);
-                newent = fuse_d_add_directory(entry, inode);
-                mutex_unlock(&fc->inst_mutex);
-                err = PTR_ERR(newent);
-                if (IS_ERR(newent))
-                        goto out_iput;
-        } else {
-                newent = d_splice_alias(inode, entry);
-        }
+        newent = fuse_materialise_dentry(entry, inode);
+        err = PTR_ERR(newent);
+        if (IS_ERR(newent))
+                goto out_err;
 
         entry = newent ? newent : entry;
         if (outarg_valid)
@@ -1275,18 +1278,10 @@ static int fuse_direntplus_link(struct file *file,
         if (!inode)
                 goto out;
 
-        if (S_ISDIR(inode->i_mode)) {
-                mutex_lock(&fc->inst_mutex);
-                alias = fuse_d_add_directory(dentry, inode);
-                mutex_unlock(&fc->inst_mutex);
-                err = PTR_ERR(alias);
-                if (IS_ERR(alias)) {
-                        iput(inode);
-                        goto out;
-                }
-        } else {
-                alias = d_splice_alias(inode, dentry);
-        }
+        alias = fuse_materialise_dentry(dentry, inode);
+        err = PTR_ERR(alias);
+        if (IS_ERR(alias))
+                goto out;
 
         if (alias) {
                 dput(dentry);
diff --git a/fs/gfs2/dentry.c b/fs/gfs2/dentry.c
index f2448ab2aac5..d3a5d4e29ba5 100644
--- a/fs/gfs2/dentry.c
+++ b/fs/gfs2/dentry.c
@@ -93,12 +93,9 @@ invalid_gunlock:
         if (!had_lock)
                 gfs2_glock_dq_uninit(&d_gh);
 invalid:
-        if (inode && S_ISDIR(inode->i_mode)) {
-                if (have_submounts(dentry))
-                        goto valid;
-                shrink_dcache_parent(dentry);
-        }
-        d_drop(dentry);
+        if (check_submounts_and_drop(dentry) != 0)
+                goto valid;
+
         dput(parent);
         return 0;
 
diff --git a/fs/internal.h b/fs/internal.h
index 7c5f01cf619d..d20893795526 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -126,6 +126,7 @@ extern int invalidate_inodes(struct super_block *, bool);
  * dcache.c
  */
 extern struct dentry *__d_alloc(struct super_block *, const struct qstr *);
+extern int d_set_mounted(struct dentry *dentry);
 
 /*
  * read_write.c
diff --git a/fs/namespace.c b/fs/namespace.c
index ef69fa5d2e5b..fc2b5226278d 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -611,6 +611,7 @@ static struct mountpoint *new_mountpoint(struct dentry *dentry)
 {
         struct list_head *chain = mountpoint_hashtable + hash(NULL, dentry);
         struct mountpoint *mp;
+        int ret;
 
         list_for_each_entry(mp, chain, m_hash) {
                 if (mp->m_dentry == dentry) {
@@ -626,14 +627,12 @@ static struct mountpoint *new_mountpoint(struct dentry *dentry)
         if (!mp)
                 return ERR_PTR(-ENOMEM);
 
-        spin_lock(&dentry->d_lock);
-        if (d_unlinked(dentry)) {
-                spin_unlock(&dentry->d_lock);
+        ret = d_set_mounted(dentry);
+        if (ret) {
                 kfree(mp);
-                return ERR_PTR(-ENOENT);
+                return ERR_PTR(ret);
         }
-        dentry->d_flags |= DCACHE_MOUNTED;
-        spin_unlock(&dentry->d_lock);
+
         mp->m_dentry = dentry;
         mp->m_count = 1;
         list_add(&mp->m_hash, chain);
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index e474ca2b2bfe..7468735d299e 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1135,14 +1135,13 @@ out_zap_parent:
         if (inode && S_ISDIR(inode->i_mode)) {
                 /* Purge readdir caches. */
                 nfs_zap_caches(inode);
-                /* If we have submounts, don't unhash ! */
-                if (have_submounts(dentry))
-                        goto out_valid;
                 if (dentry->d_flags & DCACHE_DISCONNECTED)
                         goto out_valid;
-                shrink_dcache_parent(dentry);
         }
-        d_drop(dentry);
+        /* If we have submounts, don't unhash ! */
+        if (check_submounts_and_drop(dentry) != 0)
+                goto out_valid;
+
         dput(parent);
         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
                         __func__, dentry->d_parent->d_name.name,
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 99ec5b40e977..4d83cedb9fcb 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -297,7 +297,6 @@ static int sysfs_dentry_delete(const struct dentry *dentry)
 static int sysfs_dentry_revalidate(struct dentry *dentry, unsigned int flags)
 {
         struct sysfs_dirent *sd;
-        int is_dir;
         int type;
 
         if (flags & LOOKUP_RCU)
@@ -341,18 +340,15 @@ out_bad:
          * is performed at its new name the dentry will be readded
          * to the dcache hashes.
          */
-        is_dir = (sysfs_type(sd) == SYSFS_DIR);
         mutex_unlock(&sysfs_mutex);
-        if (is_dir) {
-                /* If we have submounts we must allow the vfs caches
-                 * to lie about the state of the filesystem to prevent
-                 * leaks and other nasty things.
-                 */
-                if (have_submounts(dentry))
-                        goto out_valid;
-                shrink_dcache_parent(dentry);
-        }
-        d_drop(dentry);
+
+        /* If we have submounts we must allow the vfs caches
+         * to lie about the state of the filesystem to prevent
+         * leaks and other nasty things.
+         */
+        if (check_submounts_and_drop(dentry) != 0)
+                goto out_valid;
+
         return 0;
 }
 
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 9169b91ea2d2..fe50f3db3af9 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -212,7 +212,7 @@ struct dentry_operations {
 
 extern seqlock_t rename_lock;
 
-static inline int dname_external(struct dentry *dentry)
+static inline int dname_external(const struct dentry *dentry)
 {
         return dentry->d_name.name != dentry->d_iname;
 }
@@ -253,6 +253,7 @@ extern void d_prune_aliases(struct inode *);
 
 /* test whether we have any submounts in a subdir tree */
 extern int have_submounts(struct dentry *);
+extern int check_submounts_and_drop(struct dentry *);
 
 /*
  * This adds the entry to the hash queues.
@@ -357,17 +358,17 @@ extern struct dentry *dget_parent(struct dentry *dentry);
  *      Returns true if the dentry passed is not currently hashed.
  */
  
-static inline int d_unhashed(struct dentry *dentry)
+static inline int d_unhashed(const struct dentry *dentry)
 {
         return hlist_bl_unhashed(&dentry->d_hash);
 }
 
-static inline int d_unlinked(struct dentry *dentry)
+static inline int d_unlinked(const struct dentry *dentry)
 {
         return d_unhashed(dentry) && !IS_ROOT(dentry);
 }
 
-static inline int cant_mount(struct dentry *dentry)
+static inline int cant_mount(const struct dentry *dentry)
 {
         return (dentry->d_flags & DCACHE_CANT_MOUNT);
 }
@@ -381,12 +382,12 @@ static inline void dont_mount(struct dentry *dentry)
 
 extern void dput(struct dentry *);
 
-static inline bool d_managed(struct dentry *dentry)
+static inline bool d_managed(const struct dentry *dentry)
 {
         return dentry->d_flags & DCACHE_MANAGED_DENTRY;
 }
 
-static inline bool d_mountpoint(struct dentry *dentry)
+static inline bool d_mountpoint(const struct dentry *dentry)
 {
         return dentry->d_flags & DCACHE_MOUNTED;
 }