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

1991/0717/ss/faultsparc.c (diff list | history)

1990/1223/sys/src/9/ss/faultsparc.c:6,92 – 1990/1226/sys/src/9/ss/faultsparc.c:6,48 (short | long)
1990/1223    
#include	"ureg.h" 
#include	"errno.h" 
 
#define	FORMAT(ur)	((((ur)->vo)>>12)&0xF) 
#define	OFFSET(ur)	(((ur)->vo)&0xFFF) 
 
                 
struct FFrame 
{ 
	ushort	ireg0;			/* internal register */ 
	ushort	ssw;			/* special status word */ 
	ushort	ipsc;			/* instr. pipe stage c */ 
	ushort	ipsb;			/* instr. pipe stage b */ 
	ulong	addr;			/* data cycle fault address */ 
	ushort	ireg1;			/* internal register */ 
	ushort	ireg2;			/* internal register */ 
	ulong	dob;			/* data output buffer */ 
	ushort	ireg3[4];		/* more stuff */ 
	ulong	baddr;			/* stage b address */ 
	ushort	ireg4[26];		/* more more stuff */ 
}; 
                 
/* 
 * SSW bits 
 */ 
#define	RW	0x0040		/* read/write for data cycle */ 
#define	FC	0x8000		/* fault on stage C of instruction pipe */ 
#define	FB	0x4000		/* fault on stage B of instruction pipe */ 
#define	RC	0x2000		/* rerun flag for stage C of instruction pipe */ 
#define	RB	0x1000		/* rerun flag for stage B of instruction pipe */ 
#define	DF	0x0100		/* fault/rerun flag for data cycle */ 
#define	RM	0x0080		/* read-modify-write on data cycle */ 
#define	READ	0x0040 
#define	WRITE	0x0000 
#define	SIZ	0x0030		/* size code for data cycle */ 
#define	FC2	0x0004		/* address space for data cycle */ 
#define	FC1	0x0002 
#define	FC0	0x0001 
                 
void 
fault68020(Ureg *ur, FFrame *f)
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{ 
	ulong addr, badvaddr; 
	int user, read, insyscall;
1990/1226    
	ulong tbr;
1990/1223    
1990/1226    
	tbr = ur->tbr&0xFFF; 
	addr = ur->pc;			/* assume instr. exception */ 
	if(tbr == (9<<4))		/* data access exception */ 
		addr = getw2(SEVAR); 
	else if(tbr != (1<<4)){		/* should be instruction access exception */ 
		trap(ur); 
		panic("trap returns"); 
	} 
	spllo(); 
print("fault: %s pc=0x%lux addr %lux\n", excname(ur->tbr), ur->pc, addr);
1990/1223    
	if(u == 0){ 
		dumpregs(ur); 
		panic("fault u==0 pc=%lux", ur->pc); 
	}
1990/1226    
	if(getw2(SER) & 0x8000) 
		read = 0; 
	else 
		read = 1;
1990/1223    
	insyscall = u->p->insyscall; 
	u->p->insyscall = 1; 
	addr = 0;	/* set */ 
	if(f->ssw & DF) 
		addr = f->addr; 
	else if(FORMAT(ur) == 0xA){ 
		if(f->ssw & FC) 
			addr = ur->pc+2; 
		else if(f->ssw & FB) 
			addr = ur->pc+4; 
		else 
			panic("prefetch pagefault"); 
	}else if(FORMAT(ur) == 0xB){ 
		if(f->ssw & FC) 
			addr = f->baddr-2; 
		else if(f->ssw & FB) 
			addr = f->baddr; 
		else 
			panic("prefetch pagefault"); 
	}else 
		panic("prefetch format"); 
	addr &= VAMASK;
1990/1226    
/*	addr &= VAMASK; /**/
1990/1223    
	badvaddr = addr; 
	addr &= ~(BY2PG-1); 
	user = !(ur->sr&SUPER); 
	if(f->ssw & DF) 
		read = (f->ssw&READ) && !(f->ssw&RM); 
	else 
		read = f->ssw&(FB|FC); 
/* print("fault pc=%lux addr=%lux read %d\n", ur->pc, badvaddr, read); /**/
1990/1226    
	user = !(ur->psr&PSRSUPER);
1990/1223    
 
	if(fault(addr, read) < 0){ 
		if(user){ 
			pprint("user %s error addr=0x%lux\n", read? "read" : "write", badvaddr); 
			pprint("status=0x%lux pc=0x%lux sp=0x%lux\n", ur->sr, ur->pc, ur->sp);
1990/1226    
			pprint("psr=0x%lux pc=0x%lux sp=0x%lux\n", ur->psr, ur->pc, ur->sp);
1990/1223    
			pexit("Suicide", 0); 
		} 
		u->p->state = MMUing;
1990/1223/sys/src/9/ss/faultsparc.c:95,98 – 1990/1226/sys/src/9/ss/faultsparc.c:51,67
1990/1223    
		exit(); 
	} 
	u->p->insyscall = insyscall;
1990/1226    
} 
 
