[mirror_ubuntu-artful-kernel.git] / arch / um / kernel / tlb.c

/*
 * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
 * Licensed under the GPL
 */

#include "linux/mm.h"
#include "asm/page.h"
#include "asm/pgalloc.h"
#include "asm/tlbflush.h"
#include "choose-mode.h"
#include "mode_kern.h"
#include "as-layout.h"
#include "tlb.h"
#include "mem.h"
#include "mem_user.h"
#include "os.h"

static int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
		    int r, int w, int x, struct host_vm_op *ops, int *index,
		    int last_filled, union mm_context *mmu, void **flush,
		    int (*do_ops)(union mm_context *, struct host_vm_op *,
				  int, int, void **))
{
	__u64 offset;
	struct host_vm_op *last;
	int fd, ret = 0;

	fd = phys_mapping(phys, &offset);
	if(*index != -1){
		last = &ops[*index];
		if((last->type == MMAP) &&
		   (last->u.mmap.addr + last->u.mmap.len == virt) &&
		   (last->u.mmap.r == r) && (last->u.mmap.w == w) &&
		   (last->u.mmap.x == x) && (last->u.mmap.fd == fd) &&
		   (last->u.mmap.offset + last->u.mmap.len == offset)){
			last->u.mmap.len += len;
			return 0;
		}
	}

	if(*index == last_filled){
		ret = (*do_ops)(mmu, ops, last_filled, 0, flush);
		*index = -1;
	}

	ops[++*index] = ((struct host_vm_op) { .type	= MMAP,
			     			.u = { .mmap = {
						       .addr	= virt,
						       .len	= len,
						       .r	= r,
						       .w	= w,
						       .x	= x,
						       .fd	= fd,
						       .offset	= offset }
			   } });
	return ret;
}

static int add_munmap(unsigned long addr, unsigned long len,
		      struct host_vm_op *ops, int *index, int last_filled,
		      union mm_context *mmu, void **flush,
		      int (*do_ops)(union mm_context *, struct host_vm_op *,
				    int, int, void **))
{
	struct host_vm_op *last;
	int ret = 0;

	if(*index != -1){
		last = &ops[*index];
		if((last->type == MUNMAP) &&
		   (last->u.munmap.addr + last->u.mmap.len == addr)){
			last->u.munmap.len += len;
			return 0;
		}
	}

	if(*index == last_filled){
		ret = (*do_ops)(mmu, ops, last_filled, 0, flush);
		*index = -1;
	}

	ops[++*index] = ((struct host_vm_op) { .type	= MUNMAP,
			     		       .u = { .munmap = {
						        .addr	= addr,
							.len	= len } } });
	return ret;
}

static int add_mprotect(unsigned long addr, unsigned long len, int r, int w,
			int x, struct host_vm_op *ops, int *index,
			int last_filled, union mm_context *mmu, void **flush,
			int (*do_ops)(union mm_context *, struct host_vm_op *,
				      int, int, void **))
{
	struct host_vm_op *last;
	int ret = 0;

	if(*index != -1){
		last = &ops[*index];
		if((last->type == MPROTECT) &&
		   (last->u.mprotect.addr + last->u.mprotect.len == addr) &&
		   (last->u.mprotect.r == r) && (last->u.mprotect.w == w) &&
		   (last->u.mprotect.x == x)){
			last->u.mprotect.len += len;
			return 0;
		}
	}

	if(*index == last_filled){
		ret = (*do_ops)(mmu, ops, last_filled, 0, flush);
		*index = -1;
	}

	ops[++*index] = ((struct host_vm_op) { .type	= MPROTECT,
			     		       .u = { .mprotect = {
						       .addr	= addr,
						       .len	= len,
						       .r	= r,
						       .w	= w,
						       .x	= x } } });
	return ret;
}

#define ADD_ROUND(n, inc) (((n) + (inc)) & ~((inc) - 1))

