![[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 [Apple XNU] / XNU / osfmk / ppc|
Return to trap.c CVS log | Up to [Apple XNU] / XNU / osfmk / ppc |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * @OSF_COPYRIGHT@ ! 24: */ ! 25: ! 26: #include <mach_kdb.h> ! 27: #include <mach_kdp.h> ! 28: #include <debug.h> ! 29: #include <cpus.h> ! 30: #include <kern/thread.h> ! 31: #include <kern/exception.h> ! 32: #include <kern/syscall_sw.h> ! 33: #include <kern/cpu_data.h> ! 34: #include <kern/debug.h> ! 35: #include <mach/thread_status.h> ! 36: #include <vm/vm_fault.h> ! 37: #include <vm/vm_kern.h> /* For kernel_map */ ! 38: #include <ppc/misc_protos.h> ! 39: #include <ppc/trap.h> ! 40: #include <ppc/exception.h> ! 41: #include <ppc/proc_reg.h> /* for SR_xxx definitions */ ! 42: #include <ppc/pmap.h> ! 43: #include <ppc/mem.h> ! 44: #include <ppc/fpu_protos.h> ! 45: ! 46: #include <sys/kdebug.h> ! 47: ! 48: #if MACH_KDB ! 49: #include <ddb/db_watch.h> ! 50: #include <ddb/db_run.h> ! 51: #include <ddb/db_break.h> ! 52: #include <ddb/db_trap.h> ! 53: ! 54: boolean_t let_ddb_vm_fault = FALSE; ! 55: boolean_t debug_all_traps_with_kdb = FALSE; ! 56: extern struct db_watchpoint *db_watchpoint_list; ! 57: extern boolean_t db_watchpoints_inserted; ! 58: extern boolean_t db_breakpoints_inserted; ! 59: ! 60: ! 61: #endif /* MACH_KDB */ ! 62: ! 63: extern int debugger_active[NCPUS]; ! 64: ! 65: #if DEBUG || MACH_ASSERT ! 66: #define TRAP_ALL -1 ! 67: #define TRAP_ALIGNMENT 0x01 ! 68: #define TRAP_DATA 0x02 ! 69: #define TRAP_INSTRUCTION 0x04 ! 70: #define TRAP_AST 0x08 ! 71: #define TRAP_TRACE 0x10 ! 72: #define TRAP_PROGRAM 0x20 ! 73: #define TRAP_EXCEPTION 0x40 ! 74: #define TRAP_UNRESOLVED 0x80 ! 75: #define TRAP_SYSCALL 0x100 /* all syscalls */ ! 76: #define TRAP_HW 0x200 /* all in hw_exception.s */ ! 77: #define TRAP_MACH_SYSCALL 0x400 ! 78: #define TRAP_SERVER_SYSCALL 0x800 ! 79: ! 80: int trapdebug=0; /* TRAP_SERVER_SYSCALL;*/ ! 81: ! 82: #define TRAP_DEBUG(LEVEL, A) {if ((trapdebug & LEVEL)==LEVEL){printf A;}} ! 83: #else ! 84: #define TRAP_DEBUG(LEVEL, A) ! 85: #endif ! 86: ! 87: /* ! 88: * XXX don't pass VM_PROT_EXECUTE to vm_fault(), execute permission is implied ! 89: * in either R or RW (note: the pmap module knows this). This is done for the ! 90: * benefit of programs that execute out of their data space (ala lisp). ! 91: * If we didn't do this in that scenerio, the ITLB miss code would call us ! 92: * and we would call vm_fault() with RX permission. However, the space was ! 93: * probably vm_allocate()ed with just RW and vm_fault would fail. The "right" ! 94: * solution to me is to have the un*x server always allocate data with RWX for ! 95: * compatibility with existing binaries. ! 96: */ ! 97: ! 98: #define PROT_EXEC (VM_PROT_READ) ! 99: #define PROT_RO (VM_PROT_READ) ! 100: #define PROT_RW (VM_PROT_READ|VM_PROT_WRITE) ! 101: ! 102: /* A useful macro to update the ppc_exception_state in the PCB ! 103: * before calling doexception ! 104: */ ! 105: #define UPDATE_PPC_EXCEPTION_STATE { \ ! 106: thread_act_t thr_act = current_act(); \ ! 107: struct ppc_exception_state *es = &thr_act->mact.pcb->es; \ ! 108: es->dar = dar; \ ! 109: es->dsisr = dsisr; \ ! 110: es->exception = trapno / T_VECTOR_SIZE; /* back to powerpc */ \ ! 111: } ! 112: ! 113: static void unresolved_kernel_trap(int trapno, ! 114: struct ppc_saved_state *ssp, ! 115: unsigned int dsisr, ! 116: unsigned int dar, ! 117: char *message); ! 118: ! 119: struct ppc_saved_state *trap(int trapno, ! 120: struct ppc_saved_state *ssp, ! 121: unsigned int dsisr, ! 122: unsigned int dar) ! 123: { ! 124: int exception=0; ! 125: int code; ! 126: int subcode; ! 127: vm_map_t map; ! 128: unsigned int sp; ! 129: unsigned int space,space2; ! 130: unsigned int offset; ! 131: thread_act_t thr_act = current_act(); ! 132: #ifdef MACH_BSD ! 133: time_value_t tv; ! 134: #endif /* MACH_BSD */ ! 135: ! 136: ! 137: TRAP_DEBUG(TRAP_ALL,("NMGS TRAP %d srr0=0x%08x, srr1=0x%08x\n", ! 138: trapno/4,ssp->srr0,ssp->srr1)); ! 139: ! 140: #if DEBUG ! 141: { ! 142: /* make sure we're not near to overflowing kernel stack */ ! 143: int sp; ! 144: mp_disable_preemption(); /* Make sure we don't preempt */ ! 145: #ifdef __ELF__ ! 146: __asm__ volatile("mr %0, 1" : "=r" (sp)); ! 147: #else ! 148: __asm__ volatile("mr %0, r1" : "=r" (sp)); ! 149: #endif ! 150: if (sp < ! 151: (cpu_data[cpu_number()].active_thread->kernel_stack + ! 152: sizeof(struct ppc_saved_state)+256)) { ! 153: printf("TRAP - LOW ON KERNEL STACK!\n"); ! 154: } ! 155: mp_enable_preemption(); /* Preemption is cool now */ ! 156: } ! 157: #endif /* DEBUG */ ! 158: /* Handle kernel traps first */ ! 159: ! 160: if (!USER_MODE(ssp->srr1)) { ! 161: /* ! 162: * Trap came from system task, ie kernel or collocated server ! 163: */ ! 164: switch (trapno) { ! 165: ! 166: case T_PREEMPT: /* Handle a preempt trap */ ! 167: mp_disable_preemption(); /* since preemption is not enabled */ ! 168: ast_off(AST_URGENT); /* clear urgent and let it sched */ ! 169: mp_enable_preemption(); /* normally... */ ! 170: break; /* Do nothing, just check... */ ! 171: ! 172: /* ! 173: * These trap types should never be seen by trap() ! 174: * in kernel mode, anyway. ! 175: * Some are interrupts that should be seen by ! 176: * interrupt() others just don't happen because they ! 177: * are handled elsewhere. Some could happen but are ! 178: * considered to be fatal in kernel mode. ! 179: */ ! 180: case T_DECREMENTER: ! 181: case T_IN_VAIN: /* Shouldn't ever see this, lowmem_vectors eats it */ ! 182: case T_RESET: ! 183: case T_MACHINE_CHECK: ! 184: case T_SYSTEM_MANAGEMENT: ! 185: case T_ALTIVEC_ASSIST: ! 186: case T_INTERRUPT: ! 187: case T_FP_UNAVAILABLE: ! 188: case T_IO_ERROR: ! 189: case T_RESERVED: ! 190: default: ! 191: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 192: break; ! 193: ! 194: case T_TRACE: ! 195: case T_RUNMODE_TRACE: ! 196: case T_INSTRUCTION_BKPT: ! 197: #if MACH_KDP || MACH_KDB ! 198: if (!Call_Debugger(trapno, ssp)) ! 199: #endif ! 200: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 201: break; ! 202: ! 203: case T_PROGRAM: ! 204: if (ssp->srr1 & MASK(SRR1_PRG_TRAP)) { ! 205: #if MACH_KDP || MACH_KDB ! 206: if (!Call_Debugger(trapno, ssp)) ! 207: #endif ! 208: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 209: } else { ! 210: unresolved_kernel_trap(trapno, ssp, ! 211: dsisr, dar, NULL); ! 212: } ! 213: break; ! 214: case T_ALIGNMENT: ! 215: TRAP_DEBUG(TRAP_ALIGNMENT, ! 216: ("NMGS KERNEL ALIGNMENT_ACCESS, " ! 217: "DAR=0x%08x, DSISR = 0x%B\n", ! 218: dar, dsisr, ! 219: "\20\2HASH\5PROT\6IO_SPC\7WRITE\12WATCH\14EIO")); ! 220: if (alignment(dsisr, dar, ssp)) { ! 221: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 222: } ! 223: break; ! 224: case T_DATA_ACCESS: ! 225: TRAP_DEBUG(TRAP_DATA, ! 226: ("NMGS KERNEL DATA_ACCESS, DAR=0x%08x," ! 227: "DSISR = 0x%B\n", dar, dsisr, ! 228: "\20\2HASH\5PROT\6IO_SPC\7WRITE\12WATCH\14EIO")); ! 229: ! 230: #if MACH_KDB ! 231: mp_disable_preemption(); ! 232: if (debug_mode ! 233: #if NCPUS > 1 ! 234: && debugger_active[cpu_number()] ! 235: #endif /* NCPUS > 1 */ ! 236: && !let_ddb_vm_fault) { ! 237: /* ! 238: * Force kdb to handle this one. ! 239: */ ! 240: kdb_trap(trapno, ssp); ! 241: } ! 242: mp_enable_preemption(); ! 243: #endif /* MACH_KDB */ ! 244: ! 245: /* simple case : not SR_COPYIN segment, from kernel */ ! 246: if ((dar >> 28) != SR_COPYIN_NUM) { ! 247: map = kernel_map; ! 248: ! 249: offset = dar; ! 250: ! 251: ! 252: /* ! 253: * Note: Some ROM device drivers will access page 0 when they start. The IOKit will ! 254: * set a flag to tell us to ignore any access fault on page 0. After the driver is ! 255: * opened, it will clear the flag. ! 256: */ ! 257: if((0 == (dar & -PAGE_SIZE)) && /* Check for access of page 0 and */ ! 258: ((thr_act->mact.specFlags) & ignoreZeroFault)) { ! 259: /* special case of ignoring page zero faults */ ! 260: ssp->srr0 += 4; /* Point to next instruction */ ! 261: break; ! 262: } ! 263: ! 264: TRAP_DEBUG(TRAP_DATA, ! 265: ("SYSTEM FAULT FROM 0x%08x\n", ! 266: offset)); ! 267: ! 268: code = vm_fault(map, ! 269: trunc_page(offset), ! 270: dsisr & MASK(DSISR_WRITE) ? ! 271: PROT_RW : PROT_RO, ! 272: FALSE); ! 273: if (code != KERN_SUCCESS) { ! 274: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 275: } ! 276: else { ! 277: ((savearea *)ssp)->save_flags |= SAVredrive; /* Tell low-level to re-try fault */ ! 278: ((savearea *)ssp)->save_dsisr |= MASK(DSISR_HASH); /* Make sure this is marked as a miss */ ! 279: } ! 280: break; ! 281: } ! 282: ! 283: /* If we get here, the fault was due to a copyin/out */ ! 284: ! 285: map = thr_act->map; ! 286: ! 287: /* Mask out SR_COPYIN and mask in original segment */ ! 288: ! 289: offset = (dar & 0x0fffffff) | ! 290: ((mfsrin(dar)<<8) & 0xF0000000); ! 291: ! 292: TRAP_DEBUG(TRAP_DATA, ! 293: ("sr=0x%08x, dar=0x%08x, sp=0x%x\n", ! 294: mfsrin(dar), dar,map->pmap->space)); ! 295: assert((mfsrin(dar) & 0x000FFFFF) == ! 296: map->pmap->space); ! 297: TRAP_DEBUG(TRAP_DATA, ! 298: ("KERNEL FAULT FROM 0x%x,0x%08x\n", ! 299: map->pmap->space, offset)); ! 300: ! 301: code = vm_fault(map, ! 302: trunc_page(offset), ! 303: dsisr & MASK(DSISR_WRITE) ? ! 304: PROT_RW : PROT_RO, ! 305: FALSE); ! 306: ! 307: /* If we failed, there should be a recovery ! 308: * spot to rfi to. ! 309: */ ! 310: if (code != KERN_SUCCESS) { ! 311: TRAP_DEBUG(TRAP_DATA, ! 312: ("FAULT FAILED- srr0=0x%08x," ! 313: "pcb-srr0=0x%08x\n", ! 314: ssp->srr0, ! 315: thr_act->mact.pcb->ss.srr0)); ! 316: ! 317: if (thr_act->thread->recover) { ! 318: ! 319: #if 0 ! 320: __asm__ volatile("tweq r1,r1"); /* (TEST/DEBUG) */ ! 321: #endif ! 322: ! 323: act_lock_thread(thr_act); ! 324: ssp->srr0 = thr_act->thread->recover; ! 325: thr_act->thread->recover = ! 326: (vm_offset_t)NULL; ! 327: act_unlock_thread(thr_act); ! 328: } else { ! 329: unresolved_kernel_trap(trapno, ssp, dsisr, dar, "copyin/out has no recovery point"); ! 330: } ! 331: } ! 332: else { ! 333: ((savearea *)ssp)->save_flags |= SAVredrive; /* Tell low-level to re-try fault */ ! 334: ((savearea *)ssp)->save_dsisr |= MASK(DSISR_HASH); /* Make sure this is marked as a miss */ ! 335: } ! 336: ! 337: break; ! 338: ! 339: case T_INSTRUCTION_ACCESS: ! 340: ! 341: TRAP_DEBUG(TRAP_INSTRUCTION, ! 342: ("NMGS KERNEL INSTRUCTION ACCESS," ! 343: "DSISR = 0x%B\n", dsisr, ! 344: "\20\2HASH\5PROT\6IO_SPC\7WRITE\12WATCH\14EIO")); ! 345: ! 346: #if MACH_KDB ! 347: if (debug_mode ! 348: #if NCPUS > 1 ! 349: && debugger_active[cpu_number()] ! 350: #endif /* NCPUS > 1 */ ! 351: && !let_ddb_vm_fault) { ! 352: /* ! 353: * Force kdb to handle this one. ! 354: */ ! 355: kdb_trap(trapno, ssp); ! 356: } ! 357: #endif /* MACH_KDB */ ! 358: ! 359: /* Same as for data access, except fault type ! 360: * is PROT_EXEC and addr comes from srr0 ! 361: */ ! 362: map = thr_act->map; ! 363: ! 364: code = vm_fault(map, trunc_page(ssp->srr0), ! 365: PROT_EXEC, FALSE); ! 366: if (code != KERN_SUCCESS) { ! 367: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 368: } ! 369: else { ! 370: ((savearea *)ssp)->save_flags |= SAVredrive; /* Tell low-level to re-try fault */ ! 371: ssp->srr1 |= MASK(DSISR_HASH); /* Make sure this is marked as a miss */ ! 372: } ! 373: break; ! 374: ! 375: /* Usually shandler handles all the system calls, but the ! 376: * atomic thread switcher may throwup (via thandler) and ! 377: * have to pass it up to the exception handler. ! 378: */ ! 379: ! 380: case T_SYSTEM_CALL: ! 381: unresolved_kernel_trap(trapno, ssp, dsisr, dar, NULL); ! 382: break; ! 383: ! 384: case T_AST: ! 385: TRAP_DEBUG(TRAP_AST, ! 386: ("T_AST FROM KERNEL MODE\n")); ! 387: ast_taken(FALSE, AST_ALL, 0); ! 388: break; ! 389: } ! 390: } else { ! 391: #ifdef MACH_BSD ! 392: { ! 393: void get_procrustime(time_value_t *); ! 394: ! 395: get_procrustime(&tv); ! 396: } ! 397: #endif /* MACH_BSD */ ! 398: ! 399: ! 400: /* ! 401: * Trap came from user task ! 402: */ ! 403: ! 404: switch (trapno) { ! 405: case T_PREEMPT: /* Handle a preempt trap */ ! 406: break; /* Do nothing, just check... */ ! 407: ! 408: /* ! 409: * These trap types should never be seen by trap() ! 410: * Some are interrupts that should be seen by ! 411: * interrupt() others just don't happen because they ! 412: * are handled elsewhere. ! 413: */ ! 414: case T_DECREMENTER: ! 415: case T_IN_VAIN: /* Shouldn't ever see this, lowmem_vectors eats it */ ! 416: case T_MACHINE_CHECK: ! 417: case T_INTERRUPT: ! 418: case T_FP_UNAVAILABLE: ! 419: case T_SYSTEM_MANAGEMENT: ! 420: case T_RESERVED: ! 421: case T_IO_ERROR: ! 422: ! 423: default: ! 424: panic("Unexpected exception type"); ! 425: break; ! 426: ! 427: case T_RESET: ! 428: halt_all_cpus(TRUE); /* never returns */ ! 429: ! 430: case T_ALIGNMENT: ! 431: TRAP_DEBUG(TRAP_ALIGNMENT, ! 432: ("NMGS USER ALIGNMENT_ACCESS, " ! 433: "DAR=0x%08x, DSISR = 0x%B\n", dar, dsisr, ! 434: "\20\2HASH\5PROT\6IO_SPC\7WRITE\12WATCH\14EIO")); ! 435: if (alignment(dsisr, dar, ssp)) { ! 436: code = EXC_PPC_UNALIGNED; ! 437: exception = EXC_BAD_ACCESS; ! 438: subcode = dar; ! 439: } ! 440: break; ! 441: ! 442: case T_TRACE: /* Real PPC chips */ ! 443: case T_INSTRUCTION_BKPT: /* 603 PPC chips */ ! 444: case T_RUNMODE_TRACE: /* 601 PPC chips */ ! 445: TRAP_DEBUG(TRAP_TRACE,("NMGS TRACE TRAP\n")); ! 446: ! 447: exception = EXC_BREAKPOINT; ! 448: code = EXC_PPC_TRACE; ! 449: subcode = ssp->srr0; ! 450: break; ! 451: ! 452: case T_PROGRAM: ! 453: TRAP_DEBUG(TRAP_PROGRAM, ! 454: ("NMGS PROGRAM TRAP\n")); ! 455: if (ssp->srr1 & MASK(SRR1_PRG_FE)) { ! 456: TRAP_DEBUG(TRAP_PROGRAM, ! 457: ("FP EXCEPTION\n")); ! 458: fpu_save(); ! 459: UPDATE_PPC_EXCEPTION_STATE; ! 460: exception = EXC_ARITHMETIC; ! 461: code = EXC_ARITHMETIC; ! 462: ! 463: mp_disable_preemption(); ! 464: subcode = current_act()->mact.FPU_pcb->fs.fpscr; ! 465: mp_enable_preemption(); ! 466: } ! 467: else if (ssp->srr1 & MASK(SRR1_PRG_ILL_INS)) { ! 468: ! 469: TRAP_DEBUG(TRAP_PROGRAM, ! 470: ("ILLEGAL INSTRUCTION\n")); ! 471: ! 472: UPDATE_PPC_EXCEPTION_STATE ! 473: exception = EXC_BAD_INSTRUCTION; ! 474: code = EXC_PPC_UNIPL_INST; ! 475: subcode = ssp->srr0; ! 476: } else if (ssp->srr1 & MASK(SRR1_PRG_PRV_INS)) { ! 477: TRAP_DEBUG(TRAP_PROGRAM, ! 478: ("PRIVILEGED INSTRUCTION\n")); ! 479: ! 480: UPDATE_PPC_EXCEPTION_STATE; ! 481: exception = EXC_BAD_INSTRUCTION; ! 482: code = EXC_PPC_PRIVINST; ! 483: subcode = ssp->srr0; ! 484: } else if (ssp->srr1 & MASK(SRR1_PRG_TRAP)) { ! 485: unsigned int inst; ! 486: ! 487: if (copyin((char *) ssp->srr0, (char *) &inst, 4 )) ! 488: panic("copyin failed\n"); ! 489: UPDATE_PPC_EXCEPTION_STATE; ! 490: if (inst == 0x7FE00008) { ! 491: exception = EXC_BREAKPOINT; ! 492: code = EXC_PPC_BREAKPOINT; ! 493: } else { ! 494: exception = EXC_SOFTWARE; ! 495: code = EXC_PPC_TRAP; ! 496: } ! 497: subcode = ssp->srr0; ! 498: } ! 499: break; ! 500: ! 501: case T_ALTIVEC_ASSIST: ! 502: UPDATE_PPC_EXCEPTION_STATE; ! 503: exception = EXC_ARITHMETIC; ! 504: code = EXC_PPC_ALTIVECASSIST; ! 505: subcode = ssp->srr0; ! 506: break; ! 507: ! 508: case T_DATA_ACCESS: ! 509: TRAP_DEBUG(TRAP_DATA, ! 510: ("NMGS USER DATA_ACCESS, DAR=0x%08x, DSISR = 0x%B\n", dar, dsisr,"\20\2HASH\5PROT\6IO_SPC\7WRITE\12WATCH\14EIO")); ! 511: ! 512: map = thr_act->map; ! 513: ! 514: code = vm_fault(map, trunc_page(dar), ! 515: dsisr & MASK(DSISR_WRITE) ? PROT_RW : PROT_RO, ! 516: FALSE); ! 517: if (code != KERN_SUCCESS) { ! 518: ! 519: TRAP_DEBUG(TRAP_DATA,("FAULT FAILED!\n")); ! 520: UPDATE_PPC_EXCEPTION_STATE; ! 521: exception = EXC_BAD_ACCESS; ! 522: subcode = dar; ! 523: } ! 524: else { ! 525: ((savearea *)ssp)->save_flags |= SAVredrive; /* Tell low-level to re-try fault */ ! 526: ((savearea *)ssp)->save_dsisr |= MASK(DSISR_HASH); /* Make sure this is marked as a miss */ ! 527: } ! 528: break; ! 529: ! 530: case T_INSTRUCTION_ACCESS: ! 531: TRAP_DEBUG(TRAP_INSTRUCTION,("NMGS USER INSTRUCTION ACCESS, DSISR = 0x%B\n", dsisr,"\20\2HASH\5PROT\6IO_SPC\7WRITE\12WATCH\14EIO")); ! 532: ! 533: /* Same as for data access, except fault type ! 534: * is PROT_EXEC and addr comes from srr0 ! 535: */ ! 536: map = thr_act->map; ! 537: ! 538: code = vm_fault(map, trunc_page(ssp->srr0), ! 539: PROT_EXEC, FALSE); ! 540: if (code != KERN_SUCCESS) { ! 541: ! 542: ! 543: TRAP_DEBUG(TRAP_INSTRUCTION, ! 544: ("INSTR FAULT FAILED!\n")); ! 545: UPDATE_PPC_EXCEPTION_STATE; ! 546: exception = EXC_BAD_ACCESS; ! 547: subcode = ssp->srr0; ! 548: } ! 549: else { ! 550: ((savearea *)ssp)->save_flags |= SAVredrive; /* Tell low-level to re-try fault */ ! 551: ssp->srr1 |= MASK(DSISR_HASH); /* Make sure this is marked as a miss */ ! 552: } ! 553: break; ! 554: ! 555: case T_AST: ! 556: TRAP_DEBUG(TRAP_AST,("T_AST FROM USER MODE\n")); ! 557: ast_taken(FALSE, AST_ALL, 0); ! 558: break; ! 559: ! 560: } ! 561: #ifdef MACH_BSD ! 562: { ! 563: void bsd_uprofil(time_value_t *, unsigned int); ! 564: ! 565: bsd_uprofil(&tv, ssp->srr0); ! 566: } ! 567: #endif /* MACH_BSD */ ! 568: } ! 569: ! 570: if (exception) { ! 571: TRAP_DEBUG(TRAP_EXCEPTION, ! 572: ("doexception (0x%x, 0x%x, 0x%x\n", ! 573: exception,code,subcode)); ! 574: ! 575: #if 0 ! 576: __asm__ volatile("tweq r1,r1"); /* (TEST/DEBUG) */ ! 577: #endif ! 578: ! 579: doexception(exception, code, subcode); ! 580: return ssp; ! 581: } ! 582: /* AST delivery ! 583: * Check to see if we need an AST, if so take care of it here ! 584: */ ! 585: ! 586: mp_disable_preemption(); /* We can't preempt here */ ! 587: while (ast_needed(cpu_number()) && USER_MODE(ssp->srr1)) { ! 588: mp_enable_preemption(); /* ast_taken doesn't expect preemption disabled */ ! 589: ast_taken(FALSE, AST_ALL, 0); ! 590: mp_disable_preemption(); /* Disable pretemption for check */ ! 591: } ! 592: mp_enable_preemption(); /* Preemption be cool again */ ! 593: ! 594: return ssp; ! 595: } ! 596: ! 597: /* This routine is called from assembly before each and every system call. ! 598: * It must preserve r3. ! 599: */ ! 600: ! 601: extern int syscall_trace(int, struct ppc_saved_state *); ! 602: ! 603: ! 604: extern int pmdebug; ! 605: ! 606: int syscall_trace(int retval, struct ppc_saved_state *ssp) ! 607: { ! 608: int i, argc; ! 609: ! 610: int kdarg[3]; ! 611: /* Always prepare to trace mach system calls */ ! 612: if (kdebug_enable && (ssp->r0 & 0x80000000)) { ! 613: /* Mach trap */ ! 614: kdarg[0]=0; ! 615: kdarg[1]=0; ! 616: kdarg[2]=0; ! 617: argc = mach_trap_table[-(ssp->r0)].mach_trap_arg_count; ! 618: if (argc > 3) ! 619: argc = 3; ! 620: for (i=0; i < argc; i++) ! 621: kdarg[i] = (int)*(&ssp->r3 + i); ! 622: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_SC, (-(ssp->r0))) | DBG_FUNC_START, ! 623: kdarg[0], kdarg[1], kdarg[2], 0, 0); ! 624: } ! 625: ! 626: #if MACH_ASSERT ! 627: if (trapdebug & TRAP_SYSCALL) ! 628: trapdebug |= (TRAP_MACH_SYSCALL|TRAP_SERVER_SYSCALL); ! 629: ! 630: if (!(trapdebug & (TRAP_MACH_SYSCALL|TRAP_SERVER_SYSCALL))) ! 631: return retval; ! 632: if (ssp->r0 & 0x80000000) { ! 633: /* Mach trap */ ! 634: if (!(trapdebug & TRAP_MACH_SYSCALL)) ! 635: return retval; ! 636: ! 637: printf("0x%08x : %30s (", ! 638: ssp->srr0, mach_trap_table[-(ssp->r0)].mach_trap_name); ! 639: argc = mach_trap_table[-(ssp->r0)].mach_trap_arg_count; ! 640: for (i = 0; i < argc; i++) ! 641: printf("%08x ",*(&ssp->r3 + i)); ! 642: printf(")\n"); ! 643: } else { ! 644: if (!(trapdebug & TRAP_SERVER_SYSCALL)) ! 645: return retval; ! 646: printf("0x%08x : UNIX %3d (", ssp->srr0, ssp->r0); ! 647: argc = 4; /* print 4 of 'em! */ ! 648: for (i = 0; i < argc; i++) ! 649: printf("%08x ",*(&ssp->r3 + i)); ! 650: printf(")\n"); ! 651: } ! 652: #endif /* MACH_ASSERT */ ! 653: return retval; ! 654: } ! 655: ! 656: /* This routine is called from assembly after each mach system call ! 657: * It must preserve r3. ! 658: */ ! 659: ! 660: extern int syscall_trace_end(int, struct ppc_saved_state *); ! 661: ! 662: int syscall_trace_end(int retval, struct ppc_saved_state *ssp) ! 663: { ! 664: if (kdebug_enable && (ssp->r0 & 0x80000000)) { ! 665: /* Mach trap */ ! 666: KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_EXCP_SC,(-(ssp->r0))) | DBG_FUNC_END, ! 667: retval, 0, 0, 0, 0); ! 668: } ! 669: return retval; ! 670: } ! 671: ! 672: /* ! 673: * called from syscall if there is an error ! 674: */ ! 675: ! 676: int syscall_error( ! 677: int exception, ! 678: int code, ! 679: int subcode, ! 680: struct ppc_saved_state *ssp) ! 681: { ! 682: register thread_t thread; ! 683: ! 684: thread = current_thread(); ! 685: ! 686: if (thread == 0) ! 687: panic("syscall error in boot phase"); ! 688: ! 689: if (!USER_MODE(ssp->srr1)) ! 690: panic("system call called from kernel"); ! 691: ! 692: doexception(exception, code, subcode); ! 693: ! 694: return 0; ! 695: } ! 696: ! 697: /* Pass up a server syscall/exception */ ! 698: void ! 699: doexception( ! 700: int exc, ! 701: int code, ! 702: int sub) ! 703: { ! 704: exception_data_type_t codes[EXCEPTION_CODE_MAX]; ! 705: ! 706: codes[0] = code; ! 707: codes[1] = sub; ! 708: exception(exc, codes, 2); ! 709: } ! 710: ! 711: char *trap_type[] = { ! 712: "0x000 Interrupt in vain", ! 713: "0x100 System reset", ! 714: "0x200 Machine check", ! 715: "0x300 Data access", ! 716: "0x400 Instruction access", ! 717: "0x500 External interrupt", ! 718: "0x600 Alignment", ! 719: "0x700 Program", ! 720: "0x800 Floating point", ! 721: "0x900 Decrementer", ! 722: "0xA00 I/O controller interface", ! 723: "0xB00 INVALID EXCEPTION", ! 724: "0xC00 System call exception", ! 725: "0xD00 Trace", ! 726: "0xE00 FP assist", ! 727: "0xF20 VMX", ! 728: "0xF00 INVALID EXCEPTION", ! 729: "0x1000 Instruction PTE miss", ! 730: "0x1100 Data load PTE miss", ! 731: "0x1200 Data store PTE miss", ! 732: "0x1300 Instruction Breakpoint", ! 733: "0x1400 System Management", ! 734: "0x1500 INVALID EXCEPTION", ! 735: "0x1600 Altivec Assist", ! 736: "0x1700 INVALID EXCEPTION", ! 737: "0x1800 INVALID EXCEPTION", ! 738: "0x1900 INVALID EXCEPTION", ! 739: "0x1A00 INVALID EXCEPTION", ! 740: "0x1B00 INVALID EXCEPTION", ! 741: "0x1C00 INVALID EXCEPTION", ! 742: "0x1D00 INVALID EXCEPTION", ! 743: "0x1E00 INVALID EXCEPTION", ! 744: "0x1F00 INVALID EXCEPTION", ! 745: "0x2000 Run Mode/Trace" ! 746: }; ! 747: int TRAP_TYPES = sizeof (trap_type) / sizeof (trap_type[0]); ! 748: ! 749: void unresolved_kernel_trap(int trapno, ! 750: struct ppc_saved_state *ssp, ! 751: unsigned int dsisr, ! 752: unsigned int dar, ! 753: char *message) ! 754: { ! 755: unsigned int* stackptr; ! 756: char *trap_name; ! 757: int i, lr; ! 758: extern void print_backtrace(struct ppc_saved_state *); ! 759: extern unsigned int debug_mode, disableDebugOuput; ! 760: ! 761: disableDebugOuput = FALSE; ! 762: debug_mode++; ! 763: if ((unsigned)trapno <= T_MAX) ! 764: trap_name = trap_type[trapno / T_VECTOR_SIZE]; ! 765: else ! 766: trap_name = "???? unrecognized exception"; ! 767: if (message == NULL) ! 768: message = trap_name; ! 769: ! 770: printf("\n\nUnresolved kernel trap: %s DSISR=0x%08x DAR=0x%08x PC=0x%08x\n" ! 771: "generating stack backtrace prior to panic:\n\n", ! 772: trap_name, dsisr, dar, ssp->srr0); ! 773: ! 774: printf("backtrace: %08x ", ssp->srr0); ! 775: ! 776: stackptr = (unsigned int *)(ssp->r1); ! 777: ! 778: #ifdef __ELF__ ! 779: lr = 1; ! 780: #else ! 781: lr = 2; ! 782: #endif ! 783: ! 784: print_backtrace(ssp); ! 785: ! 786: #if MACH_KDB || MACH_KDP ! 787: (void *)Call_Debugger(trapno, ssp); ! 788: #endif ! 789: panic(message); ! 790: } ! 791: ! 792: #if MACH_KDB ! 793: void ! 794: thread_kdb_return(void) ! 795: { ! 796: register thread_act_t thr_act = current_act(); ! 797: register thread_t cur_thr = current_thread(); ! 798: register struct ppc_saved_state *regs = USER_REGS(thr_act); ! 799: ! 800: Call_Debugger(thr_act->mact.pcb->es.exception, regs); ! 801: #if MACH_LDEBUG ! 802: assert(cur_thr->mutex_count == 0); ! 803: #endif /* MACH_LDEBUG */ ! 804: check_simple_locks(); ! 805: thread_exception_return(); ! 806: /*NOTREACHED*/ ! 807: } ! 808: #endif /* MACH_KDB */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.