[mirror_ubuntu-jammy-kernel.git] / arch / sh / mm / init.c

/*
 * linux/arch/sh/mm/init.c
 *
 *  Copyright (C) 1999  Niibe Yutaka
 *  Copyright (C) 2002 - 2007  Paul Mundt
 *
 *  Based on linux/arch/i386/mm/init.c:
 *   Copyright (C) 1995  Linus Torvalds
 */
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/proc_fs.h>
#include <linux/pagemap.h>
#include <linux/percpu.h>
#include <linux/io.h>
#include <asm/mmu_context.h>
#include <asm/tlb.h>
#include <asm/cacheflush.h>
#include <asm/sections.h>
#include <asm/cache.h>

DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
pgd_t swapper_pg_dir[PTRS_PER_PGD];
unsigned long cached_to_uncached = 0;

void show_mem(void)
{
	int total = 0, reserved = 0, free = 0;
	int shared = 0, cached = 0, slab = 0;
	pg_data_t *pgdat;

	printk("Mem-info:\n");
	show_free_areas();

	for_each_online_pgdat(pgdat) {
		unsigned long flags, i;

		pgdat_resize_lock(pgdat, &flags);
		for (i = 0; i < pgdat->node_spanned_pages; i++) {
			struct page *page = pgdat_page_nr(pgdat, i);
			total++;
			if (PageReserved(page))
				reserved++;
			else if (PageSwapCache(page))
				cached++;
			else if (PageSlab(page))
				slab++;
			else if (!page_count(page))
				free++;
			else
				shared += page_count(page) - 1;
		}
		pgdat_resize_unlock(pgdat, &flags);
	}

	printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
	printk("%d pages of RAM\n", total);
	printk("%d free pages\n", free);
	printk("%d reserved pages\n", reserved);
	printk("%d slab pages\n", slab);
	printk("%d pages shared\n", shared);
	printk("%d pages swap cached\n", cached);
	printk(KERN_INFO "Total of %ld pages in page table cache\n",
	       quicklist_total_size());
}

#ifdef CONFIG_MMU
static void set_pte_phys(unsigned long addr, unsigned long phys, pgprot_t prot)
{
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;

	pgd = pgd_offset_k(addr);
	if (pgd_none(*pgd)) {
		pgd_ERROR(*pgd);
		return;
	}

	pud = pud_alloc(NULL, pgd, addr);
	if (unlikely(!pud)) {
		pud_ERROR(*pud);
		return;
	}

	pmd = pmd_alloc(NULL, pud, addr);
	if (unlikely(!pmd)) {
		pmd_ERROR(*pmd);
		return;
	}

	pte = pte_offset_kernel(pmd, addr);
	if (!pte_none(*pte)) {
		pte_ERROR(*pte);
		return;
	}

	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, prot));

	if (cached_to_uncached)
		flush_tlb_one(get_asid(), addr);
}

/*
 * As a performance optimization, other platforms preserve the fixmap mapping
 * across a context switch, we don't presently do this, but this could be done
 * in a similar fashion as to the wired TLB interface that sh64 uses (by way
 * of the memory mapped UTLB configuration) -- this unfortunately forces us to
 * give up a TLB entry for each mapping we want to preserve. While this may be
 * viable for a small number of fixmaps, it's not particularly useful for
 * everything and needs to be carefully evaluated. (ie, we may want this for
 * the vsyscall page).
 *
 * XXX: Perhaps add a _PAGE_WIRED flag or something similar that we can pass
 * in at __set_fixmap() time to determine the appropriate behavior to follow.
 *
 *					 -- PFM.
 */
void __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
{
	unsigned long address = __fix_to_virt(idx);

	if (idx >= __end_of_fixed_addresses) {
		BUG();
		return;
	}

	set_pte_phys(address, phys, prot);
}