void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
		      unsigned long end_addr, int force,
		      int (*do_ops)(union mm_context *, struct host_vm_op *,
				    int, int, void **))
{
	pgd_t *npgd;
	pud_t *npud;
	pmd_t *npmd;
	pte_t *npte;
	union mm_context *mmu = &mm->context;
	unsigned long addr, end;
	int r, w, x;
	struct host_vm_op ops[1];
	void *flush = NULL;
	int op_index = -1, last_op = ARRAY_SIZE(ops) - 1;
	int ret = 0;

	if(mm == NULL)
		return;

	ops[0].type = NONE;
	for(addr = start_addr; addr < end_addr && !ret;){
		npgd = pgd_offset(mm, addr);
		if(!pgd_present(*npgd)){
			end = ADD_ROUND(addr, PGDIR_SIZE);
			if(end > end_addr)
				end = end_addr;
			if(force || pgd_newpage(*npgd)){
				ret = add_munmap(addr, end - addr, ops,
						 &op_index, last_op, mmu,
						 &flush, do_ops);
				pgd_mkuptodate(*npgd);
			}
			addr = end;
			continue;
		}

		npud = pud_offset(npgd, addr);
		if(!pud_present(*npud)){
			end = ADD_ROUND(addr, PUD_SIZE);
			if(end > end_addr)
				end = end_addr;
			if(force || pud_newpage(*npud)){
				ret = add_munmap(addr, end - addr, ops,
						 &op_index, last_op, mmu,
						 &flush, do_ops);
				pud_mkuptodate(*npud);
			}
			addr = end;
			continue;
		}

		npmd = pmd_offset(npud, addr);
		if(!pmd_present(*npmd)){
			end = ADD_ROUND(addr, PMD_SIZE);
			if(end > end_addr)
				end = end_addr;
			if(force || pmd_newpage(*npmd)){
				ret = add_munmap(addr, end - addr, ops,
						 &op_index, last_op, mmu,
						 &flush, do_ops);
				pmd_mkuptodate(*npmd);
			}
			addr = end;
			continue;
		}

		npte = pte_offset_kernel(npmd, addr);
		r = pte_read(*npte);
		w = pte_write(*npte);
		x = pte_exec(*npte);
		if (!pte_young(*npte)) {
			r = 0;
			w = 0;
		} else if (!pte_dirty(*npte)) {
			w = 0;
		}
		if(force || pte_newpage(*npte)){
			if(pte_present(*npte))
				ret = add_mmap(addr,
					       pte_val(*npte) & PAGE_MASK,
					       PAGE_SIZE, r, w, x, ops,
					       &op_index, last_op, mmu,
					       &flush, do_ops);
			else ret = add_munmap(addr, PAGE_SIZE, ops,
					      &op_index, last_op, mmu,
					      &flush, do_ops);
		}
		else if(pte_newprot(*npte))
			ret = add_mprotect(addr, PAGE_SIZE, r, w, x, ops,
					   &op_index, last_op, mmu,
					   &flush, do_ops);

		*npte = pte_mkuptodate(*npte);
		addr += PAGE_SIZE;
	}
	if(!ret)
		ret = (*do_ops)(mmu, ops, op_index, 1, &flush);

/* This is not an else because ret is modified above */
	if(ret) {
		printk("fix_range_common: failed, killing current process\n");
		force_sig(SIGKILL, current);
	}
}

