1 files changed, 24 insertions, 71 deletions

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index b5783d81eda9..bfa142e67b1c 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -20,6 +20,7 @@
 #include <linux/mman.h>
 #include <linux/pagemap.h>
 #include <linux/migrate.h>
+#include <linux/hashtable.h>
 
 #include <asm/tlb.h>
 #include <asm/pgalloc.h>
@@ -62,12 +63,11 @@ static DECLARE_WAIT_QUEUE_HEAD(khugepaged_wait);
 static unsigned int khugepaged_max_ptes_none __read_mostly = HPAGE_PMD_NR-1;
 
 static int khugepaged(void *none);
-static int mm_slots_hash_init(void);
 static int khugepaged_slab_init(void);
-static void khugepaged_slab_free(void);
 
-#define MM_SLOTS_HASH_HEADS 1024
-static struct hlist_head *mm_slots_hash __read_mostly;
+#define MM_SLOTS_HASH_BITS 10
+static __read_mostly DEFINE_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
+
 static struct kmem_cache *mm_slot_cache __read_mostly;
 
 /**
@@ -105,7 +105,6 @@ static int set_recommended_min_free_kbytes(void)
         struct zone *zone;
         int nr_zones = 0;
         unsigned long recommended_min;
-        extern int min_free_kbytes;
 
         if (!khugepaged_enabled())
                 return 0;
@@ -634,12 +633,6 @@ static int __init hugepage_init(void)
         if (err)
                 goto out;
 
-        err = mm_slots_hash_init();
-        if (err) {
-                khugepaged_slab_free();
-                goto out;
-        }
-
         register_shrinker(&huge_zero_page_shrinker);
 
         /*
@@ -1302,7 +1295,6 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
         int target_nid;
         int current_nid = -1;
         bool migrated;
-        bool page_locked = false;
 
         spin_lock(&mm->page_table_lock);
         if (unlikely(!pmd_same(pmd, *pmdp)))
@@ -1324,7 +1316,6 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
         /* Acquire the page lock to serialise THP migrations */
         spin_unlock(&mm->page_table_lock);
         lock_page(page);
-        page_locked = true;
 
         /* Confirm the PTE did not while locked */
         spin_lock(&mm->page_table_lock);
@@ -1337,34 +1328,26 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
 
         /* Migrate the THP to the requested node */
         migrated = migrate_misplaced_transhuge_page(mm, vma,
-                                pmdp, pmd, addr,
-                                page, target_nid);
-        if (migrated)
-                current_nid = target_nid;
-        else {
-                spin_lock(&mm->page_table_lock);
-                if (unlikely(!pmd_same(pmd, *pmdp))) {
-                        unlock_page(page);
-                        goto out_unlock;
-                }
-                goto clear_pmdnuma;
-        }
+                                pmdp, pmd, addr, page, target_nid);
+        if (!migrated)
+                goto check_same;
 
-        task_numa_fault(current_nid, HPAGE_PMD_NR, migrated);
+        task_numa_fault(target_nid, HPAGE_PMD_NR, true);
         return 0;
 
+check_same:
+        spin_lock(&mm->page_table_lock);
+        if (unlikely(!pmd_same(pmd, *pmdp)))
+                goto out_unlock;
 clear_pmdnuma:
         pmd = pmd_mknonnuma(pmd);
         set_pmd_at(mm, haddr, pmdp, pmd);
         VM_BUG_ON(pmd_numa(*pmdp));
         update_mmu_cache_pmd(vma, addr, pmdp);
-        if (page_locked)
-                unlock_page(page);
-
 out_unlock:
         spin_unlock(&mm->page_table_lock);
         if (current_nid != -1)
-                task_numa_fault(current_nid, HPAGE_PMD_NR, migrated);
+                task_numa_fault(current_nid, HPAGE_PMD_NR, false);
         return 0;
 }
 
@@ -1656,7 +1639,7 @@ static void __split_huge_page_refcount(struct page *page)
                 page_tail->mapping = page->mapping;
 
                 page_tail->index = page->index + i;
-                page_xchg_last_nid(page_tail, page_last_nid(page));
+                page_nid_xchg_last(page_tail, page_nid_last(page));
 
                 BUG_ON(!PageAnon(page_tail));
                 BUG_ON(!PageUptodate(page_tail));
@@ -1846,7 +1829,7 @@ int split_huge_page(struct page *page)
 
         BUG_ON(PageCompound(page));
 out_unlock:
-        anon_vma_unlock(anon_vma);
+        anon_vma_unlock_write(anon_vma);
         put_anon_vma(anon_vma);
 out:
         return ret;
