xnu-344.21.73.tar.gz

[apple/xnu.git] / osfmk / ppc / model_dep.c

diff --git a/osfmk/ppc/model_dep.c b/osfmk/ppc/model_dep.c
index 8241a64346aa5eebf78be659b4d19b629c1c2ea4..6d1ae0b7a8151ae26591be64e2f45b9d55db2560 100644 (file)
--- a/osfmk/ppc/model_dep.c
+++ b/osfmk/ppc/model_dep.c
@@ -3,19 +3,22 @@
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @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,
  * 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@
  */
  * 
  * @APPLE_LICENSE_HEADER_END@
  */


@@ -83,6 +86,7 @@
 #include <ppc/FirmwareCalls.h>
 #include <ppc/setjmp.h>
 #include <ppc/exception.h>
 #include <ppc/FirmwareCalls.h>
 #include <ppc/setjmp.h>
 #include <ppc/exception.h>

+#include <ppc/hw_perfmon.h>

 
 #include <kern/clock.h>
 #include <kern/debug.h>
 
 #include <kern/clock.h>
 #include <kern/debug.h>


@@ -125,8 +129,8 @@ char env_buf[256];
  * from on to another using kdb_on! #cpu or cpu #cpu
  */
 
  * 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 */
 
 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 */
        "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[];
 };
 
 char *invxcption = "Unknown code";
 
 extern const char version[];
 extern char *trap_type[];

-extern vm_offset_t mem_actual;

 
 #if !MACH_KDB
 
 #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
        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
        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_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 */
        }
 
        hw_lock_init(&debugger_lock);                           /* initialize debugger lock */


@@ -253,13 +262,6 @@ machine_startup(boot_args *args)
 
                default_preemption_rate = boot_arg;
        }
 
                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;
 
        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.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();
 }
 
 void
 machine_init(void)
 {
        clock_config();

+       perfmon_init();

 }
 
 void slave_machine_init(void)
 }
 
 void slave_machine_init(void)


@@ -353,7 +356,7 @@ void machine_callstack(
 
 
 void
 
 
 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;
 {
        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;
        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.
 
 /*
  *     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(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? */
        
        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 */
                __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 */
                        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 */
                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; 
        }
        
                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... */
 
        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? */
                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 */
                }
                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 */        
                }       
                
                        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 */
 
        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 */
        
        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? */
        
        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;
        }
        
        return;


@@ -462,39 +481,39 @@ void dump_backtrace(unsigned int stackptr, unsigned int fence) {
        unsigned int  sframe[8], raddr, dumbo;
        int i;
        
        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... */
                
        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;
                }
 
                        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;
                }
        
                        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;
                }
        
                        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 */
        
 }
        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];
 
        int i;
        unsigned int store[8];

+       unsigned long pi_size = 0;

        spl_t spl;
        
        spl = splhigh();                                                                /* No interruptions from here on */
        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... */
        }
 
                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;
        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;
 
        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 */
        
        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 */
        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,
 
 int Call_DebuggerC(
         int    type,

-        struct ppc_saved_state *saved_state)
+        struct savearea *saved_state)

 {
        int                             directcall, wait;
 {
        int                             directcall, wait;

-       vm_offset_t             instr_ptr;
+       addr64_t                instr_ptr;
+       ppnum_t                 instr_pp;

        unsigned int    instr;
        int                     my_cpu, tcpu;
 
        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",
                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
        } 
        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 */
 #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 */
 
        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 */
 
                
                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, 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 */
 
 
        if(debugger_cpu == my_cpu) LLTraceSet(lastTrace);       /* Enable tracing on the way out if we are debugger */