Merge branch 'akpm' (Andrew's patch-bomb)

Merge misc VM changes from Andrew Morton:
 "The rest of most-of-MM.  The other MM bits await a slab merge.

  This patch includes the addition of a huge zero_page.  Not a
  performance boost but it an save large amounts of physical memory in
  some situations.

  Also a bunch of Fujitsu engineers are working on memory hotplug.
  Which, as it turns out, was badly broken.  About half of their patches
  are included here; the remainder are 3.8 material."

However, this merge disables CONFIG_MOVABLE_NODE, which was totally
broken.  We don't add new features with "default y", nor do we add
Kconfig questions that are incomprehensible to most people without any
help text.  Does the feature even make sense without compaction or
memory hotplug?

* akpm: (54 commits)
  mm/bootmem.c: remove unused wrapper function reserve_bootmem_generic()
  mm/memory.c: remove unused code from do_wp_page()
  asm-generic, mm: pgtable: consolidate zero page helpers
  mm/hugetlb.c: fix warning on freeing hwpoisoned hugepage
  hwpoison, hugetlbfs: fix RSS-counter warning
  hwpoison, hugetlbfs: fix "bad pmd" warning in unmapping hwpoisoned hugepage
  mm: protect against concurrent vma expansion
  memcg: do not check for mm in __mem_cgroup_count_vm_event
  tmpfs: support SEEK_DATA and SEEK_HOLE (reprise)
  mm: provide more accurate estimation of pages occupied by memmap
  fs/buffer.c: remove redundant initialization in alloc_page_buffers()
  fs/buffer.c: do not inline exported function
  writeback: fix a typo in comment
  mm: introduce new field "managed_pages" to struct zone
  mm, oom: remove statically defined arch functions of same name
  mm, oom: remove redundant sleep in pagefault oom handler
  mm, oom: cleanup pagefault oom handler
  memory_hotplug: allow online/offline memory to result movable node
  numa: add CONFIG_MOVABLE_NODE for movable-dedicated node
  mm, memcg: avoid unnecessary function call when memcg is disabled
  ...

1 files changed, 22 insertions, 14 deletions

diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 34f372ad89d0..88e7293b96bd 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1057,7 +1057,7 @@ static void return_unused_surplus_pages(struct hstate *h,
          * on-line nodes with memory and will handle the hstate accounting.
          */
         while (nr_pages--) {
-                if (!free_pool_huge_page(h, &node_states[N_HIGH_MEMORY], 1))
+                if (!free_pool_huge_page(h, &node_states[N_MEMORY], 1))
                         break;
         }
 }
@@ -1180,14 +1180,14 @@ static struct page *alloc_huge_page(struct vm_area_struct *vma,
 int __weak alloc_bootmem_huge_page(struct hstate *h)
 {
         struct huge_bootmem_page *m;
-        int nr_nodes = nodes_weight(node_states[N_HIGH_MEMORY]);
+        int nr_nodes = nodes_weight(node_states[N_MEMORY]);
 
         while (nr_nodes) {
                 void *addr;
 
                 addr = __alloc_bootmem_node_nopanic(
                                 NODE_DATA(hstate_next_node_to_alloc(h,
-                                                &node_states[N_HIGH_MEMORY])),
+                                                &node_states[N_MEMORY])),
                                 huge_page_size(h), huge_page_size(h), 0);
 
                 if (addr) {
@@ -1259,7 +1259,7 @@ static void __init hugetlb_hstate_alloc_pages(struct hstate *h)
                         if (!alloc_bootmem_huge_page(h))
                                 break;
                 } else if (!alloc_fresh_huge_page(h,
-                                         &node_states[N_HIGH_MEMORY]))
+                                         &node_states[N_MEMORY]))
                         break;
         }
         h->max_huge_pages = i;
