1 //===-- GDBRemoteCommunicationServerLLGS.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 <errno.h> 11 12 #include "lldb/Host/Config.h" 13 14 #include "GDBRemoteCommunicationServerLLGS.h" 15 #include "lldb/Utility/StreamGDBRemote.h" 16 17 // C Includes 18 // C++ Includes 19 #include <chrono> 20 #include <cstring> 21 #include <thread> 22 23 // Other libraries and framework includes 24 #include "lldb/Core/RegisterValue.h" 25 #include "lldb/Core/State.h" 26 #include "lldb/Host/ConnectionFileDescriptor.h" 27 #include "lldb/Host/Debug.h" 28 #include "lldb/Host/File.h" 29 #include "lldb/Host/FileSystem.h" 30 #include "lldb/Host/Host.h" 31 #include "lldb/Host/HostInfo.h" 32 #include "lldb/Host/common/NativeProcessProtocol.h" 33 #include "lldb/Host/common/NativeRegisterContext.h" 34 #include "lldb/Host/common/NativeThreadProtocol.h" 35 #include "lldb/Interpreter/Args.h" 36 #include "lldb/Target/FileAction.h" 37 #include "lldb/Target/MemoryRegionInfo.h" 38 #include "lldb/Utility/DataBuffer.h" 39 #include "lldb/Utility/Endian.h" 40 #include "lldb/Utility/JSON.h" 41 #include "lldb/Utility/LLDBAssert.h" 42 #include "lldb/Utility/Log.h" 43 #include "lldb/Utility/StreamString.h" 44 #include "lldb/Utility/UriParser.h" 45 #include "llvm/ADT/Triple.h" 46 #include "llvm/Support/ScopedPrinter.h" 47 48 // Project includes 49 #include "ProcessGDBRemote.h" 50 #include "ProcessGDBRemoteLog.h" 51 #include "Utility/StringExtractorGDBRemote.h" 52 53 using namespace lldb; 54 using namespace lldb_private; 55 using namespace lldb_private::process_gdb_remote; 56 using namespace llvm; 57 58 //---------------------------------------------------------------------- 59 // GDBRemote Errors 60 //---------------------------------------------------------------------- 61 62 namespace { 63 enum GDBRemoteServerError { 64 // Set to the first unused error number in literal form below 65 eErrorFirst = 29, 66 eErrorNoProcess = eErrorFirst, 67 eErrorResume, 68 eErrorExitStatus 69 }; 70 } 71 72 //---------------------------------------------------------------------- 73 // GDBRemoteCommunicationServerLLGS constructor 74 //---------------------------------------------------------------------- 75 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS( 76 MainLoop &mainloop, const NativeProcessProtocol::Factory &process_factory) 77 : GDBRemoteCommunicationServerCommon("gdb-remote.server", 78 "gdb-remote.server.rx_packet"), 79 m_mainloop(mainloop), m_process_factory(process_factory), 80 m_stdio_communication("process.stdio") { 81 RegisterPacketHandlers(); 82 } 83 84 void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() { 85 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C, 86 &GDBRemoteCommunicationServerLLGS::Handle_C); 87 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c, 88 &GDBRemoteCommunicationServerLLGS::Handle_c); 89 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D, 90 &GDBRemoteCommunicationServerLLGS::Handle_D); 91 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H, 92 &GDBRemoteCommunicationServerLLGS::Handle_H); 93 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I, 94 &GDBRemoteCommunicationServerLLGS::Handle_I); 95 RegisterMemberFunctionHandler( 96 StringExtractorGDBRemote::eServerPacketType_interrupt, 97 &GDBRemoteCommunicationServerLLGS::Handle_interrupt); 98 RegisterMemberFunctionHandler( 99 StringExtractorGDBRemote::eServerPacketType_m, 100 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 101 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M, 102 &GDBRemoteCommunicationServerLLGS::Handle_M); 103 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p, 104 &GDBRemoteCommunicationServerLLGS::Handle_p); 105 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P, 106 &GDBRemoteCommunicationServerLLGS::Handle_P); 107 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC, 108 &GDBRemoteCommunicationServerLLGS::Handle_qC); 109 RegisterMemberFunctionHandler( 110 StringExtractorGDBRemote::eServerPacketType_qfThreadInfo, 111 &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo); 112 RegisterMemberFunctionHandler( 113 StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress, 114 &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress); 115 RegisterMemberFunctionHandler( 116 StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir, 117 &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir); 118 RegisterMemberFunctionHandler( 119 StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo, 120 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo); 121 RegisterMemberFunctionHandler( 122 StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported, 123 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported); 124 RegisterMemberFunctionHandler( 125 StringExtractorGDBRemote::eServerPacketType_qProcessInfo, 126 &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo); 127 RegisterMemberFunctionHandler( 128 StringExtractorGDBRemote::eServerPacketType_qRegisterInfo, 129 &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo); 130 RegisterMemberFunctionHandler( 131 StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState, 132 &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState); 133 RegisterMemberFunctionHandler( 134 StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState, 135 &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState); 136 RegisterMemberFunctionHandler( 137 StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR, 138 &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR); 139 RegisterMemberFunctionHandler( 140 StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir, 141 &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir); 142 RegisterMemberFunctionHandler( 143 StringExtractorGDBRemote::eServerPacketType_qsThreadInfo, 144 &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo); 145 RegisterMemberFunctionHandler( 146 StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo, 147 &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo); 148 RegisterMemberFunctionHandler( 149 StringExtractorGDBRemote::eServerPacketType_jThreadsInfo, 150 &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo); 151 RegisterMemberFunctionHandler( 152 StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo, 153 &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo); 154 RegisterMemberFunctionHandler( 155 StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read, 156 &GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read); 157 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s, 158 &GDBRemoteCommunicationServerLLGS::Handle_s); 159 RegisterMemberFunctionHandler( 160 StringExtractorGDBRemote::eServerPacketType_stop_reason, 161 &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ? 162 RegisterMemberFunctionHandler( 163 StringExtractorGDBRemote::eServerPacketType_vAttach, 164 &GDBRemoteCommunicationServerLLGS::Handle_vAttach); 165 RegisterMemberFunctionHandler( 166 StringExtractorGDBRemote::eServerPacketType_vCont, 167 &GDBRemoteCommunicationServerLLGS::Handle_vCont); 168 RegisterMemberFunctionHandler( 169 StringExtractorGDBRemote::eServerPacketType_vCont_actions, 170 &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions); 171 RegisterMemberFunctionHandler( 172 StringExtractorGDBRemote::eServerPacketType_x, 173 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 174 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z, 175 &GDBRemoteCommunicationServerLLGS::Handle_Z); 176 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z, 177 &GDBRemoteCommunicationServerLLGS::Handle_z); 178 RegisterMemberFunctionHandler( 179 StringExtractorGDBRemote::eServerPacketType_QPassSignals, 180 &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals); 181 182 RegisterMemberFunctionHandler( 183 StringExtractorGDBRemote::eServerPacketType_jTraceStart, 184 &GDBRemoteCommunicationServerLLGS::Handle_jTraceStart); 185 RegisterMemberFunctionHandler( 186 StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead, 187 &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead); 188 RegisterMemberFunctionHandler( 189 StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead, 190 &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead); 191 RegisterMemberFunctionHandler( 192 StringExtractorGDBRemote::eServerPacketType_jTraceStop, 193 &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop); 194 RegisterMemberFunctionHandler( 195 StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead, 196 &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead); 197 198 RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k, 199 [this](StringExtractorGDBRemote packet, Status &error, 200 bool &interrupt, bool &quit) { 201 quit = true; 202 return this->Handle_k(packet); 203 }); 204 } 205 206 Status 207 GDBRemoteCommunicationServerLLGS::SetLaunchArguments(const char *const args[], 208 int argc) { 209 if ((argc < 1) || !args || !args[0] || !args[0][0]) 210 return Status("%s: no process command line specified to launch", 211 __FUNCTION__); 212 213 m_process_launch_info.SetArguments(const_cast<const char **>(args), true); 214 return Status(); 215 } 216 217 Status 218 GDBRemoteCommunicationServerLLGS::SetLaunchFlags(unsigned int launch_flags) { 219 m_process_launch_info.GetFlags().Set(launch_flags); 220 return Status(); 221 } 222 223 Status GDBRemoteCommunicationServerLLGS::LaunchProcess() { 224 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 225 226 if (!m_process_launch_info.GetArguments().GetArgumentCount()) 227 return Status("%s: no process command line specified to launch", 228 __FUNCTION__); 229 230 const bool should_forward_stdio = 231 m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr || 232 m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr || 233 m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr; 234 m_process_launch_info.SetLaunchInSeparateProcessGroup(true); 235 m_process_launch_info.GetFlags().Set(eLaunchFlagDebug); 236 237 const bool default_to_use_pty = true; 238 m_process_launch_info.FinalizeFileActions(nullptr, default_to_use_pty); 239 240 { 241 std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex); 242 assert(!m_debugged_process_sp && "lldb-server creating debugged " 243 "process but one already exists"); 244 auto process_or = 245 m_process_factory.Launch(m_process_launch_info, *this, m_mainloop); 246 if (!process_or) { 247 Status status(process_or.takeError()); 248 llvm::errs() << llvm::formatv( 249 "failed to launch executable `{0}`: {1}", 250 m_process_launch_info.GetArguments().GetArgumentAtIndex(0), status); 251 return status; 252 } 253 m_debugged_process_sp = *process_or; 254 } 255 256 // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol 257 // as needed. 258 // llgs local-process debugging may specify PTY paths, which will make these 259 // file actions non-null 260 // process launch -i/e/o will also make these file actions non-null 261 // nullptr means that the traffic is expected to flow over gdb-remote protocol 262 if (should_forward_stdio) { 263 // nullptr means it's not redirected to file or pty (in case of LLGS local) 264 // at least one of stdio will be transferred pty<->gdb-remote 265 // we need to give the pty master handle to this object to read and/or write 266 if (log) 267 log->Printf( 268 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 269 " setting up stdout/stderr redirection via $O gdb-remote commands", 270 __FUNCTION__, m_debugged_process_sp->GetID()); 271 272 // Setup stdout/stderr mapping from inferior to $O 273 auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor(); 274 if (terminal_fd >= 0) { 275 if (log) 276 log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting " 277 "inferior STDIO fd to %d", 278 __FUNCTION__, terminal_fd); 279 Status status = SetSTDIOFileDescriptor(terminal_fd); 280 if (status.Fail()) 281 return status; 282 } else { 283 if (log) 284 log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring " 285 "inferior STDIO since terminal fd reported as %d", 286 __FUNCTION__, terminal_fd); 287 } 288 } else { 289 if (log) 290 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 291 " skipping stdout/stderr redirection via $O: inferior will " 292 "communicate over client-provided file descriptors", 293 __FUNCTION__, m_debugged_process_sp->GetID()); 294 } 295 296 printf("Launched '%s' as process %" PRIu64 "...\n", 297 m_process_launch_info.GetArguments().GetArgumentAtIndex(0), 298 m_debugged_process_sp->GetID()); 299 300 return Status(); 301 } 302 303 Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) { 304 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 305 if (log) 306 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, 307 __FUNCTION__, pid); 308 309 // Before we try to attach, make sure we aren't already monitoring something 310 // else. 311 if (m_debugged_process_sp && 312 m_debugged_process_sp->GetID() != LLDB_INVALID_PROCESS_ID) 313 return Status("cannot attach to a process %" PRIu64 314 " when another process with pid %" PRIu64 315 " is being debugged.", 316 pid, m_debugged_process_sp->GetID()); 317 318 // Try to attach. 319 auto process_or = m_process_factory.Attach(pid, *this, m_mainloop); 320 if (!process_or) { 321 Status status(process_or.takeError()); 322 llvm::errs() << llvm::formatv("failed to attach to process {0}: {1}", pid, 323 status); 324 return status; 325 } 326 m_debugged_process_sp = *process_or; 327 328 // Setup stdout/stderr mapping from inferior. 329 auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor(); 330 if (terminal_fd >= 0) { 331 if (log) 332 log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting " 333 "inferior STDIO fd to %d", 334 __FUNCTION__, terminal_fd); 335 Status status = SetSTDIOFileDescriptor(terminal_fd); 336 if (status.Fail()) 337 return status; 338 } else { 339 if (log) 340 log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring " 341 "inferior STDIO since terminal fd reported as %d", 342 __FUNCTION__, terminal_fd); 343 } 344 345 printf("Attached to process %" PRIu64 "...\n", pid); 346 return Status(); 347 } 348 349 void GDBRemoteCommunicationServerLLGS::InitializeDelegate( 350 NativeProcessProtocol *process) { 351 assert(process && "process cannot be NULL"); 352 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 353 if (log) { 354 log->Printf("GDBRemoteCommunicationServerLLGS::%s called with " 355 "NativeProcessProtocol pid %" PRIu64 ", current state: %s", 356 __FUNCTION__, process->GetID(), 357 StateAsCString(process->GetState())); 358 } 359 } 360 361 GDBRemoteCommunication::PacketResult 362 GDBRemoteCommunicationServerLLGS::SendWResponse( 363 NativeProcessProtocol *process) { 364 assert(process && "process cannot be NULL"); 365 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 366 367 // send W notification 368 auto wait_status = process->GetExitStatus(); 369 if (!wait_status) { 370 LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status", 371 process->GetID()); 372 373 StreamGDBRemote response; 374 response.PutChar('E'); 375 response.PutHex8(GDBRemoteServerError::eErrorExitStatus); 376 return SendPacketNoLock(response.GetString()); 377 } 378 379 LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(), 380 *wait_status); 381 382 StreamGDBRemote response; 383 response.Format("{0:g}", *wait_status); 384 return SendPacketNoLock(response.GetString()); 385 } 386 387 static void AppendHexValue(StreamString &response, const uint8_t *buf, 388 uint32_t buf_size, bool swap) { 389 int64_t i; 390 if (swap) { 391 for (i = buf_size - 1; i >= 0; i--) 392 response.PutHex8(buf[i]); 393 } else { 394 for (i = 0; i < buf_size; i++) 395 response.PutHex8(buf[i]); 396 } 397 } 398 399 static void WriteRegisterValueInHexFixedWidth( 400 StreamString &response, NativeRegisterContextSP ®_ctx_sp, 401 const RegisterInfo ®_info, const RegisterValue *reg_value_p, 402 lldb::ByteOrder byte_order) { 403 RegisterValue reg_value; 404 if (!reg_value_p) { 405 Status error = reg_ctx_sp->ReadRegister(®_info, reg_value); 406 if (error.Success()) 407 reg_value_p = ®_value; 408 // else log. 409 } 410 411 if (reg_value_p) { 412 AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(), 413 reg_value_p->GetByteSize(), 414 byte_order == lldb::eByteOrderLittle); 415 } else { 416 // Zero-out any unreadable values. 417 if (reg_info.byte_size > 0) { 418 std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0'); 419 AppendHexValue(response, zeros.data(), zeros.size(), false); 420 } 421 } 422 } 423 424 static JSONObject::SP GetRegistersAsJSON(NativeThreadProtocol &thread) { 425 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 426 427 NativeRegisterContextSP reg_ctx_sp = thread.GetRegisterContext(); 428 if (!reg_ctx_sp) 429 return nullptr; 430 431 JSONObject::SP register_object_sp = std::make_shared<JSONObject>(); 432 433 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET 434 // Expedite all registers in the first register set (i.e. should be GPRs) that 435 // are not contained in other registers. 436 const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0); 437 if (!reg_set_p) 438 return nullptr; 439 for (const uint32_t *reg_num_p = reg_set_p->registers; 440 *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) { 441 uint32_t reg_num = *reg_num_p; 442 #else 443 // Expedite only a couple of registers until we figure out why sending 444 // registers is 445 // expensive. 446 static const uint32_t k_expedited_registers[] = { 447 LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP, 448 LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM}; 449 450 for (const uint32_t *generic_reg_p = k_expedited_registers; 451 *generic_reg_p != LLDB_INVALID_REGNUM; ++generic_reg_p) { 452 uint32_t reg_num = reg_ctx_sp->ConvertRegisterKindToRegisterNumber( 453 eRegisterKindGeneric, *generic_reg_p); 454 if (reg_num == LLDB_INVALID_REGNUM) 455 continue; // Target does not support the given register. 456 #endif 457 458 const RegisterInfo *const reg_info_p = 459 reg_ctx_sp->GetRegisterInfoAtIndex(reg_num); 460 if (reg_info_p == nullptr) { 461 if (log) 462 log->Printf( 463 "%s failed to get register info for register index %" PRIu32, 464 __FUNCTION__, reg_num); 465 continue; 466 } 467 468 if (reg_info_p->value_regs != nullptr) 469 continue; // Only expedite registers that are not contained in other 470 // registers. 471 472 RegisterValue reg_value; 473 Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value); 474 if (error.Fail()) { 475 if (log) 476 log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s", 477 __FUNCTION__, 478 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 479 reg_num, error.AsCString()); 480 continue; 481 } 482 483 StreamString stream; 484 WriteRegisterValueInHexFixedWidth(stream, reg_ctx_sp, *reg_info_p, 485 ®_value, lldb::eByteOrderBig); 486 487 register_object_sp->SetObject( 488 llvm::to_string(reg_num), 489 std::make_shared<JSONString>(stream.GetString())); 490 } 491 492 return register_object_sp; 493 } 494 495 static const char *GetStopReasonString(StopReason stop_reason) { 496 switch (stop_reason) { 497 case eStopReasonTrace: 498 return "trace"; 499 case eStopReasonBreakpoint: 500 return "breakpoint"; 501 case eStopReasonWatchpoint: 502 return "watchpoint"; 503 case eStopReasonSignal: 504 return "signal"; 505 case eStopReasonException: 506 return "exception"; 507 case eStopReasonExec: 508 return "exec"; 509 case eStopReasonInstrumentation: 510 case eStopReasonInvalid: 511 case eStopReasonPlanComplete: 512 case eStopReasonThreadExiting: 513 case eStopReasonNone: 514 break; // ignored 515 } 516 return nullptr; 517 } 518 519 static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process, 520 bool abridged) { 521 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 522 523 JSONArray::SP threads_array_sp = std::make_shared<JSONArray>(); 524 525 // Ensure we can get info on the given thread. 526 uint32_t thread_idx = 0; 527 for (NativeThreadProtocolSP thread_sp; 528 (thread_sp = process.GetThreadAtIndex(thread_idx)) != nullptr; 529 ++thread_idx) { 530 531 lldb::tid_t tid = thread_sp->GetID(); 532 533 // Grab the reason this thread stopped. 534 struct ThreadStopInfo tid_stop_info; 535 std::string description; 536 if (!thread_sp->GetStopReason(tid_stop_info, description)) 537 return nullptr; 538 539 const int signum = tid_stop_info.details.signal.signo; 540 if (log) { 541 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 542 " tid %" PRIu64 543 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 544 __FUNCTION__, process.GetID(), tid, signum, 545 tid_stop_info.reason, tid_stop_info.details.exception.type); 546 } 547 548 JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>(); 549 threads_array_sp->AppendObject(thread_obj_sp); 550 551 if (!abridged) { 552 if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp)) 553 thread_obj_sp->SetObject("registers", registers_sp); 554 } 555 556 thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid)); 557 if (signum != 0) 558 thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum)); 559 560 const std::string thread_name = thread_sp->GetName(); 561 if (!thread_name.empty()) 562 thread_obj_sp->SetObject("name", 563 std::make_shared<JSONString>(thread_name)); 564 565 if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason)) 566 thread_obj_sp->SetObject("reason", 567 std::make_shared<JSONString>(stop_reason_str)); 568 569 if (!description.empty()) 570 thread_obj_sp->SetObject("description", 571 std::make_shared<JSONString>(description)); 572 573 if ((tid_stop_info.reason == eStopReasonException) && 574 tid_stop_info.details.exception.type) { 575 thread_obj_sp->SetObject( 576 "metype", 577 std::make_shared<JSONNumber>(tid_stop_info.details.exception.type)); 578 579 JSONArray::SP medata_array_sp = std::make_shared<JSONArray>(); 580 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; 581 ++i) { 582 medata_array_sp->AppendObject(std::make_shared<JSONNumber>( 583 tid_stop_info.details.exception.data[i])); 584 } 585 thread_obj_sp->SetObject("medata", medata_array_sp); 586 } 587 588 // TODO: Expedite interesting regions of inferior memory 589 } 590 591 return threads_array_sp; 592 } 593 594 GDBRemoteCommunication::PacketResult 595 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 596 lldb::tid_t tid) { 597 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 598 599 // Ensure we have a debugged process. 600 if (!m_debugged_process_sp || 601 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 602 return SendErrorResponse(50); 603 604 if (log) 605 log->Printf( 606 "GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64 607 " tid %" PRIu64, 608 __FUNCTION__, m_debugged_process_sp->GetID(), tid); 609 610 // Ensure we can get info on the given thread. 611 NativeThreadProtocolSP thread_sp(m_debugged_process_sp->GetThreadByID(tid)); 612 if (!thread_sp) 613 return SendErrorResponse(51); 614 615 // Grab the reason this thread stopped. 616 struct ThreadStopInfo tid_stop_info; 617 std::string description; 618 if (!thread_sp->GetStopReason(tid_stop_info, description)) 619 return SendErrorResponse(52); 620 621 // FIXME implement register handling for exec'd inferiors. 622 // if (tid_stop_info.reason == eStopReasonExec) 623 // { 624 // const bool force = true; 625 // InitializeRegisters(force); 626 // } 627 628 StreamString response; 629 // Output the T packet with the thread 630 response.PutChar('T'); 631 int signum = tid_stop_info.details.signal.signo; 632 if (log) { 633 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 634 " tid %" PRIu64 635 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 636 __FUNCTION__, m_debugged_process_sp->GetID(), tid, signum, 637 tid_stop_info.reason, tid_stop_info.details.exception.type); 638 } 639 640 // Print the signal number. 641 response.PutHex8(signum & 0xff); 642 643 // Include the tid. 644 response.Printf("thread:%" PRIx64 ";", tid); 645 646 // Include the thread name if there is one. 647 const std::string thread_name = thread_sp->GetName(); 648 if (!thread_name.empty()) { 649 size_t thread_name_len = thread_name.length(); 650 651 if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) { 652 response.PutCString("name:"); 653 response.PutCString(thread_name); 654 } else { 655 // The thread name contains special chars, send as hex bytes. 656 response.PutCString("hexname:"); 657 response.PutCStringAsRawHex8(thread_name.c_str()); 658 } 659 response.PutChar(';'); 660 } 661 662 // If a 'QListThreadsInStopReply' was sent to enable this feature, we 663 // will send all thread IDs back in the "threads" key whose value is 664 // a list of hex thread IDs separated by commas: 665 // "threads:10a,10b,10c;" 666 // This will save the debugger from having to send a pair of qfThreadInfo 667 // and qsThreadInfo packets, but it also might take a lot of room in the 668 // stop reply packet, so it must be enabled only on systems where there 669 // are no limits on packet lengths. 670 if (m_list_threads_in_stop_reply) { 671 response.PutCString("threads:"); 672 673 uint32_t thread_index = 0; 674 NativeThreadProtocolSP listed_thread_sp; 675 for (listed_thread_sp = 676 m_debugged_process_sp->GetThreadAtIndex(thread_index); 677 listed_thread_sp; ++thread_index, 678 listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex( 679 thread_index)) { 680 if (thread_index > 0) 681 response.PutChar(','); 682 response.Printf("%" PRIx64, listed_thread_sp->GetID()); 683 } 684 response.PutChar(';'); 685 686 // Include JSON info that describes the stop reason for any threads 687 // that actually have stop reasons. We use the new "jstopinfo" key 688 // whose values is hex ascii JSON that contains the thread IDs 689 // thread stop info only for threads that have stop reasons. Only send 690 // this if we have more than one thread otherwise this packet has all 691 // the info it needs. 692 if (thread_index > 0) { 693 const bool threads_with_valid_stop_info_only = true; 694 JSONArray::SP threads_info_sp = GetJSONThreadsInfo( 695 *m_debugged_process_sp, threads_with_valid_stop_info_only); 696 if (threads_info_sp) { 697 response.PutCString("jstopinfo:"); 698 StreamString unescaped_response; 699 threads_info_sp->Write(unescaped_response); 700 response.PutCStringAsRawHex8(unescaped_response.GetData()); 701 response.PutChar(';'); 702 } else if (log) 703 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to prepare a " 704 "jstopinfo field for pid %" PRIu64, 705 __FUNCTION__, m_debugged_process_sp->GetID()); 706 } 707 708 uint32_t i = 0; 709 response.PutCString("thread-pcs"); 710 char delimiter = ':'; 711 for (NativeThreadProtocolSP thread_sp; 712 (thread_sp = m_debugged_process_sp->GetThreadAtIndex(i)) != nullptr; 713 ++i) { 714 NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext(); 715 if (!reg_ctx_sp) 716 continue; 717 718 uint32_t reg_to_read = reg_ctx_sp->ConvertRegisterKindToRegisterNumber( 719 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 720 const RegisterInfo *const reg_info_p = 721 reg_ctx_sp->GetRegisterInfoAtIndex(reg_to_read); 722 723 RegisterValue reg_value; 724 Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value); 725 if (error.Fail()) { 726 if (log) 727 log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s", 728 __FUNCTION__, 729 reg_info_p->name ? reg_info_p->name 730 : "<unnamed-register>", 731 reg_to_read, error.AsCString()); 732 continue; 733 } 734 735 response.PutChar(delimiter); 736 delimiter = ','; 737 WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p, 738 ®_value, endian::InlHostByteOrder()); 739 } 740 741 response.PutChar(';'); 742 } 743 744 // 745 // Expedite registers. 746 // 747 748 // Grab the register context. 749 NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext(); 750 if (reg_ctx_sp) { 751 // Expedite all registers in the first register set (i.e. should be GPRs) 752 // that are not contained in other registers. 753 const RegisterSet *reg_set_p; 754 if (reg_ctx_sp->GetRegisterSetCount() > 0 && 755 ((reg_set_p = reg_ctx_sp->GetRegisterSet(0)) != nullptr)) { 756 if (log) 757 log->Printf("GDBRemoteCommunicationServerLLGS::%s expediting registers " 758 "from set '%s' (registers set count: %zu)", 759 __FUNCTION__, 760 reg_set_p->name ? reg_set_p->name : "<unnamed-set>", 761 reg_set_p->num_registers); 762 763 for (const uint32_t *reg_num_p = reg_set_p->registers; 764 *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) { 765 const RegisterInfo *const reg_info_p = 766 reg_ctx_sp->GetRegisterInfoAtIndex(*reg_num_p); 767 if (reg_info_p == nullptr) { 768 if (log) 769 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get " 770 "register info for register set '%s', register index " 771 "%" PRIu32, 772 __FUNCTION__, 773 reg_set_p->name ? reg_set_p->name : "<unnamed-set>", 774 *reg_num_p); 775 } else if (reg_info_p->value_regs == nullptr) { 776 // Only expediate registers that are not contained in other registers. 777 RegisterValue reg_value; 778 Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value); 779 if (error.Success()) { 780 response.Printf("%.02x:", *reg_num_p); 781 WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p, 782 ®_value, lldb::eByteOrderBig); 783 response.PutChar(';'); 784 } else { 785 if (log) 786 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to read " 787 "register '%s' index %" PRIu32 ": %s", 788 __FUNCTION__, reg_info_p->name ? reg_info_p->name 789 : "<unnamed-register>", 790 *reg_num_p, error.AsCString()); 791 } 792 } 793 } 794 } 795 } 796 797 const char *reason_str = GetStopReasonString(tid_stop_info.reason); 798 if (reason_str != nullptr) { 799 response.Printf("reason:%s;", reason_str); 800 } 801 802 if (!description.empty()) { 803 // Description may contains special chars, send as hex bytes. 804 response.PutCString("description:"); 805 response.PutCStringAsRawHex8(description.c_str()); 806 response.PutChar(';'); 807 } else if ((tid_stop_info.reason == eStopReasonException) && 808 tid_stop_info.details.exception.type) { 809 response.PutCString("metype:"); 810 response.PutHex64(tid_stop_info.details.exception.type); 811 response.PutCString(";mecount:"); 812 response.PutHex32(tid_stop_info.details.exception.data_count); 813 response.PutChar(';'); 814 815 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) { 816 response.PutCString("medata:"); 817 response.PutHex64(tid_stop_info.details.exception.data[i]); 818 response.PutChar(';'); 819 } 820 } 821 822 return SendPacketNoLock(response.GetString()); 823 } 824 825 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited( 826 NativeProcessProtocol *process) { 827 assert(process && "process cannot be NULL"); 828 829 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 830 if (log) 831 log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 832 833 PacketResult result = SendStopReasonForState(StateType::eStateExited); 834 if (result != PacketResult::Success) { 835 if (log) 836 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop " 837 "notification for PID %" PRIu64 ", state: eStateExited", 838 __FUNCTION__, process->GetID()); 839 } 840 841 // Close the pipe to the inferior terminal i/o if we launched it 842 // and set one up. 843 MaybeCloseInferiorTerminalConnection(); 844 845 // We are ready to exit the debug monitor. 846 m_exit_now = true; 847 } 848 849 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped( 850 NativeProcessProtocol *process) { 851 assert(process && "process cannot be NULL"); 852 853 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 854 if (log) 855 log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 856 857 // Send the stop reason unless this is the stop after the 858 // launch or attach. 859 switch (m_inferior_prev_state) { 860 case eStateLaunching: 861 case eStateAttaching: 862 // Don't send anything per debugserver behavior. 863 break; 864 default: 865 // In all other cases, send the stop reason. 866 PacketResult result = SendStopReasonForState(StateType::eStateStopped); 867 if (result != PacketResult::Success) { 868 if (log) 869 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop " 870 "notification for PID %" PRIu64 ", state: eStateExited", 871 __FUNCTION__, process->GetID()); 872 } 873 break; 874 } 875 } 876 877 void GDBRemoteCommunicationServerLLGS::ProcessStateChanged( 878 NativeProcessProtocol *process, lldb::StateType state) { 879 assert(process && "process cannot be NULL"); 880 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 881 if (log) { 882 log->Printf("GDBRemoteCommunicationServerLLGS::%s called with " 883 "NativeProcessProtocol pid %" PRIu64 ", state: %s", 884 __FUNCTION__, process->GetID(), StateAsCString(state)); 885 } 886 887 switch (state) { 888 case StateType::eStateRunning: 889 StartSTDIOForwarding(); 890 break; 891 892 case StateType::eStateStopped: 893 // Make sure we get all of the pending stdout/stderr from the inferior 894 // and send it to the lldb host before we send the state change 895 // notification 896 SendProcessOutput(); 897 // Then stop the forwarding, so that any late output (see llvm.org/pr25652) 898 // does not 899 // interfere with our protocol. 900 StopSTDIOForwarding(); 901 HandleInferiorState_Stopped(process); 902 break; 903 904 case StateType::eStateExited: 905 // Same as above 906 SendProcessOutput(); 907 StopSTDIOForwarding(); 908 HandleInferiorState_Exited(process); 909 break; 910 911 default: 912 if (log) { 913 log->Printf("GDBRemoteCommunicationServerLLGS::%s didn't handle state " 914 "change for pid %" PRIu64 ", new state: %s", 915 __FUNCTION__, process->GetID(), StateAsCString(state)); 916 } 917 break; 918 } 919 920 // Remember the previous state reported to us. 921 m_inferior_prev_state = state; 922 } 923 924 void GDBRemoteCommunicationServerLLGS::DidExec(NativeProcessProtocol *process) { 925 ClearProcessSpecificData(); 926 } 927 928 void GDBRemoteCommunicationServerLLGS::DataAvailableCallback() { 929 Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_COMM)); 930 931 if (!m_handshake_completed) { 932 if (!HandshakeWithClient()) { 933 if (log) 934 log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with " 935 "client failed, exiting", 936 __FUNCTION__); 937 m_mainloop.RequestTermination(); 938 return; 939 } 940 m_handshake_completed = true; 941 } 942 943 bool interrupt = false; 944 bool done = false; 945 Status error; 946 while (true) { 947 const PacketResult result = GetPacketAndSendResponse( 948 std::chrono::microseconds(0), error, interrupt, done); 949 if (result == PacketResult::ErrorReplyTimeout) 950 break; // No more packets in the queue 951 952 if ((result != PacketResult::Success)) { 953 if (log) 954 log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet " 955 "failed: %s", 956 __FUNCTION__, error.AsCString()); 957 m_mainloop.RequestTermination(); 958 break; 959 } 960 } 961 } 962 963 Status GDBRemoteCommunicationServerLLGS::InitializeConnection( 964 std::unique_ptr<Connection> &&connection) { 965 IOObjectSP read_object_sp = connection->GetReadObject(); 966 GDBRemoteCommunicationServer::SetConnection(connection.release()); 967 968 Status error; 969 m_network_handle_up = m_mainloop.RegisterReadObject( 970 read_object_sp, [this](MainLoopBase &) { DataAvailableCallback(); }, 971 error); 972 return error; 973 } 974 975 GDBRemoteCommunication::PacketResult 976 GDBRemoteCommunicationServerLLGS::SendONotification(const char *buffer, 977 uint32_t len) { 978 if ((buffer == nullptr) || (len == 0)) { 979 // Nothing to send. 980 return PacketResult::Success; 981 } 982 983 StreamString response; 984 response.PutChar('O'); 985 response.PutBytesAsRawHex8(buffer, len); 986 987 return SendPacketNoLock(response.GetString()); 988 } 989 990 Status GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) { 991 Status error; 992 993 // Set up the reading/handling of process I/O 994 std::unique_ptr<ConnectionFileDescriptor> conn_up( 995 new ConnectionFileDescriptor(fd, true)); 996 if (!conn_up) { 997 error.SetErrorString("failed to create ConnectionFileDescriptor"); 998 return error; 999 } 1000 1001 m_stdio_communication.SetCloseOnEOF(false); 1002 m_stdio_communication.SetConnection(conn_up.release()); 1003 if (!m_stdio_communication.IsConnected()) { 1004 error.SetErrorString( 1005 "failed to set connection for inferior I/O communication"); 1006 return error; 1007 } 1008 1009 return Status(); 1010 } 1011 1012 void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() { 1013 // Don't forward if not connected (e.g. when attaching). 1014 if (!m_stdio_communication.IsConnected()) 1015 return; 1016 1017 Status error; 1018 lldbassert(!m_stdio_handle_up); 1019 m_stdio_handle_up = m_mainloop.RegisterReadObject( 1020 m_stdio_communication.GetConnection()->GetReadObject(), 1021 [this](MainLoopBase &) { SendProcessOutput(); }, error); 1022 1023 if (!m_stdio_handle_up) { 1024 // Not much we can do about the failure. Log it and continue without 1025 // forwarding. 1026 if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)) 1027 log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio " 1028 "forwarding: %s", 1029 __FUNCTION__, error.AsCString()); 1030 } 1031 } 1032 1033 void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() { 1034 m_stdio_handle_up.reset(); 1035 } 1036 1037 void GDBRemoteCommunicationServerLLGS::SendProcessOutput() { 1038 char buffer[1024]; 1039 ConnectionStatus status; 1040 Status error; 1041 while (true) { 1042 size_t bytes_read = m_stdio_communication.Read( 1043 buffer, sizeof buffer, std::chrono::microseconds(0), status, &error); 1044 switch (status) { 1045 case eConnectionStatusSuccess: 1046 SendONotification(buffer, bytes_read); 1047 break; 1048 case eConnectionStatusLostConnection: 1049 case eConnectionStatusEndOfFile: 1050 case eConnectionStatusError: 1051 case eConnectionStatusNoConnection: 1052 if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)) 1053 log->Printf("GDBRemoteCommunicationServerLLGS::%s Stopping stdio " 1054 "forwarding as communication returned status %d (error: " 1055 "%s)", 1056 __FUNCTION__, status, error.AsCString()); 1057 m_stdio_handle_up.reset(); 1058 return; 1059 1060 case eConnectionStatusInterrupted: 1061 case eConnectionStatusTimedOut: 1062 return; 1063 } 1064 } 1065 } 1066 1067 GDBRemoteCommunication::PacketResult 1068 GDBRemoteCommunicationServerLLGS::Handle_jTraceStart( 1069 StringExtractorGDBRemote &packet) { 1070 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1071 // Fail if we don't have a current process. 1072 if (!m_debugged_process_sp || 1073 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1074 return SendErrorResponse(68); 1075 1076 if (!packet.ConsumeFront("jTraceStart:")) 1077 return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet "); 1078 1079 TraceOptions options; 1080 uint64_t type = std::numeric_limits<uint64_t>::max(); 1081 uint64_t buffersize = std::numeric_limits<uint64_t>::max(); 1082 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1083 uint64_t metabuffersize = std::numeric_limits<uint64_t>::max(); 1084 1085 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1086 1087 if (!json_object || 1088 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1089 return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet "); 1090 1091 auto json_dict = json_object->GetAsDictionary(); 1092 1093 json_dict->GetValueForKeyAsInteger("metabuffersize", metabuffersize); 1094 options.setMetaDataBufferSize(metabuffersize); 1095 1096 json_dict->GetValueForKeyAsInteger("buffersize", buffersize); 1097 options.setTraceBufferSize(buffersize); 1098 1099 json_dict->GetValueForKeyAsInteger("type", type); 1100 options.setType(static_cast<lldb::TraceType>(type)); 1101 1102 json_dict->GetValueForKeyAsInteger("threadid", tid); 1103 options.setThreadID(tid); 1104 1105 StructuredData::ObjectSP custom_params_sp = 1106 json_dict->GetValueForKey("params"); 1107 if (custom_params_sp && 1108 custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary) 1109 return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet "); 1110 1111 options.setTraceParams( 1112 static_pointer_cast<StructuredData::Dictionary>(custom_params_sp)); 1113 1114 if (buffersize == std::numeric_limits<uint64_t>::max() || 1115 type != lldb::TraceType::eTraceTypeProcessorTrace) { 1116 LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize, 1117 type); 1118 return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet "); 1119 } 1120 1121 Status error; 1122 lldb::user_id_t uid = LLDB_INVALID_UID; 1123 uid = m_debugged_process_sp->StartTrace(options, error); 1124 LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError()); 1125 if (error.Fail()) 1126 return SendErrorResponse(error.GetError()); 1127 1128 StreamGDBRemote response; 1129 response.Printf("%" PRIx64, uid); 1130 return SendPacketNoLock(response.GetString()); 1131 } 1132 1133 GDBRemoteCommunication::PacketResult 1134 GDBRemoteCommunicationServerLLGS::Handle_jTraceStop( 1135 StringExtractorGDBRemote &packet) { 1136 // Fail if we don't have a current process. 1137 if (!m_debugged_process_sp || 1138 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1139 return SendErrorResponse(68); 1140 1141 if (!packet.ConsumeFront("jTraceStop:")) 1142 return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet "); 1143 1144 lldb::user_id_t uid = LLDB_INVALID_UID; 1145 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1146 1147 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1148 1149 if (!json_object || 1150 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1151 return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet "); 1152 1153 auto json_dict = json_object->GetAsDictionary(); 1154 1155 if (!json_dict->GetValueForKeyAsInteger("traceid", uid)) 1156 return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet "); 1157 1158 json_dict->GetValueForKeyAsInteger("threadid", tid); 1159 1160 Status error = m_debugged_process_sp->StopTrace(uid, tid); 1161 1162 if (error.Fail()) 1163 return SendErrorResponse(error.GetError()); 1164 1165 return SendOKResponse(); 1166 } 1167 1168 GDBRemoteCommunication::PacketResult 1169 GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead( 1170 StringExtractorGDBRemote &packet) { 1171 1172 // Fail if we don't have a current process. 1173 if (!m_debugged_process_sp || 1174 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1175 return SendErrorResponse(68); 1176 1177 if (!packet.ConsumeFront("jTraceConfigRead:")) 1178 return SendIllFormedResponse(packet, 1179 "jTraceConfigRead: Ill formed packet "); 1180 1181 lldb::user_id_t uid = LLDB_INVALID_UID; 1182 lldb::tid_t threadid = LLDB_INVALID_THREAD_ID; 1183 1184 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1185 1186 if (!json_object || 1187 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1188 return SendIllFormedResponse(packet, 1189 "jTraceConfigRead: Ill formed packet "); 1190 1191 auto json_dict = json_object->GetAsDictionary(); 1192 1193 if (!json_dict->GetValueForKeyAsInteger("traceid", uid)) 1194 return SendIllFormedResponse(packet, 1195 "jTraceConfigRead: Ill formed packet "); 1196 1197 json_dict->GetValueForKeyAsInteger("threadid", threadid); 1198 1199 TraceOptions options; 1200 StreamGDBRemote response; 1201 1202 options.setThreadID(threadid); 1203 Status error = m_debugged_process_sp->GetTraceConfig(uid, options); 1204 1205 if (error.Fail()) 1206 return SendErrorResponse(error.GetError()); 1207 1208 StreamGDBRemote escaped_response; 1209 StructuredData::Dictionary json_packet; 1210 1211 json_packet.AddIntegerItem("type", options.getType()); 1212 json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize()); 1213 json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize()); 1214 1215 StructuredData::DictionarySP custom_params = options.getTraceParams(); 1216 if (custom_params) 1217 json_packet.AddItem("params", custom_params); 1218 1219 StreamString json_string; 1220 json_packet.Dump(json_string, false); 1221 escaped_response.PutEscapedBytes(json_string.GetData(), 1222 json_string.GetSize()); 1223 return SendPacketNoLock(escaped_response.GetString()); 1224 } 1225 1226 GDBRemoteCommunication::PacketResult 1227 GDBRemoteCommunicationServerLLGS::Handle_jTraceRead( 1228 StringExtractorGDBRemote &packet) { 1229 1230 // Fail if we don't have a current process. 1231 if (!m_debugged_process_sp || 1232 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1233 return SendErrorResponse(68); 1234 1235 enum PacketType { MetaData, BufferData }; 1236 PacketType tracetype = MetaData; 1237 1238 if (packet.ConsumeFront("jTraceBufferRead:")) 1239 tracetype = BufferData; 1240 else if (packet.ConsumeFront("jTraceMetaRead:")) 1241 tracetype = MetaData; 1242 else { 1243 return SendIllFormedResponse(packet, "jTrace: Ill formed packet "); 1244 } 1245 1246 lldb::user_id_t uid = LLDB_INVALID_UID; 1247 1248 uint64_t byte_count = std::numeric_limits<uint64_t>::max(); 1249 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1250 uint64_t offset = std::numeric_limits<uint64_t>::max(); 1251 1252 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1253 1254 if (!json_object || 1255 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1256 return SendIllFormedResponse(packet, "jTrace: Ill formed packet "); 1257 1258 auto json_dict = json_object->GetAsDictionary(); 1259 1260 if (!json_dict->GetValueForKeyAsInteger("traceid", uid) || 1261 !json_dict->GetValueForKeyAsInteger("offset", offset) || 1262 !json_dict->GetValueForKeyAsInteger("buffersize", byte_count)) 1263 return SendIllFormedResponse(packet, "jTrace: Ill formed packet "); 1264 1265 json_dict->GetValueForKeyAsInteger("threadid", tid); 1266 1267 // Allocate the response buffer. 1268 std::unique_ptr<uint8_t[]> buffer (new (std::nothrow) uint8_t[byte_count]); 1269 if (!buffer) 1270 return SendErrorResponse(0x78); 1271 1272 StreamGDBRemote response; 1273 Status error; 1274 llvm::MutableArrayRef<uint8_t> buf(buffer.get(), byte_count); 1275 1276 if (tracetype == BufferData) 1277 error = m_debugged_process_sp->GetData(uid, tid, buf, offset); 1278 else if (tracetype == MetaData) 1279 error = m_debugged_process_sp->GetMetaData(uid, tid, buf, offset); 1280 1281 if (error.Fail()) 1282 return SendErrorResponse(error.GetError()); 1283 1284 for (auto i : buf) 1285 response.PutHex8(i); 1286 1287 StreamGDBRemote escaped_response; 1288 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 1289 return SendPacketNoLock(escaped_response.GetString()); 1290 } 1291 1292 GDBRemoteCommunication::PacketResult 1293 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo( 1294 StringExtractorGDBRemote &packet) { 1295 // Fail if we don't have a current process. 1296 if (!m_debugged_process_sp || 1297 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1298 return SendErrorResponse(68); 1299 1300 lldb::pid_t pid = m_debugged_process_sp->GetID(); 1301 1302 if (pid == LLDB_INVALID_PROCESS_ID) 1303 return SendErrorResponse(1); 1304 1305 ProcessInstanceInfo proc_info; 1306 if (!Host::GetProcessInfo(pid, proc_info)) 1307 return SendErrorResponse(1); 1308 1309 StreamString response; 1310 CreateProcessInfoResponse_DebugServerStyle(proc_info, response); 1311 return SendPacketNoLock(response.GetString()); 1312 } 1313 1314 GDBRemoteCommunication::PacketResult 1315 GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) { 1316 // Fail if we don't have a current process. 1317 if (!m_debugged_process_sp || 1318 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1319 return SendErrorResponse(68); 1320 1321 // Make sure we set the current thread so g and p packets return 1322 // the data the gdb will expect. 1323 lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID(); 1324 SetCurrentThreadID(tid); 1325 1326 NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetCurrentThread(); 1327 if (!thread_sp) 1328 return SendErrorResponse(69); 1329 1330 StreamString response; 1331 response.Printf("QC%" PRIx64, thread_sp->GetID()); 1332 1333 return SendPacketNoLock(response.GetString()); 1334 } 1335 1336 GDBRemoteCommunication::PacketResult 1337 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) { 1338 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1339 1340 StopSTDIOForwarding(); 1341 1342 if (!m_debugged_process_sp) { 1343 if (log) 1344 log->Printf( 1345 "GDBRemoteCommunicationServerLLGS::%s No debugged process found.", 1346 __FUNCTION__); 1347 return PacketResult::Success; 1348 } 1349 1350 Status error = m_debugged_process_sp->Kill(); 1351 if (error.Fail() && log) 1352 log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to kill debugged " 1353 "process %" PRIu64 ": %s", 1354 __FUNCTION__, m_debugged_process_sp->GetID(), 1355 error.AsCString()); 1356 1357 // No OK response for kill packet. 1358 // return SendOKResponse (); 1359 return PacketResult::Success; 1360 } 1361 1362 GDBRemoteCommunication::PacketResult 1363 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR( 1364 StringExtractorGDBRemote &packet) { 1365 packet.SetFilePos(::strlen("QSetDisableASLR:")); 1366 if (packet.GetU32(0)) 1367 m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR); 1368 else 1369 m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR); 1370 return SendOKResponse(); 1371 } 1372 1373 GDBRemoteCommunication::PacketResult 1374 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir( 1375 StringExtractorGDBRemote &packet) { 1376 packet.SetFilePos(::strlen("QSetWorkingDir:")); 1377 std::string path; 1378 packet.GetHexByteString(path); 1379 m_process_launch_info.SetWorkingDirectory(FileSpec{path, true}); 1380 return SendOKResponse(); 1381 } 1382 1383 GDBRemoteCommunication::PacketResult 1384 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir( 1385 StringExtractorGDBRemote &packet) { 1386 FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()}; 1387 if (working_dir) { 1388 StreamString response; 1389 response.PutCStringAsRawHex8(working_dir.GetCString()); 1390 return SendPacketNoLock(response.GetString()); 1391 } 1392 1393 return SendErrorResponse(14); 1394 } 1395 1396 GDBRemoteCommunication::PacketResult 1397 GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) { 1398 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 1399 if (log) 1400 log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1401 1402 // Ensure we have a native process. 1403 if (!m_debugged_process_sp) { 1404 if (log) 1405 log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process " 1406 "shared pointer", 1407 __FUNCTION__); 1408 return SendErrorResponse(0x36); 1409 } 1410 1411 // Pull out the signal number. 1412 packet.SetFilePos(::strlen("C")); 1413 if (packet.GetBytesLeft() < 1) { 1414 // Shouldn't be using a C without a signal. 1415 return SendIllFormedResponse(packet, "C packet specified without signal."); 1416 } 1417 const uint32_t signo = 1418 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1419 if (signo == std::numeric_limits<uint32_t>::max()) 1420 return SendIllFormedResponse(packet, "failed to parse signal number"); 1421 1422 // Handle optional continue address. 1423 if (packet.GetBytesLeft() > 0) { 1424 // FIXME add continue at address support for $C{signo}[;{continue-address}]. 1425 if (*packet.Peek() == ';') 1426 return SendUnimplementedResponse(packet.GetStringRef().c_str()); 1427 else 1428 return SendIllFormedResponse( 1429 packet, "unexpected content after $C{signal-number}"); 1430 } 1431 1432 ResumeActionList resume_actions(StateType::eStateRunning, 0); 1433 Status error; 1434 1435 // We have two branches: what to do if a continue thread is specified (in 1436 // which case we target 1437 // sending the signal to that thread), or when we don't have a continue thread 1438 // set (in which 1439 // case we send a signal to the process). 1440 1441 // TODO discuss with Greg Clayton, make sure this makes sense. 1442 1443 lldb::tid_t signal_tid = GetContinueThreadID(); 1444 if (signal_tid != LLDB_INVALID_THREAD_ID) { 1445 // The resume action for the continue thread (or all threads if a continue 1446 // thread is not set). 1447 ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning, 1448 static_cast<int>(signo)}; 1449 1450 // Add the action for the continue thread (or all threads when the continue 1451 // thread isn't present). 1452 resume_actions.Append(action); 1453 } else { 1454 // Send the signal to the process since we weren't targeting a specific 1455 // continue thread with the signal. 1456 error = m_debugged_process_sp->Signal(signo); 1457 if (error.Fail()) { 1458 if (log) 1459 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send " 1460 "signal for process %" PRIu64 ": %s", 1461 __FUNCTION__, m_debugged_process_sp->GetID(), 1462 error.AsCString()); 1463 1464 return SendErrorResponse(0x52); 1465 } 1466 } 1467 1468 // Resume the threads. 1469 error = m_debugged_process_sp->Resume(resume_actions); 1470 if (error.Fail()) { 1471 if (log) 1472 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to resume " 1473 "threads for process %" PRIu64 ": %s", 1474 __FUNCTION__, m_debugged_process_sp->GetID(), 1475 error.AsCString()); 1476 1477 return SendErrorResponse(0x38); 1478 } 1479 1480 // Don't send an "OK" packet; response is the stopped/exited message. 1481 return PacketResult::Success; 1482 } 1483 1484 GDBRemoteCommunication::PacketResult 1485 GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) { 1486 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 1487 if (log) 1488 log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1489 1490 packet.SetFilePos(packet.GetFilePos() + ::strlen("c")); 1491 1492 // For now just support all continue. 1493 const bool has_continue_address = (packet.GetBytesLeft() > 0); 1494 if (has_continue_address) { 1495 if (log) 1496 log->Printf("GDBRemoteCommunicationServerLLGS::%s not implemented for " 1497 "c{address} variant [%s remains]", 1498 __FUNCTION__, packet.Peek()); 1499 return SendUnimplementedResponse(packet.GetStringRef().c_str()); 1500 } 1501 1502 // Ensure we have a native process. 1503 if (!m_debugged_process_sp) { 1504 if (log) 1505 log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process " 1506 "shared pointer", 1507 __FUNCTION__); 1508 return SendErrorResponse(0x36); 1509 } 1510 1511 // Build the ResumeActionList 1512 ResumeActionList actions(StateType::eStateRunning, 0); 1513 1514 Status error = m_debugged_process_sp->Resume(actions); 1515 if (error.Fail()) { 1516 if (log) { 1517 log->Printf( 1518 "GDBRemoteCommunicationServerLLGS::%s c failed for process %" PRIu64 1519 ": %s", 1520 __FUNCTION__, m_debugged_process_sp->GetID(), error.AsCString()); 1521 } 1522 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1523 } 1524 1525 if (log) 1526 log->Printf( 1527 "GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64, 1528 __FUNCTION__, m_debugged_process_sp->GetID()); 1529 1530 // No response required from continue. 1531 return PacketResult::Success; 1532 } 1533 1534 GDBRemoteCommunication::PacketResult 1535 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions( 1536 StringExtractorGDBRemote &packet) { 1537 StreamString response; 1538 response.Printf("vCont;c;C;s;S"); 1539 1540 return SendPacketNoLock(response.GetString()); 1541 } 1542 1543 GDBRemoteCommunication::PacketResult 1544 GDBRemoteCommunicationServerLLGS::Handle_vCont( 1545 StringExtractorGDBRemote &packet) { 1546 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1547 if (log) 1548 log->Printf("GDBRemoteCommunicationServerLLGS::%s handling vCont packet", 1549 __FUNCTION__); 1550 1551 packet.SetFilePos(::strlen("vCont")); 1552 1553 if (packet.GetBytesLeft() == 0) { 1554 if (log) 1555 log->Printf("GDBRemoteCommunicationServerLLGS::%s missing action from " 1556 "vCont package", 1557 __FUNCTION__); 1558 return SendIllFormedResponse(packet, "Missing action from vCont package"); 1559 } 1560 1561 // Check if this is all continue (no options or ";c"). 1562 if (::strcmp(packet.Peek(), ";c") == 0) { 1563 // Move past the ';', then do a simple 'c'. 1564 packet.SetFilePos(packet.GetFilePos() + 1); 1565 return Handle_c(packet); 1566 } else if (::strcmp(packet.Peek(), ";s") == 0) { 1567 // Move past the ';', then do a simple 's'. 1568 packet.SetFilePos(packet.GetFilePos() + 1); 1569 return Handle_s(packet); 1570 } 1571 1572 // Ensure we have a native process. 1573 if (!m_debugged_process_sp) { 1574 if (log) 1575 log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process " 1576 "shared pointer", 1577 __FUNCTION__); 1578 return SendErrorResponse(0x36); 1579 } 1580 1581 ResumeActionList thread_actions; 1582 1583 while (packet.GetBytesLeft() && *packet.Peek() == ';') { 1584 // Skip the semi-colon. 1585 packet.GetChar(); 1586 1587 // Build up the thread action. 1588 ResumeAction thread_action; 1589 thread_action.tid = LLDB_INVALID_THREAD_ID; 1590 thread_action.state = eStateInvalid; 1591 thread_action.signal = 0; 1592 1593 const char action = packet.GetChar(); 1594 switch (action) { 1595 case 'C': 1596 thread_action.signal = packet.GetHexMaxU32(false, 0); 1597 if (thread_action.signal == 0) 1598 return SendIllFormedResponse( 1599 packet, "Could not parse signal in vCont packet C action"); 1600 LLVM_FALLTHROUGH; 1601 1602 case 'c': 1603 // Continue 1604 thread_action.state = eStateRunning; 1605 break; 1606 1607 case 'S': 1608 thread_action.signal = packet.GetHexMaxU32(false, 0); 1609 if (thread_action.signal == 0) 1610 return SendIllFormedResponse( 1611 packet, "Could not parse signal in vCont packet S action"); 1612 LLVM_FALLTHROUGH; 1613 1614 case 's': 1615 // Step 1616 thread_action.state = eStateStepping; 1617 break; 1618 1619 default: 1620 return SendIllFormedResponse(packet, "Unsupported vCont action"); 1621 break; 1622 } 1623 1624 // Parse out optional :{thread-id} value. 1625 if (packet.GetBytesLeft() && (*packet.Peek() == ':')) { 1626 // Consume the separator. 1627 packet.GetChar(); 1628 1629 thread_action.tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID); 1630 if (thread_action.tid == LLDB_INVALID_THREAD_ID) 1631 return SendIllFormedResponse( 1632 packet, "Could not parse thread number in vCont packet"); 1633 } 1634 1635 thread_actions.Append(thread_action); 1636 } 1637 1638 Status error = m_debugged_process_sp->Resume(thread_actions); 1639 if (error.Fail()) { 1640 if (log) { 1641 log->Printf("GDBRemoteCommunicationServerLLGS::%s vCont failed for " 1642 "process %" PRIu64 ": %s", 1643 __FUNCTION__, m_debugged_process_sp->GetID(), 1644 error.AsCString()); 1645 } 1646 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1647 } 1648 1649 if (log) 1650 log->Printf( 1651 "GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64, 1652 __FUNCTION__, m_debugged_process_sp->GetID()); 1653 1654 // No response required from vCont. 1655 return PacketResult::Success; 1656 } 1657 1658 void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) { 1659 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1660 if (log) 1661 log->Printf("GDBRemoteCommunicationServerLLGS::%s setting current thread " 1662 "id to %" PRIu64, 1663 __FUNCTION__, tid); 1664 1665 m_current_tid = tid; 1666 if (m_debugged_process_sp) 1667 m_debugged_process_sp->SetCurrentThreadID(m_current_tid); 1668 } 1669 1670 void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) { 1671 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1672 if (log) 1673 log->Printf("GDBRemoteCommunicationServerLLGS::%s setting continue thread " 1674 "id to %" PRIu64, 1675 __FUNCTION__, tid); 1676 1677 m_continue_tid = tid; 1678 } 1679 1680 GDBRemoteCommunication::PacketResult 1681 GDBRemoteCommunicationServerLLGS::Handle_stop_reason( 1682 StringExtractorGDBRemote &packet) { 1683 // Handle the $? gdbremote command. 1684 1685 // If no process, indicate error 1686 if (!m_debugged_process_sp) 1687 return SendErrorResponse(02); 1688 1689 return SendStopReasonForState(m_debugged_process_sp->GetState()); 1690 } 1691 1692 GDBRemoteCommunication::PacketResult 1693 GDBRemoteCommunicationServerLLGS::SendStopReasonForState( 1694 lldb::StateType process_state) { 1695 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1696 1697 switch (process_state) { 1698 case eStateAttaching: 1699 case eStateLaunching: 1700 case eStateRunning: 1701 case eStateStepping: 1702 case eStateDetached: 1703 // NOTE: gdb protocol doc looks like it should return $OK 1704 // when everything is running (i.e. no stopped result). 1705 return PacketResult::Success; // Ignore 1706 1707 case eStateSuspended: 1708 case eStateStopped: 1709 case eStateCrashed: { 1710 lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID(); 1711 // Make sure we set the current thread so g and p packets return 1712 // the data the gdb will expect. 1713 SetCurrentThreadID(tid); 1714 return SendStopReplyPacketForThread(tid); 1715 } 1716 1717 case eStateInvalid: 1718 case eStateUnloaded: 1719 case eStateExited: 1720 return SendWResponse(m_debugged_process_sp.get()); 1721 1722 default: 1723 if (log) { 1724 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 1725 ", current state reporting not handled: %s", 1726 __FUNCTION__, m_debugged_process_sp->GetID(), 1727 StateAsCString(process_state)); 1728 } 1729 break; 1730 } 1731 1732 return SendErrorResponse(0); 1733 } 1734 1735 GDBRemoteCommunication::PacketResult 1736 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo( 1737 StringExtractorGDBRemote &packet) { 1738 // Fail if we don't have a current process. 1739 if (!m_debugged_process_sp || 1740 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 1741 return SendErrorResponse(68); 1742 1743 // Ensure we have a thread. 1744 NativeThreadProtocolSP thread_sp(m_debugged_process_sp->GetThreadAtIndex(0)); 1745 if (!thread_sp) 1746 return SendErrorResponse(69); 1747 1748 // Get the register context for the first thread. 1749 NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext()); 1750 if (!reg_context_sp) 1751 return SendErrorResponse(69); 1752 1753 // Parse out the register number from the request. 1754 packet.SetFilePos(strlen("qRegisterInfo")); 1755 const uint32_t reg_index = 1756 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1757 if (reg_index == std::numeric_limits<uint32_t>::max()) 1758 return SendErrorResponse(69); 1759 1760 // Return the end of registers response if we've iterated one past the end of 1761 // the register set. 1762 if (reg_index >= reg_context_sp->GetUserRegisterCount()) 1763 return SendErrorResponse(69); 1764 1765 const RegisterInfo *reg_info = 1766 reg_context_sp->GetRegisterInfoAtIndex(reg_index); 1767 if (!reg_info) 1768 return SendErrorResponse(69); 1769 1770 // Build the reginfos response. 1771 StreamGDBRemote response; 1772 1773 response.PutCString("name:"); 1774 response.PutCString(reg_info->name); 1775 response.PutChar(';'); 1776 1777 if (reg_info->alt_name && reg_info->alt_name[0]) { 1778 response.PutCString("alt-name:"); 1779 response.PutCString(reg_info->alt_name); 1780 response.PutChar(';'); 1781 } 1782 1783 response.Printf("bitsize:%" PRIu32 ";offset:%" PRIu32 ";", 1784 reg_info->byte_size * 8, reg_info->byte_offset); 1785 1786 switch (reg_info->encoding) { 1787 case eEncodingUint: 1788 response.PutCString("encoding:uint;"); 1789 break; 1790 case eEncodingSint: 1791 response.PutCString("encoding:sint;"); 1792 break; 1793 case eEncodingIEEE754: 1794 response.PutCString("encoding:ieee754;"); 1795 break; 1796 case eEncodingVector: 1797 response.PutCString("encoding:vector;"); 1798 break; 1799 default: 1800 break; 1801 } 1802 1803 switch (reg_info->format) { 1804 case eFormatBinary: 1805 response.PutCString("format:binary;"); 1806 break; 1807 case eFormatDecimal: 1808 response.PutCString("format:decimal;"); 1809 break; 1810 case eFormatHex: 1811 response.PutCString("format:hex;"); 1812 break; 1813 case eFormatFloat: 1814 response.PutCString("format:float;"); 1815 break; 1816 case eFormatVectorOfSInt8: 1817 response.PutCString("format:vector-sint8;"); 1818 break; 1819 case eFormatVectorOfUInt8: 1820 response.PutCString("format:vector-uint8;"); 1821 break; 1822 case eFormatVectorOfSInt16: 1823 response.PutCString("format:vector-sint16;"); 1824 break; 1825 case eFormatVectorOfUInt16: 1826 response.PutCString("format:vector-uint16;"); 1827 break; 1828 case eFormatVectorOfSInt32: 1829 response.PutCString("format:vector-sint32;"); 1830 break; 1831 case eFormatVectorOfUInt32: 1832 response.PutCString("format:vector-uint32;"); 1833 break; 1834 case eFormatVectorOfFloat32: 1835 response.PutCString("format:vector-float32;"); 1836 break; 1837 case eFormatVectorOfUInt64: 1838 response.PutCString("format:vector-uint64;"); 1839 break; 1840 case eFormatVectorOfUInt128: 1841 response.PutCString("format:vector-uint128;"); 1842 break; 1843 default: 1844 break; 1845 }; 1846 1847 const char *const register_set_name = 1848 reg_context_sp->GetRegisterSetNameForRegisterAtIndex(reg_index); 1849 if (register_set_name) { 1850 response.PutCString("set:"); 1851 response.PutCString(register_set_name); 1852 response.PutChar(';'); 1853 } 1854 1855 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != 1856 LLDB_INVALID_REGNUM) 1857 response.Printf("ehframe:%" PRIu32 ";", 1858 reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 1859 1860 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 1861 response.Printf("dwarf:%" PRIu32 ";", 1862 reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 1863 1864 switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) { 1865 case LLDB_REGNUM_GENERIC_PC: 1866 response.PutCString("generic:pc;"); 1867 break; 1868 case LLDB_REGNUM_GENERIC_SP: 1869 response.PutCString("generic:sp;"); 1870 break; 1871 case LLDB_REGNUM_GENERIC_FP: 1872 response.PutCString("generic:fp;"); 1873 break; 1874 case LLDB_REGNUM_GENERIC_RA: 1875 response.PutCString("generic:ra;"); 1876 break; 1877 case LLDB_REGNUM_GENERIC_FLAGS: 1878 response.PutCString("generic:flags;"); 1879 break; 1880 case LLDB_REGNUM_GENERIC_ARG1: 1881 response.PutCString("generic:arg1;"); 1882 break; 1883 case LLDB_REGNUM_GENERIC_ARG2: 1884 response.PutCString("generic:arg2;"); 1885 break; 1886 case LLDB_REGNUM_GENERIC_ARG3: 1887 response.PutCString("generic:arg3;"); 1888 break; 1889 case LLDB_REGNUM_GENERIC_ARG4: 1890 response.PutCString("generic:arg4;"); 1891 break; 1892 case LLDB_REGNUM_GENERIC_ARG5: 1893 response.PutCString("generic:arg5;"); 1894 break; 1895 case LLDB_REGNUM_GENERIC_ARG6: 1896 response.PutCString("generic:arg6;"); 1897 break; 1898 case LLDB_REGNUM_GENERIC_ARG7: 1899 response.PutCString("generic:arg7;"); 1900 break; 1901 case LLDB_REGNUM_GENERIC_ARG8: 1902 response.PutCString("generic:arg8;"); 1903 break; 1904 default: 1905 break; 1906 } 1907 1908 if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) { 1909 response.PutCString("container-regs:"); 1910 int i = 0; 1911 for (const uint32_t *reg_num = reg_info->value_regs; 1912 *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) { 1913 if (i > 0) 1914 response.PutChar(','); 1915 response.Printf("%" PRIx32, *reg_num); 1916 } 1917 response.PutChar(';'); 1918 } 1919 1920 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) { 1921 response.PutCString("invalidate-regs:"); 1922 int i = 0; 1923 for (const uint32_t *reg_num = reg_info->invalidate_regs; 1924 *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) { 1925 if (i > 0) 1926 response.PutChar(','); 1927 response.Printf("%" PRIx32, *reg_num); 1928 } 1929 response.PutChar(';'); 1930 } 1931 1932 if (reg_info->dynamic_size_dwarf_expr_bytes) { 1933 const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len; 1934 response.PutCString("dynamic_size_dwarf_expr_bytes:"); 1935 for (uint32_t i = 0; i < dwarf_opcode_len; ++i) 1936 response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]); 1937 response.PutChar(';'); 1938 } 1939 return SendPacketNoLock(response.GetString()); 1940 } 1941 1942 GDBRemoteCommunication::PacketResult 1943 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo( 1944 StringExtractorGDBRemote &packet) { 1945 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1946 1947 // Fail if we don't have a current process. 1948 if (!m_debugged_process_sp || 1949 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 1950 if (log) 1951 log->Printf("GDBRemoteCommunicationServerLLGS::%s() no process (%s), " 1952 "returning OK", 1953 __FUNCTION__, 1954 m_debugged_process_sp ? "invalid process id" 1955 : "null m_debugged_process_sp"); 1956 return SendOKResponse(); 1957 } 1958 1959 StreamGDBRemote response; 1960 response.PutChar('m'); 1961 1962 if (log) 1963 log->Printf( 1964 "GDBRemoteCommunicationServerLLGS::%s() starting thread iteration", 1965 __FUNCTION__); 1966 1967 NativeThreadProtocolSP thread_sp; 1968 uint32_t thread_index; 1969 for (thread_index = 0, 1970 thread_sp = m_debugged_process_sp->GetThreadAtIndex(thread_index); 1971 thread_sp; ++thread_index, 1972 thread_sp = m_debugged_process_sp->GetThreadAtIndex(thread_index)) { 1973 if (log) 1974 log->Printf( 1975 "GDBRemoteCommunicationServerLLGS::%s() iterated thread %" PRIu32 1976 "(%s, tid=0x%" PRIx64 ")", 1977 __FUNCTION__, thread_index, thread_sp ? "is not null" : "null", 1978 thread_sp ? thread_sp->GetID() : LLDB_INVALID_THREAD_ID); 1979 if (thread_index > 0) 1980 response.PutChar(','); 1981 response.Printf("%" PRIx64, thread_sp->GetID()); 1982 } 1983 1984 if (log) 1985 log->Printf( 1986 "GDBRemoteCommunicationServerLLGS::%s() finished thread iteration", 1987 __FUNCTION__); 1988 1989 return SendPacketNoLock(response.GetString()); 1990 } 1991 1992 GDBRemoteCommunication::PacketResult 1993 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo( 1994 StringExtractorGDBRemote &packet) { 1995 // FIXME for now we return the full thread list in the initial packet and 1996 // always do nothing here. 1997 return SendPacketNoLock("l"); 1998 } 1999 2000 GDBRemoteCommunication::PacketResult 2001 GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) { 2002 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2003 2004 // Parse out the register number from the request. 2005 packet.SetFilePos(strlen("p")); 2006 const uint32_t reg_index = 2007 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2008 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2009 if (log) 2010 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not " 2011 "parse register number from request \"%s\"", 2012 __FUNCTION__, packet.GetStringRef().c_str()); 2013 return SendErrorResponse(0x15); 2014 } 2015 2016 // Get the thread to use. 2017 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet); 2018 if (!thread_sp) { 2019 if (log) 2020 log->Printf( 2021 "GDBRemoteCommunicationServerLLGS::%s failed, no thread available", 2022 __FUNCTION__); 2023 return SendErrorResponse(0x15); 2024 } 2025 2026 // Get the thread's register context. 2027 NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext()); 2028 if (!reg_context_sp) { 2029 if (log) 2030 log->Printf( 2031 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 2032 " failed, no register context available for the thread", 2033 __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID()); 2034 return SendErrorResponse(0x15); 2035 } 2036 2037 // Return the end of registers response if we've iterated one past the end of 2038 // the register set. 2039 if (reg_index >= reg_context_sp->GetUserRegisterCount()) { 2040 if (log) 2041 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 2042 "register %" PRIu32 " beyond register count %" PRIu32, 2043 __FUNCTION__, reg_index, 2044 reg_context_sp->GetUserRegisterCount()); 2045 return SendErrorResponse(0x15); 2046 } 2047 2048 const RegisterInfo *reg_info = 2049 reg_context_sp->GetRegisterInfoAtIndex(reg_index); 2050 if (!reg_info) { 2051 if (log) 2052 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 2053 "register %" PRIu32 " returned NULL", 2054 __FUNCTION__, reg_index); 2055 return SendErrorResponse(0x15); 2056 } 2057 2058 // Build the reginfos response. 2059 StreamGDBRemote response; 2060 2061 // Retrieve the value 2062 RegisterValue reg_value; 2063 Status error = reg_context_sp->ReadRegister(reg_info, reg_value); 2064 if (error.Fail()) { 2065 if (log) 2066 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, read of " 2067 "requested register %" PRIu32 " (%s) failed: %s", 2068 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2069 return SendErrorResponse(0x15); 2070 } 2071 2072 const uint8_t *const data = 2073 reinterpret_cast<const uint8_t *>(reg_value.GetBytes()); 2074 if (!data) { 2075 if (log) 2076 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get data " 2077 "bytes from requested register %" PRIu32, 2078 __FUNCTION__, reg_index); 2079 return SendErrorResponse(0x15); 2080 } 2081 2082 // FIXME flip as needed to get data in big/little endian format for this host. 2083 for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i) 2084 response.PutHex8(data[i]); 2085 2086 return SendPacketNoLock(response.GetString()); 2087 } 2088 2089 GDBRemoteCommunication::PacketResult 2090 GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) { 2091 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2092 2093 // Ensure there is more content. 2094 if (packet.GetBytesLeft() < 1) 2095 return SendIllFormedResponse(packet, "Empty P packet"); 2096 2097 // Parse out the register number from the request. 2098 packet.SetFilePos(strlen("P")); 2099 const uint32_t reg_index = 2100 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2101 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2102 if (log) 2103 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not " 2104 "parse register number from request \"%s\"", 2105 __FUNCTION__, packet.GetStringRef().c_str()); 2106 return SendErrorResponse(0x29); 2107 } 2108 2109 // Note debugserver would send an E30 here. 2110 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '=')) 2111 return SendIllFormedResponse( 2112 packet, "P packet missing '=' char after register number"); 2113 2114 // Get process architecture. 2115 ArchSpec process_arch; 2116 if (!m_debugged_process_sp || 2117 !m_debugged_process_sp->GetArchitecture(process_arch)) { 2118 if (log) 2119 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to retrieve " 2120 "inferior architecture", 2121 __FUNCTION__); 2122 return SendErrorResponse(0x49); 2123 } 2124 2125 // Parse out the value. 2126 uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register 2127 size_t reg_size = packet.GetHexBytesAvail(reg_bytes); 2128 2129 // Get the thread to use. 2130 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet); 2131 if (!thread_sp) { 2132 if (log) 2133 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread " 2134 "available (thread index 0)", 2135 __FUNCTION__); 2136 return SendErrorResponse(0x28); 2137 } 2138 2139 // Get the thread's register context. 2140 NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext()); 2141 if (!reg_context_sp) { 2142 if (log) 2143 log->Printf( 2144 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 2145 " failed, no register context available for the thread", 2146 __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID()); 2147 return SendErrorResponse(0x15); 2148 } 2149 2150 const RegisterInfo *reg_info = 2151 reg_context_sp->GetRegisterInfoAtIndex(reg_index); 2152 if (!reg_info) { 2153 if (log) 2154 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 2155 "register %" PRIu32 " returned NULL", 2156 __FUNCTION__, reg_index); 2157 return SendErrorResponse(0x48); 2158 } 2159 2160 // Return the end of registers response if we've iterated one past the end of 2161 // the register set. 2162 if (reg_index >= reg_context_sp->GetUserRegisterCount()) { 2163 if (log) 2164 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 2165 "register %" PRIu32 " beyond register count %" PRIu32, 2166 __FUNCTION__, reg_index, 2167 reg_context_sp->GetUserRegisterCount()); 2168 return SendErrorResponse(0x47); 2169 } 2170 2171 // The dwarf expression are evaluate on host site 2172 // which may cause register size to change 2173 // Hence the reg_size may not be same as reg_info->bytes_size 2174 if ((reg_size != reg_info->byte_size) && 2175 !(reg_info->dynamic_size_dwarf_expr_bytes)) { 2176 return SendIllFormedResponse(packet, "P packet register size is incorrect"); 2177 } 2178 2179 // Build the reginfos response. 2180 StreamGDBRemote response; 2181 2182 RegisterValue reg_value(reg_bytes, reg_size, process_arch.GetByteOrder()); 2183 Status error = reg_context_sp->WriteRegister(reg_info, reg_value); 2184 if (error.Fail()) { 2185 if (log) 2186 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, write of " 2187 "requested register %" PRIu32 " (%s) failed: %s", 2188 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2189 return SendErrorResponse(0x32); 2190 } 2191 2192 return SendOKResponse(); 2193 } 2194 2195 GDBRemoteCommunication::PacketResult 2196 GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) { 2197 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2198 2199 // Fail if we don't have a current process. 2200 if (!m_debugged_process_sp || 2201 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2202 if (log) 2203 log->Printf( 2204 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2205 __FUNCTION__); 2206 return SendErrorResponse(0x15); 2207 } 2208 2209 // Parse out which variant of $H is requested. 2210 packet.SetFilePos(strlen("H")); 2211 if (packet.GetBytesLeft() < 1) { 2212 if (log) 2213 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, H command " 2214 "missing {g,c} variant", 2215 __FUNCTION__); 2216 return SendIllFormedResponse(packet, "H command missing {g,c} variant"); 2217 } 2218 2219 const char h_variant = packet.GetChar(); 2220 switch (h_variant) { 2221 case 'g': 2222 break; 2223 2224 case 'c': 2225 break; 2226 2227 default: 2228 if (log) 2229 log->Printf( 2230 "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c", 2231 __FUNCTION__, h_variant); 2232 return SendIllFormedResponse(packet, 2233 "H variant unsupported, should be c or g"); 2234 } 2235 2236 // Parse out the thread number. 2237 // FIXME return a parse success/fail value. All values are valid here. 2238 const lldb::tid_t tid = 2239 packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max()); 2240 2241 // Ensure we have the given thread when not specifying -1 (all threads) or 0 2242 // (any thread). 2243 if (tid != LLDB_INVALID_THREAD_ID && tid != 0) { 2244 NativeThreadProtocolSP thread_sp(m_debugged_process_sp->GetThreadByID(tid)); 2245 if (!thread_sp) { 2246 if (log) 2247 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64 2248 " not found", 2249 __FUNCTION__, tid); 2250 return SendErrorResponse(0x15); 2251 } 2252 } 2253 2254 // Now switch the given thread type. 2255 switch (h_variant) { 2256 case 'g': 2257 SetCurrentThreadID(tid); 2258 break; 2259 2260 case 'c': 2261 SetContinueThreadID(tid); 2262 break; 2263 2264 default: 2265 assert(false && "unsupported $H variant - shouldn't get here"); 2266 return SendIllFormedResponse(packet, 2267 "H variant unsupported, should be c or g"); 2268 } 2269 2270 return SendOKResponse(); 2271 } 2272 2273 GDBRemoteCommunication::PacketResult 2274 GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) { 2275 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2276 2277 // Fail if we don't have a current process. 2278 if (!m_debugged_process_sp || 2279 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2280 if (log) 2281 log->Printf( 2282 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2283 __FUNCTION__); 2284 return SendErrorResponse(0x15); 2285 } 2286 2287 packet.SetFilePos(::strlen("I")); 2288 uint8_t tmp[4096]; 2289 for (;;) { 2290 size_t read = packet.GetHexBytesAvail(tmp); 2291 if (read == 0) { 2292 break; 2293 } 2294 // write directly to stdin *this might block if stdin buffer is full* 2295 // TODO: enqueue this block in circular buffer and send window size to 2296 // remote host 2297 ConnectionStatus status; 2298 Status error; 2299 m_stdio_communication.Write(tmp, read, status, &error); 2300 if (error.Fail()) { 2301 return SendErrorResponse(0x15); 2302 } 2303 } 2304 2305 return SendOKResponse(); 2306 } 2307 2308 GDBRemoteCommunication::PacketResult 2309 GDBRemoteCommunicationServerLLGS::Handle_interrupt( 2310 StringExtractorGDBRemote &packet) { 2311 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2312 2313 // Fail if we don't have a current process. 2314 if (!m_debugged_process_sp || 2315 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2316 if (log) 2317 log->Printf( 2318 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2319 __FUNCTION__); 2320 return SendErrorResponse(0x15); 2321 } 2322 2323 // Interrupt the process. 2324 Status error = m_debugged_process_sp->Interrupt(); 2325 if (error.Fail()) { 2326 if (log) { 2327 log->Printf( 2328 "GDBRemoteCommunicationServerLLGS::%s failed for process %" PRIu64 2329 ": %s", 2330 __FUNCTION__, m_debugged_process_sp->GetID(), error.AsCString()); 2331 } 2332 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 2333 } 2334 2335 if (log) 2336 log->Printf("GDBRemoteCommunicationServerLLGS::%s stopped process %" PRIu64, 2337 __FUNCTION__, m_debugged_process_sp->GetID()); 2338 2339 // No response required from stop all. 2340 return PacketResult::Success; 2341 } 2342 2343 GDBRemoteCommunication::PacketResult 2344 GDBRemoteCommunicationServerLLGS::Handle_memory_read( 2345 StringExtractorGDBRemote &packet) { 2346 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2347 2348 if (!m_debugged_process_sp || 2349 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2350 if (log) 2351 log->Printf( 2352 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2353 __FUNCTION__); 2354 return SendErrorResponse(0x15); 2355 } 2356 2357 // Parse out the memory address. 2358 packet.SetFilePos(strlen("m")); 2359 if (packet.GetBytesLeft() < 1) 2360 return SendIllFormedResponse(packet, "Too short m packet"); 2361 2362 // Read the address. Punting on validation. 2363 // FIXME replace with Hex U64 read with no default value that fails on failed 2364 // read. 2365 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2366 2367 // Validate comma. 2368 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2369 return SendIllFormedResponse(packet, "Comma sep missing in m packet"); 2370 2371 // Get # bytes to read. 2372 if (packet.GetBytesLeft() < 1) 2373 return SendIllFormedResponse(packet, "Length missing in m packet"); 2374 2375 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2376 if (byte_count == 0) { 2377 if (log) 2378 log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to read: " 2379 "zero-length packet", 2380 __FUNCTION__); 2381 return SendOKResponse(); 2382 } 2383 2384 // Allocate the response buffer. 2385 std::string buf(byte_count, '\0'); 2386 if (buf.empty()) 2387 return SendErrorResponse(0x78); 2388 2389 // Retrieve the process memory. 2390 size_t bytes_read = 0; 2391 Status error = m_debugged_process_sp->ReadMemoryWithoutTrap( 2392 read_addr, &buf[0], byte_count, bytes_read); 2393 if (error.Fail()) { 2394 if (log) 2395 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2396 " mem 0x%" PRIx64 ": failed to read. Error: %s", 2397 __FUNCTION__, m_debugged_process_sp->GetID(), read_addr, 2398 error.AsCString()); 2399 return SendErrorResponse(0x08); 2400 } 2401 2402 if (bytes_read == 0) { 2403 if (log) 2404 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2405 " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes", 2406 __FUNCTION__, m_debugged_process_sp->GetID(), read_addr, 2407 byte_count); 2408 return SendErrorResponse(0x08); 2409 } 2410 2411 StreamGDBRemote response; 2412 packet.SetFilePos(0); 2413 char kind = packet.GetChar('?'); 2414 if (kind == 'x') 2415 response.PutEscapedBytes(buf.data(), byte_count); 2416 else { 2417 assert(kind == 'm'); 2418 for (size_t i = 0; i < bytes_read; ++i) 2419 response.PutHex8(buf[i]); 2420 } 2421 2422 return SendPacketNoLock(response.GetString()); 2423 } 2424 2425 GDBRemoteCommunication::PacketResult 2426 GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) { 2427 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2428 2429 if (!m_debugged_process_sp || 2430 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2431 if (log) 2432 log->Printf( 2433 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2434 __FUNCTION__); 2435 return SendErrorResponse(0x15); 2436 } 2437 2438 // Parse out the memory address. 2439 packet.SetFilePos(strlen("M")); 2440 if (packet.GetBytesLeft() < 1) 2441 return SendIllFormedResponse(packet, "Too short M packet"); 2442 2443 // Read the address. Punting on validation. 2444 // FIXME replace with Hex U64 read with no default value that fails on failed 2445 // read. 2446 const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0); 2447 2448 // Validate comma. 2449 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2450 return SendIllFormedResponse(packet, "Comma sep missing in M packet"); 2451 2452 // Get # bytes to read. 2453 if (packet.GetBytesLeft() < 1) 2454 return SendIllFormedResponse(packet, "Length missing in M packet"); 2455 2456 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2457 if (byte_count == 0) { 2458 if (log) 2459 log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to write: " 2460 "zero-length packet", 2461 __FUNCTION__); 2462 return PacketResult::Success; 2463 } 2464 2465 // Validate colon. 2466 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':')) 2467 return SendIllFormedResponse( 2468 packet, "Comma sep missing in M packet after byte length"); 2469 2470 // Allocate the conversion buffer. 2471 std::vector<uint8_t> buf(byte_count, 0); 2472 if (buf.empty()) 2473 return SendErrorResponse(0x78); 2474 2475 // Convert the hex memory write contents to bytes. 2476 StreamGDBRemote response; 2477 const uint64_t convert_count = packet.GetHexBytes(buf, 0); 2478 if (convert_count != byte_count) { 2479 if (log) 2480 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2481 " mem 0x%" PRIx64 ": asked to write %" PRIu64 2482 " bytes, but only found %" PRIu64 " to convert.", 2483 __FUNCTION__, m_debugged_process_sp->GetID(), write_addr, 2484 byte_count, convert_count); 2485 return SendIllFormedResponse(packet, "M content byte length specified did " 2486 "not match hex-encoded content " 2487 "length"); 2488 } 2489 2490 // Write the process memory. 2491 size_t bytes_written = 0; 2492 Status error = m_debugged_process_sp->WriteMemory(write_addr, &buf[0], 2493 byte_count, bytes_written); 2494 if (error.Fail()) { 2495 if (log) 2496 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2497 " mem 0x%" PRIx64 ": failed to write. Error: %s", 2498 __FUNCTION__, m_debugged_process_sp->GetID(), write_addr, 2499 error.AsCString()); 2500 return SendErrorResponse(0x09); 2501 } 2502 2503 if (bytes_written == 0) { 2504 if (log) 2505 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2506 " mem 0x%" PRIx64 ": wrote 0 of %" PRIu64 " requested bytes", 2507 __FUNCTION__, m_debugged_process_sp->GetID(), write_addr, 2508 byte_count); 2509 return SendErrorResponse(0x09); 2510 } 2511 2512 return SendOKResponse(); 2513 } 2514 2515 GDBRemoteCommunication::PacketResult 2516 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported( 2517 StringExtractorGDBRemote &packet) { 2518 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2519 2520 // Currently only the NativeProcessProtocol knows if it can handle a 2521 // qMemoryRegionInfoSupported 2522 // request, but we're not guaranteed to be attached to a process. For now 2523 // we'll assume the 2524 // client only asks this when a process is being debugged. 2525 2526 // Ensure we have a process running; otherwise, we can't figure this out 2527 // since we won't have a NativeProcessProtocol. 2528 if (!m_debugged_process_sp || 2529 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2530 if (log) 2531 log->Printf( 2532 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2533 __FUNCTION__); 2534 return SendErrorResponse(0x15); 2535 } 2536 2537 // Test if we can get any region back when asking for the region around NULL. 2538 MemoryRegionInfo region_info; 2539 const Status error = 2540 m_debugged_process_sp->GetMemoryRegionInfo(0, region_info); 2541 if (error.Fail()) { 2542 // We don't support memory region info collection for this 2543 // NativeProcessProtocol. 2544 return SendUnimplementedResponse(""); 2545 } 2546 2547 return SendOKResponse(); 2548 } 2549 2550 GDBRemoteCommunication::PacketResult 2551 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo( 2552 StringExtractorGDBRemote &packet) { 2553 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2554 2555 // Ensure we have a process. 2556 if (!m_debugged_process_sp || 2557 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2558 if (log) 2559 log->Printf( 2560 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2561 __FUNCTION__); 2562 return SendErrorResponse(0x15); 2563 } 2564 2565 // Parse out the memory address. 2566 packet.SetFilePos(strlen("qMemoryRegionInfo:")); 2567 if (packet.GetBytesLeft() < 1) 2568 return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet"); 2569 2570 // Read the address. Punting on validation. 2571 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2572 2573 StreamGDBRemote response; 2574 2575 // Get the memory region info for the target address. 2576 MemoryRegionInfo region_info; 2577 const Status error = 2578 m_debugged_process_sp->GetMemoryRegionInfo(read_addr, region_info); 2579 if (error.Fail()) { 2580 // Return the error message. 2581 2582 response.PutCString("error:"); 2583 response.PutCStringAsRawHex8(error.AsCString()); 2584 response.PutChar(';'); 2585 } else { 2586 // Range start and size. 2587 response.Printf("start:%" PRIx64 ";size:%" PRIx64 ";", 2588 region_info.GetRange().GetRangeBase(), 2589 region_info.GetRange().GetByteSize()); 2590 2591 // Permissions. 2592 if (region_info.GetReadable() || region_info.GetWritable() || 2593 region_info.GetExecutable()) { 2594 // Write permissions info. 2595 response.PutCString("permissions:"); 2596 2597 if (region_info.GetReadable()) 2598 response.PutChar('r'); 2599 if (region_info.GetWritable()) 2600 response.PutChar('w'); 2601 if (region_info.GetExecutable()) 2602 response.PutChar('x'); 2603 2604 response.PutChar(';'); 2605 } 2606 2607 // Name 2608 ConstString name = region_info.GetName(); 2609 if (name) { 2610 response.PutCString("name:"); 2611 response.PutCStringAsRawHex8(name.AsCString()); 2612 response.PutChar(';'); 2613 } 2614 } 2615 2616 return SendPacketNoLock(response.GetString()); 2617 } 2618 2619 GDBRemoteCommunication::PacketResult 2620 GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) { 2621 // Ensure we have a process. 2622 if (!m_debugged_process_sp || 2623 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2624 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2625 if (log) 2626 log->Printf( 2627 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2628 __FUNCTION__); 2629 return SendErrorResponse(0x15); 2630 } 2631 2632 // Parse out software or hardware breakpoint or watchpoint requested. 2633 packet.SetFilePos(strlen("Z")); 2634 if (packet.GetBytesLeft() < 1) 2635 return SendIllFormedResponse( 2636 packet, "Too short Z packet, missing software/hardware specifier"); 2637 2638 bool want_breakpoint = true; 2639 bool want_hardware = false; 2640 uint32_t watch_flags = 0; 2641 2642 const GDBStoppointType stoppoint_type = 2643 GDBStoppointType(packet.GetS32(eStoppointInvalid)); 2644 switch (stoppoint_type) { 2645 case eBreakpointSoftware: 2646 want_hardware = false; 2647 want_breakpoint = true; 2648 break; 2649 case eBreakpointHardware: 2650 want_hardware = true; 2651 want_breakpoint = true; 2652 break; 2653 case eWatchpointWrite: 2654 watch_flags = 1; 2655 want_hardware = true; 2656 want_breakpoint = false; 2657 break; 2658 case eWatchpointRead: 2659 watch_flags = 2; 2660 want_hardware = true; 2661 want_breakpoint = false; 2662 break; 2663 case eWatchpointReadWrite: 2664 watch_flags = 3; 2665 want_hardware = true; 2666 want_breakpoint = false; 2667 break; 2668 case eStoppointInvalid: 2669 return SendIllFormedResponse( 2670 packet, "Z packet had invalid software/hardware specifier"); 2671 } 2672 2673 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2674 return SendIllFormedResponse( 2675 packet, "Malformed Z packet, expecting comma after stoppoint type"); 2676 2677 // Parse out the stoppoint address. 2678 if (packet.GetBytesLeft() < 1) 2679 return SendIllFormedResponse(packet, "Too short Z packet, missing address"); 2680 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2681 2682 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2683 return SendIllFormedResponse( 2684 packet, "Malformed Z packet, expecting comma after address"); 2685 2686 // Parse out the stoppoint size (i.e. size hint for opcode size). 2687 const uint32_t size = 2688 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2689 if (size == std::numeric_limits<uint32_t>::max()) 2690 return SendIllFormedResponse( 2691 packet, "Malformed Z packet, failed to parse size argument"); 2692 2693 if (want_breakpoint) { 2694 // Try to set the breakpoint. 2695 const Status error = 2696 m_debugged_process_sp->SetBreakpoint(addr, size, want_hardware); 2697 if (error.Success()) 2698 return SendOKResponse(); 2699 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 2700 if (log) 2701 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2702 " failed to set breakpoint: %s", 2703 __FUNCTION__, m_debugged_process_sp->GetID(), 2704 error.AsCString()); 2705 return SendErrorResponse(0x09); 2706 } else { 2707 // Try to set the watchpoint. 2708 const Status error = m_debugged_process_sp->SetWatchpoint( 2709 addr, size, watch_flags, want_hardware); 2710 if (error.Success()) 2711 return SendOKResponse(); 2712 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 2713 if (log) 2714 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2715 " failed to set watchpoint: %s", 2716 __FUNCTION__, m_debugged_process_sp->GetID(), 2717 error.AsCString()); 2718 return SendErrorResponse(0x09); 2719 } 2720 } 2721 2722 GDBRemoteCommunication::PacketResult 2723 GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) { 2724 // Ensure we have a process. 2725 if (!m_debugged_process_sp || 2726 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2727 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2728 if (log) 2729 log->Printf( 2730 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2731 __FUNCTION__); 2732 return SendErrorResponse(0x15); 2733 } 2734 2735 // Parse out software or hardware breakpoint or watchpoint requested. 2736 packet.SetFilePos(strlen("z")); 2737 if (packet.GetBytesLeft() < 1) 2738 return SendIllFormedResponse( 2739 packet, "Too short z packet, missing software/hardware specifier"); 2740 2741 bool want_breakpoint = true; 2742 bool want_hardware = false; 2743 2744 const GDBStoppointType stoppoint_type = 2745 GDBStoppointType(packet.GetS32(eStoppointInvalid)); 2746 switch (stoppoint_type) { 2747 case eBreakpointHardware: 2748 want_breakpoint = true; 2749 want_hardware = true; 2750 break; 2751 case eBreakpointSoftware: 2752 want_breakpoint = true; 2753 break; 2754 case eWatchpointWrite: 2755 want_breakpoint = false; 2756 break; 2757 case eWatchpointRead: 2758 want_breakpoint = false; 2759 break; 2760 case eWatchpointReadWrite: 2761 want_breakpoint = false; 2762 break; 2763 default: 2764 return SendIllFormedResponse( 2765 packet, "z packet had invalid software/hardware specifier"); 2766 } 2767 2768 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2769 return SendIllFormedResponse( 2770 packet, "Malformed z packet, expecting comma after stoppoint type"); 2771 2772 // Parse out the stoppoint address. 2773 if (packet.GetBytesLeft() < 1) 2774 return SendIllFormedResponse(packet, "Too short z packet, missing address"); 2775 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2776 2777 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2778 return SendIllFormedResponse( 2779 packet, "Malformed z packet, expecting comma after address"); 2780 2781 /* 2782 // Parse out the stoppoint size (i.e. size hint for opcode size). 2783 const uint32_t size = packet.GetHexMaxU32 (false, 2784 std::numeric_limits<uint32_t>::max ()); 2785 if (size == std::numeric_limits<uint32_t>::max ()) 2786 return SendIllFormedResponse(packet, "Malformed z packet, failed to parse 2787 size argument"); 2788 */ 2789 2790 if (want_breakpoint) { 2791 // Try to clear the breakpoint. 2792 const Status error = 2793 m_debugged_process_sp->RemoveBreakpoint(addr, want_hardware); 2794 if (error.Success()) 2795 return SendOKResponse(); 2796 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 2797 if (log) 2798 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2799 " failed to remove breakpoint: %s", 2800 __FUNCTION__, m_debugged_process_sp->GetID(), 2801 error.AsCString()); 2802 return SendErrorResponse(0x09); 2803 } else { 2804 // Try to clear the watchpoint. 2805 const Status error = m_debugged_process_sp->RemoveWatchpoint(addr); 2806 if (error.Success()) 2807 return SendOKResponse(); 2808 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 2809 if (log) 2810 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2811 " failed to remove watchpoint: %s", 2812 __FUNCTION__, m_debugged_process_sp->GetID(), 2813 error.AsCString()); 2814 return SendErrorResponse(0x09); 2815 } 2816 } 2817 2818 GDBRemoteCommunication::PacketResult 2819 GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) { 2820 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2821 2822 // Ensure we have a process. 2823 if (!m_debugged_process_sp || 2824 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2825 if (log) 2826 log->Printf( 2827 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2828 __FUNCTION__); 2829 return SendErrorResponse(0x32); 2830 } 2831 2832 // We first try to use a continue thread id. If any one or any all set, use 2833 // the current thread. 2834 // Bail out if we don't have a thread id. 2835 lldb::tid_t tid = GetContinueThreadID(); 2836 if (tid == 0 || tid == LLDB_INVALID_THREAD_ID) 2837 tid = GetCurrentThreadID(); 2838 if (tid == LLDB_INVALID_THREAD_ID) 2839 return SendErrorResponse(0x33); 2840 2841 // Double check that we have such a thread. 2842 // TODO investigate: on MacOSX we might need to do an UpdateThreads () here. 2843 NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetThreadByID(tid); 2844 if (!thread_sp || thread_sp->GetID() != tid) 2845 return SendErrorResponse(0x33); 2846 2847 // Create the step action for the given thread. 2848 ResumeAction action = {tid, eStateStepping, 0}; 2849 2850 // Setup the actions list. 2851 ResumeActionList actions; 2852 actions.Append(action); 2853 2854 // All other threads stop while we're single stepping a thread. 2855 actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0); 2856 Status error = m_debugged_process_sp->Resume(actions); 2857 if (error.Fail()) { 2858 if (log) 2859 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2860 " tid %" PRIu64 " Resume() failed with error: %s", 2861 __FUNCTION__, m_debugged_process_sp->GetID(), tid, 2862 error.AsCString()); 2863 return SendErrorResponse(0x49); 2864 } 2865 2866 // No response here - the stop or exit will come from the resulting action. 2867 return PacketResult::Success; 2868 } 2869 2870 GDBRemoteCommunication::PacketResult 2871 GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read( 2872 StringExtractorGDBRemote &packet) { 2873 // *BSD impls should be able to do this too. 2874 #if defined(__linux__) || defined(__NetBSD__) 2875 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2876 2877 // Parse out the offset. 2878 packet.SetFilePos(strlen("qXfer:auxv:read::")); 2879 if (packet.GetBytesLeft() < 1) 2880 return SendIllFormedResponse(packet, 2881 "qXfer:auxv:read:: packet missing offset"); 2882 2883 const uint64_t auxv_offset = 2884 packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 2885 if (auxv_offset == std::numeric_limits<uint64_t>::max()) 2886 return SendIllFormedResponse(packet, 2887 "qXfer:auxv:read:: packet missing offset"); 2888 2889 // Parse out comma. 2890 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ',') 2891 return SendIllFormedResponse( 2892 packet, "qXfer:auxv:read:: packet missing comma after offset"); 2893 2894 // Parse out the length. 2895 const uint64_t auxv_length = 2896 packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 2897 if (auxv_length == std::numeric_limits<uint64_t>::max()) 2898 return SendIllFormedResponse(packet, 2899 "qXfer:auxv:read:: packet missing length"); 2900 2901 // Grab the auxv data if we need it. 2902 if (!m_active_auxv_buffer_up) { 2903 // Make sure we have a valid process. 2904 if (!m_debugged_process_sp || 2905 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 2906 if (log) 2907 log->Printf( 2908 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2909 __FUNCTION__); 2910 return SendErrorResponse(0x10); 2911 } 2912 2913 // Grab the auxv data. 2914 auto buffer_or_error = m_debugged_process_sp->GetAuxvData(); 2915 if (!buffer_or_error) { 2916 std::error_code ec = buffer_or_error.getError(); 2917 LLDB_LOG(log, "no auxv data retrieved: {0}", ec.message()); 2918 return SendErrorResponse(ec.value()); 2919 } 2920 m_active_auxv_buffer_up = std::move(*buffer_or_error); 2921 } 2922 2923 StreamGDBRemote response; 2924 bool done_with_buffer = false; 2925 2926 llvm::StringRef buffer = m_active_auxv_buffer_up->getBuffer(); 2927 if (auxv_offset >= buffer.size()) { 2928 // We have nothing left to send. Mark the buffer as complete. 2929 response.PutChar('l'); 2930 done_with_buffer = true; 2931 } else { 2932 // Figure out how many bytes are available starting at the given offset. 2933 buffer = buffer.drop_front(auxv_offset); 2934 2935 // Mark the response type according to whether we're reading the remainder 2936 // of the auxv data. 2937 if (auxv_length >= buffer.size()) { 2938 // There will be nothing left to read after this 2939 response.PutChar('l'); 2940 done_with_buffer = true; 2941 } else { 2942 // There will still be bytes to read after this request. 2943 response.PutChar('m'); 2944 buffer = buffer.take_front(auxv_length); 2945 } 2946 2947 // Now write the data in encoded binary form. 2948 response.PutEscapedBytes(buffer.data(), buffer.size()); 2949 } 2950 2951 if (done_with_buffer) 2952 m_active_auxv_buffer_up.reset(); 2953 2954 return SendPacketNoLock(response.GetString()); 2955 #else 2956 return SendUnimplementedResponse("not implemented on this platform"); 2957 #endif 2958 } 2959 2960 GDBRemoteCommunication::PacketResult 2961 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( 2962 StringExtractorGDBRemote &packet) { 2963 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2964 2965 // Move past packet name. 2966 packet.SetFilePos(strlen("QSaveRegisterState")); 2967 2968 // Get the thread to use. 2969 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet); 2970 if (!thread_sp) { 2971 if (m_thread_suffix_supported) 2972 return SendIllFormedResponse( 2973 packet, "No thread specified in QSaveRegisterState packet"); 2974 else 2975 return SendIllFormedResponse(packet, 2976 "No thread was is set with the Hg packet"); 2977 } 2978 2979 // Grab the register context for the thread. 2980 NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext()); 2981 if (!reg_context_sp) { 2982 if (log) 2983 log->Printf( 2984 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 2985 " failed, no register context available for the thread", 2986 __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID()); 2987 return SendErrorResponse(0x15); 2988 } 2989 2990 // Save registers to a buffer. 2991 DataBufferSP register_data_sp; 2992 Status error = reg_context_sp->ReadAllRegisterValues(register_data_sp); 2993 if (error.Fail()) { 2994 if (log) 2995 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2996 " failed to save all register values: %s", 2997 __FUNCTION__, m_debugged_process_sp->GetID(), 2998 error.AsCString()); 2999 return SendErrorResponse(0x75); 3000 } 3001 3002 // Allocate a new save id. 3003 const uint32_t save_id = GetNextSavedRegistersID(); 3004 assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && 3005 "GetNextRegisterSaveID() returned an existing register save id"); 3006 3007 // Save the register data buffer under the save id. 3008 { 3009 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3010 m_saved_registers_map[save_id] = register_data_sp; 3011 } 3012 3013 // Write the response. 3014 StreamGDBRemote response; 3015 response.Printf("%" PRIu32, save_id); 3016 return SendPacketNoLock(response.GetString()); 3017 } 3018 3019 GDBRemoteCommunication::PacketResult 3020 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( 3021 StringExtractorGDBRemote &packet) { 3022 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3023 3024 // Parse out save id. 3025 packet.SetFilePos(strlen("QRestoreRegisterState:")); 3026 if (packet.GetBytesLeft() < 1) 3027 return SendIllFormedResponse( 3028 packet, "QRestoreRegisterState packet missing register save id"); 3029 3030 const uint32_t save_id = packet.GetU32(0); 3031 if (save_id == 0) { 3032 if (log) 3033 log->Printf("GDBRemoteCommunicationServerLLGS::%s QRestoreRegisterState " 3034 "packet has malformed save id, expecting decimal uint32_t", 3035 __FUNCTION__); 3036 return SendErrorResponse(0x76); 3037 } 3038 3039 // Get the thread to use. 3040 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet); 3041 if (!thread_sp) { 3042 if (m_thread_suffix_supported) 3043 return SendIllFormedResponse( 3044 packet, "No thread specified in QRestoreRegisterState packet"); 3045 else 3046 return SendIllFormedResponse(packet, 3047 "No thread was is set with the Hg packet"); 3048 } 3049 3050 // Grab the register context for the thread. 3051 NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext()); 3052 if (!reg_context_sp) { 3053 if (log) 3054 log->Printf( 3055 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 3056 " failed, no register context available for the thread", 3057 __FUNCTION__, m_debugged_process_sp->GetID(), thread_sp->GetID()); 3058 return SendErrorResponse(0x15); 3059 } 3060 3061 // Retrieve register state buffer, then remove from the list. 3062 DataBufferSP register_data_sp; 3063 { 3064 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3065 3066 // Find the register set buffer for the given save id. 3067 auto it = m_saved_registers_map.find(save_id); 3068 if (it == m_saved_registers_map.end()) { 3069 if (log) 3070 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 3071 " does not have a register set save buffer for id %" PRIu32, 3072 __FUNCTION__, m_debugged_process_sp->GetID(), save_id); 3073 return SendErrorResponse(0x77); 3074 } 3075 register_data_sp = it->second; 3076 3077 // Remove it from the map. 3078 m_saved_registers_map.erase(it); 3079 } 3080 3081 Status error = reg_context_sp->WriteAllRegisterValues(register_data_sp); 3082 if (error.Fail()) { 3083 if (log) 3084 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 3085 " failed to restore all register values: %s", 3086 __FUNCTION__, m_debugged_process_sp->GetID(), 3087 error.AsCString()); 3088 return SendErrorResponse(0x77); 3089 } 3090 3091 return SendOKResponse(); 3092 } 3093 3094 GDBRemoteCommunication::PacketResult 3095 GDBRemoteCommunicationServerLLGS::Handle_vAttach( 3096 StringExtractorGDBRemote &packet) { 3097 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3098 3099 // Consume the ';' after vAttach. 3100 packet.SetFilePos(strlen("vAttach")); 3101 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3102 return SendIllFormedResponse(packet, "vAttach missing expected ';'"); 3103 3104 // Grab the PID to which we will attach (assume hex encoding). 3105 lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3106 if (pid == LLDB_INVALID_PROCESS_ID) 3107 return SendIllFormedResponse(packet, 3108 "vAttach failed to parse the process id"); 3109 3110 // Attempt to attach. 3111 if (log) 3112 log->Printf("GDBRemoteCommunicationServerLLGS::%s attempting to attach to " 3113 "pid %" PRIu64, 3114 __FUNCTION__, pid); 3115 3116 Status error = AttachToProcess(pid); 3117 3118 if (error.Fail()) { 3119 if (log) 3120 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to attach to " 3121 "pid %" PRIu64 ": %s\n", 3122 __FUNCTION__, pid, error.AsCString()); 3123 return SendErrorResponse(0x01); 3124 } 3125 3126 // Notify we attached by sending a stop packet. 3127 return SendStopReasonForState(m_debugged_process_sp->GetState()); 3128 } 3129 3130 GDBRemoteCommunication::PacketResult 3131 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) { 3132 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3133 3134 StopSTDIOForwarding(); 3135 3136 // Fail if we don't have a current process. 3137 if (!m_debugged_process_sp || 3138 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) { 3139 if (log) 3140 log->Printf( 3141 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3142 __FUNCTION__); 3143 return SendErrorResponse(0x15); 3144 } 3145 3146 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 3147 3148 // Consume the ';' after D. 3149 packet.SetFilePos(1); 3150 if (packet.GetBytesLeft()) { 3151 if (packet.GetChar() != ';') 3152 return SendIllFormedResponse(packet, "D missing expected ';'"); 3153 3154 // Grab the PID from which we will detach (assume hex encoding). 3155 pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3156 if (pid == LLDB_INVALID_PROCESS_ID) 3157 return SendIllFormedResponse(packet, "D failed to parse the process id"); 3158 } 3159 3160 if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_sp->GetID() != pid) { 3161 return SendIllFormedResponse(packet, "Invalid pid"); 3162 } 3163 3164 const Status error = m_debugged_process_sp->Detach(); 3165 if (error.Fail()) { 3166 if (log) 3167 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to detach from " 3168 "pid %" PRIu64 ": %s\n", 3169 __FUNCTION__, m_debugged_process_sp->GetID(), 3170 error.AsCString()); 3171 return SendErrorResponse(0x01); 3172 } 3173 3174 return SendOKResponse(); 3175 } 3176 3177 GDBRemoteCommunication::PacketResult 3178 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo( 3179 StringExtractorGDBRemote &packet) { 3180 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3181 3182 packet.SetFilePos(strlen("qThreadStopInfo")); 3183 const lldb::tid_t tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID); 3184 if (tid == LLDB_INVALID_THREAD_ID) { 3185 if (log) 3186 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not " 3187 "parse thread id from request \"%s\"", 3188 __FUNCTION__, packet.GetStringRef().c_str()); 3189 return SendErrorResponse(0x15); 3190 } 3191 return SendStopReplyPacketForThread(tid); 3192 } 3193 3194 GDBRemoteCommunication::PacketResult 3195 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo( 3196 StringExtractorGDBRemote &) { 3197 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 3198 3199 // Ensure we have a debugged process. 3200 if (!m_debugged_process_sp || 3201 (m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID)) 3202 return SendErrorResponse(50); 3203 3204 if (log) 3205 log->Printf("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid " 3206 "%" PRIu64, 3207 __FUNCTION__, m_debugged_process_sp->GetID()); 3208 3209 StreamString response; 3210 const bool threads_with_valid_stop_info_only = false; 3211 JSONArray::SP threads_array_sp = GetJSONThreadsInfo( 3212 *m_debugged_process_sp, threads_with_valid_stop_info_only); 3213 if (!threads_array_sp) { 3214 if (log) 3215 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to prepare a " 3216 "packet for pid %" PRIu64, 3217 __FUNCTION__, m_debugged_process_sp->GetID()); 3218 return SendErrorResponse(52); 3219 } 3220 3221 threads_array_sp->Write(response); 3222 StreamGDBRemote escaped_response; 3223 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 3224 return SendPacketNoLock(escaped_response.GetString()); 3225 } 3226 3227 GDBRemoteCommunication::PacketResult 3228 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo( 3229 StringExtractorGDBRemote &packet) { 3230 // Fail if we don't have a current process. 3231 if (!m_debugged_process_sp || 3232 m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID) 3233 return SendErrorResponse(68); 3234 3235 packet.SetFilePos(strlen("qWatchpointSupportInfo")); 3236 if (packet.GetBytesLeft() == 0) 3237 return SendOKResponse(); 3238 if (packet.GetChar() != ':') 3239 return SendErrorResponse(67); 3240 3241 auto hw_debug_cap = m_debugged_process_sp->GetHardwareDebugSupportInfo(); 3242 3243 StreamGDBRemote response; 3244 if (hw_debug_cap == llvm::None) 3245 response.Printf("num:0;"); 3246 else 3247 response.Printf("num:%d;", hw_debug_cap->second); 3248 3249 return SendPacketNoLock(response.GetString()); 3250 } 3251 3252 GDBRemoteCommunication::PacketResult 3253 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress( 3254 StringExtractorGDBRemote &packet) { 3255 // Fail if we don't have a current process. 3256 if (!m_debugged_process_sp || 3257 m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID) 3258 return SendErrorResponse(67); 3259 3260 packet.SetFilePos(strlen("qFileLoadAddress:")); 3261 if (packet.GetBytesLeft() == 0) 3262 return SendErrorResponse(68); 3263 3264 std::string file_name; 3265 packet.GetHexByteString(file_name); 3266 3267 lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS; 3268 Status error = 3269 m_debugged_process_sp->GetFileLoadAddress(file_name, file_load_address); 3270 if (error.Fail()) 3271 return SendErrorResponse(69); 3272 3273 if (file_load_address == LLDB_INVALID_ADDRESS) 3274 return SendErrorResponse(1); // File not loaded 3275 3276 StreamGDBRemote response; 3277 response.PutHex64(file_load_address); 3278 return SendPacketNoLock(response.GetString()); 3279 } 3280 3281 GDBRemoteCommunication::PacketResult 3282 GDBRemoteCommunicationServerLLGS::Handle_QPassSignals( 3283 StringExtractorGDBRemote &packet) { 3284 std::vector<int> signals; 3285 packet.SetFilePos(strlen("QPassSignals:")); 3286 3287 // Read sequence of hex signal numbers divided by a semicolon and 3288 // optionally spaces. 3289 while (packet.GetBytesLeft() > 0) { 3290 int signal = packet.GetS32(-1, 16); 3291 if (signal < 0) 3292 return SendIllFormedResponse(packet, "Failed to parse signal number."); 3293 signals.push_back(signal); 3294 3295 packet.SkipSpaces(); 3296 char separator = packet.GetChar(); 3297 if (separator == '\0') 3298 break; // End of string 3299 if (separator != ';') 3300 return SendIllFormedResponse(packet, "Invalid separator," 3301 " expected semicolon."); 3302 } 3303 3304 // Fail if we don't have a current process. 3305 if (!m_debugged_process_sp) 3306 return SendErrorResponse(68); 3307 3308 Status error = m_debugged_process_sp->IgnoreSignals(signals); 3309 if (error.Fail()) 3310 return SendErrorResponse(69); 3311 3312 return SendOKResponse(); 3313 } 3314 3315 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() { 3316 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3317 3318 // Tell the stdio connection to shut down. 3319 if (m_stdio_communication.IsConnected()) { 3320 auto connection = m_stdio_communication.GetConnection(); 3321 if (connection) { 3322 Status error; 3323 connection->Disconnect(&error); 3324 3325 if (error.Success()) { 3326 if (log) 3327 log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process " 3328 "terminal stdio - SUCCESS", 3329 __FUNCTION__); 3330 } else { 3331 if (log) 3332 log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process " 3333 "terminal stdio - FAIL: %s", 3334 __FUNCTION__, error.AsCString()); 3335 } 3336 } 3337 } 3338 } 3339 3340 NativeThreadProtocolSP GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( 3341 StringExtractorGDBRemote &packet) { 3342 NativeThreadProtocolSP thread_sp; 3343 3344 // We have no thread if we don't have a process. 3345 if (!m_debugged_process_sp || 3346 m_debugged_process_sp->GetID() == LLDB_INVALID_PROCESS_ID) 3347 return thread_sp; 3348 3349 // If the client hasn't asked for thread suffix support, there will not be a 3350 // thread suffix. 3351 // Use the current thread in that case. 3352 if (!m_thread_suffix_supported) { 3353 const lldb::tid_t current_tid = GetCurrentThreadID(); 3354 if (current_tid == LLDB_INVALID_THREAD_ID) 3355 return thread_sp; 3356 else if (current_tid == 0) { 3357 // Pick a thread. 3358 return m_debugged_process_sp->GetThreadAtIndex(0); 3359 } else 3360 return m_debugged_process_sp->GetThreadByID(current_tid); 3361 } 3362 3363 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3364 3365 // Parse out the ';'. 3366 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') { 3367 if (log) 3368 log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 3369 "error: expected ';' prior to start of thread suffix: packet " 3370 "contents = '%s'", 3371 __FUNCTION__, packet.GetStringRef().c_str()); 3372 return thread_sp; 3373 } 3374 3375 if (!packet.GetBytesLeft()) 3376 return thread_sp; 3377 3378 // Parse out thread: portion. 3379 if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) { 3380 if (log) 3381 log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 3382 "error: expected 'thread:' but not found, packet contents = " 3383 "'%s'", 3384 __FUNCTION__, packet.GetStringRef().c_str()); 3385 return thread_sp; 3386 } 3387 packet.SetFilePos(packet.GetFilePos() + strlen("thread:")); 3388 const lldb::tid_t tid = packet.GetHexMaxU64(false, 0); 3389 if (tid != 0) 3390 return m_debugged_process_sp->GetThreadByID(tid); 3391 3392 return thread_sp; 3393 } 3394 3395 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const { 3396 if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) { 3397 // Use whatever the debug process says is the current thread id 3398 // since the protocol either didn't specify or specified we want 3399 // any/all threads marked as the current thread. 3400 if (!m_debugged_process_sp) 3401 return LLDB_INVALID_THREAD_ID; 3402 return m_debugged_process_sp->GetCurrentThreadID(); 3403 } 3404 // Use the specific current thread id set by the gdb remote protocol. 3405 return m_current_tid; 3406 } 3407 3408 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() { 3409 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3410 return m_next_saved_registers_id++; 3411 } 3412 3413 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() { 3414 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3415 3416 LLDB_LOG(log, "clearing auxv buffer: {0}", m_active_auxv_buffer_up.get()); 3417 m_active_auxv_buffer_up.reset(); 3418 } 3419 3420 FileSpec 3421 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path, 3422 const ArchSpec &arch) { 3423 if (m_debugged_process_sp) { 3424 FileSpec file_spec; 3425 if (m_debugged_process_sp 3426 ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec) 3427 .Success()) { 3428 if (file_spec.Exists()) 3429 return file_spec; 3430 } 3431 } 3432 3433 return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch); 3434 } 3435