1 files changed, 122 insertions, 3 deletions

diff --git a/arch/x86/mm/srat.c b/arch/x86/mm/srat.c
index cdd0da9dd530..79836d01f789 100644
--- a/arch/x86/mm/srat.c
+++ b/arch/x86/mm/srat.c
@@ -141,11 +141,126 @@ static inline int save_add_info(void) {return 1;}
 static inline int save_add_info(void) {return 0;}
 #endif
 
+#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
+static void __init
+handle_movablemem(int node, u64 start, u64 end, u32 hotpluggable)
+{
+        int overlap, i;
+        unsigned long start_pfn, end_pfn;
+
+        start_pfn = PFN_DOWN(start);
+        end_pfn = PFN_UP(end);
+
+        /*
+         * For movablemem_map=acpi:
+         *
+         * SRAT:                |_____| |_____| |_________| |_________| ......
+         * node id:                0       1         1           2
+         * hotpluggable:           n       y         y           n
+         * movablemem_map:              |_____| |_________|
+         *
+         * Using movablemem_map, we can prevent memblock from allocating memory
+         * on ZONE_MOVABLE at boot time.
+         *
+         * Before parsing SRAT, memblock has already reserve some memory ranges
+         * for other purposes, such as for kernel image. We cannot prevent
+         * kernel from using these memory, so we need to exclude these memory
+         * even if it is hotpluggable.
+         * Furthermore, to ensure the kernel has enough memory to boot, we make
+         * all the memory on the node which the kernel resides in
+         * un-hotpluggable.
+         */
+        if (hotpluggable && movablemem_map.acpi) {
+                /* Exclude ranges reserved by memblock. */
+                struct memblock_type *rgn = &memblock.reserved;
+
+                for (i = 0; i < rgn->cnt; i++) {
+                        if (end <= rgn->regions[i].base ||
+                            start >= rgn->regions[i].base +
+                            rgn->regions[i].size)
+                                continue;
+
+                        /*
+                         * If the memory range overlaps the memory reserved by
+                         * memblock, then the kernel resides in this node.
+                         */
+                        node_set(node, movablemem_map.numa_nodes_kernel);
+
+                        goto out;
+                }
+
+                /*
+                 * If the kernel resides in this node, then the whole node
+                 * should not be hotpluggable.
+                 */
+                if (node_isset(node, movablemem_map.numa_nodes_kernel))
+                        goto out;
+
+                insert_movablemem_map(start_pfn, end_pfn);
+
+                /*
+                 * numa_nodes_hotplug nodemask represents which nodes are put
+                 * into movablemem_map.map[].
+                 */
+                node_set(node, movablemem_map.numa_nodes_hotplug);
+                goto out;
+        }
+
+        /*
+         * For movablemem_map=nn[KMG]@ss[KMG]:
+         *
+         * SRAT:                |_____| |_____| |_________| |_________| ......
+         * node id:                0       1         1           2
+         * user specified:                |__|                 |___|
+         * movablemem_map:                |___| |_________|    |______| ......
+         *
+         * Using movablemem_map, we can prevent memblock from allocating memory
+         * on ZONE_MOVABLE at boot time.
+         *
+         * NOTE: In this case, SRAT info will be ingored.
+         */
+        overlap = movablemem_map_overlap(start_pfn, end_pfn);
+        if (overlap >= 0) {
+                /*
+                 * If part of this range is in movablemem_map, we need to
+                 * add the range after it to extend the range to the end
+                 * of the node, because from the min address specified to
+                 * the end of the node will be ZONE_MOVABLE.
+                 */
+                start_pfn = max(start_pfn,
+                            movablemem_map.map[overlap].start_pfn);
+                insert_movablemem_map(start_pfn, end_pfn);
+
+                /*
+                 * Set the nodemask, so that if the address range on one node
+                 * is not continuse, we can add the subsequent ranges on the
+                 * same node into movablemem_map.
+                 */
+                node_set(node, movablemem_map.numa_nodes_hotplug);
+        } else {
+                if (node_isset(node, movablemem_map.numa_nodes_hotplug))
+                        /*
+                         * Insert the range if we already have movable ranges
+                         * on the same node.
+                         */
+                        insert_movablemem_map(start_pfn, end_pfn);
+        }
+out:
+        return;
+}
+#else           /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
+static inline void
+handle_movablemem(int node, u64 start, u64 end, u32 hotpluggable)
+{
+}
+#endif          /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
+
 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
 int __init
 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 {
         u64 start, end;
+        u32 hotpluggable;
         int node, pxm;
 
         if (srat_disabled())
@@ -154,7 +269,8 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
                 goto out_err_bad_srat;
         if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
                 goto out_err;
-        if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
+        hotpluggable = ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE;
+        if (hotpluggable && !save_add_info())
                 goto out_err;
 
         start = ma->base_address;
@@ -174,9 +290,12 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 
         node_set(node, numa_nodes_parsed);
 
-        printk(KERN_INFO "SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx]\n",
+        printk(KERN_INFO "SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx] %s\n",
                node, pxm,
-               (unsigned long long) start, (unsigned long long) end - 1);
+               (unsigned long long) start, (unsigned long long) end - 1,
+               hotpluggable ? "Hot Pluggable": "");
+
+        handle_movablemem(node, start, end, hotpluggable);
 
         return 0;
 out_err_bad_srat: