![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sun3|
Return to trap.c CVS log | Up to [Research Unix] / researchv9 / sys / sun3 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)trap.c 1.1 86/02/03 Copyr 1985 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1985 by Sun Microsystems, Inc.
7: */
8:
9: #include "../h/param.h"
10: #include "../h/systm.h"
11: #include "../h/dir.h"
12: #include "../h/user.h"
13: #include "../h/lnode.h"
14: #include "../h/proc.h"
15: #include "../h/seg.h"
16: #include "../h/vm.h"
17: #include "../h/share.h"
18:
19: #include "../machine/fault.h"
20: #include "../machine/frame.h"
21: #include "../machine/buserr.h"
22: #include "../machine/memerr.h"
23: #include "../machine/mmu.h"
24: #include "../machine/cpu.h"
25: #include "../machine/psl.h"
26: #include "../machine/pte.h"
27: #include "../machine/reg.h"
28: #include "../machine/trap.h"
29:
30:
31: #define USER 0x400 /* user-mode flag added to type */
32:
33: struct sysent sysent[128];
34: int syscnt[128];
35:
36: char *trap_type[] = {
37: "Vector address 0x0",
38: "Vector address 0x4",
39: "Bus error",
40: "Address error",
41: "Illegal instruction",
42: "Divide by zero",
43: "CHK, CHK2 instruction",
44: "TRAPV, cpTRAPcc, cpTRAPcc instruction",
45: "Priviledge violation",
46: "Trace",
47: "1010 emulator trap",
48: "1111 emulator trap",
49: "Vector address 0x30",
50: "Coprocessor protocol error",
51: "Stack format error",
52: "Unitialized interrupt",
53: "Vector address 0x40",
54: "Vector address 0x44",
55: "Vector address 0x48",
56: "Vector address 0x4c",
57: "Vector address 0x50",
58: "Vector address 0x54",
59: "Vector address 0x58",
60: "Vector address 0x5c",
61: "Spurious interrupt",
62: };
63: #define TRAP_TYPES (sizeof trap_type / sizeof trap_type[0])
64:
65: #if defined(DEBUG) || defined(lint)
66: int tdebug = 0;
67: int tudebug = 0;
68: int lodebug = 0;
69: int bedebug = 0;
70: #else
71: #define tdebug 0
72: #define tudebug 0
73: #define lodebug 0
74: #define bedebug 0
75: #endif defined(DEBUG) || defined(lint)
76:
77: u_char getsegmap();
78: long getpgmap();
79:
80: /*
81: * Called from the trap handler when a processor trap occurs.
82: * Returns amount to adjust the stack: > 0 removes bus error
83: * info, == 0 does nothing.
84: */
85: int
86: trap(type, regs, fmt)
87: int type;
88: struct regs regs;
89: struct stkfmt fmt;
90: {
91: register struct regs *locregs = ®s;
92: register int i = 0;
93: register struct proc *p = u.u_procp;
94: time_t syst;
95: int nosig = 0;
96: int besize = 0;
97: int be = (type == T_BUSERR)? getbuserr() : 0;
98:
99: cnt.v_trap++;
100: syst = u.u_vm.vm_stime;
101: if (tdebug) {
102: i = type/sizeof (int);
103: if ((unsigned)i < TRAP_TYPES)
104: printf("trap: %s\n", trap_type[i]);
105: showregs("trap", type, locregs, &fmt, be);
106: }
107: if (USERMODE(locregs->r_sr)) {
108: type |= USER;
109: u.u_ar0 = &locregs->r_dreg[0];
110: }
111:
112: switch (type) {
113:
114: default:
115: die:
116: (void) spl7();
117: showregs((char *)0, fmt.f_vector, locregs, &fmt, be);
118: traceback((long)locregs->r_areg[6], (long)locregs->r_sp);
119: i = fmt.f_vector/sizeof (int);
120: if (i < TRAP_TYPES)
121: panic(trap_type[i]);
122: panic("trap");
123: /*NOTREACHED*/
124:
125: case T_BUSERR:
126: if (be & BE_TIMEOUT)
127: DELAY(2000); /* allow for refresh recovery time */
128:
129: /* may have been expected by C (e.g., Multibus probe) */
130: if (nofault) {
131: label_t *ftmp;
132:
133: ftmp = nofault;
134: nofault = 0;
135: longjmp(ftmp);
136: }
137: /* may be fault caused by transfer to/from user space */
138: if (u.u_lofault == 0)
139: goto die;
140:
141: switch (fmt.f_stkfmt) {
142: case SF_MEDIUM: {
143: struct bei_medium *beip =
144: (struct bei_medium *)&fmt.f_beibase;
145:
146: besize = sizeof (struct bei_medium);
147: if (beip->bei_faultc || beip->bei_faultb)
148: break;
149: if (beip->bei_dfault && pagefault(beip->bei_fault))
150: return (0);
151: break;
152: }
153: case SF_LONGB: {
154: struct bei_longb *beip =
155: (struct bei_longb *)&fmt.f_beibase;
156:
157: besize = sizeof (struct bei_longb);
158: if (beip->bei_faultc || beip->bei_faultb)
159: break;
160: if (beip->bei_dfault && pagefault(beip->bei_fault))
161: return (0);
162: break;
163: }
164: default:
165: panic("bad bus error stack format");
166: }
167:
168: if (lodebug) {
169: showregs("lofault", type, locregs, &fmt, be);
170: traceback((long)locregs->r_areg[6],
171: (long)locregs->r_sp);
172: }
173: locregs->r_pc = u.u_lofault;
174: return (besize);
175:
176: case T_ADDRERR: /* address error */
177: /* may be fault caused by transfer to/from user space */
178: if (u.u_lofault == 0)
179: goto die;
180: switch (fmt.f_stkfmt) {
181: case SF_MEDIUM: {
182: struct bei_medium *beip =
183: (struct bei_medium *)&fmt.f_beibase;
184:
185: if (beip->bei_fcode != FC_UD)
186: goto die;
187: besize = sizeof (struct bei_medium);
188: break;
189: }
190: case SF_LONGB: {
191: struct bei_longb *beip =
192: (struct bei_longb *)&fmt.f_beibase;
193:
194: if (beip->bei_fcode != FC_UD)
195: goto die;
196: besize = sizeof (struct bei_longb);
197: break;
198: }
199: default:
200: panic("bad address error stack format");
201: }
202: if (lodebug) {
203: showregs("lofault", type, locregs, &fmt, be);
204: traceback((long)locregs->r_areg[6],
205: (long)locregs->r_sp);
206: }
207: locregs->r_pc = u.u_lofault;
208: return (besize);
209:
210: case T_ADDRERR + USER: /* user address error */
211: if (tudebug)
212: showregs("USER ADDRESS ERROR", type, locregs, &fmt, be);
213: i = SIGBUS;
214: switch (fmt.f_stkfmt) {
215: case SF_MEDIUM:
216: besize = sizeof (struct bei_medium);
217: break;
218: case SF_LONGB:
219: besize = sizeof (struct bei_longb);
220: break;
221: default:
222: panic("bad address error stack format");
223: }
224: break;
225:
226: case T_SPURIOUS:
227: case T_SPURIOUS + USER: /* spurious interrupt */
228: i = spl7();
229: printf("spurious level %d interrupt\n", (i & SR_INTPRI) >> 8);
230: (void) splx(i);
231: return (0);
232:
233: case T_PRIVVIO + USER: /* privileged instruction fault */
234: if (tudebug)
235: showregs("USER PRIVILEGED INSTRUCTION", type, locregs,
236: &fmt, be);
237: u.u_code = fmt.f_vector;
238: i = SIGILL;
239: break;
240:
241: case T_COPROCERR + USER: /* coprocessor protocol error */
242: /*
243: * Dump out obnoxious info to warn user
244: * that something isn't right w/ the 68881
245: */
246: showregs("USER COPROCESSOR PROTOCOL ERROR", type, locregs,
247: &fmt, be);
248: u.u_code = fmt.f_vector;
249: i = SIGILL;
250: break;
251:
252: case T_M_BADTRAP + USER: /* (some) undefined trap */
253: case T_ILLINST + USER: /* illegal instruction fault */
254: if (tudebug)
255: showregs("USER ILLEGAL INSTRUCTION", type, locregs,
256: &fmt, be);
257: u.u_code = fmt.f_vector;
258: i = SIGILL;
259: break;
260:
261: case T_M_FLOATERR + USER: /* (some) floating error trap */
262: case T_ZERODIV + USER: /* divide by zero */
263: case T_CHKINST + USER: /* CHK [CHK2] instruction */
264: case T_TRAPV + USER: /* TRAPV [cpTRAPcc TRAPcc] instr */
265: u.u_code = fmt.f_vector;
266: i = SIGFPE;
267: break;
268:
269: /*
270: * If the user SP is above the stack segment,
271: * grow the stack automatically.
272: */
273: case T_BUSERR + USER: {
274:
275: if (be & BE_TIMEOUT)
276: DELAY(2000); /* allow for refresh recovery time */
277:
278: switch (fmt.f_stkfmt) {
279: case SF_MEDIUM: {
280: struct bei_medium *beip =
281: (struct bei_medium *)&fmt.f_beibase;
282:
283: besize = sizeof (struct bei_medium);
284: /*
285: * check for any errors in buserr
286: * register besides invalid
287: */
288: if (be & ~BE_INVALID)
289: goto pferr;
290: if ((bedebug && (beip->bei_faultb || beip->bei_faultc))
291: || (bedebug > 1 && beip->bei_fault))
292: printf("medium fault b %d %x, c %d %x, d %d %x\n",
293: beip->bei_faultb, locregs->r_pc+4,
294: beip->bei_faultc, locregs->r_pc+2,
295: beip->bei_dfault, beip->bei_fault);
296:
297: if (beip->bei_dfault && ((beip->bei_fcode == FC_UD)
298: || (beip->bei_fcode == FC_UP))) {
299: if (pagefault(beip->bei_fault))
300: return (0);
301: if (grow((unsigned)beip->bei_fault)) {
302: nosig = 1;
303: besize = 0;
304: goto out;
305: }
306: goto pferr;
307: }
308: if (beip->bei_faultc) {
309: if (pagefault(locregs->r_pc+2))
310: return (0);
311: goto pferr;
312: }
313: if (beip->bei_faultb) {
314: if (pagefault(locregs->r_pc+4))
315: return (0);
316: goto pferr;
317: }
318: goto pferr;
319: }
320: case SF_LONGB: {
321: struct bei_longb *beip =
322: (struct bei_longb *)&fmt.f_beibase;
323:
324: besize = sizeof (struct bei_longb);
325: /*
326: * check for any errors in buserr
327: * register besides invalid
328: */
329: if (be & ~BE_INVALID)
330: goto pferr;
331: if ((bedebug && (beip->bei_faultb || beip->bei_faultc))
332: || (bedebug > 1 && beip->bei_fault))
333: printf("long fault b %d %x, c %d %x, d %d %x\n",
334: beip->bei_faultb, beip->bei_stageb,
335: beip->bei_faultc, beip->bei_stageb-2,
336: beip->bei_dfault, beip->bei_fault);
337:
338: if (beip->bei_dfault && ((beip->bei_fcode == FC_UD)
339: || (beip->bei_fcode == FC_UP))) {
340: if (pagefault(beip->bei_fault))
341: return (0);
342: if (grow((unsigned)beip->bei_fault)) {
343: nosig = 1;
344: besize = 0;
345: goto out;
346: }
347: goto pferr;
348: }
349: if (beip->bei_faultc) {
350: if (pagefault(beip->bei_stageb-2))
351: return (0);
352: goto pferr;
353: }
354: if (beip->bei_faultb) {
355: if (pagefault(beip->bei_stageb))
356: return (0);
357: goto pferr;
358: }
359: goto pferr;
360: }
361: default:
362: panic("bad bus error stack format");
363: }
364: pferr:
365: if (tudebug)
366: showregs("USER BUS ERROR", type, locregs, &fmt, be);
367: i = SIGSEGV;
368: if (besize == 0)
369: panic("besize");
370: break;
371: }
372:
373: case T_TRACE: /* caused by tracing trap instr */
374: u.u_pcb.pcb_p0lr |= TRACE_PENDING;
375: return (0);
376:
377: case T_TRACE + USER: /* trace trap */
378: dotrace(locregs);
379: goto out;
380:
381: case T_BRKPT + USER: /* bpt instruction (trap #15) fault */
1.1.1.2 ! root 382: locregs->r_pc = locregs->r_pc - 2;
1.1 root 383: u.u_code = TRAP_BKPT;
384: i = SIGTRAP;
385: break;
386:
387: case T_EMU1010 + USER: /* 1010 emulator trap */
388: case T_EMU1111 + USER: /* 1111 emulator trap */
389: u.u_code = fmt.f_vector;
390: i = SIGEMT;
391: break;
392: }
393:
394: psignal(u.u_procp, i);
395: out:
396: if (u.u_pcb.pcb_p0lr & TRACE_PENDING)
397: dotrace(locregs);
398: p = u.u_procp;
399: if (p->p_cursig || (p->p_sig && issig(p)))
400: psig();
401: p->p_pri = p->p_usrpri;
402: if (runrun) {
403: /*
404: * Since we are u.u_procp, clock will normally just change
405: * our priority without moving us from one queue to another
406: * (since the running process is not on a queue.)
407: * If that happened after we setrq ourselves but before we
408: * swtch()'ed, we might not be on the queue indicated by
409: * our priority.
410: */
411: (void) spl6();
412: setrq(p);
413: swtch();
414: (void) spl0();
415: }
416: if (u.u_prof.pr_scale && (syst -= u.u_vm.vm_stime))
417: addupc(locregs->r_pc, &u.u_prof, (int)-syst);
418: curpri = p->p_pri;
419: return (besize);
420: }
421:
422: /*
423: * Called from the trap handler when a system call occurs
424: */
425: long syscount[0200]; /* temp */
426: syscall(code, regs)
427: int code;
428: struct regs regs;
429: {
430: time_t syst;
431: caddr_t params;
432: int i;
433:
434: syst = u.u_vm.vm_stime;
435: if (!USERMODE(regs.r_sr))
436: panic("syscall");
437: {
438: /*
439: * At this point we declare a number of register variables.
440: * syscall_setjmp (called below) does not preserve the values
441: * of register variables, so we limit their scope to this block.
442: */
443: register struct regs *locregs;
444: register struct sysent *callp;
445: register struct proc *p;
446:
447: p = u.u_procp;
448: p->p_lnode->kl_cost += shconsts.sc_syscall;
449: shconsts.sc_syscallc++;
450: syscount[code&0177]++;
451: locregs = ®s;
452: u.u_ar0 = &locregs->r_dreg[0];
453: params = (caddr_t)locregs->r_sp + 2 * NBPW;
454: u.u_error = 0;
455: callp = &sysent[code&0177];
456: if (callp == sysent) {
457: i = fuword(params);
458: params += NBPW;
459: callp = &sysent[i&0177];
460: }
461: if (callp->sy_narg) {
462: if (fulwds((caddr_t)params, (caddr_t)u.u_arg,
463: callp->sy_narg)) {
464: u.u_error = EFAULT;
465: goto bad;
466: }
467: }
468: u.u_ap = u.u_arg;
469: u.u_dirp = (caddr_t)u.u_arg[0];
470: u.u_r.r_val1 = 0;
471: u.u_r.r_val2 = regs.r_dreg[1];
472: syscnt[callp - sysent]++;
473: /*
474: * Syscall_setjmp is a special setjmp that only saves a6 and sp.
475: * The result is a significant speedup of this critical path,
476: * but meanwhile all the register variables have the wrong
477: * values after a longjmp returns here.
478: * This is the reason for the limited scope of the register
479: * variables in this routine - the values may go away here.
480: */
481: if (syscall_setjmp(u.u_qsav)) {
482: if (u.u_error == 0 && u.u_eosys == JUSTRETURN)
483: u.u_error = EINTR;
484: } else {
485: u.u_eosys = JUSTRETURN;
486: (*(callp->sy_call))(u.u_ap);
487: }
488: /* end of scope of register variables above */
489: }
490: if (u.u_eosys != JUSTRETURN) {
491: if (u.u_eosys == RESTARTSYS)
492: regs.r_pc -= 2;
493: } else {
494: regs.r_sp += sizeof (int); /* pop syscall # */
495: if (u.u_error) {
496: bad:
497: regs.r_dreg[0] = u.u_error;
498: regs.r_sr |= SR_CC; /* carry bit */
499: } else {
500: regs.r_sr &= ~SR_CC;
501: regs.r_dreg[0] = u.u_r.r_val1;
502: regs.r_dreg[1] = u.u_r.r_val2;
503: }
504: }
505: if (u.u_pcb.pcb_p0lr & TRACE_PENDING)
506: dotrace(®s);
507: {
508: /* scope for use of register variable p */
509: register struct proc *p;
510:
511: p = u.u_procp;
512: if (p->p_cursig || (p->p_sig && issig(p)))
513: psig();
514: p->p_pri = p->p_usrpri;
515: if (runrun) {
516: /*
517: * Since we are u.u_procp, clock will normally just change
518: * our priority without moving us from one queue to another
519: * (since the running process is not on a queue.)
520: * If that happened after we setrq ourselves but before we
521: * swtch()'ed, we might not be on the queue indicated by
522: * our priority.
523: */
524: (void) spl6();
525: setrq(p);
526: swtch();
527: (void) spl0();
528: }
529: if (u.u_prof.pr_scale && (syst -= u.u_vm.vm_stime))
530: addupc(regs.r_pc, &u.u_prof, (int)-syst);
531: curpri = p->p_pri;
532: }
533: }
534:
535: /*
536: * nonexistent system call-- set fatal error code.
537: */
538: nosys()
539: {
540:
541: u.u_error = 100;
542: }
543:
544: /*
545: * Ignored system call
546: */
547: nullsys()
548: {
549:
550: }
551:
552: /*
553: * Handle trace traps, both real and delayed.
554: */
555: dotrace(locregs)
556: struct regs *locregs;
557: {
558: register int r, s;
559: struct proc *p = u.u_procp;
560:
561: s = spl6();
562: r = u.u_pcb.pcb_p0lr&AST_CLR;
563: u.u_pcb.pcb_p0lr &= ~AST_CLR;
564: u.u_ar0[PS] &= ~PSL_T;
565: (void) splx(s);
566: if (r & TRACE_AST) {
567: if ((p->p_flag&SOWEUPC) && u.u_prof.pr_scale) {
568: addupc(locregs->r_pc, &u.u_prof, 1);
569: p->p_flag &= ~SOWEUPC;
570: }
571: if ((r & TRACE_USER) == 0)
572: return;
573: }
574: u.u_code = TRAP_TRACE;
575: psignal(p, SIGTRAP);
576: }
577:
578: /*
579: * Print out a traceback for kernel traps
580: */
581: traceback(afp, sp)
582: long afp, sp;
583: {
584: struct frame *tospage = (struct frame *)btoc(sp);
585: struct frame *fp = (struct frame *)afp;
586: static int done = 0;
587:
588: if (panicstr && done++ > 0)
589: return;
590:
591: printf("Begin traceback...fp = %x, sp = %x\n", fp, sp);
592: while (btoc(((int)fp)) == (int)tospage) {
593: if (fp == fp->fr_savfp) {
594: printf("FP loop at %x", fp);
595: break;
596: }
597: printf("Called from %x, fp=%x, args=%x %x %x %x\n",
598: fp->fr_savpc, fp->fr_savfp,
599: fp->fr_arg[0], fp->fr_arg[1], fp->fr_arg[2], fp->fr_arg[3]);
600: fp = fp->fr_savfp;
601: }
602: printf("End traceback...\n");
603: DELAY(2000000);
604: }
605:
606: showregs(str, type, locregs, fmtp, be)
607: char *str;
608: int type;
609: struct regs *locregs;
610: struct stkfmt *fmtp;
611: {
612: int *r, s;
613: int fcode, accaddr;
614: char *why;
615:
616: s = spl7();
617: printf("%s: %s\n", u.u_comm, str ? str : "");
618: printf(
619: "trap address 0x%x, pid %d, pc = %x, sr = %x, stkfmt %x, context %x\n",
620: fmtp->f_vector, u.u_procp->p_pid, locregs->r_pc, locregs->r_sr,
621: fmtp->f_stkfmt, getcontext());
622: type &= ~USER;
623: if (type == T_BUSERR)
624: printf("Bus Error Reg %b\n", be, BUSERR_BITS);
625: if (type == T_BUSERR || type == T_ADDRERR) {
626: switch (fmtp->f_stkfmt) {
627: case SF_MEDIUM: {
628: struct bei_medium *beip =
629: (struct bei_medium *)&fmtp->f_beibase;
630:
631: fcode = beip->bei_fcode;
632: if (beip->bei_dfault) {
633: why = "data";
634: accaddr = beip->bei_fault;
635: } else if (beip->bei_faultc) {
636: why = "stage c";
637: accaddr = locregs->r_pc+2;
638: } else if (beip->bei_faultb) {
639: why = "stage b";
640: accaddr = locregs->r_pc+4;
641: } else {
642: why = "unknown";
643: accaddr = 0;
644: }
645: printf("%s fault address %x faultc %d faultb %d ",
646: why, accaddr, beip->bei_faultc, beip->bei_faultb);
647: printf("dfault %d rw %d size %d fcode %d\n",
648: beip->bei_dfault, beip->bei_rw,
649: beip->bei_size, fcode);
650: break;
651: }
652: case SF_LONGB: {
653: struct bei_longb *beip =
654: (struct bei_longb *)&fmtp->f_beibase;
655:
656: fcode = beip->bei_fcode;
657: if (beip->bei_dfault) {
658: why = "data";
659: accaddr = beip->bei_fault;
660: } else if (beip->bei_faultc) {
661: why = "stage c";
662: accaddr = beip->bei_stageb-2;
663: } else if (beip->bei_faultb) {
664: why = "stage b";
665: accaddr = beip->bei_stageb;
666: } else {
667: why = "unknown";
668: accaddr = 0;
669: }
670: printf("%s fault address %x faultc %d faultb %d ",
671: why, accaddr, beip->bei_faultc, beip->bei_faultb);
672: printf("dfault %d rw %d size %d fcode %d\n",
673: beip->bei_dfault, beip->bei_rw,
674: beip->bei_size, fcode);
675: break;
676: }
677: default:
678: panic("bad bus error stack format");
679: }
680: if (fcode == FC_SD || fcode == FC_SP) {
681: printf("KERNEL MODE\n");
682: printf("page map %x\n", getpgmap((caddr_t)accaddr));
683: } else {
684: int tss, dss, sss, v;
685: struct pmeg *pmp;
686: struct proc *p = u.u_procp;
687: struct pte *pte;
688:
689: v = btop(accaddr);
690: tss = tptov(p, 0);
691: dss = dptov(p, 0);
692: sss = sptov(p, p->p_ssize - 1);
693: if (v >= tss && v < tss + p->p_tsize ||
694: v >= dss && v < dss + p->p_dsize ||
695: v >= sss && v < sss + p->p_ssize) {
696: pmp = &pmeg[p->p_ctx->ctx_pmeg[v/NPAGSEG]];
697: pte = vtopte(p, (unsigned)v);
698: printf("pagefault, pmp %x, pte %x %x\n",
699: pmp, pte, *pte);
700: printf("pme %x\n", getpgmap((caddr_t)accaddr));
701: } else {
702: printf("bad addr, v %d tss %d dss %d sss %d\n",
703: v, tss, dss, sss);
704: }
705: }
706: }
707: r = &locregs->r_dreg[0];
708: printf("D0-D7 %x %x %x %x %x %x %x %x\n",
709: r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7]);
710: r = &locregs->r_areg[0];
711: printf("A0-A7 %x %x %x %x %x %x %x %x\n",
712: r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7]);
713: DELAY(2000000);
714: (void) splx(s);
715: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.