From: Greg Kroah-Hartman Date: Mon, 31 May 2021 06:56:28 +0000 (+0200) Subject: 4.9-stable patches X-Git-Tag: v4.4.271~40 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=c1b1745babcc8eafda7f0d60231b93f575588943;p=thirdparty%2Fkernel%2Fstable-queue.git 4.9-stable patches added patches: hugetlbfs-hugetlb_fault_mutex_hash-cleanup.patch --- diff --git a/queue-4.9/hugetlbfs-hugetlb_fault_mutex_hash-cleanup.patch b/queue-4.9/hugetlbfs-hugetlb_fault_mutex_hash-cleanup.patch new file mode 100644 index 00000000000..f20ae022232 --- /dev/null +++ b/queue-4.9/hugetlbfs-hugetlb_fault_mutex_hash-cleanup.patch @@ -0,0 +1,106 @@ +From 552546366a30d88bd1d6f5efe848b2ab50fd57e5 Mon Sep 17 00:00:00 2001 +From: Mike Kravetz +Date: Sat, 30 Nov 2019 17:56:30 -0800 +Subject: hugetlbfs: hugetlb_fault_mutex_hash() cleanup + +From: Mike Kravetz + +commit 552546366a30d88bd1d6f5efe848b2ab50fd57e5 upstream. + +A new clang diagnostic (-Wsizeof-array-div) warns about the calculation +to determine the number of u32's in an array of unsigned longs. +Suppress warning by adding parentheses. + +While looking at the above issue, noticed that the 'address' parameter +to hugetlb_fault_mutex_hash is no longer used. So, remove it from the +definition and all callers. + +No functional change. + +Link: http://lkml.kernel.org/r/20190919011847.18400-1-mike.kravetz@oracle.com +Signed-off-by: Mike Kravetz +Reported-by: Nathan Chancellor +Reviewed-by: Nathan Chancellor +Reviewed-by: Davidlohr Bueso +Reviewed-by: Andrew Morton +Cc: Nick Desaulniers +Cc: Ilie Halip +Cc: David Bolvansky +Signed-off-by: Andrew Morton +Signed-off-by: Linus Torvalds +Signed-off-by: Greg Kroah-Hartman +--- + fs/hugetlbfs/inode.c | 4 ++-- + include/linux/hugetlb.h | 2 +- + mm/hugetlb.c | 8 ++++---- + 3 files changed, 7 insertions(+), 7 deletions(-) + +--- a/fs/hugetlbfs/inode.c ++++ b/fs/hugetlbfs/inode.c +@@ -451,7 +451,7 @@ static void remove_inode_hugepages(struc + if (next >= end) + break; + +- hash = hugetlb_fault_mutex_hash(h, mapping, next, 0); ++ hash = hugetlb_fault_mutex_hash(h, mapping, next); + mutex_lock(&hugetlb_fault_mutex_table[hash]); + + /* +@@ -634,7 +634,7 @@ static long hugetlbfs_fallocate(struct f + addr = index * hpage_size; + + /* mutex taken here, fault path and hole punch */ +- hash = hugetlb_fault_mutex_hash(h, mapping, index, addr); ++ hash = hugetlb_fault_mutex_hash(h, mapping, index); + mutex_lock(&hugetlb_fault_mutex_table[hash]); + + /* See if already present in mapping to avoid alloc/free */ +--- a/include/linux/hugetlb.h ++++ b/include/linux/hugetlb.h +@@ -93,7 +93,7 @@ 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 address_space *mapping, +- pgoff_t idx, unsigned long address); ++ pgoff_t idx); + + pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud); + +--- a/mm/hugetlb.c ++++ b/mm/hugetlb.c +@@ -3887,7 +3887,7 @@ backout_unlocked: + + #ifdef CONFIG_SMP + u32 hugetlb_fault_mutex_hash(struct hstate *h, struct address_space *mapping, +- pgoff_t idx, unsigned long address) ++ pgoff_t idx) + { + unsigned long key[2]; + u32 hash; +@@ -3895,7 +3895,7 @@ u32 hugetlb_fault_mutex_hash(struct hsta + key[0] = (unsigned long) mapping; + key[1] = idx; + +- hash = jhash2((u32 *)&key, sizeof(key)/sizeof(u32), 0); ++ hash = jhash2((u32 *)&key, sizeof(key)/(sizeof(u32)), 0); + + return hash & (num_fault_mutexes - 1); + } +@@ -3905,7 +3905,7 @@ u32 hugetlb_fault_mutex_hash(struct hsta + * return 0 and avoid the hashing overhead. + */ + u32 hugetlb_fault_mutex_hash(struct hstate *h, struct address_space *mapping, +- pgoff_t idx, unsigned long address) ++ pgoff_t idx) + { + return 0; + } +@@ -3950,7 +3950,7 @@ int hugetlb_fault(struct mm_struct *mm, + * get spurious allocation failures if two CPUs race to instantiate + * the same page in the page cache. + */ +- hash = hugetlb_fault_mutex_hash(h, mapping, idx, address); ++ hash = hugetlb_fault_mutex_hash(h, mapping, idx); + mutex_lock(&hugetlb_fault_mutex_table[hash]); + + entry = huge_ptep_get(ptep); diff --git a/queue-4.9/series b/queue-4.9/series index 483f06768ed..4d77c0a4c82 100644 --- a/queue-4.9/series +++ b/queue-4.9/series @@ -64,3 +64,4 @@ scsi-libsas-use-_safe-loop-in-sas_resume_port.patch sch_dsmark-fix-a-null-deref-in-qdisc_reset.patch mips-alchemy-xxs1500-add-gpio-au1000.h-header-file.patch mips-ralink-export-rt_sysc_membase-for-rt2880_wdt.c.patch +hugetlbfs-hugetlb_fault_mutex_hash-cleanup.patch