[net-next-2.6.git] / arch / ia64 / mm / contig.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1998-2003 Hewlett-Packard Co
 *	David Mosberger-Tang <davidm@hpl.hp.com>
 *	Stephane Eranian <eranian@hpl.hp.com>
 * Copyright (C) 2000, Rohit Seth <rohit.seth@intel.com>
 * Copyright (C) 1999 VA Linux Systems
 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
 * Copyright (C) 2003 Silicon Graphics, Inc. All rights reserved.
 *
 * Routines used by ia64 machines with contiguous (or virtually contiguous)
 * memory.
 */
#include <linux/bootmem.h>
#include <linux/efi.h>
#include <linux/mm.h>
#include <linux/swap.h>

#include <asm/meminit.h>
#include <asm/pgalloc.h>
#include <asm/pgtable.h>
#include <asm/sections.h>
#include <asm/mca.h>

#ifdef CONFIG_VIRTUAL_MEM_MAP
static unsigned long max_gap;
#endif

/**
 * show_mem - display a memory statistics summary
 *
 * Just walks the pages in the system and describes where they're allocated.
 */
void
show_mem (void)
{
	int i, total = 0, reserved = 0;
	int shared = 0, cached = 0;

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

	printk(KERN_INFO "Free swap:       %6ldkB\n",
	       nr_swap_pages<<(PAGE_SHIFT-10));
	i = max_mapnr;
	for (i = 0; i < max_mapnr; i++) {
		if (!pfn_valid(i)) {
#ifdef CONFIG_VIRTUAL_MEM_MAP
			if (max_gap < LARGE_GAP)
				continue;
			i = vmemmap_find_next_valid_pfn(0, i) - 1;
#endif
			continue;
		}
		total++;
		if (PageReserved(mem_map+i))
			reserved++;
		else if (PageSwapCache(mem_map+i))
			cached++;
		else if (page_count(mem_map + i))
			shared += page_count(mem_map + i) - 1;
	}
	printk(KERN_INFO "%d pages of RAM\n", total);
	printk(KERN_INFO "%d reserved pages\n", reserved);
	printk(KERN_INFO "%d pages shared\n", shared);
	printk(KERN_INFO "%d pages swap cached\n", cached);
	printk(KERN_INFO "%ld pages in page table cache\n",
	       pgtable_quicklist_total_size());
}

/* physical address where the bootmem map is located */
unsigned long bootmap_start;

/**
 * find_max_pfn - adjust the maximum page number callback
 * @start: start of range
 * @end: end of range
 * @arg: address of pointer to global max_pfn variable
 *
 * Passed as a callback function to efi_memmap_walk() to determine the highest
 * available page frame number in the system.
 */
int
find_max_pfn (unsigned long start, unsigned long end, void *arg)
{
	unsigned long *max_pfnp = arg, pfn;

	pfn = (PAGE_ALIGN(end - 1) - PAGE_OFFSET) >> PAGE_SHIFT;
	if (pfn > *max_pfnp)
		*max_pfnp = pfn;
	return 0;
}

/**
 * find_bootmap_location - callback to find a memory area for the bootmap
 * @start: start of region
 * @end: end of region
 * @arg: unused callback data
 *
 * Find a place to put the bootmap and return its starting address in
 * bootmap_start.  This address must be page-aligned.
 */
static int __init
find_bootmap_location (unsigned long start, unsigned long end, void *arg)
{
	unsigned long needed = *(unsigned long *)arg;
	unsigned long range_start, range_end, free_start;
	int i;

#if IGNORE_PFN0
	if (start == PAGE_OFFSET) {
		start += PAGE_SIZE;
		if (start >= end)
			return 0;
	}
#endif

	free_start = PAGE_OFFSET;

	for (i = 0; i < num_rsvd_regions; i++) {
		range_start = max(start, free_start);
		range_end   = min(end, rsvd_region[i].start & PAGE_MASK);

		free_start = PAGE_ALIGN(rsvd_region[i].end);

		if (range_end <= range_start)
			continue; /* skip over empty range */

		if (range_end - range_start >= needed) {
			bootmap_start = __pa(range_start);
			return -1;	/* done */
		}

		/* nothing more available in this segment */
		if (range_end == end)
			return 0;
	}
	return 0;
}

