![[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 [CSRG BSD Unix] / 43BSDReno / sys / hp300|
Return to trap.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300 |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 University of Utah. ! 3: * Copyright (c) 1982, 1986, 1990 The Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * This code is derived from software contributed to Berkeley by ! 7: * the Systems Programming Group of the University of Utah Computer ! 8: * Science Department. ! 9: * ! 10: * Redistribution is only permitted until one year after the first shipment ! 11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 12: * binary forms are permitted provided that: (1) source distributions retain ! 13: * this entire copyright notice and comment, and (2) distributions including ! 14: * binaries display the following acknowledgement: This product includes ! 15: * software developed by the University of California, Berkeley and its ! 16: * contributors'' in the documentation or other materials provided with the ! 17: * distribution and in all advertising materials mentioning features or use ! 18: * of this software. Neither the name of the University nor the names of ! 19: * its contributors may be used to endorse or promote products derived from ! 20: * this software without specific prior written permission. ! 21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 24: * ! 25: * from: Utah $Hdr: trap.c 1.28 89/09/25$ ! 26: * ! 27: * @(#)trap.c 7.7 (Berkeley) 6/25/90 ! 28: */ ! 29: ! 30: #include "cpu.h" ! 31: #include "psl.h" ! 32: #include "reg.h" ! 33: #include "pte.h" ! 34: #include "mtpr.h" ! 35: ! 36: #include "param.h" ! 37: #include "systm.h" ! 38: #include "user.h" ! 39: #include "proc.h" ! 40: #include "seg.h" ! 41: #include "trap.h" ! 42: #include "acct.h" ! 43: #include "kernel.h" ! 44: #include "vm.h" ! 45: #include "cmap.h" ! 46: #include "syslog.h" ! 47: #ifdef KTRACE ! 48: #include "ktrace.h" ! 49: #endif ! 50: ! 51: #ifdef HPUXCOMPAT ! 52: #include "../hpux/hpux.h" ! 53: #endif ! 54: ! 55: #define USER 040 /* user-mode flag added to type */ ! 56: ! 57: struct sysent sysent[]; ! 58: int nsysent; ! 59: ! 60: char *trap_type[] = { ! 61: "Bus error", ! 62: "Address error", ! 63: "Illegal instruction", ! 64: "Zero divide", ! 65: "CHK instruction", ! 66: "TRAPV instruction", ! 67: "Privilege violation", ! 68: "Trace trap", ! 69: "MMU fault", ! 70: "SSIR trap", ! 71: "Format error", ! 72: "68881 exception", ! 73: "Coprocessor violation", ! 74: "Async system trap" ! 75: }; ! 76: #define TRAP_TYPES (sizeof trap_type / sizeof trap_type[0]) ! 77: ! 78: #ifdef DEBUG ! 79: int mmudebug = 0; ! 80: #endif ! 81: ! 82: /* ! 83: * Called from the trap handler when a processor trap occurs. ! 84: */ ! 85: /*ARGSUSED*/ ! 86: trap(type, code, v, frame) ! 87: int type; ! 88: unsigned code; ! 89: register unsigned v; ! 90: struct frame frame; ! 91: { ! 92: register int i; ! 93: unsigned ucode = 0; ! 94: register struct proc *p = u.u_procp; ! 95: struct timeval syst; ! 96: unsigned ncode; ! 97: ! 98: cnt.v_trap++; ! 99: syst = u.u_ru.ru_stime; ! 100: if (USERMODE(frame.f_sr)) { ! 101: type |= USER; ! 102: u.u_ar0 = frame.f_regs; ! 103: } ! 104: switch (type) { ! 105: ! 106: default: ! 107: dopanic: ! 108: #ifdef KGDB ! 109: if (!panicstr && kgdb_trap(type, code, v, &frame)) ! 110: return; ! 111: #endif ! 112: printf("trap type %d, code = %x, v = %x\n", type, code, v); ! 113: regdump(frame.f_regs, 128); ! 114: type &= ~USER; ! 115: if ((unsigned)type < TRAP_TYPES) ! 116: panic(trap_type[type]); ! 117: panic("trap"); ! 118: ! 119: case T_BUSERR: /* kernel bus error */ ! 120: if (!u.u_pcb.pcb_onfault) ! 121: goto dopanic; ! 122: /* ! 123: * If we have arranged to catch this fault in any of the ! 124: * copy to/from user space routines, set PC to return to ! 125: * indicated location and set flag informing buserror code ! 126: * that it may need to clean up stack frame. ! 127: */ ! 128: copyfault: ! 129: frame.f_pc = (int) u.u_pcb.pcb_onfault; ! 130: frame.f_stackadj = -1; ! 131: return; ! 132: ! 133: case T_BUSERR+USER: /* bus error */ ! 134: case T_ADDRERR+USER: /* address error */ ! 135: i = SIGBUS; ! 136: break; ! 137: ! 138: #ifdef FPCOPROC ! 139: case T_COPERR: /* kernel coprocessor violation */ ! 140: #endif ! 141: case T_FMTERR: /* kernel format error */ ! 142: /* ! 143: * The user has most likely trashed the RTE or FP state info ! 144: * in the stack frame of a signal handler. ! 145: */ ! 146: type |= USER; ! 147: printf("pid %d: kernel %s exception\n", u.u_procp->p_pid, ! 148: type==T_COPERR ? "coprocessor" : "format"); ! 149: u.u_signal[SIGILL] = SIG_DFL; ! 150: i = sigmask(SIGILL); ! 151: p->p_sigignore &= ~i; ! 152: p->p_sigcatch &= ~i; ! 153: p->p_sigmask &= ~i; ! 154: i = SIGILL; ! 155: ucode = frame.f_format; /* XXX was ILL_RESAD_FAULT */ ! 156: break; ! 157: ! 158: #ifdef FPCOPROC ! 159: case T_COPERR+USER: /* user coprocessor violation */ ! 160: /* What is a proper response here? */ ! 161: ucode = 0; ! 162: i = SIGFPE; ! 163: break; ! 164: ! 165: case T_FPERR+USER: /* 68881 exceptions */ ! 166: /* ! 167: * We pass along the 68881 status register which locore stashed ! 168: * in code for us. Note that there is a possibility that the ! 169: * bit pattern of this register will conflict with one of the ! 170: * FPE_* codes defined in signal.h. Fortunately for us, the ! 171: * only such codes we use are all in the range 1-7 and the low ! 172: * 3 bits of the status register are defined as 0 so there is ! 173: * no clash. ! 174: */ ! 175: ucode = code; ! 176: i = SIGFPE; ! 177: break; ! 178: #endif ! 179: ! 180: case T_ILLINST+USER: /* illegal instruction fault */ ! 181: #ifdef HPUXCOMPAT ! 182: if (u.u_procp->p_flag & SHPUX) { ! 183: ucode = HPUX_ILL_ILLINST_TRAP; ! 184: i = SIGILL; ! 185: break; ! 186: } ! 187: /* fall through */ ! 188: #endif ! 189: case T_PRIVINST+USER: /* privileged instruction fault */ ! 190: #ifdef HPUXCOMPAT ! 191: if (u.u_procp->p_flag & SHPUX) ! 192: ucode = HPUX_ILL_PRIV_TRAP; ! 193: else ! 194: #endif ! 195: ucode = frame.f_format; /* XXX was ILL_PRIVIN_FAULT */ ! 196: i = SIGILL; ! 197: break; ! 198: ! 199: case T_ZERODIV+USER: /* Divide by zero */ ! 200: #ifdef HPUXCOMPAT ! 201: if (u.u_procp->p_flag & SHPUX) ! 202: ucode = HPUX_FPE_INTDIV_TRAP; ! 203: else ! 204: #endif ! 205: ucode = frame.f_format; /* XXX was FPE_INTDIV_TRAP */ ! 206: i = SIGFPE; ! 207: break; ! 208: ! 209: case T_CHKINST+USER: /* CHK instruction trap */ ! 210: #ifdef HPUXCOMPAT ! 211: if (u.u_procp->p_flag & SHPUX) { ! 212: /* handled differently under hp-ux */ ! 213: i = SIGILL; ! 214: ucode = HPUX_ILL_CHK_TRAP; ! 215: break; ! 216: } ! 217: #endif ! 218: ucode = frame.f_format; /* XXX was FPE_SUBRNG_TRAP */ ! 219: i = SIGFPE; ! 220: break; ! 221: ! 222: case T_TRAPVINST+USER: /* TRAPV instruction trap */ ! 223: #ifdef HPUXCOMPAT ! 224: if (u.u_procp->p_flag & SHPUX) { ! 225: /* handled differently under hp-ux */ ! 226: i = SIGILL; ! 227: ucode = HPUX_ILL_TRAPV_TRAP; ! 228: break; ! 229: } ! 230: #endif ! 231: ucode = frame.f_format; /* XXX was FPE_INTOVF_TRAP */ ! 232: i = SIGFPE; ! 233: break; ! 234: ! 235: /* ! 236: * XXX: Trace traps are a nightmare. ! 237: * ! 238: * HP-UX uses trap #1 for breakpoints, ! 239: * HPBSD uses trap #2, ! 240: * SUN 3.x uses trap #15, ! 241: * KGDB uses trap #15 (for kernel breakpoints). ! 242: * ! 243: * HPBSD and HP-UX traps both get mapped by locore.s into T_TRACE. ! 244: * SUN 3.x traps get passed through as T_TRAP15 and are not really ! 245: * supported yet. KGDB traps are also passed through as T_TRAP15 ! 246: * and are not used yet. ! 247: */ ! 248: case T_TRACE: /* kernel trace trap */ ! 249: case T_TRAP15: /* SUN (or KGDB) kernel trace trap */ ! 250: #ifdef KGDB ! 251: if (kgdb_trap(type, code, v, &frame)) ! 252: return; ! 253: #endif ! 254: frame.f_sr &= ~PSL_T; ! 255: i = SIGTRAP; ! 256: break; ! 257: ! 258: case T_TRACE+USER: /* user trace trap */ ! 259: case T_TRAP15+USER: /* SUN user trace trap */ ! 260: frame.f_sr &= ~PSL_T; ! 261: i = SIGTRAP; ! 262: break; ! 263: ! 264: case T_ASTFLT: /* system async trap, cannot happen */ ! 265: goto dopanic; ! 266: ! 267: case T_ASTFLT+USER: /* user async trap */ ! 268: astoff(); ! 269: /* ! 270: * We check for software interrupts first. This is because ! 271: * they are at a higher level than ASTs, and on a VAX would ! 272: * interrupt the AST. We assume that if we are processing ! 273: * an AST that we must be at IPL0 so we don't bother to ! 274: * check. Note that we ensure that we are at least at SIR ! 275: * IPL while processing the SIR. ! 276: */ ! 277: spl1(); ! 278: /* fall into... */ ! 279: ! 280: case T_SSIR: /* software interrupt */ ! 281: case T_SSIR+USER: ! 282: if (ssir & SIR_NET) { ! 283: siroff(SIR_NET); ! 284: cnt.v_soft++; ! 285: netintr(); ! 286: } ! 287: if (ssir & SIR_CLOCK) { ! 288: siroff(SIR_CLOCK); ! 289: cnt.v_soft++; ! 290: softclock((caddr_t)frame.f_pc, (int)frame.f_sr); ! 291: } ! 292: /* ! 293: * If this was not an AST trap, we are all done. ! 294: */ ! 295: if (type != T_ASTFLT+USER) { ! 296: cnt.v_trap--; ! 297: return; ! 298: } ! 299: spl0(); ! 300: #ifndef PROFTIMER ! 301: if ((u.u_procp->p_flag&SOWEUPC) && u.u_prof.pr_scale) { ! 302: addupc(frame.f_pc, &u.u_prof, 1); ! 303: u.u_procp->p_flag &= ~SOWEUPC; ! 304: } ! 305: #endif ! 306: goto out; ! 307: ! 308: case T_MMUFLT: /* kernel mode page fault */ ! 309: /* ! 310: * Could be caused by a page fault in one of the copy to/from ! 311: * user space routines. If so, we will have a catch address. ! 312: */ ! 313: if (!u.u_pcb.pcb_onfault) ! 314: goto dopanic; ! 315: /* fall into ... */ ! 316: ! 317: case T_MMUFLT+USER: /* page fault */ ! 318: /* ! 319: printf("trap: T_MMUFLT pid %d, code %x, v %x, pc %x, ps %x\n", ! 320: p->p_pid, code, v, frame.f_pc, frame.f_sr); ! 321: */ ! 322: if (v >= USRSTACK) { ! 323: if (type == T_MMUFLT) ! 324: goto copyfault; ! 325: i = SIGSEGV; ! 326: break; ! 327: } ! 328: ncode = code >> 16; ! 329: #if defined(HP330) || defined(HP360) || defined(HP370) ! 330: /* ! 331: * Crudely map PMMU faults into HP MMU faults. ! 332: */ ! 333: if (mmutype != MMU_HP) { ! 334: int ocode = ncode; ! 335: ncode = 0; ! 336: if (ocode & PMMU_WP) ! 337: ncode |= MMU_WPF; ! 338: else if (ocode & PMMU_INV) { ! 339: if ((ocode & PMMU_LVLMASK) == 2) ! 340: ncode |= MMU_PF; ! 341: else ! 342: ncode |= MMU_PTF; ! 343: } ! 344: /* ! 345: * RMW cycle, must load ATC by hand ! 346: */ ! 347: else if ((code & (SSW_DF|SSW_RM)) == (SSW_DF|SSW_RM)) { ! 348: #ifdef DEBUG ! 349: log(LOG_WARNING, ! 350: "RMW fault at %x: MMUSR %x SSW %x\n", ! 351: v, ocode, code & 0xFFFF); ! 352: #endif ! 353: ploadw((caddr_t)v); ! 354: return; ! 355: } ! 356: /* ! 357: * Fault with no fault bits, should indicate bad ! 358: * hardware but we see this on 340s using starbase ! 359: * sometimes (faults accessing catseye registers) ! 360: */ ! 361: else { ! 362: log(LOG_WARNING, ! 363: "Bad PMMU fault at %x: MMUSR %x SSW %x\n", ! 364: v, ocode, code & 0xFFFF); ! 365: return; ! 366: } ! 367: #ifdef DEBUG ! 368: if (mmudebug && mmudebug == p->p_pid) ! 369: printf("MMU %d: v%x, os%x, ns%x\n", ! 370: p->p_pid, v, ocode, ncode); ! 371: #endif ! 372: } ! 373: #endif ! 374: #ifdef DEBUG ! 375: if ((ncode & (MMU_PTF|MMU_PF|MMU_WPF|MMU_FPE)) == 0) { ! 376: printf("T_MMUFLT with no fault bits\n"); ! 377: goto dopanic; ! 378: } ! 379: #endif ! 380: if (ncode & MMU_PTF) { ! 381: #ifdef DEBUG ! 382: /* ! 383: * NOTE: we use a u_int instead of an ste since the ! 384: * current compiler generates bogus code for some ! 385: * bitfield operations (i.e. attempts to access last ! 386: * word of a page as a longword causing fault). ! 387: */ ! 388: extern struct ste *vtoste(); ! 389: u_int *ste = (u_int *)vtoste(p, v); ! 390: ! 391: if (*ste & SG_V) { ! 392: if (ncode & MMU_WPF) { ! 393: printf("PTF|WPF...\n"); ! 394: if (type == T_MMUFLT) ! 395: goto copyfault; ! 396: i = SIGBUS; ! 397: break; ! 398: } ! 399: printf("MMU_PTF with sg_v, ste@%x = %x\n", ! 400: ste, *ste); ! 401: goto dopanic; ! 402: } ! 403: #endif ! 404: #ifdef HPUXCOMPAT ! 405: if (ISHPMMADDR(v)) { ! 406: extern struct ste *vtoste(); ! 407: u_int *bste, *nste; ! 408: ! 409: bste = (u_int *)vtoste(p, HPMMBASEADDR(v)); ! 410: nste = (u_int *)vtoste(p, v); ! 411: if ((*bste & SG_V) && *nste == SG_NV) { ! 412: *nste = *bste; ! 413: TBIAU(); ! 414: return; ! 415: } ! 416: } ! 417: #endif ! 418: growit: ! 419: if (type == T_MMUFLT) ! 420: goto copyfault; ! 421: if (grow((unsigned)frame.f_regs[SP]) || grow(v)) ! 422: goto out; ! 423: i = SIGSEGV; ! 424: break; ! 425: } ! 426: #ifdef HPUXCOMPAT ! 427: if (ISHPMMADDR(v)) { ! 428: TBIS(v); ! 429: v = HPMMBASEADDR(v); ! 430: } ! 431: #endif ! 432: /* ! 433: * NOTE: WPF without PG_V is possible ! 434: * (e.g. attempt to write shared text which is paged out) ! 435: */ ! 436: if (ncode & MMU_WPF) { ! 437: #ifdef DEBUG ! 438: extern struct ste *vtoste(); ! 439: u_int *ste = (u_int *)vtoste(p, v); ! 440: ! 441: if (!(*ste & SG_V)) { ! 442: printf("MMU_WPF without sg_v, ste@%x = %x\n", ! 443: ste, *ste); ! 444: goto dopanic; ! 445: } ! 446: #endif ! 447: if (type == T_MMUFLT) ! 448: goto copyfault; ! 449: i = SIGBUS; ! 450: break; ! 451: } ! 452: if (ncode & MMU_PF) { ! 453: register u_int vp; ! 454: #ifdef DEBUG ! 455: extern struct ste *vtoste(); ! 456: u_int *ste = (u_int *)vtoste(p, v); ! 457: struct pte *pte; ! 458: ! 459: if (!(*ste & SG_V)) { ! 460: printf("MMU_PF without sg_v, ste@%x = %x\n", ! 461: ste, *ste); ! 462: goto dopanic; ! 463: } ! 464: #endif ! 465: vp = btop(v); ! 466: if (vp >= dptov(p, p->p_dsize) && ! 467: vp < sptov(p, p->p_ssize-1)) ! 468: goto growit; ! 469: #ifdef DEBUG ! 470: pte = vtopte(p, vp); ! 471: if (*(u_int *)pte & PG_V) { ! 472: printf("MMU_PF with pg_v, pte = %x\n", ! 473: *(u_int *)pte); ! 474: goto dopanic; ! 475: } ! 476: #endif ! 477: pagein(v, 0); ! 478: if (type == T_MMUFLT) ! 479: return; ! 480: goto out; ! 481: } ! 482: #ifdef DEBUG ! 483: printf("T_MMUFLT: unrecognized scenerio\n"); ! 484: goto dopanic; ! 485: #endif ! 486: } ! 487: trapsignal(i, ucode); ! 488: if ((type & USER) == 0) ! 489: return; ! 490: out: ! 491: p = u.u_procp; ! 492: if (i = CURSIG(p)) ! 493: psig(i); ! 494: p->p_pri = p->p_usrpri; ! 495: if (runrun) { ! 496: /* ! 497: * Since we are u.u_procp, clock will normally just change ! 498: * our priority without moving us from one queue to another ! 499: * (since the running process is not on a queue.) ! 500: * If that happened after we setrq ourselves but before we ! 501: * swtch()'ed, we might not be on the queue indicated by ! 502: * our priority. ! 503: */ ! 504: (void) splclock(); ! 505: setrq(p); ! 506: u.u_ru.ru_nivcsw++; ! 507: swtch(); ! 508: if (i = CURSIG(p)) ! 509: psig(i); ! 510: } ! 511: if (u.u_prof.pr_scale) { ! 512: int ticks; ! 513: struct timeval *tv = &u.u_ru.ru_stime; ! 514: ! 515: ticks = ((tv->tv_sec - syst.tv_sec) * 1000 + ! 516: (tv->tv_usec - syst.tv_usec) / 1000) / (tick / 1000); ! 517: if (ticks) { ! 518: #ifdef PROFTIMER ! 519: extern int profscale; ! 520: addupc(frame.f_pc, &u.u_prof, ticks * profscale); ! 521: #else ! 522: addupc(frame.f_pc, &u.u_prof, ticks); ! 523: #endif ! 524: } ! 525: } ! 526: curpri = p->p_pri; ! 527: } ! 528: ! 529: /* ! 530: * Called from the trap handler when a system call occurs ! 531: */ ! 532: /*ARGSUSED*/ ! 533: syscall(code, frame) ! 534: volatile int code; ! 535: struct frame frame; ! 536: { ! 537: register caddr_t params; ! 538: register int i; ! 539: register struct sysent *callp; ! 540: register struct proc *p = u.u_procp; ! 541: int error, opc, numsys; ! 542: struct args { ! 543: int i[8]; ! 544: } args; ! 545: int rval[2]; ! 546: struct timeval syst; ! 547: struct sysent *systab; ! 548: #ifdef HPUXCOMPAT ! 549: extern struct sysent hpuxsysent[]; ! 550: extern int hpuxnsysent, notimp(); ! 551: #endif ! 552: ! 553: cnt.v_syscall++; ! 554: syst = u.u_ru.ru_stime; ! 555: if (!USERMODE(frame.f_sr)) ! 556: panic("syscall"); ! 557: u.u_ar0 = frame.f_regs; ! 558: opc = frame.f_pc - 2; ! 559: systab = sysent; ! 560: numsys = nsysent; ! 561: #ifdef HPUXCOMPAT ! 562: if (p->p_flag & SHPUX) { ! 563: systab = hpuxsysent; ! 564: numsys = hpuxnsysent; ! 565: } ! 566: #endif ! 567: params = (caddr_t)frame.f_regs[SP] + NBPW; ! 568: if (code == 0) { /* indir */ ! 569: code = fuword(params); ! 570: params += NBPW; ! 571: } ! 572: if (code >= numsys) ! 573: callp = &systab[0]; /* indir (illegal) */ ! 574: else ! 575: callp = &systab[code]; ! 576: if ((i = callp->sy_narg * sizeof (int)) && ! 577: (error = copyin(params, (caddr_t)&args, (u_int)i))) { ! 578: #ifdef HPUXCOMPAT ! 579: if (p->p_flag & SHPUX) ! 580: error = bsdtohpuxerrno(error); ! 581: #endif ! 582: frame.f_regs[D0] = (u_char) error; ! 583: frame.f_sr |= PSL_C; /* carry bit */ ! 584: #ifdef KTRACE ! 585: if (KTRPOINT(p, KTR_SYSCALL)) ! 586: ktrsyscall(p->p_tracep, code, callp->sy_narg, args.i); ! 587: #endif ! 588: goto done; ! 589: } ! 590: #ifdef KTRACE ! 591: if (KTRPOINT(p, KTR_SYSCALL)) ! 592: ktrsyscall(p->p_tracep, code, callp->sy_narg, args.i); ! 593: #endif ! 594: rval[0] = 0; ! 595: rval[1] = frame.f_regs[D1]; ! 596: #ifdef HPUXCOMPAT ! 597: /* debug kludge */ ! 598: if (callp->sy_call == notimp) ! 599: error = notimp(u.u_procp, args.i, rval, code, callp->sy_narg); ! 600: else ! 601: #endif ! 602: error = (*callp->sy_call)(u.u_procp, &args, rval); ! 603: if (error == ERESTART) ! 604: frame.f_pc = opc; ! 605: else if (error != EJUSTRETURN) { ! 606: if (error) { ! 607: #ifdef HPUXCOMPAT ! 608: if (p->p_flag & SHPUX) ! 609: error = bsdtohpuxerrno(error); ! 610: #endif ! 611: frame.f_regs[D0] = (u_char) error; ! 612: frame.f_sr |= PSL_C; /* carry bit */ ! 613: } else { ! 614: frame.f_regs[D0] = rval[0]; ! 615: frame.f_regs[D1] = rval[1]; ! 616: frame.f_sr &= ~PSL_C; ! 617: } ! 618: } ! 619: /* else if (error == EJUSTRETURN) */ ! 620: /* nothing to do */ ! 621: ! 622: done: ! 623: /* ! 624: * Reinitialize proc pointer `p' as it may be different ! 625: * if this is a child returning from fork syscall. ! 626: */ ! 627: p = u.u_procp; ! 628: /* ! 629: * XXX the check for sigreturn ensures that we don't ! 630: * attempt to set up a call to a signal handler (sendsig) before ! 631: * we have cleaned up the stack from the last call (sigreturn). ! 632: * Allowing this seems to lock up the machine in certain scenarios. ! 633: * What should really be done is to clean up the signal handling ! 634: * so that this is not a problem. ! 635: */ ! 636: #include "syscall.h" ! 637: if (code != SYS_sigreturn && (i = CURSIG(p))) ! 638: psig(i); ! 639: p->p_pri = p->p_usrpri; ! 640: if (runrun) { ! 641: /* ! 642: * Since we are u.u_procp, clock will normally just change ! 643: * our priority without moving us from one queue to another ! 644: * (since the running process is not on a queue.) ! 645: * If that happened after we setrq ourselves but before we ! 646: * swtch()'ed, we might not be on the queue indicated by ! 647: * our priority. ! 648: */ ! 649: (void) splclock(); ! 650: setrq(p); ! 651: u.u_ru.ru_nivcsw++; ! 652: swtch(); ! 653: if (code != SYS_sigreturn && (i = CURSIG(p))) ! 654: psig(i); ! 655: } ! 656: if (u.u_prof.pr_scale) { ! 657: int ticks; ! 658: struct timeval *tv = &u.u_ru.ru_stime; ! 659: ! 660: ticks = ((tv->tv_sec - syst.tv_sec) * 1000 + ! 661: (tv->tv_usec - syst.tv_usec) / 1000) / (tick / 1000); ! 662: if (ticks) { ! 663: #ifdef PROFTIMER ! 664: extern int profscale; ! 665: addupc(frame.f_pc, &u.u_prof, ticks * profscale); ! 666: #else ! 667: addupc(frame.f_pc, &u.u_prof, ticks); ! 668: #endif ! 669: } ! 670: } ! 671: curpri = p->p_pri; ! 672: #ifdef KTRACE ! 673: if (KTRPOINT(p, KTR_SYSRET)) ! 674: ktrsysret(p->p_tracep, code, error, rval[0]); ! 675: #endif ! 676: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.