/* 
 * called in sysfile.c 
 */ 
void 
evenaddr(ulong addr) 
{ 
	if(addr & 3){ 
panic("evenaddr"); 
		postnote(u->p, 1, "sys: odd address", NDebug); 
		error(Ebadarg); 
	}
1990/1223    
}
1990/1226/sys/src/9/ss/faultsparc.c:14,29 – 1990/1227/sys/src/9/ss/faultsparc.c:14,29 (short | long)
1990/1223    
	int user, read, insyscall;
1990/1226    
	ulong tbr;
1990/1223    
1990/1226    
	tbr = ur->tbr&0xFFF;
1990/1227    
	tbr = (ur->tbr&0xFFF)>>4;
1990/1226    
	addr = ur->pc;			/* assume instr. exception */ 
	if(tbr == (9<<4))		/* data access exception */
1990/1227    
	if(tbr == 9)			/* data access exception */
1990/1226    
		addr = getw2(SEVAR); 
	else if(tbr != (1<<4)){		/* should be instruction access exception */
1990/1227    
	else if(tbr != 1){		/* should be instruction access exception */
1990/1226    
		trap(ur); 
		panic("trap returns");
1990/1227    
		return;
1990/1226    
	} 
	spllo(); 
print("fault: %s pc=0x%lux addr %lux\n", excname(ur->tbr), ur->pc, addr);
1990/1227    
print("fault: %s pc=0x%lux addr %lux\n", excname(tbr), ur->pc, addr);
1990/1223    
	if(u == 0){ 
		dumpregs(ur); 
		panic("fault u==0 pc=%lux", ur->pc);
1990/1227/sys/src/9/ss/faultsparc.c:6,12 – 1990/1231/sys/src/9/ss/faultsparc.c:6,11 (short | long)
1990/1223    
#include	"ureg.h" 
#include	"errno.h" 
 
                 
void
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{
1990/1227/sys/src/9/ss/faultsparc.c:16,43 – 1990/1231/sys/src/9/ss/faultsparc.c:15,44
1990/1223    
1990/1227    
	tbr = (ur->tbr&0xFFF)>>4;
1990/1226    
	addr = ur->pc;			/* assume instr. exception */
1990/1227    
	if(tbr == 9)			/* data access exception */
1990/1231    
	read = 1; 
	if(tbr == 9){			/* data access exception */ 
		/* 
		 * According to the book, this isn't good enough.  We'll see. 
		 */
1990/1226    
		addr = getw2(SEVAR);
1990/1227    
	else if(tbr != 1){		/* should be instruction access exception */
1990/1231    
		if(getw2(SER) & 0x8000) 
			read = 0; 
	}else if(tbr != 1){		/* should be instr. access exception */
1990/1226    
		trap(ur);
1990/1227    
		return;
1990/1226    
	} 
	spllo();
1990/1227    
print("fault: %s pc=0x%lux addr %lux\n", excname(tbr), ur->pc, addr);
1990/1231    
/* print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1990/1223    
	if(u == 0){ 
		dumpregs(ur); 
		panic("fault u==0 pc=%lux", ur->pc); 
	}
1990/1226    
	if(getw2(SER) & 0x8000) 
		read = 0; 
	else 
		read = 1;
1990/1223    
	insyscall = u->p->insyscall; 
	u->p->insyscall = 1;
1990/1226    
/*	addr &= VAMASK; /**/
1990/1223    
	badvaddr = addr; 
	addr &= ~(BY2PG-1);
1990/1226    
	user = !(ur->psr&PSRSUPER);
1990/1231    
	user = !(ur->psr&PSRPSUPER);
1990/1223    
 
	if(fault(addr, read) < 0){ 
		if(user){
1990/1231/sys/src/9/ss/faultsparc.c:6,11 – 1991/0110/sys/src/9/ss/faultsparc.c:6,17 (short | long)
1990/1223    
#include	"ureg.h" 
#include	"errno.h"
1991/0110    
ck(char *s) 
{ 
	if(u->p->seg[SSEG].o->flag == 0) 
		panic(s); 
}
1990/1223    
void
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{
1990/1231/sys/src/9/ss/faultsparc.c:28,34 – 1991/0110/sys/src/9/ss/faultsparc.c:34,41
1990/1227    
		return;
1990/1226    
	} 
	spllo();
1990/1231    
/* print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1991/0110    
print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/ 
ck("faultsparc");
1990/1223    
	if(u == 0){ 
		dumpregs(ur); 
		panic("fault u==0 pc=%lux", ur->pc);
1990/1231/sys/src/9/ss/faultsparc.c:41,46 – 1991/0110/sys/src/9/ss/faultsparc.c:48,58
1990/1231    
	user = !(ur->psr&PSRPSUPER);
1990/1223    
 
	if(fault(addr, read) < 0){
1991/0110    
print("death read %lux %d sizes %lux-%lux %lux-%lux, %lux-%lux %lux-%lux\n", addr, read, 
u->p->seg[SSEG].minva, u->p->seg[SSEG].maxva,  
u->p->seg[TSEG].minva, u->p->seg[TSEG].maxva,  
u->p->seg[DSEG].minva, u->p->seg[DSEG].maxva,  
u->p->seg[BSEG].minva, u->p->seg[BSEG].maxva);
1990/1223    
		if(user){ 
			pprint("user %s error addr=0x%lux\n", read? "read" : "write", badvaddr);
1990/1226    
			pprint("psr=0x%lux pc=0x%lux sp=0x%lux\n", ur->psr, ur->pc, ur->sp);
1990/1231/sys/src/9/ss/faultsparc.c:52,57 – 1991/0110/sys/src/9/ss/faultsparc.c:64,88
1990/1223    
		exit(); 
	} 
	u->p->insyscall = insyscall;
1991/0110    
ck("faultsparc return"); 
} 
 
void 
faultasync(Ureg *ur) 
{ 
	int user; 
 
	print("interrupt 15 ASER %lux ASEVAR %lux SER %lux\n", getw2(ASER), getw2(ASEVAR), getw2(SER)); 
	dumpregs(ur); 
	/* 
	 * Clear interrupt by toggling low bit of interrupt register 
	 */ 
	*intrreg &= ~1; 
	*intrreg |= 1; 
	user = !(ur->psr&PSRPSUPER); 
	if(user) 
		pexit("Suicide", 0); 
	panic("interrupt 15");
1990/1226    
} 
 
/*
1991/0110/sys/src/9/ss/faultsparc.c:6,17 – 1991/0111/sys/src/9/ss/faultsparc.c:6,11 (short | long)
1990/1223    
#include	"ureg.h" 
#include	"errno.h"
1991/0110    
ck(char *s) 
{ 
	if(u->p->seg[SSEG].o->flag == 0) 
		panic(s); 
} 
                 
1990/1223    
void
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{
1991/0110/sys/src/9/ss/faultsparc.c:34,41 – 1991/0111/sys/src/9/ss/faultsparc.c:28,34
1990/1227    
		return;
1990/1226    
	} 
	spllo();
1991/0110    
print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/ 
ck("faultsparc");
1991/0111    
/* print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1990/1223    
	if(u == 0){ 
		dumpregs(ur); 
		panic("fault u==0 pc=%lux", ur->pc);
1991/0110/sys/src/9/ss/faultsparc.c:48,58 – 1991/0111/sys/src/9/ss/faultsparc.c:41,46
1990/1231    
	user = !(ur->psr&PSRPSUPER);
1990/1223    
 
	if(fault(addr, read) < 0){
1991/0110    
print("death read %lux %d sizes %lux-%lux %lux-%lux, %lux-%lux %lux-%lux\n", addr, read, 
u->p->seg[SSEG].minva, u->p->seg[SSEG].maxva,  
u->p->seg[TSEG].minva, u->p->seg[TSEG].maxva,  
u->p->seg[DSEG].minva, u->p->seg[DSEG].maxva,  
u->p->seg[BSEG].minva, u->p->seg[BSEG].maxva);
1990/1223    
		if(user){ 
			pprint("user %s error addr=0x%lux\n", read? "read" : "write", badvaddr);
1990/1226    
			pprint("psr=0x%lux pc=0x%lux sp=0x%lux\n", ur->psr, ur->pc, ur->sp);
1991/0110/sys/src/9/ss/faultsparc.c:64,70 – 1991/0111/sys/src/9/ss/faultsparc.c:52,57
1990/1223    
		exit(); 
	} 
	u->p->insyscall = insyscall;
1991/0110    
ck("faultsparc return"); 
} 
 
void
1991/0111/sys/src/9/ss/faultsparc.c:79,85 – 1991/0115/sys/src/9/ss/faultsparc.c:79,84 (short | long)
1990/1226    
evenaddr(ulong addr) 
{ 
	if(addr & 3){ 
panic("evenaddr"); 
		postnote(u->p, 1, "sys: odd address", NDebug); 
		error(Ebadarg); 
	}
1991/0115/sys/src/9/ss/faultsparc.c:10,16 – 1991/01151/sys/src/9/ss/faultsparc.c:10,16 (short | long)
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{ 
	ulong addr, badvaddr; 
	int user, read, insyscall;
1991/01151    
	int user, read;
1990/1226    
	ulong tbr;
1990/1223    
1990/1227    
	tbr = (ur->tbr&0xFFF)>>4;
1991/0115/sys/src/9/ss/faultsparc.c:23,40 – 1991/01151/sys/src/9/ss/faultsparc.c:23,35
1990/1226    
		addr = getw2(SEVAR);
1990/1231    
		if(getw2(SER) & 0x8000) 
			read = 0; 
	}else if(tbr != 1){		/* should be instr. access exception */
1990/1226    
		trap(ur);
1990/1227    
		return;
1990/1226    
	} 
	spllo();
1991/0111    
/* print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1990/1223    
	if(u == 0){ 
		dumpregs(ur); 
		panic("fault u==0 pc=%lux", ur->pc);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1990/1223    
	} 
	insyscall = u->p->insyscall; 
	u->p->insyscall = 1;
1990/1226    
/*	addr &= VAMASK; /**/
1990/1223    
	badvaddr = addr; 
	addr &= ~(BY2PG-1);
1991/0115/sys/src/9/ss/faultsparc.c:51,57 – 1991/01151/sys/src/9/ss/faultsparc.c:46,52
1990/1223    
		panic("fault: 0x%lux", badvaddr); 
		exit(); 
	} 
	u->p->insyscall = insyscall;
1991/01151    
	splhi();
1991/0110    
} 
 
void
1991/01151/sys/src/9/ss/faultsparc.c:25,31 – 1991/0503/sys/src/9/ss/faultsparc.c:25,31 (short | long)
1990/1231    
			read = 0;
1990/1226    
	} 
	spllo();
1991/0111    
/* print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1991/0503    
print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1991/0503/sys/src/9/ss/faultsparc.c:25,31 – 1991/0504/sys/src/9/ss/faultsparc.c:25,30 (short | long)
1990/1231    
			read = 0;
1990/1226    
	} 
	spllo();
1991/0503    
print("fault: %s pc=0x%lux addr %lux %d\n", excname(tbr), ur->pc, addr, read); /**/
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1991/0504/sys/src/9/ss/faultsparc.c:25,30 – 1991/0711/sys/src/9/ss/faultsparc.c:25,31 (short | long)
1990/1231    
			read = 0;
1990/1226    
	} 
	spllo();