int flush_tlb_kernel_range_common(unsigned long start, unsigned long end)
{
	struct mm_struct *mm;
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte;
	unsigned long addr, last;
	int updated = 0, err;

	mm = &init_mm;
	for(addr = start; addr < end;){
		pgd = pgd_offset(mm, addr);
		if(!pgd_present(*pgd)){
			last = ADD_ROUND(addr, PGDIR_SIZE);
			if(last > end)
				last = end;
			if(pgd_newpage(*pgd)){
				updated = 1;
				err = os_unmap_memory((void *) addr,
						      last - addr);
				if(err < 0)
					panic("munmap failed, errno = %d\n",
					      -err);
			}
			addr = last;
			continue;
		}

		pud = pud_offset(pgd, addr);
		if(!pud_present(*pud)){
			last = ADD_ROUND(addr, PUD_SIZE);
			if(last > end)
				last = end;
			if(pud_newpage(*pud)){
				updated = 1;
				err = os_unmap_memory((void *) addr,
						      last - addr);
				if(err < 0)
					panic("munmap failed, errno = %d\n",
					      -err);
			}
			addr = last;
			continue;
		}

		pmd = pmd_offset(pud, addr);
		if(!pmd_present(*pmd)){
			last = ADD_ROUND(addr, PMD_SIZE);
			if(last > end)
				last = end;
			if(pmd_newpage(*pmd)){
				updated = 1;
				err = os_unmap_memory((void *) addr,
						      last - addr);
				if(err < 0)
					panic("munmap failed, errno = %d\n",
					      -err);
			}
			addr = last;
			continue;
		}

		pte = pte_offset_kernel(pmd, addr);
		if(!pte_present(*pte) || pte_newpage(*pte)){
			updated = 1;
			err = os_unmap_memory((void *) addr,
					      PAGE_SIZE);
			if(err < 0)
				panic("munmap failed, errno = %d\n",
				      -err);
			if(pte_present(*pte))
				map_memory(addr,
					   pte_val(*pte) & PAGE_MASK,
					   PAGE_SIZE, 1, 1, 1);
		}
		else if(pte_newprot(*pte)){
			updated = 1;
			os_protect_memory((void *) addr, PAGE_SIZE, 1, 1, 1);
		}
		addr += PAGE_SIZE;
	}
	return(updated);
}

pgd_t *pgd_offset_proc(struct mm_struct *mm, unsigned long address)
{
	return(pgd_offset(mm, address));
}

pud_t *pud_offset_proc(pgd_t *pgd, unsigned long address)
{
	return(pud_offset(pgd, address));
}

pmd_t *pmd_offset_proc(pud_t *pud, unsigned long address)
{
	return(pmd_offset(pud, address));
}

pte_t *pte_offset_proc(pmd_t *pmd, unsigned long address)
{
	return(pte_offset_kernel(pmd, address));
}

pte_t *addr_pte(struct task_struct *task, unsigned long addr)
{
	pgd_t *pgd = pgd_offset(task->mm, addr);
	pud_t *pud = pud_offset(pgd, addr);
	pmd_t *pmd = pmd_offset(pud, addr);

	return(pte_offset_map(pmd, addr));
}

void flush_tlb_page(struct vm_area_struct *vma, unsigned long address)
{
	address &= PAGE_MASK;
	flush_tlb_range(vma, address, address + PAGE_SIZE);
}

void flush_tlb_all(void)
{
	flush_tlb_mm(current->mm);
}

void flush_tlb_kernel_range(unsigned long start, unsigned long end)
{
	CHOOSE_MODE_PROC(flush_tlb_kernel_range_tt,
			 flush_tlb_kernel_range_common, start, end);
}

void flush_tlb_kernel_vm(void)
{
	CHOOSE_MODE(flush_tlb_kernel_vm_tt(),
		    flush_tlb_kernel_range_common(start_vm, end_vm));
}

void __flush_tlb_one(unsigned long addr)
{
	CHOOSE_MODE_PROC(__flush_tlb_one_tt, __flush_tlb_one_skas, addr);
}

void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
		     unsigned long end)
{
	CHOOSE_MODE_PROC(flush_tlb_range_tt, flush_tlb_range_skas, vma, start,
			 end);
}

void flush_tlb_mm(struct mm_struct *mm)
{
	CHOOSE_MODE_PROC(flush_tlb_mm_tt, flush_tlb_mm_skas, mm);
}

