[linux-2.6-block.git] / arch / um / kernel / mem.c

/*
 * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
 * Licensed under the GPL
 */

#include "linux/stddef.h"
#include "linux/kernel.h"
#include "linux/mm.h"
#include "linux/bootmem.h"
#include "linux/swap.h"
#include "linux/highmem.h"
#include "linux/gfp.h"
#include "asm/page.h"
#include "asm/fixmap.h"
#include "asm/pgalloc.h"
#include "kern_util.h"
#include "as-layout.h"
#include "kern.h"
#include "mem_user.h"
#include "um_uaccess.h"
#include "os.h"
#include "linux/types.h"
#include "linux/string.h"
#include "init.h"
#include "kern_constants.h"

/* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
unsigned long *empty_zero_page = NULL;
/* allocated in paging_init and unchanged thereafter */
unsigned long *empty_bad_page = NULL;
pgd_t swapper_pg_dir[PTRS_PER_PGD];
unsigned long long highmem;
int kmalloc_ok = 0;

static unsigned long brk_end;

void unmap_physmem(void)
{
	os_unmap_memory((void *) brk_end, uml_reserved - brk_end);
}

static void map_cb(void *unused)
{
	map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
}

#ifdef CONFIG_HIGHMEM
static void setup_highmem(unsigned long highmem_start,
			  unsigned long highmem_len)
{
	struct page *page;
	unsigned long highmem_pfn;
	int i;

	highmem_pfn = __pa(highmem_start) >> PAGE_SHIFT;
	for(i = 0; i < highmem_len >> PAGE_SHIFT; i++){
		page = &mem_map[highmem_pfn + i];
		ClearPageReserved(page);
		init_page_count(page);
		__free_page(page);
	}
}
#endif

void __init mem_init(void)
{
	/* clear the zero-page */
	memset(empty_zero_page, 0, PAGE_SIZE);

	/* Map in the area just after the brk now that kmalloc is about
	 * to be turned on.
	 */
	brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
	map_cb(NULL);
	initial_thread_cb(map_cb, NULL);
	free_bootmem(__pa(brk_end), uml_reserved - brk_end);
	uml_reserved = brk_end;

	/* this will put all low memory onto the freelists */
	totalram_pages = free_all_bootmem();
	max_low_pfn = totalram_pages;
#ifdef CONFIG_HIGHMEM
	totalhigh_pages = highmem >> PAGE_SHIFT;
	totalram_pages += totalhigh_pages;
#endif
	num_physpages = totalram_pages;
	max_pfn = totalram_pages;
	printk(KERN_INFO "Memory: %luk available\n", 
	       (unsigned long) nr_free_pages() << (PAGE_SHIFT-10));
	kmalloc_ok = 1;

#ifdef CONFIG_HIGHMEM
	setup_highmem(end_iomem, highmem);
#endif
}

/*
 * Create a page table and place a pointer to it in a middle page
 * directory entry.
 */
static void __init one_page_table_init(pmd_t *pmd)
{
	if (pmd_none(*pmd)) {
		pte_t *pte = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE);
		set_pmd(pmd, __pmd(_KERNPG_TABLE +
					   (unsigned long) __pa(pte)));
		if (pte != pte_offset_kernel(pmd, 0))
			BUG();
	}
}

static void __init one_md_table_init(pud_t *pud)
{
#ifdef CONFIG_3_LEVEL_PGTABLES
	pmd_t *pmd_table = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE);
	set_pud(pud, __pud(_KERNPG_TABLE + (unsigned long) __pa(pmd_table)));
	if (pmd_table != pmd_offset(pud, 0))
		BUG();
#endif
}

