[mirror_ubuntu-focal-kernel.git] / arch / um / kernel / mem.c

/*
 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */

#include <linux/stddef.h>
#include <linux/bootmem.h>
#include <linux/gfp.h>
#include <linux/highmem.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <asm/fixmap.h>
#include <asm/page.h>
#include "as-layout.h"
#include "init.h"
#include "kern.h"
#include "kern_util.h"
#include "mem_user.h"
#include "os.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(KERN_INFO "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(KERN_INFO "Mem-info:\n");
	show_free_areas();
	printk(KERN_INFO "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(KERN_INFO "%d pages of RAM\n", total);
	printk(KERN_INFO "%d pages of HIGHMEM\n", highmem);
	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);
}

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

#ifdef CONFIG_3_LEVEL_PGTABLES
pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
{
	pmd_t *pmd = (pmd_t *) __get_free_page(GFP_KERNEL);

	if (pmd)
		memset(pmd, 0, PAGE_SIZE);

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