1991/0711    
print("fault %lux %lux %d\n", ur->pc, addr, read);
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1991/0711/sys/src/9/ss/faultsparc.c:25,31 – 1991/0712/sys/src/9/ss/faultsparc.c:25,30 (short | long)
1990/1231    
			read = 0;
1990/1226    
	} 
	spllo();
1991/0711    
print("fault %lux %lux %d\n", ur->pc, addr, read);
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1991/0712/sys/src/9/ss/faultsparc.c:10,15 – 1991/0717/sys/src/9/ss/faultsparc.c:10,16 (short | long)
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{ 
	ulong addr, badvaddr;
1991/0717    
	char buf[ERRLEN];
1991/01151    
	int user, read;
1990/1226    
	ulong tbr;
1990/1223    
1991/0712/sys/src/9/ss/faultsparc.c:36,44 – 1991/0717/sys/src/9/ss/faultsparc.c:37,47
1990/1223    
 
	if(fault(addr, read) < 0){ 
		if(user){ 
			pprint("user %s error addr=0x%lux\n", read? "read" : "write", badvaddr);
1990/1226    
			pprint("psr=0x%lux pc=0x%lux sp=0x%lux\n", ur->psr, ur->pc, ur->sp);
1990/1223    
			pexit("Suicide", 0);
1991/0717    
			sprint(buf, "sys: fault %s pc=0x%lux addr=0x%lux", 
				read? "read" : "write", ur->pc, badvaddr); 
			postnote(u->p, 1, buf, NDebug); 
			notify(ur); 
			return;
1990/1223    
		} 
		u->p->state = MMUing; 
		dumpregs(ur);
1991/0717/sys/src/9/ss/faultsparc.c:43,49 – 1991/0926/sys/src/9/ss/faultsparc.c:43,48 (short | long)
1991/0717    
			notify(ur); 
			return;
1990/1223    
		} 
		u->p->state = MMUing; 
		dumpregs(ur); 
		panic("fault: 0x%lux", badvaddr); 
		exit();
1991/0926/sys/src/9/ss/faultsparc.c:40,46 – 1991/1108/sys/src/9/ss/faultsparc.c:40,45 (short | long)
1991/0717    
			sprint(buf, "sys: fault %s pc=0x%lux addr=0x%lux", 
				read? "read" : "write", ur->pc, badvaddr); 
			postnote(u->p, 1, buf, NDebug); 
			notify(ur); 
			return;
1990/1223    
		} 
		dumpregs(ur);