static void __init fixrange_init(unsigned long start, unsigned long end, 
				 pgd_t *pgd_base)
{
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	int i, j;
	unsigned long vaddr;

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

	for ( ; (i < PTRS_PER_PGD) && (vaddr < end); pgd++, i++) {
		pud = pud_offset(pgd, vaddr);
		if (pud_none(*pud))
			one_md_table_init(pud);
		pmd = pmd_offset(pud, vaddr);
		for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
			one_page_table_init(pmd);
			vaddr += PMD_SIZE;
		}
		j = 0;
	}
}

#ifdef CONFIG_HIGHMEM
pte_t *kmap_pte;
pgprot_t kmap_prot;

#define kmap_get_fixmap_pte(vaddr)					\
	pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
 			  (vaddr)), (vaddr))

static void __init kmap_init(void)
{
	unsigned long kmap_vstart;

	/* cache the first kmap pte */
	kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
	kmap_pte = kmap_get_fixmap_pte(kmap_vstart);

	kmap_prot = PAGE_KERNEL;
}

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

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

	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;

	kmap_init();
}
#endif /* CONFIG_HIGHMEM */

static void __init fixaddr_user_init( void)
{
#ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
	long size = FIXADDR_USER_END - FIXADDR_USER_START;
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;
	unsigned long paddr, vaddr = FIXADDR_USER_START;

	if (  ! size )
		return;

	fixrange_init( FIXADDR_USER_START, FIXADDR_USER_END, swapper_pg_dir);
	paddr = (unsigned long)alloc_bootmem_low_pages( size);
	memcpy( (void *)paddr, (void *)FIXADDR_USER_START, size);
	paddr = __pa(paddr);
	for ( ; size > 0; size-=PAGE_SIZE, vaddr+=PAGE_SIZE, paddr+=PAGE_SIZE){
		pgd = swapper_pg_dir + pgd_index(vaddr);
		pud = pud_offset(pgd, vaddr);
		pmd = pmd_offset(pud, vaddr);
		pte = pte_offset_kernel(pmd, vaddr);
		pte_set_val( (*pte), paddr, PAGE_READONLY);
	}
#endif
}

void __init paging_init(void)
{
	unsigned long zones_size[MAX_NR_ZONES], vaddr;
	int i;

	empty_zero_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
	empty_bad_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
	for(i = 0; i < ARRAY_SIZE(zones_size); i++)
		zones_size[i] = 0;

	zones_size[ZONE_NORMAL] = (end_iomem >> PAGE_SHIFT) -
		(uml_physmem >> PAGE_SHIFT);
#ifdef CONFIG_HIGHMEM
	zones_size[ZONE_HIGHMEM] = highmem >> PAGE_SHIFT;
#endif
	free_area_init(zones_size);

	/*
	 * Fixed mappings, only the page table structure has to be
	 * created - mappings will be set by set_fixmap():
	 */
	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
	fixrange_init(vaddr, FIXADDR_TOP, swapper_pg_dir);

	fixaddr_user_init();

#ifdef CONFIG_HIGHMEM
	init_highmem();
#endif
}

struct page *arch_validate(struct page *page, gfp_t mask, int order)
{
	unsigned long addr, zero = 0;
	int i;

 again:
	if(page == NULL)
		return page;
	if(PageHighMem(page))
		return page;

	addr = (unsigned long) page_address(page);
	for(i = 0; i < (1 << order); i++){
		current->thread.fault_addr = (void *) addr;
		if(__do_copy_to_user((void __user *) addr, &zero,
				     sizeof(zero),
				     &current->thread.fault_addr,
				     &current->thread.fault_catcher)){
			if(!(mask & __GFP_WAIT))
				return NULL;
			else break;
		}
		addr += PAGE_SIZE;
	}

	if(i == (1 << order))
		return page;
	page = alloc_pages(mask, order);
	goto again;
}

/* This can't do anything because nothing in the kernel image can be freed
 * since it's not in kernel physical memory.
 */

void free_initmem(void)
{
}

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