void __init page_table_range_init(unsigned long start, unsigned long end,
					 pgd_t *pgd_base)
{
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	int pgd_idx;
	unsigned long vaddr;

	vaddr = start & PMD_MASK;
	end = (end + PMD_SIZE - 1) & PMD_MASK;
	pgd_idx = pgd_index(vaddr);
	pgd = pgd_base + pgd_idx;

	for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {
		BUG_ON(pgd_none(*pgd));
		pud = pud_offset(pgd, 0);
		BUG_ON(pud_none(*pud));
		pmd = pmd_offset(pud, 0);

		if (!pmd_present(*pmd)) {
			pte_t *pte_table;
			pte_table = (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
			memset(pte_table, 0, PAGE_SIZE);
			pmd_populate_kernel(&init_mm, pmd, pte_table);
		}

		vaddr += PMD_SIZE;
	}
}
#endif	/* CONFIG_MMU */

/*
 * paging_init() sets up the page tables
 */
void __init paging_init(void)
{
	unsigned long max_zone_pfns[MAX_NR_ZONES];
	int nid;

	/* We don't need to map the kernel through the TLB, as
	 * it is permanatly mapped using P1. So clear the
	 * entire pgd. */
	memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));

	/* Set an initial value for the MMU.TTB so we don't have to
	 * check for a null value. */
	set_TTB(swapper_pg_dir);

	/* Populate the relevant portions of swapper_pg_dir so that
	 * we can use the fixmap entries without calling kmalloc.
	 * pte's will be filled in by __set_fixmap(). */
	page_table_range_init(FIXADDR_START, FIXADDR_TOP, swapper_pg_dir);

	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));

	for_each_online_node(nid) {
		pg_data_t *pgdat = NODE_DATA(nid);
		unsigned long low, start_pfn;

		start_pfn = pgdat->bdata->node_boot_start >> PAGE_SHIFT;
		low = pgdat->bdata->node_low_pfn;

		if (max_zone_pfns[ZONE_NORMAL] < low)
			max_zone_pfns[ZONE_NORMAL] = low;

		printk("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
		       nid, start_pfn, low);
	}

	free_area_init_nodes(max_zone_pfns);

#ifdef CONFIG_SUPERH32
	/* Set up the uncached fixmap */
	set_fixmap_nocache(FIX_UNCACHED, __pa(&__uncached_start));

#ifdef CONFIG_29BIT
	/*
	 * Handle trivial transitions between cached and uncached
	 * segments, making use of the 1:1 mapping relationship in
	 * 512MB lowmem.
	 */
	cached_to_uncached = P2SEG - P1SEG;
#endif
#endif
}

static struct kcore_list kcore_mem, kcore_vmalloc;
int after_bootmem = 0;

void __init mem_init(void)
{
	int codesize, datasize, initsize;
	int nid;

	num_physpages = 0;
	high_memory = NULL;

	for_each_online_node(nid) {
		pg_data_t *pgdat = NODE_DATA(nid);
		unsigned long node_pages = 0;
		void *node_high_memory;

		num_physpages += pgdat->node_present_pages;

		if (pgdat->node_spanned_pages)
			node_pages = free_all_bootmem_node(pgdat);

		totalram_pages += node_pages;

		node_high_memory = (void *)__va((pgdat->node_start_pfn +
						 pgdat->node_spanned_pages) <<
						 PAGE_SHIFT);
		if (node_high_memory > high_memory)
			high_memory = node_high_memory;
	}

	/* clear the zero-page */
	memset(empty_zero_page, 0, PAGE_SIZE);
	__flush_wback_region(empty_zero_page, PAGE_SIZE);

	after_bootmem = 1;

	codesize =  (unsigned long) &_etext - (unsigned long) &_text;
	datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
	initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;

	kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
	kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
		   VMALLOC_END - VMALLOC_START);

	printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
	       "%dk data, %dk init)\n",
		(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
		num_physpages << (PAGE_SHIFT-10),
		codesize >> 10,
		datasize >> 10,
		initsize >> 10);

	p3_cache_init();

	/* Initialize the vDSO */
	vsyscall_init();
}