1991/1108/sys/src/9/ss/faultsparc.c:37,44 – 1991/1218/sys/src/9/ss/faultsparc.c:37,44 (short | long)
1990/1223    
 
	if(fault(addr, read) < 0){ 
		if(user){
1991/0717    
			sprint(buf, "sys: fault %s pc=0x%lux addr=0x%lux", 
				read? "read" : "write", ur->pc, badvaddr);
1991/1218    
			sprint(buf, "sys: trap: fault %s addr=0x%lux", 
				read? "read" : "write", badvaddr);
1991/0717    
			postnote(u->p, 1, buf, NDebug); 
			return;
1990/1223    
		}
1991/1218/sys/src/9/ss/faultsparc.c:4,10 – 1992/0111/sys/src/9/ss/faultsparc.c:4,10 (short | long)
1990/1223    
#include	"dat.h" 
#include	"fns.h" 
#include	"ureg.h" 
#include	"errno.h"
1992/0111    
#include	"../port/error.h"
1990/1223    
 
void
1990/1226    
faultsparc(Ureg *ur)
1992/0111/sys/src/9/ss/faultsparc.c:1,5 – 1992/0321/sys/src/9/ss/faultsparc.c:1,5 (short | long)
1990/1223    
#include	"u.h" 
#include	"lib.h"
1992/0321    
#include	"../port/lib.h"
1990/1223    
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h"
1992/0321/sys/src/9/ss/faultsparc.c:6,11 – 1992/0704/sys/src/9/ss/faultsparc.c:6,18 (short | long)
1990/1223    
#include	"ureg.h"
1992/0111    
#include	"../port/error.h"
1990/1223    
1992/0704    
enum 
{ 
	SE_WRITE	= 0x8000, 
	SE_INV		= 0x0080, 
	SE_PROT		= 0x0040, 
};
1990/1223    
void
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{
1992/0321/sys/src/9/ss/faultsparc.c:12,18 – 1992/0704/sys/src/9/ss/faultsparc.c:19,25
1990/1223    
	ulong addr, badvaddr;
1991/0717    
	char buf[ERRLEN];
1991/01151    
	int user, read;
1990/1226    
	ulong tbr;
1992/0704    
	ulong tbr, ser;
1990/1223    
1990/1227    
	tbr = (ur->tbr&0xFFF)>>4;
1990/1226    
	addr = ur->pc;			/* assume instr. exception */
1992/0321/sys/src/9/ss/faultsparc.c:22,28 – 1992/0704/sys/src/9/ss/faultsparc.c:29,36
1990/1231    
		 * According to the book, this isn't good enough.  We'll see. 
		 */
1990/1226    
		addr = getw2(SEVAR);
1990/1231    
		if(getw2(SER) & 0x8000)
1992/0704    
		ser = getw2(SER); 
		if(ser&(SE_WRITE|SE_PROT))
1990/1231    
			read = 0;
1990/1226    
	} 
	spllo();
1992/0704/sys/src/9/ss/faultsparc.c:28,35 – 1992/0806/sys/src/9/ss/faultsparc.c:28,35 (short | long)
1990/1231    
		/* 
		 * According to the book, this isn't good enough.  We'll see. 
		 */
1990/1226    
		addr = getw2(SEVAR);
1992/0704    
		ser = getw2(SER);
1992/0806    
		addr = getsysspace(SEVAR); 
		ser = getsysspace(SER);
1992/0704    
		if(ser&(SE_WRITE|SE_PROT))
1990/1231    
			read = 0;
1990/1226    
	}
