]> git.saurik.com Git - apple/xnu.git/blobdiff - osfmk/kdp/kdp.c
xnu-3789.51.2.tar.gz
[apple/xnu.git] / osfmk / kdp / kdp.c
index 9f72fb57e6f5268daff6503e46f9a10289acb180..ee2e9f8d80e52a7e975897f3664f639f82cfca93 100644 (file)
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2000-2007 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2012 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
@@ -27,6 +27,7 @@
  */
 
 #include <mach/mach_types.h>
  */
 
 #include <mach/mach_types.h>
+#include <mach/vm_param.h>
 #include <sys/appleapiopts.h>
 #include <kern/debug.h>
 #include <uuid/uuid.h>
 #include <sys/appleapiopts.h>
 #include <kern/debug.h>
 #include <uuid/uuid.h>
 #include <kdp/kdp_internal.h>
 #include <kdp/kdp_private.h>
 #include <kdp/kdp_core.h>
 #include <kdp/kdp_internal.h>
 #include <kdp/kdp_private.h>
 #include <kdp/kdp_core.h>
-#include <kdp/kdp_dyld.h>
 
 #include <libsa/types.h>
 
 #include <libsa/types.h>
+#include <libkern/version.h>
 
 #include <string.h> /* bcopy */
 
 #include <kern/processor.h>
 #include <kern/thread.h>
 
 #include <string.h> /* bcopy */
 
 #include <kern/processor.h>
 #include <kern/thread.h>
+#include <kern/clock.h>
 #include <vm/vm_map.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_map.h>
 #include <vm/vm_kern.h>
+#include <vm/vm_pageout.h>
+#include <vm/vm_shared_region.h>
+#include <libkern/OSKextLibPrivate.h>
 
 #define DO_ALIGN       1       /* align all packet data accesses */
 
 
 #define DO_ALIGN       1       /* align all packet data accesses */
 
@@ -116,24 +121,6 @@ int reattach_wait = 0;
 int noresume_on_disconnect = 0;
 extern unsigned int return_on_panic;
 
 int noresume_on_disconnect = 0;
 extern unsigned int return_on_panic;
 