@@ -1527,7 +1527,7 @@ static ssize_t nr_hugepages_store_common(bool obey_mempolicy,
                 if (!(obey_mempolicy &&
                                 init_nodemask_of_mempolicy(nodes_allowed))) {
                         NODEMASK_FREE(nodes_allowed);
-                        nodes_allowed = &node_states[N_HIGH_MEMORY];
+                        nodes_allowed = &node_states[N_MEMORY];
                 }
         } else if (nodes_allowed) {
                 /*
@@ -1537,11 +1537,11 @@ static ssize_t nr_hugepages_store_common(bool obey_mempolicy,
                 count += h->nr_huge_pages - h->nr_huge_pages_node[nid];
                 init_nodemask_of_node(nodes_allowed, nid);
         } else
-                nodes_allowed = &node_states[N_HIGH_MEMORY];
+                nodes_allowed = &node_states[N_MEMORY];
 
         h->max_huge_pages = set_max_huge_pages(h, count, nodes_allowed);
 
-        if (nodes_allowed != &node_states[N_HIGH_MEMORY])
+        if (nodes_allowed != &node_states[N_MEMORY])
                 NODEMASK_FREE(nodes_allowed);
 
         return len;
@@ -1844,7 +1844,7 @@ static void hugetlb_register_all_nodes(void)
 {
         int nid;
 
-        for_each_node_state(nid, N_HIGH_MEMORY) {
+        for_each_node_state(nid, N_MEMORY) {
                 struct node *node = node_devices[nid];
                 if (node->dev.id == nid)
                         hugetlb_register_node(node);
@@ -1939,8 +1939,8 @@ void __init hugetlb_add_hstate(unsigned order)
         for (i = 0; i < MAX_NUMNODES; ++i)
                 INIT_LIST_HEAD(&h->hugepage_freelists[i]);
         INIT_LIST_HEAD(&h->hugepage_activelist);
-        h->next_nid_to_alloc = first_node(node_states[N_HIGH_MEMORY]);
-        h->next_nid_to_free = first_node(node_states[N_HIGH_MEMORY]);
+        h->next_nid_to_alloc = first_node(node_states[N_MEMORY]);
+        h->next_nid_to_free = first_node(node_states[N_MEMORY]);
         snprintf(h->name, HSTATE_NAME_LEN, "hugepages-%lukB",
                                         huge_page_size(h)/1024);
         /*
@@ -2035,11 +2035,11 @@ static int hugetlb_sysctl_handler_common(bool obey_mempolicy,
                 if (!(obey_mempolicy &&
                                init_nodemask_of_mempolicy(nodes_allowed))) {
                         NODEMASK_FREE(nodes_allowed);
-                        nodes_allowed = &node_states[N_HIGH_MEMORY];
+                        nodes_allowed = &node_states[N_MEMORY];
                 }
                 h->max_huge_pages = set_max_huge_pages(h, tmp, nodes_allowed);
 
-                if (nodes_allowed != &node_states[N_HIGH_MEMORY])
+                if (nodes_allowed != &node_states[N_MEMORY])
                         NODEMASK_FREE(nodes_allowed);
         }
 out:
@@ -2386,8 +2386,10 @@ again:
                 /*
                  * HWPoisoned hugepage is already unmapped and dropped reference
                  */
-                if (unlikely(is_hugetlb_entry_hwpoisoned(pte)))
+                if (unlikely(is_hugetlb_entry_hwpoisoned(pte))) {
+                        pte_clear(mm, address, ptep);
                         continue;
+                }
 
                 page = pte_page(pte);
                 /*
@@ -3170,7 +3172,13 @@ int dequeue_hwpoisoned_huge_page(struct page *hpage)
 
         spin_lock(&hugetlb_lock);
         if (is_hugepage_on_freelist(hpage)) {
-                list_del(&hpage->lru);
+                /*
+                 * Hwpoisoned hugepage isn't linked to activelist or freelist,
+                 * but dangling hpage->lru can trigger list-debug warnings
+                 * (this happens when we call unpoison_memory() on it),
+                 * so let it point to itself with list_del_init().
+                 */
+                list_del_init(&hpage->lru);
                 set_page_refcounted(hpage);
                 h->free_huge_pages--;
                 h->free_huge_pages_node[nid]--;