vendor/lldb/lldb-trunk-r256945

1 files changed, 1445 insertions, 0 deletions

diff --git a/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp b/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
new file mode 100644
index 000000000000..5c1c3284a35c
--- /dev/null
+++ b/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
@@ -0,0 +1,1445 @@
+//===-- CommunicationKDP.cpp ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "CommunicationKDP.h"
+
+// C Includes
+#include <errno.h>
+#include <limits.h>
+#include <string.h>
+
+// C++ Includes
+
+// Other libraries and framework includes
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/State.h"
+#include "lldb/Core/UUID.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Host/Host.h"
+#include "lldb/Host/TimeValue.h"
+#include "lldb/Target/Process.h"
+
+// Project includes
+#include "ProcessKDPLog.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// CommunicationKDP constructor
+//----------------------------------------------------------------------
+CommunicationKDP::CommunicationKDP (const char *comm_name) :
+    Communication(comm_name),
+    m_addr_byte_size (4),
+    m_byte_order (eByteOrderLittle),
+    m_packet_timeout (5),
+    m_sequence_mutex (Mutex::eMutexTypeRecursive),
+    m_is_running (false),
+    m_session_key (0u),
+    m_request_sequence_id (0u),
+    m_exception_sequence_id (0u),
+    m_kdp_version_version (0u),
+    m_kdp_version_feature (0u),
+    m_kdp_hostinfo_cpu_mask (0u),
+    m_kdp_hostinfo_cpu_type (0u),
+    m_kdp_hostinfo_cpu_subtype (0u)
+{
+}
+
+//----------------------------------------------------------------------
+// Destructor
+//----------------------------------------------------------------------
+CommunicationKDP::~CommunicationKDP()
+{
+    if (IsConnected())
+    {
+        Disconnect();
+    }
+}
+
+bool
+CommunicationKDP::SendRequestPacket (const PacketStreamType &request_packet)
+{
+    Mutex::Locker locker(m_sequence_mutex);
+    return SendRequestPacketNoLock (request_packet);
+}
+
+#if 0
+typedef struct {
+	uint8_t     request;	// Either: CommandType | ePacketTypeRequest, or CommandType | ePacketTypeReply
+	uint8_t     sequence;
+	uint16_t    length;		// Length of entire packet including this header
+	uint32_t	key;		// Session key
+} kdp_hdr_t;
+#endif
+
+void
+CommunicationKDP::MakeRequestPacketHeader (CommandType request_type,
+                                           PacketStreamType &request_packet,
+                                           uint16_t request_length)
+{
+    request_packet.Clear();
+    request_packet.PutHex8 (request_type | ePacketTypeRequest); // Set the request type
+    request_packet.PutHex8 (m_request_sequence_id++);           // Sequence number
+    request_packet.PutHex16 (request_length);                   // Length of the packet including this header
+    request_packet.PutHex32 (m_session_key);                    // Session key
+}
+
+bool
+CommunicationKDP::SendRequestAndGetReply (const CommandType command,
+                                          const PacketStreamType &request_packet,
+                                          DataExtractor &reply_packet)
+{
+    if (IsRunning())
+    {
+        Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PACKETS));
+        if (log)
+        {
+            PacketStreamType log_strm;
+            DumpPacket (log_strm, request_packet.GetData(), request_packet.GetSize());
+            log->Printf("error: kdp running, not sending packet: %.*s", (uint32_t)log_strm.GetSize(), log_strm.GetData());
+        }
+        return false;
+    }
+
+    Mutex::Locker locker(m_sequence_mutex);
+#ifdef LLDB_CONFIGURATION_DEBUG
+    // NOTE: this only works for packets that are in native endian byte order
+    assert (request_packet.GetSize() == *((uint16_t *)(request_packet.GetData() + 2)));
+#endif
+    lldb::offset_t offset = 1;
+    const uint32_t num_retries = 3;
+    for (uint32_t i=0; i<num_retries; ++i)
+    {
+        if (SendRequestPacketNoLock(request_packet))
+        {
+            const uint8_t request_sequence_id = (uint8_t)request_packet.GetData()[1];
+            while (1)
+            {
+                if (WaitForPacketWithTimeoutMicroSecondsNoLock (reply_packet, GetPacketTimeoutInMicroSeconds ()))
+                {
+                    offset = 0;
+                    const uint8_t reply_command = reply_packet.GetU8 (&offset);
+                    const uint8_t reply_sequence_id = reply_packet.GetU8 (&offset);
+                    if (request_sequence_id == reply_sequence_id)
+                    {
+                        // The sequent ID was correct, now verify we got the response we were looking for
+                        if ((reply_command & eCommandTypeMask) == command)
+                        {
+                            // Success
+                            if (command == KDP_RESUMECPUS)
+                                m_is_running.SetValue(true, eBroadcastAlways);
+                            return true;
+                        }
+                        else
+                        {
+                            // Failed to get the correct response, bail
+                            reply_packet.Clear();
+                            return false;
+                        }
+                    }
+                    else if (reply_sequence_id > request_sequence_id)
+                    {
+                        // Sequence ID was greater than the sequence ID of the packet we sent, something
+                        // is really wrong...
+                        reply_packet.Clear();
+                        return false;
+                    }
+                    else
+                    {
+                        // The reply sequence ID was less than our current packet's sequence ID
+                        // so we should keep trying to get a response because this was a response
+                        // for a previous packet that we must have retried.
+                    }
+                }
+                else
+                {
+                    // Break and retry sending the packet as we didn't get a response due to timeout
+                    break;
+                }
+            }
+        }
+    }
+    reply_packet.Clear();
+    return false;
+}
+
+bool
+CommunicationKDP::SendRequestPacketNoLock (const PacketStreamType &request_packet)
+{
+    if (IsConnected())
+    {
+        const char *packet_data = request_packet.GetData();
+        const size_t packet_size = request_packet.GetSize();
+
+        Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PACKETS));
+        if (log)
+        {
+            PacketStreamType log_strm;            
+            DumpPacket (log_strm, packet_data, packet_size);
+            log->Printf("%.*s", (uint32_t)log_strm.GetSize(), log_strm.GetData());
+        }
+        ConnectionStatus status = eConnectionStatusSuccess;
+
+        size_t bytes_written = Write (packet_data, 
+                                      packet_size, 
+                                      status, 
+                                      NULL);
+
+        if (bytes_written == packet_size)
+            return true;
+        
+        if (log)
+            log->Printf ("error: failed to send packet entire packet %" PRIu64 " of %" PRIu64 " bytes sent", (uint64_t)bytes_written, (uint64_t)packet_size);
+    }
+    return false;
+}
+
+bool
+CommunicationKDP::GetSequenceMutex (Mutex::Locker& locker)
+{
+    return locker.TryLock (m_sequence_mutex);
+}
+
+
+bool
+CommunicationKDP::WaitForNotRunningPrivate (const TimeValue *timeout_ptr)
+{
+    return m_is_running.WaitForValueEqualTo (false, timeout_ptr, NULL);
+}
+
+size_t
+CommunicationKDP::WaitForPacketWithTimeoutMicroSeconds (DataExtractor &packet, uint32_t timeout_usec)
+{
+    Mutex::Locker locker(m_sequence_mutex);
+    return WaitForPacketWithTimeoutMicroSecondsNoLock (packet, timeout_usec);
+}
+
+size_t
+CommunicationKDP::WaitForPacketWithTimeoutMicroSecondsNoLock (DataExtractor &packet, uint32_t timeout_usec)
+{
+    uint8_t buffer[8192];
+    Error error;
+
+    Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PACKETS | KDP_LOG_VERBOSE));
+
+    // Check for a packet from our cache first without trying any reading...
+    if (CheckForPacket (NULL, 0, packet))
+        return packet.GetByteSize();
+
+    bool timed_out = false;
+    while (IsConnected() && !timed_out)
+    {
+        lldb::ConnectionStatus status = eConnectionStatusNoConnection;
+        size_t bytes_read = Read (buffer, sizeof(buffer), timeout_usec, status, &error);
+        
+        if (log)
+            log->Printf ("%s: Read (buffer, (sizeof(buffer), timeout_usec = 0x%x, status = %s, error = %s) => bytes_read = %" PRIu64,
+                         __PRETTY_FUNCTION__,
+                         timeout_usec, 
+                         Communication::ConnectionStatusAsCString (status),
+                         error.AsCString(), 
+                         (uint64_t)bytes_read);
+
+        if (bytes_read > 0)
+        {
+            if (CheckForPacket (buffer, bytes_read, packet))
+                return packet.GetByteSize();
+        }
+        else
+        {
+            switch (status)
+            {
+            case eConnectionStatusInterrupted:
+            case eConnectionStatusTimedOut:
+                timed_out = true;
+                break;
+            case eConnectionStatusSuccess:
+                //printf ("status = success but error = %s\n", error.AsCString("<invalid>"));
+                break;
+                
+            case eConnectionStatusEndOfFile:
+            case eConnectionStatusNoConnection:
+            case eConnectionStatusLostConnection:
+            case eConnectionStatusError:
+                Disconnect();
+                break;
+            }
+        }
+    }
+    packet.Clear ();    
+    return 0;
+}
+
+bool
+CommunicationKDP::CheckForPacket (const uint8_t *src, size_t src_len, DataExtractor &packet)
+{
+    // Put the packet data into the buffer in a thread safe fashion
+    Mutex::Locker locker(m_bytes_mutex);
+    
+    Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PACKETS));
+
+    if (src && src_len > 0)
+    {
+        if (log && log->GetVerbose())
+        {
+            PacketStreamType log_strm;
+            DataExtractor::DumpHexBytes (&log_strm, src, src_len, UINT32_MAX, LLDB_INVALID_ADDRESS);
+            log->Printf ("CommunicationKDP::%s adding %u bytes: %s",
+                         __FUNCTION__, 
+                         (uint32_t)src_len, 
+                         log_strm.GetData());
+        }
+        m_bytes.append ((const char *)src, src_len);
+    }
+
+    // Make sure we at least have enough bytes for a packet header
+    const size_t bytes_available = m_bytes.size();
+    if (bytes_available >= 8)
+    {
+        packet.SetData (&m_bytes[0], bytes_available, m_byte_order);
+        lldb::offset_t offset = 0;
+        uint8_t reply_command = packet.GetU8(&offset);
+        switch (reply_command)
+        {
+        case ePacketTypeRequest | KDP_EXCEPTION:
+        case ePacketTypeRequest | KDP_TERMINATION:
+            // We got an exception request, so be sure to send an ACK
+            {
+                PacketStreamType request_ack_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+                // Set the reply but and make the ACK packet
+                request_ack_packet.PutHex8 (reply_command | ePacketTypeReply);
+                request_ack_packet.PutHex8 (packet.GetU8(&offset));
+                request_ack_packet.PutHex16 (packet.GetU16(&offset));
+                request_ack_packet.PutHex32 (packet.GetU32(&offset));
+                m_is_running.SetValue(false, eBroadcastAlways);
+                // Ack to the exception or termination
+                SendRequestPacketNoLock (request_ack_packet);
+            }
+            // Fall through to case below to get packet contents
+        case ePacketTypeReply | KDP_CONNECT:
+        case ePacketTypeReply | KDP_DISCONNECT:
+        case ePacketTypeReply | KDP_HOSTINFO:
+        case ePacketTypeReply | KDP_VERSION:
+        case ePacketTypeReply | KDP_MAXBYTES:
+        case ePacketTypeReply | KDP_READMEM:
+        case ePacketTypeReply | KDP_WRITEMEM:
+        case ePacketTypeReply | KDP_READREGS:
+        case ePacketTypeReply | KDP_WRITEREGS:
+        case ePacketTypeReply | KDP_LOAD:
+        case ePacketTypeReply | KDP_IMAGEPATH:
+        case ePacketTypeReply | KDP_SUSPEND:
+        case ePacketTypeReply | KDP_RESUMECPUS:
+        case ePacketTypeReply | KDP_BREAKPOINT_SET:
+        case ePacketTypeReply | KDP_BREAKPOINT_REMOVE:
+        case ePacketTypeReply | KDP_REGIONS:
+        case ePacketTypeReply | KDP_REATTACH:
+        case ePacketTypeReply | KDP_HOSTREBOOT:
+        case ePacketTypeReply | KDP_READMEM64:
+        case ePacketTypeReply | KDP_WRITEMEM64:
+        case ePacketTypeReply | KDP_BREAKPOINT_SET64:
+        case ePacketTypeReply | KDP_BREAKPOINT_REMOVE64:
+        case ePacketTypeReply | KDP_KERNELVERSION:
+        case ePacketTypeReply | KDP_READPHYSMEM64:
+        case ePacketTypeReply | KDP_WRITEPHYSMEM64:
+        case ePacketTypeReply | KDP_READIOPORT:
+        case ePacketTypeReply | KDP_WRITEIOPORT:
+        case ePacketTypeReply | KDP_READMSR64:
+        case ePacketTypeReply | KDP_WRITEMSR64:
+        case ePacketTypeReply | KDP_DUMPINFO:
+            {
+                offset = 2;
+                const uint16_t length = packet.GetU16 (&offset);
+                if (length <= bytes_available)
+                {
+                    // We have an entire packet ready, we need to copy the data
+                    // bytes into a buffer that will be owned by the packet and
+                    // erase the bytes from our communcation buffer "m_bytes"
+                    packet.SetData (DataBufferSP (new DataBufferHeap (&m_bytes[0], length)));
+                    m_bytes.erase (0, length);
+                    
+                    if (log)
+                    {
+                        PacketStreamType log_strm;
+                        DumpPacket (log_strm, packet);
+                        
+                        log->Printf("%.*s", (uint32_t)log_strm.GetSize(), log_strm.GetData());
+                    }
+                    return true;
+                }
+            }
+            break;
+
+        default:
+            // Unrecognized reply command byte, erase this byte and try to get back on track
+            if (log)
+                log->Printf ("CommunicationKDP::%s: tossing junk byte: 0x%2.2x", 
+                             __FUNCTION__, 
+                             (uint8_t)m_bytes[0]);
+            m_bytes.erase(0, 1);
+            break;
+        }
+    }
+    packet.Clear();
+    return false;
+}
+
+
+bool
+CommunicationKDP::SendRequestConnect (uint16_t reply_port, 
+                                      uint16_t exc_port, 
+                                      const char *greeting)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    if (greeting == NULL)
+        greeting = "";
+
+    const CommandType command = KDP_CONNECT;
+    // Length is 82 uint16_t and the length of the greeting C string with the terminating NULL
+    const uint32_t command_length = 8 + 2 + 2 + ::strlen(greeting) + 1;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    // Always send connect ports as little endian
+    request_packet.SetByteOrder (eByteOrderLittle);
+    request_packet.PutHex16 (htons(reply_port));
+    request_packet.PutHex16 (htons(exc_port));
+    request_packet.SetByteOrder (m_byte_order);
+    request_packet.PutCString (greeting);
+    DataExtractor reply_packet;
+    return SendRequestAndGetReply (command, request_packet, reply_packet);
+}
+
+void
+CommunicationKDP::ClearKDPSettings ()
+{
+    m_request_sequence_id = 0;
+    m_kdp_version_version = 0;
+    m_kdp_version_feature = 0;
+    m_kdp_hostinfo_cpu_mask = 0;
+    m_kdp_hostinfo_cpu_type = 0;
+    m_kdp_hostinfo_cpu_subtype = 0;
+}
+
+bool
+CommunicationKDP::SendRequestReattach (uint16_t reply_port)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_REATTACH;
+    // Length is 8 bytes for the header plus 2 bytes for the reply UDP port
+    const uint32_t command_length = 8 + 2;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    // Always send connect ports as little endian
+    request_packet.SetByteOrder (eByteOrderLittle);
+    request_packet.PutHex16(htons(reply_port));
+    request_packet.SetByteOrder (m_byte_order);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        // Reset the sequence ID to zero for reattach
+        ClearKDPSettings ();
+        lldb::offset_t offset = 4;
+        m_session_key = reply_packet.GetU32 (&offset);
+        return true;
+    }
+    return false;
+}
+
+uint32_t
+CommunicationKDP::GetVersion ()
+{
+    if (!VersionIsValid())
+        SendRequestVersion();
+    return m_kdp_version_version;
+}
+
+uint32_t
+CommunicationKDP::GetFeatureFlags ()
+{
+    if (!VersionIsValid())
+        SendRequestVersion();
+    return m_kdp_version_feature;
+}
+
+bool
+CommunicationKDP::SendRequestVersion ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_VERSION;
+    const uint32_t command_length = 8;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        m_kdp_version_version = reply_packet.GetU32 (&offset);
+        m_kdp_version_feature = reply_packet.GetU32 (&offset);
+        return true;
+    }
+    return false;
+}
+
+#if 0 // Disable KDP_IMAGEPATH for now, it seems to hang the KDP connection...
+const char *
+CommunicationKDP::GetImagePath ()
+{
+    if (m_image_path.empty())
+        SendRequestImagePath();
+    return m_image_path.c_str();
+}
+
+bool
+CommunicationKDP::SendRequestImagePath ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_IMAGEPATH;
+    const uint32_t command_length = 8;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        const char *path = reply_packet.PeekCStr(8);
+        if (path && path[0])
+            m_kernel_version.assign (path);
+        return true;
+    }
+    return false;
+}
+#endif
+
+uint32_t
+CommunicationKDP::GetCPUMask ()
+{
+    if (!HostInfoIsValid())
+        SendRequestHostInfo();
+    return m_kdp_hostinfo_cpu_mask;
+}
+
+uint32_t
+CommunicationKDP::GetCPUType ()
+{
+    if (!HostInfoIsValid())
+        SendRequestHostInfo();
+    return m_kdp_hostinfo_cpu_type;
+}
+
+uint32_t
+CommunicationKDP::GetCPUSubtype ()
+{
+    if (!HostInfoIsValid())
+        SendRequestHostInfo();
+    return m_kdp_hostinfo_cpu_subtype;
+}
+
+lldb_private::UUID
+CommunicationKDP::GetUUID ()
+{
+    UUID uuid;
+    if (GetKernelVersion() == NULL)
+        return uuid;
+
+    if (m_kernel_version.find("UUID=") == std::string::npos)
+        return uuid;
+
+    size_t p = m_kernel_version.find("UUID=") + strlen ("UUID=");
+    std::string uuid_str = m_kernel_version.substr(p, 36);
+    if (uuid_str.size() < 32)
+        return uuid;
+
+    if (uuid.SetFromCString (uuid_str.c_str()) == 0)
+    {
+        UUID invalid_uuid;
+        return invalid_uuid;
+    }
+
+    return uuid;
+}
+
+bool
+CommunicationKDP::RemoteIsEFI ()
+{
+    if (GetKernelVersion() == NULL)
+        return false;
+    if (strncmp (m_kernel_version.c_str(), "EFI", 3) == 0)
+        return true;
+    else
+        return false;
+}
+
+bool
+CommunicationKDP::RemoteIsDarwinKernel ()
+{
+    if (GetKernelVersion() == NULL)
+        return false;
+    if (m_kernel_version.find("Darwin Kernel") != std::string::npos)
+        return true;
+    else
+        return false;
+}
+
+lldb::addr_t
+CommunicationKDP::GetLoadAddress ()
+{
+    if (GetKernelVersion() == NULL)
+        return LLDB_INVALID_ADDRESS;
+
+    if (m_kernel_version.find("stext=") == std::string::npos)
+        return LLDB_INVALID_ADDRESS;
+    size_t p = m_kernel_version.find("stext=") + strlen ("stext=");
+    if (m_kernel_version[p] != '0' || m_kernel_version[p + 1] != 'x')
+        return LLDB_INVALID_ADDRESS;
+
+    addr_t kernel_load_address;
+    errno = 0;
+    kernel_load_address = ::strtoul (m_kernel_version.c_str() + p, NULL, 16);
+    if (errno != 0 || kernel_load_address == 0)
+        return LLDB_INVALID_ADDRESS;
+
+    return kernel_load_address;
+}
+
+bool
+CommunicationKDP::SendRequestHostInfo ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_HOSTINFO;
+    const uint32_t command_length = 8;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        m_kdp_hostinfo_cpu_mask     = reply_packet.GetU32 (&offset);
+        m_kdp_hostinfo_cpu_type     = reply_packet.GetU32 (&offset);
+        m_kdp_hostinfo_cpu_subtype  = reply_packet.GetU32 (&offset);
+        
+        ArchSpec kernel_arch;
+        kernel_arch.SetArchitecture (eArchTypeMachO, 
+                                     m_kdp_hostinfo_cpu_type, 
+                                     m_kdp_hostinfo_cpu_subtype);
+    
+        m_addr_byte_size = kernel_arch.GetAddressByteSize();
+        m_byte_order = kernel_arch.GetByteOrder();
+        return true;
+    }
+    return false;
+}
+
+const char *
+CommunicationKDP::GetKernelVersion ()
+{
+    if (m_kernel_version.empty())
+        SendRequestKernelVersion ();
+    return m_kernel_version.c_str();
+}
+
+bool
+CommunicationKDP::SendRequestKernelVersion ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_KERNELVERSION;
+    const uint32_t command_length = 8;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        const char *kernel_version_cstr = reply_packet.PeekCStr(8);
+        if (kernel_version_cstr && kernel_version_cstr[0])
+            m_kernel_version.assign (kernel_version_cstr);
+        return true;
+    }
+    return false;
+}
+
+bool
+CommunicationKDP::SendRequestDisconnect ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_DISCONNECT;
+    const uint32_t command_length = 8;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        // Are we supposed to get a reply for disconnect?
+    }
+    ClearKDPSettings ();
+    return true;
+}
+
+uint32_t
+CommunicationKDP::SendRequestReadMemory (lldb::addr_t addr, 
+                                         void *dst, 
+                                         uint32_t dst_len,
+                                         Error &error)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    bool use_64 = (GetVersion() >= 11);
+    uint32_t command_addr_byte_size = use_64 ? 8 : 4;
+    const CommandType command = use_64 ? KDP_READMEM64 : KDP_READMEM;
+    // Size is header + address size + uint32_t length
+    const uint32_t command_length = 8 + command_addr_byte_size + 4;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutMaxHex64 (addr, command_addr_byte_size);
+    request_packet.PutHex32 (dst_len);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        uint32_t kdp_error = reply_packet.GetU32 (&offset);
+        uint32_t src_len = reply_packet.GetByteSize() - 12;
+        
+        if (src_len > 0)
+        {
+            const void *src = reply_packet.GetData(&offset, src_len);
+            if (src)
+            {
+                ::memcpy (dst, src, src_len);
+                error.Clear();
+                return src_len;
+            }
+        }
+        if (kdp_error)
+            error.SetErrorStringWithFormat ("kdp read memory failed (error %u)", kdp_error);
+        else
+            error.SetErrorString ("kdp read memory failed");
+    }
+    else
+    {
+        error.SetErrorString ("failed to send packet");
+    }
+    return 0;
+}
+
+
+uint32_t
+CommunicationKDP::SendRequestWriteMemory (lldb::addr_t addr, 
+                                          const void *src, 
+                                          uint32_t src_len,
+                                          Error &error)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    bool use_64 = (GetVersion() >= 11);
+    uint32_t command_addr_byte_size = use_64 ? 8 : 4;
+    const CommandType command = use_64 ? KDP_WRITEMEM64 : KDP_WRITEMEM;
+    // Size is header + address size + uint32_t length
+    const uint32_t command_length = 8 + command_addr_byte_size + 4 + src_len;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutMaxHex64 (addr, command_addr_byte_size);
+    request_packet.PutHex32 (src_len);
+    request_packet.PutRawBytes(src, src_len);
+
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        uint32_t kdp_error = reply_packet.GetU32 (&offset);
+        if (kdp_error)
+            error.SetErrorStringWithFormat ("kdp write memory failed (error %u)", kdp_error);
+        else
+        {
+            error.Clear();
+            return src_len;
+        }
+    }
+    else
+    {
+        error.SetErrorString ("failed to send packet");
+    }
+    return 0;
+}
+
+bool
+CommunicationKDP::SendRawRequest (uint8_t command_byte,
+                                  const void *src,  // Raw packet payload bytes
+                                  uint32_t src_len, // Raw packet payload length
+                                  DataExtractor &reply_packet,
+                                  Error &error)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    // Size is header + address size + uint32_t length
+    const uint32_t command_length = 8 + src_len;
+    const CommandType command = (CommandType)command_byte;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutRawBytes(src, src_len);
+    
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        uint32_t kdp_error = reply_packet.GetU32 (&offset);
+        if (kdp_error  && (command_byte != KDP_DUMPINFO))
+            error.SetErrorStringWithFormat ("request packet 0x%8.8x failed (error %u)", command_byte, kdp_error);
+        else
+        {
+            error.Clear();
+            return true;
+        }
+    }
+    else
+    {
+        error.SetErrorString ("failed to send packet");
+    }
+    return false;
+}
+
+
+const char *
+CommunicationKDP::GetCommandAsCString (uint8_t command)
+{
+    switch (command)
+    {
+    case KDP_CONNECT:               return "KDP_CONNECT";
+    case KDP_DISCONNECT:            return "KDP_DISCONNECT";
+    case KDP_HOSTINFO:              return "KDP_HOSTINFO";
+    case KDP_VERSION:               return "KDP_VERSION";
+    case KDP_MAXBYTES:              return "KDP_MAXBYTES";
+    case KDP_READMEM:               return "KDP_READMEM";
+    case KDP_WRITEMEM:              return "KDP_WRITEMEM";
+    case KDP_READREGS:              return "KDP_READREGS";
+    case KDP_WRITEREGS:             return "KDP_WRITEREGS";
+    case KDP_LOAD:                  return "KDP_LOAD";
+    case KDP_IMAGEPATH:             return "KDP_IMAGEPATH";
+    case KDP_SUSPEND:               return "KDP_SUSPEND";
+    case KDP_RESUMECPUS:            return "KDP_RESUMECPUS";
+    case KDP_EXCEPTION:             return "KDP_EXCEPTION";
+    case KDP_TERMINATION:           return "KDP_TERMINATION";
+    case KDP_BREAKPOINT_SET:        return "KDP_BREAKPOINT_SET";
+    case KDP_BREAKPOINT_REMOVE:     return "KDP_BREAKPOINT_REMOVE";
+    case KDP_REGIONS:               return "KDP_REGIONS";
+    case KDP_REATTACH:              return "KDP_REATTACH";
+    case KDP_HOSTREBOOT:            return "KDP_HOSTREBOOT";
+    case KDP_READMEM64:             return "KDP_READMEM64";
+    case KDP_WRITEMEM64:            return "KDP_WRITEMEM64";
+    case KDP_BREAKPOINT_SET64:      return "KDP_BREAKPOINT64_SET";
+    case KDP_BREAKPOINT_REMOVE64:   return "KDP_BREAKPOINT64_REMOVE";
+    case KDP_KERNELVERSION:         return "KDP_KERNELVERSION";
+    case KDP_READPHYSMEM64:         return "KDP_READPHYSMEM64";
+    case KDP_WRITEPHYSMEM64:        return "KDP_WRITEPHYSMEM64";
+    case KDP_READIOPORT:            return "KDP_READIOPORT";
+    case KDP_WRITEIOPORT:           return "KDP_WRITEIOPORT";
+    case KDP_READMSR64:             return "KDP_READMSR64";
+    case KDP_WRITEMSR64:            return "KDP_WRITEMSR64";
+    case KDP_DUMPINFO:              return "KDP_DUMPINFO";
+    }
+    return NULL;
+}
+
+void
+CommunicationKDP::DumpPacket (Stream &s, const void *data, uint32_t data_len)
+{
+    DataExtractor extractor (data, data_len, m_byte_order, m_addr_byte_size);
+    DumpPacket (s, extractor);
+}
+
+void
+CommunicationKDP::DumpPacket (Stream &s, const DataExtractor& packet)
+{
+    const char *error_desc = NULL;
+    if (packet.GetByteSize() < 8)
+    {
+        error_desc = "error: invalid packet (too short): ";
+    }
+    else
+    {
+        lldb::offset_t offset = 0;
+        const uint8_t first_packet_byte = packet.GetU8 (&offset);
+        const uint8_t sequence_id = packet.GetU8 (&offset);
+        const uint16_t length = packet.GetU16 (&offset);
+        const uint32_t key = packet.GetU32 (&offset);
+        const CommandType command = ExtractCommand (first_packet_byte);
+        const char *command_name = GetCommandAsCString (command);
+        if (command_name)
+        {
+            const bool is_reply = ExtractIsReply(first_packet_byte);
+            s.Printf ("(running=%i) %s %24s: 0x%2.2x 0x%2.2x 0x%4.4x 0x%8.8x ",
+                      IsRunning(),
+                      is_reply ? "<--" : "-->",
+                      command_name,
+                      first_packet_byte,
+                      sequence_id,
+                      length,
+                      key);
+            
+            if (is_reply)
+            {
+                // Dump request reply packets
+                switch (command)
+                {
+                    // Commands that return a single 32 bit error
+                    case KDP_CONNECT:
+                    case KDP_WRITEMEM:
+                    case KDP_WRITEMEM64:
+                    case KDP_BREAKPOINT_SET:
+                    case KDP_BREAKPOINT_REMOVE:
+                    case KDP_BREAKPOINT_SET64:
+                    case KDP_BREAKPOINT_REMOVE64:
+                    case KDP_WRITEREGS:
+                    case KDP_LOAD:
+                    case KDP_WRITEIOPORT:
+                    case KDP_WRITEMSR64:
+                        {
+                            const uint32_t error = packet.GetU32 (&offset);
+                            s.Printf(" (error=0x%8.8x)", error);
+                        }
+                        break;
+                    
+                    case KDP_DISCONNECT:
+                    case KDP_REATTACH:
+                    case KDP_HOSTREBOOT:
+                    case KDP_SUSPEND:
+                    case KDP_RESUMECPUS:
+                    case KDP_EXCEPTION:
+                    case KDP_TERMINATION:
+                        // No return value for the reply, just the header to ack
+                        s.PutCString(" ()");
+                        break;
+
+                    case KDP_HOSTINFO:
+                        {
+                            const uint32_t cpu_mask = packet.GetU32 (&offset);
+                            const uint32_t cpu_type = packet.GetU32 (&offset);
+                            const uint32_t cpu_subtype = packet.GetU32 (&offset);
+                            s.Printf(" (cpu_mask=0x%8.8x, cpu_type=0x%8.8x, cpu_subtype=0x%8.8x)", cpu_mask, cpu_type, cpu_subtype);
+                        }
+                        break;
+                        
+                    case KDP_VERSION:
+                        {
+                            const uint32_t version = packet.GetU32 (&offset);
+                            const uint32_t feature = packet.GetU32 (&offset);
+                            s.Printf(" (version=0x%8.8x, feature=0x%8.8x)", version, feature);
+                        }
+                        break;
+                        
+                    case KDP_REGIONS:
+                        {
+                            const uint32_t region_count = packet.GetU32 (&offset);
+                            s.Printf(" (count = %u", region_count); 
+                            for (uint32_t i=0; i<region_count; ++i)
+                            {
+                                const addr_t region_addr = packet.GetPointer (&offset);
+                                const uint32_t region_size = packet.GetU32 (&offset);
+                                const uint32_t region_prot = packet.GetU32 (&offset);
+                                s.Printf("\n\tregion[%" PRIu64 "] = { range = [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), size = 0x%8.8x, prot = %s }", region_addr, region_addr, region_addr + region_size, region_size, GetPermissionsAsCString (region_prot));
+                            }
+                        }
+                        break;
+
+                    case KDP_READMEM:
+                    case KDP_READMEM64:
+                    case KDP_READPHYSMEM64:
+                        {
+                            const uint32_t error = packet.GetU32 (&offset);
+                            const uint32_t count = packet.GetByteSize() - offset;
+                            s.Printf(" (error = 0x%8.8x:\n", error); 
+                            if (count > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatBytesWithASCII,     // Format to use
+                                             1,                         // Size of each item in bytes
+                                             count,                     // Number of items
+                                             16,                        // Number per line
+                                             m_last_read_memory_addr,   // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                        }
+                        break;
+
+                    case KDP_READREGS:
+                        {
+                            const uint32_t error = packet.GetU32 (&offset);
+                            const uint32_t count = packet.GetByteSize() - offset;
+                            s.Printf(" (error = 0x%8.8x regs:\n", error); 
+                            if (count > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             m_addr_byte_size,          // Size of each item in bytes
+                                             count / m_addr_byte_size,  // Number of items
+                                             16 / m_addr_byte_size,     // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                        }
+                        break;
+
+                    case KDP_KERNELVERSION:
+                        {
+                            const char *kernel_version = packet.PeekCStr(8);
+                            s.Printf(" (version = \"%s\")", kernel_version);
+                        }
+                        break;
+                        
+                    case KDP_MAXBYTES:
+                        {
+                            const uint32_t max_bytes = packet.GetU32 (&offset);
+                            s.Printf(" (max_bytes = 0x%8.8x (%u))", max_bytes, max_bytes);
+                        }
+                        break;
+                    case KDP_IMAGEPATH:
+                        {
+                            const char *path = packet.GetCStr(&offset);
+                            s.Printf(" (path = \"%s\")", path);
+                        }
+                        break;
+
+                    case KDP_READIOPORT:
+                    case KDP_READMSR64:
+                        {
+                            const uint32_t error = packet.GetU32 (&offset);
+                            const uint32_t count = packet.GetByteSize() - offset;
+                            s.Printf(" (error = 0x%8.8x io:\n", error); 
+                            if (count > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             1,                         // Size of each item in bytes
+                                             count,                     // Number of items
+                                             16,                        // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                        }
+                        break;
+                    case KDP_DUMPINFO:
+                        {
+                            const uint32_t count = packet.GetByteSize() - offset;
+                            s.Printf(" (count = %u, bytes = \n", count);
+                            if (count > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             1,                         // Size of each item in bytes
+                                             count,                     // Number of items
+                                             16,                        // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                            
+                        }
+                        break;
+                        
+                    default:
+                        s.Printf(" (add support for dumping this packet reply!!!"); 
+                        break;
+                    
+                } 
+            }
+            else
+            {
+                // Dump request packets
+                switch (command)
+                {
+                    case KDP_CONNECT:               
+                        {
+                            const uint16_t reply_port = ntohs(packet.GetU16 (&offset));
+                            const uint16_t exc_port = ntohs(packet.GetU16 (&offset));
+                            s.Printf(" (reply_port = %u, exc_port = %u, greeting = \"%s\")", reply_port, exc_port, packet.GetCStr(&offset));
+                        }
+                        break;
+                                 
+                    case KDP_DISCONNECT:
+                    case KDP_HOSTREBOOT:
+                    case KDP_HOSTINFO:
+                    case KDP_VERSION:
+                    case KDP_REGIONS:
+                    case KDP_KERNELVERSION:
+                    case KDP_MAXBYTES:
+                    case KDP_IMAGEPATH:
+                    case KDP_SUSPEND:
+                        // No args, just the header in the request...
+                        s.PutCString(" ()");
+                        break;
+
+                    case KDP_RESUMECPUS:
+                        {
+                            const uint32_t cpu_mask = packet.GetU32 (&offset);
+                            s.Printf(" (cpu_mask = 0x%8.8x)", cpu_mask);
+                        }
+                        break;
+
+                    case KDP_READMEM:
+                        {
+                            const uint32_t addr = packet.GetU32 (&offset);
+                            const uint32_t size = packet.GetU32 (&offset);
+                            s.Printf(" (addr = 0x%8.8x, size = %u)", addr, size);
+                            m_last_read_memory_addr = addr;
+                        }
+                        break;
+
+                    case KDP_WRITEMEM:
+                        {
+                            const uint32_t addr = packet.GetU32 (&offset);
+                            const uint32_t size = packet.GetU32 (&offset);
+                            s.Printf(" (addr = 0x%8.8x, size = %u, bytes = \n", addr, size);
+                            if (size > 0)
+                                DataExtractor::DumpHexBytes(&s, packet.GetData(&offset, size), size, 32, addr);
+                        }
+                        break;
+
+                    case KDP_READMEM64:
+                        {
+                            const uint64_t addr = packet.GetU64 (&offset);
+                            const uint32_t size = packet.GetU32 (&offset);
+                            s.Printf(" (addr = 0x%16.16" PRIx64 ", size = %u)", addr, size);
+                            m_last_read_memory_addr = addr;
+                        }
+                        break;
+
+                    case KDP_READPHYSMEM64:
+                        {
+                            const uint64_t addr = packet.GetU64 (&offset);
+                            const uint32_t size = packet.GetU32 (&offset);
+                            const uint32_t lcpu = packet.GetU16 (&offset);
+                            s.Printf(" (addr = 0x%16.16llx, size = %u, lcpu = %u)", addr, size, lcpu);
+                            m_last_read_memory_addr = addr;
+                        }
+                        break;
+
+                    case KDP_WRITEMEM64:
+                        {
+                            const uint64_t addr = packet.GetU64 (&offset);
+                            const uint32_t size = packet.GetU32 (&offset);
+                            s.Printf(" (addr = 0x%16.16" PRIx64 ", size = %u, bytes = \n", addr, size);
+                            if (size > 0)
+                                DataExtractor::DumpHexBytes(&s, packet.GetData(&offset, size), size, 32, addr);
+                        }
+                        break;
+
+                    case KDP_WRITEPHYSMEM64:
+                        {
+                            const uint64_t addr = packet.GetU64 (&offset);
+                            const uint32_t size = packet.GetU32 (&offset);
+                            const uint32_t lcpu = packet.GetU16 (&offset);
+                            s.Printf(" (addr = 0x%16.16llx, size = %u, lcpu = %u, bytes = \n", addr, size, lcpu);
+                            if (size > 0)
+                                DataExtractor::DumpHexBytes(&s, packet.GetData(&offset, size), size, 32, addr);
+                        }
+                        break;
+
+                    case KDP_READREGS:
+                        {
+                            const uint32_t cpu = packet.GetU32 (&offset);
+                            const uint32_t flavor = packet.GetU32 (&offset);
+                            s.Printf(" (cpu = %u, flavor = %u)", cpu, flavor);
+                        }
+                        break;
+
+                    case KDP_WRITEREGS:
+                        {
+                            const uint32_t cpu = packet.GetU32 (&offset);
+                            const uint32_t flavor = packet.GetU32 (&offset);
+                            const uint32_t nbytes = packet.GetByteSize() - offset;
+                            s.Printf(" (cpu = %u, flavor = %u, regs = \n", cpu, flavor);
+                            if (nbytes > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             m_addr_byte_size,          // Size of each item in bytes
+                                             nbytes / m_addr_byte_size, // Number of items
+                                             16 / m_addr_byte_size,     // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                        }
+                        break;
+
+
+                    case KDP_BREAKPOINT_SET:
+                    case KDP_BREAKPOINT_REMOVE:
+                        {
+                            const uint32_t addr = packet.GetU32 (&offset);
+                            s.Printf(" (addr = 0x%8.8x)", addr);
+                        }
+                        break;
+
+                    case KDP_BREAKPOINT_SET64:
+                    case KDP_BREAKPOINT_REMOVE64:
+                        {
+                            const uint64_t addr = packet.GetU64 (&offset);
+                            s.Printf(" (addr = 0x%16.16" PRIx64 ")", addr);
+                        }
+                        break;
+
+
+                    case KDP_LOAD:
+                        {
+                            const char *path = packet.GetCStr(&offset);
+                            s.Printf(" (path = \"%s\")", path);
+                        }
+                        break;
+
+                    case KDP_EXCEPTION:
+                        {
+                            const uint32_t count = packet.GetU32 (&offset);
+                            
+                            for (uint32_t i=0; i<count; ++i)
+                            {
+                                const uint32_t cpu = packet.GetU32 (&offset);
+                                const uint32_t exc = packet.GetU32 (&offset);
+                                const uint32_t code = packet.GetU32 (&offset);
+                                const uint32_t subcode = packet.GetU32 (&offset);
+                                const char *exc_cstr = NULL;
+                                switch (exc)
+                                {
+                                    case 1:  exc_cstr = "EXC_BAD_ACCESS"; break;
+                                    case 2:  exc_cstr = "EXC_BAD_INSTRUCTION"; break;
+                                    case 3:  exc_cstr = "EXC_ARITHMETIC"; break;
+                                    case 4:  exc_cstr = "EXC_EMULATION"; break;
+                                    case 5:  exc_cstr = "EXC_SOFTWARE"; break;
+                                    case 6:  exc_cstr = "EXC_BREAKPOINT"; break;
+                                    case 7:  exc_cstr = "EXC_SYSCALL"; break;
+                                    case 8:  exc_cstr = "EXC_MACH_SYSCALL"; break;
+                                    case 9:  exc_cstr = "EXC_RPC_ALERT"; break;
+                                    case 10: exc_cstr = "EXC_CRASH"; break;
+                                    default:
+                                        break;
+                                }
+
+                                s.Printf ("{ cpu = 0x%8.8x, exc = %s (%u), code = %u (0x%8.8x), subcode = %u (0x%8.8x)} ", 
+                                          cpu, exc_cstr, exc, code, code, subcode, subcode);
+                            }
+                        }
+                        break;
+
+                    case KDP_TERMINATION:
+                        {
+                            const uint32_t term_code = packet.GetU32 (&offset);
+                            const uint32_t exit_code = packet.GetU32 (&offset);
+                            s.Printf(" (term_code = 0x%8.8x (%u), exit_code = 0x%8.8x (%u))", term_code, term_code, exit_code, exit_code);
+                        }
+                        break;
+
+                    case KDP_REATTACH:
+                        {
+                            const uint16_t reply_port = ntohs(packet.GetU16 (&offset));
+                            s.Printf(" (reply_port = %u)", reply_port);
+                        }
+                        break;
+
+                    case KDP_READMSR64:
+                        {
+                            const uint32_t address = packet.GetU32 (&offset);
+                            const uint16_t lcpu = packet.GetU16 (&offset);
+                            s.Printf(" (address=0x%8.8x, lcpu=0x%4.4x)", address, lcpu);
+                        }
+                        break;
+
+                    case KDP_WRITEMSR64:
+                        {
+                            const uint32_t address = packet.GetU32 (&offset);
+                            const uint16_t lcpu = packet.GetU16 (&offset);
+                            const uint32_t nbytes = packet.GetByteSize() - offset;
+                            s.Printf(" (address=0x%8.8x, lcpu=0x%4.4x, nbytes=0x%8.8x)", lcpu, address, nbytes);
+                            if (nbytes > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             1,                         // Size of each item in bytes
+                                             nbytes,                    // Number of items
+                                             16,                        // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                        }
+                        break;
+
+                    case KDP_READIOPORT:
+                        {
+                            const uint16_t lcpu = packet.GetU16 (&offset);
+                            const uint16_t address = packet.GetU16 (&offset);
+                            const uint16_t nbytes = packet.GetU16 (&offset);
+                            s.Printf(" (lcpu=0x%4.4x, address=0x%4.4x, nbytes=%u)", lcpu, address, nbytes);
+                        }
+                        break;
+
+                    case KDP_WRITEIOPORT:
+                         {
+                            const uint16_t lcpu = packet.GetU16 (&offset);
+                            const uint16_t address = packet.GetU16 (&offset);
+                            const uint16_t nbytes = packet.GetU16 (&offset);
+                            s.Printf(" (lcpu = %u, addr = 0x%4.4x, nbytes = %u, bytes = \n", lcpu, address, nbytes);
+                            if (nbytes > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             1,                         // Size of each item in bytes
+                                             nbytes,                    // Number of items
+                                             16,                        // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                        }
+                        break;
+                        
+                    case KDP_DUMPINFO:
+                        {
+                            const uint32_t count = packet.GetByteSize() - offset;
+                            s.Printf(" (count = %u, bytes = \n", count);
+                            if (count > 0)
+                                packet.Dump (&s,                        // Stream to dump to
+                                             offset,                    // Offset within "packet"
+                                             eFormatHex,                // Format to use
+                                             1,                         // Size of each item in bytes
+                                             count,                     // Number of items
+                                             16,                        // Number per line
+                                             LLDB_INVALID_ADDRESS,      // Don't show addresses before each line
+                                             0, 0);                     // No bitfields
+                            
+                        }
+                        break;
+                        
+               }
+            }
+        }
+        else
+        {
+            error_desc = "error: invalid packet command: ";
+        }
+    }
+
+    if (error_desc)
+    {
+        s.PutCString (error_desc);
+
+        packet.Dump (&s,                    // Stream to dump to
+                     0,                     // Offset into "packet"
+                     eFormatBytes,          // Dump as hex bytes
+                     1,                     // Size of each item is 1 for single bytes
+                     packet.GetByteSize(),  // Number of bytes
+                     UINT32_MAX,            // Num bytes per line
+                     LLDB_INVALID_ADDRESS,  // Base address
+                     0, 0);                 // Bitfield info set to not do anything bitfield related
+    }
+}
+
+uint32_t
+CommunicationKDP::SendRequestReadRegisters (uint32_t cpu,
+                                            uint32_t flavor,
+                                            void *dst,
+                                            uint32_t dst_len,
+                                            Error &error)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_READREGS;
+    // Size is header + 4 byte cpu and 4 byte flavor
+    const uint32_t command_length = 8 + 4 + 4;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutHex32 (cpu);
+    request_packet.PutHex32 (flavor);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        uint32_t kdp_error = reply_packet.GetU32 (&offset);
+        uint32_t src_len = reply_packet.GetByteSize() - 12;
+        
+        if (src_len > 0)
+        {
+            const uint32_t bytes_to_copy = std::min<uint32_t>(src_len, dst_len);
+            const void *src = reply_packet.GetData(&offset, bytes_to_copy);
+            if (src)
+            {
+                ::memcpy (dst, src, bytes_to_copy);
+                error.Clear();
+                // Return the number of bytes we could have returned regardless if
+                // we copied them or not, just so we know when things don't match up
+                return src_len;
+            }
+        }
+        if (kdp_error)
+            error.SetErrorStringWithFormat("failed to read kdp registers for cpu %u flavor %u (error %u)", cpu, flavor, kdp_error);
+        else
+            error.SetErrorStringWithFormat("failed to read kdp registers for cpu %u flavor %u", cpu, flavor);
+    }
+    else
+    {
+        error.SetErrorString ("failed to send packet");
+    }
+    return 0;
+}
+
+uint32_t
+CommunicationKDP::SendRequestWriteRegisters (uint32_t cpu,
+                                             uint32_t flavor,
+                                             const void *src,
+                                             uint32_t src_len,
+                                             Error &error)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_WRITEREGS;
+    // Size is header + 4 byte cpu and 4 byte flavor
+    const uint32_t command_length = 8 + 4 + 4 + src_len;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutHex32 (cpu);
+    request_packet.PutHex32 (flavor);
+    request_packet.Write(src, src_len);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        uint32_t kdp_error = reply_packet.GetU32 (&offset);
+        if (kdp_error == 0)
+            return src_len;
+        error.SetErrorStringWithFormat("failed to read kdp registers for cpu %u flavor %u (error %u)", cpu, flavor, kdp_error);
+    }
+    else
+    {
+        error.SetErrorString ("failed to send packet");
+    }
+    return 0;
+}
+
+
+bool
+CommunicationKDP::SendRequestResume ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_RESUMECPUS;
+    const uint32_t command_length = 12;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutHex32(GetCPUMask());
+
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+        return true;
+    return false;
+}
+
+bool
+CommunicationKDP::SendRequestBreakpoint (bool set, addr_t addr)
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    bool use_64 = (GetVersion() >= 11);
+    uint32_t command_addr_byte_size = use_64 ? 8 : 4;
+    const CommandType command = set ? (use_64 ? KDP_BREAKPOINT_SET64    : KDP_BREAKPOINT_SET   ):
+                                      (use_64 ? KDP_BREAKPOINT_REMOVE64 : KDP_BREAKPOINT_REMOVE);
+
+    const uint32_t command_length = 8 + command_addr_byte_size;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    request_packet.PutMaxHex64 (addr, command_addr_byte_size);
+    
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+    {
+        lldb::offset_t offset = 8;
+        uint32_t kdp_error = reply_packet.GetU32 (&offset);        
+        if (kdp_error == 0)
+            return true;
+    }
+    return false;
+}
+
+bool
+CommunicationKDP::SendRequestSuspend ()
+{
+    PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order);
+    const CommandType command = KDP_SUSPEND;
+    const uint32_t command_length = 8;
+    MakeRequestPacketHeader (command, request_packet, command_length);
+    DataExtractor reply_packet;
+    if (SendRequestAndGetReply (command, request_packet, reply_packet))
+        return true;
+    return false;
+}
+