Merge branch 'overlayfs-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszer...

[sfrench/cifs-2.6.git] / fs / dcache.c

diff --git a/fs/dcache.c b/fs/dcache.c
index d93872d425d6ffb206adc410d2f3667f8b89c801..7c38f39958bc371d0324197968a732d68da927d8 100644 (file)
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -37,8 +37,6 @@
 #include <linux/prefetch.h>
 #include <linux/ratelimit.h>
 #include <linux/list_lru.h>
-#include <linux/kasan.h>
-
 #include "internal.h"
 #include "mount.h"
 
@@ -193,7 +191,7 @@ static inline int dentry_string_cmp(const unsigned char *cs, const unsigned char
        unsigned long a,b,mask;
 
        for (;;) {
-               a = *(unsigned long *)cs;
+               a = read_word_at_a_time(cs);
                b = load_unaligned_zeropad(ct);
                if (tcount < sizeof(unsigned long))
                        break;
@@ -1628,9 +1626,6 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
                }
                atomic_set(&p->u.count, 1);
                dname = p->name;
-               if (IS_ENABLED(CONFIG_DCACHE_WORD_ACCESS))
-                       kasan_unpoison_shadow(dname,
-                               round_up(name->len + 1, sizeof(unsigned long)));
        } else  {
                dname = dentry->d_iname;
        }       
@@ -1703,9 +1698,15 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
 }
 EXPORT_SYMBOL(d_alloc);
 
