31 files changed, 86 insertions, 78 deletions

diff --git a/fs/adfs/dir.c b/fs/adfs/dir.c
index fd4cf2c48e48..bec25f7017c0 100644
--- a/fs/adfs/dir.c
+++ b/fs/adfs/dir.c
@@ -207,7 +207,7 @@ adfs_hash(const struct dentry *parent, struct qstr *qstr)
          */
         qstr->len = i = name_len;
         name = qstr->name;
-        hash = init_name_hash();
+        hash = init_name_hash(parent);
         while (i--) {
                 char c;
 
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index 00d3002a6780..eb32029bc776 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -61,7 +61,7 @@ affs_get_toupper(struct super_block *sb)
  * Note: the dentry argument is the parent dentry.
  */
 static inline int
-__affs_hash_dentry(struct qstr *qstr, toupper_t toupper, bool notruncate)
+__affs_hash_dentry(const struct dentry *dentry, struct qstr *qstr, toupper_t toupper, bool notruncate)
 {
         const u8 *name = qstr->name;
         unsigned long hash;
@@ -72,7 +72,7 @@ __affs_hash_dentry(struct qstr *qstr, toupper_t toupper, bool notruncate)
         if (retval)
                 return retval;
 
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         len = min(qstr->len, AFFSNAMEMAX);
         for (; len > 0; name++, len--)
                 hash = partial_name_hash(toupper(*name), hash);
@@ -84,7 +84,7 @@ __affs_hash_dentry(struct qstr *qstr, toupper_t toupper, bool notruncate)
 static int
 affs_hash_dentry(const struct dentry *dentry, struct qstr *qstr)
 {
-        return __affs_hash_dentry(qstr, affs_toupper,
+        return __affs_hash_dentry(dentry, qstr, affs_toupper,
                                   affs_nofilenametruncate(dentry));
 
 }
@@ -92,7 +92,7 @@ affs_hash_dentry(const struct dentry *dentry, struct qstr *qstr)
 static int
 affs_intl_hash_dentry(const struct dentry *dentry, struct qstr *qstr)
 {
-        return __affs_hash_dentry(qstr, affs_intl_toupper,
+        return __affs_hash_dentry(dentry, qstr, affs_intl_toupper,
                                   affs_nofilenametruncate(dentry));
 
 }
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index 631f1554c87b..708214457d16 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -398,7 +398,7 @@ int autofs4_wait(struct autofs_sb_info *sbi,
                 }
         }
         qstr.name = name;
-        qstr.hash = full_name_hash(name, qstr.len);
+        qstr.hash = full_name_hash(dentry, name, qstr.len);
 
         if (mutex_lock_interruptible(&sbi->wq_mutex)) {
                 kfree(qstr.name);
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index f059b5997072..99bdef66213a 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -1164,7 +1164,7 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
 
                         dname.name = rinfo->dname;
                         dname.len = rinfo->dname_len;
-                        dname.hash = full_name_hash(dname.name, dname.len);
+                        dname.hash = full_name_hash(parent, dname.name, dname.len);
                         vino.ino = le64_to_cpu(rinfo->targeti.in->ino);
                         vino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
 retry_lookup:
@@ -1508,7 +1508,7 @@ int ceph_readdir_prepopulate(struct ceph_mds_request *req,
 
                 dname.name = rde->name;
                 dname.len = rde->name_len;
-                dname.hash = full_name_hash(dname.name, dname.len);
+                dname.hash = full_name_hash(parent, dname.name, dname.len);
 
                 vino.ino = le64_to_cpu(rde->inode.in->ino);
                 vino.snap = le64_to_cpu(rde->inode.in->snapid);
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index 2103b823bec0..4e8678a612b6 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -3204,7 +3204,7 @@ static void handle_lease(struct ceph_mds_client *mdsc,
                 WARN_ON(1);
                 goto release;  /* hrm... */
         }
-        dname.hash = full_name_hash(dname.name, dname.len);
+        dname.hash = full_name_hash(parent, dname.name, dname.len);
         dentry = d_lookup(parent, &dname);
         dput(parent);
         if (!dentry)
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index fb0903fffc22..5efd6f1fb8a5 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -856,7 +856,7 @@ static int cifs_ci_hash(const struct dentry *dentry, struct qstr *q)
         wchar_t c;
         int i, charlen;
 
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         for (i = 0; i < q->len; i += charlen) {
                 charlen = codepage->char2uni(&q->name[i], q->len - i, &c);
                 /* error out if we can't convert the character */
diff --git a/fs/dcache.c b/fs/dcache.c
index d6847d7b123d..24bf27d66f6e 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -104,11 +104,9 @@ static unsigned int d_hash_shift __read_mostly;
 
 static struct hlist_bl_head *dentry_hashtable __read_mostly;
 
-static inline struct hlist_bl_head *d_hash(const struct dentry *parent,
-                                        unsigned int hash)
+static inline struct hlist_bl_head *d_hash(unsigned int hash)
 {
-        hash += (unsigned long) parent / L1_CACHE_BYTES;
-        return dentry_hashtable + hash_32(hash, d_hash_shift);
+        return dentry_hashtable + (hash >> (32 - d_hash_shift));
 }
 
 #define IN_LOOKUP_SHIFT 10
@@ -488,7 +486,7 @@ void __d_drop(struct dentry *dentry)
                 if (unlikely(IS_ROOT(dentry)))
                         b = &dentry->d_sb->s_anon;
                 else
-                        b = d_hash(dentry->d_parent, dentry->d_name.hash);
+                        b = d_hash(dentry->d_name.hash);
 
                 hlist_bl_lock(b);
                 __hlist_bl_del(&dentry->d_hash);
@@ -1716,7 +1714,7 @@ struct dentry *d_alloc_name(struct dentry *parent, const char *name)
         struct qstr q;
 
         q.name = name;
-        q.hash_len = hashlen_string(name);
+        q.hash_len = hashlen_string(parent, name);
         return d_alloc(parent, &q);
 }
 EXPORT_SYMBOL(d_alloc_name);
@@ -2140,7 +2138,7 @@ struct dentry *__d_lookup_rcu(const struct dentry *parent,
 {
         u64 hashlen = name->hash_len;
         const unsigned char *str = name->name;
-        struct hlist_bl_head *b = d_hash(parent, hashlen_hash(hashlen));
+        struct hlist_bl_head *b = d_hash(hashlen_hash(hashlen));
         struct hlist_bl_node *node;
         struct dentry *dentry;
 
@@ -2257,7 +2255,7 @@ struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name)
         unsigned int len = name->len;
         unsigned int hash = name->hash;
         const unsigned char *str = name->name;
-        struct hlist_bl_head *b = d_hash(parent, hash);
+        struct hlist_bl_head *b = d_hash(hash);
         struct hlist_bl_node *node;
         struct dentry *found = NULL;
         struct dentry *dentry;
@@ -2337,7 +2335,7 @@ struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name)
          * calculate the standard hash first, as the d_op->d_hash()
          * routine may choose to leave the hash value unchanged.
          */
-        name->hash = full_name_hash(name->name, name->len);
+        name->hash = full_name_hash(dir, name->name, name->len);
         if (dir->d_flags & DCACHE_OP_HASH) {
                 int err = dir->d_op->d_hash(dir, name);
                 if (unlikely(err < 0))
@@ -2410,7 +2408,7 @@ static void __d_rehash(struct dentry * entry, struct hlist_bl_head *b)
 
 static void _d_rehash(struct dentry * entry)
 {
-        __d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
+        __d_rehash(entry, d_hash(entry->d_name.hash));
 }
 
 /**
@@ -2874,7 +2872,7 @@ static void __d_move(struct dentry *dentry, struct dentry *target,
          * for the same hash queue because of how unlikely it is.
          */
         __d_drop(dentry);
-        __d_rehash(dentry, d_hash(target->d_parent, target->d_name.hash));
+        __d_rehash(dentry, d_hash(target->d_name.hash));
 
         /*
          * Unhash the target (d_delete() is not usable here).  If exchanging
@@ -2882,8 +2880,7 @@ static void __d_move(struct dentry *dentry, struct dentry *target,
          */
         __d_drop(target);
         if (exchange) {
-                __d_rehash(target,
-                           d_hash(dentry->d_parent, dentry->d_name.hash));
+                __d_rehash(target, d_hash(dentry->d_name.hash));
         }
 
         /* Switch the names.. */
diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c
index 9cb54a38832d..a5e607e8f056 100644
--- a/fs/efivarfs/super.c
+++ b/fs/efivarfs/super.c
@@ -65,7 +65,7 @@ static int efivarfs_d_compare(const struct dentry *parent,
 
 static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
 {
-        unsigned long hash = init_name_hash();
+        unsigned long hash = init_name_hash(dentry);
         const unsigned char *s = qstr->name;
         unsigned int len = qstr->len;
 
@@ -98,7 +98,7 @@ static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
         q.name = name;
         q.len = strlen(name);
 
-        err = efivarfs_d_hash(NULL, &q);
+        err = efivarfs_d_hash(parent, &q);
         if (err)
                 return ERR_PTR(err);
 
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index b7e2b33aa793..1337c0c7527d 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -154,7 +154,7 @@ static int msdos_hash(const struct dentry *dentry, struct qstr *qstr)
 
         error = msdos_format_name(qstr->name, qstr->len, msdos_name, options);
         if (!error)
-                qstr->hash = full_name_hash(msdos_name, MSDOS_NAME);
+                qstr->hash = full_name_hash(dentry, msdos_name, MSDOS_NAME);
         return 0;
 }
 
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index 7092584f424a..6ccdf3f34f90 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -107,7 +107,7 @@ static unsigned int vfat_striptail_len(const struct qstr *qstr)
  */
 static int vfat_hash(const struct dentry *dentry, struct qstr *qstr)
 {
-        qstr->hash = full_name_hash(qstr->name, vfat_striptail_len(qstr));
+        qstr->hash = full_name_hash(dentry, qstr->name, vfat_striptail_len(qstr));
         return 0;
 }
 
@@ -127,7 +127,7 @@ static int vfat_hashi(const struct dentry *dentry, struct qstr *qstr)
         name = qstr->name;
         len = vfat_striptail_len(qstr);
 
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         while (len--)
                 hash = partial_name_hash(nls_tolower(t, *name++), hash);
         qstr->hash = end_name_hash(hash);
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index cbece1221417..203adf3b75db 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -1525,7 +1525,6 @@ static int fuse_notify_inval_entry(struct fuse_conn *fc, unsigned int size,
                 goto err;
         fuse_copy_finish(cs);
         buf[outarg.namelen] = 0;
-        name.hash = full_name_hash(name.name, name.len);
 
         down_read(&fc->killsb);
         err = -ENOENT;
@@ -1576,7 +1575,6 @@ static int fuse_notify_delete(struct fuse_conn *fc, unsigned int size,
                 goto err;
         fuse_copy_finish(cs);
         buf[outarg.namelen] = 0;
-        name.hash = full_name_hash(name.name, name.len);
 
         down_read(&fc->killsb);
         err = -ENOENT;
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index cca7b048c07b..5f1627725791 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -955,6 +955,7 @@ int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
         if (!dir)
                 goto unlock;
 
+        name->hash = full_name_hash(dir, name->name, name->len);
         entry = d_lookup(dir, name);
         dput(dir);
         if (!entry)
@@ -1204,7 +1205,7 @@ static int fuse_direntplus_link(struct file *file,
 
         fc = get_fuse_conn(dir);
 
-        name.hash = full_name_hash(name.name, name.len);
+        name.hash = full_name_hash(parent, name.name, name.len);
         dentry = d_lookup(parent, &name);
         if (!dentry) {
 retry:
diff --git a/fs/hfs/string.c b/fs/hfs/string.c
index 85b610c3909f..ec9f164c35a5 100644
--- a/fs/hfs/string.c
+++ b/fs/hfs/string.c
@@ -59,7 +59,7 @@ int hfs_hash_dentry(const struct dentry *dentry, struct qstr *this)
         if (len > HFS_NAMELEN)
                 len = HFS_NAMELEN;
 
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         for (; len; len--)
                 hash = partial_name_hash(caseorder[*name++], hash);
         this->hash = end_name_hash(hash);
diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index e8ef121a4d8b..c13c8a240be3 100644
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -346,7 +346,7 @@ int hfsplus_hash_dentry(const struct dentry *dentry, struct qstr *str)
 
         casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
         decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         astr = str->name;
         len = str->len;
         while (len > 0) {
diff --git a/fs/hpfs/dentry.c b/fs/hpfs/dentry.c
index fa27980f2229..60e6d334d79a 100644
--- a/fs/hpfs/dentry.c
+++ b/fs/hpfs/dentry.c
@@ -26,7 +26,7 @@ static int hpfs_hash_dentry(const struct dentry *dentry, struct qstr *qstr)
                 /*return -ENOENT;*/
         x:
 
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         for (i = 0; i < l; i++)
                 hash = partial_name_hash(hpfs_upcase(hpfs_sb(dentry->d_sb)->sb_cp_table,qstr->name[i]), hash);
         qstr->hash = end_name_hash(hash);
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 131dedc920d8..761fade7680f 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -174,7 +174,7 @@ struct iso9660_options{
  * Compute the hash for the isofs name corresponding to the dentry.
  */
 static int
-isofs_hashi_common(struct qstr *qstr, int ms)
+isofs_hashi_common(const struct dentry *dentry, struct qstr *qstr, int ms)
 {
         const char *name;
         int len;
@@ -188,7 +188,7 @@ isofs_hashi_common(struct qstr *qstr, int ms)
                         len--;
         }
 
-        hash = init_name_hash();
+        hash = init_name_hash(dentry);
         while (len--) {
                 c = tolower(*name++);
                 hash = partial_name_hash(c, hash);
@@ -231,7 +231,7 @@ static int isofs_dentry_cmp_common(
 static int
 isofs_hashi(const struct dentry *dentry, struct qstr *qstr)
 {
-        return isofs_hashi_common(qstr, 0);
+        return isofs_hashi_common(dentry, qstr, 0);
 }
 
 static int
@@ -246,7 +246,7 @@ isofs_dentry_cmpi(const struct dentry *parent, const struct dentry *dentry,
  * Compute the hash for the isofs name corresponding to the dentry.
  */
 static int
-isofs_hash_common(struct qstr *qstr, int ms)
+isofs_hash_common(const struct dentry *dentry, struct qstr *qstr, int ms)
 {
         const char *name;
         int len;
@@ -258,7 +258,7 @@ isofs_hash_common(struct qstr *qstr, int ms)
                         len--;
         }
 
-        qstr->hash = full_name_hash(name, len);
+        qstr->hash = full_name_hash(dentry, name, len);
 
         return 0;
 }
@@ -266,13 +266,13 @@ isofs_hash_common(struct qstr *qstr, int ms)
 static int
 isofs_hash_ms(const struct dentry *dentry, struct qstr *qstr)
 {
-        return isofs_hash_common(qstr, 1);
+        return isofs_hash_common(dentry, qstr, 1);
 }
 
 static int
 isofs_hashi_ms(const struct dentry *dentry, struct qstr *qstr)
 {
-        return isofs_hashi_common(qstr, 1);
+        return isofs_hashi_common(dentry, qstr, 1);
 }
 
 static int
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 84c4bf3631a2..30eb33ff8189 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -81,6 +81,7 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
         struct jffs2_full_dirent *fd = NULL, *fd_list;
         uint32_t ino = 0;
         struct inode *inode = NULL;
+        unsigned int nhash;
 
         jffs2_dbg(1, "jffs2_lookup()\n");
 
@@ -89,11 +90,14 @@ static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
 
         dir_f = JFFS2_INODE_INFO(dir_i);
 
+        /* The 'nhash' on the fd_list is not the same as the dentry hash */
+        nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len);
+
         mutex_lock(&dir_f->sem);
 
         /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
-        for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) {
-                if (fd_list->nhash == target->d_name.hash &&
+        for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) {
+                if (fd_list->nhash == nhash &&
                     (!fd || fd_list->version > fd->version) &&
                     strlen(fd_list->name) == target->d_name.len &&
                     !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) {
diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index bfebbf13698c..06a71dbd4833 100644
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -674,7 +674,7 @@ static inline int read_direntry(struct jffs2_sb_info *c, struct jffs2_raw_node_r
                 }
         }
 
-        fd->nhash = full_name_hash(fd->name, rd->nsize);
+        fd->nhash = full_name_hash(NULL, fd->name, rd->nsize);
         fd->next = NULL;
         fd->name[rd->nsize] = '\0';
 
diff --git a/fs/jffs2/scan.c b/fs/jffs2/scan.c
index 9ad5ba4b299b..90431dd613b8 100644
--- a/fs/jffs2/scan.c
+++ b/fs/jffs2/scan.c
@@ -1100,7 +1100,7 @@ static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblo
         fd->next = NULL;
         fd->version = je32_to_cpu(rd->version);
         fd->ino = je32_to_cpu(rd->ino);
-        fd->nhash = full_name_hash(fd->name, checkedlen);
+        fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
         fd->type = rd->type;
         jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
 
diff --git a/fs/jffs2/summary.c b/fs/jffs2/summary.c
index bc5385471a6e..be7c8a6a5748 100644
--- a/fs/jffs2/summary.c
+++ b/fs/jffs2/summary.c
@@ -476,7 +476,7 @@ static int jffs2_sum_process_sum_data(struct jffs2_sb_info *c, struct jffs2_eras
                                 fd->next = NULL;
                                 fd->version = je32_to_cpu(spd->version);
                                 fd->ino = je32_to_cpu(spd->ino);
-                                fd->nhash = full_name_hash(fd->name, checkedlen);
+                                fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
                                 fd->type = spd->type;
 
                                 jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
diff --git a/fs/jffs2/write.c b/fs/jffs2/write.c
index 7fb187ab2682..cda9a361368e 100644
--- a/fs/jffs2/write.c
+++ b/fs/jffs2/write.c
@@ -245,7 +245,7 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
 
         fd->version = je32_to_cpu(rd->version);
         fd->ino = je32_to_cpu(rd->ino);
-        fd->nhash = full_name_hash(name, namelen);
+        fd->nhash = full_name_hash(NULL, name, namelen);
         fd->type = rd->type;
         memcpy(fd->name, name, namelen);
         fd->name[namelen]=0;
@@ -598,7 +598,7 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                 jffs2_add_fd_to_list(c, fd, &dir_f->dents);
                 mutex_unlock(&dir_f->sem);
         } else {
-                uint32_t nhash = full_name_hash(name, namelen);
+                uint32_t nhash = full_name_hash(NULL, name, namelen);
 
                 fd = dir_f->dents;
                 /* We don't actually want to reserve any space, but we do
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index 539deddecbb0..04baf0dfc40c 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -1564,7 +1564,7 @@ static int jfs_ci_hash(const struct dentry *dir, struct qstr *this)
         unsigned long hash;
         int i;
 
-        hash = init_name_hash();
+        hash = init_name_hash(dir);
         for (i=0; i < this->len; i++)
                 hash = partial_name_hash(tolower(this->name[i]), hash);
         this->hash = end_name_hash(hash);
diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index 8a652404eef6..e57174d43683 100644
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -336,11 +336,11 @@ struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
  */
 static unsigned int kernfs_name_hash(const char *name, const void *ns)
 {
-        unsigned long hash = init_name_hash();
+        unsigned long hash = init_name_hash(ns);
         unsigned int len = strlen(name);
         while (len--)
                 hash = partial_name_hash(*name++, hash);
-        hash = (end_name_hash(hash) ^ hash_ptr((void *)ns, 31));
+        hash = end_name_hash(hash);
         hash &= 0x7fffffffU;
         /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
         if (hash < 2)
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index 2d5336bd4efd..bcd754d216bd 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -95,7 +95,7 @@ static int beyond_eof(struct inode *inode, loff_t bix)
  * of each character and pick a prime nearby, preferably a bit-sparse
  * one.
  */
-static u32 hash_32(const char *s, int len, u32 seed)
+static u32 logfs_hash_32(const char *s, int len, u32 seed)
 {
         u32 hash = seed;
         int i;
@@ -159,7 +159,7 @@ static struct page *logfs_get_dd_page(struct inode *dir, struct dentry *dentry)
         struct qstr *name = &dentry->d_name;
         struct page *page;
         struct logfs_disk_dentry *dd;
-        u32 hash = hash_32(name->name, name->len, 0);
+        u32 hash = logfs_hash_32(name->name, name->len, 0);
         pgoff_t index;
         int round;
 
@@ -370,7 +370,7 @@ static int logfs_write_dir(struct inode *dir, struct dentry *dentry,
 {
         struct page *page;
         struct logfs_disk_dentry *dd;
-        u32 hash = hash_32(dentry->d_name.name, dentry->d_name.len, 0);
+        u32 hash = logfs_hash_32(dentry->d_name.name, dentry->d_name.len, 0);
         pgoff_t index;
         int round, err;
 
diff --git a/fs/namei.c b/fs/namei.c
index 70580ab1445c..7cb9be3e200a 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1890,9 +1890,9 @@ static inline unsigned int fold_hash(unsigned long x, unsigned long y)
  * payload bytes, to match the way that hash_name() iterates until it
  * finds the delimiter after the name.
  */
-unsigned int full_name_hash(const char *name, unsigned int len)
+unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)
 {
-        unsigned long a, x = 0, y = 0;
+        unsigned long a, x = 0, y = (unsigned long)salt;
 
         for (;;) {
                 if (!len)
@@ -1911,15 +1911,19 @@ done:
 EXPORT_SYMBOL(full_name_hash);
 
 /* Return the "hash_len" (hash and length) of a null-terminated string */
-u64 hashlen_string(const char *name)
+u64 hashlen_string(const void *salt, const char *name)
 {
-        unsigned long a = 0, x = 0, y = 0, adata, mask, len;
+        unsigned long a = 0, x = 0, y = (unsigned long)salt;
+        unsigned long adata, mask, len;
         const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 
-        len = -sizeof(unsigned long);
+        len = 0;
+        goto inside;
+
         do {
                 HASH_MIX(x, y, a);
                 len += sizeof(unsigned long);
+inside:
                 a = load_unaligned_zeropad(name+len);
         } while (!has_zero(a, &adata, &constants));
 
@@ -1935,15 +1939,19 @@ EXPORT_SYMBOL(hashlen_string);
  * Calculate the length and hash of the path component, and
  * return the "hash_len" as the result.
  */
-static inline u64 hash_name(const char *name)
+static inline u64 hash_name(const void *salt, const char *name)
 {
-        unsigned long a = 0, b, x = 0, y = 0, adata, bdata, mask, len;
+        unsigned long a = 0, b, x = 0, y = (unsigned long)salt;
+        unsigned long adata, bdata, mask, len;
         const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 
-        len = -sizeof(unsigned long);
+        len = 0;
+        goto inside;
+
         do {
                 HASH_MIX(x, y, a);
                 len += sizeof(unsigned long);
+inside:
                 a = load_unaligned_zeropad(name+len);
                 b = a ^ REPEAT_BYTE('/');
         } while (!(has_zero(a, &adata, &constants) | has_zero(b, &bdata, &constants)));
@@ -1959,9 +1967,9 @@ static inline u64 hash_name(const char *name)
 #else   /* !CONFIG_DCACHE_WORD_ACCESS: Slow, byte-at-a-time version */
 
 /* Return the hash of a string of known length */
-unsigned int full_name_hash(const char *name, unsigned int len)
+unsigned int full_name_hash(const void *salt, const char *name, unsigned int len)
 {
-        unsigned long hash = init_name_hash();
+        unsigned long hash = init_name_hash(salt);
         while (len--)
                 hash = partial_name_hash((unsigned char)*name++, hash);
         return end_name_hash(hash);
@@ -1969,9 +1977,9 @@ unsigned int full_name_hash(const char *name, unsigned int len)
 EXPORT_SYMBOL(full_name_hash);
 
 /* Return the "hash_len" (hash and length) of a null-terminated string */
-u64 hashlen_string(const char *name)
+u64 hashlen_string(const void *salt, const char *name)
 {
-        unsigned long hash = init_name_hash();
+        unsigned long hash = init_name_hash(salt);
         unsigned long len = 0, c;
 
         c = (unsigned char)*name;
@@ -1988,9 +1996,9 @@ EXPORT_SYMBOL(hashlen_string);
  * We know there's a real path component here of at least
  * one character.
  */
-static inline u64 hash_name(const char *name)
+static inline u64 hash_name(const void *salt, const char *name)
 {
-        unsigned long hash = init_name_hash();
+        unsigned long hash = init_name_hash(salt);
         unsigned long len = 0, c;
 
         c = (unsigned char)*name;
@@ -2030,7 +2038,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                 if (err)
                         return err;
 
-                hash_len = hash_name(name);
+                hash_len = hash_name(nd->path.dentry, name);
 
                 type = LAST_NORM;
                 if (name[0] == '.') switch (hashlen_len(hash_len)) {
@@ -2436,7 +2444,7 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
 
         this.name = name;
         this.len = len;
-        this.hash = full_name_hash(name, len);
+        this.hash = full_name_hash(base, name, len);
         if (!len)
                 return ERR_PTR(-EACCES);
 
@@ -2489,7 +2497,7 @@ struct dentry *lookup_one_len_unlocked(const char *name,
 
         this.name = name;
         this.len = len;
-        this.hash = full_name_hash(name, len);
+        this.hash = full_name_hash(base, name, len);
         if (!len)
                 return ERR_PTR(-EACCES);
 
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index bfdad003ee56..9add7ab747a5 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -139,7 +139,7 @@ ncp_hash_dentry(const struct dentry *dentry, struct qstr *this)
                 int i;
 
                 t = NCP_IO_TABLE(sb);
-                hash = init_name_hash();
+                hash = init_name_hash(dentry);
                 for (i=0; i<this->len ; i++)
                         hash = partial_name_hash(ncp_tolower(t, this->name[i]),
                                                                         hash);
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 19d93d0cd400..411375f3c585 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -232,7 +232,7 @@ int nfs_readdir_make_qstr(struct qstr *string, const char *name, unsigned int le
          * in a page cache page which kmemleak does not scan.
          */
         kmemleak_not_leak(string->name);
-        string->hash = full_name_hash(name, len);
+        string->hash = full_name_hash(NULL, name, len);
         return 0;
 }
 
@@ -502,7 +502,7 @@ void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)
                 if (filename.len == 2 && filename.name[1] == '.')
                         return;
         }
-        filename.hash = full_name_hash(filename.name, filename.len);
+        filename.hash = full_name_hash(parent, filename.name, filename.len);
 
         dentry = d_lookup(parent, &filename);
 again:
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index 443abecf01b7..358258364616 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -253,7 +253,7 @@ handle_name:
                 err = (signed)nls_name.len;
                 goto err_out;
         }
-        nls_name.hash = full_name_hash(nls_name.name, nls_name.len);
+        nls_name.hash = full_name_hash(dent, nls_name.name, nls_name.len);
 
         dent = d_add_ci(dent, dent_inode, &nls_name);
         kfree(nls_name.name);
diff --git a/fs/ocfs2/dlm/dlmcommon.h b/fs/ocfs2/dlm/dlmcommon.h
index 004f2cbe8f71..8107d0d0c3f6 100644
--- a/fs/ocfs2/dlm/dlmcommon.h
+++ b/fs/ocfs2/dlm/dlmcommon.h
@@ -47,7 +47,7 @@
 #define DLM_HASH_BUCKETS        (DLM_HASH_PAGES * DLM_BUCKETS_PER_PAGE)
 
 /* Intended to make it easier for us to switch out hash functions */
-#define dlm_lockid_hash(_n, _l) full_name_hash(_n, _l)
+#define dlm_lockid_hash(_n, _l) full_name_hash(NULL, _n, _l)
 
 enum dlm_mle_type {
         DLM_MLE_BLOCK = 0,
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 5e57c3e46e1d..b59db94d2ff4 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -623,7 +623,7 @@ static bool proc_sys_fill_cache(struct file *file,
 
         qname.name = table->procname;
         qname.len  = strlen(table->procname);
-        qname.hash = full_name_hash(qname.name, qname.len);
+        qname.hash = full_name_hash(dir, qname.name, qname.len);
 
         child = d_lookup(dir, &qname);
         if (!child) {
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index 90b60c03b588..a42de45ce40d 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -33,7 +33,7 @@ static int sysv_hash(const struct dentry *dentry, struct qstr *qstr)
            function. */
         if (qstr->len > SYSV_NAMELEN) {
                 qstr->len = SYSV_NAMELEN;
-                qstr->hash = full_name_hash(qstr->name, qstr->len);
+                qstr->hash = full_name_hash(dentry, qstr->name, qstr->len);
         }
         return 0;
 }