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/GDBRemote.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 // Temporarily relax the following for Windows until we can take advantage 221 // of the recently added pty support. This doesn't really affect the use of 222 // lldb-server on Windows. 223 #if !defined(_WIN32) 224 if (llvm::Error Err = m_process_launch_info.SetUpPtyRedirection()) 225 return Status(std::move(Err)); 226 #endif 227 } 228 229 { 230 std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex); 231 assert(!m_debugged_process_up && "lldb-server creating debugged " 232 "process but one already exists"); 233 auto process_or = 234 m_process_factory.Launch(m_process_launch_info, *this, m_mainloop); 235 if (!process_or) 236 return Status(process_or.takeError()); 237 m_debugged_process_up = std::move(*process_or); 238 } 239 240 // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol as 241 // needed. llgs local-process debugging may specify PTY paths, which will 242 // make these file actions non-null process launch -i/e/o will also make 243 // these file actions non-null nullptr means that the traffic is expected to 244 // flow over gdb-remote protocol 245 if (should_forward_stdio) { 246 // nullptr means it's not redirected to file or pty (in case of LLGS local) 247 // at least one of stdio will be transferred pty<->gdb-remote we need to 248 // give the pty master handle to this object to read and/or write 249 LLDB_LOG(log, 250 "pid = {0}: setting up stdout/stderr redirection via $O " 251 "gdb-remote commands", 252 m_debugged_process_up->GetID()); 253 254 // Setup stdout/stderr mapping from inferior to $O 255 auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor(); 256 if (terminal_fd >= 0) { 257 LLDB_LOGF(log, 258 "ProcessGDBRemoteCommunicationServerLLGS::%s setting " 259 "inferior STDIO fd to %d", 260 __FUNCTION__, terminal_fd); 261 Status status = SetSTDIOFileDescriptor(terminal_fd); 262 if (status.Fail()) 263 return status; 264 } else { 265 LLDB_LOGF(log, 266 "ProcessGDBRemoteCommunicationServerLLGS::%s ignoring " 267 "inferior STDIO since terminal fd reported as %d", 268 __FUNCTION__, terminal_fd); 269 } 270 } else { 271 LLDB_LOG(log, 272 "pid = {0} skipping stdout/stderr redirection via $O: inferior " 273 "will communicate over client-provided file descriptors", 274 m_debugged_process_up->GetID()); 275 } 276 277 printf("Launched '%s' as process %" PRIu64 "...\n", 278 m_process_launch_info.GetArguments().GetArgumentAtIndex(0), 279 m_debugged_process_up->GetID()); 280 281 return Status(); 282 } 283 284 Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) { 285 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 286 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, 287 __FUNCTION__, pid); 288 289 // Before we try to attach, make sure we aren't already monitoring something 290 // else. 291 if (m_debugged_process_up && 292 m_debugged_process_up->GetID() != LLDB_INVALID_PROCESS_ID) 293 return Status("cannot attach to process %" PRIu64 294 " when another process with pid %" PRIu64 295 " is being debugged.", 296 pid, m_debugged_process_up->GetID()); 297 298 // Try to attach. 299 auto process_or = m_process_factory.Attach(pid, *this, m_mainloop); 300 if (!process_or) { 301 Status status(process_or.takeError()); 302 llvm::errs() << llvm::formatv("failed to attach to process {0}: {1}", pid, 303 status); 304 return status; 305 } 306 m_debugged_process_up = std::move(*process_or); 307 308 // Setup stdout/stderr mapping from inferior. 309 auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor(); 310 if (terminal_fd >= 0) { 311 LLDB_LOGF(log, 312 "ProcessGDBRemoteCommunicationServerLLGS::%s setting " 313 "inferior STDIO fd to %d", 314 __FUNCTION__, terminal_fd); 315 Status status = SetSTDIOFileDescriptor(terminal_fd); 316 if (status.Fail()) 317 return status; 318 } else { 319 LLDB_LOGF(log, 320 "ProcessGDBRemoteCommunicationServerLLGS::%s ignoring " 321 "inferior STDIO since terminal fd reported as %d", 322 __FUNCTION__, terminal_fd); 323 } 324 325 printf("Attached to process %" PRIu64 "...\n", pid); 326 return Status(); 327 } 328 329 void GDBRemoteCommunicationServerLLGS::InitializeDelegate( 330 NativeProcessProtocol *process) { 331 assert(process && "process cannot be NULL"); 332 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 333 if (log) { 334 LLDB_LOGF(log, 335 "GDBRemoteCommunicationServerLLGS::%s called with " 336 "NativeProcessProtocol pid %" PRIu64 ", current state: %s", 337 __FUNCTION__, process->GetID(), 338 StateAsCString(process->GetState())); 339 } 340 } 341 342 GDBRemoteCommunication::PacketResult 343 GDBRemoteCommunicationServerLLGS::SendWResponse( 344 NativeProcessProtocol *process) { 345 assert(process && "process cannot be NULL"); 346 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 347 348 // send W notification 349 auto wait_status = process->GetExitStatus(); 350 if (!wait_status) { 351 LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status", 352 process->GetID()); 353 354 StreamGDBRemote response; 355 response.PutChar('E'); 356 response.PutHex8(GDBRemoteServerError::eErrorExitStatus); 357 return SendPacketNoLock(response.GetString()); 358 } 359 360 LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(), 361 *wait_status); 362 363 StreamGDBRemote response; 364 response.Format("{0:g}", *wait_status); 365 return SendPacketNoLock(response.GetString()); 366 } 367 368 static void AppendHexValue(StreamString &response, const uint8_t *buf, 369 uint32_t buf_size, bool swap) { 370 int64_t i; 371 if (swap) { 372 for (i = buf_size - 1; i >= 0; i--) 373 response.PutHex8(buf[i]); 374 } else { 375 for (i = 0; i < buf_size; i++) 376 response.PutHex8(buf[i]); 377 } 378 } 379 380 static void WriteRegisterValueInHexFixedWidth( 381 StreamString &response, NativeRegisterContext ®_ctx, 382 const RegisterInfo ®_info, const RegisterValue *reg_value_p, 383 lldb::ByteOrder byte_order) { 384 RegisterValue reg_value; 385 if (!reg_value_p) { 386 Status error = reg_ctx.ReadRegister(®_info, reg_value); 387 if (error.Success()) 388 reg_value_p = ®_value; 389 // else log. 390 } 391 392 if (reg_value_p) { 393 AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(), 394 reg_value_p->GetByteSize(), 395 byte_order == lldb::eByteOrderLittle); 396 } else { 397 // Zero-out any unreadable values. 398 if (reg_info.byte_size > 0) { 399 std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0'); 400 AppendHexValue(response, zeros.data(), zeros.size(), false); 401 } 402 } 403 } 404 405 static JSONObject::SP GetRegistersAsJSON(NativeThreadProtocol &thread) { 406 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 407 408 NativeRegisterContext& reg_ctx = thread.GetRegisterContext(); 409 410 JSONObject::SP register_object_sp = std::make_shared<JSONObject>(); 411 412 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET 413 // Expedite all registers in the first register set (i.e. should be GPRs) 414 // that are not contained in other registers. 415 const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0); 416 if (!reg_set_p) 417 return nullptr; 418 for (const uint32_t *reg_num_p = reg_set_p->registers; 419 *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) { 420 uint32_t reg_num = *reg_num_p; 421 #else 422 // Expedite only a couple of registers until we figure out why sending 423 // registers is expensive. 424 static const uint32_t k_expedited_registers[] = { 425 LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP, 426 LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM}; 427 428 for (const uint32_t *generic_reg_p = k_expedited_registers; 429 *generic_reg_p != LLDB_INVALID_REGNUM; ++generic_reg_p) { 430 uint32_t reg_num = reg_ctx.ConvertRegisterKindToRegisterNumber( 431 eRegisterKindGeneric, *generic_reg_p); 432 if (reg_num == LLDB_INVALID_REGNUM) 433 continue; // Target does not support the given register. 434 #endif 435 436 const RegisterInfo *const reg_info_p = 437 reg_ctx.GetRegisterInfoAtIndex(reg_num); 438 if (reg_info_p == nullptr) { 439 LLDB_LOGF(log, 440 "%s failed to get register info for register index %" PRIu32, 441 __FUNCTION__, reg_num); 442 continue; 443 } 444 445 if (reg_info_p->value_regs != nullptr) 446 continue; // Only expedite registers that are not contained in other 447 // registers. 448 449 RegisterValue reg_value; 450 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 451 if (error.Fail()) { 452 LLDB_LOGF(log, "%s failed to read register '%s' index %" PRIu32 ": %s", 453 __FUNCTION__, 454 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 455 reg_num, error.AsCString()); 456 continue; 457 } 458 459 StreamString stream; 460 WriteRegisterValueInHexFixedWidth(stream, reg_ctx, *reg_info_p, 461 ®_value, lldb::eByteOrderBig); 462 463 register_object_sp->SetObject( 464 llvm::to_string(reg_num), 465 std::make_shared<JSONString>(stream.GetString())); 466 } 467 468 return register_object_sp; 469 } 470 471 static const char *GetStopReasonString(StopReason stop_reason) { 472 switch (stop_reason) { 473 case eStopReasonTrace: 474 return "trace"; 475 case eStopReasonBreakpoint: 476 return "breakpoint"; 477 case eStopReasonWatchpoint: 478 return "watchpoint"; 479 case eStopReasonSignal: 480 return "signal"; 481 case eStopReasonException: 482 return "exception"; 483 case eStopReasonExec: 484 return "exec"; 485 case eStopReasonInstrumentation: 486 case eStopReasonInvalid: 487 case eStopReasonPlanComplete: 488 case eStopReasonThreadExiting: 489 case eStopReasonNone: 490 break; // ignored 491 } 492 return nullptr; 493 } 494 495 static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process, 496 bool abridged) { 497 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 498 499 JSONArray::SP threads_array_sp = std::make_shared<JSONArray>(); 500 501 // Ensure we can get info on the given thread. 502 uint32_t thread_idx = 0; 503 for (NativeThreadProtocol *thread; 504 (thread = process.GetThreadAtIndex(thread_idx)) != nullptr; 505 ++thread_idx) { 506 507 lldb::tid_t tid = thread->GetID(); 508 509 // Grab the reason this thread stopped. 510 struct ThreadStopInfo tid_stop_info; 511 std::string description; 512 if (!thread->GetStopReason(tid_stop_info, description)) 513 return nullptr; 514 515 const int signum = tid_stop_info.details.signal.signo; 516 if (log) { 517 LLDB_LOGF(log, 518 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 519 " tid %" PRIu64 520 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 521 __FUNCTION__, process.GetID(), tid, signum, 522 tid_stop_info.reason, tid_stop_info.details.exception.type); 523 } 524 525 JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>(); 526 threads_array_sp->AppendObject(thread_obj_sp); 527 528 if (!abridged) { 529 if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread)) 530 thread_obj_sp->SetObject("registers", registers_sp); 531 } 532 533 thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid)); 534 if (signum != 0) 535 thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum)); 536 537 const std::string thread_name = thread->GetName(); 538 if (!thread_name.empty()) 539 thread_obj_sp->SetObject("name", 540 std::make_shared<JSONString>(thread_name)); 541 542 if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason)) 543 thread_obj_sp->SetObject("reason", 544 std::make_shared<JSONString>(stop_reason_str)); 545 546 if (!description.empty()) 547 thread_obj_sp->SetObject("description", 548 std::make_shared<JSONString>(description)); 549 550 if ((tid_stop_info.reason == eStopReasonException) && 551 tid_stop_info.details.exception.type) { 552 thread_obj_sp->SetObject( 553 "metype", 554 std::make_shared<JSONNumber>(tid_stop_info.details.exception.type)); 555 556 JSONArray::SP medata_array_sp = std::make_shared<JSONArray>(); 557 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; 558 ++i) { 559 medata_array_sp->AppendObject(std::make_shared<JSONNumber>( 560 tid_stop_info.details.exception.data[i])); 561 } 562 thread_obj_sp->SetObject("medata", medata_array_sp); 563 } 564 565 // TODO: Expedite interesting regions of inferior memory 566 } 567 568 return threads_array_sp; 569 } 570 571 GDBRemoteCommunication::PacketResult 572 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 573 lldb::tid_t tid) { 574 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 575 576 // Ensure we have a debugged process. 577 if (!m_debugged_process_up || 578 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 579 return SendErrorResponse(50); 580 581 LLDB_LOG(log, "preparing packet for pid {0} tid {1}", 582 m_debugged_process_up->GetID(), tid); 583 584 // Ensure we can get info on the given thread. 585 NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid); 586 if (!thread) 587 return SendErrorResponse(51); 588 589 // Grab the reason this thread stopped. 590 struct ThreadStopInfo tid_stop_info; 591 std::string description; 592 if (!thread->GetStopReason(tid_stop_info, description)) 593 return SendErrorResponse(52); 594 595 // FIXME implement register handling for exec'd inferiors. 596 // if (tid_stop_info.reason == eStopReasonExec) { 597 // const bool force = true; 598 // InitializeRegisters(force); 599 // } 600 601 StreamString response; 602 // Output the T packet with the thread 603 response.PutChar('T'); 604 int signum = tid_stop_info.details.signal.signo; 605 LLDB_LOG( 606 log, 607 "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}", 608 m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info.reason), 609 tid_stop_info.details.exception.type); 610 611 // Print the signal number. 612 response.PutHex8(signum & 0xff); 613 614 // Include the tid. 615 response.Printf("thread:%" PRIx64 ";", tid); 616 617 // Include the thread name if there is one. 618 const std::string thread_name = thread->GetName(); 619 if (!thread_name.empty()) { 620 size_t thread_name_len = thread_name.length(); 621 622 if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) { 623 response.PutCString("name:"); 624 response.PutCString(thread_name); 625 } else { 626 // The thread name contains special chars, send as hex bytes. 627 response.PutCString("hexname:"); 628 response.PutStringAsRawHex8(thread_name); 629 } 630 response.PutChar(';'); 631 } 632 633 // If a 'QListThreadsInStopReply' was sent to enable this feature, we will 634 // send all thread IDs back in the "threads" key whose value is a list of hex 635 // thread IDs separated by commas: 636 // "threads:10a,10b,10c;" 637 // This will save the debugger from having to send a pair of qfThreadInfo and 638 // qsThreadInfo packets, but it also might take a lot of room in the stop 639 // reply packet, so it must be enabled only on systems where there are no 640 // limits on packet lengths. 641 if (m_list_threads_in_stop_reply) { 642 response.PutCString("threads:"); 643 644 uint32_t thread_index = 0; 645 NativeThreadProtocol *listed_thread; 646 for (listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index); 647 listed_thread; ++thread_index, 648 listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) { 649 if (thread_index > 0) 650 response.PutChar(','); 651 response.Printf("%" PRIx64, listed_thread->GetID()); 652 } 653 response.PutChar(';'); 654 655 // Include JSON info that describes the stop reason for any threads that 656 // actually have stop reasons. We use the new "jstopinfo" key whose values 657 // is hex ascii JSON that contains the thread IDs thread stop info only for 658 // threads that have stop reasons. Only send this if we have more than one 659 // thread otherwise this packet has all the info it needs. 660 if (thread_index > 0) { 661 const bool threads_with_valid_stop_info_only = true; 662 JSONArray::SP threads_info_sp = GetJSONThreadsInfo( 663 *m_debugged_process_up, threads_with_valid_stop_info_only); 664 if (threads_info_sp) { 665 response.PutCString("jstopinfo:"); 666 StreamString unescaped_response; 667 threads_info_sp->Write(unescaped_response); 668 response.PutStringAsRawHex8(unescaped_response.GetData()); 669 response.PutChar(';'); 670 } else 671 LLDB_LOG(log, "failed to prepare a jstopinfo field for pid {0}", 672 m_debugged_process_up->GetID()); 673 } 674 675 uint32_t i = 0; 676 response.PutCString("thread-pcs"); 677 char delimiter = ':'; 678 for (NativeThreadProtocol *thread; 679 (thread = m_debugged_process_up->GetThreadAtIndex(i)) != nullptr; 680 ++i) { 681 NativeRegisterContext& reg_ctx = thread->GetRegisterContext(); 682 683 uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber( 684 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 685 const RegisterInfo *const reg_info_p = 686 reg_ctx.GetRegisterInfoAtIndex(reg_to_read); 687 688 RegisterValue reg_value; 689 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 690 if (error.Fail()) { 691 LLDB_LOGF(log, "%s failed to read register '%s' index %" PRIu32 ": %s", 692 __FUNCTION__, 693 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 694 reg_to_read, error.AsCString()); 695 continue; 696 } 697 698 response.PutChar(delimiter); 699 delimiter = ','; 700 WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p, 701 ®_value, endian::InlHostByteOrder()); 702 } 703 704 response.PutChar(';'); 705 } 706 707 // 708 // Expedite registers. 709 // 710 711 // Grab the register context. 712 NativeRegisterContext& reg_ctx = thread->GetRegisterContext(); 713 // Expedite all registers in the first register set (i.e. should be GPRs) 714 // that are not contained in other registers. 715 const RegisterSet *reg_set_p; 716 if (reg_ctx.GetRegisterSetCount() > 0 && 717 ((reg_set_p = reg_ctx.GetRegisterSet(0)) != nullptr)) { 718 LLDB_LOGF(log, 719 "GDBRemoteCommunicationServerLLGS::%s expediting registers " 720 "from set '%s' (registers set count: %zu)", 721 __FUNCTION__, reg_set_p->name ? reg_set_p->name : "<unnamed-set>", 722 reg_set_p->num_registers); 723 724 for (const uint32_t *reg_num_p = reg_set_p->registers; 725 *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) { 726 const RegisterInfo *const reg_info_p = 727 reg_ctx.GetRegisterInfoAtIndex(*reg_num_p); 728 if (reg_info_p == nullptr) { 729 LLDB_LOGF(log, 730 "GDBRemoteCommunicationServerLLGS::%s failed to get " 731 "register info for register set '%s', register index " 732 "%" PRIu32, 733 __FUNCTION__, 734 reg_set_p->name ? reg_set_p->name : "<unnamed-set>", 735 *reg_num_p); 736 } else if (reg_info_p->value_regs == nullptr) { 737 // Only expediate registers that are not contained in other registers. 738 RegisterValue reg_value; 739 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 740 if (error.Success()) { 741 response.Printf("%.02x:", *reg_num_p); 742 WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p, 743 ®_value, lldb::eByteOrderBig); 744 response.PutChar(';'); 745 } else { 746 LLDB_LOGF(log, 747 "GDBRemoteCommunicationServerLLGS::%s failed to read " 748 "register '%s' index %" PRIu32 ": %s", 749 __FUNCTION__, 750 reg_info_p->name ? reg_info_p->name : "<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 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 791 792 PacketResult result = SendStopReasonForState(StateType::eStateExited); 793 if (result != PacketResult::Success) { 794 LLDB_LOGF(log, 795 "GDBRemoteCommunicationServerLLGS::%s failed to send stop " 796 "notification for PID %" PRIu64 ", state: eStateExited", 797 __FUNCTION__, process->GetID()); 798 } 799 800 // Close the pipe to the inferior terminal i/o if we launched it and set one 801 // up. 802 MaybeCloseInferiorTerminalConnection(); 803 804 // We are ready to exit the debug monitor. 805 m_exit_now = true; 806 m_mainloop.RequestTermination(); 807 } 808 809 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped( 810 NativeProcessProtocol *process) { 811 assert(process && "process cannot be NULL"); 812 813 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 814 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 815 816 // Send the stop reason unless this is the stop after the launch or attach. 817 switch (m_inferior_prev_state) { 818 case eStateLaunching: 819 case eStateAttaching: 820 // Don't send anything per debugserver behavior. 821 break; 822 default: 823 // In all other cases, send the stop reason. 824 PacketResult result = SendStopReasonForState(StateType::eStateStopped); 825 if (result != PacketResult::Success) { 826 LLDB_LOGF(log, 827 "GDBRemoteCommunicationServerLLGS::%s failed to send stop " 828 "notification for PID %" PRIu64 ", state: eStateExited", 829 __FUNCTION__, process->GetID()); 830 } 831 break; 832 } 833 } 834 835 void GDBRemoteCommunicationServerLLGS::ProcessStateChanged( 836 NativeProcessProtocol *process, lldb::StateType state) { 837 assert(process && "process cannot be NULL"); 838 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 839 if (log) { 840 LLDB_LOGF(log, 841 "GDBRemoteCommunicationServerLLGS::%s called with " 842 "NativeProcessProtocol pid %" PRIu64 ", state: %s", 843 __FUNCTION__, process->GetID(), StateAsCString(state)); 844 } 845 846 switch (state) { 847 case StateType::eStateRunning: 848 StartSTDIOForwarding(); 849 break; 850 851 case StateType::eStateStopped: 852 // Make sure we get all of the pending stdout/stderr from the inferior and 853 // send it to the lldb host before we send the state change notification 854 SendProcessOutput(); 855 // Then stop the forwarding, so that any late output (see llvm.org/pr25652) 856 // does not interfere with our protocol. 857 StopSTDIOForwarding(); 858 HandleInferiorState_Stopped(process); 859 break; 860 861 case StateType::eStateExited: 862 // Same as above 863 SendProcessOutput(); 864 StopSTDIOForwarding(); 865 HandleInferiorState_Exited(process); 866 break; 867 868 default: 869 if (log) { 870 LLDB_LOGF(log, 871 "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 LLDB_LOGF(log, 892 "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 LLDB_LOGF(log, 912 "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 LLDB_LOGF(log, 986 "GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio " 987 "forwarding: %s", 988 __FUNCTION__, error.AsCString()); 989 } 990 } 991 992 void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() { 993 m_stdio_handle_up.reset(); 994 } 995 996 void GDBRemoteCommunicationServerLLGS::SendProcessOutput() { 997 char buffer[1024]; 998 ConnectionStatus status; 999 Status error; 1000 while (true) { 1001 size_t bytes_read = m_stdio_communication.Read( 1002 buffer, sizeof buffer, std::chrono::microseconds(0), status, &error); 1003 switch (status) { 1004 case eConnectionStatusSuccess: 1005 SendONotification(buffer, bytes_read); 1006 break; 1007 case eConnectionStatusLostConnection: 1008 case eConnectionStatusEndOfFile: 1009 case eConnectionStatusError: 1010 case eConnectionStatusNoConnection: 1011 if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)) 1012 LLDB_LOGF(log, 1013 "GDBRemoteCommunicationServerLLGS::%s Stopping stdio " 1014 "forwarding as communication returned status %d (error: " 1015 "%s)", 1016 __FUNCTION__, status, error.AsCString()); 1017 m_stdio_handle_up.reset(); 1018 return; 1019 1020 case eConnectionStatusInterrupted: 1021 case eConnectionStatusTimedOut: 1022 return; 1023 } 1024 } 1025 } 1026 1027 GDBRemoteCommunication::PacketResult 1028 GDBRemoteCommunicationServerLLGS::Handle_jTraceStart( 1029 StringExtractorGDBRemote &packet) { 1030 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1031 // Fail if we don't have a current process. 1032 if (!m_debugged_process_up || 1033 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1034 return SendErrorResponse(68); 1035 1036 if (!packet.ConsumeFront("jTraceStart:")) 1037 return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet "); 1038 1039 TraceOptions options; 1040 uint64_t type = std::numeric_limits<uint64_t>::max(); 1041 uint64_t buffersize = std::numeric_limits<uint64_t>::max(); 1042 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1043 uint64_t metabuffersize = std::numeric_limits<uint64_t>::max(); 1044 1045 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1046 1047 if (!json_object || 1048 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1049 return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet "); 1050 1051 auto json_dict = json_object->GetAsDictionary(); 1052 1053 json_dict->GetValueForKeyAsInteger("metabuffersize", metabuffersize); 1054 options.setMetaDataBufferSize(metabuffersize); 1055 1056 json_dict->GetValueForKeyAsInteger("buffersize", buffersize); 1057 options.setTraceBufferSize(buffersize); 1058 1059 json_dict->GetValueForKeyAsInteger("type", type); 1060 options.setType(static_cast<lldb::TraceType>(type)); 1061 1062 json_dict->GetValueForKeyAsInteger("threadid", tid); 1063 options.setThreadID(tid); 1064 1065 StructuredData::ObjectSP custom_params_sp = 1066 json_dict->GetValueForKey("params"); 1067 if (custom_params_sp && 1068 custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary) 1069 return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet "); 1070 1071 options.setTraceParams( 1072 static_pointer_cast<StructuredData::Dictionary>(custom_params_sp)); 1073 1074 if (buffersize == std::numeric_limits<uint64_t>::max() || 1075 type != lldb::TraceType::eTraceTypeProcessorTrace) { 1076 LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize, 1077 type); 1078 return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet "); 1079 } 1080 1081 Status error; 1082 lldb::user_id_t uid = LLDB_INVALID_UID; 1083 uid = m_debugged_process_up->StartTrace(options, error); 1084 LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError()); 1085 if (error.Fail()) 1086 return SendErrorResponse(error); 1087 1088 StreamGDBRemote response; 1089 response.Printf("%" PRIx64, uid); 1090 return SendPacketNoLock(response.GetString()); 1091 } 1092 1093 GDBRemoteCommunication::PacketResult 1094 GDBRemoteCommunicationServerLLGS::Handle_jTraceStop( 1095 StringExtractorGDBRemote &packet) { 1096 // Fail if we don't have a current process. 1097 if (!m_debugged_process_up || 1098 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1099 return SendErrorResponse(68); 1100 1101 if (!packet.ConsumeFront("jTraceStop:")) 1102 return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet "); 1103 1104 lldb::user_id_t uid = LLDB_INVALID_UID; 1105 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1106 1107 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1108 1109 if (!json_object || 1110 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1111 return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet "); 1112 1113 auto json_dict = json_object->GetAsDictionary(); 1114 1115 if (!json_dict->GetValueForKeyAsInteger("traceid", uid)) 1116 return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet "); 1117 1118 json_dict->GetValueForKeyAsInteger("threadid", tid); 1119 1120 Status error = m_debugged_process_up->StopTrace(uid, tid); 1121 1122 if (error.Fail()) 1123 return SendErrorResponse(error); 1124 1125 return SendOKResponse(); 1126 } 1127 1128 GDBRemoteCommunication::PacketResult 1129 GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead( 1130 StringExtractorGDBRemote &packet) { 1131 1132 // Fail if we don't have a current process. 1133 if (!m_debugged_process_up || 1134 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1135 return SendErrorResponse(68); 1136 1137 if (!packet.ConsumeFront("jTraceConfigRead:")) 1138 return SendIllFormedResponse(packet, 1139 "jTraceConfigRead: Ill formed packet "); 1140 1141 lldb::user_id_t uid = LLDB_INVALID_UID; 1142 lldb::tid_t threadid = LLDB_INVALID_THREAD_ID; 1143 1144 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1145 1146 if (!json_object || 1147 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1148 return SendIllFormedResponse(packet, 1149 "jTraceConfigRead: Ill formed packet "); 1150 1151 auto json_dict = json_object->GetAsDictionary(); 1152 1153 if (!json_dict->GetValueForKeyAsInteger("traceid", uid)) 1154 return SendIllFormedResponse(packet, 1155 "jTraceConfigRead: Ill formed packet "); 1156 1157 json_dict->GetValueForKeyAsInteger("threadid", threadid); 1158 1159 TraceOptions options; 1160 StreamGDBRemote response; 1161 1162 options.setThreadID(threadid); 1163 Status error = m_debugged_process_up->GetTraceConfig(uid, options); 1164 1165 if (error.Fail()) 1166 return SendErrorResponse(error); 1167 1168 StreamGDBRemote escaped_response; 1169 StructuredData::Dictionary json_packet; 1170 1171 json_packet.AddIntegerItem("type", options.getType()); 1172 json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize()); 1173 json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize()); 1174 1175 StructuredData::DictionarySP custom_params = options.getTraceParams(); 1176 if (custom_params) 1177 json_packet.AddItem("params", custom_params); 1178 1179 StreamString json_string; 1180 json_packet.Dump(json_string, false); 1181 escaped_response.PutEscapedBytes(json_string.GetData(), 1182 json_string.GetSize()); 1183 return SendPacketNoLock(escaped_response.GetString()); 1184 } 1185 1186 GDBRemoteCommunication::PacketResult 1187 GDBRemoteCommunicationServerLLGS::Handle_jTraceRead( 1188 StringExtractorGDBRemote &packet) { 1189 1190 // Fail if we don't have a current process. 1191 if (!m_debugged_process_up || 1192 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1193 return SendErrorResponse(68); 1194 1195 enum PacketType { MetaData, BufferData }; 1196 PacketType tracetype = MetaData; 1197 1198 if (packet.ConsumeFront("jTraceBufferRead:")) 1199 tracetype = BufferData; 1200 else if (packet.ConsumeFront("jTraceMetaRead:")) 1201 tracetype = MetaData; 1202 else { 1203 return SendIllFormedResponse(packet, "jTrace: Ill formed packet "); 1204 } 1205 1206 lldb::user_id_t uid = LLDB_INVALID_UID; 1207 1208 uint64_t byte_count = std::numeric_limits<uint64_t>::max(); 1209 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1210 uint64_t offset = std::numeric_limits<uint64_t>::max(); 1211 1212 auto json_object = StructuredData::ParseJSON(packet.Peek()); 1213 1214 if (!json_object || 1215 json_object->GetType() != lldb::eStructuredDataTypeDictionary) 1216 return SendIllFormedResponse(packet, "jTrace: Ill formed packet "); 1217 1218 auto json_dict = json_object->GetAsDictionary(); 1219 1220 if (!json_dict->GetValueForKeyAsInteger("traceid", uid) || 1221 !json_dict->GetValueForKeyAsInteger("offset", offset) || 1222 !json_dict->GetValueForKeyAsInteger("buffersize", byte_count)) 1223 return SendIllFormedResponse(packet, "jTrace: Ill formed packet "); 1224 1225 json_dict->GetValueForKeyAsInteger("threadid", tid); 1226 1227 // Allocate the response buffer. 1228 std::unique_ptr<uint8_t[]> buffer (new (std::nothrow) uint8_t[byte_count]); 1229 if (!buffer) 1230 return SendErrorResponse(0x78); 1231 1232 StreamGDBRemote response; 1233 Status error; 1234 llvm::MutableArrayRef<uint8_t> buf(buffer.get(), byte_count); 1235 1236 if (tracetype == BufferData) 1237 error = m_debugged_process_up->GetData(uid, tid, buf, offset); 1238 else if (tracetype == MetaData) 1239 error = m_debugged_process_up->GetMetaData(uid, tid, buf, offset); 1240 1241 if (error.Fail()) 1242 return SendErrorResponse(error); 1243 1244 for (auto i : buf) 1245 response.PutHex8(i); 1246 1247 StreamGDBRemote escaped_response; 1248 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 1249 return SendPacketNoLock(escaped_response.GetString()); 1250 } 1251 1252 GDBRemoteCommunication::PacketResult 1253 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo( 1254 StringExtractorGDBRemote &packet) { 1255 // Fail if we don't have a current process. 1256 if (!m_debugged_process_up || 1257 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1258 return SendErrorResponse(68); 1259 1260 lldb::pid_t pid = m_debugged_process_up->GetID(); 1261 1262 if (pid == LLDB_INVALID_PROCESS_ID) 1263 return SendErrorResponse(1); 1264 1265 ProcessInstanceInfo proc_info; 1266 if (!Host::GetProcessInfo(pid, proc_info)) 1267 return SendErrorResponse(1); 1268 1269 StreamString response; 1270 CreateProcessInfoResponse_DebugServerStyle(proc_info, response); 1271 return SendPacketNoLock(response.GetString()); 1272 } 1273 1274 GDBRemoteCommunication::PacketResult 1275 GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) { 1276 // Fail if we don't have a current process. 1277 if (!m_debugged_process_up || 1278 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1279 return SendErrorResponse(68); 1280 1281 // Make sure we set the current thread so g and p packets return the data the 1282 // gdb will expect. 1283 lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID(); 1284 SetCurrentThreadID(tid); 1285 1286 NativeThreadProtocol *thread = m_debugged_process_up->GetCurrentThread(); 1287 if (!thread) 1288 return SendErrorResponse(69); 1289 1290 StreamString response; 1291 response.Printf("QC%" PRIx64, thread->GetID()); 1292 1293 return SendPacketNoLock(response.GetString()); 1294 } 1295 1296 GDBRemoteCommunication::PacketResult 1297 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) { 1298 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1299 1300 StopSTDIOForwarding(); 1301 1302 if (!m_debugged_process_up) { 1303 LLDB_LOG(log, "No debugged process found."); 1304 return PacketResult::Success; 1305 } 1306 1307 Status error = m_debugged_process_up->Kill(); 1308 if (error.Fail()) 1309 LLDB_LOG(log, "Failed to kill debugged process {0}: {1}", 1310 m_debugged_process_up->GetID(), error); 1311 1312 // No OK response for kill packet. 1313 // return SendOKResponse (); 1314 return PacketResult::Success; 1315 } 1316 1317 GDBRemoteCommunication::PacketResult 1318 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR( 1319 StringExtractorGDBRemote &packet) { 1320 packet.SetFilePos(::strlen("QSetDisableASLR:")); 1321 if (packet.GetU32(0)) 1322 m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR); 1323 else 1324 m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR); 1325 return SendOKResponse(); 1326 } 1327 1328 GDBRemoteCommunication::PacketResult 1329 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir( 1330 StringExtractorGDBRemote &packet) { 1331 packet.SetFilePos(::strlen("QSetWorkingDir:")); 1332 std::string path; 1333 packet.GetHexByteString(path); 1334 m_process_launch_info.SetWorkingDirectory(FileSpec(path)); 1335 return SendOKResponse(); 1336 } 1337 1338 GDBRemoteCommunication::PacketResult 1339 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir( 1340 StringExtractorGDBRemote &packet) { 1341 FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()}; 1342 if (working_dir) { 1343 StreamString response; 1344 response.PutStringAsRawHex8(working_dir.GetCString()); 1345 return SendPacketNoLock(response.GetString()); 1346 } 1347 1348 return SendErrorResponse(14); 1349 } 1350 1351 GDBRemoteCommunication::PacketResult 1352 GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) { 1353 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 1354 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1355 1356 // Ensure we have a native process. 1357 if (!m_debugged_process_up) { 1358 LLDB_LOGF(log, 1359 "GDBRemoteCommunicationServerLLGS::%s no debugged process " 1360 "shared pointer", 1361 __FUNCTION__); 1362 return SendErrorResponse(0x36); 1363 } 1364 1365 // Pull out the signal number. 1366 packet.SetFilePos(::strlen("C")); 1367 if (packet.GetBytesLeft() < 1) { 1368 // Shouldn't be using a C without a signal. 1369 return SendIllFormedResponse(packet, "C packet specified without signal."); 1370 } 1371 const uint32_t signo = 1372 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1373 if (signo == std::numeric_limits<uint32_t>::max()) 1374 return SendIllFormedResponse(packet, "failed to parse signal number"); 1375 1376 // Handle optional continue address. 1377 if (packet.GetBytesLeft() > 0) { 1378 // FIXME add continue at address support for $C{signo}[;{continue-address}]. 1379 if (*packet.Peek() == ';') 1380 return SendUnimplementedResponse(packet.GetStringRef().data()); 1381 else 1382 return SendIllFormedResponse( 1383 packet, "unexpected content after $C{signal-number}"); 1384 } 1385 1386 ResumeActionList resume_actions(StateType::eStateRunning, 1387 LLDB_INVALID_SIGNAL_NUMBER); 1388 Status error; 1389 1390 // We have two branches: what to do if a continue thread is specified (in 1391 // which case we target sending the signal to that thread), or when we don't 1392 // have a continue thread set (in which case we send a signal to the 1393 // process). 1394 1395 // TODO discuss with Greg Clayton, make sure this makes sense. 1396 1397 lldb::tid_t signal_tid = GetContinueThreadID(); 1398 if (signal_tid != LLDB_INVALID_THREAD_ID) { 1399 // The resume action for the continue thread (or all threads if a continue 1400 // thread is not set). 1401 ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning, 1402 static_cast<int>(signo)}; 1403 1404 // Add the action for the continue thread (or all threads when the continue 1405 // thread isn't present). 1406 resume_actions.Append(action); 1407 } else { 1408 // Send the signal to the process since we weren't targeting a specific 1409 // continue thread with the signal. 1410 error = m_debugged_process_up->Signal(signo); 1411 if (error.Fail()) { 1412 LLDB_LOG(log, "failed to send signal for process {0}: {1}", 1413 m_debugged_process_up->GetID(), error); 1414 1415 return SendErrorResponse(0x52); 1416 } 1417 } 1418 1419 // Resume the threads. 1420 error = m_debugged_process_up->Resume(resume_actions); 1421 if (error.Fail()) { 1422 LLDB_LOG(log, "failed to resume threads for process {0}: {1}", 1423 m_debugged_process_up->GetID(), error); 1424 1425 return SendErrorResponse(0x38); 1426 } 1427 1428 // Don't send an "OK" packet; response is the stopped/exited message. 1429 return PacketResult::Success; 1430 } 1431 1432 GDBRemoteCommunication::PacketResult 1433 GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) { 1434 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 1435 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1436 1437 packet.SetFilePos(packet.GetFilePos() + ::strlen("c")); 1438 1439 // For now just support all continue. 1440 const bool has_continue_address = (packet.GetBytesLeft() > 0); 1441 if (has_continue_address) { 1442 LLDB_LOG(log, "not implemented for c[address] variant [{0} remains]", 1443 packet.Peek()); 1444 return SendUnimplementedResponse(packet.GetStringRef().data()); 1445 } 1446 1447 // Ensure we have a native process. 1448 if (!m_debugged_process_up) { 1449 LLDB_LOGF(log, 1450 "GDBRemoteCommunicationServerLLGS::%s no debugged process " 1451 "shared pointer", 1452 __FUNCTION__); 1453 return SendErrorResponse(0x36); 1454 } 1455 1456 // Build the ResumeActionList 1457 ResumeActionList actions(StateType::eStateRunning, 1458 LLDB_INVALID_SIGNAL_NUMBER); 1459 1460 Status error = m_debugged_process_up->Resume(actions); 1461 if (error.Fail()) { 1462 LLDB_LOG(log, "c failed for process {0}: {1}", 1463 m_debugged_process_up->GetID(), error); 1464 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1465 } 1466 1467 LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID()); 1468 // No response required from continue. 1469 return PacketResult::Success; 1470 } 1471 1472 GDBRemoteCommunication::PacketResult 1473 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions( 1474 StringExtractorGDBRemote &packet) { 1475 StreamString response; 1476 response.Printf("vCont;c;C;s;S"); 1477 1478 return SendPacketNoLock(response.GetString()); 1479 } 1480 1481 GDBRemoteCommunication::PacketResult 1482 GDBRemoteCommunicationServerLLGS::Handle_vCont( 1483 StringExtractorGDBRemote &packet) { 1484 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1485 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s handling vCont packet", 1486 __FUNCTION__); 1487 1488 packet.SetFilePos(::strlen("vCont")); 1489 1490 if (packet.GetBytesLeft() == 0) { 1491 LLDB_LOGF(log, 1492 "GDBRemoteCommunicationServerLLGS::%s missing action from " 1493 "vCont package", 1494 __FUNCTION__); 1495 return SendIllFormedResponse(packet, "Missing action from vCont package"); 1496 } 1497 1498 // Check if this is all continue (no options or ";c"). 1499 if (::strcmp(packet.Peek(), ";c") == 0) { 1500 // Move past the ';', then do a simple 'c'. 1501 packet.SetFilePos(packet.GetFilePos() + 1); 1502 return Handle_c(packet); 1503 } else if (::strcmp(packet.Peek(), ";s") == 0) { 1504 // Move past the ';', then do a simple 's'. 1505 packet.SetFilePos(packet.GetFilePos() + 1); 1506 return Handle_s(packet); 1507 } 1508 1509 // Ensure we have a native process. 1510 if (!m_debugged_process_up) { 1511 LLDB_LOG(log, "no debugged process"); 1512 return SendErrorResponse(0x36); 1513 } 1514 1515 ResumeActionList thread_actions; 1516 1517 while (packet.GetBytesLeft() && *packet.Peek() == ';') { 1518 // Skip the semi-colon. 1519 packet.GetChar(); 1520 1521 // Build up the thread action. 1522 ResumeAction thread_action; 1523 thread_action.tid = LLDB_INVALID_THREAD_ID; 1524 thread_action.state = eStateInvalid; 1525 thread_action.signal = LLDB_INVALID_SIGNAL_NUMBER; 1526 1527 const char action = packet.GetChar(); 1528 switch (action) { 1529 case 'C': 1530 thread_action.signal = packet.GetHexMaxU32(false, 0); 1531 if (thread_action.signal == 0) 1532 return SendIllFormedResponse( 1533 packet, "Could not parse signal in vCont packet C action"); 1534 LLVM_FALLTHROUGH; 1535 1536 case 'c': 1537 // Continue 1538 thread_action.state = eStateRunning; 1539 break; 1540 1541 case 'S': 1542 thread_action.signal = packet.GetHexMaxU32(false, 0); 1543 if (thread_action.signal == 0) 1544 return SendIllFormedResponse( 1545 packet, "Could not parse signal in vCont packet S action"); 1546 LLVM_FALLTHROUGH; 1547 1548 case 's': 1549 // Step 1550 thread_action.state = eStateStepping; 1551 break; 1552 1553 default: 1554 return SendIllFormedResponse(packet, "Unsupported vCont action"); 1555 break; 1556 } 1557 1558 // Parse out optional :{thread-id} value. 1559 if (packet.GetBytesLeft() && (*packet.Peek() == ':')) { 1560 // Consume the separator. 1561 packet.GetChar(); 1562 1563 thread_action.tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID); 1564 if (thread_action.tid == LLDB_INVALID_THREAD_ID) 1565 return SendIllFormedResponse( 1566 packet, "Could not parse thread number in vCont packet"); 1567 } 1568 1569 thread_actions.Append(thread_action); 1570 } 1571 1572 Status error = m_debugged_process_up->Resume(thread_actions); 1573 if (error.Fail()) { 1574 LLDB_LOG(log, "vCont failed for process {0}: {1}", 1575 m_debugged_process_up->GetID(), error); 1576 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1577 } 1578 1579 LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID()); 1580 // No response required from vCont. 1581 return PacketResult::Success; 1582 } 1583 1584 void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) { 1585 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1586 LLDB_LOG(log, "setting current thread id to {0}", tid); 1587 1588 m_current_tid = tid; 1589 if (m_debugged_process_up) 1590 m_debugged_process_up->SetCurrentThreadID(m_current_tid); 1591 } 1592 1593 void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) { 1594 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1595 LLDB_LOG(log, "setting continue thread id to {0}", tid); 1596 1597 m_continue_tid = tid; 1598 } 1599 1600 GDBRemoteCommunication::PacketResult 1601 GDBRemoteCommunicationServerLLGS::Handle_stop_reason( 1602 StringExtractorGDBRemote &packet) { 1603 // Handle the $? gdbremote command. 1604 1605 // If no process, indicate error 1606 if (!m_debugged_process_up) 1607 return SendErrorResponse(02); 1608 1609 return SendStopReasonForState(m_debugged_process_up->GetState()); 1610 } 1611 1612 GDBRemoteCommunication::PacketResult 1613 GDBRemoteCommunicationServerLLGS::SendStopReasonForState( 1614 lldb::StateType process_state) { 1615 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1616 1617 switch (process_state) { 1618 case eStateAttaching: 1619 case eStateLaunching: 1620 case eStateRunning: 1621 case eStateStepping: 1622 case eStateDetached: 1623 // NOTE: gdb protocol doc looks like it should return $OK 1624 // when everything is running (i.e. no stopped result). 1625 return PacketResult::Success; // Ignore 1626 1627 case eStateSuspended: 1628 case eStateStopped: 1629 case eStateCrashed: { 1630 lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID(); 1631 // Make sure we set the current thread so g and p packets return the data 1632 // the gdb will expect. 1633 SetCurrentThreadID(tid); 1634 return SendStopReplyPacketForThread(tid); 1635 } 1636 1637 case eStateInvalid: 1638 case eStateUnloaded: 1639 case eStateExited: 1640 return SendWResponse(m_debugged_process_up.get()); 1641 1642 default: 1643 LLDB_LOG(log, "pid {0}, current state reporting not handled: {1}", 1644 m_debugged_process_up->GetID(), process_state); 1645 break; 1646 } 1647 1648 return SendErrorResponse(0); 1649 } 1650 1651 GDBRemoteCommunication::PacketResult 1652 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo( 1653 StringExtractorGDBRemote &packet) { 1654 // Fail if we don't have a current process. 1655 if (!m_debugged_process_up || 1656 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 1657 return SendErrorResponse(68); 1658 1659 // Ensure we have a thread. 1660 NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0); 1661 if (!thread) 1662 return SendErrorResponse(69); 1663 1664 // Get the register context for the first thread. 1665 NativeRegisterContext ®_context = thread->GetRegisterContext(); 1666 1667 // Parse out the register number from the request. 1668 packet.SetFilePos(strlen("qRegisterInfo")); 1669 const uint32_t reg_index = 1670 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1671 if (reg_index == std::numeric_limits<uint32_t>::max()) 1672 return SendErrorResponse(69); 1673 1674 // Return the end of registers response if we've iterated one past the end of 1675 // the register set. 1676 if (reg_index >= reg_context.GetUserRegisterCount()) 1677 return SendErrorResponse(69); 1678 1679 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 1680 if (!reg_info) 1681 return SendErrorResponse(69); 1682 1683 // Build the reginfos response. 1684 StreamGDBRemote response; 1685 1686 response.PutCString("name:"); 1687 response.PutCString(reg_info->name); 1688 response.PutChar(';'); 1689 1690 if (reg_info->alt_name && reg_info->alt_name[0]) { 1691 response.PutCString("alt-name:"); 1692 response.PutCString(reg_info->alt_name); 1693 response.PutChar(';'); 1694 } 1695 1696 response.Printf("bitsize:%" PRIu32 ";offset:%" PRIu32 ";", 1697 reg_info->byte_size * 8, reg_info->byte_offset); 1698 1699 switch (reg_info->encoding) { 1700 case eEncodingUint: 1701 response.PutCString("encoding:uint;"); 1702 break; 1703 case eEncodingSint: 1704 response.PutCString("encoding:sint;"); 1705 break; 1706 case eEncodingIEEE754: 1707 response.PutCString("encoding:ieee754;"); 1708 break; 1709 case eEncodingVector: 1710 response.PutCString("encoding:vector;"); 1711 break; 1712 default: 1713 break; 1714 } 1715 1716 switch (reg_info->format) { 1717 case eFormatBinary: 1718 response.PutCString("format:binary;"); 1719 break; 1720 case eFormatDecimal: 1721 response.PutCString("format:decimal;"); 1722 break; 1723 case eFormatHex: 1724 response.PutCString("format:hex;"); 1725 break; 1726 case eFormatFloat: 1727 response.PutCString("format:float;"); 1728 break; 1729 case eFormatVectorOfSInt8: 1730 response.PutCString("format:vector-sint8;"); 1731 break; 1732 case eFormatVectorOfUInt8: 1733 response.PutCString("format:vector-uint8;"); 1734 break; 1735 case eFormatVectorOfSInt16: 1736 response.PutCString("format:vector-sint16;"); 1737 break; 1738 case eFormatVectorOfUInt16: 1739 response.PutCString("format:vector-uint16;"); 1740 break; 1741 case eFormatVectorOfSInt32: 1742 response.PutCString("format:vector-sint32;"); 1743 break; 1744 case eFormatVectorOfUInt32: 1745 response.PutCString("format:vector-uint32;"); 1746 break; 1747 case eFormatVectorOfFloat32: 1748 response.PutCString("format:vector-float32;"); 1749 break; 1750 case eFormatVectorOfUInt64: 1751 response.PutCString("format:vector-uint64;"); 1752 break; 1753 case eFormatVectorOfUInt128: 1754 response.PutCString("format:vector-uint128;"); 1755 break; 1756 default: 1757 break; 1758 }; 1759 1760 const char *const register_set_name = 1761 reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index); 1762 if (register_set_name) { 1763 response.PutCString("set:"); 1764 response.PutCString(register_set_name); 1765 response.PutChar(';'); 1766 } 1767 1768 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != 1769 LLDB_INVALID_REGNUM) 1770 response.Printf("ehframe:%" PRIu32 ";", 1771 reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 1772 1773 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 1774 response.Printf("dwarf:%" PRIu32 ";", 1775 reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 1776 1777 switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) { 1778 case LLDB_REGNUM_GENERIC_PC: 1779 response.PutCString("generic:pc;"); 1780 break; 1781 case LLDB_REGNUM_GENERIC_SP: 1782 response.PutCString("generic:sp;"); 1783 break; 1784 case LLDB_REGNUM_GENERIC_FP: 1785 response.PutCString("generic:fp;"); 1786 break; 1787 case LLDB_REGNUM_GENERIC_RA: 1788 response.PutCString("generic:ra;"); 1789 break; 1790 case LLDB_REGNUM_GENERIC_FLAGS: 1791 response.PutCString("generic:flags;"); 1792 break; 1793 case LLDB_REGNUM_GENERIC_ARG1: 1794 response.PutCString("generic:arg1;"); 1795 break; 1796 case LLDB_REGNUM_GENERIC_ARG2: 1797 response.PutCString("generic:arg2;"); 1798 break; 1799 case LLDB_REGNUM_GENERIC_ARG3: 1800 response.PutCString("generic:arg3;"); 1801 break; 1802 case LLDB_REGNUM_GENERIC_ARG4: 1803 response.PutCString("generic:arg4;"); 1804 break; 1805 case LLDB_REGNUM_GENERIC_ARG5: 1806 response.PutCString("generic:arg5;"); 1807 break; 1808 case LLDB_REGNUM_GENERIC_ARG6: 1809 response.PutCString("generic:arg6;"); 1810 break; 1811 case LLDB_REGNUM_GENERIC_ARG7: 1812 response.PutCString("generic:arg7;"); 1813 break; 1814 case LLDB_REGNUM_GENERIC_ARG8: 1815 response.PutCString("generic:arg8;"); 1816 break; 1817 default: 1818 break; 1819 } 1820 1821 if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) { 1822 response.PutCString("container-regs:"); 1823 int i = 0; 1824 for (const uint32_t *reg_num = reg_info->value_regs; 1825 *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) { 1826 if (i > 0) 1827 response.PutChar(','); 1828 response.Printf("%" PRIx32, *reg_num); 1829 } 1830 response.PutChar(';'); 1831 } 1832 1833 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) { 1834 response.PutCString("invalidate-regs:"); 1835 int i = 0; 1836 for (const uint32_t *reg_num = reg_info->invalidate_regs; 1837 *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) { 1838 if (i > 0) 1839 response.PutChar(','); 1840 response.Printf("%" PRIx32, *reg_num); 1841 } 1842 response.PutChar(';'); 1843 } 1844 1845 if (reg_info->dynamic_size_dwarf_expr_bytes) { 1846 const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len; 1847 response.PutCString("dynamic_size_dwarf_expr_bytes:"); 1848 for (uint32_t i = 0; i < dwarf_opcode_len; ++i) 1849 response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]); 1850 response.PutChar(';'); 1851 } 1852 return SendPacketNoLock(response.GetString()); 1853 } 1854 1855 GDBRemoteCommunication::PacketResult 1856 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo( 1857 StringExtractorGDBRemote &packet) { 1858 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1859 1860 // Fail if we don't have a current process. 1861 if (!m_debugged_process_up || 1862 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 1863 LLDB_LOG(log, "no process ({0}), returning OK", 1864 m_debugged_process_up ? "invalid process id" 1865 : "null m_debugged_process_up"); 1866 return SendOKResponse(); 1867 } 1868 1869 StreamGDBRemote response; 1870 response.PutChar('m'); 1871 1872 LLDB_LOG(log, "starting thread iteration"); 1873 NativeThreadProtocol *thread; 1874 uint32_t thread_index; 1875 for (thread_index = 0, 1876 thread = m_debugged_process_up->GetThreadAtIndex(thread_index); 1877 thread; ++thread_index, 1878 thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) { 1879 LLDB_LOG(log, "iterated thread {0}(tid={2})", thread_index, 1880 thread->GetID()); 1881 if (thread_index > 0) 1882 response.PutChar(','); 1883 response.Printf("%" PRIx64, thread->GetID()); 1884 } 1885 1886 LLDB_LOG(log, "finished thread iteration"); 1887 return SendPacketNoLock(response.GetString()); 1888 } 1889 1890 GDBRemoteCommunication::PacketResult 1891 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo( 1892 StringExtractorGDBRemote &packet) { 1893 // FIXME for now we return the full thread list in the initial packet and 1894 // always do nothing here. 1895 return SendPacketNoLock("l"); 1896 } 1897 1898 GDBRemoteCommunication::PacketResult 1899 GDBRemoteCommunicationServerLLGS::Handle_g(StringExtractorGDBRemote &packet) { 1900 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1901 1902 // Move past packet name. 1903 packet.SetFilePos(strlen("g")); 1904 1905 // Get the thread to use. 1906 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 1907 if (!thread) { 1908 LLDB_LOG(log, "failed, no thread available"); 1909 return SendErrorResponse(0x15); 1910 } 1911 1912 // Get the thread's register context. 1913 NativeRegisterContext ®_ctx = thread->GetRegisterContext(); 1914 1915 std::vector<uint8_t> regs_buffer; 1916 for (uint32_t reg_num = 0; reg_num < reg_ctx.GetUserRegisterCount(); 1917 ++reg_num) { 1918 const RegisterInfo *reg_info = reg_ctx.GetRegisterInfoAtIndex(reg_num); 1919 1920 if (reg_info == nullptr) { 1921 LLDB_LOG(log, "failed to get register info for register index {0}", 1922 reg_num); 1923 return SendErrorResponse(0x15); 1924 } 1925 1926 if (reg_info->value_regs != nullptr) 1927 continue; // skip registers that are contained in other registers 1928 1929 RegisterValue reg_value; 1930 Status error = reg_ctx.ReadRegister(reg_info, reg_value); 1931 if (error.Fail()) { 1932 LLDB_LOG(log, "failed to read register at index {0}", reg_num); 1933 return SendErrorResponse(0x15); 1934 } 1935 1936 if (reg_info->byte_offset + reg_info->byte_size >= regs_buffer.size()) 1937 // Resize the buffer to guarantee it can store the register offsetted 1938 // data. 1939 regs_buffer.resize(reg_info->byte_offset + reg_info->byte_size); 1940 1941 // Copy the register offsetted data to the buffer. 1942 memcpy(regs_buffer.data() + reg_info->byte_offset, reg_value.GetBytes(), 1943 reg_info->byte_size); 1944 } 1945 1946 // Write the response. 1947 StreamGDBRemote response; 1948 response.PutBytesAsRawHex8(regs_buffer.data(), regs_buffer.size()); 1949 1950 return SendPacketNoLock(response.GetString()); 1951 } 1952 1953 GDBRemoteCommunication::PacketResult 1954 GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) { 1955 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1956 1957 // Parse out the register number from the request. 1958 packet.SetFilePos(strlen("p")); 1959 const uint32_t reg_index = 1960 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1961 if (reg_index == std::numeric_limits<uint32_t>::max()) { 1962 LLDB_LOGF(log, 1963 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 1964 "parse register number from request \"%s\"", 1965 __FUNCTION__, packet.GetStringRef().data()); 1966 return SendErrorResponse(0x15); 1967 } 1968 1969 // Get the thread to use. 1970 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 1971 if (!thread) { 1972 LLDB_LOG(log, "failed, no thread available"); 1973 return SendErrorResponse(0x15); 1974 } 1975 1976 // Get the thread's register context. 1977 NativeRegisterContext ®_context = thread->GetRegisterContext(); 1978 1979 // Return the end of registers response if we've iterated one past the end of 1980 // the register set. 1981 if (reg_index >= reg_context.GetUserRegisterCount()) { 1982 LLDB_LOGF(log, 1983 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 1984 "register %" PRIu32 " beyond register count %" PRIu32, 1985 __FUNCTION__, reg_index, reg_context.GetUserRegisterCount()); 1986 return SendErrorResponse(0x15); 1987 } 1988 1989 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 1990 if (!reg_info) { 1991 LLDB_LOGF(log, 1992 "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 LLDB_LOGF(log, 2006 "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 LLDB_LOGF(log, 2016 "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 LLDB_LOGF(log, 2043 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 2044 "parse register number from request \"%s\"", 2045 __FUNCTION__, packet.GetStringRef().data()); 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 LLDB_LOGF(log, 2062 "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 LLDB_LOGF(log, 2073 "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 LLDB_LOGF(log, 2083 "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 LLDB_LOGF(log, 2105 "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 LLDB_LOGF( 2122 log, 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 LLDB_LOGF(log, 2132 "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 LLDB_LOGF( 2148 log, 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 LLDB_LOGF(log, 2166 "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 LLDB_LOGF( 2200 log, 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 LLDB_LOGF( 2261 log, 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 LLDB_LOGF(log, 2288 "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 LLDB_LOGF(log, 2305 "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 LLDB_LOGF(log, 2314 "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 LLDB_LOGF( 2342 log, 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 LLDB_LOGF( 2430 log, 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 LLDB_LOGF( 2458 log, 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 LLDB_LOGF( 2707 log, 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, LLDB_INVALID_SIGNAL_NUMBER}; 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 LLDB_LOGF(log, 2739 "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 if (object == "libraries-svr4") { 2769 auto library_list = m_debugged_process_up->GetLoadedSVR4Libraries(); 2770 if (!library_list) 2771 return library_list.takeError(); 2772 2773 StreamString response; 2774 response.Printf("<library-list-svr4 version=\"1.0\">"); 2775 for (auto const &library : *library_list) { 2776 response.Printf("<library name=\"%s\" ", 2777 XMLEncodeAttributeValue(library.name.c_str()).c_str()); 2778 response.Printf("lm=\"0x%" PRIx64 "\" ", library.link_map); 2779 response.Printf("l_addr=\"0x%" PRIx64 "\" ", library.base_addr); 2780 response.Printf("l_ld=\"0x%" PRIx64 "\" />", library.ld_addr); 2781 } 2782 response.Printf("</library-list-svr4>"); 2783 return MemoryBuffer::getMemBufferCopy(response.GetString(), __FUNCTION__); 2784 } 2785 2786 return llvm::make_error<PacketUnimplementedError>( 2787 "Xfer object not supported"); 2788 } 2789 2790 GDBRemoteCommunication::PacketResult 2791 GDBRemoteCommunicationServerLLGS::Handle_qXfer( 2792 StringExtractorGDBRemote &packet) { 2793 SmallVector<StringRef, 5> fields; 2794 // The packet format is "qXfer:<object>:<action>:<annex>:offset,length" 2795 StringRef(packet.GetStringRef()).split(fields, ':', 4); 2796 if (fields.size() != 5) 2797 return SendIllFormedResponse(packet, "malformed qXfer packet"); 2798 StringRef &xfer_object = fields[1]; 2799 StringRef &xfer_action = fields[2]; 2800 StringRef &xfer_annex = fields[3]; 2801 StringExtractor offset_data(fields[4]); 2802 if (xfer_action != "read") 2803 return SendUnimplementedResponse("qXfer action not supported"); 2804 // Parse offset. 2805 const uint64_t xfer_offset = 2806 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 2807 if (xfer_offset == std::numeric_limits<uint64_t>::max()) 2808 return SendIllFormedResponse(packet, "qXfer packet missing offset"); 2809 // Parse out comma. 2810 if (offset_data.GetChar() != ',') 2811 return SendIllFormedResponse(packet, 2812 "qXfer packet missing comma after offset"); 2813 // Parse out the length. 2814 const uint64_t xfer_length = 2815 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 2816 if (xfer_length == std::numeric_limits<uint64_t>::max()) 2817 return SendIllFormedResponse(packet, "qXfer packet missing length"); 2818 2819 // Get a previously constructed buffer if it exists or create it now. 2820 std::string buffer_key = (xfer_object + xfer_action + xfer_annex).str(); 2821 auto buffer_it = m_xfer_buffer_map.find(buffer_key); 2822 if (buffer_it == m_xfer_buffer_map.end()) { 2823 auto buffer_up = ReadXferObject(xfer_object, xfer_annex); 2824 if (!buffer_up) 2825 return SendErrorResponse(buffer_up.takeError()); 2826 buffer_it = m_xfer_buffer_map 2827 .insert(std::make_pair(buffer_key, std::move(*buffer_up))) 2828 .first; 2829 } 2830 2831 // Send back the response 2832 StreamGDBRemote response; 2833 bool done_with_buffer = false; 2834 llvm::StringRef buffer = buffer_it->second->getBuffer(); 2835 if (xfer_offset >= buffer.size()) { 2836 // We have nothing left to send. Mark the buffer as complete. 2837 response.PutChar('l'); 2838 done_with_buffer = true; 2839 } else { 2840 // Figure out how many bytes are available starting at the given offset. 2841 buffer = buffer.drop_front(xfer_offset); 2842 // Mark the response type according to whether we're reading the remainder 2843 // of the data. 2844 if (xfer_length >= buffer.size()) { 2845 // There will be nothing left to read after this 2846 response.PutChar('l'); 2847 done_with_buffer = true; 2848 } else { 2849 // There will still be bytes to read after this request. 2850 response.PutChar('m'); 2851 buffer = buffer.take_front(xfer_length); 2852 } 2853 // Now write the data in encoded binary form. 2854 response.PutEscapedBytes(buffer.data(), buffer.size()); 2855 } 2856 2857 if (done_with_buffer) 2858 m_xfer_buffer_map.erase(buffer_it); 2859 2860 return SendPacketNoLock(response.GetString()); 2861 } 2862 2863 GDBRemoteCommunication::PacketResult 2864 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( 2865 StringExtractorGDBRemote &packet) { 2866 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2867 2868 // Move past packet name. 2869 packet.SetFilePos(strlen("QSaveRegisterState")); 2870 2871 // Get the thread to use. 2872 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2873 if (!thread) { 2874 if (m_thread_suffix_supported) 2875 return SendIllFormedResponse( 2876 packet, "No thread specified in QSaveRegisterState packet"); 2877 else 2878 return SendIllFormedResponse(packet, 2879 "No thread was is set with the Hg packet"); 2880 } 2881 2882 // Grab the register context for the thread. 2883 NativeRegisterContext& reg_context = thread->GetRegisterContext(); 2884 2885 // Save registers to a buffer. 2886 DataBufferSP register_data_sp; 2887 Status error = reg_context.ReadAllRegisterValues(register_data_sp); 2888 if (error.Fail()) { 2889 LLDB_LOG(log, "pid {0} failed to save all register values: {1}", 2890 m_debugged_process_up->GetID(), error); 2891 return SendErrorResponse(0x75); 2892 } 2893 2894 // Allocate a new save id. 2895 const uint32_t save_id = GetNextSavedRegistersID(); 2896 assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && 2897 "GetNextRegisterSaveID() returned an existing register save id"); 2898 2899 // Save the register data buffer under the save id. 2900 { 2901 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 2902 m_saved_registers_map[save_id] = register_data_sp; 2903 } 2904 2905 // Write the response. 2906 StreamGDBRemote response; 2907 response.Printf("%" PRIu32, save_id); 2908 return SendPacketNoLock(response.GetString()); 2909 } 2910 2911 GDBRemoteCommunication::PacketResult 2912 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( 2913 StringExtractorGDBRemote &packet) { 2914 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2915 2916 // Parse out save id. 2917 packet.SetFilePos(strlen("QRestoreRegisterState:")); 2918 if (packet.GetBytesLeft() < 1) 2919 return SendIllFormedResponse( 2920 packet, "QRestoreRegisterState packet missing register save id"); 2921 2922 const uint32_t save_id = packet.GetU32(0); 2923 if (save_id == 0) { 2924 LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, " 2925 "expecting decimal uint32_t"); 2926 return SendErrorResponse(0x76); 2927 } 2928 2929 // Get the thread to use. 2930 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2931 if (!thread) { 2932 if (m_thread_suffix_supported) 2933 return SendIllFormedResponse( 2934 packet, "No thread specified in QRestoreRegisterState packet"); 2935 else 2936 return SendIllFormedResponse(packet, 2937 "No thread was is set with the Hg packet"); 2938 } 2939 2940 // Grab the register context for the thread. 2941 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2942 2943 // Retrieve register state buffer, then remove from the list. 2944 DataBufferSP register_data_sp; 2945 { 2946 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 2947 2948 // Find the register set buffer for the given save id. 2949 auto it = m_saved_registers_map.find(save_id); 2950 if (it == m_saved_registers_map.end()) { 2951 LLDB_LOG(log, 2952 "pid {0} does not have a register set save buffer for id {1}", 2953 m_debugged_process_up->GetID(), save_id); 2954 return SendErrorResponse(0x77); 2955 } 2956 register_data_sp = it->second; 2957 2958 // Remove it from the map. 2959 m_saved_registers_map.erase(it); 2960 } 2961 2962 Status error = reg_context.WriteAllRegisterValues(register_data_sp); 2963 if (error.Fail()) { 2964 LLDB_LOG(log, "pid {0} failed to restore all register values: {1}", 2965 m_debugged_process_up->GetID(), error); 2966 return SendErrorResponse(0x77); 2967 } 2968 2969 return SendOKResponse(); 2970 } 2971 2972 GDBRemoteCommunication::PacketResult 2973 GDBRemoteCommunicationServerLLGS::Handle_vAttach( 2974 StringExtractorGDBRemote &packet) { 2975 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2976 2977 // Consume the ';' after vAttach. 2978 packet.SetFilePos(strlen("vAttach")); 2979 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 2980 return SendIllFormedResponse(packet, "vAttach missing expected ';'"); 2981 2982 // Grab the PID to which we will attach (assume hex encoding). 2983 lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 2984 if (pid == LLDB_INVALID_PROCESS_ID) 2985 return SendIllFormedResponse(packet, 2986 "vAttach failed to parse the process id"); 2987 2988 // Attempt to attach. 2989 LLDB_LOGF(log, 2990 "GDBRemoteCommunicationServerLLGS::%s attempting to attach to " 2991 "pid %" PRIu64, 2992 __FUNCTION__, pid); 2993 2994 Status error = AttachToProcess(pid); 2995 2996 if (error.Fail()) { 2997 LLDB_LOGF(log, 2998 "GDBRemoteCommunicationServerLLGS::%s failed to attach to " 2999 "pid %" PRIu64 ": %s\n", 3000 __FUNCTION__, pid, error.AsCString()); 3001 return SendErrorResponse(error); 3002 } 3003 3004 // Notify we attached by sending a stop packet. 3005 return SendStopReasonForState(m_debugged_process_up->GetState()); 3006 } 3007 3008 GDBRemoteCommunication::PacketResult 3009 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) { 3010 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3011 3012 StopSTDIOForwarding(); 3013 3014 // Fail if we don't have a current process. 3015 if (!m_debugged_process_up || 3016 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) { 3017 LLDB_LOGF( 3018 log, 3019 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3020 __FUNCTION__); 3021 return SendErrorResponse(0x15); 3022 } 3023 3024 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 3025 3026 // Consume the ';' after D. 3027 packet.SetFilePos(1); 3028 if (packet.GetBytesLeft()) { 3029 if (packet.GetChar() != ';') 3030 return SendIllFormedResponse(packet, "D missing expected ';'"); 3031 3032 // Grab the PID from which we will detach (assume hex encoding). 3033 pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3034 if (pid == LLDB_INVALID_PROCESS_ID) 3035 return SendIllFormedResponse(packet, "D failed to parse the process id"); 3036 } 3037 3038 if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_up->GetID() != pid) { 3039 return SendIllFormedResponse(packet, "Invalid pid"); 3040 } 3041 3042 const Status error = m_debugged_process_up->Detach(); 3043 if (error.Fail()) { 3044 LLDB_LOGF(log, 3045 "GDBRemoteCommunicationServerLLGS::%s failed to detach from " 3046 "pid %" PRIu64 ": %s\n", 3047 __FUNCTION__, m_debugged_process_up->GetID(), error.AsCString()); 3048 return SendErrorResponse(0x01); 3049 } 3050 3051 return SendOKResponse(); 3052 } 3053 3054 GDBRemoteCommunication::PacketResult 3055 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo( 3056 StringExtractorGDBRemote &packet) { 3057 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3058 3059 packet.SetFilePos(strlen("qThreadStopInfo")); 3060 const lldb::tid_t tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID); 3061 if (tid == LLDB_INVALID_THREAD_ID) { 3062 LLDB_LOGF(log, 3063 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 3064 "parse thread id from request \"%s\"", 3065 __FUNCTION__, packet.GetStringRef().data()); 3066 return SendErrorResponse(0x15); 3067 } 3068 return SendStopReplyPacketForThread(tid); 3069 } 3070 3071 GDBRemoteCommunication::PacketResult 3072 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo( 3073 StringExtractorGDBRemote &) { 3074 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 3075 3076 // Ensure we have a debugged process. 3077 if (!m_debugged_process_up || 3078 (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) 3079 return SendErrorResponse(50); 3080 LLDB_LOG(log, "preparing packet for pid {0}", m_debugged_process_up->GetID()); 3081 3082 StreamString response; 3083 const bool threads_with_valid_stop_info_only = false; 3084 JSONArray::SP threads_array_sp = GetJSONThreadsInfo( 3085 *m_debugged_process_up, threads_with_valid_stop_info_only); 3086 if (!threads_array_sp) { 3087 LLDB_LOG(log, "failed to prepare a packet for pid {0}", 3088 m_debugged_process_up->GetID()); 3089 return SendErrorResponse(52); 3090 } 3091 3092 threads_array_sp->Write(response); 3093 StreamGDBRemote escaped_response; 3094 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 3095 return SendPacketNoLock(escaped_response.GetString()); 3096 } 3097 3098 GDBRemoteCommunication::PacketResult 3099 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo( 3100 StringExtractorGDBRemote &packet) { 3101 // Fail if we don't have a current process. 3102 if (!m_debugged_process_up || 3103 m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID) 3104 return SendErrorResponse(68); 3105 3106 packet.SetFilePos(strlen("qWatchpointSupportInfo")); 3107 if (packet.GetBytesLeft() == 0) 3108 return SendOKResponse(); 3109 if (packet.GetChar() != ':') 3110 return SendErrorResponse(67); 3111 3112 auto hw_debug_cap = m_debugged_process_up->GetHardwareDebugSupportInfo(); 3113 3114 StreamGDBRemote response; 3115 if (hw_debug_cap == llvm::None) 3116 response.Printf("num:0;"); 3117 else 3118 response.Printf("num:%d;", hw_debug_cap->second); 3119 3120 return SendPacketNoLock(response.GetString()); 3121 } 3122 3123 GDBRemoteCommunication::PacketResult 3124 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress( 3125 StringExtractorGDBRemote &packet) { 3126 // Fail if we don't have a current process. 3127 if (!m_debugged_process_up || 3128 m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID) 3129 return SendErrorResponse(67); 3130 3131 packet.SetFilePos(strlen("qFileLoadAddress:")); 3132 if (packet.GetBytesLeft() == 0) 3133 return SendErrorResponse(68); 3134 3135 std::string file_name; 3136 packet.GetHexByteString(file_name); 3137 3138 lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS; 3139 Status error = 3140 m_debugged_process_up->GetFileLoadAddress(file_name, file_load_address); 3141 if (error.Fail()) 3142 return SendErrorResponse(69); 3143 3144 if (file_load_address == LLDB_INVALID_ADDRESS) 3145 return SendErrorResponse(1); // File not loaded 3146 3147 StreamGDBRemote response; 3148 response.PutHex64(file_load_address); 3149 return SendPacketNoLock(response.GetString()); 3150 } 3151 3152 GDBRemoteCommunication::PacketResult 3153 GDBRemoteCommunicationServerLLGS::Handle_QPassSignals( 3154 StringExtractorGDBRemote &packet) { 3155 std::vector<int> signals; 3156 packet.SetFilePos(strlen("QPassSignals:")); 3157 3158 // Read sequence of hex signal numbers divided by a semicolon and optionally 3159 // spaces. 3160 while (packet.GetBytesLeft() > 0) { 3161 int signal = packet.GetS32(-1, 16); 3162 if (signal < 0) 3163 return SendIllFormedResponse(packet, "Failed to parse signal number."); 3164 signals.push_back(signal); 3165 3166 packet.SkipSpaces(); 3167 char separator = packet.GetChar(); 3168 if (separator == '\0') 3169 break; // End of string 3170 if (separator != ';') 3171 return SendIllFormedResponse(packet, "Invalid separator," 3172 " expected semicolon."); 3173 } 3174 3175 // Fail if we don't have a current process. 3176 if (!m_debugged_process_up) 3177 return SendErrorResponse(68); 3178 3179 Status error = m_debugged_process_up->IgnoreSignals(signals); 3180 if (error.Fail()) 3181 return SendErrorResponse(69); 3182 3183 return SendOKResponse(); 3184 } 3185 3186 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() { 3187 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3188 3189 // Tell the stdio connection to shut down. 3190 if (m_stdio_communication.IsConnected()) { 3191 auto connection = m_stdio_communication.GetConnection(); 3192 if (connection) { 3193 Status error; 3194 connection->Disconnect(&error); 3195 3196 if (error.Success()) { 3197 LLDB_LOGF(log, 3198 "GDBRemoteCommunicationServerLLGS::%s disconnect process " 3199 "terminal stdio - SUCCESS", 3200 __FUNCTION__); 3201 } else { 3202 LLDB_LOGF(log, 3203 "GDBRemoteCommunicationServerLLGS::%s disconnect process " 3204 "terminal stdio - FAIL: %s", 3205 __FUNCTION__, error.AsCString()); 3206 } 3207 } 3208 } 3209 } 3210 3211 NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( 3212 StringExtractorGDBRemote &packet) { 3213 // We have no thread if we don't have a process. 3214 if (!m_debugged_process_up || 3215 m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID) 3216 return nullptr; 3217 3218 // If the client hasn't asked for thread suffix support, there will not be a 3219 // thread suffix. Use the current thread in that case. 3220 if (!m_thread_suffix_supported) { 3221 const lldb::tid_t current_tid = GetCurrentThreadID(); 3222 if (current_tid == LLDB_INVALID_THREAD_ID) 3223 return nullptr; 3224 else if (current_tid == 0) { 3225 // Pick a thread. 3226 return m_debugged_process_up->GetThreadAtIndex(0); 3227 } else 3228 return m_debugged_process_up->GetThreadByID(current_tid); 3229 } 3230 3231 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 3232 3233 // Parse out the ';'. 3234 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') { 3235 LLDB_LOGF(log, 3236 "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 3237 "error: expected ';' prior to start of thread suffix: packet " 3238 "contents = '%s'", 3239 __FUNCTION__, packet.GetStringRef().data()); 3240 return nullptr; 3241 } 3242 3243 if (!packet.GetBytesLeft()) 3244 return nullptr; 3245 3246 // Parse out thread: portion. 3247 if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) { 3248 LLDB_LOGF(log, 3249 "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 3250 "error: expected 'thread:' but not found, packet contents = " 3251 "'%s'", 3252 __FUNCTION__, packet.GetStringRef().data()); 3253 return nullptr; 3254 } 3255 packet.SetFilePos(packet.GetFilePos() + strlen("thread:")); 3256 const lldb::tid_t tid = packet.GetHexMaxU64(false, 0); 3257 if (tid != 0) 3258 return m_debugged_process_up->GetThreadByID(tid); 3259 3260 return nullptr; 3261 } 3262 3263 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const { 3264 if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) { 3265 // Use whatever the debug process says is the current thread id since the 3266 // protocol either didn't specify or specified we want any/all threads 3267 // marked as the current thread. 3268 if (!m_debugged_process_up) 3269 return LLDB_INVALID_THREAD_ID; 3270 return m_debugged_process_up->GetCurrentThreadID(); 3271 } 3272 // Use the specific current thread id set by the gdb remote protocol. 3273 return m_current_tid; 3274 } 3275 3276 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() { 3277 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3278 return m_next_saved_registers_id++; 3279 } 3280 3281 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() { 3282 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 3283 3284 LLDB_LOG(log, "clearing {0} xfer buffers", m_xfer_buffer_map.size()); 3285 m_xfer_buffer_map.clear(); 3286 } 3287 3288 FileSpec 3289 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path, 3290 const ArchSpec &arch) { 3291 if (m_debugged_process_up) { 3292 FileSpec file_spec; 3293 if (m_debugged_process_up 3294 ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec) 3295 .Success()) { 3296 if (FileSystem::Instance().Exists(file_spec)) 3297 return file_spec; 3298 } 3299 } 3300 3301 return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch); 3302 } 3303 3304 std::string GDBRemoteCommunicationServerLLGS::XMLEncodeAttributeValue( 3305 llvm::StringRef value) { 3306 std::string result; 3307 for (const char &c : value) { 3308 switch (c) { 3309 case '\'': 3310 result += "'"; 3311 break; 3312 case '"': 3313 result += """; 3314 break; 3315 case '<': 3316 result += "<"; 3317 break; 3318 case '>': 3319 result += ">"; 3320 break; 3321 default: 3322 result += c; 3323 break; 3324 } 3325 } 3326 return result; 3327 } 3328