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