1 //===-- CommunicationKDP.cpp ------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "CommunicationKDP.h" 11 12 // C Includes 13 #include <errno.h> 14 #include <limits.h> 15 #include <string.h> 16 17 // C++ Includes 18 19 // Other libraries and framework includes 20 #include "lldb/Core/DataBufferHeap.h" 21 #include "lldb/Core/DataExtractor.h" 22 #include "lldb/Core/Log.h" 23 #include "lldb/Core/State.h" 24 #include "lldb/Core/UUID.h" 25 #include "lldb/Host/FileSpec.h" 26 #include "lldb/Host/Host.h" 27 #include "lldb/Target/Process.h" 28 29 // Project includes 30 #include "ProcessKDPLog.h" 31 32 using namespace lldb; 33 using namespace lldb_private; 34 35 //---------------------------------------------------------------------- 36 // CommunicationKDP constructor 37 //---------------------------------------------------------------------- 38 CommunicationKDP::CommunicationKDP(const char *comm_name) 39 : Communication(comm_name), m_addr_byte_size(4), 40 m_byte_order(eByteOrderLittle), m_packet_timeout(5), m_sequence_mutex(), 41 m_is_running(false), m_session_key(0u), m_request_sequence_id(0u), 42 m_exception_sequence_id(0u), m_kdp_version_version(0u), 43 m_kdp_version_feature(0u), m_kdp_hostinfo_cpu_mask(0u), 44 m_kdp_hostinfo_cpu_type(0u), m_kdp_hostinfo_cpu_subtype(0u) {} 45 46 //---------------------------------------------------------------------- 47 // Destructor 48 //---------------------------------------------------------------------- 49 CommunicationKDP::~CommunicationKDP() { 50 if (IsConnected()) { 51 Disconnect(); 52 } 53 } 54 55 bool CommunicationKDP::SendRequestPacket( 56 const PacketStreamType &request_packet) { 57 std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex); 58 return SendRequestPacketNoLock(request_packet); 59 } 60 61 #if 0 62 typedef struct { 63 uint8_t request; // Either: CommandType | ePacketTypeRequest, or CommandType | ePacketTypeReply 64 uint8_t sequence; 65 uint16_t length; // Length of entire packet including this header 66 uint32_t key; // Session key 67 } kdp_hdr_t; 68 #endif 69 70 void CommunicationKDP::MakeRequestPacketHeader(CommandType request_type, 71 PacketStreamType &request_packet, 72 uint16_t request_length) { 73 request_packet.Clear(); 74 request_packet.PutHex8(request_type | 75 ePacketTypeRequest); // Set the request type 76 request_packet.PutHex8(m_request_sequence_id++); // Sequence number 77 request_packet.PutHex16( 78 request_length); // Length of the packet including this header 79 request_packet.PutHex32(m_session_key); // Session key 80 } 81 82 bool CommunicationKDP::SendRequestAndGetReply( 83 const CommandType command, const PacketStreamType &request_packet, 84 DataExtractor &reply_packet) { 85 if (IsRunning()) { 86 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PACKETS)); 87 if (log) { 88 PacketStreamType log_strm; 89 DumpPacket(log_strm, request_packet.GetData(), request_packet.GetSize()); 90 log->Printf("error: kdp running, not sending packet: %.*s", 91 (uint32_t)log_strm.GetSize(), log_strm.GetData()); 92 } 93 return false; 94 } 95 96 std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex); 97 #ifdef LLDB_CONFIGURATION_DEBUG 98 // NOTE: this only works for packets that are in native endian byte order 99 assert(request_packet.GetSize() == 100 *((uint16_t *)(request_packet.GetData() + 2))); 101 #endif 102 lldb::offset_t offset = 1; 103 const uint32_t num_retries = 3; 104 for (uint32_t i = 0; i < num_retries; ++i) { 105 if (SendRequestPacketNoLock(request_packet)) { 106 const uint8_t request_sequence_id = (uint8_t)request_packet.GetData()[1]; 107 while (1) { 108 if (WaitForPacketWithTimeoutMicroSecondsNoLock( 109 reply_packet, 110 std::chrono::microseconds(GetPacketTimeout()).count())) { 111 offset = 0; 112 const uint8_t reply_command = reply_packet.GetU8(&offset); 113 const uint8_t reply_sequence_id = reply_packet.GetU8(&offset); 114 if (request_sequence_id == reply_sequence_id) { 115 // The sequent ID was correct, now verify we got the response we 116 // were looking for 117 if ((reply_command & eCommandTypeMask) == command) { 118 // Success 119 if (command == KDP_RESUMECPUS) 120 m_is_running.SetValue(true, eBroadcastAlways); 121 return true; 122 } else { 123 // Failed to get the correct response, bail 124 reply_packet.Clear(); 125 return false; 126 } 127 } else if (reply_sequence_id > request_sequence_id) { 128 // Sequence ID was greater than the sequence ID of the packet we 129 // sent, something 130 // is really wrong... 131 reply_packet.Clear(); 132 return false; 133 } else { 134 // The reply sequence ID was less than our current packet's sequence 135 // ID 136 // so we should keep trying to get a response because this was a 137 // response 138 // for a previous packet that we must have retried. 139 } 140 } else { 141 // Break and retry sending the packet as we didn't get a response due 142 // to timeout 143 break; 144 } 145 } 146 } 147 } 148 reply_packet.Clear(); 149 return false; 150 } 151 152 bool CommunicationKDP::SendRequestPacketNoLock( 153 const PacketStreamType &request_packet) { 154 if (IsConnected()) { 155 const char *packet_data = request_packet.GetData(); 156 const size_t packet_size = request_packet.GetSize(); 157 158 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PACKETS)); 159 if (log) { 160 PacketStreamType log_strm; 161 DumpPacket(log_strm, packet_data, packet_size); 162 log->Printf("%.*s", (uint32_t)log_strm.GetSize(), log_strm.GetData()); 163 } 164 ConnectionStatus status = eConnectionStatusSuccess; 165 166 size_t bytes_written = Write(packet_data, packet_size, status, NULL); 167 168 if (bytes_written == packet_size) 169 return true; 170 171 if (log) 172 log->Printf("error: failed to send packet entire packet %" PRIu64 173 " of %" PRIu64 " bytes sent", 174 (uint64_t)bytes_written, (uint64_t)packet_size); 175 } 176 return false; 177 } 178 179 bool CommunicationKDP::GetSequenceMutex( 180 std::unique_lock<std::recursive_mutex> &lock) { 181 return (lock = std::unique_lock<std::recursive_mutex>(m_sequence_mutex, 182 std::try_to_lock)) 183 .owns_lock(); 184 } 185 186 bool CommunicationKDP::WaitForNotRunningPrivate( 187 const std::chrono::microseconds &timeout) { 188 return m_is_running.WaitForValueEqualTo(false, timeout, NULL); 189 } 190 191 size_t 192 CommunicationKDP::WaitForPacketWithTimeoutMicroSeconds(DataExtractor &packet, 193 uint32_t timeout_usec) { 194 std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex); 195 return WaitForPacketWithTimeoutMicroSecondsNoLock(packet, timeout_usec); 196 } 197 198 size_t CommunicationKDP::WaitForPacketWithTimeoutMicroSecondsNoLock( 199 DataExtractor &packet, uint32_t timeout_usec) { 200 uint8_t buffer[8192]; 201 Error error; 202 203 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PACKETS | 204 KDP_LOG_VERBOSE)); 205 206 // Check for a packet from our cache first without trying any reading... 207 if (CheckForPacket(NULL, 0, packet)) 208 return packet.GetByteSize(); 209 210 bool timed_out = false; 211 while (IsConnected() && !timed_out) { 212 lldb::ConnectionStatus status = eConnectionStatusNoConnection; 213 size_t bytes_read = Read(buffer, sizeof(buffer), 214 timeout_usec == UINT32_MAX 215 ? Timeout<std::micro>(llvm::None) 216 : std::chrono::microseconds(timeout_usec), 217 status, &error); 218 219 if (log) 220 log->Printf("%s: Read (buffer, (sizeof(buffer), timeout_usec = 0x%x, " 221 "status = %s, error = %s) => bytes_read = %" PRIu64, 222 LLVM_PRETTY_FUNCTION, timeout_usec, 223 Communication::ConnectionStatusAsCString(status), 224 error.AsCString(), (uint64_t)bytes_read); 225 226 if (bytes_read > 0) { 227 if (CheckForPacket(buffer, bytes_read, packet)) 228 return packet.GetByteSize(); 229 } else { 230 switch (status) { 231 case eConnectionStatusInterrupted: 232 case eConnectionStatusTimedOut: 233 timed_out = true; 234 break; 235 case eConnectionStatusSuccess: 236 // printf ("status = success but error = %s\n", 237 // error.AsCString("<invalid>")); 238 break; 239 240 case eConnectionStatusEndOfFile: 241 case eConnectionStatusNoConnection: 242 case eConnectionStatusLostConnection: 243 case eConnectionStatusError: 244 Disconnect(); 245 break; 246 } 247 } 248 } 249 packet.Clear(); 250 return 0; 251 } 252 253 bool CommunicationKDP::CheckForPacket(const uint8_t *src, size_t src_len, 254 DataExtractor &packet) { 255 // Put the packet data into the buffer in a thread safe fashion 256 std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex); 257 258 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PACKETS)); 259 260 if (src && src_len > 0) { 261 if (log && log->GetVerbose()) { 262 PacketStreamType log_strm; 263 DataExtractor::DumpHexBytes(&log_strm, src, src_len, UINT32_MAX, 264 LLDB_INVALID_ADDRESS); 265 log->Printf("CommunicationKDP::%s adding %u bytes: %s", __FUNCTION__, 266 (uint32_t)src_len, log_strm.GetData()); 267 } 268 m_bytes.append((const char *)src, src_len); 269 } 270 271 // Make sure we at least have enough bytes for a packet header 272 const size_t bytes_available = m_bytes.size(); 273 if (bytes_available >= 8) { 274 packet.SetData(&m_bytes[0], bytes_available, m_byte_order); 275 lldb::offset_t offset = 0; 276 uint8_t reply_command = packet.GetU8(&offset); 277 switch (reply_command) { 278 case ePacketTypeRequest | KDP_EXCEPTION: 279 case ePacketTypeRequest | KDP_TERMINATION: 280 // We got an exception request, so be sure to send an ACK 281 { 282 PacketStreamType request_ack_packet(Stream::eBinary, m_addr_byte_size, 283 m_byte_order); 284 // Set the reply but and make the ACK packet 285 request_ack_packet.PutHex8(reply_command | ePacketTypeReply); 286 request_ack_packet.PutHex8(packet.GetU8(&offset)); 287 request_ack_packet.PutHex16(packet.GetU16(&offset)); 288 request_ack_packet.PutHex32(packet.GetU32(&offset)); 289 m_is_running.SetValue(false, eBroadcastAlways); 290 // Ack to the exception or termination 291 SendRequestPacketNoLock(request_ack_packet); 292 } 293 // Fall through to case below to get packet contents 294 LLVM_FALLTHROUGH; 295 case ePacketTypeReply | KDP_CONNECT: 296 case ePacketTypeReply | KDP_DISCONNECT: 297 case ePacketTypeReply | KDP_HOSTINFO: 298 case ePacketTypeReply | KDP_VERSION: 299 case ePacketTypeReply | KDP_MAXBYTES: 300 case ePacketTypeReply | KDP_READMEM: 301 case ePacketTypeReply | KDP_WRITEMEM: 302 case ePacketTypeReply | KDP_READREGS: 303 case ePacketTypeReply | KDP_WRITEREGS: 304 case ePacketTypeReply | KDP_LOAD: 305 case ePacketTypeReply | KDP_IMAGEPATH: 306 case ePacketTypeReply | KDP_SUSPEND: 307 case ePacketTypeReply | KDP_RESUMECPUS: 308 case ePacketTypeReply | KDP_BREAKPOINT_SET: 309 case ePacketTypeReply | KDP_BREAKPOINT_REMOVE: 310 case ePacketTypeReply | KDP_REGIONS: 311 case ePacketTypeReply | KDP_REATTACH: 312 case ePacketTypeReply | KDP_HOSTREBOOT: 313 case ePacketTypeReply | KDP_READMEM64: 314 case ePacketTypeReply | KDP_WRITEMEM64: 315 case ePacketTypeReply | KDP_BREAKPOINT_SET64: 316 case ePacketTypeReply | KDP_BREAKPOINT_REMOVE64: 317 case ePacketTypeReply | KDP_KERNELVERSION: 318 case ePacketTypeReply | KDP_READPHYSMEM64: 319 case ePacketTypeReply | KDP_WRITEPHYSMEM64: 320 case ePacketTypeReply | KDP_READIOPORT: 321 case ePacketTypeReply | KDP_WRITEIOPORT: 322 case ePacketTypeReply | KDP_READMSR64: 323 case ePacketTypeReply | KDP_WRITEMSR64: 324 case ePacketTypeReply | KDP_DUMPINFO: { 325 offset = 2; 326 const uint16_t length = packet.GetU16(&offset); 327 if (length <= bytes_available) { 328 // We have an entire packet ready, we need to copy the data 329 // bytes into a buffer that will be owned by the packet and 330 // erase the bytes from our communcation buffer "m_bytes" 331 packet.SetData(DataBufferSP(new DataBufferHeap(&m_bytes[0], length))); 332 m_bytes.erase(0, length); 333 334 if (log) { 335 PacketStreamType log_strm; 336 DumpPacket(log_strm, packet); 337 338 log->Printf("%.*s", (uint32_t)log_strm.GetSize(), log_strm.GetData()); 339 } 340 return true; 341 } 342 } break; 343 344 default: 345 // Unrecognized reply command byte, erase this byte and try to get back on 346 // track 347 if (log) 348 log->Printf("CommunicationKDP::%s: tossing junk byte: 0x%2.2x", 349 __FUNCTION__, (uint8_t)m_bytes[0]); 350 m_bytes.erase(0, 1); 351 break; 352 } 353 } 354 packet.Clear(); 355 return false; 356 } 357 358 bool CommunicationKDP::SendRequestConnect(uint16_t reply_port, 359 uint16_t exc_port, 360 const char *greeting) { 361 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 362 m_byte_order); 363 if (greeting == NULL) 364 greeting = ""; 365 366 const CommandType command = KDP_CONNECT; 367 // Length is 82 uint16_t and the length of the greeting C string with the 368 // terminating NULL 369 const uint32_t command_length = 8 + 2 + 2 + ::strlen(greeting) + 1; 370 MakeRequestPacketHeader(command, request_packet, command_length); 371 // Always send connect ports as little endian 372 request_packet.SetByteOrder(eByteOrderLittle); 373 request_packet.PutHex16(htons(reply_port)); 374 request_packet.PutHex16(htons(exc_port)); 375 request_packet.SetByteOrder(m_byte_order); 376 request_packet.PutCString(greeting); 377 DataExtractor reply_packet; 378 return SendRequestAndGetReply(command, request_packet, reply_packet); 379 } 380 381 void CommunicationKDP::ClearKDPSettings() { 382 m_request_sequence_id = 0; 383 m_kdp_version_version = 0; 384 m_kdp_version_feature = 0; 385 m_kdp_hostinfo_cpu_mask = 0; 386 m_kdp_hostinfo_cpu_type = 0; 387 m_kdp_hostinfo_cpu_subtype = 0; 388 } 389 390 bool CommunicationKDP::SendRequestReattach(uint16_t reply_port) { 391 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 392 m_byte_order); 393 const CommandType command = KDP_REATTACH; 394 // Length is 8 bytes for the header plus 2 bytes for the reply UDP port 395 const uint32_t command_length = 8 + 2; 396 MakeRequestPacketHeader(command, request_packet, command_length); 397 // Always send connect ports as little endian 398 request_packet.SetByteOrder(eByteOrderLittle); 399 request_packet.PutHex16(htons(reply_port)); 400 request_packet.SetByteOrder(m_byte_order); 401 DataExtractor reply_packet; 402 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 403 // Reset the sequence ID to zero for reattach 404 ClearKDPSettings(); 405 lldb::offset_t offset = 4; 406 m_session_key = reply_packet.GetU32(&offset); 407 return true; 408 } 409 return false; 410 } 411 412 uint32_t CommunicationKDP::GetVersion() { 413 if (!VersionIsValid()) 414 SendRequestVersion(); 415 return m_kdp_version_version; 416 } 417 418 uint32_t CommunicationKDP::GetFeatureFlags() { 419 if (!VersionIsValid()) 420 SendRequestVersion(); 421 return m_kdp_version_feature; 422 } 423 424 bool CommunicationKDP::SendRequestVersion() { 425 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 426 m_byte_order); 427 const CommandType command = KDP_VERSION; 428 const uint32_t command_length = 8; 429 MakeRequestPacketHeader(command, request_packet, command_length); 430 DataExtractor reply_packet; 431 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 432 lldb::offset_t offset = 8; 433 m_kdp_version_version = reply_packet.GetU32(&offset); 434 m_kdp_version_feature = reply_packet.GetU32(&offset); 435 return true; 436 } 437 return false; 438 } 439 440 #if 0 // Disable KDP_IMAGEPATH for now, it seems to hang the KDP connection... 441 const char * 442 CommunicationKDP::GetImagePath () 443 { 444 if (m_image_path.empty()) 445 SendRequestImagePath(); 446 return m_image_path.c_str(); 447 } 448 449 bool 450 CommunicationKDP::SendRequestImagePath () 451 { 452 PacketStreamType request_packet (Stream::eBinary, m_addr_byte_size, m_byte_order); 453 const CommandType command = KDP_IMAGEPATH; 454 const uint32_t command_length = 8; 455 MakeRequestPacketHeader (command, request_packet, command_length); 456 DataExtractor reply_packet; 457 if (SendRequestAndGetReply (command, request_packet, reply_packet)) 458 { 459 const char *path = reply_packet.PeekCStr(8); 460 if (path && path[0]) 461 m_kernel_version.assign (path); 462 return true; 463 } 464 return false; 465 } 466 #endif 467 468 uint32_t CommunicationKDP::GetCPUMask() { 469 if (!HostInfoIsValid()) 470 SendRequestHostInfo(); 471 return m_kdp_hostinfo_cpu_mask; 472 } 473 474 uint32_t CommunicationKDP::GetCPUType() { 475 if (!HostInfoIsValid()) 476 SendRequestHostInfo(); 477 return m_kdp_hostinfo_cpu_type; 478 } 479 480 uint32_t CommunicationKDP::GetCPUSubtype() { 481 if (!HostInfoIsValid()) 482 SendRequestHostInfo(); 483 return m_kdp_hostinfo_cpu_subtype; 484 } 485 486 lldb_private::UUID CommunicationKDP::GetUUID() { 487 UUID uuid; 488 if (GetKernelVersion() == NULL) 489 return uuid; 490 491 if (m_kernel_version.find("UUID=") == std::string::npos) 492 return uuid; 493 494 size_t p = m_kernel_version.find("UUID=") + strlen("UUID="); 495 std::string uuid_str = m_kernel_version.substr(p, 36); 496 if (uuid_str.size() < 32) 497 return uuid; 498 499 if (uuid.SetFromCString(uuid_str.c_str()) == 0) { 500 UUID invalid_uuid; 501 return invalid_uuid; 502 } 503 504 return uuid; 505 } 506 507 bool CommunicationKDP::RemoteIsEFI() { 508 if (GetKernelVersion() == NULL) 509 return false; 510 if (strncmp(m_kernel_version.c_str(), "EFI", 3) == 0) 511 return true; 512 else 513 return false; 514 } 515 516 bool CommunicationKDP::RemoteIsDarwinKernel() { 517 if (GetKernelVersion() == NULL) 518 return false; 519 if (m_kernel_version.find("Darwin Kernel") != std::string::npos) 520 return true; 521 else 522 return false; 523 } 524 525 lldb::addr_t CommunicationKDP::GetLoadAddress() { 526 if (GetKernelVersion() == NULL) 527 return LLDB_INVALID_ADDRESS; 528 529 if (m_kernel_version.find("stext=") == std::string::npos) 530 return LLDB_INVALID_ADDRESS; 531 size_t p = m_kernel_version.find("stext=") + strlen("stext="); 532 if (m_kernel_version[p] != '0' || m_kernel_version[p + 1] != 'x') 533 return LLDB_INVALID_ADDRESS; 534 535 addr_t kernel_load_address; 536 errno = 0; 537 kernel_load_address = ::strtoul(m_kernel_version.c_str() + p, NULL, 16); 538 if (errno != 0 || kernel_load_address == 0) 539 return LLDB_INVALID_ADDRESS; 540 541 return kernel_load_address; 542 } 543 544 bool CommunicationKDP::SendRequestHostInfo() { 545 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 546 m_byte_order); 547 const CommandType command = KDP_HOSTINFO; 548 const uint32_t command_length = 8; 549 MakeRequestPacketHeader(command, request_packet, command_length); 550 DataExtractor reply_packet; 551 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 552 lldb::offset_t offset = 8; 553 m_kdp_hostinfo_cpu_mask = reply_packet.GetU32(&offset); 554 m_kdp_hostinfo_cpu_type = reply_packet.GetU32(&offset); 555 m_kdp_hostinfo_cpu_subtype = reply_packet.GetU32(&offset); 556 557 ArchSpec kernel_arch; 558 kernel_arch.SetArchitecture(eArchTypeMachO, m_kdp_hostinfo_cpu_type, 559 m_kdp_hostinfo_cpu_subtype); 560 561 m_addr_byte_size = kernel_arch.GetAddressByteSize(); 562 m_byte_order = kernel_arch.GetByteOrder(); 563 return true; 564 } 565 return false; 566 } 567 568 const char *CommunicationKDP::GetKernelVersion() { 569 if (m_kernel_version.empty()) 570 SendRequestKernelVersion(); 571 return m_kernel_version.c_str(); 572 } 573 574 bool CommunicationKDP::SendRequestKernelVersion() { 575 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 576 m_byte_order); 577 const CommandType command = KDP_KERNELVERSION; 578 const uint32_t command_length = 8; 579 MakeRequestPacketHeader(command, request_packet, command_length); 580 DataExtractor reply_packet; 581 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 582 const char *kernel_version_cstr = reply_packet.PeekCStr(8); 583 if (kernel_version_cstr && kernel_version_cstr[0]) 584 m_kernel_version.assign(kernel_version_cstr); 585 return true; 586 } 587 return false; 588 } 589 590 bool CommunicationKDP::SendRequestDisconnect() { 591 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 592 m_byte_order); 593 const CommandType command = KDP_DISCONNECT; 594 const uint32_t command_length = 8; 595 MakeRequestPacketHeader(command, request_packet, command_length); 596 DataExtractor reply_packet; 597 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 598 // Are we supposed to get a reply for disconnect? 599 } 600 ClearKDPSettings(); 601 return true; 602 } 603 604 uint32_t CommunicationKDP::SendRequestReadMemory(lldb::addr_t addr, void *dst, 605 uint32_t dst_len, 606 Error &error) { 607 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 608 m_byte_order); 609 bool use_64 = (GetVersion() >= 11); 610 uint32_t command_addr_byte_size = use_64 ? 8 : 4; 611 const CommandType command = use_64 ? KDP_READMEM64 : KDP_READMEM; 612 // Size is header + address size + uint32_t length 613 const uint32_t command_length = 8 + command_addr_byte_size + 4; 614 MakeRequestPacketHeader(command, request_packet, command_length); 615 request_packet.PutMaxHex64(addr, command_addr_byte_size); 616 request_packet.PutHex32(dst_len); 617 DataExtractor reply_packet; 618 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 619 lldb::offset_t offset = 8; 620 uint32_t kdp_error = reply_packet.GetU32(&offset); 621 uint32_t src_len = reply_packet.GetByteSize() - 12; 622 623 if (src_len > 0) { 624 const void *src = reply_packet.GetData(&offset, src_len); 625 if (src) { 626 ::memcpy(dst, src, src_len); 627 error.Clear(); 628 return src_len; 629 } 630 } 631 if (kdp_error) 632 error.SetErrorStringWithFormat("kdp read memory failed (error %u)", 633 kdp_error); 634 else 635 error.SetErrorString("kdp read memory failed"); 636 } else { 637 error.SetErrorString("failed to send packet"); 638 } 639 return 0; 640 } 641 642 uint32_t CommunicationKDP::SendRequestWriteMemory(lldb::addr_t addr, 643 const void *src, 644 uint32_t src_len, 645 Error &error) { 646 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 647 m_byte_order); 648 bool use_64 = (GetVersion() >= 11); 649 uint32_t command_addr_byte_size = use_64 ? 8 : 4; 650 const CommandType command = use_64 ? KDP_WRITEMEM64 : KDP_WRITEMEM; 651 // Size is header + address size + uint32_t length 652 const uint32_t command_length = 8 + command_addr_byte_size + 4 + src_len; 653 MakeRequestPacketHeader(command, request_packet, command_length); 654 request_packet.PutMaxHex64(addr, command_addr_byte_size); 655 request_packet.PutHex32(src_len); 656 request_packet.PutRawBytes(src, src_len); 657 658 DataExtractor reply_packet; 659 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 660 lldb::offset_t offset = 8; 661 uint32_t kdp_error = reply_packet.GetU32(&offset); 662 if (kdp_error) 663 error.SetErrorStringWithFormat("kdp write memory failed (error %u)", 664 kdp_error); 665 else { 666 error.Clear(); 667 return src_len; 668 } 669 } else { 670 error.SetErrorString("failed to send packet"); 671 } 672 return 0; 673 } 674 675 bool CommunicationKDP::SendRawRequest( 676 uint8_t command_byte, 677 const void *src, // Raw packet payload bytes 678 uint32_t src_len, // Raw packet payload length 679 DataExtractor &reply_packet, Error &error) { 680 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 681 m_byte_order); 682 // Size is header + address size + uint32_t length 683 const uint32_t command_length = 8 + src_len; 684 const CommandType command = (CommandType)command_byte; 685 MakeRequestPacketHeader(command, request_packet, command_length); 686 request_packet.PutRawBytes(src, src_len); 687 688 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 689 lldb::offset_t offset = 8; 690 uint32_t kdp_error = reply_packet.GetU32(&offset); 691 if (kdp_error && (command_byte != KDP_DUMPINFO)) 692 error.SetErrorStringWithFormat("request packet 0x%8.8x failed (error %u)", 693 command_byte, kdp_error); 694 else { 695 error.Clear(); 696 return true; 697 } 698 } else { 699 error.SetErrorString("failed to send packet"); 700 } 701 return false; 702 } 703 704 const char *CommunicationKDP::GetCommandAsCString(uint8_t command) { 705 switch (command) { 706 case KDP_CONNECT: 707 return "KDP_CONNECT"; 708 case KDP_DISCONNECT: 709 return "KDP_DISCONNECT"; 710 case KDP_HOSTINFO: 711 return "KDP_HOSTINFO"; 712 case KDP_VERSION: 713 return "KDP_VERSION"; 714 case KDP_MAXBYTES: 715 return "KDP_MAXBYTES"; 716 case KDP_READMEM: 717 return "KDP_READMEM"; 718 case KDP_WRITEMEM: 719 return "KDP_WRITEMEM"; 720 case KDP_READREGS: 721 return "KDP_READREGS"; 722 case KDP_WRITEREGS: 723 return "KDP_WRITEREGS"; 724 case KDP_LOAD: 725 return "KDP_LOAD"; 726 case KDP_IMAGEPATH: 727 return "KDP_IMAGEPATH"; 728 case KDP_SUSPEND: 729 return "KDP_SUSPEND"; 730 case KDP_RESUMECPUS: 731 return "KDP_RESUMECPUS"; 732 case KDP_EXCEPTION: 733 return "KDP_EXCEPTION"; 734 case KDP_TERMINATION: 735 return "KDP_TERMINATION"; 736 case KDP_BREAKPOINT_SET: 737 return "KDP_BREAKPOINT_SET"; 738 case KDP_BREAKPOINT_REMOVE: 739 return "KDP_BREAKPOINT_REMOVE"; 740 case KDP_REGIONS: 741 return "KDP_REGIONS"; 742 case KDP_REATTACH: 743 return "KDP_REATTACH"; 744 case KDP_HOSTREBOOT: 745 return "KDP_HOSTREBOOT"; 746 case KDP_READMEM64: 747 return "KDP_READMEM64"; 748 case KDP_WRITEMEM64: 749 return "KDP_WRITEMEM64"; 750 case KDP_BREAKPOINT_SET64: 751 return "KDP_BREAKPOINT64_SET"; 752 case KDP_BREAKPOINT_REMOVE64: 753 return "KDP_BREAKPOINT64_REMOVE"; 754 case KDP_KERNELVERSION: 755 return "KDP_KERNELVERSION"; 756 case KDP_READPHYSMEM64: 757 return "KDP_READPHYSMEM64"; 758 case KDP_WRITEPHYSMEM64: 759 return "KDP_WRITEPHYSMEM64"; 760 case KDP_READIOPORT: 761 return "KDP_READIOPORT"; 762 case KDP_WRITEIOPORT: 763 return "KDP_WRITEIOPORT"; 764 case KDP_READMSR64: 765 return "KDP_READMSR64"; 766 case KDP_WRITEMSR64: 767 return "KDP_WRITEMSR64"; 768 case KDP_DUMPINFO: 769 return "KDP_DUMPINFO"; 770 } 771 return NULL; 772 } 773 774 void CommunicationKDP::DumpPacket(Stream &s, const void *data, 775 uint32_t data_len) { 776 DataExtractor extractor(data, data_len, m_byte_order, m_addr_byte_size); 777 DumpPacket(s, extractor); 778 } 779 780 void CommunicationKDP::DumpPacket(Stream &s, const DataExtractor &packet) { 781 const char *error_desc = NULL; 782 if (packet.GetByteSize() < 8) { 783 error_desc = "error: invalid packet (too short): "; 784 } else { 785 lldb::offset_t offset = 0; 786 const uint8_t first_packet_byte = packet.GetU8(&offset); 787 const uint8_t sequence_id = packet.GetU8(&offset); 788 const uint16_t length = packet.GetU16(&offset); 789 const uint32_t key = packet.GetU32(&offset); 790 const CommandType command = ExtractCommand(first_packet_byte); 791 const char *command_name = GetCommandAsCString(command); 792 if (command_name) { 793 const bool is_reply = ExtractIsReply(first_packet_byte); 794 s.Printf("(running=%i) %s %24s: 0x%2.2x 0x%2.2x 0x%4.4x 0x%8.8x ", 795 IsRunning(), is_reply ? "<--" : "-->", command_name, 796 first_packet_byte, sequence_id, length, key); 797 798 if (is_reply) { 799 // Dump request reply packets 800 switch (command) { 801 // Commands that return a single 32 bit error 802 case KDP_CONNECT: 803 case KDP_WRITEMEM: 804 case KDP_WRITEMEM64: 805 case KDP_BREAKPOINT_SET: 806 case KDP_BREAKPOINT_REMOVE: 807 case KDP_BREAKPOINT_SET64: 808 case KDP_BREAKPOINT_REMOVE64: 809 case KDP_WRITEREGS: 810 case KDP_LOAD: 811 case KDP_WRITEIOPORT: 812 case KDP_WRITEMSR64: { 813 const uint32_t error = packet.GetU32(&offset); 814 s.Printf(" (error=0x%8.8x)", error); 815 } break; 816 817 case KDP_DISCONNECT: 818 case KDP_REATTACH: 819 case KDP_HOSTREBOOT: 820 case KDP_SUSPEND: 821 case KDP_RESUMECPUS: 822 case KDP_EXCEPTION: 823 case KDP_TERMINATION: 824 // No return value for the reply, just the header to ack 825 s.PutCString(" ()"); 826 break; 827 828 case KDP_HOSTINFO: { 829 const uint32_t cpu_mask = packet.GetU32(&offset); 830 const uint32_t cpu_type = packet.GetU32(&offset); 831 const uint32_t cpu_subtype = packet.GetU32(&offset); 832 s.Printf(" (cpu_mask=0x%8.8x, cpu_type=0x%8.8x, cpu_subtype=0x%8.8x)", 833 cpu_mask, cpu_type, cpu_subtype); 834 } break; 835 836 case KDP_VERSION: { 837 const uint32_t version = packet.GetU32(&offset); 838 const uint32_t feature = packet.GetU32(&offset); 839 s.Printf(" (version=0x%8.8x, feature=0x%8.8x)", version, feature); 840 } break; 841 842 case KDP_REGIONS: { 843 const uint32_t region_count = packet.GetU32(&offset); 844 s.Printf(" (count = %u", region_count); 845 for (uint32_t i = 0; i < region_count; ++i) { 846 const addr_t region_addr = packet.GetPointer(&offset); 847 const uint32_t region_size = packet.GetU32(&offset); 848 const uint32_t region_prot = packet.GetU32(&offset); 849 s.Printf("\n\tregion[%" PRIu64 "] = { range = [0x%16.16" PRIx64 850 " - 0x%16.16" PRIx64 "), size = 0x%8.8x, prot = %s }", 851 region_addr, region_addr, region_addr + region_size, 852 region_size, GetPermissionsAsCString(region_prot)); 853 } 854 } break; 855 856 case KDP_READMEM: 857 case KDP_READMEM64: 858 case KDP_READPHYSMEM64: { 859 const uint32_t error = packet.GetU32(&offset); 860 const uint32_t count = packet.GetByteSize() - offset; 861 s.Printf(" (error = 0x%8.8x:\n", error); 862 if (count > 0) 863 packet.Dump(&s, // Stream to dump to 864 offset, // Offset within "packet" 865 eFormatBytesWithASCII, // Format to use 866 1, // Size of each item in bytes 867 count, // Number of items 868 16, // Number per line 869 m_last_read_memory_addr, // Don't show addresses before 870 // each line 871 0, 0); // No bitfields 872 } break; 873 874 case KDP_READREGS: { 875 const uint32_t error = packet.GetU32(&offset); 876 const uint32_t count = packet.GetByteSize() - offset; 877 s.Printf(" (error = 0x%8.8x regs:\n", error); 878 if (count > 0) 879 packet.Dump( 880 &s, // Stream to dump to 881 offset, // Offset within "packet" 882 eFormatHex, // Format to use 883 m_addr_byte_size, // Size of each item in bytes 884 count / m_addr_byte_size, // Number of items 885 16 / m_addr_byte_size, // Number per line 886 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 887 0, 0); // No bitfields 888 } break; 889 890 case KDP_KERNELVERSION: { 891 const char *kernel_version = packet.PeekCStr(8); 892 s.Printf(" (version = \"%s\")", kernel_version); 893 } break; 894 895 case KDP_MAXBYTES: { 896 const uint32_t max_bytes = packet.GetU32(&offset); 897 s.Printf(" (max_bytes = 0x%8.8x (%u))", max_bytes, max_bytes); 898 } break; 899 case KDP_IMAGEPATH: { 900 const char *path = packet.GetCStr(&offset); 901 s.Printf(" (path = \"%s\")", path); 902 } break; 903 904 case KDP_READIOPORT: 905 case KDP_READMSR64: { 906 const uint32_t error = packet.GetU32(&offset); 907 const uint32_t count = packet.GetByteSize() - offset; 908 s.Printf(" (error = 0x%8.8x io:\n", error); 909 if (count > 0) 910 packet.Dump( 911 &s, // Stream to dump to 912 offset, // Offset within "packet" 913 eFormatHex, // Format to use 914 1, // Size of each item in bytes 915 count, // Number of items 916 16, // Number per line 917 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 918 0, 0); // No bitfields 919 } break; 920 case KDP_DUMPINFO: { 921 const uint32_t count = packet.GetByteSize() - offset; 922 s.Printf(" (count = %u, bytes = \n", count); 923 if (count > 0) 924 packet.Dump( 925 &s, // Stream to dump to 926 offset, // Offset within "packet" 927 eFormatHex, // Format to use 928 1, // Size of each item in bytes 929 count, // Number of items 930 16, // Number per line 931 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 932 0, 0); // No bitfields 933 934 } break; 935 936 default: 937 s.Printf(" (add support for dumping this packet reply!!!"); 938 break; 939 } 940 } else { 941 // Dump request packets 942 switch (command) { 943 case KDP_CONNECT: { 944 const uint16_t reply_port = ntohs(packet.GetU16(&offset)); 945 const uint16_t exc_port = ntohs(packet.GetU16(&offset)); 946 s.Printf(" (reply_port = %u, exc_port = %u, greeting = \"%s\")", 947 reply_port, exc_port, packet.GetCStr(&offset)); 948 } break; 949 950 case KDP_DISCONNECT: 951 case KDP_HOSTREBOOT: 952 case KDP_HOSTINFO: 953 case KDP_VERSION: 954 case KDP_REGIONS: 955 case KDP_KERNELVERSION: 956 case KDP_MAXBYTES: 957 case KDP_IMAGEPATH: 958 case KDP_SUSPEND: 959 // No args, just the header in the request... 960 s.PutCString(" ()"); 961 break; 962 963 case KDP_RESUMECPUS: { 964 const uint32_t cpu_mask = packet.GetU32(&offset); 965 s.Printf(" (cpu_mask = 0x%8.8x)", cpu_mask); 966 } break; 967 968 case KDP_READMEM: { 969 const uint32_t addr = packet.GetU32(&offset); 970 const uint32_t size = packet.GetU32(&offset); 971 s.Printf(" (addr = 0x%8.8x, size = %u)", addr, size); 972 m_last_read_memory_addr = addr; 973 } break; 974 975 case KDP_WRITEMEM: { 976 const uint32_t addr = packet.GetU32(&offset); 977 const uint32_t size = packet.GetU32(&offset); 978 s.Printf(" (addr = 0x%8.8x, size = %u, bytes = \n", addr, size); 979 if (size > 0) 980 DataExtractor::DumpHexBytes(&s, packet.GetData(&offset, size), size, 981 32, addr); 982 } break; 983 984 case KDP_READMEM64: { 985 const uint64_t addr = packet.GetU64(&offset); 986 const uint32_t size = packet.GetU32(&offset); 987 s.Printf(" (addr = 0x%16.16" PRIx64 ", size = %u)", addr, size); 988 m_last_read_memory_addr = addr; 989 } break; 990 991 case KDP_READPHYSMEM64: { 992 const uint64_t addr = packet.GetU64(&offset); 993 const uint32_t size = packet.GetU32(&offset); 994 const uint32_t lcpu = packet.GetU16(&offset); 995 s.Printf(" (addr = 0x%16.16llx, size = %u, lcpu = %u)", addr, size, 996 lcpu); 997 m_last_read_memory_addr = addr; 998 } break; 999 1000 case KDP_WRITEMEM64: { 1001 const uint64_t addr = packet.GetU64(&offset); 1002 const uint32_t size = packet.GetU32(&offset); 1003 s.Printf(" (addr = 0x%16.16" PRIx64 ", size = %u, bytes = \n", addr, 1004 size); 1005 if (size > 0) 1006 DataExtractor::DumpHexBytes(&s, packet.GetData(&offset, size), size, 1007 32, addr); 1008 } break; 1009 1010 case KDP_WRITEPHYSMEM64: { 1011 const uint64_t addr = packet.GetU64(&offset); 1012 const uint32_t size = packet.GetU32(&offset); 1013 const uint32_t lcpu = packet.GetU16(&offset); 1014 s.Printf(" (addr = 0x%16.16llx, size = %u, lcpu = %u, bytes = \n", 1015 addr, size, lcpu); 1016 if (size > 0) 1017 DataExtractor::DumpHexBytes(&s, packet.GetData(&offset, size), size, 1018 32, addr); 1019 } break; 1020 1021 case KDP_READREGS: { 1022 const uint32_t cpu = packet.GetU32(&offset); 1023 const uint32_t flavor = packet.GetU32(&offset); 1024 s.Printf(" (cpu = %u, flavor = %u)", cpu, flavor); 1025 } break; 1026 1027 case KDP_WRITEREGS: { 1028 const uint32_t cpu = packet.GetU32(&offset); 1029 const uint32_t flavor = packet.GetU32(&offset); 1030 const uint32_t nbytes = packet.GetByteSize() - offset; 1031 s.Printf(" (cpu = %u, flavor = %u, regs = \n", cpu, flavor); 1032 if (nbytes > 0) 1033 packet.Dump( 1034 &s, // Stream to dump to 1035 offset, // Offset within "packet" 1036 eFormatHex, // Format to use 1037 m_addr_byte_size, // Size of each item in bytes 1038 nbytes / m_addr_byte_size, // Number of items 1039 16 / m_addr_byte_size, // Number per line 1040 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 1041 0, 0); // No bitfields 1042 } break; 1043 1044 case KDP_BREAKPOINT_SET: 1045 case KDP_BREAKPOINT_REMOVE: { 1046 const uint32_t addr = packet.GetU32(&offset); 1047 s.Printf(" (addr = 0x%8.8x)", addr); 1048 } break; 1049 1050 case KDP_BREAKPOINT_SET64: 1051 case KDP_BREAKPOINT_REMOVE64: { 1052 const uint64_t addr = packet.GetU64(&offset); 1053 s.Printf(" (addr = 0x%16.16" PRIx64 ")", addr); 1054 } break; 1055 1056 case KDP_LOAD: { 1057 const char *path = packet.GetCStr(&offset); 1058 s.Printf(" (path = \"%s\")", path); 1059 } break; 1060 1061 case KDP_EXCEPTION: { 1062 const uint32_t count = packet.GetU32(&offset); 1063 1064 for (uint32_t i = 0; i < count; ++i) { 1065 const uint32_t cpu = packet.GetU32(&offset); 1066 const uint32_t exc = packet.GetU32(&offset); 1067 const uint32_t code = packet.GetU32(&offset); 1068 const uint32_t subcode = packet.GetU32(&offset); 1069 const char *exc_cstr = NULL; 1070 switch (exc) { 1071 case 1: 1072 exc_cstr = "EXC_BAD_ACCESS"; 1073 break; 1074 case 2: 1075 exc_cstr = "EXC_BAD_INSTRUCTION"; 1076 break; 1077 case 3: 1078 exc_cstr = "EXC_ARITHMETIC"; 1079 break; 1080 case 4: 1081 exc_cstr = "EXC_EMULATION"; 1082 break; 1083 case 5: 1084 exc_cstr = "EXC_SOFTWARE"; 1085 break; 1086 case 6: 1087 exc_cstr = "EXC_BREAKPOINT"; 1088 break; 1089 case 7: 1090 exc_cstr = "EXC_SYSCALL"; 1091 break; 1092 case 8: 1093 exc_cstr = "EXC_MACH_SYSCALL"; 1094 break; 1095 case 9: 1096 exc_cstr = "EXC_RPC_ALERT"; 1097 break; 1098 case 10: 1099 exc_cstr = "EXC_CRASH"; 1100 break; 1101 default: 1102 break; 1103 } 1104 1105 s.Printf("{ cpu = 0x%8.8x, exc = %s (%u), code = %u (0x%8.8x), " 1106 "subcode = %u (0x%8.8x)} ", 1107 cpu, exc_cstr, exc, code, code, subcode, subcode); 1108 } 1109 } break; 1110 1111 case KDP_TERMINATION: { 1112 const uint32_t term_code = packet.GetU32(&offset); 1113 const uint32_t exit_code = packet.GetU32(&offset); 1114 s.Printf(" (term_code = 0x%8.8x (%u), exit_code = 0x%8.8x (%u))", 1115 term_code, term_code, exit_code, exit_code); 1116 } break; 1117 1118 case KDP_REATTACH: { 1119 const uint16_t reply_port = ntohs(packet.GetU16(&offset)); 1120 s.Printf(" (reply_port = %u)", reply_port); 1121 } break; 1122 1123 case KDP_READMSR64: { 1124 const uint32_t address = packet.GetU32(&offset); 1125 const uint16_t lcpu = packet.GetU16(&offset); 1126 s.Printf(" (address=0x%8.8x, lcpu=0x%4.4x)", address, lcpu); 1127 } break; 1128 1129 case KDP_WRITEMSR64: { 1130 const uint32_t address = packet.GetU32(&offset); 1131 const uint16_t lcpu = packet.GetU16(&offset); 1132 const uint32_t nbytes = packet.GetByteSize() - offset; 1133 s.Printf(" (address=0x%8.8x, lcpu=0x%4.4x, nbytes=0x%8.8x)", lcpu, 1134 address, nbytes); 1135 if (nbytes > 0) 1136 packet.Dump( 1137 &s, // Stream to dump to 1138 offset, // Offset within "packet" 1139 eFormatHex, // Format to use 1140 1, // Size of each item in bytes 1141 nbytes, // Number of items 1142 16, // Number per line 1143 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 1144 0, 0); // No bitfields 1145 } break; 1146 1147 case KDP_READIOPORT: { 1148 const uint16_t lcpu = packet.GetU16(&offset); 1149 const uint16_t address = packet.GetU16(&offset); 1150 const uint16_t nbytes = packet.GetU16(&offset); 1151 s.Printf(" (lcpu=0x%4.4x, address=0x%4.4x, nbytes=%u)", lcpu, address, 1152 nbytes); 1153 } break; 1154 1155 case KDP_WRITEIOPORT: { 1156 const uint16_t lcpu = packet.GetU16(&offset); 1157 const uint16_t address = packet.GetU16(&offset); 1158 const uint16_t nbytes = packet.GetU16(&offset); 1159 s.Printf(" (lcpu = %u, addr = 0x%4.4x, nbytes = %u, bytes = \n", lcpu, 1160 address, nbytes); 1161 if (nbytes > 0) 1162 packet.Dump( 1163 &s, // Stream to dump to 1164 offset, // Offset within "packet" 1165 eFormatHex, // Format to use 1166 1, // Size of each item in bytes 1167 nbytes, // Number of items 1168 16, // Number per line 1169 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 1170 0, 0); // No bitfields 1171 } break; 1172 1173 case KDP_DUMPINFO: { 1174 const uint32_t count = packet.GetByteSize() - offset; 1175 s.Printf(" (count = %u, bytes = \n", count); 1176 if (count > 0) 1177 packet.Dump( 1178 &s, // Stream to dump to 1179 offset, // Offset within "packet" 1180 eFormatHex, // Format to use 1181 1, // Size of each item in bytes 1182 count, // Number of items 1183 16, // Number per line 1184 LLDB_INVALID_ADDRESS, // Don't show addresses before each line 1185 0, 0); // No bitfields 1186 1187 } break; 1188 } 1189 } 1190 } else { 1191 error_desc = "error: invalid packet command: "; 1192 } 1193 } 1194 1195 if (error_desc) { 1196 s.PutCString(error_desc); 1197 1198 packet.Dump(&s, // Stream to dump to 1199 0, // Offset into "packet" 1200 eFormatBytes, // Dump as hex bytes 1201 1, // Size of each item is 1 for single bytes 1202 packet.GetByteSize(), // Number of bytes 1203 UINT32_MAX, // Num bytes per line 1204 LLDB_INVALID_ADDRESS, // Base address 1205 0, 0); // Bitfield info set to not do anything bitfield related 1206 } 1207 } 1208 1209 uint32_t CommunicationKDP::SendRequestReadRegisters(uint32_t cpu, 1210 uint32_t flavor, void *dst, 1211 uint32_t dst_len, 1212 Error &error) { 1213 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 1214 m_byte_order); 1215 const CommandType command = KDP_READREGS; 1216 // Size is header + 4 byte cpu and 4 byte flavor 1217 const uint32_t command_length = 8 + 4 + 4; 1218 MakeRequestPacketHeader(command, request_packet, command_length); 1219 request_packet.PutHex32(cpu); 1220 request_packet.PutHex32(flavor); 1221 DataExtractor reply_packet; 1222 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 1223 lldb::offset_t offset = 8; 1224 uint32_t kdp_error = reply_packet.GetU32(&offset); 1225 uint32_t src_len = reply_packet.GetByteSize() - 12; 1226 1227 if (src_len > 0) { 1228 const uint32_t bytes_to_copy = std::min<uint32_t>(src_len, dst_len); 1229 const void *src = reply_packet.GetData(&offset, bytes_to_copy); 1230 if (src) { 1231 ::memcpy(dst, src, bytes_to_copy); 1232 error.Clear(); 1233 // Return the number of bytes we could have returned regardless if 1234 // we copied them or not, just so we know when things don't match up 1235 return src_len; 1236 } 1237 } 1238 if (kdp_error) 1239 error.SetErrorStringWithFormat( 1240 "failed to read kdp registers for cpu %u flavor %u (error %u)", cpu, 1241 flavor, kdp_error); 1242 else 1243 error.SetErrorStringWithFormat( 1244 "failed to read kdp registers for cpu %u flavor %u", cpu, flavor); 1245 } else { 1246 error.SetErrorString("failed to send packet"); 1247 } 1248 return 0; 1249 } 1250 1251 uint32_t CommunicationKDP::SendRequestWriteRegisters(uint32_t cpu, 1252 uint32_t flavor, 1253 const void *src, 1254 uint32_t src_len, 1255 Error &error) { 1256 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 1257 m_byte_order); 1258 const CommandType command = KDP_WRITEREGS; 1259 // Size is header + 4 byte cpu and 4 byte flavor 1260 const uint32_t command_length = 8 + 4 + 4 + src_len; 1261 MakeRequestPacketHeader(command, request_packet, command_length); 1262 request_packet.PutHex32(cpu); 1263 request_packet.PutHex32(flavor); 1264 request_packet.Write(src, src_len); 1265 DataExtractor reply_packet; 1266 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 1267 lldb::offset_t offset = 8; 1268 uint32_t kdp_error = reply_packet.GetU32(&offset); 1269 if (kdp_error == 0) 1270 return src_len; 1271 error.SetErrorStringWithFormat( 1272 "failed to read kdp registers for cpu %u flavor %u (error %u)", cpu, 1273 flavor, kdp_error); 1274 } else { 1275 error.SetErrorString("failed to send packet"); 1276 } 1277 return 0; 1278 } 1279 1280 bool CommunicationKDP::SendRequestResume() { 1281 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 1282 m_byte_order); 1283 const CommandType command = KDP_RESUMECPUS; 1284 const uint32_t command_length = 12; 1285 MakeRequestPacketHeader(command, request_packet, command_length); 1286 request_packet.PutHex32(GetCPUMask()); 1287 1288 DataExtractor reply_packet; 1289 if (SendRequestAndGetReply(command, request_packet, reply_packet)) 1290 return true; 1291 return false; 1292 } 1293 1294 bool CommunicationKDP::SendRequestBreakpoint(bool set, addr_t addr) { 1295 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 1296 m_byte_order); 1297 bool use_64 = (GetVersion() >= 11); 1298 uint32_t command_addr_byte_size = use_64 ? 8 : 4; 1299 const CommandType command = 1300 set ? (use_64 ? KDP_BREAKPOINT_SET64 : KDP_BREAKPOINT_SET) 1301 : (use_64 ? KDP_BREAKPOINT_REMOVE64 : KDP_BREAKPOINT_REMOVE); 1302 1303 const uint32_t command_length = 8 + command_addr_byte_size; 1304 MakeRequestPacketHeader(command, request_packet, command_length); 1305 request_packet.PutMaxHex64(addr, command_addr_byte_size); 1306 1307 DataExtractor reply_packet; 1308 if (SendRequestAndGetReply(command, request_packet, reply_packet)) { 1309 lldb::offset_t offset = 8; 1310 uint32_t kdp_error = reply_packet.GetU32(&offset); 1311 if (kdp_error == 0) 1312 return true; 1313 } 1314 return false; 1315 } 1316 1317 bool CommunicationKDP::SendRequestSuspend() { 1318 PacketStreamType request_packet(Stream::eBinary, m_addr_byte_size, 1319 m_byte_order); 1320 const CommandType command = KDP_SUSPEND; 1321 const uint32_t command_length = 8; 1322 MakeRequestPacketHeader(command, request_packet, command_length); 1323 DataExtractor reply_packet; 1324 if (SendRequestAndGetReply(command, request_packet, reply_packet)) 1325 return true; 1326 return false; 1327 } 1328