arch/metag/mm/init.c - linux - Git at Google

 /*
  *  Copyright (C) 2005,2006,2007,2008,2009,2010 Imagination Technologies
  *
  */

 #include <linux/export.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <linux/pagemap.h>
 #include <linux/percpu.h>
 #include <linux/memblock.h>
 #include <linux/initrd.h>

 #include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
 #include <asm/mmu.h>
 #include <asm/mmu_context.h>
 #include <asm/sections.h>
 #include <asm/tlb.h>
 #include <asm/user_gateway.h>
 #include <asm/mmzone.h>
 #include <asm/fixmap.h>

 unsigned long pfn_base;
 EXPORT_SYMBOL(pfn_base);

 pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_data;

 unsigned long empty_zero_page;
 EXPORT_SYMBOL(empty_zero_page);

 extern char __user_gateway_start;
 extern char __user_gateway_end;

 void *gateway_page;

 /*
  * Insert the gateway page into a set of page tables, creating the
  * page tables if necessary.
  */
 static void insert_gateway_page(pgd_t *pgd, unsigned long address)
 {
 	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;

 	BUG_ON(!pgd_present(*pgd));

 	pud = pud_offset(pgd, address);
 	BUG_ON(!pud_present(*pud));

 	pmd = pmd_offset(pud, address);
 	if (!pmd_present(*pmd)) {
 		pte = alloc_bootmem_pages(PAGE_SIZE);
 		set_pmd(pmd, __pmd(_PAGE_TABLE | __pa(pte)));
 	}

 	pte = pte_offset_kernel(pmd, address);
 	set_pte(pte, pfn_pte(__pa(gateway_page) >> PAGE_SHIFT, PAGE_READONLY));
 }

 /* Alloc and map a page in a known location accessible to userspace. */
 static void __init user_gateway_init(void)
 {
 	unsigned long address = USER_GATEWAY_PAGE;
 	int offset = pgd_index(address);
 	pgd_t *pgd;

 	gateway_page = alloc_bootmem_pages(PAGE_SIZE);

 	pgd = swapper_pg_dir + offset;
 	insert_gateway_page(pgd, address);

 #ifdef CONFIG_METAG_META12
 	/*
 	 * Insert the gateway page into our current page tables even
 	 * though we've already inserted it into our reference page
 	 * table (swapper_pg_dir). This is because with a META1 mmu we
 	 * copy just the user address range and not the gateway page
 	 * entry on context switch, see switch_mmu().
 	 */
 	pgd = (pgd_t *)mmu_get_base() + offset;
 	insert_gateway_page(pgd, address);
 #endif /* CONFIG_METAG_META12 */

 	BUG_ON((&__user_gateway_end - &__user_gateway_start) > PAGE_SIZE);

 	gateway_page += (address & ~PAGE_MASK);

 	memcpy(gateway_page, &__user_gateway_start,
 	       &__user_gateway_end - &__user_gateway_start);

 	/*
 	 * We don't need to flush the TLB here, there should be no mapping
 	 * present at boot for this address and only valid mappings are in
 	 * the TLB (apart from on Meta 1.x, but those cached invalid
 	 * mappings should be impossible to hit here).
 	 *
 	 * We don't flush the code cache here even though we have written
 	 * code through the data cache and they may not be coherent. At
 	 * this point we assume there is no stale data in the code cache
 	 * for this address so there is no need to flush.
 	 */
 }

 static void __init allocate_pgdat(unsigned int nid)
 {
 	unsigned long start_pfn, end_pfn;
 #ifdef CONFIG_NEED_MULTIPLE_NODES
 	unsigned long phys;
 #endif

 	get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);

 #ifdef CONFIG_NEED_MULTIPLE_NODES
 	phys = __memblock_alloc_base(sizeof(struct pglist_data),
 				SMP_CACHE_BYTES, end_pfn << PAGE_SHIFT);
 	/* Retry with all of system memory */
 	if (!phys)
 		phys = __memblock_alloc_base(sizeof(struct pglist_data),
 					     SMP_CACHE_BYTES,
 					     memblock_end_of_DRAM());
 	if (!phys)
 		panic("Can't allocate pgdat for node %d\n", nid);

 	NODE_DATA(nid) = __va(phys);
 	memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));

 	NODE_DATA(nid)->bdata = &bootmem_node_data[nid];
 #endif

 	NODE_DATA(nid)->node_start_pfn = start_pfn;
 	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
 }

 static void __init bootmem_init_one_node(unsigned int nid)
 {
 	unsigned long total_pages, paddr;
 	unsigned long end_pfn;
 	struct pglist_data *p;

 	p = NODE_DATA(nid);

 	/* Nothing to do.. */
 	if (!p->node_spanned_pages)
 		return;

 	end_pfn = pgdat_end_pfn(p);
 #ifdef CONFIG_HIGHMEM
 	if (end_pfn > max_low_pfn)
 		end_pfn = max_low_pfn;
 #endif

 	total_pages = bootmem_bootmap_pages(end_pfn - p->node_start_pfn);

 	paddr = memblock_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
 	if (!paddr)
 		panic("Can't allocate bootmap for nid[%d]\n", nid);

 	init_bootmem_node(p, paddr >> PAGE_SHIFT, p->node_start_pfn, end_pfn);

 	free_bootmem_with_active_regions(nid, end_pfn);

 	/*
 	 * XXX Handle initial reservations for the system memory node
 	 * only for the moment, we'll refactor this later for handling
 	 * reservations in other nodes.
 	 */
 	if (nid == 0) {
 		struct memblock_region *reg;

 		/* Reserve the sections we're already using. */
 		for_each_memblock(reserved, reg) {
 			unsigned long size = reg->size;

 #ifdef CONFIG_HIGHMEM
 			/* ...but not highmem */
 			if (PFN_DOWN(reg->base) >= highstart_pfn)
 				continue;

 			if (PFN_UP(reg->base + size) > highstart_pfn)
 				size = (highstart_pfn - PFN_DOWN(reg->base))
 				       << PAGE_SHIFT;
 #endif

 			reserve_bootmem(reg->base, size, BOOTMEM_DEFAULT);
 		}
 	}

 	sparse_memory_present_with_active_regions(nid);
 }

 static void __init do_init_bootmem(void)
 {
 	struct memblock_region *reg;
 	int i;

 	/* Add active regions with valid PFNs. */
 	for_each_memblock(memory, reg) {
 		unsigned long start_pfn, end_pfn;
 		start_pfn = memblock_region_memory_base_pfn(reg);
 		end_pfn = memblock_region_memory_end_pfn(reg);
 		memblock_set_node(PFN_PHYS(start_pfn),
 				  PFN_PHYS(end_pfn - start_pfn),
 				  &memblock.memory, 0);
 	}

 	/* All of system RAM sits in node 0 for the non-NUMA case */
 	allocate_pgdat(0);
 	node_set_online(0);

 	soc_mem_setup();

 	for_each_online_node(i)
 		bootmem_init_one_node(i);

 	sparse_init();
 }

 extern char _heap_start[];

 static void __init init_and_reserve_mem(void)
 {
 	unsigned long start_pfn, heap_start;
 	u64 base = min_low_pfn << PAGE_SHIFT;
 	u64 size = (max_low_pfn << PAGE_SHIFT) - base;

 	heap_start = (unsigned long) &_heap_start;

 	memblock_add(base, size);

 	/*
 	 * Partially used pages are not usable - thus
 	 * we are rounding upwards:
 	 */
 	start_pfn = PFN_UP(__pa(heap_start));

 	/*
 	 * Reserve the kernel text.
 	 */
 	memblock_reserve(base, (PFN_PHYS(start_pfn) + PAGE_SIZE - 1) - base);

 #ifdef CONFIG_HIGHMEM
 	/*
 	 * Add & reserve highmem, so page structures are initialised.
 	 */
 	base = highstart_pfn << PAGE_SHIFT;
 	size = (highend_pfn << PAGE_SHIFT) - base;
 	if (size) {
 		memblock_add(base, size);
 		memblock_reserve(base, size);
 	}
 #endif
 }

 #ifdef CONFIG_HIGHMEM
 /*
  * Ensure we have allocated page tables in swapper_pg_dir for the
  * fixed mappings range from 'start' to 'end'.
  */
 static void __init allocate_pgtables(unsigned long start, unsigned long end)
 {
 	pgd_t *pgd;
 	pmd_t *pmd;
 	pte_t *pte;
 	int i, j;
 	unsigned long vaddr;

 	vaddr = start;
 	i = pgd_index(vaddr);
 	j = pmd_index(vaddr);
 	pgd = swapper_pg_dir + i;

 	for ( ; (i < PTRS_PER_PGD) && (vaddr != end); pgd++, i++) {
 		pmd = (pmd_t *)pgd;
 		for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
 			vaddr += PMD_SIZE;

 			if (!pmd_none(*pmd))
 				continue;

 			pte = (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
 			pmd_populate_kernel(&init_mm, pmd, pte);
 		}
 		j = 0;
 	}
 }

 static void __init fixedrange_init(void)
 {
 	unsigned long vaddr, end;
 	pgd_t *pgd;
 	pud_t *pud;
 	pmd_t *pmd;
 	pte_t *pte;

 	/*
 	 * Fixed mappings:
 	 */
 	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
 	end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
 	allocate_pgtables(vaddr, end);

 	/*
 	 * Permanent kmaps:
 	 */
 	vaddr = PKMAP_BASE;
 	allocate_pgtables(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP);

 	pgd = swapper_pg_dir + pgd_index(vaddr);
 	pud = pud_offset(pgd, vaddr);
 	pmd = pmd_offset(pud, vaddr);
 	pte = pte_offset_kernel(pmd, vaddr);
 	pkmap_page_table = pte;
 }
 #endif /* CONFIG_HIGHMEM */

 /*
  * paging_init() continues the virtual memory environment setup which
  * was begun by the code in arch/metag/kernel/setup.c.
  */
 void __init paging_init(unsigned long mem_end)
 {
 	unsigned long max_zone_pfns[MAX_NR_ZONES];
 	int nid;

 	init_and_reserve_mem();

 	memblock_allow_resize();

 	memblock_dump_all();

 	nodes_clear(node_online_map);

 	init_new_context(&init_task, &init_mm);

 	memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));

 	do_init_bootmem();
 	mmu_init(mem_end);

 #ifdef CONFIG_HIGHMEM
 	fixedrange_init();
 	kmap_init();
 #endif

 	/* Initialize the zero page to a bootmem page, already zeroed. */
 	empty_zero_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);

 	user_gateway_init();

 	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_min_pfn;
 		low = pgdat->bdata->node_low_pfn;

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

 #ifdef CONFIG_HIGHMEM
 		max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
 #endif
 		pr_info("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
 			nid, start_pfn, low);
 	}

 	free_area_init_nodes(max_zone_pfns);
 }

 void __init mem_init(void)
 {
 #ifdef CONFIG_HIGHMEM
 	unsigned long tmp;

 	/*
 	 * Explicitly reset zone->managed_pages because highmem pages are
 	 * freed before calling free_all_bootmem();
 	 */
 	reset_all_zones_managed_pages();
 	for (tmp = highstart_pfn; tmp < highend_pfn; tmp++)
 		free_highmem_page(pfn_to_page(tmp));
 #endif /* CONFIG_HIGHMEM */

 	free_all_bootmem();
 	mem_init_print_info(NULL);
 	show_mem(0);
 }

 void free_initmem(void)
 {
 	free_initmem_default(POISON_FREE_INITMEM);
 }

 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
 	free_reserved_area((void *)start, (void *)end, POISON_FREE_INITMEM,
 			   "initrd");
 }
 #endif
	/*
	* Copyright (C) 2005,2006,2007,2008,2009,2010 Imagination Technologies
	*
	*/

	#include <linux/export.h>
	#include <linux/mm.h>
	#include <linux/swap.h>
	#include <linux/init.h>
	#include <linux/bootmem.h>
	#include <linux/pagemap.h>
	#include <linux/percpu.h>
	#include <linux/memblock.h>
	#include <linux/initrd.h>

	#include <asm/setup.h>
	#include <asm/page.h>
	#include <asm/pgalloc.h>
	#include <asm/mmu.h>
	#include <asm/mmu_context.h>
	#include <asm/sections.h>
	#include <asm/tlb.h>
	#include <asm/user_gateway.h>
	#include <asm/mmzone.h>
	#include <asm/fixmap.h>

	unsigned long pfn_base;
	EXPORT_SYMBOL(pfn_base);

	pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_data;

	unsigned long empty_zero_page;
	EXPORT_SYMBOL(empty_zero_page);

	extern char __user_gateway_start;
	extern char __user_gateway_end;

	void *gateway_page;

	/*
	* Insert the gateway page into a set of page tables, creating the
	* page tables if necessary.
	*/
	static void insert_gateway_page(pgd_t *pgd, unsigned long address)
	{
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;

	BUG_ON(!pgd_present(*pgd));

	pud = pud_offset(pgd, address);
	BUG_ON(!pud_present(*pud));

	pmd = pmd_offset(pud, address);
	if (!pmd_present(*pmd)) {
	pte = alloc_bootmem_pages(PAGE_SIZE);
	set_pmd(pmd, __pmd(_PAGE_TABLE \| __pa(pte)));
	}

	pte = pte_offset_kernel(pmd, address);
	set_pte(pte, pfn_pte(__pa(gateway_page) >> PAGE_SHIFT, PAGE_READONLY));
	}

	/* Alloc and map a page in a known location accessible to userspace. */
	static void __init user_gateway_init(void)
	{
	unsigned long address = USER_GATEWAY_PAGE;
	int offset = pgd_index(address);
	pgd_t *pgd;

	gateway_page = alloc_bootmem_pages(PAGE_SIZE);

	pgd = swapper_pg_dir + offset;
	insert_gateway_page(pgd, address);

	#ifdef CONFIG_METAG_META12
	/*
	* Insert the gateway page into our current page tables even
	* though we've already inserted it into our reference page
	* table (swapper_pg_dir). This is because with a META1 mmu we
	* copy just the user address range and not the gateway page
	* entry on context switch, see switch_mmu().
	*/
	pgd = (pgd_t *)mmu_get_base() + offset;
	insert_gateway_page(pgd, address);
	#endif /* CONFIG_METAG_META12 */

	BUG_ON((&__user_gateway_end - &__user_gateway_start) > PAGE_SIZE);

	gateway_page += (address & ~PAGE_MASK);

	memcpy(gateway_page, &__user_gateway_start,
	&__user_gateway_end - &__user_gateway_start);

	/*
	* We don't need to flush the TLB here, there should be no mapping
	* present at boot for this address and only valid mappings are in
	* the TLB (apart from on Meta 1.x, but those cached invalid
	* mappings should be impossible to hit here).
	*
	* We don't flush the code cache here even though we have written
	* code through the data cache and they may not be coherent. At
	* this point we assume there is no stale data in the code cache
	* for this address so there is no need to flush.
	*/
	}

	static void __init allocate_pgdat(unsigned int nid)
	{
	unsigned long start_pfn, end_pfn;
	#ifdef CONFIG_NEED_MULTIPLE_NODES
	unsigned long phys;
	#endif

	get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);

	#ifdef CONFIG_NEED_MULTIPLE_NODES
	phys = __memblock_alloc_base(sizeof(struct pglist_data),
	SMP_CACHE_BYTES, end_pfn << PAGE_SHIFT);
	/* Retry with all of system memory */
	if (!phys)
	phys = __memblock_alloc_base(sizeof(struct pglist_data),
	SMP_CACHE_BYTES,
	memblock_end_of_DRAM());
	if (!phys)
	panic("Can't allocate pgdat for node %d\n", nid);

	NODE_DATA(nid) = __va(phys);
	memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));

	NODE_DATA(nid)->bdata = &bootmem_node_data[nid];
	#endif

	NODE_DATA(nid)->node_start_pfn = start_pfn;
	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
	}

	static void __init bootmem_init_one_node(unsigned int nid)
	{
	unsigned long total_pages, paddr;
	unsigned long end_pfn;
	struct pglist_data *p;

	p = NODE_DATA(nid);

	/* Nothing to do.. */
	if (!p->node_spanned_pages)
	return;

	end_pfn = pgdat_end_pfn(p);
	#ifdef CONFIG_HIGHMEM
	if (end_pfn > max_low_pfn)
	end_pfn = max_low_pfn;
	#endif

	total_pages = bootmem_bootmap_pages(end_pfn - p->node_start_pfn);

	paddr = memblock_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
	if (!paddr)
	panic("Can't allocate bootmap for nid[%d]\n", nid);

	init_bootmem_node(p, paddr >> PAGE_SHIFT, p->node_start_pfn, end_pfn);

	free_bootmem_with_active_regions(nid, end_pfn);

	/*
	* XXX Handle initial reservations for the system memory node
	* only for the moment, we'll refactor this later for handling
	* reservations in other nodes.
	*/
	if (nid == 0) {
	struct memblock_region *reg;

	/* Reserve the sections we're already using. */
	for_each_memblock(reserved, reg) {
	unsigned long size = reg->size;

	#ifdef CONFIG_HIGHMEM
	/* ...but not highmem */
	if (PFN_DOWN(reg->base) >= highstart_pfn)
	continue;

	if (PFN_UP(reg->base + size) > highstart_pfn)
	size = (highstart_pfn - PFN_DOWN(reg->base))
	<< PAGE_SHIFT;
	#endif

	reserve_bootmem(reg->base, size, BOOTMEM_DEFAULT);
	}
	}

	sparse_memory_present_with_active_regions(nid);
	}

	static void __init do_init_bootmem(void)
	{
	struct memblock_region *reg;
	int i;

	/* Add active regions with valid PFNs. */
	for_each_memblock(memory, reg) {
	unsigned long start_pfn, end_pfn;
	start_pfn = memblock_region_memory_base_pfn(reg);
	end_pfn = memblock_region_memory_end_pfn(reg);
	memblock_set_node(PFN_PHYS(start_pfn),
	PFN_PHYS(end_pfn - start_pfn),
	&memblock.memory, 0);
	}

	/* All of system RAM sits in node 0 for the non-NUMA case */
	allocate_pgdat(0);
	node_set_online(0);

	soc_mem_setup();

	for_each_online_node(i)
	bootmem_init_one_node(i);

	sparse_init();
	}

	extern char _heap_start[];

	static void __init init_and_reserve_mem(void)
	{
	unsigned long start_pfn, heap_start;
	u64 base = min_low_pfn << PAGE_SHIFT;
	u64 size = (max_low_pfn << PAGE_SHIFT) - base;

	heap_start = (unsigned long) &_heap_start;

	memblock_add(base, size);

	/*
	* Partially used pages are not usable - thus
	* we are rounding upwards:
	*/
	start_pfn = PFN_UP(__pa(heap_start));

	/*
	* Reserve the kernel text.
	*/
	memblock_reserve(base, (PFN_PHYS(start_pfn) + PAGE_SIZE - 1) - base);

	#ifdef CONFIG_HIGHMEM
	/*
	* Add & reserve highmem, so page structures are initialised.
	*/
	base = highstart_pfn << PAGE_SHIFT;
	size = (highend_pfn << PAGE_SHIFT) - base;
	if (size) {
	memblock_add(base, size);
	memblock_reserve(base, size);
	}
	#endif
	}

	#ifdef CONFIG_HIGHMEM
	/*
	* Ensure we have allocated page tables in swapper_pg_dir for the
	* fixed mappings range from 'start' to 'end'.
	*/
	static void __init allocate_pgtables(unsigned long start, unsigned long end)
	{
	pgd_t *pgd;
	pmd_t *pmd;
	pte_t *pte;
	int i, j;
	unsigned long vaddr;

	vaddr = start;
	i = pgd_index(vaddr);
	j = pmd_index(vaddr);
	pgd = swapper_pg_dir + i;

	for ( ; (i < PTRS_PER_PGD) && (vaddr != end); pgd++, i++) {
	pmd = (pmd_t *)pgd;
	for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
	vaddr += PMD_SIZE;

	if (!pmd_none(*pmd))
	continue;

	pte = (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
	pmd_populate_kernel(&init_mm, pmd, pte);
	}
	j = 0;
	}
	}

	static void __init fixedrange_init(void)
	{
	unsigned long vaddr, end;
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;

	/*
	* Fixed mappings:
	*/
	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
	end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
	allocate_pgtables(vaddr, end);

	/*
	* Permanent kmaps:
	*/
	vaddr = PKMAP_BASE;
	allocate_pgtables(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP);

	pgd = swapper_pg_dir + pgd_index(vaddr);
	pud = pud_offset(pgd, vaddr);
	pmd = pmd_offset(pud, vaddr);
	pte = pte_offset_kernel(pmd, vaddr);
	pkmap_page_table = pte;
	}
	#endif /* CONFIG_HIGHMEM */

	/*
	* paging_init() continues the virtual memory environment setup which
	* was begun by the code in arch/metag/kernel/setup.c.
	*/
	void __init paging_init(unsigned long mem_end)
	{
	unsigned long max_zone_pfns[MAX_NR_ZONES];
	int nid;

	init_and_reserve_mem();

	memblock_allow_resize();

	memblock_dump_all();

	nodes_clear(node_online_map);

	init_new_context(&init_task, &init_mm);

	memset(swapper_pg_dir, 0, sizeof(swapper_pg_dir));

	do_init_bootmem();
	mmu_init(mem_end);

	#ifdef CONFIG_HIGHMEM
	fixedrange_init();
	kmap_init();
	#endif

	/* Initialize the zero page to a bootmem page, already zeroed. */
	empty_zero_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);

	user_gateway_init();

	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_min_pfn;
	low = pgdat->bdata->node_low_pfn;

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

	#ifdef CONFIG_HIGHMEM
	max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
	#endif
	pr_info("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
	nid, start_pfn, low);
	}

	free_area_init_nodes(max_zone_pfns);
	}

	void __init mem_init(void)
	{
	#ifdef CONFIG_HIGHMEM
	unsigned long tmp;

	/*
	* Explicitly reset zone->managed_pages because highmem pages are
	* freed before calling free_all_bootmem();
	*/
	reset_all_zones_managed_pages();
	for (tmp = highstart_pfn; tmp < highend_pfn; tmp++)
	free_highmem_page(pfn_to_page(tmp));
	#endif /* CONFIG_HIGHMEM */

	free_all_bootmem();
	mem_init_print_info(NULL);
	show_mem(0);
	}

	void free_initmem(void)
	{
	free_initmem_default(POISON_FREE_INITMEM);
	}

	#ifdef CONFIG_BLK_DEV_INITRD
	void free_initrd_mem(unsigned long start, unsigned long end)
	{
	free_reserved_area((void )start, (void )end, POISON_FREE_INITMEM,
	"initrd");
	}
	#endif