plan 9 kernel history: overview | file list | diff list

1991/0821/gnot/mmu.c (diff list | history)

gnot/mmu.c on 1990/03091
1990/03091    
#include	"u.h" 
#include	"lib.h" 
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
 
1990/06021    
struct 
{ 
	Lock; 
	int	init; 
	KMap	*free; 
1991/0821    
	KMap	arena[MB4/BY2PG];	/* kernel mmu maps up to 4MB */ 
1990/06021    
}kmapalloc; 
 
1990/03091    
/* 
 * Called splhi, not in Running state 
 */ 
void 
mapstack(Proc *p) 
{ 
	ulong tlbvirt, tlbphys; 
1990/1004    
	ulong next; 
	MMU *mm, *mn, *me; 
1990/03091    
 
1991/0705    
 
1990/03091    
	if(p->upage->va != (USERADDR|(p->pid&0xFFFF))) 
		panic("mapstack %d 0x%lux 0x%lux", p->pid, p->upage->pa, p->upage->va); 
	tlbvirt = USERADDR; 
	tlbphys = PPN(p->upage->pa) | PTEVALID | PTEKERNEL; 
	putkmmu(tlbvirt, tlbphys); 
1990/1211    
	u = (User*)USERADDR; 
1990/1004    
 
1991/0705    
	if(p->newtlb) { 
		flushmmu(); 
		clearmmucache(); 
		p->newtlb = 0; 
	} 
 
1990/1004    
	/* 
	 *  if not a kernel process and this process was not the  
	 *  last process on this machine, flush & preload mmu 
	 */ 
	if(!p->kp && p!=m->lproc){ 
		flushmmu(); 
 
		/* 
		 *  preload the MMU with the last (up to) NMMU user entries 
		 *  previously faulted into it for this process. 
		 */ 
		mn = &u->mc.mmu[u->mc.next&(NMMU-1)]; 
		me = &u->mc.mmu[NMMU]; 
		if(u->mc.next >= NMMU){ 
			for(mm = mn; mm < me; mm++) 
				UMAP[mm->va] = mm->pa; 
		} 
		for(mm = u->mc.mmu; mm < mn; mm++) 
			UMAP[mm->va] = mm->pa; 
 
		m->lproc = p; 
	} 
1990/03091    
} 
 
void 
1991/0507    
mmurelease(Proc *p) 
{ 
	USED(p); 
} 
 
void 
1990/03091    
putkmmu(ulong tlbvirt, ulong tlbphys) 
{ 
	if(!(tlbvirt&KZERO)) 
		panic("putkmmu"); 
	tlbvirt &= ~KZERO; 
	KMAP[(tlbvirt&0x003FE000L)>>2] = tlbphys; 
} 
 
void 
1991/0705    
putmmu(ulong tlbvirt, ulong tlbphys, Page *p) 
1990/03091    
{ 
	if(tlbvirt&KZERO) 
		panic("putmmu"); 
	tlbphys |= VTAG(tlbvirt)<<24; 
1990/1004    
	tlbvirt = (tlbvirt&0x003FE000L)>>2; 
	if(u){ 
		MMU *mp; 
		int s; 
 
		s = splhi(); 
		mp = &(u->mc.mmu[u->mc.next&(NMMU-1)]); 
		mp->pa = tlbphys; 
		mp->va = tlbvirt; 
		u->mc.next++; 
		splx(s); 
	} 
	UMAP[tlbvirt] = tlbphys; 
1990/03091    
} 
 
void 
flushmmu(void) 
{ 
	flushcpucache(); 
	*PARAM &= ~TLBFLUSH_; 
	*PARAM |= TLBFLUSH_; 
1990/1004    
} 
 
void 
clearmmucache(void) 
{ 
	if(u == 0) 
1991/0705    
		panic("clearmmucache"); 
1990/1004    
	u->mc.next = 0; 
1990/06021    
} 
 
void 
kmapinit(void) 
{ 
	KMap *k; 
	int i, e; 
 
	if(kmapalloc.init == 0){ 
		k = &kmapalloc.arena[0]; 
1991/0821    
		k->va = KZERO|(MB4-256*1024-BY2PG); 
1990/06021    
		k->next = 0; 
		kmapalloc.free = k; 
		kmapalloc.init = 1; 
		return; 
	} 
1991/0821    
 
	e = (MB4 - 256*1024)/BY2PG;	/* screen lives at top 256K */ 
1991/0802    
	i = PGROUND(((ulong)ialloc(0, 0))&~KZERO)/BY2PG; 
1991/0821    
 
1990/0709    
	print("%lud free map registers\n", e-i); 
1991/0821    
 
1990/06021    
	kmapalloc.free = 0; 
	for(k=&kmapalloc.arena[i]; i<e; i++,k++){ 
		k->va = i*BY2PG|KZERO; 
		kunmap(k); 
	} 
} 
 
KMap* 
kmap(Page *pg) 
{ 
	KMap *k; 
 
	lock(&kmapalloc); 
	k = kmapalloc.free; 
1990/0709    
	if(k == 0){ 
		dumpstack(); 
1990/06021    
		panic("kmap"); 
1990/0709    
	} 
1990/06021    
	kmapalloc.free = k->next; 
	unlock(&kmapalloc); 
1991/0821    
 
1990/06021    
	k->pa = pg->pa; 
	putkmmu(k->va, PPN(k->pa) | PTEVALID | PTEKERNEL); 
	return k; 
} 
 
void 
kunmap(KMap *k) 
{ 
	k->pa = 0; 
1991/0821    
	putkmmu(k->va, INVALIDPTE); 
 
1990/06021    
	lock(&kmapalloc); 
	k->next = kmapalloc.free; 
	kmapalloc.free = k; 
	unlock(&kmapalloc); 
1990/1211    
} 
 
void 
invalidateu(void) 
{ 
	putkmmu(USERADDR, INVALIDPTE); 
1990/03091    
} 


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)