xnu-792.25.20.tar.gz

[apple/xnu.git] / osfmk / kdp / ml / i386 / kdp_machdep.c

diff --git a/osfmk/kdp/ml/i386/kdp_machdep.c b/osfmk/kdp/ml/i386/kdp_machdep.c
index 6211fdae976ca1335d12f8969d7fc808f5f03002..09e93e2b4033df76527b7aa22f27c1573954bf1a 100644 (file)
--- a/osfmk/kdp/ml/i386/kdp_machdep.c
+++ b/osfmk/kdp/ml/i386/kdp_machdep.c
@@ -3,32 +3,40 @@
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @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,
  * 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@
  */
  
  * 
  * @APPLE_LICENSE_HEADER_END@
  */
  

+#include <mach_kdp.h>

 #include <mach/mach_types.h>
 #include <mach/machine.h>
 #include <mach/exception_types.h>
 #include <mach/mach_types.h>
 #include <mach/machine.h>
 #include <mach/exception_types.h>

+#include <kern/cpu_data.h>

 #include <i386/trap.h>
 #include <i386/mp.h>
 #include <kdp/kdp_internal.h>
 #include <i386/trap.h>
 #include <i386/mp.h>
 #include <kdp/kdp_internal.h>

+#include <mach-o/loader.h>
+#include <mach-o/nlist.h>
+#include <IOKit/IOPlatformExpert.h> /* for PE_halt_restart */
+#include <kern/machine.h> /* for halt_all_cpus */
+
+#include <kern/thread.h>
+#include <i386/thread.h>
+#include <vm/vm_map.h>
+#include <i386/pmap.h>

 
 #define KDP_TEST_HARNESS 0
 #if KDP_TEST_HARNESS
 
 #define KDP_TEST_HARNESS 0
 #if KDP_TEST_HARNESS


@@ -37,10 +45,24 @@
 #define dprintf(x)
 #endif
 
 #define dprintf(x)
 #endif
 

