x86, ACPI, mm: Revert movablemem_map support (20e6926d) · Commits · 戴 / test

Documentation/kernel-parameters.txt

+0 −36

Original line number	Diff line number	Diff line
		@@ -1645,42 +1645,6 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
		that the amount of memory usable for all allocations
		is not too small.

		movablemem_map=acpi
		[KNL,X86,IA-64,PPC] This parameter is similar to
		memmap except it specifies the memory map of
		ZONE_MOVABLE.
		This option inform the kernel to use Hot Pluggable bit
		in flags from SRAT from ACPI BIOS to determine which
		memory devices could be hotplugged. The corresponding
		memory ranges will be set as ZONE_MOVABLE.
		NOTE: Whatever node the kernel resides in will always
		be un-hotpluggable.

		movablemem_map=nn[KMG]@ss[KMG]
		[KNL,X86,IA-64,PPC] This parameter is similar to
		memmap except it specifies the memory map of
		ZONE_MOVABLE.
		If user specifies memory ranges, the info in SRAT will
		be ingored. And it works like the following:
		- If more ranges are all within one node, then from
		lowest ss to the end of the node will be ZONE_MOVABLE.
		- If a range is within a node, then from ss to the end
		of the node will be ZONE_MOVABLE.
		- If a range covers two or more nodes, then from ss to
		the end of the 1st node will be ZONE_MOVABLE, and all
		the rest nodes will only have ZONE_MOVABLE.
		If memmap is specified at the same time, the
		movablemem_map will be limited within the memmap
		areas. If kernelcore or movablecore is also specified,
		movablemem_map will have higher priority to be
		satisfied. So the administrator should be careful that
		the amount of movablemem_map areas are not too large.
		Otherwise kernel won't have enough memory to start.
		NOTE: We don't stop users specifying the node the
		kernel resides in as hotpluggable so that this
		option can be used as a workaround of firmware
		bugs.

		MTD_Partition= [MTD]
		Format: <name>,<region-number>,<size>,<offset>

arch/x86/kernel/setup.c

+4 −9

Original line number	Diff line number	Diff line
		@@ -1056,15 +1056,6 @@ void __init setup_arch(char **cmdline_p)
		setup_bios_corruption_check();
		#endif

		/*
		* In the memory hotplug case, the kernel needs info from SRAT to
		* determine which memory is hotpluggable before allocating memory
		* using memblock.
		*/
		acpi_boot_table_init();
		early_acpi_boot_init();
		early_parse_srat();

		#ifdef CONFIG_X86_32
		printk(KERN_DEBUG "initial memory mapped: [mem 0x00000000-%#010lx]\n",
		(max_pfn_mapped<<PAGE_SHIFT) - 1);
		@@ -1110,6 +1101,10 @@ void __init setup_arch(char **cmdline_p)
		/*
		* Parse the ACPI tables for possible boot-time SMP configuration.
		*/
		acpi_boot_table_init();

		early_acpi_boot_init();

		initmem_init();
		memblock_find_dma_reserve();

arch/x86/mm/numa.c

+5 −6

Original line number	Diff line number	Diff line
		@@ -212,9 +212,10 @@ static void __init setup_node_data(int nid, u64 start, u64 end)
		* Allocate node data. Try node-local memory and then any node.
		* Never allocate in DMA zone.
		*/
		nd_pa = memblock_alloc_try_nid(nd_size, SMP_CACHE_BYTES, nid);
		nd_pa = memblock_alloc_nid(nd_size, SMP_CACHE_BYTES, nid);
		if (!nd_pa) {
		pr_err("Cannot find %zu bytes in any node\n", nd_size);
		pr_err("Cannot find %zu bytes in node %d\n",
		nd_size, nid);
		return;
		}
		nd = __va(nd_pa);
		@@ -559,12 +560,10 @@ static int __init numa_init(int (*init_func)(void))
		for (i = 0; i < MAX_LOCAL_APIC; i++)
		set_apicid_to_node(i, NUMA_NO_NODE);

		/*
		* Do not clear numa_nodes_parsed or zero numa_meminfo here, because
		* SRAT was parsed earlier in early_parse_srat().
		*/
		nodes_clear(numa_nodes_parsed);
		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));
		numa_reset_distance();

arch/x86/mm/srat.c

+3 −122

Original line number	Diff line number	Diff line
		@@ -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:

drivers/acpi/numa.c

+10 −13

Original line number	Diff line number	Diff line
		@@ -282,10 +282,10 @@ acpi_table_parse_srat(enum acpi_srat_type id,
		handler, max_entries);
		}

		static int srat_mem_cnt;

		void __init early_parse_srat(void)
		int __init acpi_numa_init(void)
		{
		int cnt = 0;

		/*
		* Should not limit number with cpu num that is from NR_CPUS or nr_cpus=
		* SRAT cpu entries could have different order with that in MADT.
		@@ -298,21 +298,18 @@ void __init early_parse_srat(void)
		acpi_parse_x2apic_affinity, 0);
		acpi_table_parse_srat(ACPI_SRAT_TYPE_CPU_AFFINITY,
		acpi_parse_processor_affinity, 0);
		srat_mem_cnt = acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY,
		cnt = acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY,
		acpi_parse_memory_affinity,
		NR_NODE_MEMBLKS);
		}
		}

		int __init acpi_numa_init(void)
		{
		/* SLIT: System Locality Information Table */
		acpi_table_parse(ACPI_SIG_SLIT, acpi_parse_slit);

		acpi_numa_arch_fixup();

		if (srat_mem_cnt < 0)
		return srat_mem_cnt;
		if (cnt < 0)
		return cnt;
		else if (!parsed_numa_memblks)
		return -ENOENT;
		return 0;

Admin message