void show_mem(void)
{
	int pfn, total = 0, reserved = 0;
	int shared = 0, cached = 0;
	int highmem = 0;
	struct page *page;

	printk("Mem-info:\n");
	show_free_areas();
	printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
	pfn = max_mapnr;
	while(pfn-- > 0) {
		page = pfn_to_page(pfn);
		total++;
		if(PageHighMem(page))
			highmem++;
		if(PageReserved(page))
			reserved++;
		else if(PageSwapCache(page))
			cached++;
		else if(page_count(page))
			shared += page_count(page) - 1;
	}
	printk("%d pages of RAM\n", total);
	printk("%d pages of HIGHMEM\n", highmem);
	printk("%d reserved pages\n", reserved);
	printk("%d pages shared\n", shared);
	printk("%d pages swap cached\n", cached);
}

/*
 * Allocate and free page tables.
 */

pgd_t *pgd_alloc(struct mm_struct *mm)
{
	pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);

	if (pgd) {
		memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
		memcpy(pgd + USER_PTRS_PER_PGD, 
		       swapper_pg_dir + USER_PTRS_PER_PGD, 
		       (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
	}
	return pgd;
}

void pgd_free(struct mm_struct *mm, pgd_t *pgd)
{
	free_page((unsigned long) pgd);
}

pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
{
	pte_t *pte;

	pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
	return pte;
}

struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
{
	struct page *pte;

	pte = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
	return pte;
}
Commit	Line	Data
114069f7	1	/*
1da177e4 LT	2	* Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
	3	* Licensed under the GPL
	4	*/
	5
	6	#include "linux/stddef.h"
	7	#include "linux/kernel.h"
	8	#include "linux/mm.h"
	9	#include "linux/bootmem.h"
	10	#include "linux/swap.h"
	11	#include "linux/highmem.h"
	12	#include "linux/gfp.h"
	13	#include "asm/page.h"
	14	#include "asm/fixmap.h"
	15	#include "asm/pgalloc.h"
1da177e4	16	#include "kern_util.h"
4ff83ce1	17	#include "as-layout.h"
1da177e4 LT	18	#include "kern.h"
1da177e4 LT	19	#include "mem_user.h"
fab95c55	20	#include "um_uaccess.h"
1da177e4	21	#include "os.h"
114069f7 JD	22	#include "linux/types.h"
	23	#include "linux/string.h"
	24	#include "init.h"
	25	#include "kern_constants.h"
1da177e4	26
6bf79482	27	/* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
1da177e4	28	unsigned long *empty_zero_page = NULL;
6bf79482	29	/* allocated in paging_init and unchanged thereafter */
1da177e4 LT	30	unsigned long *empty_bad_page = NULL;
1da177e4 LT	31	pgd_t swapper_pg_dir[PTRS_PER_PGD];
9902abd7	32	unsigned long long highmem;
1da177e4 LT	33	int kmalloc_ok = 0;
	34
	35	static unsigned long brk_end;
	36
	37	void unmap_physmem(void)
	38	{
	39	os_unmap_memory((void *) brk_end, uml_reserved - brk_end);
	40	}
	41
	42	static void map_cb(void *unused)
	43	{
	44	map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
	45	}
	46
	47	#ifdef CONFIG_HIGHMEM
	48	static void setup_highmem(unsigned long highmem_start,
	49	unsigned long highmem_len)
	50	{
	51	struct page *page;
	52	unsigned long highmem_pfn;
	53	int i;
	54
	55	highmem_pfn = __pa(highmem_start) >> PAGE_SHIFT;
	56	for(i = 0; i < highmem_len >> PAGE_SHIFT; i++){
	57	page = &mem_map[highmem_pfn + i];
	58	ClearPageReserved(page);
7835e98b	59	init_page_count(page);
1da177e4 LT	60	__free_page(page);
	61	}
	62	}
	63	#endif
	64
97a1fcbb	65	void __init mem_init(void)
1da177e4	66	{
60678bbc	67	/* clear the zero-page */
c0a9290e	68	memset(empty_zero_page, 0, PAGE_SIZE);
1da177e4 LT	69
	70	/* Map in the area just after the brk now that kmalloc is about
	71	* to be turned on.
	72	*/
	73	brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
	74	map_cb(NULL);
	75	initial_thread_cb(map_cb, NULL);
	76	free_bootmem(__pa(brk_end), uml_reserved - brk_end);
	77	uml_reserved = brk_end;
	78
1da177e4 LT	79	/* this will put all low memory onto the freelists */
1da177e4 LT	80	totalram_pages = free_all_bootmem();
af84eab2	81	max_low_pfn = totalram_pages;
c1f60a5a	82	#ifdef CONFIG_HIGHMEM
1da177e4 LT	83	totalhigh_pages = highmem >> PAGE_SHIFT;
1da177e4 LT	84	totalram_pages += totalhigh_pages;
c1f60a5a	85	#endif
1da177e4 LT	86	num_physpages = totalram_pages;
	87	max_pfn = totalram_pages;
	88	printk(KERN_INFO "Memory: %luk available\n",
	89	(unsigned long) nr_free_pages() << (PAGE_SHIFT-10));
	90	kmalloc_ok = 1;
	91
	92	#ifdef CONFIG_HIGHMEM
	93	setup_highmem(end_iomem, highmem);
	94	#endif
	95	}
	96
12f49643 JD	97	/*
	98	* Create a page table and place a pointer to it in a middle page
	99	* directory entry.
	100	*/
	101	static void __init one_page_table_init(pmd_t *pmd)
	102	{
	103	if (pmd_none(*pmd)) {
	104	pte_t pte = (pte_t ) alloc_bootmem_low_pages(PAGE_SIZE);
	105	set_pmd(pmd, __pmd(_KERNPG_TABLE +
	106	(unsigned long) __pa(pte)));
	107	if (pte != pte_offset_kernel(pmd, 0))
	108	BUG();
	109	}
	110	}
	111
	112	static void __init one_md_table_init(pud_t *pud)
	113	{
	114	#ifdef CONFIG_3_LEVEL_PGTABLES
	115	pmd_t pmd_table = (pmd_t ) alloc_bootmem_low_pages(PAGE_SIZE);
	116	set_pud(pud, __pud(_KERNPG_TABLE + (unsigned long) __pa(pmd_table)));
	117	if (pmd_table != pmd_offset(pud, 0))
	118	BUG();
	119	#endif
	120	}
	121
1da177e4 LT	122	static void __init fixrange_init(unsigned long start, unsigned long end,
	123	pgd_t *pgd_base)
	124	{
	125	pgd_t *pgd;
12f49643	126	pud_t *pud;
1da177e4	127	pmd_t *pmd;
1da177e4 LT	128	int i, j;
	129	unsigned long vaddr;
	130
	131	vaddr = start;
	132	i = pgd_index(vaddr);
	133	j = pmd_index(vaddr);
	134	pgd = pgd_base + i;
	135
	136	for ( ; (i < PTRS_PER_PGD) && (vaddr < end); pgd++, i++) {
12f49643 JD	137	pud = pud_offset(pgd, vaddr);
	138	if (pud_none(*pud))
	139	one_md_table_init(pud);
	140	pmd = pmd_offset(pud, vaddr);
1da177e4	141	for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
12f49643	142	one_page_table_init(pmd);
1da177e4 LT	143	vaddr += PMD_SIZE;
	144	}
	145	j = 0;
	146	}
	147	}
	148
	149	#ifdef CONFIG_HIGHMEM
	150	pte_t *kmap_pte;
	151	pgprot_t kmap_prot;
	152
	153	#define kmap_get_fixmap_pte(vaddr) \
	154	pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
	155	(vaddr)), (vaddr))
	156
	157	static void __init kmap_init(void)
	158	{
	159	unsigned long kmap_vstart;
	160
	161	/* cache the first kmap pte */
	162	kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
	163	kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
	164
	165	kmap_prot = PAGE_KERNEL;
	166	}
	167
