[PATCH] memory hotplug: move section_mem_map alloc to sparse.c (0b0acbec) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/acpi/acpi_memhotplug.c

+2 −3

Original line number	Original line	Diff line number	Diff line
	@@ -200,8 +200,7 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
	* Note: Assume that this function returns zero on success		* Note: Assume that this function returns zero on success
	*/		*/
	result = add_memory(mem_device->start_addr,		result = add_memory(mem_device->start_addr,
	(mem_device->end_addr - mem_device->start_addr) + 1,		(mem_device->end_addr - mem_device->start_addr) + 1);
	mem_device->read_write_attribute);
	if (result) {		if (result) {
	ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
	mem_device->state = MEMORY_INVALID_STATE;		mem_device->state = MEMORY_INVALID_STATE;
	@@ -259,7 +258,7 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
	* Ask the VM to offline this memory range.		* Ask the VM to offline this memory range.
	* Note: Assume that this function returns zero on success		* Note: Assume that this function returns zero on success
	*/		*/
	result = remove_memory(start, len, attr);		result = remove_memory(start, len);
	if (result) {		if (result) {
	ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));
	return_VALUE(result);		return_VALUE(result);

drivers/base/memory.c

+1 −4

Original line number	Original line	Diff line number	Diff line
	@@ -340,15 +340,12 @@ static int memory_probe_init(void)
	static int add_memory_block(unsigned long node_id, struct mem_section *section,		static int add_memory_block(unsigned long node_id, struct mem_section *section,
	unsigned long state, int phys_device)		unsigned long state, int phys_device)
	{		{
	size_t size = sizeof(struct memory_block);		struct memory_block mem = kzalloc(sizeof(mem), GFP_KERNEL);
	struct memory_block *mem = kmalloc(size, GFP_KERNEL);
	int ret = 0;		int ret = 0;

	if (!mem)		if (!mem)
	return -ENOMEM;		return -ENOMEM;

	memset(mem, 0, size);

	mem->phys_index = __section_nr(section);		mem->phys_index = __section_nr(section);
	mem->state = state;		mem->state = state;
	init_MUTEX(&mem->state_sem);		init_MUTEX(&mem->state_sem);

mm/memory_hotplug.c

+3 −45

Original line number	Original line	Diff line number	Diff line
	@@ -24,28 +24,6 @@

	#include <asm/tlbflush.h>		#include <asm/tlbflush.h>

	static struct page *__kmalloc_section_memmap(unsigned long nr_pages)
	{
	struct page page, ret;
	unsigned long memmap_size = sizeof(struct page) * nr_pages;

	page = alloc_pages(GFP_KERNEL, get_order(memmap_size));
	if (page)
	goto got_map_page;

	ret = vmalloc(memmap_size);
	if (ret)
	goto got_map_ptr;

	return NULL;
	got_map_page:
	ret = (struct page *)pfn_to_kaddr(page_to_pfn(page));
	got_map_ptr:
	memset(ret, 0, memmap_size);

	return ret;
	}

	extern void zonetable_add(struct zone *zone, int nid, int zid, unsigned long pfn,		extern void zonetable_add(struct zone *zone, int nid, int zid, unsigned long pfn,
	unsigned long size);		unsigned long size);
	static void __add_zone(struct zone *zone, unsigned long phys_start_pfn)		static void __add_zone(struct zone *zone, unsigned long phys_start_pfn)
	@@ -60,35 +38,15 @@ static void __add_zone(struct zone *zone, unsigned long phys_start_pfn)
	zonetable_add(zone, nid, zone_type, phys_start_pfn, nr_pages);		zonetable_add(zone, nid, zone_type, phys_start_pfn, nr_pages);
	}		}

	extern int sparse_add_one_section(struct zone *, unsigned long,		extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
	struct page *mem_map);		int nr_pages);
	static int __add_section(struct zone *zone, unsigned long phys_start_pfn)		static int __add_section(struct zone *zone, unsigned long phys_start_pfn)
	{		{
	struct pglist_data *pgdat = zone->zone_pgdat;		struct pglist_data *pgdat = zone->zone_pgdat;
	int nr_pages = PAGES_PER_SECTION;		int nr_pages = PAGES_PER_SECTION;
	struct page *memmap;
	int ret;		int ret;

	/*		ret = sparse_add_one_section(zone, phys_start_pfn, nr_pages);
	* This can potentially allocate memory, and does its own
	* internal locking.
	*/
	sparse_index_init(pfn_to_section_nr(phys_start_pfn), pgdat->node_id);

	pgdat_resize_lock(pgdat, &flags);
	memmap = __kmalloc_section_memmap(nr_pages);
	ret = sparse_add_one_section(zone, phys_start_pfn, memmap);
	pgdat_resize_unlock(pgdat, &flags);

	if (ret <= 0) {
	/* the mem_map didn't get used */
	if (memmap >= (struct page *)VMALLOC_START &&
	memmap < (struct page *)VMALLOC_END)
	vfree(memmap);
	else
	free_pages((unsigned long)memmap,
	get_order(sizeof(struct page) * nr_pages));
	}

	if (ret < 0)		if (ret < 0)
	return ret;		return ret;

mm/sparse.c

+69 −5

Original line number	Original line	Diff line number	Diff line
	@@ -5,8 +5,10 @@
	#include <linux/mm.h>		#include <linux/mm.h>
	#include <linux/mmzone.h>		#include <linux/mmzone.h>
	#include <linux/bootmem.h>		#include <linux/bootmem.h>
			#include <linux/highmem.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/spinlock.h>		#include <linux/spinlock.h>
			#include <linux/vmalloc.h>
	#include <asm/dma.h>		#include <asm/dma.h>

	/*		/*
	@@ -187,6 +189,45 @@ static struct page *sparse_early_mem_map_alloc(unsigned long pnum)
	return NULL;		return NULL;
	}		}

			static struct page *__kmalloc_section_memmap(unsigned long nr_pages)
			{
			struct page page, ret;
			unsigned long memmap_size = sizeof(struct page) * nr_pages;

			page = alloc_pages(GFP_KERNEL, get_order(memmap_size));
			if (page)
			goto got_map_page;

			ret = vmalloc(memmap_size);
			if (ret)
			goto got_map_ptr;

			return NULL;
			got_map_page:
			ret = (struct page *)pfn_to_kaddr(page_to_pfn(page));
			got_map_ptr:
			memset(ret, 0, memmap_size);

			return ret;
			}

			static int vaddr_in_vmalloc_area(void *addr)
			{
			if (addr >= (void *)VMALLOC_START &&
			addr < (void *)VMALLOC_END)
			return 1;
			return 0;
			}

			static void __kfree_section_memmap(struct page *memmap, unsigned long nr_pages)
			{
			if (vaddr_in_vmalloc_area(memmap))
			vfree(memmap);
			else
			free_pages((unsigned long)memmap,
			get_order(sizeof(struct page) * nr_pages));
			}

	/*		/*
	* Allocate the accumulated non-linear sections, allocate a mem_map		* Allocate the accumulated non-linear sections, allocate a mem_map
	* for each and record the physical to section mapping.		* for each and record the physical to section mapping.
	@@ -212,14 +253,37 @@ void sparse_init(void)
	* set. If this is <=0, then that means that the passed-in		* set. If this is <=0, then that means that the passed-in
	* map was not consumed and must be freed.		* map was not consumed and must be freed.
	*/		*/
	int sparse_add_one_section(unsigned long start_pfn, int nr_pages, struct page *map)		int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
			int nr_pages)
	{		{
	struct mem_section *ms = __pfn_to_section(start_pfn);		unsigned long section_nr = pfn_to_section_nr(start_pfn);
			struct pglist_data *pgdat = zone->zone_pgdat;
			struct mem_section *ms;
			struct page *memmap;
			unsigned long flags;
			int ret;

	if (ms->section_mem_map & SECTION_MARKED_PRESENT)		/*
	return -EEXIST;		* no locking for this, because it does its own
			* plus, it does a kmalloc
			*/
			sparse_index_init(section_nr, pgdat->node_id);
			memmap = __kmalloc_section_memmap(nr_pages);

			pgdat_resize_lock(pgdat, &flags);

			ms = __pfn_to_section(start_pfn);
			if (ms->section_mem_map & SECTION_MARKED_PRESENT) {
			ret = -EEXIST;
			goto out;
			}
	ms->section_mem_map \|= SECTION_MARKED_PRESENT;		ms->section_mem_map \|= SECTION_MARKED_PRESENT;

	return sparse_init_one_section(ms, pfn_to_section_nr(start_pfn), map);		ret = sparse_init_one_section(ms, section_nr, memmap);

			if (ret <= 0)
			__kfree_section_memmap(memmap, nr_pages);
			out:
			pgdat_resize_unlock(pgdat, &flags);
			return ret;
	}		}