1 //===-- GDBRemoteCommunicationServerLLGS.cpp --------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include <errno.h> 10 11 #include "lldb/Host/Config.h" 12 13 #include "GDBRemoteCommunicationServerLLGS.h" 14 #include "lldb/Utility/StreamGDBRemote.h" 15 16 #include <chrono> 17 #include <cstring> 18 #include <thread> 19 20 #include "lldb/Host/ConnectionFileDescriptor.h" 21 #include "lldb/Host/Debug.h" 22 #include "lldb/Host/File.h" 23 #include "lldb/Host/FileAction.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/MemoryRegionInfo.h" 32 #include "lldb/Utility/Args.h" 33 #include "lldb/Utility/DataBuffer.h" 34 #include "lldb/Utility/Endian.h" 35 #include "lldb/Utility/JSON.h" 36 #include "lldb/Utility/LLDBAssert.h" 37 #include "lldb/Utility/Log.h" 38 #include "lldb/Utility/RegisterValue.h" 39 #include "lldb/Utility/State.h" 40 #include "lldb/Utility/StreamString.h" 41 #include "lldb/Utility/UriParser.h" 42 #include "llvm/ADT/Triple.h" 43 #include "llvm/Support/ScopedPrinter.h" 44 45 #include "ProcessGDBRemote.h" 46 #include "ProcessGDBRemoteLog.h" 47 #include "lldb/Utility/StringExtractorGDBRemote.h" 48 49 using namespace lldb; 50 using namespace lldb_private; 51 using namespace lldb_private::process_gdb_remote; 52 using namespace llvm; 53 54 // GDBRemote Errors 55 56 namespace { 57 enum GDBRemoteServerError { 58 // Set to the first unused error number in literal form below 59 eErrorFirst = 29, 60 eErrorNoProcess = eErrorFirst, 61 eErrorResume, 62 eErrorExitStatus 63 }; 64 } 65 66 // GDBRemoteCommunicationServerLLGS constructor 67 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS( 68 MainLoop &mainloop, const NativeProcessProtocol::Factory &process_factory) 69 : GDBRemoteCommunicationServerCommon("gdb-remote.server", 70 "gdb-remote.server.rx_packet"), 71 m_mainloop(mainloop), m_process_factory(process_factory), 72 m_stdio_communication("process.stdio") { 73 RegisterPacketHandlers(); 74 } 75 76 void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() { 77 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C, 78 &GDBRemoteCommunicationServerLLGS::Handle_C); 79 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c, 80 &GDBRemoteCommunicationServerLLGS::Handle_c); 81 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D, 82 &GDBRemoteCommunicationServerLLGS::Handle_D); 83 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H, 84 &GDBRemoteCommunicationServerLLGS::Handle_H); 85 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I, 86 &GDBRemoteCommunicationServerLLGS::Handle_I); 87 RegisterMemberFunctionHandler( 88 StringExtractorGDBRemote::eServerPacketType_interrupt, 89 &GDBRemoteCommunicationServerLLGS::Handle_interrupt); 90 RegisterMemberFunctionHandler( 91 StringExtractorGDBRemote::eServerPacketType_m, 92 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 93 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M, 94 &GDBRemoteCommunicationServerLLGS::Handle_M); 95 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p, 96 &GDBRemoteCommunicationServerLLGS::Handle_p); 97 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P, 98 &GDBRemoteCommunicationServerLLGS::Handle_P); 99 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC, 100 &GDBRemoteCommunicationServerLLGS::Handle_qC); 101 RegisterMemberFunctionHandler( 102 StringExtractorGDBRemote::eServerPacketType_qfThreadInfo, 103 &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo); 104 RegisterMemberFunctionHandler( 105 StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress, 106 &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress); 107 RegisterMemberFunctionHandler( 108 StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir, 109 &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir); 110 RegisterMemberFunctionHandler( 111 StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo, 112 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo); 113 RegisterMemberFunctionHandler( 114 StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported, 115 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported); 116 RegisterMemberFunctionHandler( 117 StringExtractorGDBRemote::eServerPacketType_qProcessInfo, 118 &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo); 119 RegisterMemberFunctionHandler( 120 StringExtractorGDBRemote::eServerPacketType_qRegisterInfo, 121 &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo); 122 RegisterMemberFunctionHandler( 123 StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState, 124 &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState); 125 RegisterMemberFunctionHandler( 126 StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState, 127 &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState); 128 RegisterMemberFunctionHandler( 129 StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR, 130 &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR); 131 RegisterMemberFunctionHandler( 132 StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir, 133 &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir); 134 RegisterMemberFunctionHandler( 135 StringExtractorGDBRemote::eServerPacketType_qsThreadInfo, 136 &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo); 137 RegisterMemberFunctionHandler( 138 StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo, 139 &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo); 140 RegisterMemberFunctionHandler( 141 StringExtractorGDBRemote::eServerPacketType_jThreadsInfo, 142 &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo); 143 RegisterMemberFunctionHandler( 144 StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo, 145 &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo); 146 RegisterMemberFunctionHandler( 147 StringExtractorGDBRemote::eServerPacketType_qXfer, 148 &GDBRemoteCommunicationServerLLGS::Handle_qXfer); 149 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s, 150 &GDBRemoteCommunicationServerLLGS::Handle_s); 151 RegisterMemberFunctionHandler( 152 StringExtractorGDBRemote::eServerPacketType_stop_reason, 153 &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ? 154 RegisterMemberFunctionHandler( 155 StringExtractorGDBRemote::eServerPacketType_vAttach, 156 &GDBRemoteCommunicationServerLLGS::Handle_vAttach); 157 RegisterMemberFunctionHandler( 158 StringExtractorGDBRemote::eServerPacketType_vCont, 159 &GDBRemoteCommunicationServerLLGS::Handle_vCont); 160 RegisterMemberFunctionHandler( 161 StringExtractorGDBRemote::eServerPacketType_vCont_actions, 162 &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions); 163 RegisterMemberFunctionHandler( 164 StringExtractorGDBRemote::eServerPacketType_x, 165 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 166 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z, 167 &GDBRemoteCommunicationServerLLGS::Handle_Z); 168 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z, 169 &GDBRemoteCommunicationServerLLGS::Handle_z); 170 RegisterMemberFunctionHandler( 171 StringExtractorGDBRemote::eServerPacketType_QPassSignals, 172 &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals); 173 174 RegisterMemberFunctionHandler( 175 StringExtractorGDBRemote::eServerPacketType_jTraceStart, 176 &GDBRemoteCommunicationServerLLGS::Handle_jTraceStart); 177 RegisterMemberFunctionHandler( 178 StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead, 179 &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead); 180 RegisterMemberFunctionHandler( 181 StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead, 182 &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead); 183 RegisterMemberFunctionHandler( 184 StringExtractorGDBRemote::eServerPacketType_jTraceStop, 185 &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop); 186 RegisterMemberFunctionHandler( 187 StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead, 188 &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead); 189 190 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_g, 191 &GDBRemoteCommunicationServerLLGS::Handle_g); 192 193 RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k, 194 [this](StringExtractorGDBRemote packet, Status &error, 195 bool &interrupt, bool &quit) { 196 quit = true; 197 return this->Handle_k(packet); 198 }); 199 } 200 201 void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) { 202 m_process_launch_info = info; 203 } 204 205 Status GDBRemoteCommunicationServerLLGS::LaunchProcess() { 206 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 207 208 if (!m_process_launch_info.GetArguments().GetArgumentCount()) 209 return Status("%s: no process command line specified to launch", 210 __FUNCTION__); 211 212 const bool should_forward_stdio = 213 m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr || 214 m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr || 215 m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr; 216 m_process_launch_info.SetLaunchInSeparateProcessGroup(true); 217 m_process_launch_info.GetFlags().Set(eLaunchFlagDebug); 218 219 if (should_forward_stdio) { 220 if (llvm::Error Err = m_process_launch_info.SetUpPtyRedirection()) 221 return Status(std::move(Err)); 222 } 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.PutStringAsRawHex8(thread_name); 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.PutStringAsRawHex8(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.PutStringAsRawHex8(description); 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.PutStringAsRawHex8(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_g(StringExtractorGDBRemote &packet) { 1899 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1900 1901 // Move past packet name. 1902 packet.SetFilePos(strlen("g")); 1903 1904 // Get the thread to use. 1905 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 1906 if (!thread) { 1907 LLDB_LOG(log, "failed, no thread available"); 1908 return SendErrorResponse(0x15); 1909 } 1910 1911 // Get the thread's register context. 1912 NativeRegisterContext ®_ctx = thread->GetRegisterContext(); 1913 1914 std::vector<uint8_t> regs_buffer; 1915 for (uint32_t reg_num = 0; reg_num < reg_ctx.GetUserRegisterCount(); 1916 ++reg_num) { 1917 const RegisterInfo *reg_info = reg_ctx.GetRegisterInfoAtIndex(reg_num); 1918 1919 if (reg_info == nullptr) { 1920 LLDB_LOG(log, "failed to get register info for register index {0}", 1921 reg_num); 1922 return SendErrorResponse(0x15); 1923 } 1924 1925 if (reg_info->value_regs != nullptr) 1926 continue; // skip registers that are contained in other registers 1927 1928 RegisterValue reg_value; 1929 Status error = reg_ctx.ReadRegister(reg_info, reg_value); 1930 if (error.Fail()) { 1931 LLDB_LOG(log, "failed to read register at index {0}", reg_num); 1932 return SendErrorResponse(0x15); 1933 } 1934 1935 if (reg_info->byte_offset + reg_info->byte_size >= regs_buffer.size()) 1936 // Resize the buffer to guarantee it can store the register offsetted 1937 // data. 1938 regs_buffer.resize(reg_info->byte_offset + reg_info->byte_size); 1939 1940 // Copy the register offsetted data to the buffer. 1941 memcpy(regs_buffer.data() + reg_info->byte_offset, reg_value.GetBytes(), 1942 reg_info->byte_size); 1943 } 1944 1945 // Write the response. 1946 StreamGDBRemote response; 1947 response.PutBytesAsRawHex8(regs_buffer.data(), regs_buffer.size()); 1948 1949 return SendPacketNoLock(response.GetString()); 1950 } 1951 1952 GDBRemoteCommunication::PacketResult 1953 GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) { 1954 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1955 1956 // Parse out the register number from the request. 1957 packet.SetFilePos(strlen("p")); 1958 const uint32_t reg_index = 1959 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1960 if (reg_index == std::numeric_limits<uint32_t>::max()) { 1961 if (log) 1962 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not " 1963 "parse register number from request \"%s\"", 1964 __FUNCTION__, packet.GetStringRef().c_str()); 1965 return SendErrorResponse(0x15); 1966 } 1967 1968 // Get the thread to use. 1969 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 1970 if (!thread) { 1971 LLDB_LOG(log, "failed, no thread available"); 1972 return SendErrorResponse(0x15); 1973 } 1974 1975 // Get the thread's register context. 1976 NativeRegisterContext ®_context = thread->GetRegisterContext(); 1977 1978 // Return the end of registers response if we've iterated one past the end of 1979 // the register set. 1980 if (reg_index >= reg_context.GetUserRegisterCount()) { 1981 if (log) 1982 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 1983 "register %" PRIu32 " beyond register count %" PRIu32, 1984 __FUNCTION__, reg_index, 1985 reg_context.GetUserRegisterCount()); 1986 return SendErrorResponse(0x15); 1987 } 1988 1989 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 1990 if (!reg_info) { 1991 if (log) 1992 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 1993 "register %" PRIu32 " returned NULL", 1994 __FUNCTION__, reg_index); 1995 return SendErrorResponse(0x15); 1996 } 1997 1998 // Build the reginfos response. 1999 StreamGDBRemote response; 2000 2001 // Retrieve the value 2002 RegisterValue reg_value; 2003 Status error = reg_context.ReadRegister(reg_info, reg_value); 2004 if (error.Fail()) { 2005 if (log) 2006 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, read of " 2007 "requested register %" PRIu32 " (%s) failed: %s", 2008 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2009 return SendErrorResponse(0x15); 2010 } 2011 2012 const uint8_t *const data = 2013 reinterpret_cast<const uint8_t *>(reg_value.GetBytes()); 2014 if (!data) { 2015 if (log) 2016 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get data " 2017 "bytes from requested register %" PRIu32, 2018 __FUNCTION__, reg_index); 2019 return SendErrorResponse(0x15); 2020 } 2021 2022 // FIXME flip as needed to get data in big/little endian format for this host. 2023 for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i) 2024 response.PutHex8(data[i]); 2025 2026 return SendPacketNoLock(response.GetString()); 2027 } 2028 2029 GDBRemoteCommunication::PacketResult 2030 GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) { 2031 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2032 2033 // Ensure there is more content. 2034 if (packet.GetBytesLeft() < 1) 2035 return SendIllFormedResponse(packet, "Empty P packet"); 2036 2037 // Parse out the register number from the request. 2038 packet.SetFilePos(strlen("P")); 2039 const uint32_t reg_index = 2040 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2041 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2042 if (log) 2043 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not " 2044 "parse register number from request \"%s\"", 2045 __FUNCTION__, packet.GetStringRef().c_str()); 2046 return SendErrorResponse(0x29); 2047 } 2048 2049 // Note debugserver would send an E30 here. 2050 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '=')) 2051 return SendIllFormedResponse( 2052 packet, "P packet missing '=' char after register number"); 2053 2054 // Parse out the value. 2055 uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register 2056 size_t reg_size = packet.GetHexBytesAvail(reg_bytes); 2057 2058 // Get the thread to use. 2059 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2060 if (!thread) { 2061 if (log) 2062 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread " 2063 "available (thread index 0)", 2064 __FUNCTION__); 2065 return SendErrorResponse(0x28); 2066 } 2067 2068 // Get the thread's register context. 2069 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2070 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2071 if (!reg_info) { 2072 if (log) 2073 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 2074 "register %" PRIu32 " returned NULL", 2075 __FUNCTION__, reg_index); 2076 return SendErrorResponse(0x48); 2077 } 2078 2079 // Return the end of registers response if we've iterated one past the end of 2080 // the register set. 2081 if (reg_index >= reg_context.GetUserRegisterCount()) { 2082 if (log) 2083 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested " 2084 "register %" PRIu32 " beyond register count %" PRIu32, 2085 __FUNCTION__, reg_index, reg_context.GetUserRegisterCount()); 2086 return SendErrorResponse(0x47); 2087 } 2088 2089 // The dwarf expression are evaluate on host site which may cause register 2090 // size to change Hence the reg_size may not be same as reg_info->bytes_size 2091 if ((reg_size != reg_info->byte_size) && 2092 !(reg_info->dynamic_size_dwarf_expr_bytes)) { 2093 return SendIllFormedResponse(packet, "P packet register size is incorrect"); 2094 } 2095 2096 // Build the reginfos response. 2097 StreamGDBRemote response; 2098 2099 RegisterValue reg_value( 2100 reg_bytes, reg_size, 2101 m_debugged_process_up->GetArchitecture().GetByteOrder()); 2102 Status error = reg_context.WriteRegister(reg_info, reg_value); 2103 if (error.Fail()) { 2104 if (log) 2105 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, write of " 2106 "requested register %" PRIu32 " (%s) failed: %s", 2107 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2108 return SendErrorResponse(0x32); 2109 } 2110 2111 return SendOKResponse(); 2112 } 2113 2114 GDBRemoteCommunication::PacketResult 2115 GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) { 2116 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2117 2118 // Fail if we don't have a current process. 2119 if (!m_debugged_process_up || 2120 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2121 if (log) 2122 log->Printf( 2123 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2124 __FUNCTION__); 2125 return SendErrorResponse(0x15); 2126 } 2127 2128 // Parse out which variant of $H is requested. 2129 packet.SetFilePos(strlen("H")); 2130 if (packet.GetBytesLeft() < 1) { 2131 if (log) 2132 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, H command " 2133 "missing {g,c} variant", 2134 __FUNCTION__); 2135 return SendIllFormedResponse(packet, "H command missing {g,c} variant"); 2136 } 2137 2138 const char h_variant = packet.GetChar(); 2139 switch (h_variant) { 2140 case 'g': 2141 break; 2142 2143 case 'c': 2144 break; 2145 2146 default: 2147 if (log) 2148 log->Printf( 2149 "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c", 2150 __FUNCTION__, h_variant); 2151 return SendIllFormedResponse(packet, 2152 "H variant unsupported, should be c or g"); 2153 } 2154 2155 // Parse out the thread number. 2156 // FIXME return a parse success/fail value. All values are valid here. 2157 const lldb::tid_t tid = 2158 packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max()); 2159 2160 // Ensure we have the given thread when not specifying -1 (all threads) or 0 2161 // (any thread). 2162 if (tid != LLDB_INVALID_THREAD_ID && tid != 0) { 2163 NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid); 2164 if (!thread) { 2165 if (log) 2166 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64 2167 " not found", 2168 __FUNCTION__, tid); 2169 return SendErrorResponse(0x15); 2170 } 2171 } 2172 2173 // Now switch the given thread type. 2174 switch (h_variant) { 2175 case 'g': 2176 SetCurrentThreadID(tid); 2177 break; 2178 2179 case 'c': 2180 SetContinueThreadID(tid); 2181 break; 2182 2183 default: 2184 assert(false && "unsupported $H variant - shouldn't get here"); 2185 return SendIllFormedResponse(packet, 2186 "H variant unsupported, should be c or g"); 2187 } 2188 2189 return SendOKResponse(); 2190 } 2191 2192 GDBRemoteCommunication::PacketResult 2193 GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) { 2194 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2195 2196 // Fail if we don't have a current process. 2197 if (!m_debugged_process_up || 2198 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2199 if (log) 2200 log->Printf( 2201 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2202 __FUNCTION__); 2203 return SendErrorResponse(0x15); 2204 } 2205 2206 packet.SetFilePos(::strlen("I")); 2207 uint8_t tmp[4096]; 2208 for (;;) { 2209 size_t read = packet.GetHexBytesAvail(tmp); 2210 if (read == 0) { 2211 break; 2212 } 2213 // write directly to stdin *this might block if stdin buffer is full* 2214 // TODO: enqueue this block in circular buffer and send window size to 2215 // remote host 2216 ConnectionStatus status; 2217 Status error; 2218 m_stdio_communication.Write(tmp, read, status, &error); 2219 if (error.Fail()) { 2220 return SendErrorResponse(0x15); 2221 } 2222 } 2223 2224 return SendOKResponse(); 2225 } 2226 2227 GDBRemoteCommunication::PacketResult 2228 GDBRemoteCommunicationServerLLGS::Handle_interrupt( 2229 StringExtractorGDBRemote &packet) { 2230 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2231 2232 // Fail if we don't have a current process. 2233 if (!m_debugged_process_up || 2234 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2235 LLDB_LOG(log, "failed, no process available"); 2236 return SendErrorResponse(0x15); 2237 } 2238 2239 // Interrupt the process. 2240 Status error = m_debugged_process_up->Interrupt(); 2241 if (error.Fail()) { 2242 LLDB_LOG(log, "failed for process {0}: {1}", m_debugged_process_up->GetID(), 2243 error); 2244 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 2245 } 2246 2247 LLDB_LOG(log, "stopped process {0}", m_debugged_process_up->GetID()); 2248 2249 // No response required from stop all. 2250 return PacketResult::Success; 2251 } 2252 2253 GDBRemoteCommunication::PacketResult 2254 GDBRemoteCommunicationServerLLGS::Handle_memory_read( 2255 StringExtractorGDBRemote &packet) { 2256 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2257 2258 if (!m_debugged_process_up || 2259 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2260 if (log) 2261 log->Printf( 2262 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2263 __FUNCTION__); 2264 return SendErrorResponse(0x15); 2265 } 2266 2267 // Parse out the memory address. 2268 packet.SetFilePos(strlen("m")); 2269 if (packet.GetBytesLeft() < 1) 2270 return SendIllFormedResponse(packet, "Too short m packet"); 2271 2272 // Read the address. Punting on validation. 2273 // FIXME replace with Hex U64 read with no default value that fails on failed 2274 // read. 2275 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2276 2277 // Validate comma. 2278 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2279 return SendIllFormedResponse(packet, "Comma sep missing in m packet"); 2280 2281 // Get # bytes to read. 2282 if (packet.GetBytesLeft() < 1) 2283 return SendIllFormedResponse(packet, "Length missing in m packet"); 2284 2285 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2286 if (byte_count == 0) { 2287 if (log) 2288 log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to read: " 2289 "zero-length packet", 2290 __FUNCTION__); 2291 return SendOKResponse(); 2292 } 2293 2294 // Allocate the response buffer. 2295 std::string buf(byte_count, '\0'); 2296 if (buf.empty()) 2297 return SendErrorResponse(0x78); 2298 2299 // Retrieve the process memory. 2300 size_t bytes_read = 0; 2301 Status error = m_debugged_process_up->ReadMemoryWithoutTrap( 2302 read_addr, &buf[0], byte_count, bytes_read); 2303 if (error.Fail()) { 2304 if (log) 2305 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2306 " mem 0x%" PRIx64 ": failed to read. Error: %s", 2307 __FUNCTION__, m_debugged_process_up->GetID(), read_addr, 2308 error.AsCString()); 2309 return SendErrorResponse(0x08); 2310 } 2311 2312 if (bytes_read == 0) { 2313 if (log) 2314 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2315 " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes", 2316 __FUNCTION__, m_debugged_process_up->GetID(), read_addr, 2317 byte_count); 2318 return SendErrorResponse(0x08); 2319 } 2320 2321 StreamGDBRemote response; 2322 packet.SetFilePos(0); 2323 char kind = packet.GetChar('?'); 2324 if (kind == 'x') 2325 response.PutEscapedBytes(buf.data(), byte_count); 2326 else { 2327 assert(kind == 'm'); 2328 for (size_t i = 0; i < bytes_read; ++i) 2329 response.PutHex8(buf[i]); 2330 } 2331 2332 return SendPacketNoLock(response.GetString()); 2333 } 2334 2335 GDBRemoteCommunication::PacketResult 2336 GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) { 2337 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2338 2339 if (!m_debugged_process_up || 2340 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2341 if (log) 2342 log->Printf( 2343 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2344 __FUNCTION__); 2345 return SendErrorResponse(0x15); 2346 } 2347 2348 // Parse out the memory address. 2349 packet.SetFilePos(strlen("M")); 2350 if (packet.GetBytesLeft() < 1) 2351 return SendIllFormedResponse(packet, "Too short M packet"); 2352 2353 // Read the address. Punting on validation. 2354 // FIXME replace with Hex U64 read with no default value that fails on failed 2355 // read. 2356 const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0); 2357 2358 // Validate comma. 2359 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2360 return SendIllFormedResponse(packet, "Comma sep missing in M packet"); 2361 2362 // Get # bytes to read. 2363 if (packet.GetBytesLeft() < 1) 2364 return SendIllFormedResponse(packet, "Length missing in M packet"); 2365 2366 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2367 if (byte_count == 0) { 2368 LLDB_LOG(log, "nothing to write: zero-length packet"); 2369 return PacketResult::Success; 2370 } 2371 2372 // Validate colon. 2373 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':')) 2374 return SendIllFormedResponse( 2375 packet, "Comma sep missing in M packet after byte length"); 2376 2377 // Allocate the conversion buffer. 2378 std::vector<uint8_t> buf(byte_count, 0); 2379 if (buf.empty()) 2380 return SendErrorResponse(0x78); 2381 2382 // Convert the hex memory write contents to bytes. 2383 StreamGDBRemote response; 2384 const uint64_t convert_count = packet.GetHexBytes(buf, 0); 2385 if (convert_count != byte_count) { 2386 LLDB_LOG(log, 2387 "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} " 2388 "to convert.", 2389 m_debugged_process_up->GetID(), write_addr, byte_count, 2390 convert_count); 2391 return SendIllFormedResponse(packet, "M content byte length specified did " 2392 "not match hex-encoded content " 2393 "length"); 2394 } 2395 2396 // Write the process memory. 2397 size_t bytes_written = 0; 2398 Status error = m_debugged_process_up->WriteMemory(write_addr, &buf[0], 2399 byte_count, bytes_written); 2400 if (error.Fail()) { 2401 LLDB_LOG(log, "pid {0} mem {1:x}: failed to write. Error: {2}", 2402 m_debugged_process_up->GetID(), write_addr, error); 2403 return SendErrorResponse(0x09); 2404 } 2405 2406 if (bytes_written == 0) { 2407 LLDB_LOG(log, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes", 2408 m_debugged_process_up->GetID(), write_addr, byte_count); 2409 return SendErrorResponse(0x09); 2410 } 2411 2412 return SendOKResponse(); 2413 } 2414 2415 GDBRemoteCommunication::PacketResult 2416 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported( 2417 StringExtractorGDBRemote &packet) { 2418 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2419 2420 // Currently only the NativeProcessProtocol knows if it can handle a 2421 // qMemoryRegionInfoSupported request, but we're not guaranteed to be 2422 // attached to a process. For now we'll assume the client only asks this 2423 // when a process is being debugged. 2424 2425 // Ensure we have a process running; otherwise, we can't figure this out 2426 // since we won't have a NativeProcessProtocol. 2427 if (!m_debugged_process_up || 2428 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2429 if (log) 2430 log->Printf( 2431 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2432 __FUNCTION__); 2433 return SendErrorResponse(0x15); 2434 } 2435 2436 // Test if we can get any region back when asking for the region around NULL. 2437 MemoryRegionInfo region_info; 2438 const Status error = 2439 m_debugged_process_up->GetMemoryRegionInfo(0, region_info); 2440 if (error.Fail()) { 2441 // We don't support memory region info collection for this 2442 // NativeProcessProtocol. 2443 return SendUnimplementedResponse(""); 2444 } 2445 2446 return SendOKResponse(); 2447 } 2448 2449 GDBRemoteCommunication::PacketResult 2450 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo( 2451 StringExtractorGDBRemote &packet) { 2452 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2453 2454 // Ensure we have a process. 2455 if (!m_debugged_process_up || 2456 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2457 if (log) 2458 log->Printf( 2459 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2460 __FUNCTION__); 2461 return SendErrorResponse(0x15); 2462 } 2463 2464 // Parse out the memory address. 2465 packet.SetFilePos(strlen("qMemoryRegionInfo:")); 2466 if (packet.GetBytesLeft() < 1) 2467 return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet"); 2468 2469 // Read the address. Punting on validation. 2470 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2471 2472 StreamGDBRemote response; 2473 2474 // Get the memory region info for the target address. 2475 MemoryRegionInfo region_info; 2476 const Status error = 2477 m_debugged_process_up->GetMemoryRegionInfo(read_addr, region_info); 2478 if (error.Fail()) { 2479 // Return the error message. 2480 2481 response.PutCString("error:"); 2482 response.PutStringAsRawHex8(error.AsCString()); 2483 response.PutChar(';'); 2484 } else { 2485 // Range start and size. 2486 response.Printf("start:%" PRIx64 ";size:%" PRIx64 ";", 2487 region_info.GetRange().GetRangeBase(), 2488 region_info.GetRange().GetByteSize()); 2489 2490 // Permissions. 2491 if (region_info.GetReadable() || region_info.GetWritable() || 2492 region_info.GetExecutable()) { 2493 // Write permissions info. 2494 response.PutCString("permissions:"); 2495 2496 if (region_info.GetReadable()) 2497 response.PutChar('r'); 2498 if (region_info.GetWritable()) 2499 response.PutChar('w'); 2500 if (region_info.GetExecutable()) 2501 response.PutChar('x'); 2502 2503 response.PutChar(';'); 2504 } 2505 2506 // Name 2507 ConstString name = region_info.GetName(); 2508 if (name) { 2509 response.PutCString("name:"); 2510 response.PutStringAsRawHex8(name.AsCString()); 2511 response.PutChar(';'); 2512 } 2513 } 2514 2515 return SendPacketNoLock(response.GetString()); 2516 } 2517 2518 GDBRemoteCommunication::PacketResult 2519 GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) { 2520 // Ensure we have a process. 2521 if (!m_debugged_process_up || 2522 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2523 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2524 LLDB_LOG(log, "failed, no process available"); 2525 return SendErrorResponse(0x15); 2526 } 2527 2528 // Parse out software or hardware breakpoint or watchpoint requested. 2529 packet.SetFilePos(strlen("Z")); 2530 if (packet.GetBytesLeft() < 1) 2531 return SendIllFormedResponse( 2532 packet, "Too short Z packet, missing software/hardware specifier"); 2533 2534 bool want_breakpoint = true; 2535 bool want_hardware = false; 2536 uint32_t watch_flags = 0; 2537 2538 const GDBStoppointType stoppoint_type = 2539 GDBStoppointType(packet.GetS32(eStoppointInvalid)); 2540 switch (stoppoint_type) { 2541 case eBreakpointSoftware: 2542 want_hardware = false; 2543 want_breakpoint = true; 2544 break; 2545 case eBreakpointHardware: 2546 want_hardware = true; 2547 want_breakpoint = true; 2548 break; 2549 case eWatchpointWrite: 2550 watch_flags = 1; 2551 want_hardware = true; 2552 want_breakpoint = false; 2553 break; 2554 case eWatchpointRead: 2555 watch_flags = 2; 2556 want_hardware = true; 2557 want_breakpoint = false; 2558 break; 2559 case eWatchpointReadWrite: 2560 watch_flags = 3; 2561 want_hardware = true; 2562 want_breakpoint = false; 2563 break; 2564 case eStoppointInvalid: 2565 return SendIllFormedResponse( 2566 packet, "Z packet had invalid software/hardware specifier"); 2567 } 2568 2569 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2570 return SendIllFormedResponse( 2571 packet, "Malformed Z packet, expecting comma after stoppoint type"); 2572 2573 // Parse out the stoppoint address. 2574 if (packet.GetBytesLeft() < 1) 2575 return SendIllFormedResponse(packet, "Too short Z packet, missing address"); 2576 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2577 2578 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2579 return SendIllFormedResponse( 2580 packet, "Malformed Z packet, expecting comma after address"); 2581 2582 // Parse out the stoppoint size (i.e. size hint for opcode size). 2583 const uint32_t size = 2584 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2585 if (size == std::numeric_limits<uint32_t>::max()) 2586 return SendIllFormedResponse( 2587 packet, "Malformed Z packet, failed to parse size argument"); 2588 2589 if (want_breakpoint) { 2590 // Try to set the breakpoint. 2591 const Status error = 2592 m_debugged_process_up->SetBreakpoint(addr, size, want_hardware); 2593 if (error.Success()) 2594 return SendOKResponse(); 2595 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 2596 LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}", 2597 m_debugged_process_up->GetID(), error); 2598 return SendErrorResponse(0x09); 2599 } else { 2600 // Try to set the watchpoint. 2601 const Status error = m_debugged_process_up->SetWatchpoint( 2602 addr, size, watch_flags, want_hardware); 2603 if (error.Success()) 2604 return SendOKResponse(); 2605 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 2606 LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}", 2607 m_debugged_process_up->GetID(), error); 2608 return SendErrorResponse(0x09); 2609 } 2610 } 2611 2612 GDBRemoteCommunication::PacketResult 2613 GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) { 2614 // Ensure we have a process. 2615 if (!m_debugged_process_up || 2616 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2617 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2618 LLDB_LOG(log, "failed, no process available"); 2619 return SendErrorResponse(0x15); 2620 } 2621 2622 // Parse out software or hardware breakpoint or watchpoint requested. 2623 packet.SetFilePos(strlen("z")); 2624 if (packet.GetBytesLeft() < 1) 2625 return SendIllFormedResponse( 2626 packet, "Too short z packet, missing software/hardware specifier"); 2627 2628 bool want_breakpoint = true; 2629 bool want_hardware = false; 2630 2631 const GDBStoppointType stoppoint_type = 2632 GDBStoppointType(packet.GetS32(eStoppointInvalid)); 2633 switch (stoppoint_type) { 2634 case eBreakpointHardware: 2635 want_breakpoint = true; 2636 want_hardware = true; 2637 break; 2638 case eBreakpointSoftware: 2639 want_breakpoint = true; 2640 break; 2641 case eWatchpointWrite: 2642 want_breakpoint = false; 2643 break; 2644 case eWatchpointRead: 2645 want_breakpoint = false; 2646 break; 2647 case eWatchpointReadWrite: 2648 want_breakpoint = false; 2649 break; 2650 default: 2651 return SendIllFormedResponse( 2652 packet, "z packet had invalid software/hardware specifier"); 2653 } 2654 2655 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2656 return SendIllFormedResponse( 2657 packet, "Malformed z packet, expecting comma after stoppoint type"); 2658 2659 // Parse out the stoppoint address. 2660 if (packet.GetBytesLeft() < 1) 2661 return SendIllFormedResponse(packet, "Too short z packet, missing address"); 2662 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2663 2664 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2665 return SendIllFormedResponse( 2666 packet, "Malformed z packet, expecting comma after address"); 2667 2668 /* 2669 // Parse out the stoppoint size (i.e. size hint for opcode size). 2670 const uint32_t size = packet.GetHexMaxU32 (false, 2671 std::numeric_limits<uint32_t>::max ()); 2672 if (size == std::numeric_limits<uint32_t>::max ()) 2673 return SendIllFormedResponse(packet, "Malformed z packet, failed to parse 2674 size argument"); 2675 */ 2676 2677 if (want_breakpoint) { 2678 // Try to clear the breakpoint. 2679 const Status error = 2680 m_debugged_process_up->RemoveBreakpoint(addr, want_hardware); 2681 if (error.Success()) 2682 return SendOKResponse(); 2683 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 2684 LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}", 2685 m_debugged_process_up->GetID(), error); 2686 return SendErrorResponse(0x09); 2687 } else { 2688 // Try to clear the watchpoint. 2689 const Status error = m_debugged_process_up->RemoveWatchpoint(addr); 2690 if (error.Success()) 2691 return SendOKResponse(); 2692 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 2693 LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}", 2694 m_debugged_process_up->GetID(), error); 2695 return SendErrorResponse(0x09); 2696 } 2697 } 2698 2699 GDBRemoteCommunication::PacketResult 2700 GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) { 2701 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2702 2703 // Ensure we have a process. 2704 if (!m_debugged_process_up || 2705 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2706 if (log) 2707 log->Printf( 2708 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2709 __FUNCTION__); 2710 return SendErrorResponse(0x32); 2711 } 2712 2713 // We first try to use a continue thread id. If any one or any all set, use 2714 // the current thread. Bail out if we don't have a thread id. 2715 lldb::tid_t tid = GetContinueThreadID(); 2716 if (tid == 0 || tid == LLDB_INVALID_THREAD_ID) 2717 tid = GetCurrentThreadID(); 2718 if (tid == LLDB_INVALID_THREAD_ID) 2719 return SendErrorResponse(0x33); 2720 2721 // Double check that we have such a thread. 2722 // TODO investigate: on MacOSX we might need to do an UpdateThreads () here. 2723 NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid); 2724 if (!thread) 2725 return SendErrorResponse(0x33); 2726 2727 // Create the step action for the given thread. 2728 ResumeAction action = {tid, eStateStepping, 0}; 2729 2730 // Setup the actions list. 2731 ResumeActionList actions; 2732 actions.Append(action); 2733 2734 // All other threads stop while we're single stepping a thread. 2735 actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0); 2736 Status error = m_debugged_process_up->Resume(actions); 2737 if (error.Fail()) { 2738 if (log) 2739 log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2740 " tid %" PRIu64 " Resume() failed with error: %s", 2741 __FUNCTION__, m_debugged_process_up->GetID(), tid, 2742 error.AsCString()); 2743 return SendErrorResponse(0x49); 2744 } 2745 2746 // No response here - the stop or exit will come from the resulting action. 2747 return PacketResult::Success; 2748 } 2749 2750 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> 2751 GDBRemoteCommunicationServerLLGS::ReadXferObject(llvm::StringRef object, 2752 llvm::StringRef annex) { 2753 if (object == "auxv") { 2754 // Make sure we have a valid process. 2755 if (!m_debugged_process_up || 2756 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2757 return llvm::createStringError(llvm::inconvertibleErrorCode(), 2758 "No process available"); 2759 } 2760 2761 // Grab the auxv data. 2762 auto buffer_or_error = m_debugged_process_up->GetAuxvData(); 2763 if (!buffer_or_error) 2764 return llvm::errorCodeToError(buffer_or_error.getError()); 2765 return std::move(*buffer_or_error); 2766 } 2767 2768 return llvm::make_error<PacketUnimplementedError>( 2769 "Xfer object not supported"); 2770 } 2771 2772 GDBRemoteCommunication::PacketResult 2773 GDBRemoteCommunicationServerLLGS::Handle_qXfer( 2774 StringExtractorGDBRemote &packet) { 2775 SmallVector<StringRef, 5> fields; 2776 // The packet format is "qXfer:<object>:<action>:<annex>:offset,length" 2777 StringRef(packet.GetStringRef()).split(fields, ':', 4); 2778 if (fields.size() != 5) 2779 return SendIllFormedResponse(packet, "malformed qXfer packet"); 2780 StringRef &xfer_object = fields[1]; 2781 StringRef &xfer_action = fields[2]; 2782 StringRef &xfer_annex = fields[3]; 2783 StringExtractor offset_data(fields[4]); 2784 if (xfer_action != "read") 2785 return SendUnimplementedResponse("qXfer action not supported"); 2786 // Parse offset. 2787 const uint64_t xfer_offset = 2788 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 2789 if (xfer_offset == std::numeric_limits<uint64_t>::max()) 2790 return SendIllFormedResponse(packet, "qXfer packet missing offset"); 2791 // Parse out comma. 2792 if (offset_data.GetChar() != ',') 2793 return SendIllFormedResponse(packet, 2794 "qXfer packet missing comma after offset"); 2795 // Parse out the length. 2796 const uint64_t xfer_length = 2797 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 2798 if (xfer_length == std::numeric_limits<uint64_t>::max()) 2799 return SendIllFormedResponse(packet, "qXfer packet missing length"); 2800 2801 // Get a previously constructed buffer if it exists or create it now. 2802 std::string buffer_key = (xfer_object + xfer_action + xfer_annex).str(); 2803 auto buffer_it = m_xfer_buffer_map.find(buffer_key); 2804 if (buffer_it == m_xfer_buffer_map.end()) { 2805 auto buffer_up = ReadXferObject(xfer_object, xfer_annex); 2806 if (!buffer_up) 2807 return SendErrorResponse(buffer_up.takeError()); 2808 buffer_it = m_xfer_buffer_map 2809 .insert(std::make_pair(buffer_key, std::move(*buffer_up))) 2810 .first; 2811 } 2812 2813 // Send back the response 2814 StreamGDBRemote response; 2815 bool done_with_buffer = false; 2816 llvm::StringRef buffer = buffer_it->second->getBuffer(); 2817 if (xfer_offset >= buffer.size()) { 2818 // We have nothing left to send. Mark the buffer as complete. 2819 response.PutChar('l'); 2820 done_with_buffer = true; 2821 } else { 2822 // Figure out how many bytes are available starting at the given offset. 2823 buffer = buffer.drop_front(xfer_offset); 2824 // Mark the response type according to whether we're reading the remainder 2825 // of the data. 2826 if (xfer_length >= buffer.size()) { 2827 // There will be nothing left to read after this 2828 response.PutChar('l'); 2829 done_with_buffer = true; 2830 } else { 2831 // There will still be bytes to read after this request. 2832 response.PutChar('m'); 2833 buffer = buffer.take_front(xfer_length); 2834 } 2835 // Now write the data in encoded binary form. 2836 response.PutEscapedBytes(buffer.data(), buffer.size()); 2837 } 2838 2839 if (done_with_buffer) 2840 m_xfer_buffer_map.erase(buffer_it); 2841 2842 return SendPacketNoLock(response.GetString()); 2843 } 2844 2845 GDBRemoteCommunication::PacketResult 2846 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( 2847 StringExtractorGDBRemote &packet) { 2848 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2849 2850 // Move past packet name. 2851 packet.SetFilePos(strlen("QSaveRegisterState")); 2852 2853 // Get the thread to use. 2854 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2855 if (!thread) { 2856 if (m_thread_suffix_supported) 2857 return SendIllFormedResponse( 2858 packet, "No thread specified in QSaveRegisterState packet"); 2859 else 2860 return SendIllFormedResponse(packet, 2861 "No thread was is set with the Hg packet"); 2862 } 2863 2864 // Grab the register context for the thread. 2865 NativeRegisterContext& reg_context = thread->GetRegisterContext(); 2866 2867 // Save registers to a buffer. 2868 DataBufferSP register_data_sp; 2869 Status error = reg_context.ReadAllRegisterValues(register_data_sp); 2870 if (error.Fail()) { 2871 LLDB_LOG(log, "pid {0} failed to save all register values: {1}", 2872 m_debugged_process_up->GetID(), error); 2873 return SendErrorResponse(0x75); 2874 } 2875 2876 // Allocate a new save id. 2877 const uint32_t save_id = GetNextSavedRegistersID(); 2878 assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && 2879 "GetNextRegisterSaveID() returned an existing register save id"); 2880 2881 // Save the register data buffer under the save id. 2882 { 2883 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 2884 m_saved_registers_map[save_id] = register_data_sp; 2885 } 2886 2887 // Write the response. 2888 StreamGDBRemote response; 2889 response.Printf("%" PRIu32, save_id); 2890 return SendPacketNoLock(response.GetString()); 2891 } 2892 2893 GDBRemoteCommunication::PacketResult 2894 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( 2895 StringExtractorGDBRemote &packet) { 2896 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2897 2898 // Parse out save id. 2899 packet.SetFilePos(strlen("QRestoreRegisterState:")); 2900 if (packet.GetBytesLeft() < 1) 2901 return SendIllFormedResponse( 2902 packet, "QRestoreRegisterState packet missing register save id"); 2903 2904 const uint32_t save_id = packet.GetU32(0); 2905 if (save_id == 0) { 2906 LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, " 2907 "expecting decimal uint32_t"); 2908 return SendErrorResponse(0x76); 2909 } 2910 2911 // Get the thread to use. 2912 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2913 if (!thread) { 2914 if (m_thread_suffix_supported) 2915 return SendIllFormedResponse( 2916 packet, "No thread specified in QRestoreRegisterState packet"); 2917 else 2918 return SendIllFormedResponse(packet, 2919 "No thread was is set with the Hg packet"); 2920 } 2921 2922 // Grab the register context for the thread. 2923 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2924 2925 // Retrieve register state buffer, then remove from the list. 2926 DataBufferSP register_data_sp; 2927 { 2928 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 2929 2930 // Find the register set buffer for the given save id. 2931 auto it = m_saved_registers_map.find(save_id); 2932 if (it == m_saved_registers_map.end()) { 2933 LLDB_LOG(log, 2934 "pid {0} does not have a register set save buffer for id {1}", 2935 m_debugged_process_up->GetID(), save_id); 2936 return SendErrorResponse(0x77); 2937 } 2938 register_data_sp = it->second; 2939 2940 // Remove it from the map. 2941 m_saved_registers_map.erase(it); 2942 } 2943 2944 Status error = reg_context.WriteAllRegisterValues(register_data_sp); 2945 if (error.Fail()) { 2946 LLDB_LOG(log, "pid {0} failed to restore all register values: {1}", 2947 m_debugged_process_up->GetID(), error); 2948 return SendErrorResponse(0x77); 2949 } 2950 2951 return SendOKResponse(); 2952 } 2953 2954 GDBRemoteCommunication::PacketResult 2955 GDBRemoteCommunicationServerLLGS::Handle_vAttach( 2956 StringExtractorGDBRemote &packet) { 2957 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2958 2959 // Consume the ';' after vAttach. 2960 packet.SetFilePos(strlen("vAttach")); 2961 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 2962 return SendIllFormedResponse(packet, "vAttach missing expected ';'"); 2963 2964 // Grab the PID to which we will attach (assume hex encoding). 2965 lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 2966 if (pid == LLDB_INVALID_PROCESS_ID) 2967 return SendIllFormedResponse(packet, 2968 "vAttach failed to parse the process id"); 2969 2970 // Attempt to attach. 2971 if (log) 2972 log->Printf("GDBRemoteCommunicationServerLLGS::%s attempting to attach to " 2973 "pid %" PRIu64, 2974 __FUNCTION__, pid); 2975 2976 Status error = AttachToProcess(pid); 2977 2978 if (error.Fail()) { 2979 if (log) 2980 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to attach to " 2981 "pid %" PRIu64 ": %s\n", 2982 __FUNCTION__, pid, error.AsCString()); 2983 return SendErrorResponse(error); 2984 } 2985 2986 // Notify we attached by sending a stop packet. 2987 return SendStopReasonForState(m_debugged_process_up->GetState()); 2988 } 2989 2990 GDBRemoteCommunication::PacketResult 2991 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) { 2992 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2993 2994 StopSTDIOForwarding(); 2995 2996 // Fail if we don't have a current process. 2997 if (!m_debugged_process_up || 2998 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 2999 if (log) 3000 log->Printf( 3001 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3002 __FUNCTION__); 3003 return SendErrorResponse(0x15); 3004 } 3005 3006 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 3007 3008 // Consume the ';' after D. 3009 packet.SetFilePos(1); 3010 if (packet.GetBytesLeft()) { 3011 if (packet.GetChar() != ';') 3012 return SendIllFormedResponse(packet, "D missing expected ';'"); 3013 3014 // Grab the PID from which we will detach (assume hex encoding). 3015 pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3016 if (pid == LLDB_INVALID_PROCESS_ID) 3017 return SendIllFormedResponse(packet, "D failed to parse the process id"); 3018 } 3019 3020 if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_up->GetID() != pid) { 3021 return SendIllFormedResponse(packet, "Invalid pid"); 3022 } 3023 3024 const Status error = m_debugged_process_up->Detach(); 3025 if (error.Fail()) { 3026 if (log) 3027 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to detach from " 3028 "pid %" PRIu64 ": %s\n", 3029 __FUNCTION__, m_debugged_process_up->GetID(), 3030 error.AsCString()); 3031 return SendErrorResponse(0x01); 3032 } 3033 3034 return SendOKResponse(); 3035 } 3036 3037 GDBRemoteCommunication::PacketResult 3038 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo( 3039 StringExtractorGDBRemote &packet) { 3040 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3041 3042 packet.SetFilePos(strlen("qThreadStopInfo")); 3043 const lldb::tid_t tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID); 3044 if (tid == LLDB_INVALID_THREAD_ID) { 3045 if (log) 3046 log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not " 3047 "parse thread id from request \"%s\"", 3048 __FUNCTION__, packet.GetStringRef().c_str()); 3049 return SendErrorResponse(0x15); 3050 } 3051 return SendStopReplyPacketForThread(tid); 3052 } 3053 3054 GDBRemoteCommunication::PacketResult 3055 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo( 3056 StringExtractorGDBRemote &) { 3057 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 3058 3059 // Ensure we have a debugged process. 3060 if (!m_debugged_process_up || 3061 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 3062 return SendErrorResponse(50); 3063 LLDB_LOG(log, "preparing packet for pid {0}", m_debugged_process_up->GetID()); 3064 3065 StreamString response; 3066 const bool threads_with_valid_stop_info_only = false; 3067 JSONArray::SP threads_array_sp = GetJSONThreadsInfo( 3068 *m_debugged_process_up, threads_with_valid_stop_info_only); 3069 if (!threads_array_sp) { 3070 LLDB_LOG(log, "failed to prepare a packet for pid {0}", 3071 m_debugged_process_up->GetID()); 3072 return SendErrorResponse(52); 3073 } 3074 3075 threads_array_sp->Write(response); 3076 StreamGDBRemote escaped_response; 3077 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 3078 return SendPacketNoLock(escaped_response.GetString()); 3079 } 3080 3081 GDBRemoteCommunication::PacketResult 3082 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo( 3083 StringExtractorGDBRemote &packet) { 3084 // Fail if we don't have a current process. 3085 if (!m_debugged_process_up || 3086 m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID) 3087 return SendErrorResponse(68); 3088 3089 packet.SetFilePos(strlen("qWatchpointSupportInfo")); 3090 if (packet.GetBytesLeft() == 0) 3091 return SendOKResponse(); 3092 if (packet.GetChar() != ':') 3093 return SendErrorResponse(67); 3094 3095 auto hw_debug_cap = m_debugged_process_up->GetHardwareDebugSupportInfo(); 3096 3097 StreamGDBRemote response; 3098 if (hw_debug_cap == llvm::None) 3099 response.Printf("num:0;"); 3100 else 3101 response.Printf("num:%d;", hw_debug_cap->second); 3102 3103 return SendPacketNoLock(response.GetString()); 3104 } 3105 3106 GDBRemoteCommunication::PacketResult 3107 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress( 3108 StringExtractorGDBRemote &packet) { 3109 // Fail if we don't have a current process. 3110 if (!m_debugged_process_up || 3111 m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID) 3112 return SendErrorResponse(67); 3113 3114 packet.SetFilePos(strlen("qFileLoadAddress:")); 3115 if (packet.GetBytesLeft() == 0) 3116 return SendErrorResponse(68); 3117 3118 std::string file_name; 3119 packet.GetHexByteString(file_name); 3120 3121 lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS; 3122 Status error = 3123 m_debugged_process_up->GetFileLoadAddress(file_name, file_load_address); 3124 if (error.Fail()) 3125 return SendErrorResponse(69); 3126 3127 if (file_load_address == LLDB_INVALID_ADDRESS) 3128 return SendErrorResponse(1); // File not loaded 3129 3130 StreamGDBRemote response; 3131 response.PutHex64(file_load_address); 3132 return SendPacketNoLock(response.GetString()); 3133 } 3134 3135 GDBRemoteCommunication::PacketResult 3136 GDBRemoteCommunicationServerLLGS::Handle_QPassSignals( 3137 StringExtractorGDBRemote &packet) { 3138 std::vector<int> signals; 3139 packet.SetFilePos(strlen("QPassSignals:")); 3140 3141 // Read sequence of hex signal numbers divided by a semicolon and optionally 3142 // spaces. 3143 while (packet.GetBytesLeft() > 0) { 3144 int signal = packet.GetS32(-1, 16); 3145 if (signal < 0) 3146 return SendIllFormedResponse(packet, "Failed to parse signal number."); 3147 signals.push_back(signal); 3148 3149 packet.SkipSpaces(); 3150 char separator = packet.GetChar(); 3151 if (separator == '\0') 3152 break; // End of string 3153 if (separator != ';') 3154 return SendIllFormedResponse(packet, "Invalid separator," 3155 " expected semicolon."); 3156 } 3157 3158 // Fail if we don't have a current process. 3159 if (!m_debugged_process_up) 3160 return SendErrorResponse(68); 3161 3162 Status error = m_debugged_process_up->IgnoreSignals(signals); 3163 if (error.Fail()) 3164 return SendErrorResponse(69); 3165 3166 return SendOKResponse(); 3167 } 3168 3169 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() { 3170 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3171 3172 // Tell the stdio connection to shut down. 3173 if (m_stdio_communication.IsConnected()) { 3174 auto connection = m_stdio_communication.GetConnection(); 3175 if (connection) { 3176 Status error; 3177 connection->Disconnect(&error); 3178 3179 if (error.Success()) { 3180 if (log) 3181 log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process " 3182 "terminal stdio - SUCCESS", 3183 __FUNCTION__); 3184 } else { 3185 if (log) 3186 log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process " 3187 "terminal stdio - FAIL: %s", 3188 __FUNCTION__, error.AsCString()); 3189 } 3190 } 3191 } 3192 } 3193 3194 NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( 3195 StringExtractorGDBRemote &packet) { 3196 // We have no thread if we don't have a process. 3197 if (!m_debugged_process_up || 3198 m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID) 3199 return nullptr; 3200 3201 // If the client hasn't asked for thread suffix support, there will not be a 3202 // thread suffix. Use the current thread in that case. 3203 if (!m_thread_suffix_supported) { 3204 const lldb::tid_t current_tid = GetCurrentThreadID(); 3205 if (current_tid == LLDB_INVALID_THREAD_ID) 3206 return nullptr; 3207 else if (current_tid == 0) { 3208 // Pick a thread. 3209 return m_debugged_process_up->GetThreadAtIndex(0); 3210 } else 3211 return m_debugged_process_up->GetThreadByID(current_tid); 3212 } 3213 3214 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3215 3216 // Parse out the ';'. 3217 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') { 3218 if (log) 3219 log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 3220 "error: expected ';' prior to start of thread suffix: packet " 3221 "contents = '%s'", 3222 __FUNCTION__, packet.GetStringRef().c_str()); 3223 return nullptr; 3224 } 3225 3226 if (!packet.GetBytesLeft()) 3227 return nullptr; 3228 3229 // Parse out thread: portion. 3230 if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) { 3231 if (log) 3232 log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 3233 "error: expected 'thread:' but not found, packet contents = " 3234 "'%s'", 3235 __FUNCTION__, packet.GetStringRef().c_str()); 3236 return nullptr; 3237 } 3238 packet.SetFilePos(packet.GetFilePos() + strlen("thread:")); 3239 const lldb::tid_t tid = packet.GetHexMaxU64(false, 0); 3240 if (tid != 0) 3241 return m_debugged_process_up->GetThreadByID(tid); 3242 3243 return nullptr; 3244 } 3245 3246 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const { 3247 if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) { 3248 // Use whatever the debug process says is the current thread id since the 3249 // protocol either didn't specify or specified we want any/all threads 3250 // marked as the current thread. 3251 if (!m_debugged_process_up) 3252 return LLDB_INVALID_THREAD_ID; 3253 return m_debugged_process_up->GetCurrentThreadID(); 3254 } 3255 // Use the specific current thread id set by the gdb remote protocol. 3256 return m_current_tid; 3257 } 3258 3259 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() { 3260 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3261 return m_next_saved_registers_id++; 3262 } 3263 3264 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() { 3265 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3266 3267 LLDB_LOG(log, "clearing {0} xfer buffers", m_xfer_buffer_map.size()); 3268 m_xfer_buffer_map.clear(); 3269 } 3270 3271 FileSpec 3272 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path, 3273 const ArchSpec &arch) { 3274 if (m_debugged_process_up) { 3275 FileSpec file_spec; 3276 if (m_debugged_process_up 3277 ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec) 3278 .Success()) { 3279 if (FileSystem::Instance().Exists(file_spec)) 3280 return file_spec; 3281 } 3282 } 3283 3284 return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch); 3285 } 3286