b4a08a10	168	static void __init init_highmem(void)
1da177e4 LT	169	{
	170	pgd_t *pgd;
	171	pud_t *pud;
	172	pmd_t *pmd;
	173	pte_t *pte;
	174	unsigned long vaddr;
	175
	176	/*
	177	* Permanent kmaps:
	178	*/
	179	vaddr = PKMAP_BASE;
	180	fixrange_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, swapper_pg_dir);
	181
	182	pgd = swapper_pg_dir + pgd_index(vaddr);
	183	pud = pud_offset(pgd, vaddr);
	184	pmd = pmd_offset(pud, vaddr);
	185	pte = pte_offset_kernel(pmd, vaddr);
	186	pkmap_page_table = pte;
	187
	188	kmap_init();
	189	}
	190	#endif /* CONFIG_HIGHMEM */
	191
	192	static void __init fixaddr_user_init( void)
	193	{
9a0b3869	194	#ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
1da177e4 LT	195	long size = FIXADDR_USER_END - FIXADDR_USER_START;
	196	pgd_t *pgd;
	197	pud_t *pud;
	198	pmd_t *pmd;
	199	pte_t *pte;
	200	unsigned long paddr, vaddr = FIXADDR_USER_START;
	201
	202	if ( ! size )
	203	return;
	204
	205	fixrange_init( FIXADDR_USER_START, FIXADDR_USER_END, swapper_pg_dir);
	206	paddr = (unsigned long)alloc_bootmem_low_pages( size);
	207	memcpy( (void )paddr, (void )FIXADDR_USER_START, size);
	208	paddr = __pa(paddr);
	209	for ( ; size > 0; size-=PAGE_SIZE, vaddr+=PAGE_SIZE, paddr+=PAGE_SIZE){
	210	pgd = swapper_pg_dir + pgd_index(vaddr);
	211	pud = pud_offset(pgd, vaddr);
	212	pmd = pmd_offset(pud, vaddr);
	213	pte = pte_offset_kernel(pmd, vaddr);
	214	pte_set_val( (*pte), paddr, PAGE_READONLY);
	215	}
	216	#endif
	217	}
	218
