Merge branch 'akpm' (incoming from Andrew)

Merge first patch-bomb from Andrew Morton:

 - a couple of misc things

 - inotify/fsnotify work from Jan

 - ocfs2 updates (partial)

 - about half of MM

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (117 commits)
  mm/migrate: remove unused function, fail_migrate_page()
  mm/migrate: remove putback_lru_pages, fix comment on putback_movable_pages
  mm/migrate: correct failure handling if !hugepage_migration_support()
  mm/migrate: add comment about permanent failure path
  mm, page_alloc: warn for non-blockable __GFP_NOFAIL allocation failure
  mm: compaction: reset scanner positions immediately when they meet
  mm: compaction: do not mark unmovable pageblocks as skipped in async compaction
  mm: compaction: detect when scanners meet in isolate_freepages
  mm: compaction: reset cached scanner pfn's before reading them
  mm: compaction: encapsulate defer reset logic
  mm: compaction: trace compaction begin and end
  memcg, oom: lock mem_cgroup_print_oom_info
  sched: add tracepoints related to NUMA task migration
  mm: numa: do not automatically migrate KSM pages
  mm: numa: trace tasks that fail migration due to rate limiting
  mm: numa: limit scope of lock for NUMA migrate rate limiting
  mm: numa: make NUMA-migrate related functions static
  lib/show_mem.c: show num_poisoned_pages when oom
  mm/hwpoison: add '#' to hwpoison_inject
  mm/memblock: use WARN_ONCE when MAX_NUMNODES passed as input parameter
  ...

1 files changed, 50 insertions, 2 deletions

diff --git a/arch/x86/mm/numa.c b/arch/x86/mm/numa.c
index c85da7bb6b60..81b2750f3666 100644
--- a/arch/x86/mm/numa.c
+++ b/arch/x86/mm/numa.c
@@ -491,7 +491,16 @@ static int __init numa_register_memblks(struct numa_meminfo *mi)
 
         for (i = 0; i < mi->nr_blks; i++) {
                 struct numa_memblk *mb = &mi->blk[i];
-                memblock_set_node(mb->start, mb->end - mb->start, mb->nid);
+                memblock_set_node(mb->start, mb->end - mb->start,
+                                  &memblock.memory, mb->nid);
+
+                /*
+                 * At this time, all memory regions reserved by memblock are
+                 * used by the kernel. Set the nid in memblock.reserved will
+                 * mark out all the nodes the kernel resides in.
+                 */
+                memblock_set_node(mb->start, mb->end - mb->start,
+                                  &memblock.reserved, mb->nid);
         }
 
         /*
@@ -553,6 +562,30 @@ static void __init numa_init_array(void)
         }
 }
 
+static void __init numa_clear_kernel_node_hotplug(void)
+{
+        int i, nid;
+        nodemask_t numa_kernel_nodes;
+        unsigned long start, end;
+        struct memblock_type *type = &memblock.reserved;
+
+        /* Mark all kernel nodes. */
+        for (i = 0; i < type->cnt; i++)
+                node_set(type->regions[i].nid, numa_kernel_nodes);
+
+        /* Clear MEMBLOCK_HOTPLUG flag for memory in kernel nodes. */
+        for (i = 0; i < numa_meminfo.nr_blks; i++) {
+                nid = numa_meminfo.blk[i].nid;
+                if (!node_isset(nid, numa_kernel_nodes))
+                        continue;
+
+                start = numa_meminfo.blk[i].start;
+                end = numa_meminfo.blk[i].end;
+
+                memblock_clear_hotplug(start, end - start);
+        }
+}
+
 static int __init numa_init(int (*init_func)(void))
 {
         int i;
@@ -565,7 +598,12 @@ static int __init numa_init(int (*init_func)(void))
         nodes_clear(node_possible_map);
         nodes_clear(node_online_map);
         memset(&numa_meminfo, 0, sizeof(numa_meminfo));
-        WARN_ON(memblock_set_node(0, ULLONG_MAX, MAX_NUMNODES));
+        WARN_ON(memblock_set_node(0, ULLONG_MAX, &memblock.memory,
+                                  MAX_NUMNODES));
+        WARN_ON(memblock_set_node(0, ULLONG_MAX, &memblock.reserved,
+                                  MAX_NUMNODES));
+        /* In case that parsing SRAT failed. */
+        WARN_ON(memblock_clear_hotplug(0, ULLONG_MAX));
         numa_reset_distance();
 
         ret = init_func();
@@ -601,6 +639,16 @@ static int __init numa_init(int (*init_func)(void))
                         numa_clear_node(i);
         }
         numa_init_array();
+
+        /*
+         * At very early time, the kernel have to use some memory such as
+         * loading the kernel image. We cannot prevent this anyway. So any
+         * node the kernel resides in should be un-hotpluggable.
+         *
+         * And when we come here, numa_init() won't fail.
+         */
+        numa_clear_kernel_node_hotplug();
+
         return 0;
 }