![[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 [MW Coherent from dump] / coherent / b / STREAMS / i386|
Return to trap.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / i386 |
1.1 ! root 1: /* (lgl- ! 2: * COHERENT Version 4.0 ! 3: * Copyright (c) 1982, 1992. ! 4: * An unpublished work by Mark Williams Company, Chicago. ! 5: * All rights reserved. ! 6: -lgl) */ ! 7: ! 8: #include <common/_gregset.h> ! 9: #include <kernel/systab.h> ! 10: ! 11: #include <sys/coherent.h> ! 12: #include <sys/errno.h> ! 13: #include <sys/proc.h> ! 14: #include <sys/seg.h> ! 15: #include <signal.h> ! 16: ! 17: /* opcodes recognized, and partially emulated, in gp fault handler */ ! 18: #define READ_CR0 1 ! 19: #define WRITE_CR0 2 ! 20: #define READ_CR2 3 ! 21: #define READ_CR3 4 ! 22: #define WRITE_CR3 5 ! 23: #define HALT 6 ! 24: #define IRET 7 ! 25: #define READ_DR0 8 ! 26: #define READ_DR1 9 ! 27: #define READ_DR2 10 ! 28: #define READ_DR3 11 ! 29: #define READ_DR6 12 ! 30: #define READ_DR7 13 ! 31: #define WRITE_DR0 14 ! 32: #define WRITE_DR1 15 ! 33: #define WRITE_DR2 16 ! 34: #define WRITE_DR3 17 ! 35: #define WRITE_DR6 18 ! 36: #define WRITE_DR7 19 ! 37: ! 38: #define ENTER_OP 0xC8 /* Opcode for 'enter' instruction. */ ! 39: #define IRET_RETRY_LIM 10 ! 40: #define RESUME_FLAG 0x10000 /* RF bit in PSW */ ! 41: #define TRAP_FLAG 0x00100 /* TF bit in PSW */ ! 42: ! 43: extern unsigned char selkcopy(); ! 44: extern unsigned int DR0,DR1,DR2,DR3,DR7; ! 45: static int trap_op(); ! 46: ! 47: ! 48: /* ! 49: * Global symbols from kernel text. ! 50: */ ! 51: ! 52: extern unsigned int _Idle; ! 53: extern unsigned int __xtrap_break__; ! 54: extern unsigned int __xtrap_off__; ! 55: extern unsigned int __xtrap_on__; ! 56: extern unsigned int sig32; ! 57: extern unsigned int syc32; ! 58: ! 59: /* ! 60: * iret_flt is set when first bad iret is detected. ! 61: */ ! 62: static int iret_flt; ! 63: ! 64: /* ! 65: * Trap handler. ! 66: * The arguments are the registers, ! 67: * saved on the stack by machine code. This call ! 68: * is different from most C calls in that the registers ! 69: * get copied back; if you change a "trap" parameter then ! 70: * the machine register will be altered when the trap is ! 71: * dismissed. ! 72: * ! 73: * Argument "trapno" is the return eip for the code calling tsave(). ! 74: */ ! 75: ! 76: void ! 77: trap (regset) ! 78: gregset_t regset; ! 79: { ! 80: register struct systab *stp; ! 81: register int sigcode; ! 82: extern int trapcode; ! 83: extern *mmdata[], mminit; ! 84: cseg_t *pp; ! 85: register SEG *segp; ! 86: int splo, datahi; ! 87: unsigned int txtlo, txthi; ! 88: unsigned int cr2 = 0; ! 89: unsigned int cpl = regset._i386._cs & SEG_PL; ! 90: ! 91: if (regset._i386._err == SINMI) { ! 92: printf ("Parity error\n"); ! 93: curr_register_dump (& regset); ! 94: #if 0 ! 95: panic("..."); ! 96: #else ! 97: return; ! 98: #endif ! 99: } ! 100: ! 101: /* ! 102: * Expect this to never happen! ! 103: */ ! 104: if (SELF->p_flags & PFKERN) { ! 105: panic ("pid%d: kernel process trap: err=%x, ip=%x ax=%d", ! 106: SELF->p_pid, regset._i386._err, regset._i386._eip, ! 107: regset._i386._eax); ! 108: } ! 109: ! 110: T_HAL (0x4000, printf ("T%d ", regset._i386._err)); ! 111: sigcode = 0; ! 112: ! 113: #if 0 ! 114: u.u_regl = & regset; /* hook in register set for consave/conrest */ ! 115: #endif ! 116: ! 117: switch (regset._i386._err) { ! 118: case SIOSYS: ! 119: /* ! 120: * 286 System call. ! 121: */ ! 122: sigcode = oldsys (& regset); ! 123: break; ! 124: ! 125: case SISYS: { ! 126: long args [MSACOUNT]; ! 127: unsigned callnum; ! 128: ! 129: /* ! 130: * 386 System call. ! 131: */ ! 132: u.u_error = 0; ! 133: callnum = regset._i386._eax; ! 134: ! 135: T_PIGGY (4, printf ("{%d", callnum)); ! 136: ! 137: if (callnum < NMICALL) ! 138: stp = sysitab + callnum; ! 139: else if (callnum == COHCALL) ! 140: stp = & cohcall; ! 141: else if ((callnum & 0xFF) == 0x28 && ! 142: (callnum >> 8) <= H28CALL) ! 143: stp = h28itab + (callnum >> 8) - 1; ! 144: else { ! 145: sigcode = SIGSYS; ! 146: goto trapend; ! 147: } ! 148: ! 149: ukcopy (regset._i386._uesp + sizeof (long), args, ! 150: stp->s_nargs * sizeof (long)); ! 151: ! 152: if (u.u_error) { ! 153: sigcode = SIGSYS; ! 154: goto trapend; ! 155: } ! 156: ! 157: /* ! 158: * NIGEL: This is sleazy and stupid, and must go ASAP. We ! 159: * must learn to initialize structures properly. ! 160: */ ! 161: ! 162: #if 0 ! 163: u.u_io.io_seg = IOUSR; ! 164: #endif ! 165: ! 166: if (envsave (& u.u_sigenv)) { ! 167: u.u_error = EINTR; ! 168: } else { ! 169: regset._i386._eax = __DOSYSCALL (stp->s_nargs, ! 170: stp->s_func, args, ! 171: & regset); ! 172: regset._i386._edx = u.u_rval2; ! 173: } ! 174: ! 175: if (u.u_error) { ! 176: regset._i386._eax = u.u_error; ! 177: regset._i386._eflags |= MFCBIT; ! 178: } else /* clear carry flag in return efl */ ! 179: regset._i386._eflags &= ~ MFCBIT; ! 180: ! 181: T_PIGGY (0x04, printf ("=%x}", regset._i386._eax)); ! 182: break; ! 183: } /* end block */ ! 184: ! 185: /* ! 186: * Trap. ! 187: */ ! 188: case SIDIV: ! 189: #ifdef TRACER ! 190: printf ("Integer divide by zero"); ! 191: curr_register_dump (& regset); ! 192: #endif ! 193: sigcode = SIGFPE; ! 194: break; ! 195: ! 196: case SISST: ! 197: sigcode = SIGTRAP; ! 198: break; ! 199: ! 200: case SIBPT: ! 201: sigcode = SIGTRAP; ! 202: break; ! 203: ! 204: case SIOVF: ! 205: sigcode = SIGEMT; ! 206: break; ! 207: ! 208: case SIBND: ! 209: /* ! 210: * Bound ! 211: */ ! 212: sigcode = SIGIOT; ! 213: break; ! 214: ! 215: case SIOP: ! 216: /* ! 217: * Invalid opcode ! 218: */ ! 219: if (cpl < 2) { ! 220: int * ip = (int *) regset._i386._eip; ! 221: ! 222: curr_register_dump (& regset); ! 223: printf ("(eip)=%x %x %x ", ip [0], ip [1], ip [2]); ! 224: panic ("Invalid Opcode"); ! 225: } ! 226: sigcode = SIGILL; ! 227: break; ! 228: ! 229: #if 0 ! 230: case SIXNP: ! 231: /* ! 232: * Processor extension not available ! 233: */ ! 234: if (int11() & 2) /* NDP present */ ! 235: ndpNewOwner(); ! 236: else ! 237: sigcode = SIGFPE; ! 238: break; ! 239: #endif ! 240: ! 241: case SIDBL: ! 242: /* ! 243: * Double exception ! 244: */ ! 245: panic ("double exception: cs=%x ip=%x", regset._i386._cs, ! 246: regset._i386._eip); ! 247: sigcode = SIGSEGV; ! 248: break; ! 249: ! 250: case SIXS: ! 251: /* ! 252: * Processor extension segment overrun ! 253: */ ! 254: sigcode = SIGSEGV; ! 255: break; ! 256: ! 257: case SITS: ! 258: /* ! 259: * Invalid task state segment ! 260: */ ! 261: panic ("invalid tss: cs=%x ip=%x", regset._i386._cs, ! 262: regset._i386._eip); ! 263: sigcode = SIGSEGV; ! 264: break; ! 265: ! 266: case SINP: ! 267: /* ! 268: * Segment not present ! 269: */ ! 270: sigcode = SIGSEGV; ! 271: break; ! 272: ! 273: case SISS: ! 274: /* ! 275: * Stack segment overrun/not present ! 276: */ ! 277: sigcode = SIGKILL; ! 278: break; ! 279: ! 280: default: ! 281: curr_register_dump (& regset); ! 282: panic("Fatal Trap"); ! 283: } ! 284: ! 285: trapend: ! 286: /* ! 287: * Send user a signal. ! 288: * If not a breakpoint, do console register dump. ! 289: */ ! 290: if (sigcode) { ! 291: if (sigcode != SIGTRAP) { ! 292: curr_register_dump (& regset); ! 293: printf("sigcode=#%d User Trap\n", sigcode); ! 294: } ! 295: sendsig (sigcode, SELF); ! 296: } ! 297: } ! 298: ! 299: /* ! 300: * trap_op() ! 301: * ! 302: * Look at the trapped instruction. ! 303: * If it's one of a select few, recognize and return the type. ! 304: * Otherwise, return 0. ! 305: * ! 306: * This could be fancier, but all we want to look for is: ! 307: * (for CRx and DRx, second operand is limited to %eax). ! 308: * 0F 20 C0 READ_CR0 ! 309: * 0F 22 C0 WRITE_CR0 ! 310: * 0F 20 D0 READ_CR2 ! 311: * 0F 20 D8 READ_CR3 ! 312: * 0F 22 D8 WRITE_CR3 ! 313: * CF IRET ! 314: * F4 HALT ! 315: * 0F 23 C0 WRITE_DR0 ! 316: * 0F 23 C8 WRITE_DR1 ! 317: * 0F 23 D0 WRITE_DR2 ! 318: * 0F 23 D8 WRITE_DR3 ! 319: * 0F 23 F0 WRITE_DR6 ! 320: * 0F 23 F8 WRITE_DR7 ! 321: * 0F 21 C0 READ_DR0 ! 322: * 0F 21 C8 READ_DR1 ! 323: * 0F 21 D0 READ_DR2 ! 324: * 0F 21 D8 READ_DR3 ! 325: * 0F 21 F0 READ_DR6 ! 326: * 0F 21 F8 READ_DR7 ! 327: */ ! 328: static int ! 329: trap_op(cs,eip) ! 330: unsigned int cs, eip; ! 331: { ! 332: int ret = 0; ! 333: ! 334: switch (ffbyte (eip, cs)) { ! 335: case 0x0F: ! 336: switch (ffbyte (eip + 1, cs)) { ! 337: case 0x20: ! 338: switch (ffbyte (eip + 2, cs)) { ! 339: case 0xC0: ! 340: ret = READ_CR0; ! 341: break; ! 342: case 0xD0: ! 343: ret = READ_CR2; ! 344: break; ! 345: case 0xD8: ! 346: ret = READ_CR3; ! 347: break; ! 348: } ! 349: break; ! 350: case 0x21: ! 351: switch (ffbyte (eip + 2, cs)) { ! 352: case 0xC0: ! 353: ret = READ_DR0; ! 354: break; ! 355: case 0xC8: ! 356: ret = READ_DR1; ! 357: break; ! 358: case 0xD0: ! 359: ret = READ_DR2; ! 360: break; ! 361: case 0xD8: ! 362: ret = READ_DR3; ! 363: break; ! 364: case 0xF0: ! 365: ret = READ_DR6; ! 366: break; ! 367: case 0xF8: ! 368: ret = READ_DR7; ! 369: break; ! 370: } ! 371: break; ! 372: case 0x22: ! 373: switch (ffbyte (eip + 2, cs)) { ! 374: case 0xC0: ! 375: ret = WRITE_CR0; ! 376: break; ! 377: case 0xD8: ! 378: ret = WRITE_CR3; ! 379: break; ! 380: } ! 381: break; ! 382: case 0x23: ! 383: switch (ffbyte (eip + 2, cs)) { ! 384: case 0xC0: ! 385: ret = WRITE_DR0; ! 386: break; ! 387: case 0xC8: ! 388: ret = WRITE_DR1; ! 389: break; ! 390: case 0xD0: ! 391: ret = WRITE_DR2; ! 392: break; ! 393: case 0xD8: ! 394: ret = WRITE_DR3; ! 395: break; ! 396: case 0xF0: ! 397: ret = WRITE_DR6; ! 398: break; ! 399: case 0xF8: ! 400: ret = WRITE_DR7; ! 401: break; ! 402: } ! 403: break; ! 404: } ! 405: break; ! 406: case 0xF4: ! 407: ret = HALT; ! 408: break; ! 409: case 0xCF: ! 410: ret = IRET; ! 411: break; ! 412: } ! 413: return ret; ! 414: } ! 415: ! 416: /* ! 417: * Kernel debugger. ! 418: * ! 419: * Runs in ring 0. ! 420: */ ! 421: ! 422: void ! 423: __debug_ker__ (regset) ! 424: gregset_t regset; ! 425: { ! 426: unsigned int dr6 = read_dr6 (); ! 427: unsigned cpl = regset._i386._cs & SEG_PL; ! 428: int do_rdump = 1; ! 429: ! 430: if (dr6 & 0xf) { /* report breakpoint exception(s) */ ! 431: printf("Breakpoint "); ! 432: if (dr6 & 1) ! 433: printf("DR0=%x ", DR0); ! 434: if (dr6 & 2) ! 435: printf("DR1=%x ", DR1); ! 436: if (dr6 & 4) ! 437: printf("DR2=%x ", DR2); ! 438: if (dr6 & 8) ! 439: printf("DR3=%x ", DR3); ! 440: printf("DR7=%x\n", DR7); ! 441: } ! 442: ! 443: if (dr6 & 0xf000) { /* report other debug exception(s) */ ! 444: if (dr6 & 0x8000) ! 445: printf("Switch to debugged task\n"); ! 446: ! 447: if (dr6 & 0x4000) { ! 448: /* Single Step */ ! 449: switch (cpl) { ! 450: /* ! 451: * If user code trapped, send signal ! 452: * and suppress console register dump. ! 453: */ ! 454: case DPL_1: ! 455: /* ! 456: * Turn off single-stepping when entering ! 457: * Ring 1. ! 458: */ ! 459: if (regset._i386._eip == & syc32 || ! 460: regset._i386._eip == & sig32) { ! 461: do_rdump = 0; ! 462: } else { ! 463: printf("\nefl=%x No single stepping the kernel.\n", regset._i386._eflags); ! 464: } ! 465: regset._i386._eflags &= ~TRAP_FLAG; ! 466: break; ! 467: case DPL_3: ! 468: do_rdump = 0; ! 469: T_HAL(0x20000, printf ("Kernel SSTEP eip=%x efl=%x ", regset._i386._eip, ! 470: regset._i386._eflags)); ! 471: sendsig (SIGTRAP, SELF); ! 472: break; ! 473: } ! 474: } ! 475: if (dr6 & 0x2000) { ! 476: printf("ICE in use\n"); ! 477: regset._i386._eip += 3; ! 478: } ! 479: } ! 480: ! 481: if (do_rdump) ! 482: curr_register_dump (& regset); ! 483: ! 484: write_dr6 (0); ! 485: regset._i386._eflags |= RESUME_FLAG; ! 486: return; ! 487: } ! 488: ! 489: /* ! 490: * General protection fault handler. ! 491: * Entered via a ring 0 gate. ! 492: */ ! 493: ! 494: void ! 495: gpfault (regset) ! 496: gregset_t regset; ! 497: { ! 498: unsigned cpl = regset._i386._cs & SEG_PL; ! 499: ! 500: /* ! 501: * Switch on CPL of code that trapped. ! 502: */ ! 503: ! 504: switch(cpl) { ! 505: case DPL_0: ! 506: /* ! 507: * Ring 0 should not gp fault. ! 508: */ ! 509: curr_register_dump (& regset); ! 510: panic ("System GP Fault from Ring 0"); ! 511: break; ! 512: ! 513: case DPL_1: ! 514: /* ! 515: * If ring 1 faulted on a valid request, emulate the ! 516: * request while running in ring 0. ! 517: */ ! 518: switch (trap_op (regset._i386._cs, regset._i386._eip)) { ! 519: case READ_CR0: ! 520: regset._i386._eax = read_cr0 (); ! 521: regset._i386._eip += 3; ! 522: break; ! 523: #if 0 ! 524: case WRITE_CR0: ! 525: if (eax & 4) ! 526: setfpe (0); ! 527: else ! 528: setfpe (1); ! 529: eip += 3; ! 530: break; ! 531: #endif ! 532: case READ_CR2: ! 533: regset._i386._eax = read_cr2 (); ! 534: regset._i386._eip += 3; ! 535: break; ! 536: ! 537: case READ_CR3: ! 538: regset._i386._eax = read_cr3 (); ! 539: regset._i386._eip += 3; ! 540: break; ! 541: #if 0 ! 542: case WRITE_CR3: ! 543: mmuupdnR0 (); ! 544: eip += 3; ! 545: break; ! 546: #endif ! 547: case IRET: ! 548: /* ! 549: * Some CPU's wrongly generate GP faults on IRET ! 550: * from inner ring to ring 3. ! 551: * Fix is to retry the instruction a few times. ! 552: */ ! 553: if (! iret_flt) { ! 554: iret_flt = 1; ! 555: printf ("CPU Bug: " ! 556: "Spurious GP Fault on Iret to Ring 3.\n"); ! 557: } ! 558: break; ! 559: ! 560: case READ_DR0: ! 561: regset._i386._eax = read_dr0 (); ! 562: regset._i386._eip += 3; ! 563: break; ! 564: ! 565: case READ_DR1: ! 566: regset._i386._eax = read_dr1 (); ! 567: regset._i386._eip += 3; ! 568: break; ! 569: ! 570: case READ_DR2: ! 571: regset._i386._eax = read_dr2 (); ! 572: regset._i386._eip += 3; ! 573: break; ! 574: ! 575: case READ_DR3: ! 576: regset._i386._eax = read_dr3 (); ! 577: regset._i386._eip += 3; ! 578: break; ! 579: ! 580: case READ_DR6: ! 581: regset._i386._eax = read_dr6 (); ! 582: regset._i386._eip += 3; ! 583: break; ! 584: ! 585: case READ_DR7: ! 586: regset._i386._eax = read_dr7 (); ! 587: regset._i386._eip += 3; ! 588: break; ! 589: ! 590: case WRITE_DR0: ! 591: write_dr0 (regset._i386._eax); ! 592: regset._i386._eip += 3; ! 593: break; ! 594: ! 595: case WRITE_DR1: ! 596: write_dr1 (regset._i386._eax); ! 597: regset._i386._eip += 3; ! 598: break; ! 599: ! 600: case WRITE_DR2: ! 601: write_dr2 (regset._i386._eax); ! 602: regset._i386._eip += 3; ! 603: break; ! 604: ! 605: case WRITE_DR3: ! 606: write_dr3 (regset._i386._eax); ! 607: regset._i386._eip += 3; ! 608: break; ! 609: ! 610: case WRITE_DR6: ! 611: write_dr6 (regset._i386._eax); ! 612: regset._i386._eip += 3; ! 613: break; ! 614: ! 615: case WRITE_DR7: ! 616: write_dr7 (regset._i386._eax); ! 617: regset._i386._eip += 3; ! 618: break; ! 619: ! 620: case HALT: ! 621: halt (); ! 622: break; ! 623: #if 0 ! 624: case WRITE_DR7: ! 625: /* ! 626: * Expect breakpoint info in globals DR0-3,DR7. ! 627: */ ! 628: printf("Setting DR0=%x DR1=%x DR2=%x DR3=%x DR7=%x\n", ! 629: DR0, DR1, DR2, DR3, DR7); ! 630: write_dr0 (DR0); ! 631: write_dr1 (DR1); ! 632: write_dr2 (DR2); ! 633: write_dr3 (DR3); ! 634: write_dr7 (DR7); ! 635: regset._i386._eip += 3; ! 636: break; ! 637: #endif ! 638: default: ! 639: if (regset._i386._eip >= & __xtrap_on__ && ! 640: regset._i386._eip < & __xtrap_off__) { ! 641: #ifdef TRACER ! 642: curr_register_dump (& regset); ! 643: printf ("copy fault called from %x\n", ! 644: * (int *) regset._i386._edx); ! 645: #endif ! 646: SET_U_ERROR (EFAULT, "copy gp"); ! 647: regset._i386._eip = & __xtrap_break__; ! 648: } else { ! 649: curr_register_dump (& regset); ! 650: panic ("System GP Fault from Ring 1"); ! 651: } ! 652: } ! 653: goto gpdone; ! 654: break; ! 655: ! 656: case DPL_2: ! 657: /* ! 658: * Nothing should be running in Ring 2. ! 659: */ ! 660: ! 661: case DPL_3: ! 662: /* ! 663: * Ring 3 gp fault means errant user process. ! 664: */ ! 665: curr_register_dump (& regset); ! 666: printf ("User GP Violation\n"); ! 667: sendsig (SIGSEGV, SELF); ! 668: break; ! 669: } ! 670: gpdone: ! 671: return; ! 672: } ! 673: ! 674: ! 675: /* ! 676: * User debugger. ! 677: * ! 678: * Runs in ring 1. ! 679: */ ! 680: ! 681: void ! 682: __debug_usr__ (regset) ! 683: gregset_t regset; ! 684: { ! 685: unsigned int dr6 = read_dr6(); ! 686: unsigned cpl = regset._i386._cs & SEG_PL; ! 687: int do_rdump = 1; ! 688: ! 689: if (dr6 & 0xf) { /* report breakpoint exception(s) */ ! 690: printf("Breakpoint "); ! 691: if (dr6 & 1) ! 692: printf("DR0=%x ", DR0); ! 693: if (dr6 & 2) ! 694: printf("DR1=%x ", DR1); ! 695: if (dr6 & 4) ! 696: printf("DR2=%x ", DR2); ! 697: if (dr6 & 8) ! 698: printf("DR3=%x ", DR3); ! 699: printf("DR7=%x\n", DR7); ! 700: } ! 701: ! 702: if (dr6 & 0xf000) { /* report other debug exception(s) */ ! 703: if (dr6 & 0x8000) ! 704: printf("Switch to debugged task\n"); ! 705: ! 706: if (dr6 & 0x4000) { ! 707: /* Single Step */ ! 708: switch(cpl) { ! 709: /* ! 710: * If user code trapped, send signal ! 711: * and suppress console register dump. ! 712: */ ! 713: case DPL_1: ! 714: /* ! 715: * Turn off single-stepping when entering ! 716: * Ring 1. ! 717: */ ! 718: if (regset._i386._eip == & syc32 || ! 719: regset._i386._eip == & sig32) { ! 720: do_rdump = 0; ! 721: } else { ! 722: printf("/nefl=%x No single stepping the kernel.\n", regset._i386._eflags); ! 723: } ! 724: regset._i386._eflags &= ~TRAP_FLAG; ! 725: break; ! 726: ! 727: case DPL_3: ! 728: do_rdump = 0; ! 729: T_HAL(0x20000, printf ("User SSTEP eip=%x efl=%x ", regset._i386._eip, ! 730: regset._i386._eflags)); ! 731: sendsig (SIGTRAP, SELF); ! 732: break; ! 733: } ! 734: } ! 735: if (dr6 & 0x2000) { ! 736: printf("ICE in use\n"); ! 737: regset._i386._eip += 3; ! 738: } ! 739: } ! 740: ! 741: if (do_rdump) ! 742: curr_register_dump (& regset); ! 743: ! 744: write_dr6 (0); ! 745: regset._i386._eflags |= RESUME_FLAG; ! 746: return; ! 747: } ! 748: ! 749: irqblab (regset) ! 750: gregset_t regset; ! 751: { ! 752: puts("*ip="); ! 753: print32 (regset._i386._eip); ! 754: puts(" *err="); ! 755: print32 (regset._i386._err); ! 756: ! 757: if ((regset._i386._err & 0xff) == 0x40) { ! 758: int irqno = (regset._i386._err >> 8) & 0xFF; ! 759: print8 (irqno); ! 760: } else if (regset._i386._err == 2) ! 761: puts("NMI "); ! 762: } ! 763: ! 764: void ! 765: pagefault (regset) ! 766: gregset_t regset; ! 767: { ! 768: register struct systab *stp; ! 769: register int callnum; ! 770: register int sigcode; ! 771: extern int trapcode; ! 772: extern *mmdata[], mminit; ! 773: cseg_t *pp; ! 774: register SEG *segp; ! 775: int splo, datahi; ! 776: unsigned int txtlo, txthi; ! 777: unsigned long newsp; /* Anticipated value for stack pointer. */ ! 778: unsigned int cr2 = 0; ! 779: unsigned int cpl = regset._i386._cs & SEG_PL; ! 780: ! 781: /* ! 782: * Expect this to never happen! ! 783: */ ! 784: ! 785: if (SELF->p_flags & PFKERN) { ! 786: panic ("pid%d: kernel process trap: err=%x, ip=%x ax=%d", ! 787: SELF->p_pid, regset._i386._err, regset._i386._eip, ! 788: regset._i386._eax); ! 789: } ! 790: ! 791: T_HAL (0x4000, printf("T%d ", regset._i386._err)); ! 792: sigcode = 0; ! 793: ! 794: #if 0 ! 795: u.u_regl = &gs; /* hook in register set for consave/conrest */ ! 796: #endif ! 797: ! 798: /* ! 799: * Page fault ! 800: */ ! 801: ! 802: cr2 = read_cr2 (); ! 803: if (cpl < 2) { ! 804: /* ! 805: * If page fault during Ring 1 copy service routine, ! 806: * such as kucopy or ukcopy, set u_error and abort ! 807: * the copy, but don't send signal to the user. ! 808: */ ! 809: ! 810: if (regset._i386._eip >= & __xtrap_on__ && ! 811: regset._i386._eip < & __xtrap_off__) { ! 812: ! 813: T_HAL (0x1000, printf ("copy trapped ")); ! 814: #ifdef TRACER ! 815: curr_register_dump (& regset); ! 816: printf ("copy fault called from %x\n", ! 817: * (int *) regset._i386._edx); ! 818: #endif ! 819: SET_U_ERROR (EFAULT, "copy service"); ! 820: regset._i386._eip = & __xtrap_break__; ! 821: goto pf_end; ! 822: } else { ! 823: printf ("cr2=%x", cr2); ! 824: curr_register_dump (& regset); ! 825: panic ("Kernel Page Fault"); ! 826: } ! 827: } ! 828: ! 829: /* Check for stack underflow. */ ! 830: ! 831: /* ! 832: * I think 'splo' is being calculated in a bass-ackwards way, ! 833: * and that 'datahi' is just wrong, but I'm not certain, ! 834: * so the fixes are #if 0'd out. -piggy ! 835: * ! 836: * I'll take out the 0 some day and test these changes. ! 837: */ ! 838: segp = u.u_segl [SISTACK].sr_segp; ! 839: #if 0 ! 840: splo = u.u_segl [SISTACK].sr_base - segp->s_size; ! 841: datahi = u.u_segl [SIPDATA].sr_base + u.u_segl [SIPDATA].sr_size; ! 842: #else ! 843: splo = __xmode_286 (& regset) ? ISP_286 : ISP_386; ! 844: splo -= segp->s_size; ! 845: datahi = u.u_segl [SIPDATA].sr_size; ! 846: #endif /* 0 */ ! 847: ! 848: /* ! 849: * Catch bad function pointer here - don't want to restart ! 850: * the user instruction and get runaway segv's. ! 851: * ! 852: * For 286 executables, eip starts at 0, but cs points to ! 853: * descriptor SEG_286_UII which adds 0x400000 (UII_BASE). ! 854: */ ! 855: ! 856: txtlo = u.u_segl [SISTEXT].sr_base; ! 857: if (__xmode_286 (& regset)) ! 858: txtlo -= UII_BASE; ! 859: ! 860: txthi = txtlo + u.u_segl [SISTEXT].sr_size; ! 861: if (regset._i386._eip < txtlo || ! 862: regset._i386._eip > txthi) { ! 863: T_HAL (0x1000, printf ("Bad eip, txtlo=%x txthi=%x\n", ! 864: txtlo, txthi)); ! 865: goto bad_pf; ! 866: } ! 867: ! 868: /* ! 869: * If we trapped on an 'enter' instruction, the stack ! 870: * pointer (uesp) has not yet been decremented. In ! 871: * order to correctly process such a stack overflow, ! 872: * we must look at the _expected_ value for uesp. ! 873: * NB: We COPY uesp, because that arg gets loaded back ! 874: * into the real esp--when we return from the trap the ! 875: * enter instruction will decrement the esp. ! 876: */ ! 877: ! 878: newsp = __xmode_286 (& regset) ? regset._i286._usp : ! 879: regset._i386._uesp; ! 880: ! 881: if (ffbyte (regset._i386._eip, regset._i386._cs) == ENTER_OP) { ! 882: /* ! 883: * Adjust the sp by the argument of the ENTER ! 884: * instruction. ! 885: */ ! 886: ! 887: newsp -= ffword (regset._i386._eip + 1, regset._i386._cs); ! 888: } ! 889: ! 890: if (cr2 <= splo && newsp <= splo && newsp > datahi && ! 891: btoc (datahi) < btocrd (splo)) { ! 892: ! 893: pp = c_extend(segp->s_vmem, btoc(segp->s_size)); ! 894: if (pp==0) { ! 895: T_HAL (0x1000, printf ("c_extend(%x,%x)=0 ", ! 896: segp->s_vmem, ! 897: btoc(segp->s_size))); ! 898: goto bad_pf; ! 899: } ! 900: ! 901: segp->s_vmem = pp; ! 902: segp->s_size += NBPC; ! 903: ! 904: if (sproto (0) == 0) { ! 905: T_HAL(0x1000, printf("sproto(0)=0 ")); ! 906: goto bad_pf; ! 907: } ! 908: ! 909: segload (); ! 910: goto pf_end; ! 911: } ! 912: ! 913: /* ! 914: * Catch bad data pointer here - don't want to restart ! 915: * the user instruction and get runaway segv's. ! 916: */ ! 917: ! 918: { ! 919: T_HAL(0x1000, printf ("Bad data, splo=%x datahi=%x\n", ! 920: splo, datahi)); ! 921: } ! 922: ! 923: bad_pf: ! 924: /* ! 925: * User generated unacceptable page fault. ! 926: */ ! 927: ! 928: sigcode = SIGSEGV; ! 929: printf("\ncr2=%x ", cr2); ! 930: ! 931: pf_end: ! 932: /* ! 933: * Send user a signal. ! 934: * If not segload (); ! 935: * If not a breakpoint, do console register dump. ! 936: */ ! 937: ! 938: if (sigcode) { ! 939: curr_register_dump (& regset); ! 940: printf ("sigcode=#%d User Page Fault\n", sigcode); ! 941: sendsig (sigcode, SELF); ! 942: } ! 943: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.