void force_flush_all(void)
{
	CHOOSE_MODE(force_flush_all_tt(), force_flush_all_skas());
}
Commit	Line	Data
5e1f65a6	1	/*
1da177e4 LT	2	* Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
	3	* Licensed under the GPL
	4	*/
	5
	6	#include "linux/mm.h"
	7	#include "asm/page.h"
	8	#include "asm/pgalloc.h"
	9	#include "asm/tlbflush.h"
	10	#include "choose-mode.h"
	11	#include "mode_kern.h"
4ff83ce1	12	#include "as-layout.h"
1da177e4 LT	13	#include "tlb.h"
	14	#include "mem.h"
	15	#include "mem_user.h"
	16	#include "os.h"
	17
c5600490	18	static int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
5e1f65a6	19	int r, int w, int x, struct host_vm_op ops, int index,
c5600490	20	int last_filled, union mm_context mmu, void *flush,
07bf731e BS	21	int (do_ops)(union mm_context , struct host_vm_op *,
07bf731e BS	22	int, int, void **))
c5600490	23	{
5e1f65a6	24	__u64 offset;
c5600490	25	struct host_vm_op *last;
07bf731e	26	int fd, ret = 0;
c5600490 JD	27
c5600490 JD	28	fd = phys_mapping(phys, &offset);
07bf731e BS	29	if(*index != -1){
07bf731e BS	30	last = &ops[*index];
c5600490 JD	31	if((last->type == MMAP) &&
	32	(last->u.mmap.addr + last->u.mmap.len == virt) &&
	33	(last->u.mmap.r == r) && (last->u.mmap.w == w) &&
	34	(last->u.mmap.x == x) && (last->u.mmap.fd == fd) &&
	35	(last->u.mmap.offset + last->u.mmap.len == offset)){
	36	last->u.mmap.len += len;
07bf731e	37	return 0;
c5600490 JD	38	}
	39	}
	40
07bf731e BS	41	if(*index == last_filled){
	42	ret = (*do_ops)(mmu, ops, last_filled, 0, flush);
	43	*index = -1;
c5600490 JD	44	}
c5600490 JD	45
07bf731e BS	46	ops[++*index] = ((struct host_vm_op) { .type = MMAP,
	47	.u = { .mmap = {
	48	.addr = virt,
	49	.len = len,
	50	.r = r,
	51	.w = w,
	52	.x = x,
	53	.fd = fd,
	54	.offset = offset }
	55	} });
	56	return ret;
c5600490 JD	57	}
	58
	59	static int add_munmap(unsigned long addr, unsigned long len,
07bf731e	60	struct host_vm_op ops, int index, int last_filled,
c5600490	61	union mm_context mmu, void *flush,
07bf731e BS	62	int (do_ops)(union mm_context , struct host_vm_op *,
07bf731e BS	63	int, int, void **))
c5600490 JD	64	{
c5600490 JD	65	struct host_vm_op *last;
07bf731e	66	int ret = 0;
c5600490	67
07bf731e BS	68	if(*index != -1){
07bf731e BS	69	last = &ops[*index];
c5600490 JD	70	if((last->type == MUNMAP) &&
	71	(last->u.munmap.addr + last->u.mmap.len == addr)){
	72	last->u.munmap.len += len;
07bf731e	73	return 0;
c5600490 JD	74	}
	75	}
	76
07bf731e BS	77	if(*index == last_filled){
	78	ret = (*do_ops)(mmu, ops, last_filled, 0, flush);
	79	*index = -1;
c5600490 JD	80	}
c5600490 JD	81
07bf731e BS	82	ops[++*index] = ((struct host_vm_op) { .type = MUNMAP,
	83	.u = { .munmap = {
	84	.addr = addr,
	85	.len = len } } });
	86	return ret;
c5600490 JD	87	}
	88
	89	static int add_mprotect(unsigned long addr, unsigned long len, int r, int w,
07bf731e	90	int x, struct host_vm_op ops, int index,
c5600490	91	int last_filled, union mm_context mmu, void *flush,
5e1f65a6	92	int (do_ops)(union mm_context , struct host_vm_op *,
07bf731e	93	int, int, void **))
c5600490 JD	94	{
c5600490 JD	95	struct host_vm_op *last;
07bf731e	96	int ret = 0;
c5600490	97
07bf731e BS	98	if(*index != -1){
07bf731e BS	99	last = &ops[*index];
c5600490 JD	100	if((last->type == MPROTECT) &&
	101	(last->u.mprotect.addr + last->u.mprotect.len == addr) &&
	102	(last->u.mprotect.r == r) && (last->u.mprotect.w == w) &&
	103	(last->u.mprotect.x == x)){
	104	last->u.mprotect.len += len;
07bf731e	105	return 0;
c5600490 JD	106	}
	107	}
	108
07bf731e BS	109	if(*index == last_filled){
	110	ret = (*do_ops)(mmu, ops, last_filled, 0, flush);
	111	*index = -1;
c5600490 JD	112	}
c5600490 JD	113
07bf731e BS	114	ops[++*index] = ((struct host_vm_op) { .type = MPROTECT,
	115	.u = { .mprotect = {
	116	.addr = addr,
	117	.len = len,
	118	.r = r,
	119	.w = w,
	120	.x = x } } });
	121	return ret;
c5600490 JD	122	}
c5600490 JD	123
1da177e4 LT	124	#define ADD_ROUND(n, inc) (((n) + (inc)) & ~((inc) - 1))
	125
	126	void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