void free_initmem(void)
{
	unsigned long addr;

	addr = (unsigned long)(&__init_begin);
	for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
		ClearPageReserved(virt_to_page(addr));
		init_page_count(virt_to_page(addr));
		free_page(addr);
		totalram_pages++;
	}
	printk("Freeing unused kernel memory: %ldk freed\n",
	       ((unsigned long)&__init_end -
	        (unsigned long)&__init_begin) >> 10);
}

#ifdef CONFIG_BLK_DEV_INITRD
void free_initrd_mem(unsigned long start, unsigned long end)
{
	unsigned long p;
	for (p = start; p < end; p += PAGE_SIZE) {
		ClearPageReserved(virt_to_page(p));
		init_page_count(virt_to_page(p));
		free_page(p);
		totalram_pages++;
	}
	printk("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
}
#endif

#ifdef CONFIG_MEMORY_HOTPLUG
void online_page(struct page *page)
{
	ClearPageReserved(page);
	init_page_count(page);
	__free_page(page);
	totalram_pages++;
	num_physpages++;
}

int arch_add_memory(int nid, u64 start, u64 size)
{
	pg_data_t *pgdat;
	unsigned long start_pfn = start >> PAGE_SHIFT;
	unsigned long nr_pages = size >> PAGE_SHIFT;
	int ret;

	pgdat = NODE_DATA(nid);

	/* We only have ZONE_NORMAL, so this is easy.. */
	ret = __add_pages(pgdat->node_zones + ZONE_NORMAL, start_pfn, nr_pages);
	if (unlikely(ret))
		printk("%s: Failed, __add_pages() == %d\n", __FUNCTION__, ret);

	return ret;
}
EXPORT_SYMBOL_GPL(arch_add_memory);

#ifdef CONFIG_NUMA
int memory_add_physaddr_to_nid(u64 addr)
{
	/* Node 0 for now.. */
	return 0;
}
EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
#endif
#endif
Commit	Line	Data
01066625 PM	1	/*
01066625 PM	2	* linux/arch/sh/mm/init.c
1da177e4 LT	3	*
1da177e4 LT	4	* Copyright (C) 1999 Niibe Yutaka
01066625	5	* Copyright (C) 2002 - 2007 Paul Mundt
1da177e4 LT	6	*
	7	* Based on linux/arch/i386/mm/init.c:
	8	* Copyright (C) 1995 Linus Torvalds
	9	*/
1da177e4 LT	10	#include <linux/mm.h>
1da177e4 LT	11	#include <linux/swap.h>
1da177e4	12	#include <linux/init.h>
1da177e4	13	#include <linux/bootmem.h>
2cb7ce3b	14	#include <linux/proc_fs.h>
27641dee	15	#include <linux/pagemap.h>
01066625 PM	16	#include <linux/percpu.h>
01066625 PM	17	#include <linux/io.h>
1da177e4	18	#include <asm/mmu_context.h>
1da177e4 LT	19	#include <asm/tlb.h>
1da177e4 LT	20	#include <asm/cacheflush.h>
07cbb41b	21	#include <asm/sections.h>
1da177e4 LT	22	#include <asm/cache.h>
	23
	24	DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
	25	pgd_t swapper_pg_dir[PTRS_PER_PGD];
cbaa118e	26	unsigned long cached_to_uncached = 0;
1da177e4	27
1da177e4 LT	28	void show_mem(void)
1da177e4 LT	29	{
01066625 PM	30	int total = 0, reserved = 0, free = 0;
	31	int shared = 0, cached = 0, slab = 0;
	32	pg_data_t *pgdat;
1da177e4 LT	33
	34	printk("Mem-info:\n");
	35	show_free_areas();
01066625 PM	36
01066625 PM	37	for_each_online_pgdat(pgdat) {
dfbb9042	38	unsigned long flags, i;
01066625 PM	39
01066625 PM	40	pgdat_resize_lock(pgdat, &flags);
dfbb9042 PM	41	for (i = 0; i < pgdat->node_spanned_pages; i++) {
dfbb9042 PM	42	struct page *page = pgdat_page_nr(pgdat, i);
01066625 PM	43	total++;
	44	if (PageReserved(page))
	45	reserved++;
	46	else if (PageSwapCache(page))
	47	cached++;
	48	else if (PageSlab(page))
	49	slab++;
	50	else if (!page_count(page))
	51	free++;
	52	else
	53	shared += page_count(page) - 1;
dfbb9042	54	}
01066625	55	pgdat_resize_unlock(pgdat, &flags);
1da177e4	56	}
01066625 PM	57
	58	printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
	59	printk("%d pages of RAM\n", total);
	60	printk("%d free pages\n", free);
	61	printk("%d reserved pages\n", reserved);
	62	printk("%d slab pages\n", slab);
	63	printk("%d pages shared\n", shared);
	64	printk("%d pages swap cached\n", cached);
5f8c9908 PM	65	printk(KERN_INFO "Total of %ld pages in page table cache\n",
5f8c9908 PM	66	quicklist_total_size());
1da177e4 LT	67	}
1da177e4 LT	68
11cbb70e	69	#ifdef CONFIG_MMU
1da177e4 LT	70	static void set_pte_phys(unsigned long addr, unsigned long phys, pgprot_t prot)
	71	{
	72	pgd_t *pgd;
26ff6c11	73	pud_t *pud;
1da177e4 LT	74	pmd_t *pmd;
	75	pte_t *pte;
	76
99a596f9	77	pgd = pgd_offset_k(addr);
1da177e4 LT	78	if (pgd_none(*pgd)) {
	79	pgd_ERROR(*pgd);
	80	return;
	81	}
	82
99a596f9 SM	83	pud = pud_alloc(NULL, pgd, addr);
	84	if (unlikely(!pud)) {
	85	pud_ERROR(*pud);
	86	return;
26ff6c11 PM	87	}
26ff6c11 PM	88
99a596f9 SM	89	pmd = pmd_alloc(NULL, pud, addr);
	90	if (unlikely(!pmd)) {
	91	pmd_ERROR(*pmd);
	92	return;
1da177e4 LT	93	}
	94
	95	pte = pte_offset_kernel(pmd, addr);
	96	if (!pte_none(*pte)) {
	97	pte_ERROR(*pte);
	98	return;
	99	}
	100
	101	set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, prot));
	102
