1 files changed, 3 insertions, 122 deletions

diff --git a/arch/x86/mm/srat.c b/arch/x86/mm/srat.c
index 79836d01f789..cdd0da9dd530 100644
--- a/arch/x86/mm/srat.c
+++ b/arch/x86/mm/srat.c
@@ -141,126 +141,11 @@ 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())
@@ -269,8 +154,7 @@ 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;
-        hotpluggable = ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE;
-        if (hotpluggable && !save_add_info())
+        if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
                 goto out_err;
 
         start = ma->base_address;
@@ -290,12 +174,9 @@ 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] %s\n",
+        printk(KERN_INFO "SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx]\n",
                node, pxm,
-               (unsigned long long) start, (unsigned long long) end - 1,
-               hotpluggable ? "Hot Pluggable": "");
-
-        handle_movablemem(node, start, end, hotpluggable);
+               (unsigned long long) start, (unsigned long long) end - 1);
 
         return 0;
 out_err_bad_srat: