Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0b0acbec authored by Dave Hansen's avatar Dave Hansen Committed by Linus Torvalds
Browse files

[PATCH] memory hotplug: move section_mem_map alloc to sparse.c 



This basically keeps up from having to extern __kmalloc_section_memmap().

The vaddr_in_vmalloc_area() helper could go in a vmalloc header, but that
header gets hard to work with, because it needs some arch-specific macros.
Just stick it in here for now, instead of creating another header.

Signed-off-by: default avatarDave Hansen <haveblue@us.ibm.com>
Signed-off-by: default avatarLion Vollnhals <webmaster@schiggl.de>
Signed-off-by: default avatarJiri Slaby <xslaby@fi.muni.cz>
Signed-off-by: default avatarYasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 3947be19

drivers/acpi/acpi_memhotplug.c

+2 −3
Original line number 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

	 */

	result = add_memory(mem_device->start_addr,

			    (mem_device->end_addr - mem_device->start_addr) + 1,

			    mem_device->read_write_attribute);

			    (mem_device->end_addr - mem_device->start_addr) + 1);

	if (result) {

		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));

		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.

	 * Note: Assume that this function returns zero on success

	 */

	result = remove_memory(start, len, attr);

	result = remove_memory(start, len);

	if (result) {

		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));

		return_VALUE(result);

drivers/base/memory.c

+1 −4
Original line number 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,

		     unsigned long state, int phys_device)

{

	size_t size = sizeof(struct memory_block);

	struct memory_block *mem = kmalloc(size, GFP_KERNEL);

	struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);

	int ret = 0;



	if (!mem)

		return -ENOMEM;



	memset(mem, 0, size);



	mem->phys_index = __section_nr(section);

	mem->state = state;

	init_MUTEX(&mem->state_sem);

mm/memory_hotplug.c

+3 −45
Original line number Diff line number Diff line
@@ -24,28 +24,6 @@ 


#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,

			  unsigned long size);

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);

}



extern int sparse_add_one_section(struct zone *, unsigned long,

				  struct page *mem_map);

extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,

				  int nr_pages);

static int __add_section(struct zone *zone, unsigned long phys_start_pfn)

{

	struct pglist_data *pgdat = zone->zone_pgdat;

	int nr_pages = PAGES_PER_SECTION;

	struct page *memmap;

	int ret;



	/*

	 * 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));

	}

	ret = sparse_add_one_section(zone, phys_start_pfn, nr_pages);



	if (ret < 0)

		return ret;

mm/sparse.c

+69 −5
Original line number Diff line number Diff line
@@ -5,8 +5,10 @@ 
#include <linux/mm.h>

#include <linux/mmzone.h>

#include <linux/bootmem.h>

#include <linux/highmem.h>

#include <linux/module.h>

#include <linux/spinlock.h>

#include <linux/vmalloc.h>

#include <asm/dma.h>



/*
@@ -187,6 +189,45 @@ static struct page *sparse_early_mem_map_alloc(unsigned long pnum) 
	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

 * 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

 * 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;



	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;

}