@@ -1908,12 +1891,6 @@ static int __init khugepaged_slab_init(void)
         return 0;
 }
 
-static void __init khugepaged_slab_free(void)
-{
-        kmem_cache_destroy(mm_slot_cache);
-        mm_slot_cache = NULL;
-}
-
 static inline struct mm_slot *alloc_mm_slot(void)
 {
         if (!mm_slot_cache)     /* initialization failed */
@@ -1926,47 +1903,23 @@ static inline void free_mm_slot(struct mm_slot *mm_slot)
         kmem_cache_free(mm_slot_cache, mm_slot);
 }
 
-static int __init mm_slots_hash_init(void)
-{
-        mm_slots_hash = kzalloc(MM_SLOTS_HASH_HEADS * sizeof(struct hlist_head),
-                                GFP_KERNEL);
-        if (!mm_slots_hash)
-                return -ENOMEM;
-        return 0;
-}
-
-#if 0
-static void __init mm_slots_hash_free(void)
-{
-        kfree(mm_slots_hash);
-        mm_slots_hash = NULL;
-}
-#endif
-
 static struct mm_slot *get_mm_slot(struct mm_struct *mm)
 {
         struct mm_slot *mm_slot;
-        struct hlist_head *bucket;
         struct hlist_node *node;
 
-        bucket = &mm_slots_hash[((unsigned long)mm / sizeof(struct mm_struct))
-                                % MM_SLOTS_HASH_HEADS];
-        hlist_for_each_entry(mm_slot, node, bucket, hash) {
+        hash_for_each_possible(mm_slots_hash, mm_slot, node, hash, (unsigned long)mm)
                 if (mm == mm_slot->mm)
                         return mm_slot;
-        }
+
         return NULL;
 }
 
 static void insert_to_mm_slots_hash(struct mm_struct *mm,
                                     struct mm_slot *mm_slot)
 {
-        struct hlist_head *bucket;
-
-        bucket = &mm_slots_hash[((unsigned long)mm / sizeof(struct mm_struct))
-                                % MM_SLOTS_HASH_HEADS];
         mm_slot->mm = mm;
-        hlist_add_head(&mm_slot->hash, bucket);
+        hash_add(mm_slots_hash, &mm_slot->hash, (long)mm);
 }
 
 static inline int khugepaged_test_exit(struct mm_struct *mm)
@@ -2035,7 +1988,7 @@ void __khugepaged_exit(struct mm_struct *mm)
         spin_lock(&khugepaged_mm_lock);
         mm_slot = get_mm_slot(mm);
         if (mm_slot && khugepaged_scan.mm_slot != mm_slot) {
-                hlist_del(&mm_slot->hash);
+                hash_del(&mm_slot->hash);
                 list_del(&mm_slot->mm_node);
                 free = 1;
         }
@@ -2368,7 +2321,7 @@ static void collapse_huge_page(struct mm_struct *mm,
                 BUG_ON(!pmd_none(*pmd));
                 set_pmd_at(mm, address, pmd, _pmd);
                 spin_unlock(&mm->page_table_lock);
-                anon_vma_unlock(vma->anon_vma);
+                anon_vma_unlock_write(vma->anon_vma);
                 goto out;
         }
 
@@ -2376,7 +2329,7 @@ static void collapse_huge_page(struct mm_struct *mm,
          * All pages are isolated and locked so anon_vma rmap
          * can't run anymore.
          */
-        anon_vma_unlock(vma->anon_vma);
+        anon_vma_unlock_write(vma->anon_vma);
 
         __collapse_huge_page_copy(pte, new_page, vma, address, ptl);
         pte_unmap(pte);
@@ -2423,7 +2376,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
         struct page *page;
         unsigned long _address;
         spinlock_t *ptl;
-        int node = -1;
+        int node = NUMA_NO_NODE;
 
         VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
@@ -2453,7 +2406,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
                  * be more sophisticated and look at more pages,
                  * but isn't for now.
                  */
-                if (node == -1)
+                if (node == NUMA_NO_NODE)
                         node = page_to_nid(page);
                 VM_BUG_ON(PageCompound(page));
                 if (!PageLRU(page) || PageLocked(page) || !PageAnon(page))
@@ -2484,7 +2437,7 @@ static void collect_mm_slot(struct mm_slot *mm_slot)
 
         if (khugepaged_test_exit(mm)) {
                 /* free mm_slot */
-                hlist_del(&mm_slot->hash);
+                hash_del(&mm_slot->hash);
                 list_del(&mm_slot->mm_node);
 
                 /*