36e45463	219	void __init paging_init(void)
1da177e4 LT	220	{
	221	unsigned long zones_size[MAX_NR_ZONES], vaddr;
	222	int i;
	223
	224	empty_zero_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
	225	empty_bad_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
91b165c0	226	for(i = 0; i < ARRAY_SIZE(zones_size); i++)
1da177e4	227	zones_size[i] = 0;
91b165c0	228
0715501b JD	229	zones_size[ZONE_NORMAL] = (end_iomem >> PAGE_SHIFT) -
0715501b JD	230	(uml_physmem >> PAGE_SHIFT);
e53ef38d	231	#ifdef CONFIG_HIGHMEM
353f8d1c	232	zones_size[ZONE_HIGHMEM] = highmem >> PAGE_SHIFT;
e53ef38d	233	#endif
1da177e4 LT	234	free_area_init(zones_size);
	235
	236	/*
	237	* Fixed mappings, only the page table structure has to be
	238	* created - mappings will be set by set_fixmap():
	239	*/
	240	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
	241	fixrange_init(vaddr, FIXADDR_TOP, swapper_pg_dir);
	242
	243	fixaddr_user_init();
	244
	245	#ifdef CONFIG_HIGHMEM
	246	init_highmem();
	247	#endif
	248	}
	249