1992/0704/sys/src/9/ss/faultsparc.c:62,68 – 1992/0806/sys/src/9/ss/faultsparc.c:62,68
1991/0110    
{ 
	int user; 
 
	print("interrupt 15 ASER %lux ASEVAR %lux SER %lux\n", getw2(ASER), getw2(ASEVAR), getw2(SER));
1992/0806    
	print("interrupt 15 ASER %lux ASEVAR %lux SER %lux\n", getsysspace(ASER), getsysspace(ASEVAR), getsysspace(SER));
1991/0110    
	dumpregs(ur); 
	/* 
	 * Clear interrupt by toggling low bit of interrupt register
1992/0806/sys/src/9/ss/faultsparc.c:52,58 – 1992/0812/sys/src/9/ss/faultsparc.c:52,57 (short | long)
1990/1223    
		} 
		dumpregs(ur); 
		panic("fault: 0x%lux", badvaddr); 
		exit(); 
	}
1991/01151    
	splhi();
1991/0110    
}
1992/0812/sys/src/9/ss/faultsparc.c:38,43 – 1992/0813/sys/src/9/ss/faultsparc.c:38,44 (short | long)
1990/1223    
		dumpregs(ur);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1990/1223    
	}
1992/0813    
1990/1226    
/*	addr &= VAMASK; /**/
1990/1223    
	badvaddr = addr; 
	addr &= ~(BY2PG-1);
1992/0813/sys/src/9/ss/faultsparc.c:33,38 – 1992/0911/sys/src/9/ss/faultsparc.c:33,40 (short | long)
1992/0704    
		if(ser&(SE_WRITE|SE_PROT))
1990/1231    
			read = 0;
1990/1226    
	}
