4 files changed, 10 insertions, 26 deletions

diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index c74ef4426282..f23237135163 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -440,9 +440,7 @@ static void remove_inode_hugepages(struct inode *inode, loff_t lstart,
                         u32 hash;
 
                         index = page->index;
-                        hash = hugetlb_fault_mutex_hash(h, current->mm,
-                                                        &pseudo_vma,
-                                                        mapping, index, 0);
+                        hash = hugetlb_fault_mutex_hash(h, mapping, index, 0);
                         mutex_lock(&hugetlb_fault_mutex_table[hash]);
 
                         /*
@@ -639,8 +637,7 @@ static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset,
                 addr = index * hpage_size;
 
                 /* mutex taken here, fault path and hole punch */
-                hash = hugetlb_fault_mutex_hash(h, mm, &pseudo_vma, mapping,
-                                                index, addr);
+                hash = hugetlb_fault_mutex_hash(h, mapping, index, addr);
                 mutex_lock(&hugetlb_fault_mutex_table[hash]);
 
                 /* See if already present in mapping to avoid alloc/free */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 11943b60f208..edf476c8cfb9 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -123,9 +123,7 @@ void move_hugetlb_state(struct page *oldpage, struct page *newpage, int reason);
 void free_huge_page(struct page *page);
 void hugetlb_fix_reserve_counts(struct inode *inode);
 extern struct mutex *hugetlb_fault_mutex_table;
-u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
-                                struct vm_area_struct *vma,
-                                struct address_space *mapping,
+u32 hugetlb_fault_mutex_hash(struct hstate *h, struct address_space *mapping,
                                 pgoff_t idx, unsigned long address);
 
 pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud);
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index c33c5cbb67ff..98a3c7c224cb 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -3824,8 +3824,7 @@ retry:
                          * handling userfault.  Reacquire after handling
                          * fault to make calling code simpler.
                          */
-                        hash = hugetlb_fault_mutex_hash(h, mm, vma, mapping,
-                                                        idx, haddr);
+                        hash = hugetlb_fault_mutex_hash(h, mapping, idx, haddr);
                         mutex_unlock(&hugetlb_fault_mutex_table[hash]);
                         ret = handle_userfault(&vmf, VM_UFFD_MISSING);
                         mutex_lock(&hugetlb_fault_mutex_table[hash]);
@@ -3933,21 +3932,14 @@ backout_unlocked:
 }
 
 #ifdef CONFIG_SMP
-u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
-                            struct vm_area_struct *vma,
-                            struct address_space *mapping,
+u32 hugetlb_fault_mutex_hash(struct hstate *h, struct address_space *mapping,
                             pgoff_t idx, unsigned long address)
 {
         unsigned long key[2];
         u32 hash;
 
-        if (vma->vm_flags & VM_SHARED) {
-                key[0] = (unsigned long) mapping;
-                key[1] = idx;
-        } else {
-                key[0] = (unsigned long) mm;
-                key[1] = address >> huge_page_shift(h);
-        }
+        key[0] = (unsigned long) mapping;
+        key[1] = idx;
 
         hash = jhash2((u32 *)&key, sizeof(key)/sizeof(u32), 0);
 
@@ -3958,9 +3950,7 @@ u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
  * For uniprocesor systems we always use a single mutex, so just
  * return 0 and avoid the hashing overhead.
  */
-u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
-                            struct vm_area_struct *vma,
-                            struct address_space *mapping,
+u32 hugetlb_fault_mutex_hash(struct hstate *h, struct address_space *mapping,
                             pgoff_t idx, unsigned long address)
 {
         return 0;
@@ -4005,7 +3995,7 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
          * get spurious allocation failures if two CPUs race to instantiate
          * the same page in the page cache.
          */
-        hash = hugetlb_fault_mutex_hash(h, mm, vma, mapping, idx, haddr);
+        hash = hugetlb_fault_mutex_hash(h, mapping, idx, haddr);
         mutex_lock(&hugetlb_fault_mutex_table[hash]);
 
         entry = huge_ptep_get(ptep);
diff --git a/mm/userfaultfd.c b/mm/userfaultfd.c
index d59b5a73dfb3..9932d5755e4c 100644
--- a/mm/userfaultfd.c
+++ b/mm/userfaultfd.c
@@ -271,8 +271,7 @@ retry:
                  */
                 idx = linear_page_index(dst_vma, dst_addr);
                 mapping = dst_vma->vm_file->f_mapping;
-                hash = hugetlb_fault_mutex_hash(h, dst_mm, dst_vma, mapping,
-                                                                idx, dst_addr);
+                hash = hugetlb_fault_mutex_hash(h, mapping, idx, dst_addr);
                 mutex_lock(&hugetlb_fault_mutex_table[hash]);
 
                 err = -ENOMEM;