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