/**
 * find_memory - setup memory map
 *
 * Walk the EFI memory map and find usable memory for the system, taking
 * into account reserved areas.
 */
void __init
find_memory (void)
{
	unsigned long bootmap_size;

	reserve_memory();

	/* first find highest page frame number */
	max_pfn = 0;
	efi_memmap_walk(find_max_pfn, &max_pfn);

	/* how many bytes to cover all the pages */
	bootmap_size = bootmem_bootmap_pages(max_pfn) << PAGE_SHIFT;

	/* look for a location to hold the bootmap */
	bootmap_start = ~0UL;
	efi_memmap_walk(find_bootmap_location, &bootmap_size);
	if (bootmap_start == ~0UL)
		panic("Cannot find %ld bytes for bootmap\n", bootmap_size);

	bootmap_size = init_bootmem(bootmap_start >> PAGE_SHIFT, max_pfn);

	/* Free all available memory, then mark bootmem-map as being in use. */
	efi_memmap_walk(filter_rsvd_memory, free_bootmem);
	reserve_bootmem(bootmap_start, bootmap_size);

	find_initrd();

#ifdef CONFIG_CRASH_DUMP
	/* If we are doing a crash dump, we still need to know the real mem
	 * size before original memory map is * reset. */
	saved_max_pfn = max_pfn;
#endif
}

#ifdef CONFIG_SMP
/**
 * per_cpu_init - setup per-cpu variables
 *
 * Allocate and setup per-cpu data areas.
 */
void * __cpuinit
per_cpu_init (void)
{
	void *cpu_data;
	int cpu;
	static int first_time=1;

	/*
	 * get_free_pages() cannot be used before cpu_init() done.  BSP
	 * allocates "NR_CPUS" pages for all CPUs to avoid that AP calls
	 * get_zeroed_page().
	 */
	if (first_time) {
		first_time=0;
		cpu_data = __alloc_bootmem(PERCPU_PAGE_SIZE * NR_CPUS,
					   PERCPU_PAGE_SIZE, __pa(MAX_DMA_ADDRESS));
		for (cpu = 0; cpu < NR_CPUS; cpu++) {
			memcpy(cpu_data, __phys_per_cpu_start, __per_cpu_end - __per_cpu_start);
			__per_cpu_offset[cpu] = (char *) cpu_data - __per_cpu_start;
			cpu_data += PERCPU_PAGE_SIZE;
			per_cpu(local_per_cpu_offset, cpu) = __per_cpu_offset[cpu];
		}
	}
	return __per_cpu_start + __per_cpu_offset[smp_processor_id()];
}
#endif /* CONFIG_SMP */

static int
count_pages (u64 start, u64 end, void *arg)
{
	unsigned long *count = arg;

	*count += (end - start) >> PAGE_SHIFT;
	return 0;
}

/*
 * Set up the page tables.
 */