-typedef struct thread_snapshot *thread_snapshot_t;
-typedef struct task_snapshot *task_snapshot_t;
-
-extern int
-machine_trace_thread(thread_t thread, char *tracepos, char *tracebound, int nframes, boolean_t user_p);
-extern int
-machine_trace_thread64(thread_t thread, char *tracepos, char *tracebound, int nframes, boolean_t user_p);
-extern int
-proc_pid(void *p);
-extern void
-proc_name_kdp(task_t  task, char *buf, int size);
-
-extern void
-kdp_snapshot_postflight(void);
-
-static int
-pid_from_task(task_t task);
-
 kdp_error_t
 kdp_set_breakpoint_internal(
                                                           mach_vm_address_t    address
 kdp_error_t
 kdp_set_breakpoint_internal(
                                                           mach_vm_address_t    address
@@ -144,15 +131,6 @@ kdp_remove_breakpoint_internal(
                                                           mach_vm_address_t    address
                                                           );
 
                                                           mach_vm_address_t    address
                                                           );
 
-
-int
-kdp_stackshot(int pid, void *tracebuf, uint32_t tracebuf_size, uint32_t trace_flags, uint32_t dispatch_offset, uint32_t *pbytesTraced);
-
-boolean_t kdp_copyin(pmap_t, uint64_t, void *, size_t);
-extern void bcopy_phys(addr64_t, addr64_t, vm_size_t);
-
-extern char version[];
-
 boolean_t
 kdp_packet(
     unsigned char      *pkt,
 boolean_t
 kdp_packet(
     unsigned char      *pkt,
@@ -165,9 +143,13 @@ kdp_packet(
     size_t             plen = *len;
     kdp_req_t          req;
     boolean_t          ret;
     size_t             plen = *len;
     kdp_req_t          req;
     boolean_t          ret;
-    
+
 #if DO_ALIGN
 #if DO_ALIGN
-    bcopy((char *)pkt, (char *)rd, sizeof(aligned_pkt));
+    if (plen > sizeof(aligned_pkt)) {
+       printf("kdp_packet bad len %lu\n", plen);
+       return FALSE;
+    }
+    bcopy((char *)pkt, (char *)rd, plen);
 #else
     rd = (kdp_pkt_t *)pkt;
 #endif
 #else
     rd = (kdp_pkt_t *)pkt;
 #endif
@@ -295,7 +277,7 @@ kdp_disconnect(
     kdp.session_key = 0;
 
     if ((panicstr != NULL) && (return_on_panic == 0))
     kdp.session_key = 0;
 
     if ((panicstr != NULL) && (return_on_panic == 0))
-           reattach_wait = 1;
+       reattach_wait = 1;
 
     if (noresume_on_disconnect == 1) {
        reattach_wait = 1;
 
     if (noresume_on_disconnect == 1) {
        reattach_wait = 1;
@@ -320,13 +302,13 @@ kdp_reattach(
     unsigned short     *reply_port
 )
 {
     unsigned short     *reply_port
 )
 {
-  kdp_reattach_req_t            *rq = &pkt->reattach_req;
+    kdp_reattach_req_t            *rq = &pkt->reattach_req;
 
 
-  kdp.is_conn = TRUE;
-  kdp_disconnect(pkt, len, reply_port);
-  *reply_port = rq->req_reply_port;
-  reattach_wait = 1;
-  return (TRUE);
+    kdp.is_conn = TRUE;
+    kdp_disconnect(pkt, len, reply_port);
+    *reply_port = rq->req_reply_port;
+    reattach_wait = 1;
+    return (TRUE);
 }
 
 static boolean_t
 }
 
 static boolean_t
@@ -343,7 +325,7 @@ kdp_hostinfo(
     if (plen < sizeof (*rq))
        return (FALSE);
 
     if (plen < sizeof (*rq))
        return (FALSE);
 
-       dprintf(("kdp_hostinfo\n"));
+    dprintf(("kdp_hostinfo\n"));
 
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
 
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
@@ -358,9 +340,9 @@ kdp_hostinfo(
 
 static boolean_t
 kdp_kernelversion(
 
 static boolean_t
 kdp_kernelversion(
-                                 kdp_pkt_t             *pkt,
-                                 int                   *len,
-                                 unsigned short        *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
     kdp_kernelversion_req_t    *rq = &pkt->kernelversion_req;
 )
 {
     kdp_kernelversion_req_t    *rq = &pkt->kernelversion_req;
@@ -375,9 +357,9 @@ kdp_kernelversion(
     rp->hdr.len = sizeof (*rp);
        
     dprintf(("kdp_kernelversion\n"));
     rp->hdr.len = sizeof (*rp);
        
     dprintf(("kdp_kernelversion\n"));
-       slen = strlcpy(rp->version, version, MAX_KDP_DATA_SIZE);
+    slen = strlcpy(rp->version, kdp_kernelversion_string, MAX_KDP_DATA_SIZE);
        
        
-       rp->hdr.len += slen + 1; /* strlcpy returns the amount copied with NUL */
+    rp->hdr.len += slen + 1; /* strlcpy returns the amount copied with NUL */
        
     *reply_port = kdp.reply_port;
     *len = rp->hdr.len;
        
     *reply_port = kdp.reply_port;
     *len = rp->hdr.len;
@@ -449,7 +431,7 @@ kdp_writemem(
     kdp_writemem_req_t *rq = &pkt->writemem_req;
     size_t             plen = *len;
     kdp_writemem_reply_t *rp = &pkt->writemem_reply;
     kdp_writemem_req_t *rq = &pkt->writemem_req;
     size_t             plen = *len;
     kdp_writemem_reply_t *rp = &pkt->writemem_reply;
-    mach_vm_size_t             cnt;
+    mach_vm_size_t     cnt;
 
     if (plen < sizeof (*rq))
        return (FALSE);
 
     if (plen < sizeof (*rq))
        return (FALSE);
@@ -458,9 +440,9 @@ kdp_writemem(
        rp->error = KDPERR_BAD_NBYTES;
     else {
        dprintf(("kdp_writemem addr %x size %d\n", rq->address, rq->nbytes));
        rp->error = KDPERR_BAD_NBYTES;
     else {
        dprintf(("kdp_writemem addr %x size %d\n", rq->address, rq->nbytes));
-
        cnt = kdp_machine_vm_write((caddr_t)rq->data, (mach_vm_address_t)rq->address, rq->nbytes);
        cnt = kdp_machine_vm_write((caddr_t)rq->data, (mach_vm_address_t)rq->address, rq->nbytes);
-       rp->error = KDPERR_NO_ERROR;
+       rp->error = KDPERR_ACCESS(rq->nbytes, cnt);
+       dprintf(("  cnt %lld error %d\n", cnt, rp->error));
     }
 
     rp->hdr.is_reply = 1;
     }
 
     rp->hdr.is_reply = 1;
@@ -474,9 +456,9 @@ kdp_writemem(
 
 static boolean_t
 kdp_writemem64(
 
 static boolean_t
 kdp_writemem64(
-                        kdp_pkt_t              *pkt,
-                        int                    *len,
-                        unsigned short *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
     kdp_writemem64_req_t       *rq = &pkt->writemem64_req;
 )
 {
     kdp_writemem64_req_t       *rq = &pkt->writemem64_req;
@@ -488,12 +470,12 @@ kdp_writemem64(
                return (FALSE);
        
     if (rq->nbytes > MAX_KDP_DATA_SIZE)
                return (FALSE);
        
     if (rq->nbytes > MAX_KDP_DATA_SIZE)
-               rp->error = KDPERR_BAD_NBYTES;
+       rp->error = KDPERR_BAD_NBYTES;
     else {
     else {
-               dprintf(("kdp_writemem64 addr %llx size %d\n", rq->address, rq->nbytes));
-               
-               cnt = kdp_machine_vm_write((caddr_t)rq->data, (mach_vm_address_t)rq->address, (mach_vm_size_t)rq->nbytes);
-               rp->error = KDPERR_NO_ERROR;
+       dprintf(("kdp_writemem64 addr %llx size %d\n", rq->address, rq->nbytes));
+       cnt = kdp_machine_vm_write((caddr_t)rq->data, (mach_vm_address_t)rq->address, (mach_vm_size_t)rq->nbytes);
+       rp->error = KDPERR_ACCESS(rq->nbytes, cnt);
+       dprintf(("  cnt %lld error %d\n", cnt, rp->error));
     }
        
     rp->hdr.is_reply = 1;
     }
        
     rp->hdr.is_reply = 1;
@@ -507,24 +489,28 @@ kdp_writemem64(
 
 static boolean_t
 kdp_writephysmem64(
 
 static boolean_t
 kdp_writephysmem64(
-                        kdp_pkt_t              *pkt,
-                        int                    *len,
-                        unsigned short *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
     kdp_writephysmem64_req_t   *rq = &pkt->writephysmem64_req;
     size_t             plen = *len;
     kdp_writephysmem64_reply_t *rp = &pkt->writephysmem64_reply;
 )
 {
     kdp_writephysmem64_req_t   *rq = &pkt->writephysmem64_req;
     size_t             plen = *len;
     kdp_writephysmem64_reply_t *rp = &pkt->writephysmem64_reply;
+    mach_vm_size_t             cnt;
+    unsigned int               size;
        
     if (plen < sizeof (*rq))
        
     if (plen < sizeof (*rq))
-               return (FALSE);
+       return (FALSE);
        
        
-    if (rq->nbytes > MAX_KDP_DATA_SIZE)
-               rp->error = KDPERR_BAD_NBYTES;
+    size = rq->nbytes;
+    if (size > MAX_KDP_DATA_SIZE)
+       rp->error = KDPERR_BAD_NBYTES;
     else {
     else {
-               dprintf(("kdp_writephysmem64 addr %llx size %d\n", rq->address, rq->nbytes));
-               kdp_machine_phys_write(rq, rq->data, rq->lcpu);
-               rp->error = KDPERR_NO_ERROR;
+       dprintf(("kdp_writephysmem64 addr %llx size %d\n", rq->address, size));
+       cnt = kdp_machine_phys_write(rq, rq->data, rq->lcpu);
+       rp->error = KDPERR_ACCESS(size, cnt);
+       dprintf(("  cnt %lld error %d\n", cnt, rp->error));
     }
        
     rp->hdr.is_reply = 1;
     }
        
     rp->hdr.is_reply = 1;
@@ -546,10 +532,8 @@ kdp_readmem(
     kdp_readmem_req_t  *rq = &pkt->readmem_req;
     size_t             plen = *len;
     kdp_readmem_reply_t *rp = &pkt->readmem_reply;
     kdp_readmem_req_t  *rq = &pkt->readmem_req;
     size_t             plen = *len;
     kdp_readmem_reply_t *rp = &pkt->readmem_reply;
-    mach_vm_size_t                     cnt;
-#if __i386__ || __arm__
-    void               *pversion = &version;
-#endif
+    mach_vm_size_t     cnt;
+    unsigned int       size;
 
     if (plen < sizeof (*rq))
        return (FALSE);
 
     if (plen < sizeof (*rq))
        return (FALSE);
@@ -557,29 +541,14 @@ kdp_readmem(
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
 
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
 
-    if (rq->nbytes > MAX_KDP_DATA_SIZE)
+    size = rq->nbytes;
+    if (size > MAX_KDP_DATA_SIZE)
        rp->error = KDPERR_BAD_NBYTES;
     else {
        rp->error = KDPERR_BAD_NBYTES;
     else {
-       unsigned int    n = rq->nbytes;
-
-       dprintf(("kdp_readmem addr %x size %d\n", rq->address, n));
-#if __i386__ || __arm__
-       /* XXX This is a hack to facilitate the "showversion" macro
-        * on i386/ARM, which is used to obtain the kernel version without
-        * symbols - a pointer to the version string should eventually
-        * be pinned at a fixed address when an equivalent of the
-        * VECTORS segment (loaded at a fixed load address, and contains
-        * a table) is implemented on these architectures, as with PPC.
-        * N.B.: x86 now has a low global page, and the version indirection
-        * is pinned at 0x201C. We retain the 0x501C address override
-        * for compatibility. Future architectures should instead use
-        * the KDP_KERNELVERSION request.
-        */
-       if (rq->address == 0x501C)
-               rq->address = (uintptr_t)&pversion;
-#endif
-       cnt = kdp_machine_vm_read((mach_vm_address_t)rq->address, (caddr_t)rp->data, n);
-       rp->error = KDPERR_NO_ERROR;
+       dprintf(("kdp_readmem addr %x size %d\n", rq->address, size));
+       cnt = kdp_machine_vm_read((mach_vm_address_t)rq->address, (caddr_t)rp->data, rq->nbytes);
+       rp->error = KDPERR_ACCESS(size, cnt);
+       dprintf(("  cnt %lld error %d\n", cnt, rp->error));
 
        rp->hdr.len += cnt;
     }
 
        rp->hdr.len += cnt;
     }
@@ -592,15 +561,16 @@ kdp_readmem(
 
 static boolean_t
 kdp_readmem64(
 
 static boolean_t
 kdp_readmem64(
-                       kdp_pkt_t               *pkt,
-                       int                     *len,
-                       unsigned short  *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
     kdp_readmem64_req_t        *rq = &pkt->readmem64_req;
     size_t             plen = *len;
     kdp_readmem64_reply_t *rp = &pkt->readmem64_reply;
 )
 {
     kdp_readmem64_req_t        *rq = &pkt->readmem64_req;
     size_t             plen = *len;
     kdp_readmem64_reply_t *rp = &pkt->readmem64_reply;
-    mach_vm_size_t                     cnt;
+    mach_vm_size_t     cnt;
+    unsigned int       size;
 
     if (plen < sizeof (*rq))
                return (FALSE);
 
     if (plen < sizeof (*rq))
                return (FALSE);
@@ -608,16 +578,16 @@ kdp_readmem64(
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
        
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
        
-    if (rq->nbytes > MAX_KDP_DATA_SIZE)
-               rp->error = KDPERR_BAD_NBYTES;
+    size = rq->nbytes;
+    if (size > MAX_KDP_DATA_SIZE)
+       rp->error = KDPERR_BAD_NBYTES;
     else {
     else {
-
-               dprintf(("kdp_readmem64 addr %llx size %d\n", rq->address, rq->nbytes));
-
-               cnt = kdp_machine_vm_read((mach_vm_address_t)rq->address, (caddr_t)rp->data, rq->nbytes);
-               rp->error = KDPERR_NO_ERROR;
+       dprintf(("kdp_readmem64 addr %llx size %d\n", rq->address, size));
+       cnt = kdp_machine_vm_read((mach_vm_address_t)rq->address, (caddr_t)rp->data, rq->nbytes);
+       rp->error = KDPERR_ACCESS(size, cnt);
+       dprintf(("  cnt %lld error %d\n", cnt, rp->error));
                
                
-               rp->hdr.len += cnt;
+       rp->hdr.len += cnt;
     }
        
     *reply_port = kdp.reply_port;
     }
        
     *reply_port = kdp.reply_port;
@@ -628,32 +598,33 @@ kdp_readmem64(
 
 static boolean_t
 kdp_readphysmem64(
 
 static boolean_t
 kdp_readphysmem64(
-                       kdp_pkt_t               *pkt,
-                       int                     *len,
-                       unsigned short  *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
     kdp_readphysmem64_req_t    *rq = &pkt->readphysmem64_req;
     size_t             plen = *len;
     kdp_readphysmem64_reply_t *rp = &pkt->readphysmem64_reply;
 )
 {
     kdp_readphysmem64_req_t    *rq = &pkt->readphysmem64_req;
     size_t             plen = *len;
     kdp_readphysmem64_reply_t *rp = &pkt->readphysmem64_reply;
-    int                        cnt;
+    mach_vm_size_t     cnt;
+    unsigned int       size;
 
     if (plen < sizeof (*rq))
 
     if (plen < sizeof (*rq))
-               return (FALSE);
+       return (FALSE);
        
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
        
        
     rp->hdr.is_reply = 1;
     rp->hdr.len = sizeof (*rp);
        
-    if (rq->nbytes > MAX_KDP_DATA_SIZE)
-               rp->error = KDPERR_BAD_NBYTES;
+    size = rq->nbytes;
+    if (size > MAX_KDP_DATA_SIZE)
+       rp->error = KDPERR_BAD_NBYTES;
     else {
     else {
-
-               dprintf(("kdp_readphysmem64 addr %llx size %d\n", rq->address, rq->nbytes));
-
-               cnt = (int)kdp_machine_phys_read(rq, rp->data, rq->lcpu);
-               rp->error = KDPERR_NO_ERROR;
+       dprintf(("kdp_readphysmem64 addr %llx size %d\n", rq->address, size));
+       cnt = kdp_machine_phys_read(rq, rp->data, rq->lcpu);
+       rp->error = KDPERR_ACCESS(size, cnt);
+       dprintf(("  cnt %lld error %d\n", cnt, rp->error));
                
                
-               rp->hdr.len += cnt;
+       rp->hdr.len += cnt;
     }
        
     *reply_port = kdp.reply_port;
     }
        
     *reply_port = kdp.reply_port;
@@ -813,9 +784,9 @@ kdp_readregs(
 
 boolean_t 
 kdp_breakpoint_set(
 
 boolean_t 
 kdp_breakpoint_set(
-                                  kdp_pkt_t            *pkt,
-                                  int                  *len,
-                                  unsigned short       *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
        kdp_breakpoint_req_t    *rq = &pkt->breakpoint_req;
 )
 {
        kdp_breakpoint_req_t    *rq = &pkt->breakpoint_req;
@@ -842,9 +813,9 @@ kdp_breakpoint_set(
 
 boolean_t 
 kdp_breakpoint64_set(
 
 boolean_t 
 kdp_breakpoint64_set(
-                                        kdp_pkt_t              *pkt,
-                                        int                    *len,
-                                        unsigned short *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
        kdp_breakpoint64_req_t  *rq = &pkt->breakpoint64_req;
 )
 {
        kdp_breakpoint64_req_t  *rq = &pkt->breakpoint64_req;
@@ -871,9 +842,9 @@ kdp_breakpoint64_set(
 
 boolean_t 
 kdp_breakpoint_remove(
 
 boolean_t 
 kdp_breakpoint_remove(
-                                         kdp_pkt_t             *pkt,
-                                         int                   *len,
-                                         unsigned short        *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
        kdp_breakpoint_req_t    *rq = &pkt->breakpoint_req;
 )
 {
        kdp_breakpoint_req_t    *rq = &pkt->breakpoint_req;
@@ -899,9 +870,9 @@ kdp_breakpoint_remove(
 
 boolean_t 
 kdp_breakpoint64_remove(
 
 boolean_t 
 kdp_breakpoint64_remove(
-                                               kdp_pkt_t               *pkt,
-                                               int                     *len,
-                                               unsigned short  *reply_port
+    kdp_pkt_t          *pkt,
+    int                        *len,
+    unsigned short     *reply_port
 )
 {
        kdp_breakpoint64_req_t  *rq = &pkt->breakpoint64_req;
 )
 {
        kdp_breakpoint64_req_t  *rq = &pkt->breakpoint64_req;
@@ -929,8 +900,8 @@ kdp_breakpoint64_remove(
 
 kdp_error_t
 kdp_set_breakpoint_internal(
 
 kdp_error_t
 kdp_set_breakpoint_internal(
-                                                       mach_vm_address_t       address
-                                                       )
+    mach_vm_address_t  address
+)
 {
        
        uint8_t         breakinstr[MAX_BREAKINSN_BYTES], oldinstr[MAX_BREAKINSN_BYTES];
 {
        
        uint8_t         breakinstr[MAX_BREAKINSN_BYTES], oldinstr[MAX_BREAKINSN_BYTES];
@@ -971,8 +942,8 @@ kdp_set_breakpoint_internal(
 
 kdp_error_t
 kdp_remove_breakpoint_internal(
 
 kdp_error_t
 kdp_remove_breakpoint_internal(
-                                                          mach_vm_address_t    address
-                                                          )
+    mach_vm_address_t  address
+)
 {
        mach_vm_size_t  cnt;
        int             i;
 {
        mach_vm_size_t  cnt;
        int             i;
@@ -980,7 +951,7 @@ kdp_remove_breakpoint_internal(
        for(i=0;(i < MAX_BREAKPOINTS) && (breakpoint_list[i].address != address); i++);
        
        if (i == MAX_BREAKPOINTS)
        for(i=0;(i < MAX_BREAKPOINTS) && (breakpoint_list[i].address != address); i++);
        
        if (i == MAX_BREAKPOINTS)
-    {
+       {
                return KDPERR_BREAKPOINT_NOT_FOUND; 
        }
        
                return KDPERR_BREAKPOINT_NOT_FOUND; 
        }
        
@@ -997,7 +968,7 @@ kdp_remove_all_breakpoints(void)
        boolean_t breakpoint_found = FALSE;
        
        if (breakpoints_initialized)
        boolean_t breakpoint_found = FALSE;
        
        if (breakpoints_initialized)
-    {
+       {
                for(i=0;i < MAX_BREAKPOINTS; i++)
                {
                        if (breakpoint_list[i].address)
                for(i=0;i < MAX_BREAKPOINTS; i++)
                {
                        if (breakpoint_list[i].address)
@@ -1010,15 +981,15 @@ kdp_remove_all_breakpoints(void)
                
                if (breakpoint_found)
                        printf("kdp_remove_all_breakpoints: found extant breakpoints, removing them.\n");
                
                if (breakpoint_found)
                        printf("kdp_remove_all_breakpoints: found extant breakpoints, removing them.\n");
-    }
+       }
        return breakpoint_found;
 }
 
 boolean_t
 kdp_reboot(
        return breakpoint_found;
 }
 
 boolean_t
 kdp_reboot(
-                  __unused kdp_pkt_t *pkt,
-                  __unused int *len,
-                  __unused unsigned short *reply_port
+       __unused kdp_pkt_t *pkt,
+       __unused int    *len,
+       __unused unsigned short *reply_port
 )
 {
        dprintf(("kdp_reboot\n"));
 )
 {
        dprintf(("kdp_reboot\n"));
@@ -1028,212 +999,9 @@ kdp_reboot(
        return (TRUE); // no, not really, we won't return
 }
 
        return (TRUE); // no, not really, we won't return
 }
 
-#define MAX_FRAMES 1000
-
-static int pid_from_task(task_t task)
-{
-       int pid = -1;
-
-       if (task->bsd_info)
-               pid = proc_pid(task->bsd_info);
-
-       return pid;
-}
-
-boolean_t
-kdp_copyin(pmap_t p, uint64_t uaddr, void *dest, size_t size) {
-       size_t rem = size;
-       char *kvaddr = dest;
-
-       while (rem) {
-               ppnum_t upn = pmap_find_phys(p, uaddr);
-               uint64_t phys_src = (upn << PAGE_SHIFT) | (uaddr & PAGE_MASK);
-               uint64_t phys_dest = kvtophys((vm_offset_t)kvaddr);
-               uint64_t src_rem = PAGE_SIZE - (phys_src & PAGE_MASK);
-               uint64_t dst_rem = PAGE_SIZE - (phys_dest & PAGE_MASK);
-               size_t cur_size = (uint32_t) MIN(src_rem, dst_rem);
-               cur_size = MIN(cur_size, rem);
-
-               if (upn && pmap_valid_page(upn) && phys_dest) {
-                       bcopy_phys(phys_src, phys_dest, cur_size);
-               }
-               else
-                       break;
-               uaddr += cur_size;
-               kvaddr += cur_size;
-               rem -= cur_size;        
-       }
-       return (rem == 0);
-}
-
-int
-kdp_stackshot(int pid, void *tracebuf, uint32_t tracebuf_size, uint32_t trace_flags, uint32_t dispatch_offset, uint32_t *pbytesTraced)
-{
-       char *tracepos = (char *) tracebuf;
-       char *tracebound = tracepos + tracebuf_size;
-       uint32_t tracebytes = 0;
-       int error = 0;
-
-       task_t task = TASK_NULL;
-       thread_t thread = THREAD_NULL;
-       thread_snapshot_t tsnap = NULL;
-       unsigned framesize = 2 * sizeof(vm_offset_t);
-       struct task ctask;
-       struct thread cthread;
-       
-       boolean_t dispatch_p = ((trace_flags & STACKSHOT_GET_DQ) != 0);
-       boolean_t save_loadinfo_p = ((trace_flags & STACKSHOT_SAVE_LOADINFO) != 0);
-
-       queue_iterate(&tasks, task, task_t, tasks) {
-               int task_pid = pid_from_task(task);
-               boolean_t task64 = task_has_64BitAddr(task);
-
-               if ((task == NULL) || (ml_nofault_copy((vm_offset_t) task, (vm_offset_t) &ctask, sizeof(struct task)) != sizeof(struct task)))
-                       goto error_exit;
-
-               /* Trace everything, unless a process was specified */
-               if ((pid == -1) || (pid == task_pid)) {
-                       task_snapshot_t task_snap;
-                       uint32_t uuid_info_count;
-                       mach_vm_address_t uuid_info_addr;
-
-                       if (save_loadinfo_p && task_pid > 0) {
-                               // Read the dyld_all_image_infos struct from the task memory to get UUID array count and location
-                               if (task64) {
-                                       struct dyld_all_image_infos64 task_image_infos;
-                                       if (!kdp_copyin(task->map->pmap, task->all_image_info_addr, &task_image_infos, sizeof(struct dyld_all_image_infos64)))
-                                               goto error_exit;
-                                       uuid_info_count = (uint32_t)task_image_infos.uuidArrayCount;
-                                       uuid_info_addr = task_image_infos.uuidArray;
-                               } else {
-                                       struct dyld_all_image_infos task_image_infos;
-                                       if (!kdp_copyin(task->map->pmap, task->all_image_info_addr, &task_image_infos, sizeof(struct dyld_all_image_infos)))
-                                               goto error_exit;
-                                       uuid_info_count = task_image_infos.uuidArrayCount;
-                                       uuid_info_addr = task_image_infos.uuidArray;
-                               }
-                       } else {
-                               uuid_info_count = 0;
-                               uuid_info_addr = 0;
-                       }
-
-                       if (tracepos + sizeof(struct task_snapshot) > tracebound) {
-                               error = -1;
-                               goto error_exit;
-                       }
-
-                       task_snap = (task_snapshot_t) tracepos;
-                       task_snap->snapshot_magic = STACKSHOT_TASK_SNAPSHOT_MAGIC;
-                       task_snap->pid = task_pid;
-                       task_snap->nloadinfos = uuid_info_count;
-                       /* Add the BSD process identifiers */
-                       if (task_pid != -1)
-                               proc_name_kdp(task, task_snap->p_comm, sizeof(task_snap->p_comm));
-                       else
-                               task_snap->p_comm[0] = '\0';
-                       task_snap->ss_flags = 0;
-                       if (task64)
-                               task_snap->ss_flags |= kUser64_p;
-                       
-                       tracepos += sizeof(struct task_snapshot);
-
-                       if (task_pid > 0 && uuid_info_count > 0) {
-                               uint32_t uuid_info_size = (uint32_t)(task64 ? sizeof(struct dyld_uuid_info64) : sizeof(struct dyld_uuid_info));
-                               uint32_t uuid_info_array_size = uuid_info_count * uuid_info_size;
-
-                               if (tracepos + uuid_info_array_size > tracebound) {
-                                       error = -1;
-                                       goto error_exit;
-                               }
-
-                               // Copy in the UUID info array
-                               if (!kdp_copyin(task->map->pmap, uuid_info_addr, tracepos, uuid_info_array_size))
-                                       goto error_exit;
-
-                               tracepos += uuid_info_array_size;
-                       }
-
-                       queue_iterate(&task->threads, thread, thread_t, task_threads){
-                               if ((thread == NULL) || (ml_nofault_copy((vm_offset_t) thread, (vm_offset_t) &cthread, sizeof(struct thread)) != sizeof(struct thread)))
-                                       goto error_exit;
-
-                               if (((tracepos + 4 * sizeof(struct thread_snapshot)) > tracebound)) {
-                                       error = -1;
-                                       goto error_exit;
-                               }
-                               /* Populate the thread snapshot header */
-                               tsnap = (thread_snapshot_t) tracepos;
-                               tsnap->thread_id = thread_tid(thread);
-                               tsnap->state = thread->state;
-                               tsnap->wait_event = thread->wait_event;
-                               tsnap->continuation = (uint64_t) (uintptr_t) thread->continuation;
-
-                               tsnap->snapshot_magic = STACKSHOT_THREAD_SNAPSHOT_MAGIC;
-                               tracepos += sizeof(struct thread_snapshot);
-                               tsnap->ss_flags = 0;
-
-                               if (dispatch_p && (task != kernel_task) && (task->active) && (task->map)) {
-                                       uint64_t dqkeyaddr = thread_dispatchqaddr(thread);
-                                       if (dqkeyaddr != 0) {
-                                               uint64_t dqaddr = 0;
-                                               if (kdp_copyin(task->map->pmap, dqkeyaddr, &dqaddr, (task64 ? 8 : 4)) && (dqaddr != 0)) {
-                                                       uint64_t dqserialnumaddr = dqaddr + dispatch_offset;
-                                                       uint64_t dqserialnum = 0;
-                                                       if (kdp_copyin(task->map->pmap, dqserialnumaddr, &dqserialnum, (task64 ? 8 : 4))) {
-                                                               tsnap->ss_flags |= kHasDispatchSerial;
-                                                               *(uint64_t *)tracepos = dqserialnum;
-                                                               tracepos += 8;
-                                                       }
-                                               }
-                                       }
-                               }
-/* Call through to the machine specific trace routines
- * Frames are added past the snapshot header.
- */
-                               if (thread->kernel_stack != 0) {
-#if defined(__LP64__)                                  
-                                       tracebytes = machine_trace_thread64(thread, tracepos, tracebound, MAX_FRAMES, FALSE);
-                                       tsnap->ss_flags |= kKernel64_p;
-                                       framesize = 16;
-#else
-                                       tracebytes = machine_trace_thread(thread, tracepos, tracebound, MAX_FRAMES, FALSE);
-                                       framesize = 8;
-#endif
-                               }
-                               tsnap->nkern_frames = tracebytes/framesize;
-                               tracepos += tracebytes;
-                               tracebytes = 0;
-                               /* Trace user stack, if any */
-                               if (thread->task->map != kernel_map) {
-                                       /* 64-bit task? */
-                                       if (task_has_64BitAddr(thread->task)) {
-                                               tracebytes = machine_trace_thread64(thread, tracepos, tracebound, MAX_FRAMES, TRUE);
-                                               tsnap->ss_flags |= kUser64_p;
-                                               framesize = 16;
-                                       }
-                                       else {
-                                               tracebytes = machine_trace_thread(thread, tracepos, tracebound, MAX_FRAMES, TRUE);
-                                               framesize = 8;
-                                       }
-                               }
-                               tsnap->nuser_frames = tracebytes/framesize;
-                               tracepos += tracebytes;
-                               tracebytes = 0;
-                       }
-               }
-       }
-
-error_exit:
-       /* Release stack snapshot wait indicator */
-       kdp_snapshot_postflight();
-
-       *pbytesTraced = (uint32_t)(tracepos - (char *) tracebuf);
-
-       return error;
-}
-
 static boolean_t
 static boolean_t
-kdp_readioport(kdp_pkt_t               *pkt,
+kdp_readioport(
+    kdp_pkt_t          *pkt,
     int                        *len,
     unsigned short     *reply_port
               )
     int                        *len,
     unsigned short     *reply_port
               )
@@ -1301,10 +1069,11 @@ kdp_writeioport(
 }
 
 static boolean_t
 }
 
 static boolean_t
-kdp_readmsr64(kdp_pkt_t                *pkt,
-    int                        *len,
-    unsigned short     *reply_port
-              )
+kdp_readmsr64(
+       kdp_pkt_t               *pkt,
+       int                     *len,
+       unsigned short  *reply_port
+)
 {
        kdp_readmsr64_req_t   *rq = &pkt->readmsr64_req;
        kdp_readmsr64_reply_t *rp = &pkt->readmsr64_reply;
 {
        kdp_readmsr64_req_t   *rq = &pkt->readmsr64_req;
        kdp_readmsr64_reply_t *rp = &pkt->readmsr64_reply;
@@ -1377,11 +1146,11 @@ kdp_dumpinfo(
         }
 
         /* gather some stats for reply */
         }
 
         /* gather some stats for reply */
-        kdp_get_dump_info(&rp->type, rp->name, rp->destip, rp->routerip, 
-                          &rp->port);
+        kdp_get_dump_info(rp);
 
        *reply_port = kdp.reply_port;
        *len = rp->hdr.len;
     
        return (TRUE);
 }
 
        *reply_port = kdp.reply_port;
        *len = rp->hdr.len;
     
        return (TRUE);
 }
+