![[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 [Plan 9 NeXT] / lucent / sys / src / 9 / pc|
Return to trap.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "io.h"
7: #include "ureg.h"
8: #include "../port/error.h"
9:
10: void noted(Ureg*, ulong);
11:
12: void intr0(void), intr1(void), intr2(void), intr3(void);
13: void intr4(void), intr5(void), intr6(void), intr7(void);
14: void intr8(void), intr9(void), intr10(void), intr11(void);
15: void intr12(void), intr13(void), intr14(void), intr15(void);
16: void intr16(void);
17: void intr24(void), intr25(void), intr26(void), intr27(void);
18: void intr28(void), intr29(void), intr30(void), intr31(void);
19: void intr32(void), intr33(void), intr34(void), intr35(void);
20: void intr36(void), intr37(void), intr38(void), intr39(void);
21: void intr64(void);
22: void intrbad(void);
23:
24: int int0mask = 0xff; /* interrupts enabled for first 8259 */
25: int int1mask = 0xff; /* interrupts enabled for second 8259 */
26:
27: /*
28: * trap/interrupt gates
29: */
30: Segdesc ilt[256];
31: int badintr[16];
32:
33: enum
34: {
35: Maxhandler= 128, /* max number of interrupt handlers */
36: };
37:
38: typedef struct Handler Handler;
39: struct Handler
40: {
41: void (*r)(void*, void*);
42: void *arg;
43: Handler *next;
44: };
45:
46: struct
47: {
48: Lock;
49: Handler *ivec[256];
50: Handler h[Maxhandler];
51: int free;
52: } halloc;
53:
54: void
55: sethvec(int v, void (*r)(void), int type, int pri)
56: {
57: ilt[v].d0 = ((ulong)r)&0xFFFF|(KESEL<<16);
58: ilt[v].d1 = ((ulong)r)&0xFFFF0000|SEGP|SEGPL(pri)|type;
59: }
60:
61: void
62: setvec(int v, void (*r)(Ureg*, void*), void *arg)
63: {
64: Handler *h;
65:
66: lock(&halloc);
67: if(halloc.free >= Maxhandler)
68: panic("out of interrupt handlers");
69: h = &halloc.h[halloc.free++];
70: h->next = halloc.ivec[v];
71: h->r = r;
72: h->arg = arg;
73: halloc.ivec[v] = h;
74: unlock(&halloc);
75:
76: /*
77: * enable corresponding interrupt in 8259
78: */
79: if((v&~0x7) == Int0vec){
80: int0mask &= ~(1<<(v&7));
81: outb(Int0aux, int0mask);
82: } else if((v&~0x7) == Int1vec){
83: int1mask &= ~(1<<(v&7));
84: outb(Int1aux, int1mask);
85: }
86: }
87:
88: void
89: debugbpt(Ureg *ur, void *a)
90: {
91: char buf[ERRLEN];
92:
93: USED(a);
94:
95: if(u == 0)
96: panic("kernel bpt");
97: /* restore pc to instruction that caused the trap */
98: ur->pc--;
99: sprint(buf, "sys: breakpoint");
100: postnote(u->p, 1, buf, NDebug);
101: }
102:
103: /*
104: * set up the interrupt/trap gates
105: */
106: void
107: trapinit(void)
108: {
109: int i;
110:
111: /*
112: * set all interrupts to panics
113: */
114: for(i = 0; i < 256; i++)
115: sethvec(i, intrbad, SEGTG, 0);
116:
117: /*
118: * 80386 processor (and coprocessor) traps
119: */
120: sethvec(0, intr0, SEGTG, 0);
121: sethvec(1, intr1, SEGTG, 0);
122: sethvec(2, intr2, SEGTG, 0);
123: sethvec(4, intr4, SEGTG, 0);
124: sethvec(5, intr5, SEGTG, 0);
125: sethvec(6, intr6, SEGTG, 0);
126: sethvec(7, intr7, SEGTG, 0);
127: sethvec(8, intr8, SEGTG, 0);
128: sethvec(9, intr9, SEGTG, 0);
129: sethvec(10, intr10, SEGTG, 0);
130: sethvec(11, intr11, SEGTG, 0);
131: sethvec(12, intr12, SEGTG, 0);
132: sethvec(13, intr13, SEGTG, 0);
133: sethvec(14, intr14, SEGIG, 0); /* page fault, interrupts off */
134: sethvec(15, intr15, SEGTG, 0);
135: sethvec(16, intr16, SEGIG, 0); /* math coprocessor, interrupts off */
136:
137: /*
138: * device interrupts
139: */
140: sethvec(24, intr24, SEGIG, 0);
141: sethvec(25, intr25, SEGIG, 0);
142: sethvec(26, intr26, SEGIG, 0);
143: sethvec(27, intr27, SEGIG, 0);
144: sethvec(28, intr28, SEGIG, 0);
145: sethvec(29, intr29, SEGIG, 0);
146: sethvec(30, intr30, SEGIG, 0);
147: sethvec(31, intr31, SEGIG, 0);
148: sethvec(32, intr32, SEGIG, 0);
149: sethvec(33, intr33, SEGIG, 0);
150: sethvec(34, intr34, SEGIG, 0);
151: sethvec(35, intr35, SEGIG, 0);
152: sethvec(36, intr36, SEGIG, 0);
153: sethvec(37, intr37, SEGIG, 0);
154: sethvec(38, intr38, SEGIG, 0);
155: sethvec(39, intr39, SEGIG, 0);
156:
157: /*
158: * system calls and break points
159: */
160: sethvec(Syscallvec, intr64, SEGTG, 3);
161: setvec(Syscallvec, (void (*)(Ureg*, void*))syscall, 0);
162: sethvec(Bptvec, intr3, SEGTG, 3);
163: setvec(Bptvec, debugbpt, 0);
164:
165: /*
166: * tell the hardware where the table is (and how long)
167: */
168: putidt(ilt, sizeof(ilt));
169:
170: /*
171: * Set up the first 8259 interrupt processor.
172: * Make 8259 interrupts start at CPU vector Int0vec.
173: * Set the 8259 as master with edge triggered
174: * input with fully nested interrupts.
175: */
176: outb(Int0ctl, (1<<4)|(0<<3)|(1<<0)); /* ICW1 - edge triggered, master,
177: ICW4 will be sent */
178: outb(Int0aux, Int0vec); /* ICW2 - interrupt vector offset */
179: outb(Int0aux, 0x04); /* ICW3 - have slave on level 2 */
180: outb(Int0aux, 0x01); /* ICW4 - 8086 mode, not buffered */
181:
182: /*
183: * Set up the second 8259 interrupt processor.
184: * Make 8259 interrupts start at CPU vector Int0vec.
185: * Set the 8259 as master with edge triggered
186: * input with fully nested interrupts.
187: */
188: outb(Int1ctl, (1<<4)|(0<<3)|(1<<0)); /* ICW1 - edge triggered, master,
189: ICW4 will be sent */
190: outb(Int1aux, Int1vec); /* ICW2 - interrupt vector offset */
191: outb(Int1aux, 0x02); /* ICW3 - I am a slave on level 2 */
192: outb(Int1aux, 0x01); /* ICW4 - 8086 mode, not buffered */
193:
194: /*
195: * pass #2 8259 interrupts to #1
196: */
197: int0mask &= ~0x04;
198: outb(Int0aux, int0mask);
199:
200: /*
201: * Set Ocw3 to return the ISR when ctl read.
202: */
203: outb(Int0ctl, Ocw3|0x03);
204: outb(Int1ctl, Ocw3|0x03);
205: }
206:
207: char *excname[] = {
208: [0] "divide error",
209: [1] "debug exception",
210: [2] " nonmaskable interrupt",
211: [3] "breakpoint",
212: [4] "overflow",
213: [5] "bounds check",
214: [6] "invalid opcode",
215: [7] "coprocessor not available",
216: [8] "double fault",
217: [9] "9 (reserved)",
218: [10] "invalid TSS",
219: [11] "segment not present",
220: [12] "stack exception",
221: [13] "general protection violation",
222: [14] "page fault",
223: [15] "15 (reserved)",
224: [16] "coprocessor error",
225: };
226:
227:
228: /*
229: * All traps
230: */
231: void
232: trap(Ureg *ur)
233: {
234: int v, user;
235: int c;
236: char buf[ERRLEN];
237: Handler *h;
238: static ulong intrtime;
239: static int snoozing;
240: static int iret_traps;
241: ushort isr;
242:
243: v = ur->trap;
244:
245: user = ((ur->cs)&0xffff)!=KESEL && v!=Syscallvec;
246: if(user)
247: u->dbgreg = ur;
248: else if(ur->pc >= KTZERO && ur->pc < (ulong)end && *(uchar*)ur->pc == 0xCF) {
249: if(iret_traps++ > 10)
250: panic("iret trap");
251: return;
252: }
253: iret_traps = 0;
254:
255: /*
256: * tell the 8259 that we're done with the
257: * highest level interrupt (interrupts are still
258: * off at this point)
259: */
260: c = v&~0x7;
261: isr = 0;
262: if(c==Int0vec || c==Int1vec){
263: isr = inb(Int0ctl);
264: outb(Int0ctl, EOI);
265: if(c == Int1vec){
266: isr |= inb(Int1ctl)<<8;
267: outb(Int1ctl, EOI);
268: }
269: }
270:
271: if(v>=256 || (h = halloc.ivec[v]) == 0){
272: /* an old 386 generates these fairly often, no idea why */
273: if(v == 13)
274: return;
275:
276: /* a processor or coprocessor error */
277: if(v <= 16){
278: if(user){
279: sprint(buf, "sys: trap: %s", excname[v]);
280: postnote(u->p, 1, buf, NDebug);
281: return;
282: } else {
283: dumpregs(ur);
284: panic("%s pc=0x%lux", excname[v], ur->pc);
285: }
286: }
287:
288: if(v >= Int0vec && v < Int0vec+16){
289: /* an unknown interrupt */
290: v -= Int0vec;
291: /*
292: * Check for a default IRQ7. This can happen when
293: * the IRQ input goes away before the acknowledge.
294: * In this case, a 'default IRQ7' is generated, but
295: * the corresponding bit in the ISR isn't set.
296: * In fact, just ignore all such interrupts.
297: */
298: if((isr & (1<<v)) == 0)
299: return;
300: if(badintr[v]++ == 0 || (badintr[v]%100000) == 0){
301: print("unknown interrupt %d pc=0x%lux: total %d\n", v,
302: ur->pc, badintr[v]);
303: print("isr = 0x%4.4ux\n", isr);
304: }
305: } else {
306: /* unimplemented traps */
307: print("illegal trap %d pc=0x%lux\n", v, ur->pc);
308: }
309: return;
310: }
311:
312: /* there may be multiple handlers on one interrupt level */
313: do {
314: (*h->r)(ur, h->arg);
315: h = h->next;
316: } while(h);
317: splhi();
318:
319: /* power management */
320: if(v == Clockvec){
321: /* allow power sheding on clock ticks */
322: if(arch->snooze)
323: snoozing = (*arch->snooze)(intrtime, 0);
324: } else {
325: /* turn power back on when anything else happens */
326: if(snoozing && arch->snooze)
327: snoozing = (*arch->snooze)(intrtime, 1);
328: intrtime = m->ticks;
329: }
330:
331: /* check user since syscall does its own notifying */
332: if(user && (u->p->procctl || u->nnote))
333: notify(ur);
334: }
335:
336: /*
337: * dump registers
338: */
339: void
340: dumpregs2(Ureg *ur)
341: {
342: if(u)
343: print("registers for %s %d\n", u->p->text, u->p->pid);
344: else
345: print("registers for kernel\n");
346: print("FLAGS=%lux TRAP=%lux ECODE=%lux CS=%lux PC=%lux", ur->flags, ur->trap,
347: ur->ecode, ur->cs&0xff, ur->pc);
348: if(ur == (Ureg*)UREGADDR)
349: print(" SS=%lux USP=%lux\n", ur->ss&0xff, ur->usp);
350: else
351: print("\n");
352: print(" AX %8.8lux BX %8.8lux CX %8.8lux DX %8.8lux\n",
353: ur->ax, ur->bx, ur->cx, ur->dx);
354: print(" SI %8.8lux DI %8.8lux BP %8.8lux\n",
355: ur->si, ur->di, ur->bp);
356: print(" DS %4.4ux ES %4.4ux FS %4.4ux GS %4.4ux\n",
357: ur->ds&0xffff, ur->es&0xffff, ur->fs&0xffff, ur->gs&0xffff);
358:
359: }
360:
361: void
362: dumpregs(Ureg *ur)
363: {
364: dumpregs2(ur);
365: print(" ur %lux\n", ur);
366: }
367:
368: void
369: dumpstack(void)
370: {
371: ulong l, v, i;
372: extern ulong etext;
373:
374: if(u == 0)
375: return;
376:
377: i = 0;
378: for(l=(ulong)&l; l<USERADDR+BY2PG; l+=4){
379: v = *(ulong*)l;
380: if(KTZERO < v && v < (ulong)&etext){
381: print("%lux ", v);
382: i++;
383: }
384: if(i == 4){
385: i = 0;
386: print("\n");
387: }
388: }
389:
390: }
391:
392: long
393: execregs(ulong entry, ulong ssize, ulong nargs)
394: {
395: ulong *sp;
396:
397: sp = (ulong*)(USTKTOP - ssize);
398: *--sp = nargs;
399: ((Ureg*)UREGADDR)->usp = (ulong)sp;
400: ((Ureg*)UREGADDR)->pc = entry;
401: return USTKTOP-BY2WD; /* address of user-level clock */
402: }
403:
404: ulong
405: userpc(void)
406: {
407: return ((Ureg*)UREGADDR)->pc;
408: }
409:
410: /*
411: * system calls
412: */
413: #include "../port/systab.h"
414:
415: /*
416: * syscall is called spllo()
417: */
418: long
419: syscall(Ureg *ur, void *a)
420: {
421: ulong sp;
422: long ret;
423: int i;
424:
425: USED(a);
426:
427: u->p->insyscall = 1;
428: u->p->pc = ur->pc;
429: if((ur->cs)&0xffff == KESEL)
430: panic("recursive system call");
431:
432: u->scallnr = ur->ax;
433: if(u->scallnr == RFORK && u->p->fpstate == FPactive){
434: /*
435: * so that the child starts out with the
436: * same registers as the parent
437: */
438: splhi();
439: if(u->p->fpstate == FPactive){
440: fpsave(&u->fpsave);
441: u->p->fpstate = FPinactive;
442: }
443: spllo();
444: }
445: sp = ur->usp;
446: u->nerrlab = 0;
447: ret = -1;
448: if(!waserror()){
449: if(u->scallnr >= sizeof systab/BY2WD){
450: pprint("bad sys call number %d pc %lux\n", u->scallnr, ur->pc);
451: postnote(u->p, 1, "sys: bad sys call", NDebug);
452: error(Ebadarg);
453: }
454:
455: if(sp<(USTKTOP-BY2PG) || sp>(USTKTOP-(1+MAXSYSARG)*BY2WD))
456: validaddr(sp, (1+MAXSYSARG)*BY2WD, 0);
457:
458: u->s = *((Sargs*)(sp+1*BY2WD));
459: u->p->psstate = sysctab[u->scallnr];
460:
461: ret = (*systab[u->scallnr])(u->s.args);
462: poperror();
463: }
464: if(u->nerrlab){
465: print("bad errstack [%d]: %d extra\n", u->scallnr, u->nerrlab);
466: for(i = 0; i < NERR; i++)
467: print("sp=%lux pc=%lux\n", u->errlab[i].sp, u->errlab[i].pc);
468: panic("error stack");
469: }
470:
471: u->p->insyscall = 0;
472: u->p->psstate = 0;
473:
474: /*
475: * Put return value in frame. On the safari the syscall is
476: * just another trap and the return value from syscall is
477: * ignored. On other machines the return value is put into
478: * the results register by caller of syscall.
479: */
480: ur->ax = ret;
481:
482: if(u->scallnr == NOTED)
483: noted(ur, *(ulong*)(sp+BY2WD));
484:
485: splhi(); /* avoid interrupts during the iret */
486: if(u->scallnr!=RFORK && (u->p->procctl || u->nnote))
487: notify(ur);
488:
489: return ret;
490: }
491:
492: /*
493: * Call user, if necessary, with note.
494: * Pass user the Ureg struct and the note on his stack.
495: */
496: int
497: notify(Ureg *ur)
498: {
499: int l;
500: ulong s, sp;
501: Note *n;
502:
503: if(u->p->procctl)
504: procctl(u->p);
505: if(u->nnote == 0)
506: return 0;
507:
508: s = spllo();
509: qlock(&u->p->debug);
510: u->p->notepending = 0;
511: n = &u->note[0];
512: if(strncmp(n->msg, "sys:", 4) == 0){
513: l = strlen(n->msg);
514: if(l > ERRLEN-15) /* " pc=0x12345678\0" */
515: l = ERRLEN-15;
516: sprint(n->msg+l, " pc=0x%.8lux", ur->pc);
517: }
518:
519: if(n->flag!=NUser && (u->notified || u->notify==0)){
520: if(n->flag == NDebug){
521: qunlock(&u->p->debug);
522: pprint("suicide: %s\n", n->msg);
523: }else
524: qunlock(&u->p->debug);
525: pexit(n->msg, n->flag!=NDebug);
526: }
527:
528: if(u->notified) {
529: qunlock(&u->p->debug);
530: splhi();
531: return 0;
532: }
533:
534: if(!u->notify){
535: qunlock(&u->p->debug);
536: pexit(n->msg, n->flag!=NDebug);
537: }
538: sp = ur->usp;
539: sp -= sizeof(Ureg);
540:
541: if(!okaddr((ulong)u->notify, 1, 0)
542: || !okaddr(sp-ERRLEN-4*BY2WD, sizeof(Ureg)+ERRLEN+4*BY2WD, 1)){
543: qunlock(&u->p->debug);
544: pprint("suicide: bad address in notify\n");
545: pexit("Suicide", 0);
546: }
547:
548: u->ureg = (void*)sp;
549: memmove((Ureg*)sp, ur, sizeof(Ureg));
550: *(Ureg**)(sp-BY2WD) = u->ureg; /* word under Ureg is old u->ureg */
551: u->ureg = (void*)sp;
552: sp -= BY2WD+ERRLEN;
553: memmove((char*)sp, u->note[0].msg, ERRLEN);
554: sp -= 3*BY2WD;
555: *(ulong*)(sp+2*BY2WD) = sp+3*BY2WD; /* arg 2 is string */
556: *(ulong*)(sp+1*BY2WD) = (ulong)u->ureg; /* arg 1 is ureg* */
557: *(ulong*)(sp+0*BY2WD) = 0; /* arg 0 is pc */
558: ur->usp = sp;
559: ur->pc = (ulong)u->notify;
560: u->notified = 1;
561: u->nnote--;
562: memmove(&u->lastnote, &u->note[0], sizeof(Note));
563: memmove(&u->note[0], &u->note[1], u->nnote*sizeof(Note));
564:
565: qunlock(&u->p->debug);
566: splx(s);
567: return 1;
568: }
569:
570: /*
571: * Return user to state before notify()
572: */
573: void
574: noted(Ureg *ur, ulong arg0)
575: {
576: Ureg *nur;
577: ulong oureg, sp;
578:
579: qlock(&u->p->debug);
580: if(arg0!=NRSTR && !u->notified) {
581: qunlock(&u->p->debug);
582: pprint("call to noted() when not notified\n");
583: pexit("Suicide", 0);
584: }
585: u->notified = 0;
586:
587: nur = u->ureg; /* pointer to user returned Ureg struct */
588:
589: /* sanity clause */
590: oureg = (ulong)nur;
591: if(!okaddr((ulong)oureg-BY2WD, BY2WD+sizeof(Ureg), 0)){
592: qunlock(&u->p->debug);
593: pprint("bad u->ureg in noted or call to noted() when not notified\n");
594: pexit("Suicide", 0);
595: }
596:
597: /* don't let user change text or stack segments */
598: nur->cs = ur->cs;
599: nur->ss = ur->ss;
600:
601: /* don't let user change system flags */
602: nur->flags = (ur->flags & ~0xCD5) | (nur->flags & 0xCD5);
603:
604: memmove(ur, nur, sizeof(Ureg));
605:
606: switch(arg0){
607: case NCONT:
608: case NRSTR:
609: if(!okaddr(nur->pc, 1, 0) || !okaddr(nur->usp, BY2WD, 0)){
610: qunlock(&u->p->debug);
611: pprint("suicide: trap in noted\n");
612: pexit("Suicide", 0);
613: }
614: u->ureg = (Ureg*)(*(ulong*)(oureg-BY2WD));
615: qunlock(&u->p->debug);
616: break;
617:
618: case NSAVE:
619: if(!okaddr(nur->pc, BY2WD, 0) || !okaddr(nur->usp, BY2WD, 0)){
620: qunlock(&u->p->debug);
621: pprint("suicide: trap in noted\n");
622: pexit("Suicide", 0);
623: }
624: qunlock(&u->p->debug);
625: sp = oureg-4*BY2WD-ERRLEN;
626: splhi();
627: ur->sp = sp;
628: ((ulong*)sp)[1] = oureg; /* arg 1 0(FP) is ureg* */
629: ((ulong*)sp)[0] = 0; /* arg 0 is pc */
630: break;
631:
632: default:
633: u->lastnote.flag = NDebug;
634: qunlock(&u->p->debug);
635: pprint("unknown noted arg 0x%lux\n", arg0);
636: pprint("suicide: %s\n", u->lastnote.msg);
637: pexit(u->lastnote.msg, 0);
638: break;
639:
640: case NDFLT:
641: if(u->lastnote.flag == NDebug){
642: qunlock(&u->p->debug);
643: pprint("suicide: %s\n", u->lastnote.msg);
644: }else
645: qunlock(&u->p->debug);
646: pexit(u->lastnote.msg, u->lastnote.flag!=NDebug);
647: }
648: }
649:
650: /* This routine must save the values of registers the user is not permitted to write
651: * from devproc and the restore the saved values before returning
652: */
653: void
654: setregisters(Ureg *xp, char *pureg, char *uva, int n)
655: {
656: ulong flags;
657: ulong cs;
658: ulong ss;
659:
660: flags = xp->flags;
661: cs = xp->cs;
662: ss = xp->ss;
663: memmove(pureg, uva, n);
664: xp->flags = (xp->flags & 0xff) | (flags & 0xff00);
665: xp->cs = cs;
666: xp->ss = ss;
667: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.