cbaa118e SM	103	if (cached_to_uncached)
cbaa118e SM	104	flush_tlb_one(get_asid(), addr);
1da177e4 LT	105	}
	106
	107	/*
	108	* As a performance optimization, other platforms preserve the fixmap mapping
	109	* across a context switch, we don't presently do this, but this could be done
	110	* in a similar fashion as to the wired TLB interface that sh64 uses (by way
e868d612	111	* of the memory mapped UTLB configuration) -- this unfortunately forces us to
1da177e4 LT	112	* give up a TLB entry for each mapping we want to preserve. While this may be
	113	* viable for a small number of fixmaps, it's not particularly useful for
	114	* everything and needs to be carefully evaluated. (ie, we may want this for
	115	* the vsyscall page).
	116	*
	117	* XXX: Perhaps add a _PAGE_WIRED flag or something similar that we can pass
	118	* in at __set_fixmap() time to determine the appropriate behavior to follow.
	119	*
	120	* -- PFM.
	121	*/
	122	void __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
	123	{
	124	unsigned long address = __fix_to_virt(idx);
	125
	126	if (idx >= __end_of_fixed_addresses) {
	127	BUG();
	128	return;
	129	}
	130
	131	set_pte_phys(address, phys, prot);
	132	}
2adb4e10 SM	133
	134	void __init page_table_range_init(unsigned long start, unsigned long end,
	135	pgd_t *pgd_base)
	136	{
	137	pgd_t *pgd;
	138	pud_t *pud;
	139	pmd_t *pmd;
	140	int pgd_idx;
	141	unsigned long vaddr;
	142
	143	vaddr = start & PMD_MASK;
	144	end = (end + PMD_SIZE - 1) & PMD_MASK;
	145	pgd_idx = pgd_index(vaddr);
	146	pgd = pgd_base + pgd_idx;
	147
	148	for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {
	149	BUG_ON(pgd_none(*pgd));
	150	pud = pud_offset(pgd, 0);
	151	BUG_ON(pud_none(*pud));
	152	pmd = pmd_offset(pud, 0);
	153
	154	if (!pmd_present(*pmd)) {
	155	pte_t *pte_table;
	156	pte_table = (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
	157	memset(pte_table, 0, PAGE_SIZE);
	158	pmd_populate_kernel(&init_mm, pmd, pte_table);
	159	}
	160
	161	vaddr += PMD_SIZE;
	162	}
	163	}
11cbb70e	164	#endif /* CONFIG_MMU */
1da177e4	165
1da177e4 LT	166	/*
1da177e4 LT	167	* paging_init() sets up the page tables
1da177e4 LT	168	*/
	169	void __init paging_init(void)
	170	{
2de212eb	171	unsigned long max_zone_pfns[MAX_NR_ZONES];
01066625	172	int nid;
1da177e4	173
01066625 PM	174	/* We don't need to map the kernel through the TLB, as
	175	* it is permanatly mapped using P1. So clear the
	176	* entire pgd. */
	177	memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));