-void print_saved_state(void *);
-void kdp_call(void);
-void kdp_i386_trap(unsigned int, struct i386_saved_state *, kern_return_t, vm_offset_t);
-int kdp_getc(void);
+extern cpu_type_t cpuid_cputype(void);
+extern cpu_subtype_t cpuid_cpusubtype(void);
+
+void           print_saved_state(void *);
+void           kdp_call(void);
+int            kdp_getc(void);
+boolean_t      kdp_call_kdb(void);
+void           kdp_getstate(i386_thread_state_t *);
+void           kdp_setstate(i386_thread_state_t *);
+void           kdp_print_phys(int);
+
+int
+machine_trace_thread(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p);
+
+int
+machine_trace_thread64(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p);
+
+extern unsigned kdp_vm_read(caddr_t src, caddr_t dst, unsigned len);

 
 void
 kdp_exception(
 
 void
 kdp_exception(


@@ -84,7 +106,7 @@ kdp_exception_ack(
 {
     kdp_exception_ack_t        *rq = (kdp_exception_ack_t *)pkt;
 
 {
     kdp_exception_ack_t        *rq = (kdp_exception_ack_t *)pkt;
 

-    if (len < sizeof (*rq))
+    if (((unsigned int) len) < sizeof (*rq))

        return(FALSE);
        
     if (!rq->hdr.is_reply || rq->hdr.request != KDP_EXCEPTION)
        return(FALSE);
        
     if (!rq->hdr.is_reply || rq->hdr.request != KDP_EXCEPTION)


@@ -101,14 +123,15 @@ kdp_exception_ack(
 
 void
 kdp_getstate(
 
 void
 kdp_getstate(

-    i386_thread_state_t                *state
+    x86_thread_state32_t       *state

 )
 {
 )
 {

-    struct i386_saved_state    *saved_state;
+    static x86_thread_state32_t        null_state;
+    x86_saved_state32_t        *saved_state;

     
     

-    saved_state = (struct i386_saved_state *)kdp.saved_state;
+    saved_state = (x86_saved_state32_t *)kdp.saved_state;

     
     

-    *state = (i386_thread_state_t) { 0 };      
+    *state = null_state;       

     state->eax = saved_state->eax;
     state->ebx = saved_state->ebx;
     state->ecx = saved_state->ecx;
     state->eax = saved_state->eax;
     state->ebx = saved_state->ebx;
     state->ecx = saved_state->ecx;


@@ -137,12 +160,12 @@ kdp_getstate(
 
 void
 kdp_setstate(
 
 void
 kdp_setstate(

-    i386_thread_state_t                *state
+    x86_thread_state32_t       *state

 )
 {
 )
 {

-    struct i386_saved_state    *saved_state;
+    x86_saved_state32_t                *saved_state;

     
     

-    saved_state = (struct i386_saved_state *)kdp.saved_state;
+    saved_state = (x86_saved_state32_t *)kdp.saved_state;

 
     saved_state->eax = state->eax;
     saved_state->ebx = state->ebx;
 
     saved_state->eax = state->eax;
     saved_state->ebx = state->ebx;


@@ -164,48 +187,53 @@ kdp_setstate(
 
 kdp_error_t
 kdp_machine_read_regs(
 
 kdp_error_t
 kdp_machine_read_regs(

-    unsigned int cpu,
-    unsigned int flavor,
+    __unused unsigned int cpu,
+    __unused unsigned int flavor,

     char *data,
     char *data,

-    int *size
+    __unused int *size

 )
 {
 )
 {

+    static struct i386_float_state  null_fpstate;
+

     switch (flavor) {
 
     switch (flavor) {
 

-    case i386_THREAD_STATE:
+    case OLD_i386_THREAD_STATE:
+    case x86_THREAD_STATE32:

        dprintf(("kdp_readregs THREAD_STATE\n"));
        dprintf(("kdp_readregs THREAD_STATE\n"));

-       kdp_getstate((i386_thread_state_t *)data);
-       *size = sizeof (i386_thread_state_t);
+       kdp_getstate((x86_thread_state32_t *)data);
+       *size = sizeof (x86_thread_state32_t);

        return KDPERR_NO_ERROR;
        
        return KDPERR_NO_ERROR;
        

-    case i386_THREAD_FPSTATE:
+    case x86_FLOAT_STATE32:

        dprintf(("kdp_readregs THREAD_FPSTATE\n"));
        dprintf(("kdp_readregs THREAD_FPSTATE\n"));

-       *(i386_thread_fpstate_t *)data = (i386_thread_fpstate_t) { 0 }; 
-       *size = sizeof (i386_thread_fpstate_t);
+       *(x86_float_state32_t *)data = null_fpstate;
+       *size = sizeof (x86_float_state32_t);

        return KDPERR_NO_ERROR;
        
     default:
        return KDPERR_NO_ERROR;
        
     default:

-       dprintf(("kdp_readregs bad flavor %d\n"));
+       dprintf(("kdp_readregs bad flavor %d\n", flavor));
+       *size = 0;

        return KDPERR_BADFLAVOR;
     }
 }
 
 kdp_error_t
 kdp_machine_write_regs(
        return KDPERR_BADFLAVOR;
     }
 }
 
 kdp_error_t
 kdp_machine_write_regs(

-    unsigned int cpu,
+    __unused unsigned int cpu,

     unsigned int flavor,
     char *data,
     unsigned int flavor,
     char *data,

-    int *size
+    __unused int *size

 )
 {
     switch (flavor) {
 
 )
 {
     switch (flavor) {
 

-    case i386_THREAD_STATE:
+    case OLD_i386_THREAD_STATE:
+    case x86_THREAD_STATE32:

        dprintf(("kdp_writeregs THREAD_STATE\n"));
        dprintf(("kdp_writeregs THREAD_STATE\n"));

-       kdp_setstate((i386_thread_state_t *)data);
+       kdp_setstate((x86_thread_state32_t *)data);

        return KDPERR_NO_ERROR;
        
        return KDPERR_NO_ERROR;
        

-    case i386_THREAD_FPSTATE:
+    case x86_FLOAT_STATE32:

        dprintf(("kdp_writeregs THREAD_FPSTATE\n"));
        return KDPERR_NO_ERROR;
        
        dprintf(("kdp_writeregs THREAD_FPSTATE\n"));
        return KDPERR_NO_ERROR;
        


@@ -222,22 +250,19 @@ kdp_machine_hostinfo(
     kdp_hostinfo_t *hostinfo
 )
 {
     kdp_hostinfo_t *hostinfo
 )
 {

-    machine_slot_t     m;

     int                        i;
 
     hostinfo->cpus_mask = 0;
 
     for (i = 0; i < machine_info.max_cpus; i++) {
     int                        i;
 
     hostinfo->cpus_mask = 0;
 
     for (i = 0; i < machine_info.max_cpus; i++) {

-        m = &machine_slot[i];
-        if (!m->is_cpu)
+       if (cpu_data_ptr[i] == NULL)

             continue;
        
         hostinfo->cpus_mask |= (1 << i);
     }
 
             continue;
        
         hostinfo->cpus_mask |= (1 << i);
     }
 

-   /* FIXME?? */
-    hostinfo->cpu_type = CPU_TYPE_I386;
-    hostinfo->cpu_subtype = CPU_SUBTYPE_486;
+    hostinfo->cpu_type = cpuid_cputype();
+    hostinfo->cpu_subtype = cpuid_cpusubtype();

 }
 
 void
 }
 
 void


@@ -245,7 +270,7 @@ kdp_panic(
     const char         *msg
 )
 {
     const char         *msg
 )
 {

-    printf("kdp panic: %s\n", msg);    
+    kprintf("kdp panic: %s\n", msg);    

     __asm__ volatile("hlt");   
 }
 
     __asm__ volatile("hlt");   
 }
 


@@ -253,7 +278,12 @@ kdp_panic(
 void
 kdp_reboot(void)
 {
 void
 kdp_reboot(void)
 {

-    kdreboot();
+       printf("Attempting system restart...");
+       /* Call the platform specific restart*/
+       if (PE_halt_restart)
+               (*PE_halt_restart)(kPERestartCPU);
+       /* If we do reach this, give up */
+       halt_all_cpus(TRUE);

 }
 
 int
 }
 
 int


@@ -277,21 +307,19 @@ kdp_getc()
 void
 kdp_us_spin(int usec)
 {
 void
 kdp_us_spin(int usec)
 {

-    extern void delay(int);
-

     delay(usec/100);
 }
 
 void print_saved_state(void *state)
 {
     delay(usec/100);
 }
 
 void print_saved_state(void *state)
 {

-    struct i386_saved_state    *saved_state;
+    x86_saved_state32_t                *saved_state;

 
     saved_state = state;
 
 
     saved_state = state;
 

-       printf("pc = 0x%x\n", saved_state->eip);
-       printf("cr3= 0x%x\n", saved_state->cr2);
-       printf("rp = TODO FIXME\n");
-       printf("sp = 0x%x\n", saved_state->esp);
+       kprintf("pc = 0x%x\n", saved_state->eip);
+       kprintf("cr2= 0x%x\n", saved_state->cr2);
+       kprintf("rp = TODO FIXME\n");
+       kprintf("sp = 0x%x\n", saved_state);

 
 }
 
 
 }
 


@@ -314,50 +342,47 @@ typedef struct _cframe_t {
     unsigned           args[0];
 } cframe_t;
 
     unsigned           args[0];
 } cframe_t;
 

-
-#define MAX_FRAME_DELTA                65536
+#include <i386/pmap.h>
+extern pt_entry_t *DMAP2;
+extern caddr_t DADDR2;

 
 void
 
 void

-kdp_i386_backtrace(void        *_frame, int nframes)
+kdp_print_phys(int src)

 {
 {

-       cframe_t        *frame = (cframe_t *)_frame;
-       int i;
-
-       for (i=0; i<nframes; i++) {
-           if ((vm_offset_t)frame < VM_MIN_KERNEL_ADDRESS ||
-               (vm_offset_t)frame > VM_MAX_KERNEL_ADDRESS) {
-               goto invalid;
-           }
-           printf("frame %x called by %x ",
-               frame, frame->caller);
-           printf("args %x %x %x %x\n",
-               frame->args[0], frame->args[1],
-               frame->args[2], frame->args[3]);
-           if ((frame->prev < frame) ||        /* wrong direction */
-               ((frame->prev - frame) > MAX_FRAME_DELTA)) {
-               goto invalid;
-           }
-           frame = frame->prev;
+       unsigned int   *iptr;
+       int             i;
+
+       *(int *) DMAP2 = 0x63 | (src & 0xfffff000);
+       invlpg((u_int) DADDR2);
+       iptr = (unsigned int *) DADDR2;
+       for (i = 0; i < 100; i++) {
+               kprintf("0x%x ", *iptr++);
+               if ((i % 8) == 0)
+                       kprintf("\n");

        }
        }

-       return;
-invalid:
-       printf("invalid frame pointer %x\n",frame);
+       kprintf("\n");
+       *(int *) DMAP2 = 0;
+

 }
 
 }
 

-void
+boolean_t

 kdp_i386_trap(
 kdp_i386_trap(

-    unsigned int               trapno,
-    struct i386_saved_state    *saved_state,
+    unsigned int       trapno,
+    x86_saved_state32_t        *saved_state,

     kern_return_t      result,
     vm_offset_t                va
 )
 {
     unsigned int exception, subcode = 0, code;
 
     kern_return_t      result,
     vm_offset_t                va
 )
 {
     unsigned int exception, subcode = 0, code;
 

-    mp_kdp_enter();
+    if (trapno != T_INT3 && trapno != T_DEBUG) {
+       kprintf("unexpected kernel trap 0x%x eip 0x%x cr2 0x%x \n",
+               trapno, saved_state->eip, saved_state->cr2);
+       if (!kdp.is_conn)
+           return FALSE;
+    }  

 
 

-    if (trapno != T_INT3 && trapno != T_DEBUG)
-       printf("unexpected kernel trap %x eip %x\n", trapno, saved_state->eip);
+    mp_kdp_enter();

 
     switch (trapno) {
     
 
     switch (trapno) {
     


@@ -422,11 +447,11 @@ kdp_i386_trap(
        break;
     }
 
        break;
     }
 

-//    kdp_i386_backtrace((void *) saved_state->ebp, 10);
-

     kdp_raise_exception(exception, code, subcode, saved_state);
 
     mp_kdp_exit();
     kdp_raise_exception(exception, code, subcode, saved_state);
 
     mp_kdp_exit();

+
+    return TRUE;

 }
 
 boolean_t 
 }
 
 boolean_t 


@@ -436,7 +461,89 @@ kdp_call_kdb(
         return(FALSE);
 }
 
         return(FALSE);
 }
 

-unsigned int kdp_ml_get_breakinsn()
+unsigned int
+kdp_ml_get_breakinsn(void)

 {
   return 0xcc;
 }
 {
   return 0xcc;
 }

+extern pmap_t kdp_pmap;
+
+#define RETURN_OFFSET 4
+int
+machine_trace_thread(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p)
+{
+       uint32_t *tracebuf = (uint32_t *)tracepos;
+       uint32_t fence = 0;
+       uint32_t stackptr = 0;
+       uint32_t stacklimit = 0xfc000000;
+       int framecount = 0;
+       uint32_t init_eip = 0;
+       uint32_t prevsp = 0;
+       uint32_t framesize = 2 * sizeof(vm_offset_t);
+       
+       if (user_p) {
+               x86_saved_state32_t     *iss32;
+               
+               iss32 = USER_REGS32(thread);
+
+               init_eip = iss32->eip;
+               stackptr = iss32->ebp;
+
+               /* This bound isn't useful, but it doesn't hinder us*/
+               stacklimit = 0xffffffff;
+               kdp_pmap = thread->task->map->pmap;
+       }
+       else {
+               /*Examine the i386_saved_state at the base of the kernel stack*/
+               stackptr = STACK_IKS(thread->kernel_stack)->k_ebp;
+               init_eip = STACK_IKS(thread->kernel_stack)->k_eip;
+       }
+
+       *tracebuf++ = init_eip;
+
+       for (framecount = 0; framecount < nframes; framecount++) {
+
+               if ((tracebound - ((uint32_t) tracebuf)) < (4 * framesize)) {
+                       tracebuf--;
+                       break;
+               }
+
+               *tracebuf++ = stackptr;
+/* Invalid frame, or hit fence */
+               if (!stackptr || (stackptr == fence)) {
+                       break;
+               }
+               /* Stack grows downward */
+               if (stackptr < prevsp) {
+                       break;
+               }
+               /* Unaligned frame */
+               if (stackptr & 0x0000003) {
+                       break;
+               }
+               if (stackptr > stacklimit) {
+                       break;
+               }
+
+               if (kdp_vm_read((caddr_t) (stackptr + RETURN_OFFSET), (caddr_t) tracebuf, sizeof(caddr_t)) != sizeof(caddr_t)) {
+                       break;
+               }
+               tracebuf++;
+               
+               prevsp = stackptr;
+               if (kdp_vm_read((caddr_t) stackptr, (caddr_t) &stackptr, sizeof(caddr_t)) != sizeof(caddr_t)) {
+                       *tracebuf++ = 0;
+                       break;
+               }
+       }
+
+       kdp_pmap = 0;
+
+       return ((uint32_t) tracebuf - tracepos);
+}
+
+/* This is a stub until the x86 64-bit model becomes clear */
+int
+machine_trace_thread64(__unused thread_t thread, __unused uint32_t tracepos, __unused uint32_t tracebound, __unused int nframes, __unused boolean_t user_p) {
+       return 0;
+}