53f9fc93	250	struct page arch_validate(struct page page, gfp_t mask, int order)
1da177e4 LT	251	{
	252	unsigned long addr, zero = 0;
	253	int i;
	254
	255	again:
60678bbc JD	256	if(page == NULL)
	257	return page;
	258	if(PageHighMem(page))
	259	return page;
1da177e4 LT	260
	261	addr = (unsigned long) page_address(page);
	262	for(i = 0; i < (1 << order); i++){
	263	current->thread.fault_addr = (void *) addr;
	264	if(__do_copy_to_user((void __user *) addr, &zero,
	265	sizeof(zero),
	266	&current->thread.fault_addr,
	267	&current->thread.fault_catcher)){
60678bbc JD	268	if(!(mask & __GFP_WAIT))
60678bbc JD	269	return NULL;
1da177e4 LT	270	else break;
	271	}
	272	addr += PAGE_SIZE;
	273	}
	274
60678bbc JD	275	if(i == (1 << order))
60678bbc JD	276	return page;
1da177e4 LT	277	page = alloc_pages(mask, order);
	278	goto again;
	279	}
	280
	281	/* This can't do anything because nothing in the kernel image can be freed
	282	* since it's not in kernel physical memory.
	283	*/
	284
	285	void free_initmem(void)
	286	{
	287	}
	288
	289	#ifdef CONFIG_BLK_DEV_INITRD
1da177e4 LT	290	void free_initrd_mem(unsigned long start, unsigned long end)
	291	{
	292	if (start < end)
	293	printk ("Freeing initrd memory: %ldk freed\n",
	294	(end - start) >> 10);
	295	for (; start < end; start += PAGE_SIZE) {
	296	ClearPageReserved(virt_to_page(start));
7835e98b	297	init_page_count(virt_to_page(start));
1da177e4 LT	298	free_page(start);
	299	totalram_pages++;
	300	}
	301	}
1da177e4 LT	302	#endif
	303
	304	void show_mem(void)
	305	{
60678bbc JD	306	int pfn, total = 0, reserved = 0;
	307	int shared = 0, cached = 0;
	308	int highmem = 0;
1da177e4 LT	309	struct page *page;
1da177e4 LT	310
60678bbc JD	311	printk("Mem-info:\n");
	312	show_free_areas();
	313	printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
	314	pfn = max_mapnr;
	315	while(pfn-- > 0) {
1da177e4	316	page = pfn_to_page(pfn);
60678bbc JD	317	total++;
	318	if(PageHighMem(page))
	319	highmem++;
	320	if(PageReserved(page))
	321	reserved++;
	322	else if(PageSwapCache(page))
	323	cached++;
	324	else if(page_count(page))
	325	shared += page_count(page) - 1;
	326	}
	327	printk("%d pages of RAM\n", total);
	328	printk("%d pages of HIGHMEM\n", highmem);
	329	printk("%d reserved pages\n", reserved);
	330	printk("%d pages shared\n", shared);
	331	printk("%d pages swap cached\n", cached);
1da177e4 LT	332	}
	333
	334	/*
	335	* Allocate and free page tables.
	336	*/
	337
	338	pgd_t pgd_alloc(struct mm_struct mm)
	339	{
	340	pgd_t pgd = (pgd_t )__get_free_page(GFP_KERNEL);
	341
	342	if (pgd) {
	343	memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
	344	memcpy(pgd + USER_PTRS_PER_PGD,
	345	swapper_pg_dir + USER_PTRS_PER_PGD,
	346	(PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
	347	}
	348	return pgd;
	349	}
	350
5e541973	351	void pgd_free(struct mm_struct mm, pgd_t pgd)
1da177e4 LT	352	{
	353	free_page((unsigned long) pgd);
	354	}
	355
	356	pte_t pte_alloc_one_kernel(struct mm_struct mm, unsigned long address)
	357	{
	358	pte_t *pte;
	359
	360	pte = (pte_t *)__get_free_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);
	361	return pte;
	362	}
	363
	364	struct page pte_alloc_one(struct mm_struct mm, unsigned long address)
	365	{
	366	struct page *pte;
60678bbc	367
1da177e4 LT	368	pte = alloc_page(GFP_KERNEL\|__GFP_REPEAT\|__GFP_ZERO);
	369	return pte;
	370	}