1da177e4	178
6e4662ff SM	179	/* Set an initial value for the MMU.TTB so we don't have to
	180	* check for a null value. */
	181	set_TTB(swapper_pg_dir);
	182
2adb4e10 SM	183	/* Populate the relevant portions of swapper_pg_dir so that
	184	* we can use the fixmap entries without calling kmalloc.
	185	* pte's will be filled in by __set_fixmap(). */
	186	page_table_range_init(FIXADDR_START, FIXADDR_TOP, swapper_pg_dir);
	187
2de212eb PM	188	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
2de212eb PM	189
01066625 PM	190	for_each_online_node(nid) {
01066625 PM	191	pg_data_t *pgdat = NODE_DATA(nid);
01066625 PM	192	unsigned long low, start_pfn;
01066625 PM	193
01066625 PM	194	start_pfn = pgdat->bdata->node_boot_start >> PAGE_SHIFT;
	195	low = pgdat->bdata->node_low_pfn;
	196
2de212eb PM	197	if (max_zone_pfns[ZONE_NORMAL] < low)
2de212eb PM	198	max_zone_pfns[ZONE_NORMAL] = low;
01066625 PM	199
	200	printk("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
	201	nid, start_pfn, low);
01066625	202	}
2de212eb PM	203
2de212eb PM	204	free_area_init_nodes(max_zone_pfns);
cbaa118e	205
db02612b	206	#ifdef CONFIG_SUPERH32
cbaa118e SM	207	/* Set up the uncached fixmap */
	208	set_fixmap_nocache(FIX_UNCACHED, __pa(&__uncached_start));
	209
	210	#ifdef CONFIG_29BIT
	211	/*
	212	* Handle trivial transitions between cached and uncached
	213	* segments, making use of the 1:1 mapping relationship in
	214	* 512MB lowmem.
	215	*/
	216	cached_to_uncached = P2SEG - P1SEG;
	217	#endif