void __init
paging_init (void)
{
	unsigned long max_dma;
	unsigned long max_zone_pfns[MAX_NR_ZONES];

	num_physpages = 0;
	efi_memmap_walk(count_pages, &num_physpages);

	max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
	max_zone_pfns[ZONE_DMA] = max_dma;
	max_zone_pfns[ZONE_NORMAL] = max_low_pfn;

#ifdef CONFIG_VIRTUAL_MEM_MAP
	efi_memmap_walk(register_active_ranges, NULL);
	efi_memmap_walk(find_largest_hole, (u64 *)&max_gap);
	if (max_gap < LARGE_GAP) {
		vmem_map = (struct page *) 0;
		free_area_init_nodes(max_zone_pfns);
	} else {
		unsigned long map_size;

		/* allocate virtual_mem_map */

		map_size = PAGE_ALIGN(ALIGN(max_low_pfn, MAX_ORDER_NR_PAGES) *
			sizeof(struct page));
		vmalloc_end -= map_size;
		vmem_map = (struct page *) vmalloc_end;
		efi_memmap_walk(create_mem_map_page_table, NULL);

		/*
		 * alloc_node_mem_map makes an adjustment for mem_map
		 * which isn't compatible with vmem_map.
		 */
		NODE_DATA(0)->node_mem_map = vmem_map +
			find_min_pfn_with_active_regions();
		free_area_init_nodes(max_zone_pfns);

		printk("Virtual mem_map starts at 0x%p\n", mem_map);
	}
#else /* !CONFIG_VIRTUAL_MEM_MAP */
	add_active_range(0, 0, max_low_pfn);
	free_area_init_nodes(max_zone_pfns);
#endif /* !CONFIG_VIRTUAL_MEM_MAP */
	zero_page_memmap_ptr = virt_to_page(ia64_imva(empty_zero_page));
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Copyright (C) 1998-2003 Hewlett-Packard Co
	7	* David Mosberger-Tang <davidm@hpl.hp.com>
	8	* Stephane Eranian <eranian@hpl.hp.com>
	9	* Copyright (C) 2000, Rohit Seth <rohit.seth@intel.com>
	10	* Copyright (C) 1999 VA Linux Systems
	11	* Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
	12	* Copyright (C) 2003 Silicon Graphics, Inc. All rights reserved.
	13	*
	14	* Routines used by ia64 machines with contiguous (or virtually contiguous)
	15	* memory.
	16	*/
1da177e4 LT	17	#include <linux/bootmem.h>
	18	#include <linux/efi.h>
	19	#include <linux/mm.h>
	20	#include <linux/swap.h>
	21
	22	#include <asm/meminit.h>
	23	#include <asm/pgalloc.h>
	24	#include <asm/pgtable.h>
	25	#include <asm/sections.h>
	26	#include <asm/mca.h>
	27
	28	#ifdef CONFIG_VIRTUAL_MEM_MAP
e44e41d0	29	static unsigned long max_gap;
1da177e4 LT	30	#endif
	31
	32	/**
	33	* show_mem - display a memory statistics summary
	34	*
	35	* Just walks the pages in the system and describes where they're allocated.
	36	*/
	37	void
	38	show_mem (void)
	39	{
	40	int i, total = 0, reserved = 0;
	41	int shared = 0, cached = 0;
	42
709a6c1c	43	printk(KERN_INFO "Mem-info:\n");
1da177e4 LT	44	show_free_areas();
1da177e4 LT	45
709a6c1c JS	46	printk(KERN_INFO "Free swap: %6ldkB\n",
709a6c1c JS	47	nr_swap_pages<<(PAGE_SHIFT-10));
1da177e4	48	i = max_mapnr;
e44e41d0 BP	49	for (i = 0; i < max_mapnr; i++) {
	50	if (!pfn_valid(i)) {
	51	#ifdef CONFIG_VIRTUAL_MEM_MAP
	52	if (max_gap < LARGE_GAP)
	53	continue;
	54	i = vmemmap_find_next_valid_pfn(0, i) - 1;
	55	#endif
1da177e4	56	continue;
e44e41d0	57	}
1da177e4 LT	58	total++;
	59	if (PageReserved(mem_map+i))
	60	reserved++;
	61	else if (PageSwapCache(mem_map+i))
	62	cached++;
	63	else if (page_count(mem_map + i))
	64	shared += page_count(mem_map + i) - 1;
	65	}
709a6c1c JS	66	printk(KERN_INFO "%d pages of RAM\n", total);
	67	printk(KERN_INFO "%d reserved pages\n", reserved);
	68	printk(KERN_INFO "%d pages shared\n", shared);
	69	printk(KERN_INFO "%d pages swap cached\n", cached);
	70	printk(KERN_INFO "%ld pages in page table cache\n",
	71	pgtable_quicklist_total_size());
1da177e4 LT	72	}
	73
	74	/* physical address where the bootmem map is located */
	75	unsigned long bootmap_start;
	76
	77	/**
	78	* find_max_pfn - adjust the maximum page number callback
	79	* @start: start of range
	80	* @end: end of range
	81	* @arg: address of pointer to global max_pfn variable
	82	*
	83	* Passed as a callback function to efi_memmap_walk() to determine the highest
	84	* available page frame number in the system.
	85	*/
	86	int
	87	find_max_pfn (unsigned long start, unsigned long end, void *arg)
	88	{
	89	unsigned long *max_pfnp = arg, pfn;
	90
	91	pfn = (PAGE_ALIGN(end - 1) - PAGE_OFFSET) >> PAGE_SHIFT;
	92	if (pfn > *max_pfnp)
	93	*max_pfnp = pfn;
	94	return 0;
	95	}
	96
	97	/**
	98	* find_bootmap_location - callback to find a memory area for the bootmap
	99	* @start: start of region
	100	* @end: end of region
	101	* @arg: unused callback data
	102	*
	103	* Find a place to put the bootmap and return its starting address in
	104	* bootmap_start. This address must be page-aligned.
	105	*/
dae28066	106	static int __init
1da177e4 LT	107	find_bootmap_location (unsigned long start, unsigned long end, void *arg)
	108	{
	109	unsigned long needed = (unsigned long )arg;
	110	unsigned long range_start, range_end, free_start;
	111	int i;
	112
	113	#if IGNORE_PFN0
	114	if (start == PAGE_OFFSET) {
	115	start += PAGE_SIZE;
	116	if (start >= end)
	117	return 0;
	118	}
	119	#endif
	120
	121	free_start = PAGE_OFFSET;
	122
	123	for (i = 0; i < num_rsvd_regions; i++) {
	124	range_start = max(start, free_start);
	125	range_end = min(end, rsvd_region[i].start & PAGE_MASK);
	126
	127	free_start = PAGE_ALIGN(rsvd_region[i].end);
	128
	129	if (range_end <= range_start)
	130	continue; /* skip over empty range */
	131
	132	if (range_end - range_start >= needed) {
	133	bootmap_start = __pa(range_start);
	134	return -1; /* done */
	135	}
	136
	137	/* nothing more available in this segment */
	138	if (range_end == end)
	139	return 0;
	140	}
	141	return 0;
	142	}
	143
	144	/**
	145	* find_memory - setup memory map
	146	*
	147	* Walk the EFI memory map and find usable memory for the system, taking
	148	* into account reserved areas.
	149	*/
dae28066	150	void __init
1da177e4 LT	151	find_memory (void)
	152	{
	153	unsigned long bootmap_size;
	154
	155	reserve_memory();
	156
	157	/* first find highest page frame number */
	158	max_pfn = 0;
	159	efi_memmap_walk(find_max_pfn, &max_pfn);
	160
	161	/* how many bytes to cover all the pages */
	162	bootmap_size = bootmem_bootmap_pages(max_pfn) << PAGE_SHIFT;
	163
	164	/* look for a location to hold the bootmap */
	165	bootmap_start = ~0UL;
	166	efi_memmap_walk(find_bootmap_location, &bootmap_size);
	167	if (bootmap_start == ~0UL)
	168	panic("Cannot find %ld bytes for bootmap\n", bootmap_size);
	169
	170	bootmap_size = init_bootmem(bootmap_start >> PAGE_SHIFT, max_pfn);
	171
	172	/* Free all available memory, then mark bootmem-map as being in use. */
	173	efi_memmap_walk(filter_rsvd_memory, free_bootmem);
	174	reserve_bootmem(bootmap_start, bootmap_size);
	175
	176	find_initrd();
45a98fc6 H	177
	178	#ifdef CONFIG_CRASH_DUMP
	179	/* If we are doing a crash dump, we still need to know the real mem
	180	* size before original memory map is * reset. */
	181	saved_max_pfn = max_pfn;
	182	#endif
1da177e4 LT	183	}
	184
	185	#ifdef CONFIG_SMP
	186	/**
	187	* per_cpu_init - setup per-cpu variables
	188	*
	189	* Allocate and setup per-cpu data areas.
	190	*/
244fd545	191	void * __cpuinit
1da177e4 LT	192	per_cpu_init (void)
	193	{
	194	void *cpu_data;
	195	int cpu;
ff741906	196	static int first_time=1;
1da177e4 LT	197
	198	/*
	199	* get_free_pages() cannot be used before cpu_init() done. BSP
	200	* allocates "NR_CPUS" pages for all CPUs to avoid that AP calls
	201	* get_zeroed_page().
	202	*/
ff741906 AR	203	if (first_time) {
ff741906 AR	204	first_time=0;
1da177e4 LT	205	cpu_data = __alloc_bootmem(PERCPU_PAGE_SIZE * NR_CPUS,
	206	PERCPU_PAGE_SIZE, __pa(MAX_DMA_ADDRESS));
	207	for (cpu = 0; cpu < NR_CPUS; cpu++) {
	208	memcpy(cpu_data, __phys_per_cpu_start, __per_cpu_end - __per_cpu_start);
	209	__per_cpu_offset[cpu] = (char *) cpu_data - __per_cpu_start;
	210	cpu_data += PERCPU_PAGE_SIZE;
	211	per_cpu(local_per_cpu_offset, cpu) = __per_cpu_offset[cpu];
	212	}
	213	}
	214	return __per_cpu_start + __per_cpu_offset[smp_processor_id()];
	215	}
	216	#endif /* CONFIG_SMP */
	217
	218	static int
	219	count_pages (u64 start, u64 end, void *arg)
	220	{
	221	unsigned long *count = arg;
	222
	223	*count += (end - start) >> PAGE_SHIFT;
	224	return 0;
	225	}
	226
1da177e4 LT	227	/*
	228	* Set up the page tables.
	229	*/
	230
dae28066	231	void __init
1da177e4 LT	232	paging_init (void)
	233	{
	234	unsigned long max_dma;
05e0caad	235	unsigned long max_zone_pfns[MAX_NR_ZONES];
1da177e4 LT	236
	237	num_physpages = 0;
	238	efi_memmap_walk(count_pages, &num_physpages);
	239
	240	max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
6391af17	241	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
05e0caad MG	242	max_zone_pfns[ZONE_DMA] = max_dma;
05e0caad MG	243	max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
1da177e4 LT	244
1da177e4 LT	245	#ifdef CONFIG_VIRTUAL_MEM_MAP
8b9c1068	246	efi_memmap_walk(register_active_ranges, NULL);
1da177e4 LT	247	efi_memmap_walk(find_largest_hole, (u64 *)&max_gap);
	248	if (max_gap < LARGE_GAP) {
	249	vmem_map = (struct page *) 0;
05e0caad	250	free_area_init_nodes(max_zone_pfns);
1da177e4 LT	251	} else {
	252	unsigned long map_size;
	253
	254	/* allocate virtual_mem_map */
	255
921eea1c BP	256	map_size = PAGE_ALIGN(ALIGN(max_low_pfn, MAX_ORDER_NR_PAGES) *
921eea1c BP	257	sizeof(struct page));
1da177e4 LT	258	vmalloc_end -= map_size;
	259	vmem_map = (struct page *) vmalloc_end;
	260	efi_memmap_walk(create_mem_map_page_table, NULL);
	261
05e0caad MG	262	/*
	263	* alloc_node_mem_map makes an adjustment for mem_map
	264	* which isn't compatible with vmem_map.
	265	*/
	266	NODE_DATA(0)->node_mem_map = vmem_map +
	267	find_min_pfn_with_active_regions();
	268	free_area_init_nodes(max_zone_pfns);
1da177e4 LT	269
	270	printk("Virtual mem_map starts at 0x%p\n", mem_map);
	271	}
	272	#else /* !CONFIG_VIRTUAL_MEM_MAP */
05e0caad MG	273	add_active_range(0, 0, max_low_pfn);
05e0caad MG	274	free_area_init_nodes(max_zone_pfns);
1da177e4 LT	275	#endif /* !CONFIG_VIRTUAL_MEM_MAP */
	276	zero_page_memmap_ptr = virt_to_page(ia64_imva(empty_zero_page));
	277	}