5e1f65a6	127	unsigned long end_addr, int force,
07bf731e BS	128	int (do_ops)(union mm_context , struct host_vm_op *,
07bf731e BS	129	int, int, void **))
1da177e4	130	{
5e1f65a6 JD	131	pgd_t *npgd;
	132	pud_t *npud;
	133	pmd_t *npmd;
	134	pte_t *npte;
	135	union mm_context *mmu = &mm->context;
	136	unsigned long addr, end;
	137	int r, w, x;
	138	struct host_vm_op ops[1];
	139	void *flush = NULL;
	140	int op_index = -1, last_op = ARRAY_SIZE(ops) - 1;
	141	int ret = 0;
	142
	143	if(mm == NULL)
91b165c0	144	return;
1da177e4	145
5e1f65a6 JD	146	ops[0].type = NONE;
	147	for(addr = start_addr; addr < end_addr && !ret;){
	148	npgd = pgd_offset(mm, addr);
	149	if(!pgd_present(*npgd)){
	150	end = ADD_ROUND(addr, PGDIR_SIZE);
	151	if(end > end_addr)
	152	end = end_addr;
	153	if(force \|\| pgd_newpage(*npgd)){
	154	ret = add_munmap(addr, end - addr, ops,
	155	&op_index, last_op, mmu,
	156	&flush, do_ops);
	157	pgd_mkuptodate(*npgd);
	158	}
	159	addr = end;
	160	continue;
	161	}
	162
	163	npud = pud_offset(npgd, addr);
	164	if(!pud_present(*npud)){
	165	end = ADD_ROUND(addr, PUD_SIZE);
	166	if(end > end_addr)
	167	end = end_addr;
	168	if(force \|\| pud_newpage(*npud)){
	169	ret = add_munmap(addr, end - addr, ops,
	170	&op_index, last_op, mmu,
	171	&flush, do_ops);
	172	pud_mkuptodate(*npud);
	173	}
	174	addr = end;
	175	continue;
	176	}
	177
	178	npmd = pmd_offset(npud, addr);
	179	if(!pmd_present(*npmd)){
	180	end = ADD_ROUND(addr, PMD_SIZE);
	181	if(end > end_addr)
	182	end = end_addr;
	183	if(force \|\| pmd_newpage(*npmd)){
	184	ret = add_munmap(addr, end - addr, ops,
	185	&op_index, last_op, mmu,
	186	&flush, do_ops);
	187	pmd_mkuptodate(*npmd);
	188	}
	189	addr = end;
	190	continue;
	191	}
	192
	193	npte = pte_offset_kernel(npmd, addr);
	194	r = pte_read(*npte);
	195	w = pte_write(*npte);
	196	x = pte_exec(*npte);
dc36abf3 PBG	197	if (!pte_young(*npte)) {
	198	r = 0;
	199	w = 0;
	200	} else if (!pte_dirty(*npte)) {
	201	w = 0;
	202	}
5e1f65a6 JD	203	if(force \|\| pte_newpage(*npte)){
	204	if(pte_present(*npte))
	205	ret = add_mmap(addr,
	206	pte_val(*npte) & PAGE_MASK,
	207	PAGE_SIZE, r, w, x, ops,
	208	&op_index, last_op, mmu,
	209	&flush, do_ops);
07bf731e BS	210	else ret = add_munmap(addr, PAGE_SIZE, ops,
	211	&op_index, last_op, mmu,
	212	&flush, do_ops);
5e1f65a6 JD	213	}
5e1f65a6 JD	214	else if(pte_newprot(*npte))
07bf731e BS	215	ret = add_mprotect(addr, PAGE_SIZE, r, w, x, ops,
	216	&op_index, last_op, mmu,
	217	&flush, do_ops);
1da177e4	218
5e1f65a6 JD	219	npte = pte_mkuptodate(npte);
	220	addr += PAGE_SIZE;
	221	}
07bf731e BS	222	if(!ret)
	223	ret = (*do_ops)(mmu, ops, op_index, 1, &flush);
	224
5e1f65a6	225	/* This is not an else because ret is modified above */
07bf731e BS	226	if(ret) {
	227	printk("fix_range_common: failed, killing current process\n");
	228	force_sig(SIGKILL, current);
	229	}
1da177e4 LT	230	}
	231
	232	int flush_tlb_kernel_range_common(unsigned long start, unsigned long end)
	233	{
5e1f65a6 JD	234	struct mm_struct *mm;
	235	pgd_t *pgd;
	236	pud_t *pud;
	237	pmd_t *pmd;
	238	pte_t *pte;
	239	unsigned long addr, last;
	240	int updated = 0, err;
	241
	242	mm = &init_mm;
	243	for(addr = start; addr < end;){
	244	pgd = pgd_offset(mm, addr);
	245	if(!pgd_present(*pgd)){
	246	last = ADD_ROUND(addr, PGDIR_SIZE);
	247	if(last > end)
	248	last = end;
	249	if(pgd_newpage(*pgd)){
	250	updated = 1;
	251	err = os_unmap_memory((void *) addr,
	252	last - addr);
	253	if(err < 0)
	254	panic("munmap failed, errno = %d\n",
	255	-err);
	256	}
	257	addr = last;
	258	continue;
	259	}
	260
	261	pud = pud_offset(pgd, addr);
	262	if(!pud_present(*pud)){
	263	last = ADD_ROUND(addr, PUD_SIZE);
	264	if(last > end)
	265	last = end;
	266	if(pud_newpage(*pud)){
	267	updated = 1;
	268	err = os_unmap_memory((void *) addr,
	269	last - addr);
	270	if(err < 0)
	271	panic("munmap failed, errno = %d\n",
	272	-err);
	273	}
	274	addr = last;
	275	continue;
	276	}
	277
	278	pmd = pmd_offset(pud, addr);
	279	if(!pmd_present(*pmd)){
	280	last = ADD_ROUND(addr, PMD_SIZE);
	281	if(last > end)
	282	last = end;
	283	if(pmd_newpage(*pmd)){
	284	updated = 1;
	285	err = os_unmap_memory((void *) addr,
	286	last - addr);
	287	if(err < 0)
	288	panic("munmap failed, errno = %d\n",
	289	-err);
	290	}
	291	addr = last;
	292	continue;
	293	}
	294
	295	pte = pte_offset_kernel(pmd, addr);
	296	if(!pte_present(pte) \|\| pte_newpage(pte)){
	297	updated = 1;
298	err = os_unmap_memory((void *) addr,
299	PAGE_SIZE);
300	if(err < 0)
301	panic("munmap failed, errno = %d\n",
302	-err);
303	if(pte_present(*pte))
304	map_memory(addr,
305	pte_val(*pte) & PAGE_MASK,
306	PAGE_SIZE, 1, 1, 1);
307	}
308	else if(pte_newprot(*pte)){
309	updated = 1;
310	os_protect_memory((void *) addr, PAGE_SIZE, 1, 1, 1);
311	}
312	addr += PAGE_SIZE;
313	}
314	return(updated);
1da177e4 LT	315	}
1da177e4 LT	316
1da177e4 LT	317	pgd_t pgd_offset_proc(struct mm_struct mm, unsigned long address)
1da177e4 LT	318	{
5e1f65a6	319	return(pgd_offset(mm, address));
1da177e4 LT	320	}
	321
	322	pud_t pud_offset_proc(pgd_t pgd, unsigned long address)
	323	{
5e1f65a6	324	return(pud_offset(pgd, address));
1da177e4 LT	325	}
	326
	327	pmd_t pmd_offset_proc(pud_t pud, unsigned long address)
	328	{
5e1f65a6	329	return(pmd_offset(pud, address));
1da177e4 LT	330	}
	331
	332	pte_t pte_offset_proc(pmd_t pmd, unsigned long address)
	333	{
5e1f65a6	334	return(pte_offset_kernel(pmd, address));
1da177e4 LT	335	}
	336
	337	pte_t addr_pte(struct task_struct task, unsigned long addr)
	338	{
5e1f65a6 JD	339	pgd_t *pgd = pgd_offset(task->mm, addr);
	340	pud_t *pud = pud_offset(pgd, addr);
	341	pmd_t *pmd = pmd_offset(pud, addr);
1da177e4	342
5e1f65a6	343	return(pte_offset_map(pmd, addr));
1da177e4 LT	344	}
1da177e4 LT	345
d67b569f JD	346	void flush_tlb_page(struct vm_area_struct *vma, unsigned long address)
d67b569f JD	347	{
5e1f65a6 JD	348	address &= PAGE_MASK;
5e1f65a6 JD	349	flush_tlb_range(vma, address, address + PAGE_SIZE);
d67b569f JD	350	}
	351
	352	void flush_tlb_all(void)
	353	{
5e1f65a6	354	flush_tlb_mm(current->mm);
d67b569f JD	355	}
	356
	357	void flush_tlb_kernel_range(unsigned long start, unsigned long end)
	358	{
5e1f65a6 JD	359	CHOOSE_MODE_PROC(flush_tlb_kernel_range_tt,
5e1f65a6 JD	360	flush_tlb_kernel_range_common, start, end);
d67b569f JD	361	}
	362
	363	void flush_tlb_kernel_vm(void)
	364	{
5e1f65a6 JD	365	CHOOSE_MODE(flush_tlb_kernel_vm_tt(),
5e1f65a6 JD	366	flush_tlb_kernel_range_common(start_vm, end_vm));
d67b569f JD	367	}
	368
	369	void __flush_tlb_one(unsigned long addr)
	370	{
5e1f65a6	371	CHOOSE_MODE_PROC(__flush_tlb_one_tt, __flush_tlb_one_skas, addr);
d67b569f JD	372	}
	373
	374	void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
	375	unsigned long end)
	376	{
5e1f65a6 JD	377	CHOOSE_MODE_PROC(flush_tlb_range_tt, flush_tlb_range_skas, vma, start,
5e1f65a6 JD	378	end);
d67b569f JD	379	}
	380
	381	void flush_tlb_mm(struct mm_struct *mm)
	382	{
5e1f65a6	383	CHOOSE_MODE_PROC(flush_tlb_mm_tt, flush_tlb_mm_skas, mm);
d67b569f JD	384	}
	385
	386	void force_flush_all(void)
	387	{
5e1f65a6	388	CHOOSE_MODE(force_flush_all_tt(), force_flush_all_skas());
d67b569f JD	389	}
d67b569f JD	390