db02612b	218	#endif
1da177e4 LT	219	}
1da177e4 LT	220
2cb7ce3b	221	static struct kcore_list kcore_mem, kcore_vmalloc;
ba2727b5	222	int after_bootmem = 0;
2cb7ce3b	223
1da177e4 LT	224	void __init mem_init(void)
1da177e4 LT	225	{
dfbb9042	226	int codesize, datasize, initsize;
01066625	227	int nid;
1da177e4	228
2de212eb PM	229	num_physpages = 0;
	230	high_memory = NULL;
	231
01066625 PM	232	for_each_online_node(nid) {
	233	pg_data_t *pgdat = NODE_DATA(nid);
	234	unsigned long node_pages = 0;
	235	void *node_high_memory;
01066625 PM	236
	237	num_physpages += pgdat->node_present_pages;
	238
	239	if (pgdat->node_spanned_pages)
	240	node_pages = free_all_bootmem_node(pgdat);
	241
	242	totalram_pages += node_pages;
1da177e4	243
2de212eb PM	244	node_high_memory = (void *)__va((pgdat->node_start_pfn +
	245	pgdat->node_spanned_pages) <<
	246	PAGE_SHIFT);
01066625 PM	247	if (node_high_memory > high_memory)
	248	high_memory = node_high_memory;
	249	}
1da177e4 LT	250
	251	/* clear the zero-page */
	252	memset(empty_zero_page, 0, PAGE_SIZE);
	253	__flush_wback_region(empty_zero_page, PAGE_SIZE);
	254
ba2727b5 PM	255	after_bootmem = 1;
ba2727b5 PM	256
1da177e4 LT	257	codesize = (unsigned long) &_etext - (unsigned long) &_text;
	258	datasize = (unsigned long) &_edata - (unsigned long) &_etext;
	259	initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin;
	260
2cb7ce3b PM	261	kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
	262	kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
	263	VMALLOC_END - VMALLOC_START);
	264
	265	printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
dfbb9042	266	"%dk data, %dk init)\n",
1da177e4	267	(unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
2de212eb	268	num_physpages << (PAGE_SHIFT-10),
1da177e4	269	codesize >> 10,
1da177e4 LT	270	datasize >> 10,
	271	initsize >> 10);
	272
	273	p3_cache_init();
19f9a34f PM	274
	275	/* Initialize the vDSO */
	276	vsyscall_init();
1da177e4 LT	277	}
	278
	279	void free_initmem(void)
	280	{
	281	unsigned long addr;
65463b73	282
1da177e4 LT	283	addr = (unsigned long)(&__init_begin);
	284	for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
	285	ClearPageReserved(virt_to_page(addr));
7835e98b	286	init_page_count(virt_to_page(addr));
1da177e4 LT	287	free_page(addr);
	288	totalram_pages++;
	289	}
07cbb41b PM	290	printk("Freeing unused kernel memory: %ldk freed\n",
	291	((unsigned long)&__init_end -
	292	(unsigned long)&__init_begin) >> 10);
1da177e4 LT	293	}
	294
	295	#ifdef CONFIG_BLK_DEV_INITRD
	296	void free_initrd_mem(unsigned long start, unsigned long end)
	297	{
	298	unsigned long p;
	299	for (p = start; p < end; p += PAGE_SIZE) {
	300	ClearPageReserved(virt_to_page(p));
7835e98b	301	init_page_count(virt_to_page(p));
1da177e4 LT	302	free_page(p);
	303	totalram_pages++;
	304	}
2de212eb	305	printk("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
1da177e4 LT	306	}
1da177e4 LT	307	#endif
33d63bd8 PM	308
	309	#ifdef CONFIG_MEMORY_HOTPLUG
	310	void online_page(struct page *page)
	311	{
	312	ClearPageReserved(page);
	313	init_page_count(page);
	314	__free_page(page);
	315	totalram_pages++;
	316	num_physpages++;
	317	}
	318
	319	int arch_add_memory(int nid, u64 start, u64 size)
	320	{
	321	pg_data_t *pgdat;
	322	unsigned long start_pfn = start >> PAGE_SHIFT;
	323	unsigned long nr_pages = size >> PAGE_SHIFT;
	324	int ret;
	325
	326	pgdat = NODE_DATA(nid);
	327
	328	/* We only have ZONE_NORMAL, so this is easy.. */
	329	ret = __add_pages(pgdat->node_zones + ZONE_NORMAL, start_pfn, nr_pages);
	330	if (unlikely(ret))
	331	printk("%s: Failed, __add_pages() == %d\n", __FUNCTION__, ret);
	332
	333	return ret;
	334	}
	335	EXPORT_SYMBOL_GPL(arch_add_memory);
	336
357d5946	337	#ifdef CONFIG_NUMA
33d63bd8 PM	338	int memory_add_physaddr_to_nid(u64 addr)
	339	{
	340	/* Node 0 for now.. */
	341	return 0;
	342	}
	343	EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
	344	#endif
357d5946	345	#endif