+struct dentry *d_alloc_anon(struct super_block *sb)
+{
+       return __d_alloc(sb, NULL);
+}
+EXPORT_SYMBOL(d_alloc_anon);
+
 struct dentry *d_alloc_cursor(struct dentry * parent)
 {
-       struct dentry *dentry = __d_alloc(parent->d_sb, NULL);
+       struct dentry *dentry = d_alloc_anon(parent->d_sb);
        if (dentry) {
                dentry->d_flags |= DCACHE_RCUACCESS | DCACHE_DENTRY_CURSOR;
                dentry->d_parent = dget(parent);
@@ -1891,7 +1892,7 @@ struct dentry *d_make_root(struct inode *root_inode)
        struct dentry *res = NULL;
 
        if (root_inode) {
-               res = __d_alloc(root_inode->i_sb, NULL);
+               res = d_alloc_anon(root_inode->i_sb);
                if (res)
                        d_instantiate(res, root_inode);
                else
@@ -1930,33 +1931,19 @@ struct dentry *d_find_any_alias(struct inode *inode)
 }
 EXPORT_SYMBOL(d_find_any_alias);
 
-static struct dentry *__d_obtain_alias(struct inode *inode, int disconnected)
+static struct dentry *__d_instantiate_anon(struct dentry *dentry,
+                                          struct inode *inode,
+                                          bool disconnected)
 {
-       struct dentry *tmp;
        struct dentry *res;
        unsigned add_flags;
 
-       if (!inode)
-               return ERR_PTR(-ESTALE);
-       if (IS_ERR(inode))
-               return ERR_CAST(inode);
-
-       res = d_find_any_alias(inode);
-       if (res)
-               goto out_iput;
-
-       tmp = __d_alloc(inode->i_sb, NULL);
-       if (!tmp) {
-               res = ERR_PTR(-ENOMEM);
-               goto out_iput;
-       }
-
-       security_d_instantiate(tmp, inode);
+       security_d_instantiate(dentry, inode);
        spin_lock(&inode->i_lock);
        res = __d_find_any_alias(inode);
        if (res) {
                spin_unlock(&inode->i_lock);
-               dput(tmp);
+               dput(dentry);
                goto out_iput;
        }
 
@@ -1966,24 +1953,57 @@ static struct dentry *__d_obtain_alias(struct inode *inode, int disconnected)
        if (disconnected)
                add_flags |= DCACHE_DISCONNECTED;
 
-       spin_lock(&tmp->d_lock);
-       __d_set_inode_and_type(tmp, inode, add_flags);
-       hlist_add_head(&tmp->d_u.d_alias, &inode->i_dentry);
+       spin_lock(&dentry->d_lock);
+       __d_set_inode_and_type(dentry, inode, add_flags);
+       hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
        if (!disconnected) {
-               hlist_bl_lock(&tmp->d_sb->s_roots);
-               hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_roots);
-               hlist_bl_unlock(&tmp->d_sb->s_roots);
+               hlist_bl_lock(&dentry->d_sb->s_roots);
+               hlist_bl_add_head(&dentry->d_hash, &dentry->d_sb->s_roots);
+               hlist_bl_unlock(&dentry->d_sb->s_roots);
        }
-       spin_unlock(&tmp->d_lock);
+       spin_unlock(&dentry->d_lock);
        spin_unlock(&inode->i_lock);
 
-       return tmp;
+       return dentry;
 
  out_iput:
        iput(inode);
        return res;
 }
 
+struct dentry *d_instantiate_anon(struct dentry *dentry, struct inode *inode)
+{
+       return __d_instantiate_anon(dentry, inode, true);
+}
+EXPORT_SYMBOL(d_instantiate_anon);
+
+static struct dentry *__d_obtain_alias(struct inode *inode, bool disconnected)
+{
+       struct dentry *tmp;
+       struct dentry *res;
+
+       if (!inode)
+               return ERR_PTR(-ESTALE);
+       if (IS_ERR(inode))
+               return ERR_CAST(inode);
+
+       res = d_find_any_alias(inode);
+       if (res)
+               goto out_iput;
+
+       tmp = d_alloc_anon(inode->i_sb);
+       if (!tmp) {
+               res = ERR_PTR(-ENOMEM);
+               goto out_iput;
+       }
+
+       return __d_instantiate_anon(tmp, inode, disconnected);
+
+out_iput:
+       iput(inode);
+       return res;
+}
+
 /**
  * d_obtain_alias - find or allocate a DISCONNECTED dentry for a given inode
  * @inode: inode to allocate the dentry for
@@ -2004,7 +2024,7 @@ static struct dentry *__d_obtain_alias(struct inode *inode, int disconnected)
  */
 struct dentry *d_obtain_alias(struct inode *inode)
 {
-       return __d_obtain_alias(inode, 1);
+       return __d_obtain_alias(inode, true);
 }
 EXPORT_SYMBOL(d_obtain_alias);
 
@@ -2025,7 +2045,7 @@ EXPORT_SYMBOL(d_obtain_alias);
  */
 struct dentry *d_obtain_root(struct inode *inode)
 {
-       return __d_obtain_alias(inode, 0);
+       return __d_obtain_alias(inode, false);
 }
 EXPORT_SYMBOL(d_obtain_root);
 
@@ -3532,6 +3552,7 @@ bool is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)
 
        return result;
 }
+EXPORT_SYMBOL(is_subdir);
 
 static enum d_walk_ret d_genocide_kill(void *data, struct dentry *dentry)
 {
@@ -3607,8 +3628,9 @@ static void __init dcache_init(void)
         * but it is probably not worth it because of the cache nature
         * of the dcache.
         */
-       dentry_cache = KMEM_CACHE(dentry,
-               SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD|SLAB_ACCOUNT);
+       dentry_cache = KMEM_CACHE_USERCOPY(dentry,
+               SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
+               d_iname);
 
        /* Hash may have been set up in dcache_init_early */
        if (!hashdist)
@@ -3646,8 +3668,8 @@ void __init vfs_caches_init_early(void)
 
 void __init vfs_caches_init(void)
 {
-       names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
+       names_cachep = kmem_cache_create_usercopy("names_cache", PATH_MAX, 0,
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, 0, PATH_MAX, NULL);
 
        dcache_init();
        inode_init();