![[BACK]](/icons/back.gif){kind=icon}
Return to trap.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvme68k / mvme68k|
Return to trap.c CVS log | Up to [local] / sys / arch / mvme68k / mvme68k |
1.1 nbrk 1: /* $OpenBSD: trap.c,v 1.67 2007/05/15 13:46:22 martin Exp $ */
2:
3: /*
4: * Copyright (c) 1995 Theo de Raadt
5: * Copyright (c) 1999 Steve Murphree, Jr. (68060 support)
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
17: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26: * SUCH DAMAGE.
27: *
28: * Copyright (c) 1988 University of Utah.
29: * Copyright (c) 1982, 1986, 1990, 1993
30: * The Regents of the University of California. All rights reserved.
31: *
32: * This code is derived from software contributed to Berkeley by
33: * the Systems Programming Group of the University of Utah Computer
34: * Science Department.
35: *
36: * Redistribution and use in source and binary forms, with or without
37: * modification, are permitted provided that the following conditions
38: * are met:
39: * 1. Redistributions of source code must retain the above copyright
40: * notice, this list of conditions and the following disclaimer.
41: * 2. Redistributions in binary form must reproduce the above copyright
42: * notice, this list of conditions and the following disclaimer in the
43: * documentation and/or other materials provided with the distribution.
44: * 3. Neither the name of the University nor the names of its contributors
45: * may be used to endorse or promote products derived from this software
46: * without specific prior written permission.
47: *
48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58: * SUCH DAMAGE.
59: *
60: * from: Utah $Hdr: trap.c 1.37 92/12/20$
61: *
62: * @(#)trap.c 8.5 (Berkeley) 1/4/94
63: */
64:
65: #include <sys/param.h>
66: #include <sys/systm.h>
67: #include <sys/proc.h>
68: #include <sys/acct.h>
69: #include <sys/kernel.h>
70: #include <sys/signalvar.h>
71: #include <sys/resourcevar.h>
72: #include <sys/syscall.h>
73: #include <sys/syslog.h>
74: #include <sys/user.h>
75: #ifdef KTRACE
76: #include <sys/ktrace.h>
77: #endif
78:
79: #include <machine/db_machdep.h>
80: #include <machine/cpu.h>
81: #include <machine/psl.h>
82: #include <machine/reg.h>
83: #include <machine/trap.h>
84:
85: #ifdef COMPAT_SUNOS
86: #include <compat/sunos/sunos_syscall.h>
87: extern struct emul emul_sunos;
88: #endif
89:
90: #include "systrace.h"
91: #include <dev/systrace.h>
92:
93: #include <uvm/uvm_extern.h>
94: #include <uvm/uvm_pmap.h>
95:
96: #ifdef COMPAT_HPUX
97: #include <compat/hpux/hpux.h>
98: #endif
99:
100: int astpending;
101: int want_resched;
102:
103: char *trap_type[] = {
104: "Bus error",
105: "Address error",
106: "Illegal instruction",
107: "Zero divide",
108: "CHK instruction",
109: "TRAPV instruction",
110: "Privilege violation",
111: "Trace trap",
112: "MMU fault",
113: "SSIR trap",
114: "Format error",
115: "68881 exception",
116: "Coprocessor violation",
117: "Async system trap"
118: };
119: int trap_types = sizeof trap_type / sizeof trap_type[0];
120:
121: /*
122: * Size of various exception stack frames (minus the standard 8 bytes)
123: */
124: short exframesize[] = {
125: FMT0SIZE, /* type 0 - normal (68020/030/040/060) */
126: FMT1SIZE, /* type 1 - throwaway (68020/030/040) */
127: FMT2SIZE, /* type 2 - normal 6-word (68020/030/040/060) */
128: FMT3SIZE, /* type 3 - FP post-instruction (68040/060) */
129: FMT4SIZE, /* type 4 - access error/fp disabled (68060) */
130: -1, -1, /* type 5-6 - undefined */
131: FMT7SIZE, /* type 7 - access error (68040) */
132: 58, /* type 8 - bus fault (68010) */
133: FMT9SIZE, /* type 9 - coprocessor mid-instruction (68020/030) */
134: FMTASIZE, /* type A - short bus fault (68020/030) */
135: FMTBSIZE, /* type B - long bus fault (68020/030) */
136: -1, -1, -1, -1 /* type C-F - undefined */
137: };
138:
139:
140: #if defined(M68040) || defined(M68060)
141: #define KDFAULT(c) (mmutype == MMU_68060 ? ((c) & FSLW_TM_SV) : \
142: mmutype == MMU_68040 ? ((c) & SSW4_TMMASK) == SSW4_TMKD : \
143: ((c) & (SSW_DF|FC_SUPERD)) == (SSW_DF|FC_SUPERD))
144: #define WRFAULT(c) (mmutype == MMU_68060 ? ((c) & FSLW_RW_W) : \
145: mmutype == MMU_68040 ? ((c) & SSW4_RW) == 0 : \
146: ((c) & (SSW_DF|SSW_RW)) == SSW_DF)
147: #else
148: #define KDFAULT(c) (((c) & (SSW_DF|SSW_FCMASK)) == (SSW_DF|FC_SUPERD))
149: #define WRFAULT(c) (((c) & (SSW_DF|SSW_RW)) == SSW_DF)
150: #endif
151:
152: #ifdef DEBUG
153: int mmudebug = 0;
154: int mmupid = -1;
155: #define MDB_FOLLOW 1
156: #define MDB_WBFOLLOW 2
157: #define MDB_WBFAILED 4
158: #define MDB_ISPID(p) (p) == mmupid
159: #endif
160:
161: #define NSIR 8
162: void (*sir_routines[NSIR])(void *);
163: void *sir_args[NSIR];
164: u_char next_sir;
165:
166: void trap(int, u_int, u_int, struct frame);
167: void syscall(register_t, struct frame);
168: void init_intrs(void);
169: void hardintr(int, int, void *);
170: int writeback(struct frame *);
171: void wb_userret(struct proc *, struct frame *);
172:
173: /*
174: * trap and syscall both need the following work done before returning
175: * to user mode.
176: */
177: void
178: userret(struct proc *p)
179: {
180: int sig;
181:
182: /* take pending signals */
183: while ((sig = CURSIG(p)) != 0)
184: postsig(sig);
185: curcpu()->ci_schedstate.spc_curpriority = p->p_priority = p->p_usrpri;
186: }
187:
188: #ifdef M68040
189: /*
190: * Same as above, but also handles writeback completion on 68040.
191: */
192: void
193: wb_userret(struct proc *p, struct frame *fp)
194: {
195: int sig;
196: union sigval sv;
197:
198: /* take pending signals */
199: while ((sig = CURSIG(p)) != 0)
200: postsig(sig);
201: p->p_priority = p->p_usrpri;
202:
203: /*
204: * Deal with user mode writebacks (from trap, or from sigreturn).
205: * If any writeback fails, go back and attempt signal delivery.
206: * unless we have already been here and attempted the writeback
207: * (e.g. bad address with user ignoring SIGSEGV). In that case
208: * we just return to the user without successfully completing
209: * the writebacks. Maybe we should just drop the sucker?
210: */
211: if (mmutype == MMU_68040 && fp->f_format == FMT7) {
212: if ((sig = writeback(fp)) != 0) {
213: sv.sival_int = fp->f_fmt7.f_fa;
214: trapsignal(p, sig, T_MMUFLT, SEGV_MAPERR, sv);
215:
216: while ((sig = CURSIG(p)) != 0)
217: postsig(sig);
218: p->p_priority = p->p_usrpri;
219: }
220: }
221: curcpu()->ci_schedstate.spc_curpriority = p->p_priority;
222: }
223: #endif
224:
225: /*
226: * Trap is called from locore to handle most types of processor traps,
227: * including events such as simulated software interrupts/AST's.
228: * System calls are broken out for efficiency.
229: */
230: /*ARGSUSED*/
231: void
232: trap(type, code, v, frame)
233: int type;
234: u_int code;
235: register u_int v;
236: struct frame frame;
237: {
238: register struct proc *p;
239: register int i;
240: u_int ucode;
241: int typ = 0, bit;
242: #ifdef COMPAT_HPUX
243: extern struct emul emul_hpux;
244: #endif
245: #ifdef COMPAT_SUNOS
246: extern struct emul emul_sunos;
247: #endif
248: register union sigval sv;
249:
250: uvmexp.traps++;
251: p = curproc;
252: ucode = 0;
253: if (USERMODE(frame.f_sr)) {
254: type |= T_USER;
255: p->p_md.md_regs = frame.f_regs;
256: }
257: switch (type) {
258: default:
259: dopanic:
260: printf("trap type %d, code = %x, v = %x\n", type, code, v);
261: #ifdef DDB
262: if (kdb_trap(type, (db_regs_t *)&frame))
263: return;
264: #endif
265: regdump(&(frame.F_t), 128);
266: type &= ~T_USER;
267: if ((u_int)type < trap_types)
268: panic(trap_type[type]);
269: panic("trap");
270:
271: case T_BUSERR: /* kernel bus error */
272: if (!p || !p->p_addr->u_pcb.pcb_onfault)
273: goto dopanic;
274: copyfault:
275: /*
276: * If we have arranged to catch this fault in any of the
277: * copy to/from user space routines, set PC to return to
278: * indicated location and set flag informing buserror code
279: * that it may need to clean up stack frame.
280: */
281: frame.f_stackadj = exframesize[frame.f_format];
282: frame.f_format = frame.f_vector = 0;
283: frame.f_pc = (int) p->p_addr->u_pcb.pcb_onfault;
284: return;
285:
286: case T_BUSERR|T_USER: /* bus error */
287: typ = BUS_OBJERR;
288: ucode = code & ~T_USER;
289: i = SIGBUS;
290: break;
291: case T_ADDRERR|T_USER: /* address error */
292: typ = BUS_ADRALN;
293: ucode = code & ~T_USER;
294: i = SIGBUS;
295: break;
296:
297: case T_COPERR: /* kernel coprocessor violation */
298: case T_FMTERR|T_USER: /* do all RTE errors come in as T_USER? */
299: case T_FMTERR: /* ...just in case... */
300: /*
301: * The user has most likely trashed the RTE or FP state info
302: * in the stack frame of a signal handler.
303: */
304: printf("pid %d: kernel %s exception\n", p->p_pid,
305: type==T_COPERR ? "coprocessor" : "format");
306: type |= T_USER;
307: p->p_sigacts->ps_sigact[SIGILL] = SIG_DFL;
308: i = sigmask(SIGILL);
309: p->p_sigignore &= ~i;
310: p->p_sigcatch &= ~i;
311: p->p_sigmask &= ~i;
312: i = SIGILL;
313: ucode = frame.f_format; /* XXX was ILL_RESAD_FAULT */
314: typ = ILL_COPROC;
315: v = frame.f_pc;
316: break;
317:
318: case T_COPERR|T_USER: /* user coprocessor violation */
319: /* What is a proper response here? */
320: typ = FPE_FLTINV;
321: ucode = 0;
322: i = SIGFPE;
323: break;
324:
325: case T_FPERR|T_USER: /* 68881 exceptions */
326: typ = FPE_FLTRES;
327: ucode = code;
328: i = SIGFPE;
329: v = frame.f_pc;
330: break;
331:
332: #if defined(M68040) || defined(M68060)
333: case T_FPEMULI|T_USER: /* unimplemented FP instruction */
334: case T_FPEMULD|T_USER: /* unimplemented FP data type */
335: /* XXX need to FSAVE */
336: printf("pid %d(%s): unimplemented FP %s at %x (EA %x)\n",
337: p->p_pid, p->p_comm,
338: frame.f_format == 2 ? "instruction" : "data type",
339: frame.f_pc, frame.f_fmt2.f_iaddr);
340: /* XXX need to FRESTORE */
341: typ = FPE_FLTINV;
342: i = SIGFPE;
343: v = frame.f_pc;
344: break;
345: #endif
346:
347: case T_ILLINST|T_USER: /* illegal instruction fault */
348: #ifdef COMPAT_HPUX
349: if (p->p_emul == &emul_hpux) {
350: typ = 0;
351: ucode = HPUX_ILL_ILLINST_TRAP;
352: i = SIGILL;
353: break;
354: }
355: #endif
356: ucode = frame.f_format; /* XXX was ILL_PRIVIN_FAULT */
357: typ = ILL_ILLOPC;
358: i = SIGILL;
359: v = frame.f_pc;
360: break;
361:
362: case T_PRIVINST|T_USER: /* privileged instruction fault */
363: #ifdef COMPAT_HPUX
364: if (p->p_emul == &emul_hpux)
365: ucode = HPUX_ILL_PRIV_TRAP;
366: else
367: #endif
368: ucode = frame.f_format; /* XXX was ILL_PRIVIN_FAULT */
369: typ = ILL_PRVOPC;
370: i = SIGILL;
371: v = frame.f_pc;
372: break;
373:
374: case T_ZERODIV|T_USER: /* Divide by zero */
375: #ifdef COMPAT_HPUX
376: if (p->p_emul == &emul_hpux)
377: ucode = HPUX_FPE_INTDIV_TRAP;
378: else
379: #endif
380: ucode = frame.f_format; /* XXX was FPE_INTDIV_TRAP */
381: typ = FPE_INTDIV;
382: i = SIGFPE;
383: v = frame.f_pc;
384: break;
385:
386: case T_CHKINST|T_USER: /* CHK instruction trap */
387: #ifdef COMPAT_HPUX
388: if (p->p_emul == &emul_hpux) {
389: /* handled differently under hp-ux */
390: i = SIGILL;
391: ucode = HPUX_ILL_CHK_TRAP;
392: break;
393: }
394: #endif
395: ucode = frame.f_format; /* XXX was FPE_SUBRNG_TRAP */
396: typ = FPE_FLTSUB;
397: i = SIGFPE;
398: v = frame.f_pc;
399: break;
400:
401: case T_TRAPVINST|T_USER: /* TRAPV instruction trap */
402: #ifdef COMPAT_HPUX
403: if (p->p_emul == &emul_hpux) {
404: /* handled differently under hp-ux */
405: i = SIGILL;
406: ucode = HPUX_ILL_TRAPV_TRAP;
407: break;
408: }
409: #endif
410: ucode = frame.f_format; /* XXX was FPE_INTOVF_TRAP */
411: typ = ILL_ILLTRP;
412: i = SIGILL;
413: v = frame.f_pc;
414: break;
415:
416: /*
417: * XXX: Trace traps are a nightmare.
418: *
419: * HP-UX uses trap #1 for breakpoints,
420: * OpenBSD/m68k uses trap #2,
421: * SUN 3.x uses trap #15,
422: * KGDB uses trap #15 (for kernel breakpoints; handled elsewhere).
423: *
424: * OpenBSD and HP-UX traps both get mapped by locore.s into
425: * T_TRACE.
426: * SUN 3.x traps get passed through as T_TRAP15 and are not really
427: * supported yet.
428: */
429: case T_TRAP15: /* kernel breakpoint */
430: #ifdef DEBUG
431: printf("unexpected kernel trace trap, type = %d\n", type);
432: printf("program counter = 0x%x\n", frame.f_pc);
433: #endif
434: frame.f_sr &= ~PSL_T;
435: return;
436:
437: case T_TRACE|T_USER: /* user trace trap */
438: #ifdef COMPAT_SUNOS
439: /*
440: * SunOS uses Trap #2 for a "CPU cache flush"
441: * Just flush the on-chip caches and return.
442: */
443: if (p->p_emul == &emul_sunos) {
444: ICIA();
445: DCIU();
446: return;
447: }
448: #endif
449: /* FALLTHROUGH */
450:
451: case T_TRACE:
452: case T_TRAP15|T_USER: /* SUN user trace trap */
453: frame.f_sr &= ~PSL_T;
454: i = SIGTRAP;
455: typ = TRAP_TRACE;
456: break;
457:
458: case T_ASTFLT: /* system async trap, cannot happen */
459: goto dopanic;
460:
461: case T_ASTFLT|T_USER: /* user async trap */
462: astpending = 0;
463: /*
464: * We check for software interrupts first. This is because
465: * they are at a higher level than ASTs, and on a VAX would
466: * interrupt the AST. We assume that if we are processing
467: * an AST that we must be at IPL0 so we don't bother to
468: * check. Note that we ensure that we are at least at SIR
469: * IPL while processing the SIR.
470: */
471: splsoft();
472: /* FALLTHROUGH */
473:
474: case T_SSIR: /* software interrupt */
475: case T_SSIR|T_USER:
476: while ((bit = ffs(ssir))) {
477: --bit;
478: ssir &= ~(1 << bit);
479: uvmexp.softs++;
480: if (sir_routines[bit])
481: sir_routines[bit](sir_args[bit]);
482: }
483: /*
484: * If this was not an AST trap, we are all done.
485: */
486: if (type != (T_ASTFLT|T_USER)) {
487: uvmexp.traps--;
488: return;
489: }
490: spl0();
491: if (p->p_flag & P_OWEUPC) {
492: ADDUPROF(p);
493: }
494: if (type == (T_ASTFLT | T_USER) && want_resched) {
495: preempt(NULL);
496: }
497: goto out;
498:
499: case T_MMUFLT: /* kernel mode page fault */
500: case T_MMUFLT|T_USER: /* page fault */
501: {
502: vaddr_t va;
503: struct vmspace *vm = NULL;
504: struct vm_map *map;
505: int rv;
506: vm_prot_t ftype, vftype;
507: extern struct vm_map *kernel_map;
508:
509: /* vmspace only significant if T_USER */
510: if (p)
511: vm = p->p_vmspace;
512:
513: #ifdef DEBUG
514: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid))
515: printf("trap: T_MMUFLT pid=%d, code=%x, v=%x, pc=%x, sr=%x\n",
516: p->p_pid, code, v, frame.f_pc, frame.f_sr);
517: #endif
518: /*
519: * It is only a kernel address space fault iff:
520: * 1. (type & T_USER) == 0 and
521: * 2. pcb_onfault not set or
522: * 3. pcb_onfault set but supervisor space data fault
523: * The last can occur during an exec() copyin where the
524: * argument space is lazy-allocated.
525: */
526: if (type == T_MMUFLT &&
527: ((p && !p->p_addr->u_pcb.pcb_onfault) || KDFAULT(code)))
528: map = kernel_map;
529: else
530: map = vm ? &vm->vm_map : kernel_map;
531: if (WRFAULT(code)) {
532: vftype = VM_PROT_WRITE;
533: ftype = VM_PROT_READ | VM_PROT_WRITE;
534: } else
535: vftype = ftype = VM_PROT_READ;
536: va = trunc_page((vaddr_t)v);
537:
538: if (map == kernel_map && va == 0) {
539: printf("trap: bad kernel access at %x\n", v);
540: goto dopanic;
541: }
542: #ifdef COMPAT_HPUX
543: if (ISHPMMADDR(p, va)) {
544: vaddr_t bva;
545:
546: rv = pmap_mapmulti(map->pmap, va);
547: if (rv) {
548: bva = HPMMBASEADDR(va);
549: rv = uvm_fault(map, bva, 0, ftype);
550: if (rv == 0)
551: (void)pmap_mapmulti(map->pmap, va);
552: }
553: } else
554: #endif
555: rv = uvm_fault(map, va, 0, ftype);
556: #ifdef DEBUG
557: if (rv && MDB_ISPID(p->p_pid))
558: printf("uvm_fault(%x, %x, 0, %x) -> %x\n",
559: map, va, ftype, rv);
560: #endif
561: /*
562: * If this was a stack access we keep track of the maximum
563: * accessed stack size. Also, if vm_fault gets a protection
564: * failure it is due to accessing the stack region outside
565: * the current limit and we need to reflect that as an access
566: * error.
567: */
568: if ((vm != NULL && (caddr_t)va >= vm->vm_maxsaddr)
569: && map != kernel_map) {
570: if (rv == 0)
571: uvm_grow(p, va);
572: else if (rv == EACCES)
573: rv = EFAULT;
574: }
575: if (rv == 0) {
576: if (type == T_MMUFLT) {
577: #if defined(M68040)
578: if (mmutype == MMU_68040)
579: (void)writeback(&frame);
580: #endif
581: return;
582: }
583: goto out;
584: }
585: if (type == T_MMUFLT) {
586: if (p && p->p_addr->u_pcb.pcb_onfault)
587: goto copyfault;
588: printf("uvm_fault(%p, %lx, 0, %x) -> %x\n",
589: map, va, ftype, rv);
590: printf(" type %x, code [mmu,,ssw]: %x\n",
591: type, code);
592: goto dopanic;
593: }
594: frame.f_pad = code & 0xffff;
595: ucode = vftype;
596: typ = SEGV_MAPERR;
597: i = SIGSEGV;
598: }
599: break;
600: }
601: sv.sival_int = v;
602: trapsignal(p, i, ucode, typ, sv);
603: out:
604: if ((type & T_USER) == 0)
605: return;
606: #ifdef M68040
607: wb_userret(p, &frame);
608: #else
609: userret(p);
610: #endif
611: }
612:
613: #if defined(M68040)
614: #ifdef DEBUG
615: struct writebackstats {
616: int calls;
617: int cpushes;
618: int move16s;
619: int wb1s, wb2s, wb3s;
620: int wbsize[4];
621: } wbstats;
622:
623: char *f7sz[] = { "longword", "byte", "word", "line"};
624: char *f7tt[] = { "normal", "MOVE16", "AFC", "ACK"};
625: char *f7tm[] = { "d-push", "u-data", "u-code", "M-data",
626: "M-code", "k-data", "k-code", "RES"};
627: char wberrstr[] =
628: "WARNING: pid %d(%s) writeback [%s] failed, pc=%x fa=%x wba=%x wbd=%x\n";
629: #endif
630:
631: int
632: writeback(struct frame *fp)
633: {
634: struct fmt7 *f = &fp->f_fmt7;
635: struct proc *p = curproc;
636: int err = 0;
637: u_int fa;
638: paddr_t pa;
639: caddr_t oonfault = p->p_addr->u_pcb.pcb_onfault;
640:
641: #ifdef DEBUG
642: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid)) {
643: printf(" pid=%d, fa=%x,", p->p_pid, f->f_fa);
644: dumpssw(f->f_ssw);
645: }
646: wbstats.calls++;
647: #endif
648: /*
649: * Deal with special cases first.
650: */
651: if ((f->f_ssw & SSW4_TMMASK) == SSW4_TMDCP) {
652: /*
653: * Dcache push fault.
654: * Line-align the address and write out the push data to
655: * the indicated physical address.
656: */
657: #ifdef DEBUG
658: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid)) {
659: printf(" pushing %s to PA %x, data %x",
660: f7sz[(f->f_ssw & SSW4_SZMASK) >> 5],
661: f->f_fa, f->f_pd0);
662: if ((f->f_ssw & SSW4_SZMASK) == SSW4_SZLN)
663: printf("/%x/%x/%x",
664: f->f_pd1, f->f_pd2, f->f_pd3);
665: printf("\n");
666: }
667: if (f->f_wb1s & SSW4_WBSV)
668: panic("writeback: cache push with WB1S valid");
669: wbstats.cpushes++;
670: #endif
671: /*
672: * XXX there are security problems if we attempt to do a
673: * cache push after a signal handler has been called.
674: */
675: pmap_kenter_pa((vaddr_t)vmmap,
676: trunc_page(f->f_fa), VM_PROT_WRITE);
677: pmap_update(pmap_kernel());
678: fa = (u_int)&vmmap[(f->f_fa & PGOFSET) & ~0x000f];
679: bcopy((caddr_t)&f->f_pd0, (caddr_t)fa, 16);
680: pmap_extract(pmap_kernel(), (vaddr_t)fa, &pa);
681: DCFL(pa);
682: pmap_kremove((vaddr_t)vmmap, PAGE_SIZE);
683: pmap_update(pmap_kernel());
684: } else if ((f->f_ssw & (SSW4_RW|SSW4_TTMASK)) == SSW4_TTM16) {
685: /*
686: * MOVE16 fault.
687: * Line-align the address and write out the push data to
688: * the indicated virtual address.
689: */
690: #ifdef DEBUG
691: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid))
692: printf(" MOVE16 to VA %x(%x), data %x/%x/%x/%x\n",
693: f->f_fa, f->f_fa & ~0xF, f->f_pd0, f->f_pd1,
694: f->f_pd2, f->f_pd3);
695: if (f->f_wb1s & SSW4_WBSV)
696: panic("writeback: MOVE16 with WB1S valid");
697: wbstats.move16s++;
698: #endif
699: if (KDFAULT(f->f_wb1s))
700: bcopy((caddr_t)&f->f_pd0, (caddr_t)(f->f_fa & ~0xF), 16);
701: else
702: err = suline((caddr_t)(f->f_fa & ~0xF), (caddr_t)&f->f_pd0);
703: if (err) {
704: fa = f->f_fa & ~0xF;
705: #ifdef DEBUG
706: if (mmudebug & MDB_WBFAILED)
707: printf(wberrstr, p->p_pid, p->p_comm,
708: "MOVE16", fp->f_pc, f->f_fa,
709: f->f_fa & ~0xF, f->f_pd0);
710: #endif
711: }
712: } else if (f->f_wb1s & SSW4_WBSV) {
713: /*
714: * Writeback #1.
715: * Position the "memory-aligned" data and write it out.
716: */
717: u_int wb1d = f->f_wb1d;
718: int off;
719:
720: #ifdef DEBUG
721: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid))
722: dumpwb(1, f->f_wb1s, f->f_wb1a, f->f_wb1d);
723: wbstats.wb1s++;
724: wbstats.wbsize[(f->f_wb2s&SSW4_SZMASK)>>5]++;
725: #endif
726: off = (f->f_wb1a & 3) * 8;
727: switch (f->f_wb1s & SSW4_SZMASK) {
728: case SSW4_SZLW:
729: if (off)
730: wb1d = (wb1d >> (32 - off)) | (wb1d << off);
731: if (KDFAULT(f->f_wb1s))
732: *(long *)f->f_wb1a = wb1d;
733: else
734: err = copyout(&wb1d,
735: (caddr_t)f->f_wb1a, sizeof(int));
736: break;
737: case SSW4_SZB:
738: off = 24 - off;
739: if (off)
740: wb1d >>= off;
741: if (KDFAULT(f->f_wb1s))
742: *(char *)f->f_wb1a = wb1d;
743: else {
744: char tmp = wb1d;
745:
746: err = copyout(&tmp,
747: (caddr_t)f->f_wb1a, sizeof(char));
748: }
749: break;
750: case SSW4_SZW:
751: off = (off + 16) % 32;
752: if (off)
753: wb1d = (wb1d >> (32 - off)) | (wb1d << off);
754: if (KDFAULT(f->f_wb1s))
755: *(short *)f->f_wb1a = wb1d;
756: else {
757: short tmp = wb1d;
758:
759: err = copyout(&tmp,
760: (caddr_t)f->f_wb1a, sizeof(short));
761: }
762: break;
763: }
764: if (err) {
765: fa = f->f_wb1a;
766: #ifdef DEBUG
767: if (mmudebug & MDB_WBFAILED)
768: printf(wberrstr, p->p_pid, p->p_comm,
769: "#1", fp->f_pc, f->f_fa,
770: f->f_wb1a, f->f_wb1d);
771: #endif
772: }
773: }
774: /*
775: * Deal with the "normal" writebacks.
776: *
777: * XXX writeback2 is known to reflect a LINE size writeback after
778: * a MOVE16 was already dealt with above. Ignore it.
779: */
780: if (err == 0 && (f->f_wb2s & SSW4_WBSV) &&
781: (f->f_wb2s & SSW4_SZMASK) != SSW4_SZLN) {
782: #ifdef DEBUG
783: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid))
784: dumpwb(2, f->f_wb2s, f->f_wb2a, f->f_wb2d);
785: wbstats.wb2s++;
786: wbstats.wbsize[(f->f_wb2s&SSW4_SZMASK)>>5]++;
787: #endif
788: switch (f->f_wb2s & SSW4_SZMASK) {
789: case SSW4_SZLW:
790: if (KDFAULT(f->f_wb2s))
791: *(long *)f->f_wb2a = f->f_wb2d;
792: else
793: err = copyout(&f->f_wb2d,
794: (caddr_t)f->f_wb2a, sizeof(int));
795: break;
796: case SSW4_SZB:
797: if (KDFAULT(f->f_wb2s))
798: *(char *)f->f_wb2a = f->f_wb2d;
799: else {
800: char tmp = f->f_wb2d;
801:
802: err = copyout(&tmp,
803: (caddr_t)f->f_wb2a, sizeof(char));
804: }
805: break;
806: case SSW4_SZW:
807: if (KDFAULT(f->f_wb2s))
808: *(short *)f->f_wb2a = f->f_wb2d;
809: else {
810: short tmp = f->f_wb2d;
811:
812: err = copyout(&tmp,
813: (caddr_t)f->f_wb2a, sizeof(short));
814: }
815: break;
816: }
817: if (err) {
818: fa = f->f_wb2a;
819: #ifdef DEBUG
820: if (mmudebug & MDB_WBFAILED) {
821: printf(wberrstr, p->p_pid, p->p_comm,
822: "#2", fp->f_pc, f->f_fa,
823: f->f_wb2a, f->f_wb2d);
824: dumpssw(f->f_ssw);
825: dumpwb(2, f->f_wb2s, f->f_wb2a, f->f_wb2d);
826: }
827: #endif
828: }
829: }
830: if (err == 0 && (f->f_wb3s & SSW4_WBSV)) {
831: #ifdef DEBUG
832: if ((mmudebug & MDB_WBFOLLOW) || MDB_ISPID(p->p_pid))
833: dumpwb(3, f->f_wb3s, f->f_wb3a, f->f_wb3d);
834: wbstats.wb3s++;
835: wbstats.wbsize[(f->f_wb3s&SSW4_SZMASK)>>5]++;
836: #endif
837: switch (f->f_wb3s & SSW4_SZMASK) {
838: case SSW4_SZLW:
839: if (KDFAULT(f->f_wb3s))
840: *(long *)f->f_wb3a = f->f_wb3d;
841: else
842: err = copyout(&f->f_wb3d,
843: (caddr_t)f->f_wb3a, sizeof(int));
844: break;
845: case SSW4_SZB:
846: if (KDFAULT(f->f_wb3s))
847: *(char *)f->f_wb3a = f->f_wb3d;
848: else {
849: char tmp = f->f_wb3d;
850:
851: err = copyout(&tmp,
852: (caddr_t)f->f_wb3a, sizeof(char));
853: }
854: break;
855: case SSW4_SZW:
856: if (KDFAULT(f->f_wb3s))
857: *(short *)f->f_wb3a = f->f_wb3d;
858: else {
859: short tmp = f->f_wb3d;
860:
861: err = copyout(&tmp,
862: (caddr_t)f->f_wb3a, sizeof(short));
863: }
864: break;
865: #ifdef DEBUG
866: case SSW4_SZLN:
867: panic("writeback: wb3s indicates LINE write");
868: #endif
869: }
870: if (err) {
871: fa = f->f_wb3a;
872: #ifdef DEBUG
873: if (mmudebug & MDB_WBFAILED)
874: printf(wberrstr, p->p_pid, p->p_comm,
875: "#3", fp->f_pc, f->f_fa,
876: f->f_wb3a, f->f_wb3d);
877: #endif
878: }
879: }
880: p->p_addr->u_pcb.pcb_onfault = oonfault;
881: /*
882: * Any problems are SIGSEGV's
883: */
884: if (err)
885: err = SIGSEGV;
886: return (err);
887: }
888:
889: #ifdef DEBUG
890: void
891: dumpssw(ssw)
892: register u_short ssw;
893: {
894: printf(" SSW: %x: ", ssw);
895: if (ssw & SSW4_CP)
896: printf("CP,");
897: if (ssw & SSW4_CU)
898: printf("CU,");
899: if (ssw & SSW4_CT)
900: printf("CT,");
901: if (ssw & SSW4_CM)
902: printf("CM,");
903: if (ssw & SSW4_MA)
904: printf("MA,");
905: if (ssw & SSW4_ATC)
906: printf("ATC,");
907: if (ssw & SSW4_LK)
908: printf("LK,");
909: if (ssw & SSW4_RW)
910: printf("RW,");
911: printf(" SZ=%s, TT=%s, TM=%s\n",
912: f7sz[(ssw & SSW4_SZMASK) >> 5],
913: f7tt[(ssw & SSW4_TTMASK) >> 3],
914: f7tm[ssw & SSW4_TMMASK]);
915: }
916:
917: void
918: dumpwb(num, s, a, d)
919: int num;
920: u_short s;
921: u_int a, d;
922: {
923: register struct proc *p = curproc;
924: paddr_t pa;
925: int tmp;
926:
927: printf(" writeback #%d: VA %x, data %x, SZ=%s, TT=%s, TM=%s\n",
928: num, a, d, f7sz[(s & SSW4_SZMASK) >> 5],
929: f7tt[(s & SSW4_TTMASK) >> 3], f7tm[s & SSW4_TMMASK]);
930: printf(" PA ");
931: if (pmap_extract(p->p_vmspace->vm_map.pmap, (vaddr_t)a, &pa) == FALSE)
932: printf("<invalid address>");
933: else {
934: if (copyin((caddr_t)a, &tmp, sizeof(int)) == 0)
935: printf("%lx, current value %lx", pa, tmp);
936: else
937: printf("%lx, current value inaccessible", pa);
938: }
939: printf("\n");
940: }
941: #endif
942: #endif
943:
944: /*
945: * Process a system call.
946: */
947: void
948: syscall(code, frame)
949: register_t code;
950: struct frame frame;
951: {
952: register caddr_t params;
953: register struct sysent *callp;
954: register struct proc *p;
955: int error, opc, nsys;
956: size_t argsize;
957: register_t args[8], rval[2];
958: #ifdef COMPAT_SUNOS
959: extern struct emul emul_sunos;
960: #endif
961: uvmexp.syscalls++;
962:
963: if (!USERMODE(frame.f_sr))
964: panic("syscall");
965: p = curproc;
966: p->p_md.md_regs = frame.f_regs;
967: opc = frame.f_pc;
968:
969: nsys = p->p_emul->e_nsysent;
970: callp = p->p_emul->e_sysent;
971:
972: #ifdef COMPAT_SUNOS
973: if (p->p_emul == &emul_sunos) {
974: /*
975: * SunOS passes the syscall-number on the stack, whereas
976: * BSD passes it in D0. So, we have to get the real "code"
977: * from the stack, and clean up the stack, as SunOS glue
978: * code assumes the kernel pops the syscall argument the
979: * glue pushed on the stack. Sigh...
980: */
981: if (copyin((caddr_t)frame.f_regs[SP], &code,
982: sizeof(register_t)) != 0)
983: code = -1;
984:
985: /*
986: * XXX
987: * Don't do this for sunos_sigreturn, as there's no stored pc
988: * on the stack to skip, the argument follows the syscall
989: * number without a gap.
990: */
991: if (code != SUNOS_SYS_sigreturn) {
992: frame.f_regs[SP] += sizeof (int);
993: /*
994: * remember that we adjusted the SP,
995: * might have to undo this if the system call
996: * returns ERESTART.
997: */
998: p->p_md.md_flags |= MDP_STACKADJ;
999: } else
1000: p->p_md.md_flags &= ~MDP_STACKADJ;
1001: }
1002: #endif
1003:
1004: params = (caddr_t)frame.f_regs[SP] + sizeof(int);
1005:
1006: switch (code) {
1007: case SYS_syscall:
1008: /*
1009: * Code is first argument, followed by actual args.
1010: */
1011: if (copyin(params, &code, sizeof(register_t)) != 0)
1012: code = -1;
1013: params += sizeof(int);
1014: /*
1015: * XXX sigreturn requires special stack manipulation
1016: * that is only done if entered via the sigreturn
1017: * trap. Cannot allow it here so make sure we fail.
1018: */
1019: if (code == SYS_sigreturn)
1020: code = nsys;
1021: break;
1022: case SYS___syscall:
1023: /*
1024: * Like syscall, but code is a quad, so as to maintain
1025: * quad alignment for the rest of the arguments.
1026: */
1027: if (callp != sysent)
1028: break;
1029: if (copyin(params + _QUAD_LOWWORD * sizeof(int), &code,
1030: sizeof(register_t)) != 0)
1031: code = -1;
1032: params += sizeof(quad_t);
1033: break;
1034: default:
1035: break;
1036: }
1037: if (code < 0 || code >= nsys)
1038: callp += p->p_emul->e_nosys; /* illegal */
1039: else
1040: callp += code;
1041: argsize = callp->sy_argsize;
1042: if (argsize)
1043: error = copyin(params, (caddr_t)args, argsize);
1044: else
1045: error = 0;
1046: #ifdef SYSCALL_DEBUG
1047: scdebug_call(p, code, args);
1048: #endif
1049: #ifdef KTRACE
1050: if (KTRPOINT(p, KTR_SYSCALL))
1051: ktrsyscall(p, code, argsize, args);
1052: #endif
1053: if (error)
1054: goto bad;
1055: rval[0] = 0;
1056: rval[1] = frame.f_regs[D1];
1057: #if NSYSTRACE > 0
1058: if (ISSET(p->p_flag, P_SYSTRACE))
1059: error = systrace_redirect(code, p, args, rval);
1060: else
1061: #endif
1062: error = (*callp->sy_call)(p, args, rval);
1063: switch (error) {
1064: case 0:
1065: frame.f_regs[D0] = rval[0];
1066: frame.f_regs[D1] = rval[1];
1067: frame.f_sr &= ~PSL_C; /* carry bit */
1068: break;
1069: case ERESTART:
1070: /*
1071: * We always enter through a `trap' instruction, which is 2
1072: * bytes, so adjust the pc by that amount.
1073: */
1074: frame.f_pc = opc - 2;
1075: break;
1076: case EJUSTRETURN:
1077: /* nothing to do */
1078: break;
1079: default:
1080: bad:
1081: if (p->p_emul->e_errno)
1082: error = p->p_emul->e_errno[error];
1083: frame.f_regs[D0] = error;
1084: frame.f_sr |= PSL_C; /* carry bit */
1085: break;
1086: }
1087:
1088: #ifdef SYSCALL_DEBUG
1089: scdebug_ret(p, code, error, rval);
1090: #endif
1091: #ifdef COMPAT_SUNOS
1092: /* need new p-value for this */
1093: if (error == ERESTART && (p->p_md.md_flags & MDP_STACKADJ))
1094: frame.f_regs[SP] -= sizeof (int);
1095: #endif
1096: userret(p);
1097: #ifdef KTRACE
1098: if (KTRPOINT(p, KTR_SYSRET))
1099: ktrsysret(p, code, error, rval[0]);
1100: #endif
1101: }
1102:
1103: /*
1104: * Allocation routines for software interrupts.
1105: */
1106: u_int8_t
1107: allocate_sir(proc, arg)
1108: void (*proc)(void *);
1109: void *arg;
1110: {
1111: int bit;
1112:
1113: if (next_sir >= NSIR)
1114: panic("allocate_sir: none left");
1115: bit = next_sir++;
1116: sir_routines[bit] = proc;
1117: sir_args[bit] = arg;
1118: return (1 << bit);
1119: }
1120:
1121: typedef SLIST_HEAD(,intrhand) intrhand_t;
1122: intrhand_t intrs[NVMEINTR];
1123:
1124: void
1125: init_intrs()
1126: {
1127: int i;
1128: extern void netintr(void *);
1129:
1130: /* hard interrupts... */
1131: for (i = 0; i < NVMEINTR; i++)
1132: SLIST_INIT(&intrs[i]);
1133:
1134: /* soft interrupts... */
1135: sir_routines[0] = netintr;
1136: sir_routines[1] = (void (*)(void *))softclock;
1137: next_sir = 2;
1138: }
1139:
1140: void
1141: hardintr(pc, evec, frame)
1142: int pc;
1143: int evec;
1144: void *frame;
1145: {
1146: extern void straytrap(int, u_short);
1147: int vec = (evec & 0xfff) >> 2; /* XXX should be m68k macro? */
1148: struct intrhand *ih;
1149: intrhand_t *list;
1150: int count = 0;
1151: int r;
1152:
1153: uvmexp.intrs++;
1154:
1155: list = &intrs[vec];
1156: if (SLIST_EMPTY(list)) {
1157: straytrap(pc, evec);
1158: } else {
1159: SLIST_FOREACH(ih, list, ih_link) {
1160: r = (*ih->ih_fn)(ih->ih_wantframe ? frame : ih->ih_arg);
1161: if (r != 0) {
1162: ih->ih_count.ec_count++;
1163: count++;
1164: }
1165: }
1166:
1167: if (count == 0) {
1168: printf("Unclaimed interrupt (vector %d) from %x\n",
1169: evec, pc);
1170: }
1171: }
1172: }
1173:
1174: /*
1175: * find a useable interrupt vector in the range start, end. It starts at
1176: * the end of the range, and searches backwards (to increase the chances
1177: * of not conflicting with more normal users)
1178: */
1179: int
1180: intr_findvec(start, end)
1181: int start, end;
1182: {
1183: extern u_long *vectab[], hardtrap, badtrap;
1184: int vec;
1185:
1186: if (start < 0 || end >= NVMEINTR || start > end)
1187: return (-1);
1188: for (vec = end; vec > start; --vec)
1189: if (vectab[vec] == &badtrap || vectab[vec] == &hardtrap)
1190: return (vec);
1191: return (-1);
1192: }
1193:
1194: /*
1195: * Chain the interrupt handler in. But first check if the vector
1196: * offset chosen is legal. It either must be a badtrap (not allocated
1197: * for a `system' purpose), or it must be a hardtrap (ie. already
1198: * allocated to deal with chained interrupt handlers).
1199: */
1200: int
1201: intr_establish(vec, ih, name)
1202: int vec;
1203: struct intrhand *ih;
1204: const char *name;
1205: {
1206: extern u_long *vectab[], hardtrap, badtrap;
1207: struct intrhand *intr;
1208: intrhand_t *list;
1209:
1210: #ifdef DIAGNOSTIC
1211: if (vec < 0 || vec >= NVMEINTR) {
1212: panic("intr_establish: vec (0x%x) out of bounds", vec);
1213: return (-1);
1214: }
1215: #endif
1216:
1217: if (vectab[vec] != &badtrap && vectab[vec] != &hardtrap) {
1218: #ifdef DIAGNOSTIC
1219: panic("intr_establish: vec (%x) unavailable for devices", vec);
1220: #endif
1221: return (-1);
1222: }
1223: vectab[vec] = &hardtrap;
1224:
1225: list = &intrs[vec];
1226: if (!SLIST_EMPTY(list)) {
1227: intr = SLIST_FIRST(list);
1228: if (intr->ih_ipl != ih->ih_ipl) {
1229: #ifdef DIAGNOSTIC
1230: panic("intr_establish: there are other handlers with "
1231: "vec (0x%x) at ipl %x, but you want it at %x",
1232: vec, intr->ih_ipl, ih->ih_ipl);
1233: #endif
1234: return (-1);
1235: }
1236: }
1237:
1238: evcount_attach(&ih->ih_count, name, &ih->ih_ipl, &evcount_intr);
1239: SLIST_INSERT_HEAD(list, ih, ih_link);
1240: return (0);
1241: }
1242:
1243: #ifdef DDB
1244: #include <sys/reboot.h>
1245: #include <machine/db_machdep.h>
1246: #include <ddb/db_command.h>
1247:
1248: void db_prom_cmd(db_expr_t, int, db_expr_t, char *);
1249: void db_machine_init(void);
1250:
1251: /* ARGSUSED */
1252: void
1253: db_prom_cmd(addr, have_addr, count, modif)
1254: db_expr_t addr;
1255: int have_addr;
1256: db_expr_t count;
1257: char *modif;
1258: {
1259: doboot();
1260: }
1261:
1262: struct db_command db_machine_cmds[] = {
1263: { "prom", db_prom_cmd, 0, 0},
1264: { (char *)0,}
1265: };
1266:
1267: void
1268: db_machine_init()
1269: {
1270: db_machine_commands_install(db_machine_cmds);
1271: }
1272: #endif /* DDB */