1992/0911    
if(u && strcmp(u->p->text, "rc") == 0) 
print("fault pc=%lux addr=%lux %d\n", ur->pc, addr, read);/**/
1990/1226    
	spllo();
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1992/0911/sys/src/9/ss/faultsparc.c:33,39 – 1992/0912/sys/src/9/ss/faultsparc.c:33,39 (short | long)
1992/0704    
		if(ser&(SE_WRITE|SE_PROT))
1990/1231    
			read = 0;
1990/1226    
	}
1992/0911    
if(u && strcmp(u->p->text, "rc") == 0)
1992/0912    
/*if(u && strcmp(u->p->text, "rc") == 0)
1992/0911    
print("fault pc=%lux addr=%lux %d\n", ur->pc, addr, read);/**/
1990/1226    
	spllo();
1990/1223    
	if(u == 0){
1992/0912/sys/src/9/ss/faultsparc.c:33,40 – 1992/0913/sys/src/9/ss/faultsparc.c:33,39 (short | long)
1992/0704    
		if(ser&(SE_WRITE|SE_PROT))
1990/1231    
			read = 0;
1990/1226    
	}
1992/0912    
/*if(u && strcmp(u->p->text, "rc") == 0)
1992/0911    
print("fault pc=%lux addr=%lux %d\n", ur->pc, addr, read);/**/
1992/0913    
1990/1226    
	spllo();
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1992/0912/sys/src/9/ss/faultsparc.c:41,47 – 1992/0913/sys/src/9/ss/faultsparc.c:40,45
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1990/1223    
	}
