| //===-- 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; |
| } |
| |
