X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d7e50217d7adf6e52786a38bcaa4cd698cb9a79e..6601e61aa18bf4f09af135ff61fc7f4771d23b06:/osfmk/ppc/model_dep.c diff --git a/osfmk/ppc/model_dep.c b/osfmk/ppc/model_dep.c index 6d1ae0b7a..b88e4af64 100644 --- a/osfmk/ppc/model_dep.c +++ b/osfmk/ppc/model_dep.c @@ -1,24 +1,21 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * - * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. + * 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. * - * 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 + * This 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, QUIET ENJOYMENT OR NON-INFRINGEMENT. - * Please see the License for the specific language governing rights and - * limitations under the License. + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. * * @APPLE_LICENSE_HEADER_END@ */ @@ -60,11 +57,9 @@ #include #include #include -#include #include #include -#include #include #include @@ -84,16 +79,16 @@ #include #include #include -#include +#include #include #include +#include #include #include #include #include #include -#include #include @@ -134,10 +129,6 @@ hw_lock_data_t pbtlock; /* backtrace print lock */ int debugger_cpu = -1; /* current cpu running debugger */ int debugger_debug = 0; /* Debug debugger */ -int debugger_is_slave[NCPUS]; /* Show that we were entered via sigp */ -int debugger_active[NCPUS]; /* Debugger active on CPU */ -int debugger_pending[NCPUS]; /* Debugger entry pending on CPU (this is a HACK) */ -int debugger_holdoff[NCPUS]; /* Holdoff debugger entry on this CPU (this is a HACK) */ int db_run_mode; /* Debugger run mode */ unsigned int debugger_sync = 0; /* Cross processor debugger entry sync */ extern unsigned int NMIss; /* NMI debounce switch */ @@ -148,14 +139,17 @@ volatile unsigned int pbtcpu = -1; unsigned int lastTrace; /* Value of low-level exception trace controls */ + volatile unsigned int cpus_holding_bkpts; /* counter for number of cpus holding breakpoints (ie: cpus that did not insert back breakpoints) */ void unlock_debugger(void); void lock_debugger(void); -void dump_backtrace(unsigned int stackptr, unsigned int fence); +void dump_backtrace(savearea *sv, unsigned int stackptr, unsigned int fence); void dump_savearea(savearea *sv, unsigned int fence); +int packAsc (unsigned char *inbuf, unsigned int length); + #if !MACH_KDB boolean_t db_breakpoints_inserted = TRUE; jmp_buf_t *db_recover = 0; @@ -186,7 +180,10 @@ char *failNames[] = { "No saveareas", /* failNoSavearea */ "Savearea corruption", /* failSaveareaCorr */ "Invalid live context", /* failBadLiveContext */ + "Corrupt skip lists", /* failSkipLists */ "Unaligned stack", /* failUnalignedStk */ + "Invalid pmap", /* failPmap */ + "Lock timeout", /* failTimeout */ "Unknown failure code" /* Unknown failure code - must always be last */ }; @@ -213,12 +210,13 @@ void machine_startup(boot_args *args) { int boot_arg; + unsigned int wncpu; + unsigned int vmm_arg; if (PE_parse_boot_arg("cpus", &wncpu)) { - if (!((wncpu > 0) && (wncpu < NCPUS))) - wncpu = NCPUS; - } else - wncpu = NCPUS; + if ((wncpu > 0) && (wncpu < MAX_CPUS)) + max_ncpus = wncpu; + } if( PE_get_hotkey( kPEControlKey )) halt_in_debugger = halt_in_debugger ? 0 : 1; @@ -230,6 +228,8 @@ machine_startup(boot_args *args) if (boot_arg & DB_NMI) panicDebugging=TRUE; if (boot_arg & DB_LOG_PI_SCRN) logPanicDataToScreen=TRUE; } + + PE_parse_boot_arg("vmmforce", &lowGlo.lgVMMforcedFeats); hw_lock_init(&debugger_lock); /* initialize debugger lock */ hw_lock_init(&pbtlock); /* initialize print backtrace lock */ @@ -280,14 +280,11 @@ machine_startup(boot_args *args) machine_conf(); - ml_thrm_init(); /* Start thermal monitoring on this processor */ - /* - * Start the system. + * Kick off the kernel bootstrap. */ - setup_main(); - - /* Should never return */ + kernel_bootstrap(); + /*NOTREACHED*/ } char * @@ -301,8 +298,6 @@ machine_boot_info( void machine_conf(void) { - machine_info.max_cpus = NCPUS; - machine_info.avail_cpus = 1; machine_info.memory_size = mem_size; /* Note that this will be 2 GB for >= 2 GB machines */ } @@ -310,14 +305,17 @@ void machine_init(void) { clock_config(); +/* Note that we must initialize the stepper tables AFTER the clock is configured!!!!! */ + if(pmsExperimental & 1) pmsCPUConf(); /* (EXPERIMENTAL) Initialize the stepper tables */ perfmon_init(); + return; + } void slave_machine_init(void) { - (void) ml_set_interrupts_enabled(FALSE); /* Make sure we are disabled */ - clock_init(); /* Init the clock */ cpu_machine_init(); /* Initialize the processor */ + clock_init(); /* Init the clock */ } void @@ -362,7 +360,6 @@ print_backtrace(struct savearea *ssp) int i, frames_cnt, skip_top_frames, frames_max; unsigned int store[8]; /* Buffer for real storage reads */ vm_offset_t backtrace_entries[32]; - thread_act_t *act; savearea *sv, *svssp; int cpu; savearea *psv; @@ -373,14 +370,14 @@ print_backtrace(struct savearea *ssp) cpu = cpu_number(); /* Just who are we anyways? */ if(pbtcpu != cpu) { /* Allow recursion */ - hw_atomic_add(&pbtcnt, 1); /* Remember we are trying */ + hw_atomic_add((uint32_t *)&pbtcnt, 1); /* Remember we are trying */ while(!hw_lock_try(&pbtlock)); /* Spin here until we can get in. If we never do, well, we're crashing anyhow... */ pbtcpu = cpu; /* Mark it as us */ } svssp = (savearea *)ssp; /* Make this easier */ sv = 0; - if(current_thread()) sv = (savearea *)current_act()->mact.pcb; /* Find most current savearea if system has started */ + if(current_thread()) sv = (savearea *)current_thread()->machine.pcb; /* Find most current savearea if system has started */ fence = 0xFFFFFFFF; /* Show we go all the way */ if(sv) fence = (unsigned int)sv->save_r1; /* Stop at previous exception point */ @@ -388,7 +385,7 @@ print_backtrace(struct savearea *ssp) if(!svssp) { /* Should we start from stack? */ 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 */ + dump_backtrace((savearea *)0,stackptr, fence); /* Dump the backtrace */ if(!sv) { /* Leave if no saveareas */ kdb_printf("\nKernel version:\n%s\n",version); /* Print kernel version */ hw_lock_unlock(&pbtlock); /* Allow another back trace to happen */ @@ -418,7 +415,8 @@ print_backtrace(struct savearea *ssp) kdb_printf("Proceeding back via exception chain:\n"); while(sv) { /* Do them all... */ - if(!((sv <= vm_last_addr) && (unsigned int)pmap_find_phys(kernel_pmap, (addr64_t)sv))) { /* Valid address? */ + if(!(((addr64_t)((uintptr_t)sv) <= vm_last_addr) && + (unsigned int)pmap_find_phys(kernel_pmap, (addr64_t)((uintptr_t)sv)))) { /* Valid address? */ kdb_printf(" Exception state (sv=0x%08X) Not mapped or invalid. stopping...\n", sv); break; } @@ -438,14 +436,14 @@ print_backtrace(struct savearea *ssp) dump_savearea(sv, fence); /* Dump this savearea */ } - sv = (savearea *)sv->save_hdr.save_prev; /* Back chain */ + sv = CAST_DOWN(savearea *, sv->save_hdr.save_prev); /* Back chain */ } 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 */ - hw_atomic_sub(&pbtcnt, 1); /* Show we are done */ + hw_atomic_sub((uint32_t *) &pbtcnt, 1); /* Show we are done */ while(pbtcnt); /* Wait for completion */ @@ -464,7 +462,7 @@ void dump_savearea(savearea *sv, unsigned int fence) { (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((unsigned int)sv->save_r1, fence); /* Dump the stack back trace from here if not user state */ + dump_backtrace(sv, (unsigned int)sv->save_r1, fence); /* Dump the stack back trace from here if not user state */ } return; @@ -472,17 +470,22 @@ void dump_savearea(savearea *sv, unsigned int fence) { -#define DUMPFRAMES 32 +#define DUMPFRAMES 34 #define LRindex 2 -void dump_backtrace(unsigned int stackptr, unsigned int fence) { +void dump_backtrace(savearea *sv, unsigned int stackptr, unsigned int fence) { unsigned int bframes[DUMPFRAMES]; unsigned int sframe[8], raddr, dumbo; - int i; + int i, index=0; kdb_printf(" Backtrace:\n"); - for(i = 0; i < DUMPFRAMES; i++) { /* Dump up to max frames */ + if (sv != (savearea *)0) { + bframes[0] = (unsigned int)sv->save_srr0; + bframes[1] = (unsigned int)sv->save_lr; + index = 2; + } + for(i = index; i < DUMPFRAMES; i++) { /* Dump up to max frames */ if(!stackptr || (stackptr == fence)) break; /* Hit stop point or end... */ @@ -543,7 +546,7 @@ Debugger(const char *message) { } } - if (debug_mode && debugger_active[cpu_number()]) { /* Are we already on debugger on this processor? */ + if (debug_mode && getPerProc()->debugger_active) { /* Are we already on debugger on this processor? */ splx(spl); return; /* Yeah, don't do it again... */ } @@ -560,20 +563,46 @@ Debugger(const char *message) { /* everything should be printed now so copy to NVRAM */ if( debug_buf_size > 0) - pi_size = PESavePanicInfo( debug_buf, debug_buf_ptr - debug_buf); + + { + /* Do not compress the panic log unless kernel debugging + * is disabled - the panic log isn't synced to NVRAM if + * debugging is enabled, and the panic log is valuable + * whilst debugging + */ + if (!panicDebugging) + { + unsigned int bufpos; + + /* Now call the compressor */ + bufpos = packAsc (debug_buf, (unsigned int) (debug_buf_ptr - debug_buf) ); + /* If compression was successful, use the compressed length */ + if (bufpos) + { + debug_buf_ptr = debug_buf + bufpos; + } + } + /* Truncate if the buffer is larger than a certain magic + * size - this really ought to be some appropriate fraction + * of the NVRAM image buffer, and is best done in the + * savePanicInfo() or PESavePanicInfo() calls + */ + pi_size = debug_buf_ptr - debug_buf; + pi_size = PESavePanicInfo( debug_buf, ((pi_size > 2040) ? 2040 : pi_size)); + } if( !panicDebugging && (pi_size != 0) ) { - int my_cpu, debugger_cpu; + int my_cpu; int tcpu; my_cpu = cpu_number(); debugger_cpu = my_cpu; hw_atomic_add(&debug_mode, 1); - debugger_active[my_cpu]++; + PerProcTable[my_cpu].ppe_vaddr->debugger_active++; lock_debugger(); - for(tcpu = 0; tcpu < NCPUS; tcpu++) { + for(tcpu = 0; tcpu < real_ncpus; tcpu++) { if(tcpu == my_cpu) continue; hw_atomic_add(&debugger_sync, 1); (void)cpu_signal(tcpu, SIGPdebug, 0 ,0); @@ -652,13 +681,15 @@ int Call_DebuggerC( addr64_t instr_ptr; ppnum_t instr_pp; unsigned int instr; - int my_cpu, tcpu; + int my_cpu, tcpu, wasdebugger; + struct per_proc_info *pp; + uint64_t nowtime, poptime; my_cpu = cpu_number(); /* Get our CPU */ #if MACH_KDB if((debugger_cpu == my_cpu) && /* Do we already own debugger? */ - debugger_active[my_cpu] && /* and are we really active? */ + PerProcTable[my_cpu].ppe_vaddr->debugger_active && /* and are we really active? */ db_recover && /* and have we set up recovery? */ (current_debugger == KDB_CUR_DB)) { /* and are we in KDB (only it handles recovery) */ kdb_trap(type, saved_state); /* Then reenter it... */ @@ -666,7 +697,8 @@ int Call_DebuggerC( #endif hw_atomic_add(&debug_mode, 1); /* Indicate we are in debugger */ - debugger_active[my_cpu]++; /* Show active on our CPU */ + PerProcTable[my_cpu].ppe_vaddr->debugger_active++; /* Show active on our CPU */ + lock_debugger(); /* Insure that only one CPU is in debugger */ if(db_im_stepping == my_cpu) { /* Are we just back from a step? */ @@ -679,7 +711,7 @@ 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->save_srr0); + my_cpu, PerProcTable[my_cpu].ppe_vaddr->debugger_is_slave, debugger_cpu, saved_state->save_srr0); } instr_pp = (vm_offset_t)pmap_find_phys(kernel_pmap, (addr64_t)(saved_state->save_srr0)); @@ -695,14 +727,16 @@ int Call_DebuggerC( #endif if (db_breakpoints_inserted) cpus_holding_bkpts++; /* Bump up the holding count */ - if (debugger_cpu == -1 && !debugger_is_slave[my_cpu]) { + if (debugger_cpu == -1 && !PerProcTable[my_cpu].ppe_vaddr->debugger_is_slave) { #if 0 if (debugger_debug) kprintf("Call_DebuggerC(%d): lasttrace = %08X\n", my_cpu, lastTrace); /* (TEST/DEBUG) */ #endif debugger_cpu = my_cpu; /* Show that we are debugger */ + + lastTrace = LLTraceSet(0); /* Disable low-level tracing */ - for(tcpu = 0; tcpu < NCPUS; tcpu++) { /* Stop all the other guys */ + for(tcpu = 0; tcpu < real_ncpus; tcpu++) { /* Stop all the other guys */ if(tcpu == my_cpu) continue; /* Don't diddle ourselves */ hw_atomic_add(&debugger_sync, 1); /* Count signal sent */ (void)cpu_signal(tcpu, SIGPdebug, 0 ,0); /* Tell 'em to enter debugger */ @@ -805,14 +839,18 @@ debugger_exit: if ((instr == TRAP_DEBUGGER_INST) || /* Did we trap to enter debugger? */ (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 */ + wasdebugger = 0; /* Assume not debugger */ + if(debugger_cpu == my_cpu) { /* Are the debugger processor? */ + wasdebugger = 1; /* Remember that we were the debugger */ + LLTraceSet(lastTrace); /* Enable tracing on the way out if we are debugger */ + } wait = FALSE; /* Assume we are not going to wait */ if (db_run_mode == STEP_CONTINUE) { /* Are we going to run? */ wait = TRUE; /* Yeah, remember to wait for breakpoints to clear */ debugger_cpu = -1; /* Release other processor's debuggers */ - debugger_pending[0] = 0; /* Release request (this is a HACK) */ - debugger_pending[1] = 0; /* Release request (this is a HACK) */ + for(tcpu = 0; tcpu < real_ncpus; tcpu++) + PerProcTable[tcpu].ppe_vaddr->debugger_pending = 0; /* Release request (this is a HACK) */ NMIss = 0; /* Let NMI bounce */ } @@ -822,17 +860,18 @@ debugger_exit: } if (db_breakpoints_inserted) cpus_holding_bkpts--; /* If any breakpoints, back off count */ - if (debugger_is_slave[my_cpu]) debugger_is_slave[my_cpu]--; /* If we were a slove, uncount us */ + if (PerProcTable[my_cpu].ppe_vaddr->debugger_is_slave) PerProcTable[my_cpu].ppe_vaddr->debugger_is_slave--; /* If we were a slove, uncount us */ if (debugger_debug) printf("Call_Debugger: exit - cpu %d, debugger_cpu %d, run_mode %d holds %d\n", my_cpu, debugger_cpu, db_run_mode, cpus_holding_bkpts); unlock_debugger(); /* Release the lock */ - debugger_active[my_cpu]--; /* Say we aren't active anymore */ + PerProcTable[my_cpu].ppe_vaddr->debugger_active--; /* Say we aren't active anymore */ if (wait) while(cpus_holding_bkpts); /* Wait for breakpoints to clear */ + hw_atomic_sub(&debug_mode, 1); /* Set out of debug now */ return(1); /* Exit debugger normally */ @@ -866,4 +905,38 @@ void unlock_debugger(void) { } +struct pasc { + unsigned a: 7; + unsigned b: 7; + unsigned c: 7; + unsigned d: 7; + unsigned e: 7; + unsigned f: 7; + unsigned g: 7; + unsigned h: 7; +} __attribute__((packed)); + +typedef struct pasc pasc_t; +int packAsc (unsigned char *inbuf, unsigned int length) +{ + unsigned int i, j = 0; + pasc_t pack; + + for (i = 0; i < length; i+=8) + { + pack.a = inbuf[i]; + pack.b = inbuf[i+1]; + pack.c = inbuf[i+2]; + pack.d = inbuf[i+3]; + pack.e = inbuf[i+4]; + pack.f = inbuf[i+5]; + pack.g = inbuf[i+6]; + pack.h = inbuf[i+7]; + bcopy ((char *) &pack, inbuf + j, 7); + j += 7; + } + if (0 != (i - length)) + inbuf[j - (i - length)] &= 0xFF << (8-(i - length)); + return j-(((i-length) == 7) ? 6 : (i - length)); +}