1992/0813    
1990/1226    
/*	addr &= VAMASK; /**/
1990/1223    
	badvaddr = addr; 
	addr &= ~(BY2PG-1);
1990/1231    
	user = !(ur->psr&PSRPSUPER);
1992/0913/sys/src/9/ss/faultsparc.c:1,88 – 1993/0501/sys/src/9/ss/faultsparc.c:0 (short | long)
Deleted.
rsc Mon Mar 7 10:33:12 2005
1990/1223    
#include	"u.h"
1992/0321    
#include	"../port/lib.h"
1990/1223    
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
#include	"ureg.h"
1992/0111    
#include	"../port/error.h"
1990/1223    
                 
1992/0704    
enum 
{ 
	SE_WRITE	= 0x8000, 
	SE_INV		= 0x0080, 
	SE_PROT		= 0x0040, 
}; 
                 
1990/1223    
void
1990/1226    
faultsparc(Ureg *ur)
1990/1223    
{ 
	ulong addr, badvaddr;
1991/0717    
	char buf[ERRLEN];
1991/01151    
	int user, read;
1992/0704    
	ulong tbr, ser;
1990/1223    
                 
1990/1227    
	tbr = (ur->tbr&0xFFF)>>4;
1990/1226    
	addr = ur->pc;			/* assume instr. exception */
1990/1231    
	read = 1; 
	if(tbr == 9){			/* data access exception */ 
		/* 
		 * According to the book, this isn't good enough.  We'll see. 
		 */
1992/0806    
		addr = getsysspace(SEVAR); 
		ser = getsysspace(SER);
1992/0704    
		if(ser&(SE_WRITE|SE_PROT))
1990/1231    
			read = 0;
1990/1226    
	}
1992/0913    
                 
1990/1226    
	spllo();
1990/1223    
	if(u == 0){ 
		dumpregs(ur);
1991/01151    
		panic("fault u==0 pc=%lux addr=%lux", ur->pc, addr);
1990/1223    
	}
1992/0813    
                 
1990/1223    
	badvaddr = addr; 
	addr &= ~(BY2PG-1);
1990/1231    
	user = !(ur->psr&PSRPSUPER);
1990/1223    
                 
	if(fault(addr, read) < 0){ 
		if(user){
1991/1218    
			sprint(buf, "sys: trap: fault %s addr=0x%lux", 
				read? "read" : "write", badvaddr);
1991/0717    
			postnote(u->p, 1, buf, NDebug); 
			return;
1990/1223    
		} 
		dumpregs(ur); 
		panic("fault: 0x%lux", badvaddr); 
	}
1991/01151    
	splhi();
1991/0110    
} 
                 
void 
faultasync(Ureg *ur) 
{ 
	int user; 
                 
1992/0806    
	print("interrupt 15 ASER %lux ASEVAR %lux SER %lux\n", getsysspace(ASER), getsysspace(ASEVAR), getsysspace(SER));
1991/0110    
	dumpregs(ur); 
	/* 
	 * Clear interrupt by toggling low bit of interrupt register 
	 */ 
	*intrreg &= ~1; 
	*intrreg |= 1; 
	user = !(ur->psr&PSRPSUPER); 
	if(user) 
		pexit("Suicide", 0); 
	panic("interrupt 15");
1990/1226    
} 
                 
/* 
 * called in sysfile.c 
 */ 
void 
evenaddr(ulong addr) 
{ 
	if(addr & 3){ 
		postnote(u->p, 1, "sys: odd address", NDebug); 
		error(Ebadarg); 
	}
1990/1223    
}


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