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
  ...

3 files changed, 17 insertions, 39 deletions

diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index b017887d632f..7bb63eea6eb8 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -302,10 +302,10 @@ static void guarantee_online_cpus(const struct cpuset *cs,
  * are online, with memory.  If none are online with memory, walk
  * up the cpuset hierarchy until we find one that does have some
  * online mems.  If we get all the way to the top and still haven't
- * found any online mems, return node_states[N_HIGH_MEMORY].
+ * found any online mems, return node_states[N_MEMORY].
  *
  * One way or another, we guarantee to return some non-empty subset
- * of node_states[N_HIGH_MEMORY].
+ * of node_states[N_MEMORY].
  *
  * Call with callback_mutex held.
  */
@@ -313,14 +313,14 @@ static void guarantee_online_cpus(const struct cpuset *cs,
 static void guarantee_online_mems(const struct cpuset *cs, nodemask_t *pmask)
 {
         while (cs && !nodes_intersects(cs->mems_allowed,
-                                        node_states[N_HIGH_MEMORY]))
+                                        node_states[N_MEMORY]))
                 cs = cs->parent;
         if (cs)
                 nodes_and(*pmask, cs->mems_allowed,
-                                        node_states[N_HIGH_MEMORY]);
+                                        node_states[N_MEMORY]);
         else
-                *pmask = node_states[N_HIGH_MEMORY];
-        BUG_ON(!nodes_intersects(*pmask, node_states[N_HIGH_MEMORY]));
+                *pmask = node_states[N_MEMORY];
+        BUG_ON(!nodes_intersects(*pmask, node_states[N_MEMORY]));
 }
 
 /*
@@ -1100,7 +1100,7 @@ static int update_nodemask(struct cpuset *cs, struct cpuset *trialcs,
                 return -ENOMEM;
 
         /*
-         * top_cpuset.mems_allowed tracks node_stats[N_HIGH_MEMORY];
+         * top_cpuset.mems_allowed tracks node_stats[N_MEMORY];
          * it's read-only
          */
         if (cs == &top_cpuset) {
@@ -1122,7 +1122,7 @@ static int update_nodemask(struct cpuset *cs, struct cpuset *trialcs,
                         goto done;
 
                 if (!nodes_subset(trialcs->mems_allowed,
-                                node_states[N_HIGH_MEMORY])) {
+                                node_states[N_MEMORY])) {
                         retval =  -EINVAL;
                         goto done;
                 }
@@ -2026,7 +2026,7 @@ static struct cpuset *cpuset_next(struct list_head *queue)
  * before dropping down to the next.  It always processes a node before
  * any of its children.
  *
- * In the case of memory hot-unplug, it will remove nodes from N_HIGH_MEMORY
+ * In the case of memory hot-unplug, it will remove nodes from N_MEMORY
  * if all present pages from a node are offlined.
  */
 static void
@@ -2065,7 +2065,7 @@ scan_cpusets_upon_hotplug(struct cpuset *root, enum hotplug_event event)
 
                         /* Continue past cpusets with all mems online */
                         if (nodes_subset(cp->mems_allowed,
-                                        node_states[N_HIGH_MEMORY]))
+                                        node_states[N_MEMORY]))
                                 continue;
 
                         oldmems = cp->mems_allowed;
@@ -2073,7 +2073,7 @@ scan_cpusets_upon_hotplug(struct cpuset *root, enum hotplug_event event)
                         /* Remove offline mems from this cpuset. */
                         mutex_lock(&callback_mutex);
                         nodes_and(cp->mems_allowed, cp->mems_allowed,
-                                                node_states[N_HIGH_MEMORY]);
+                                                node_states[N_MEMORY]);
                         mutex_unlock(&callback_mutex);
 
                         /* Move tasks from the empty cpuset to a parent */
@@ -2126,8 +2126,8 @@ void cpuset_update_active_cpus(bool cpu_online)
 
 #ifdef CONFIG_MEMORY_HOTPLUG
 /*
- * Keep top_cpuset.mems_allowed tracking node_states[N_HIGH_MEMORY].
- * Call this routine anytime after node_states[N_HIGH_MEMORY] changes.
+ * Keep top_cpuset.mems_allowed tracking node_states[N_MEMORY].
+ * Call this routine anytime after node_states[N_MEMORY] changes.
  * See cpuset_update_active_cpus() for CPU hotplug handling.
  */
 static int cpuset_track_online_nodes(struct notifier_block *self,
@@ -2140,7 +2140,7 @@ static int cpuset_track_online_nodes(struct notifier_block *self,
         case MEM_ONLINE:
                 oldmems = top_cpuset.mems_allowed;
                 mutex_lock(&callback_mutex);
-                top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+                top_cpuset.mems_allowed = node_states[N_MEMORY];
                 mutex_unlock(&callback_mutex);
                 update_tasks_nodemask(&top_cpuset, &oldmems, NULL);
                 break;
@@ -2169,7 +2169,7 @@ static int cpuset_track_online_nodes(struct notifier_block *self,
 void __init cpuset_init_smp(void)
 {
         cpumask_copy(top_cpuset.cpus_allowed, cpu_active_mask);
-        top_cpuset.mems_allowed = node_states[N_HIGH_MEMORY];
+        top_cpuset.mems_allowed = node_states[N_MEMORY];
 
         hotplug_memory_notifier(cpuset_track_online_nodes, 10);
 
@@ -2237,7 +2237,7 @@ void cpuset_init_current_mems_allowed(void)
  *
  * Description: Returns the nodemask_t mems_allowed of the cpuset
  * attached to the specified @tsk.  Guaranteed to return some non-empty
- * subset of node_states[N_HIGH_MEMORY], even if this means going outside the
+ * subset of node_states[N_MEMORY], even if this means going outside the
  * tasks cpuset.
  **/
 
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 29fb60caecb5..691dc2ef9baf 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -428,7 +428,7 @@ int kthreadd(void *unused)
         set_task_comm(tsk, "kthreadd");
         ignore_signals(tsk);
         set_cpus_allowed_ptr(tsk, cpu_all_mask);
-        set_mems_allowed(node_states[N_HIGH_MEMORY]);
+        set_mems_allowed(node_states[N_MEMORY]);
 
         current->flags |= PF_NOFREEZE;
 
diff --git a/kernel/res_counter.c b/kernel/res_counter.c
index ad581aa2369a..3920d593e63c 100644
--- a/kernel/res_counter.c
+++ b/kernel/res_counter.c
@@ -192,25 +192,3 @@ int res_counter_memparse_write_strategy(const char *buf,
         *res = PAGE_ALIGN(*res);
         return 0;
 }
-
-int res_counter_write(struct res_counter *counter, int member,
-                      const char *buf, write_strategy_fn write_strategy)
-{
-        char *end;
-        unsigned long flags;
-        unsigned long long tmp, *val;
-
-        if (write_strategy) {
-                if (write_strategy(buf, &tmp))
-                        return -EINVAL;
-        } else {
-                tmp = simple_strtoull(buf, &end, 10);
-                if (*end != '\0')
-                        return -EINVAL;
-        }
-        spin_lock_irqsave(&counter->lock, flags);
-        val = res_counter_member(counter, member);
-        *val = tmp;
-        spin_unlock_irqrestore(&counter->lock, flags);
-        return 0;
-}