X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d52fe63fc81f7e44faaae711812a211a78434976..d7e50217d7adf6e52786a38bcaa4cd698cb9a79e:/osfmk/ppc/model_dep.c diff --git a/osfmk/ppc/model_dep.c b/osfmk/ppc/model_dep.c index 8241a6434..6d1ae0b7a 100644 --- a/osfmk/ppc/model_dep.c +++ b/osfmk/ppc/model_dep.c @@ -3,19 +3,22 @@ * * @APPLE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. * * @APPLE_LICENSE_HEADER_END@ */ @@ -83,6 +86,7 @@ #include #include #include +#include #include #include @@ -125,8 +129,8 @@ char env_buf[256]; * from on to another using kdb_on! #cpu or cpu #cpu */ -decl_simple_lock_data(, debugger_lock) /* debugger lock */ -decl_simple_lock_data(, pbtlock) /* backtrace print lock */ +hw_lock_data_t debugger_lock; /* debugger lock */ +hw_lock_data_t pbtlock; /* backtrace print lock */ int debugger_cpu = -1; /* current cpu running debugger */ int debugger_debug = 0; /* Debug debugger */ @@ -179,25 +183,28 @@ char *failNames[] = { "Corrupt stack", /* failStack */ "Corrupt mapping tables", /* failMapping */ "Corrupt context", /* failContext */ - "Unknown failure code" /* Unknown failure code - must always be last */ + "No saveareas", /* failNoSavearea */ + "Savearea corruption", /* failSaveareaCorr */ + "Invalid live context", /* failBadLiveContext */ + "Unaligned stack", /* failUnalignedStk */ + "Unknown failure code" /* Unknown failure code - must always be last */ }; char *invxcption = "Unknown code"; extern const char version[]; extern char *trap_type[]; -extern vm_offset_t mem_actual; #if !MACH_KDB -void kdb_trap(int type, struct ppc_saved_state *regs); -void kdb_trap(int type, struct ppc_saved_state *regs) { +void kdb_trap(int type, struct savearea *regs); +void kdb_trap(int type, struct savearea *regs) { return; } #endif #if !MACH_KDP -void kdp_trap(int type, struct ppc_saved_state *regs); -void kdp_trap(int type, struct ppc_saved_state *regs) { +void kdp_trap(int type, struct savearea *regs); +void kdp_trap(int type, struct savearea *regs) { return; } #endif @@ -220,6 +227,8 @@ machine_startup(boot_args *args) if (boot_arg & DB_HALT) halt_in_debugger=1; if (boot_arg & DB_PRT) disableDebugOuput=FALSE; if (boot_arg & DB_SLOG) systemLogDiags=TRUE; + if (boot_arg & DB_NMI) panicDebugging=TRUE; + if (boot_arg & DB_LOG_PI_SCRN) logPanicDataToScreen=TRUE; } hw_lock_init(&debugger_lock); /* initialize debugger lock */ @@ -253,13 +262,6 @@ machine_startup(boot_args *args) default_preemption_rate = boot_arg; } - if (PE_parse_boot_arg("kpreempt", &boot_arg)) { - extern int kernel_preemption_mode; - extern boolean_t zone_gc_allowed; - - kernel_preemption_mode = boot_arg; - zone_gc_allowed = FALSE; /* XXX: TO BE REMOVED */ - } if (PE_parse_boot_arg("unsafe", &boot_arg)) { extern int max_unsafe_quanta; @@ -301,13 +303,14 @@ machine_conf(void) { machine_info.max_cpus = NCPUS; machine_info.avail_cpus = 1; - machine_info.memory_size = mem_size; + machine_info.memory_size = mem_size; /* Note that this will be 2 GB for >= 2 GB machines */ } void machine_init(void) { clock_config(); + perfmon_init(); } void slave_machine_init(void) @@ -353,7 +356,7 @@ void machine_callstack( void -print_backtrace(struct ppc_saved_state *ssp) +print_backtrace(struct savearea *ssp) { unsigned int stackptr, *raddr, *rstack, trans, fence; int i, frames_cnt, skip_top_frames, frames_max; @@ -362,6 +365,7 @@ print_backtrace(struct ppc_saved_state *ssp) thread_act_t *act; savearea *sv, *svssp; int cpu; + savearea *psv; /* * We need this lock to make sure we don't hang up when we double panic on an MP. @@ -379,50 +383,65 @@ print_backtrace(struct ppc_saved_state *ssp) if(current_thread()) sv = (savearea *)current_act()->mact.pcb; /* Find most current savearea if system has started */ fence = 0xFFFFFFFF; /* Show we go all the way */ - if(sv) fence = sv->save_r1; /* Stop at previous exception point */ + if(sv) fence = (unsigned int)sv->save_r1; /* Stop at previous exception point */ if(!svssp) { /* Should we start from stack? */ - printf("Latest stack backtrace for cpu %d:\n", cpu_number()); + kdb_printf("Latest stack backtrace for cpu %d:\n", cpu_number()); __asm__ volatile("mr %0,r1" : "=r" (stackptr)); /* Get current stack */ dump_backtrace(stackptr, fence); /* Dump the backtrace */ if(!sv) { /* Leave if no saveareas */ - printf("\nKernel version:\n%s\n",version); /* Print kernel version */ + kdb_printf("\nKernel version:\n%s\n",version); /* Print kernel version */ hw_lock_unlock(&pbtlock); /* Allow another back trace to happen */ return; } } else { /* Were we passed an exception? */ fence = 0xFFFFFFFF; /* Show we go all the way */ - if(svssp->save_prev) fence = svssp->save_prev->save_r1; /* Stop at previous exception point */ + if(svssp->save_hdr.save_prev) { + if((svssp->save_hdr.save_prev <= vm_last_addr) && ((unsigned int)pmap_find_phys(kernel_pmap, (addr64_t)svssp->save_hdr.save_prev))) { /* Valid address? */ + psv = (savearea *)((unsigned int)svssp->save_hdr.save_prev); /* Get the 64-bit back chain converted to a regualr pointer */ + fence = (unsigned int)psv->save_r1; /* Stop at previous exception point */ + } + } - printf("Latest crash info for cpu %d:\n", cpu_number()); - printf(" Exception state (sv=0x%08x)\n", sv); + kdb_printf("Latest crash info for cpu %d:\n", cpu_number()); + kdb_printf(" Exception state (sv=0x%08X)\n", sv); dump_savearea(svssp, fence); /* Dump this savearea */ } if(!sv) { /* Leave if no saveareas */ - printf("\nKernel version:\n%s\n",version); /* Print kernel version */ + kdb_printf("\nKernel version:\n%s\n",version); /* Print kernel version */ hw_lock_unlock(&pbtlock); /* Allow another back trace to happen */ return; } - printf("Proceeding back via exception chain:\n"); + kdb_printf("Proceeding back via exception chain:\n"); while(sv) { /* Do them all... */ - printf(" Exception state (sv=0x%08x)\n", sv); + if(!((sv <= vm_last_addr) && (unsigned int)pmap_find_phys(kernel_pmap, (addr64_t)sv))) { /* Valid address? */ + kdb_printf(" Exception state (sv=0x%08X) Not mapped or invalid. stopping...\n", sv); + break; + } + + kdb_printf(" Exception state (sv=0x%08X)\n", sv); if(sv == svssp) { /* Did we dump it already? */ - printf(" previously dumped as \"Latest\" state. skipping...\n"); + kdb_printf(" previously dumped as \"Latest\" state. skipping...\n"); } else { fence = 0xFFFFFFFF; /* Show we go all the way */ - if(sv->save_prev) fence = sv->save_prev->save_r1; /* Stop at previous exception point */ + if(sv->save_hdr.save_prev) { + if((sv->save_hdr.save_prev <= vm_last_addr) && ((unsigned int)pmap_find_phys(kernel_pmap, (addr64_t)sv->save_hdr.save_prev))) { /* Valid address? */ + psv = (savearea *)((unsigned int)sv->save_hdr.save_prev); /* Get the 64-bit back chain converted to a regualr pointer */ + fence = (unsigned int)psv->save_r1; /* Stop at previous exception point */ + } + } dump_savearea(sv, fence); /* Dump this savearea */ } - sv = sv->save_prev; /* Back chain */ + sv = (savearea *)sv->save_hdr.save_prev; /* Back chain */ } - printf("\nKernel version:\n%s\n",version); /* Print kernel version */ + kdb_printf("\nKernel version:\n%s\n",version); /* Print kernel version */ pbtcpu = -1; /* Mark as unowned */ hw_lock_unlock(&pbtlock); /* Allow another back trace to happen */ @@ -440,12 +459,12 @@ void dump_savearea(savearea *sv, unsigned int fence) { if(sv->save_exception > T_MAX) xcode = invxcption; /* Too big for table */ else xcode = trap_type[sv->save_exception / 4]; /* Point to the type */ - printf(" PC=0x%08X; MSR=0x%08x; DAR=0x%08x; DSISR=0x%08x; LR=0x%08x; R1=0x%08x; XCP=0x%08x (%s)\n", - sv->save_srr0, sv->save_srr1, sv->save_dar, sv->save_dsisr, - sv->save_lr, sv->save_r1, sv->save_exception, xcode); + kdb_printf(" PC=0x%08X; MSR=0x%08X; DAR=0x%08X; DSISR=0x%08X; LR=0x%08X; R1=0x%08X; XCP=0x%08X (%s)\n", + (unsigned int)sv->save_srr0, (unsigned int)sv->save_srr1, (unsigned int)sv->save_dar, sv->save_dsisr, + (unsigned int)sv->save_lr, (unsigned int)sv->save_r1, sv->save_exception, xcode); if(!(sv->save_srr1 & MASK(MSR_PR))) { /* Are we in the kernel? */ - dump_backtrace(sv->save_r1, fence); /* Dump the stack back trace from here if not user state */ + dump_backtrace((unsigned int)sv->save_r1, fence); /* Dump the stack back trace from here if not user state */ } return; @@ -462,39 +481,39 @@ void dump_backtrace(unsigned int stackptr, unsigned int fence) { unsigned int sframe[8], raddr, dumbo; int i; - printf(" Backtrace:\n"); + kdb_printf(" Backtrace:\n"); for(i = 0; i < DUMPFRAMES; i++) { /* Dump up to max frames */ if(!stackptr || (stackptr == fence)) break; /* Hit stop point or end... */ - if(stackptr & 0x0000000f) { /* Is stack pointer valid? */ - printf("\n backtrace terminated - unaligned frame address: 0x%08x\n", stackptr); /* No, tell 'em */ + if(stackptr & 0x0000000F) { /* Is stack pointer valid? */ + kdb_printf("\n backtrace terminated - unaligned frame address: 0x%08X\n", stackptr); /* No, tell 'em */ break; } - raddr = (unsigned int)LRA(PPC_SID_KERNEL, (void *)stackptr); /* Get physical frame address */ - if(!raddr) { /* Is it mapped? */ - printf("\n backtrace terminated - frame not mapped: 0x%08x\n", stackptr); /* No, tell 'em */ + raddr = (unsigned int)pmap_find_phys(kernel_pmap, (addr64_t)stackptr); /* Get physical frame address */ + if(!raddr || (stackptr > vm_last_addr)) { /* Is it mapped? */ + kdb_printf("\n backtrace terminated - frame not mapped or invalid: 0x%08X\n", stackptr); /* No, tell 'em */ break; } - if(raddr >= mem_actual) { /* Is it within physical RAM? */ - printf("\n backtrace terminated - frame outside of RAM: v=0x%08x, p=%08X\n", stackptr, raddr); /* No, tell 'em */ + if(!mapping_phys_lookup(raddr, &dumbo)) { /* Is it within physical RAM? */ + kdb_printf("\n backtrace terminated - frame outside of RAM: v=0x%08X, p=%08X\n", stackptr, raddr); /* No, tell 'em */ break; } - ReadReal(raddr, &sframe[0]); /* Fetch the stack frame */ + ReadReal((addr64_t)((raddr << 12) | (stackptr & 4095)), &sframe[0]); /* Fetch the stack frame */ - bframes[i] = sframe[LRindex]; /* Save the link register */ + bframes[i] = sframe[LRindex]; /* Save the link register */ - if(!i) printf(" "); /* Indent first time */ - else if(!(i & 7)) printf("\n "); /* Skip to new line every 8 */ - printf("0x%08x ", bframes[i]); /* Dump the link register */ + if(!i) kdb_printf(" "); /* Indent first time */ + else if(!(i & 7)) kdb_printf("\n "); /* Skip to new line every 8 */ + kdb_printf("0x%08X ", bframes[i]); /* Dump the link register */ - stackptr = sframe[0]; /* Chain back */ + stackptr = sframe[0]; /* Chain back */ } - printf("\n"); - if(i >= DUMPFRAMES) printf(" backtrace continues...\n"); /* Say we terminated early */ + kdb_printf("\n"); + if(i >= DUMPFRAMES) kdb_printf(" backtrace continues...\n"); /* Say we terminated early */ if(i) kmod_dump((vm_offset_t *)&bframes[0], i); /* Show what kmods are in trace */ } @@ -506,6 +525,7 @@ Debugger(const char *message) { int i; unsigned int store[8]; + unsigned long pi_size = 0; spl_t spl; spl = splhigh(); /* No interruptions from here on */ @@ -528,6 +548,49 @@ Debugger(const char *message) { return; /* Yeah, don't do it again... */ } + +/* + * The above stuff catches the double panic case so we shouldn't have to worry about that here. + */ + if ( panicstr != (char *)0 ) + { + /* diable kernel preemptions */ + disable_preemption(); + + /* everything should be printed now so copy to NVRAM + */ + if( debug_buf_size > 0) + pi_size = PESavePanicInfo( debug_buf, debug_buf_ptr - debug_buf); + + if( !panicDebugging && (pi_size != 0) ) { + int my_cpu, debugger_cpu; + int tcpu; + + my_cpu = cpu_number(); + debugger_cpu = my_cpu; + + hw_atomic_add(&debug_mode, 1); + debugger_active[my_cpu]++; + lock_debugger(); + + for(tcpu = 0; tcpu < NCPUS; tcpu++) { + if(tcpu == my_cpu) continue; + hw_atomic_add(&debugger_sync, 1); + (void)cpu_signal(tcpu, SIGPdebug, 0 ,0); + } + (void)hw_cpu_sync(&debugger_sync, LockTimeOut); + debugger_sync = 0; + } + + draw_panic_dialog(); + + if( !panicDebugging && (pi_size != 0)) + PEHaltRestart( kPEHangCPU ); + + enable_preemption(); + } + + if ((current_debugger != NO_CUR_DB)) { /* If there is a debugger configured, enter it */ printf("Debugger(%s)\n", message); TRAP_DEBUGGER; @@ -561,13 +624,13 @@ void SysChoked(int type, savearea *sv) { /* The system is bad dead */ disableDebugOuput = FALSE; debug_mode = TRUE; - failcode = sv->save_r3; /* Get the failure code */ + failcode = (unsigned int)sv->save_r3; /* Get the failure code */ if(failcode > failUnknown) failcode = failUnknown; /* Set unknown code code */ - kprintf("System Failure: cpu=%d; code=%08X (%s)\n", cpu_number(), sv->save_r3, failNames[failcode]); - printf("System Failure: cpu=%d; code=%08X (%s)\n", cpu_number(), sv->save_r3, failNames[failcode]); + kprintf("System Failure: cpu=%d; code=%08X (%s)\n", cpu_number(), (unsigned int)sv->save_r3, failNames[failcode]); + kdb_printf("System Failure: cpu=%d; code=%08X (%s)\n", cpu_number(), (unsigned int)sv->save_r3, failNames[failcode]); - print_backtrace((struct ppc_saved_state *)sv); /* Attempt to print backtrace */ + print_backtrace(sv); /* Attempt to print backtrace */ Call_DebuggerC(type, sv); /* Attempt to get into debugger */ if ((current_debugger != NO_CUR_DB)) Call_DebuggerC(type, sv); /* Attempt to get into debugger */ @@ -583,10 +646,11 @@ void SysChoked(int type, savearea *sv) { /* The system is bad dead */ int Call_DebuggerC( int type, - struct ppc_saved_state *saved_state) + struct savearea *saved_state) { int directcall, wait; - vm_offset_t instr_ptr; + addr64_t instr_ptr; + ppnum_t instr_pp; unsigned int instr; int my_cpu, tcpu; @@ -615,16 +679,19 @@ int Call_DebuggerC( kprintf("Call_DebuggerC(%d): %08X %08X, debact = %d\n", my_cpu, type, saved_state, debug_mode); /* (TEST/DEBUG) */ #endif printf("Call_Debugger: enter - cpu %d, is_slave %d, debugger_cpu %d, pc %08X\n", - my_cpu, debugger_is_slave[my_cpu], debugger_cpu, saved_state->srr0); + my_cpu, debugger_is_slave[my_cpu], debugger_cpu, saved_state->save_srr0); } - if (instr_ptr = (vm_offset_t)LRA(PPC_SID_KERNEL, (void *)(saved_state->srr0))) { - instr = ml_phys_read(instr_ptr); /* Get the trap that caused entry */ + instr_pp = (vm_offset_t)pmap_find_phys(kernel_pmap, (addr64_t)(saved_state->save_srr0)); + + if (instr_pp) { + instr_ptr = (addr64_t)(((addr64_t)instr_pp << 12) | (saved_state->save_srr0 & 0xFFF)); /* Make physical address */ + instr = ml_phys_read_64(instr_ptr); /* Get the trap that caused entry */ } else instr = 0; #if 0 - if (debugger_debug) kprintf("Call_DebuggerC(%d): instr_ptr = %08X, instr = %08X\n", my_cpu, instr_ptr, instr); /* (TEST/DEBUG) */ + if (debugger_debug) kprintf("Call_DebuggerC(%d): instr_pp = %08X, instr_ptr = %016llX, instr = %08X\n", my_cpu, instr_pp, instr_ptr, instr); /* (TEST/DEBUG) */ #endif if (db_breakpoints_inserted) cpus_holding_bkpts++; /* Bump up the holding count */ @@ -654,7 +721,7 @@ int Call_DebuggerC( switch_debugger = 0; /* Make sure switch request is off */ directcall = 1; /* Assume direct call */ - if (saved_state->srr1 & MASK(SRR1_PRG_TRAP)) { /* Trap instruction? */ + if (saved_state->save_srr1 & MASK(SRR1_PRG_TRAP)) { /* Trap instruction? */ directcall = 0; /* We had a trap not a direct call */ @@ -736,7 +803,7 @@ debugger_exit: instr, my_cpu, debugger_cpu, db_run_mode); /* (TEST/DEBUG) */ #endif if ((instr == TRAP_DEBUGGER_INST) || /* Did we trap to enter debugger? */ - (instr == TRAP_DIRECT_INST)) saved_state->srr0 += TRAP_INST_SIZE; /* Yes, point past trap */ + (instr == TRAP_DIRECT_INST)) saved_state->save_srr0 += TRAP_INST_SIZE; /* Yes, point past trap */ if(debugger_cpu == my_cpu) LLTraceSet(lastTrace); /* Enable tracing on the way out if we are debugger */