1//===-- GDBRemoteCommunicationServerLLGS.cpp ------------------------------===// 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 <cerrno> 10 11#include "lldb/Host/Config.h" 12 13#include <chrono> 14#include <cstring> 15#include <limits> 16#include <optional> 17#include <thread> 18 19#include "GDBRemoteCommunicationServerLLGS.h" 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/Socket.h" 29#include "lldb/Host/common/NativeProcessProtocol.h" 30#include "lldb/Host/common/NativeRegisterContext.h" 31#include "lldb/Host/common/NativeThreadProtocol.h" 32#include "lldb/Target/MemoryRegionInfo.h" 33#include "lldb/Utility/Args.h" 34#include "lldb/Utility/DataBuffer.h" 35#include "lldb/Utility/Endian.h" 36#include "lldb/Utility/GDBRemote.h" 37#include "lldb/Utility/LLDBAssert.h" 38#include "lldb/Utility/LLDBLog.h" 39#include "lldb/Utility/Log.h" 40#include "lldb/Utility/State.h" 41#include "lldb/Utility/StreamString.h" 42#include "lldb/Utility/UnimplementedError.h" 43#include "lldb/Utility/UriParser.h" 44#include "llvm/Support/JSON.h" 45#include "llvm/Support/ScopedPrinter.h" 46#include "llvm/TargetParser/Triple.h" 47 48#include "ProcessGDBRemote.h" 49#include "ProcessGDBRemoteLog.h" 50#include "lldb/Utility/StringExtractorGDBRemote.h" 51 52using namespace lldb; 53using namespace lldb_private; 54using namespace lldb_private::process_gdb_remote; 55using namespace llvm; 56 57// GDBRemote Errors 58 59namespace { 60enum GDBRemoteServerError { 61 // Set to the first unused error number in literal form below 62 eErrorFirst = 29, 63 eErrorNoProcess = eErrorFirst, 64 eErrorResume, 65 eErrorExitStatus 66}; 67} 68 69// GDBRemoteCommunicationServerLLGS constructor 70GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS( 71 MainLoop &mainloop, NativeProcessProtocol::Manager &process_manager) 72 : GDBRemoteCommunicationServerCommon(), m_mainloop(mainloop), 73 m_process_manager(process_manager), m_current_process(nullptr), 74 m_continue_process(nullptr), m_stdio_communication() { 75 RegisterPacketHandlers(); 76} 77 78void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() { 79 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C, 80 &GDBRemoteCommunicationServerLLGS::Handle_C); 81 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c, 82 &GDBRemoteCommunicationServerLLGS::Handle_c); 83 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D, 84 &GDBRemoteCommunicationServerLLGS::Handle_D); 85 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H, 86 &GDBRemoteCommunicationServerLLGS::Handle_H); 87 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I, 88 &GDBRemoteCommunicationServerLLGS::Handle_I); 89 RegisterMemberFunctionHandler( 90 StringExtractorGDBRemote::eServerPacketType_interrupt, 91 &GDBRemoteCommunicationServerLLGS::Handle_interrupt); 92 RegisterMemberFunctionHandler( 93 StringExtractorGDBRemote::eServerPacketType_m, 94 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 95 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M, 96 &GDBRemoteCommunicationServerLLGS::Handle_M); 97 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType__M, 98 &GDBRemoteCommunicationServerLLGS::Handle__M); 99 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType__m, 100 &GDBRemoteCommunicationServerLLGS::Handle__m); 101 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p, 102 &GDBRemoteCommunicationServerLLGS::Handle_p); 103 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P, 104 &GDBRemoteCommunicationServerLLGS::Handle_P); 105 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC, 106 &GDBRemoteCommunicationServerLLGS::Handle_qC); 107 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_T, 108 &GDBRemoteCommunicationServerLLGS::Handle_T); 109 RegisterMemberFunctionHandler( 110 StringExtractorGDBRemote::eServerPacketType_qfThreadInfo, 111 &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo); 112 RegisterMemberFunctionHandler( 113 StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress, 114 &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress); 115 RegisterMemberFunctionHandler( 116 StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir, 117 &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir); 118 RegisterMemberFunctionHandler( 119 StringExtractorGDBRemote::eServerPacketType_QThreadSuffixSupported, 120 &GDBRemoteCommunicationServerLLGS::Handle_QThreadSuffixSupported); 121 RegisterMemberFunctionHandler( 122 StringExtractorGDBRemote::eServerPacketType_QListThreadsInStopReply, 123 &GDBRemoteCommunicationServerLLGS::Handle_QListThreadsInStopReply); 124 RegisterMemberFunctionHandler( 125 StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo, 126 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo); 127 RegisterMemberFunctionHandler( 128 StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported, 129 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported); 130 RegisterMemberFunctionHandler( 131 StringExtractorGDBRemote::eServerPacketType_qProcessInfo, 132 &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo); 133 RegisterMemberFunctionHandler( 134 StringExtractorGDBRemote::eServerPacketType_qRegisterInfo, 135 &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo); 136 RegisterMemberFunctionHandler( 137 StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState, 138 &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState); 139 RegisterMemberFunctionHandler( 140 StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState, 141 &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState); 142 RegisterMemberFunctionHandler( 143 StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR, 144 &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR); 145 RegisterMemberFunctionHandler( 146 StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir, 147 &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir); 148 RegisterMemberFunctionHandler( 149 StringExtractorGDBRemote::eServerPacketType_qsThreadInfo, 150 &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo); 151 RegisterMemberFunctionHandler( 152 StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo, 153 &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo); 154 RegisterMemberFunctionHandler( 155 StringExtractorGDBRemote::eServerPacketType_jThreadsInfo, 156 &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo); 157 RegisterMemberFunctionHandler( 158 StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo, 159 &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo); 160 RegisterMemberFunctionHandler( 161 StringExtractorGDBRemote::eServerPacketType_qXfer, 162 &GDBRemoteCommunicationServerLLGS::Handle_qXfer); 163 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s, 164 &GDBRemoteCommunicationServerLLGS::Handle_s); 165 RegisterMemberFunctionHandler( 166 StringExtractorGDBRemote::eServerPacketType_stop_reason, 167 &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ? 168 RegisterMemberFunctionHandler( 169 StringExtractorGDBRemote::eServerPacketType_vAttach, 170 &GDBRemoteCommunicationServerLLGS::Handle_vAttach); 171 RegisterMemberFunctionHandler( 172 StringExtractorGDBRemote::eServerPacketType_vAttachWait, 173 &GDBRemoteCommunicationServerLLGS::Handle_vAttachWait); 174 RegisterMemberFunctionHandler( 175 StringExtractorGDBRemote::eServerPacketType_qVAttachOrWaitSupported, 176 &GDBRemoteCommunicationServerLLGS::Handle_qVAttachOrWaitSupported); 177 RegisterMemberFunctionHandler( 178 StringExtractorGDBRemote::eServerPacketType_vAttachOrWait, 179 &GDBRemoteCommunicationServerLLGS::Handle_vAttachOrWait); 180 RegisterMemberFunctionHandler( 181 StringExtractorGDBRemote::eServerPacketType_vCont, 182 &GDBRemoteCommunicationServerLLGS::Handle_vCont); 183 RegisterMemberFunctionHandler( 184 StringExtractorGDBRemote::eServerPacketType_vCont_actions, 185 &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions); 186 RegisterMemberFunctionHandler( 187 StringExtractorGDBRemote::eServerPacketType_vRun, 188 &GDBRemoteCommunicationServerLLGS::Handle_vRun); 189 RegisterMemberFunctionHandler( 190 StringExtractorGDBRemote::eServerPacketType_x, 191 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 192 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z, 193 &GDBRemoteCommunicationServerLLGS::Handle_Z); 194 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z, 195 &GDBRemoteCommunicationServerLLGS::Handle_z); 196 RegisterMemberFunctionHandler( 197 StringExtractorGDBRemote::eServerPacketType_QPassSignals, 198 &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals); 199 200 RegisterMemberFunctionHandler( 201 StringExtractorGDBRemote::eServerPacketType_jLLDBTraceSupported, 202 &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupported); 203 RegisterMemberFunctionHandler( 204 StringExtractorGDBRemote::eServerPacketType_jLLDBTraceStart, 205 &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart); 206 RegisterMemberFunctionHandler( 207 StringExtractorGDBRemote::eServerPacketType_jLLDBTraceStop, 208 &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop); 209 RegisterMemberFunctionHandler( 210 StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetState, 211 &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState); 212 RegisterMemberFunctionHandler( 213 StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetBinaryData, 214 &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData); 215 216 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_g, 217 &GDBRemoteCommunicationServerLLGS::Handle_g); 218 219 RegisterMemberFunctionHandler( 220 StringExtractorGDBRemote::eServerPacketType_qMemTags, 221 &GDBRemoteCommunicationServerLLGS::Handle_qMemTags); 222 223 RegisterMemberFunctionHandler( 224 StringExtractorGDBRemote::eServerPacketType_QMemTags, 225 &GDBRemoteCommunicationServerLLGS::Handle_QMemTags); 226 227 RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k, 228 [this](StringExtractorGDBRemote packet, Status &error, 229 bool &interrupt, bool &quit) { 230 quit = true; 231 return this->Handle_k(packet); 232 }); 233 234 RegisterMemberFunctionHandler( 235 StringExtractorGDBRemote::eServerPacketType_vKill, 236 &GDBRemoteCommunicationServerLLGS::Handle_vKill); 237 238 RegisterMemberFunctionHandler( 239 StringExtractorGDBRemote::eServerPacketType_qLLDBSaveCore, 240 &GDBRemoteCommunicationServerLLGS::Handle_qSaveCore); 241 242 RegisterMemberFunctionHandler( 243 StringExtractorGDBRemote::eServerPacketType_QNonStop, 244 &GDBRemoteCommunicationServerLLGS::Handle_QNonStop); 245 RegisterMemberFunctionHandler( 246 StringExtractorGDBRemote::eServerPacketType_vStdio, 247 &GDBRemoteCommunicationServerLLGS::Handle_vStdio); 248 RegisterMemberFunctionHandler( 249 StringExtractorGDBRemote::eServerPacketType_vStopped, 250 &GDBRemoteCommunicationServerLLGS::Handle_vStopped); 251 RegisterMemberFunctionHandler( 252 StringExtractorGDBRemote::eServerPacketType_vCtrlC, 253 &GDBRemoteCommunicationServerLLGS::Handle_vCtrlC); 254} 255 256void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) { 257 m_process_launch_info = info; 258} 259 260Status GDBRemoteCommunicationServerLLGS::LaunchProcess() { 261 Log *log = GetLog(LLDBLog::Process); 262 263 if (!m_process_launch_info.GetArguments().GetArgumentCount()) 264 return Status("%s: no process command line specified to launch", 265 __FUNCTION__); 266 267 const bool should_forward_stdio = 268 m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr || 269 m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr || 270 m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr; 271 m_process_launch_info.SetLaunchInSeparateProcessGroup(true); 272 m_process_launch_info.GetFlags().Set(eLaunchFlagDebug); 273 274 if (should_forward_stdio) { 275 // Temporarily relax the following for Windows until we can take advantage 276 // of the recently added pty support. This doesn't really affect the use of 277 // lldb-server on Windows. 278#if !defined(_WIN32) 279 if (llvm::Error Err = m_process_launch_info.SetUpPtyRedirection()) 280 return Status(std::move(Err)); 281#endif 282 } 283 284 { 285 std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex); 286 assert(m_debugged_processes.empty() && "lldb-server creating debugged " 287 "process but one already exists"); 288 auto process_or = m_process_manager.Launch(m_process_launch_info, *this); 289 if (!process_or) 290 return Status(process_or.takeError()); 291 m_continue_process = m_current_process = process_or->get(); 292 m_debugged_processes.emplace( 293 m_current_process->GetID(), 294 DebuggedProcess{std::move(*process_or), DebuggedProcess::Flag{}}); 295 } 296 297 SetEnabledExtensions(*m_current_process); 298 299 // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol as 300 // needed. llgs local-process debugging may specify PTY paths, which will 301 // make these file actions non-null process launch -i/e/o will also make 302 // these file actions non-null nullptr means that the traffic is expected to 303 // flow over gdb-remote protocol 304 if (should_forward_stdio) { 305 // nullptr means it's not redirected to file or pty (in case of LLGS local) 306 // at least one of stdio will be transferred pty<->gdb-remote we need to 307 // give the pty primary handle to this object to read and/or write 308 LLDB_LOG(log, 309 "pid = {0}: setting up stdout/stderr redirection via $O " 310 "gdb-remote commands", 311 m_current_process->GetID()); 312 313 // Setup stdout/stderr mapping from inferior to $O 314 auto terminal_fd = m_current_process->GetTerminalFileDescriptor(); 315 if (terminal_fd >= 0) { 316 LLDB_LOGF(log, 317 "ProcessGDBRemoteCommunicationServerLLGS::%s setting " 318 "inferior STDIO fd to %d", 319 __FUNCTION__, terminal_fd); 320 Status status = SetSTDIOFileDescriptor(terminal_fd); 321 if (status.Fail()) 322 return status; 323 } else { 324 LLDB_LOGF(log, 325 "ProcessGDBRemoteCommunicationServerLLGS::%s ignoring " 326 "inferior STDIO since terminal fd reported as %d", 327 __FUNCTION__, terminal_fd); 328 } 329 } else { 330 LLDB_LOG(log, 331 "pid = {0} skipping stdout/stderr redirection via $O: inferior " 332 "will communicate over client-provided file descriptors", 333 m_current_process->GetID()); 334 } 335 336 printf("Launched '%s' as process %" PRIu64 "...\n", 337 m_process_launch_info.GetArguments().GetArgumentAtIndex(0), 338 m_current_process->GetID()); 339 340 return Status(); 341} 342 343Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) { 344 Log *log = GetLog(LLDBLog::Process); 345 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, 346 __FUNCTION__, pid); 347 348 // Before we try to attach, make sure we aren't already monitoring something 349 // else. 350 if (!m_debugged_processes.empty()) 351 return Status("cannot attach to process %" PRIu64 352 " when another process with pid %" PRIu64 353 " is being debugged.", 354 pid, m_current_process->GetID()); 355 356 // Try to attach. 357 auto process_or = m_process_manager.Attach(pid, *this); 358 if (!process_or) { 359 Status status(process_or.takeError()); 360 llvm::errs() << llvm::formatv("failed to attach to process {0}: {1}\n", pid, 361 status); 362 return status; 363 } 364 m_continue_process = m_current_process = process_or->get(); 365 m_debugged_processes.emplace( 366 m_current_process->GetID(), 367 DebuggedProcess{std::move(*process_or), DebuggedProcess::Flag{}}); 368 SetEnabledExtensions(*m_current_process); 369 370 // Setup stdout/stderr mapping from inferior. 371 auto terminal_fd = m_current_process->GetTerminalFileDescriptor(); 372 if (terminal_fd >= 0) { 373 LLDB_LOGF(log, 374 "ProcessGDBRemoteCommunicationServerLLGS::%s setting " 375 "inferior STDIO fd to %d", 376 __FUNCTION__, terminal_fd); 377 Status status = SetSTDIOFileDescriptor(terminal_fd); 378 if (status.Fail()) 379 return status; 380 } else { 381 LLDB_LOGF(log, 382 "ProcessGDBRemoteCommunicationServerLLGS::%s ignoring " 383 "inferior STDIO since terminal fd reported as %d", 384 __FUNCTION__, terminal_fd); 385 } 386 387 printf("Attached to process %" PRIu64 "...\n", pid); 388 return Status(); 389} 390 391Status GDBRemoteCommunicationServerLLGS::AttachWaitProcess( 392 llvm::StringRef process_name, bool include_existing) { 393 Log *log = GetLog(LLDBLog::Process); 394 395 std::chrono::milliseconds polling_interval = std::chrono::milliseconds(1); 396 397 // Create the matcher used to search the process list. 398 ProcessInstanceInfoList exclusion_list; 399 ProcessInstanceInfoMatch match_info; 400 match_info.GetProcessInfo().GetExecutableFile().SetFile( 401 process_name, llvm::sys::path::Style::native); 402 match_info.SetNameMatchType(NameMatch::Equals); 403 404 if (include_existing) { 405 LLDB_LOG(log, "including existing processes in search"); 406 } else { 407 // Create the excluded process list before polling begins. 408 Host::FindProcesses(match_info, exclusion_list); 409 LLDB_LOG(log, "placed '{0}' processes in the exclusion list.", 410 exclusion_list.size()); 411 } 412 413 LLDB_LOG(log, "waiting for '{0}' to appear", process_name); 414 415 auto is_in_exclusion_list = 416 [&exclusion_list](const ProcessInstanceInfo &info) { 417 for (auto &excluded : exclusion_list) { 418 if (excluded.GetProcessID() == info.GetProcessID()) 419 return true; 420 } 421 return false; 422 }; 423 424 ProcessInstanceInfoList loop_process_list; 425 while (true) { 426 loop_process_list.clear(); 427 if (Host::FindProcesses(match_info, loop_process_list)) { 428 // Remove all the elements that are in the exclusion list. 429 llvm::erase_if(loop_process_list, is_in_exclusion_list); 430 431 // One match! We found the desired process. 432 if (loop_process_list.size() == 1) { 433 auto matching_process_pid = loop_process_list[0].GetProcessID(); 434 LLDB_LOG(log, "found pid {0}", matching_process_pid); 435 return AttachToProcess(matching_process_pid); 436 } 437 438 // Multiple matches! Return an error reporting the PIDs we found. 439 if (loop_process_list.size() > 1) { 440 StreamString error_stream; 441 error_stream.Format( 442 "Multiple executables with name: '{0}' found. Pids: ", 443 process_name); 444 for (size_t i = 0; i < loop_process_list.size() - 1; ++i) { 445 error_stream.Format("{0}, ", loop_process_list[i].GetProcessID()); 446 } 447 error_stream.Format("{0}.", loop_process_list.back().GetProcessID()); 448 449 Status error; 450 error.SetErrorString(error_stream.GetString()); 451 return error; 452 } 453 } 454 // No matches, we have not found the process. Sleep until next poll. 455 LLDB_LOG(log, "sleep {0} seconds", polling_interval); 456 std::this_thread::sleep_for(polling_interval); 457 } 458} 459 460void GDBRemoteCommunicationServerLLGS::InitializeDelegate( 461 NativeProcessProtocol *process) { 462 assert(process && "process cannot be NULL"); 463 Log *log = GetLog(LLDBLog::Process); 464 if (log) { 465 LLDB_LOGF(log, 466 "GDBRemoteCommunicationServerLLGS::%s called with " 467 "NativeProcessProtocol pid %" PRIu64 ", current state: %s", 468 __FUNCTION__, process->GetID(), 469 StateAsCString(process->GetState())); 470 } 471} 472 473GDBRemoteCommunication::PacketResult 474GDBRemoteCommunicationServerLLGS::SendWResponse( 475 NativeProcessProtocol *process) { 476 assert(process && "process cannot be NULL"); 477 Log *log = GetLog(LLDBLog::Process); 478 479 // send W notification 480 auto wait_status = process->GetExitStatus(); 481 if (!wait_status) { 482 LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status", 483 process->GetID()); 484 485 StreamGDBRemote response; 486 response.PutChar('E'); 487 response.PutHex8(GDBRemoteServerError::eErrorExitStatus); 488 return SendPacketNoLock(response.GetString()); 489 } 490 491 LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(), 492 *wait_status); 493 494 // If the process was killed through vKill, return "OK". 495 if (bool(m_debugged_processes.at(process->GetID()).flags & 496 DebuggedProcess::Flag::vkilled)) 497 return SendOKResponse(); 498 499 StreamGDBRemote response; 500 response.Format("{0:g}", *wait_status); 501 if (bool(m_extensions_supported & 502 NativeProcessProtocol::Extension::multiprocess)) 503 response.Format(";process:{0:x-}", process->GetID()); 504 if (m_non_stop) 505 return SendNotificationPacketNoLock("Stop", m_stop_notification_queue, 506 response.GetString()); 507 return SendPacketNoLock(response.GetString()); 508} 509 510static void AppendHexValue(StreamString &response, const uint8_t *buf, 511 uint32_t buf_size, bool swap) { 512 int64_t i; 513 if (swap) { 514 for (i = buf_size - 1; i >= 0; i--) 515 response.PutHex8(buf[i]); 516 } else { 517 for (i = 0; i < buf_size; i++) 518 response.PutHex8(buf[i]); 519 } 520} 521 522static llvm::StringRef GetEncodingNameOrEmpty(const RegisterInfo ®_info) { 523 switch (reg_info.encoding) { 524 case eEncodingUint: 525 return "uint"; 526 case eEncodingSint: 527 return "sint"; 528 case eEncodingIEEE754: 529 return "ieee754"; 530 case eEncodingVector: 531 return "vector"; 532 default: 533 return ""; 534 } 535} 536 537static llvm::StringRef GetFormatNameOrEmpty(const RegisterInfo ®_info) { 538 switch (reg_info.format) { 539 case eFormatBinary: 540 return "binary"; 541 case eFormatDecimal: 542 return "decimal"; 543 case eFormatHex: 544 return "hex"; 545 case eFormatFloat: 546 return "float"; 547 case eFormatVectorOfSInt8: 548 return "vector-sint8"; 549 case eFormatVectorOfUInt8: 550 return "vector-uint8"; 551 case eFormatVectorOfSInt16: 552 return "vector-sint16"; 553 case eFormatVectorOfUInt16: 554 return "vector-uint16"; 555 case eFormatVectorOfSInt32: 556 return "vector-sint32"; 557 case eFormatVectorOfUInt32: 558 return "vector-uint32"; 559 case eFormatVectorOfFloat32: 560 return "vector-float32"; 561 case eFormatVectorOfUInt64: 562 return "vector-uint64"; 563 case eFormatVectorOfUInt128: 564 return "vector-uint128"; 565 default: 566 return ""; 567 }; 568} 569 570static llvm::StringRef GetKindGenericOrEmpty(const RegisterInfo ®_info) { 571 switch (reg_info.kinds[RegisterKind::eRegisterKindGeneric]) { 572 case LLDB_REGNUM_GENERIC_PC: 573 return "pc"; 574 case LLDB_REGNUM_GENERIC_SP: 575 return "sp"; 576 case LLDB_REGNUM_GENERIC_FP: 577 return "fp"; 578 case LLDB_REGNUM_GENERIC_RA: 579 return "ra"; 580 case LLDB_REGNUM_GENERIC_FLAGS: 581 return "flags"; 582 case LLDB_REGNUM_GENERIC_ARG1: 583 return "arg1"; 584 case LLDB_REGNUM_GENERIC_ARG2: 585 return "arg2"; 586 case LLDB_REGNUM_GENERIC_ARG3: 587 return "arg3"; 588 case LLDB_REGNUM_GENERIC_ARG4: 589 return "arg4"; 590 case LLDB_REGNUM_GENERIC_ARG5: 591 return "arg5"; 592 case LLDB_REGNUM_GENERIC_ARG6: 593 return "arg6"; 594 case LLDB_REGNUM_GENERIC_ARG7: 595 return "arg7"; 596 case LLDB_REGNUM_GENERIC_ARG8: 597 return "arg8"; 598 case LLDB_REGNUM_GENERIC_TP: 599 return "tp"; 600 default: 601 return ""; 602 } 603} 604 605static void CollectRegNums(const uint32_t *reg_num, StreamString &response, 606 bool usehex) { 607 for (int i = 0; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) { 608 if (i > 0) 609 response.PutChar(','); 610 if (usehex) 611 response.Printf("%" PRIx32, *reg_num); 612 else 613 response.Printf("%" PRIu32, *reg_num); 614 } 615} 616 617static void WriteRegisterValueInHexFixedWidth( 618 StreamString &response, NativeRegisterContext ®_ctx, 619 const RegisterInfo ®_info, const RegisterValue *reg_value_p, 620 lldb::ByteOrder byte_order) { 621 RegisterValue reg_value; 622 if (!reg_value_p) { 623 Status error = reg_ctx.ReadRegister(®_info, reg_value); 624 if (error.Success()) 625 reg_value_p = ®_value; 626 // else log. 627 } 628 629 if (reg_value_p) { 630 AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(), 631 reg_value_p->GetByteSize(), 632 byte_order == lldb::eByteOrderLittle); 633 } else { 634 // Zero-out any unreadable values. 635 if (reg_info.byte_size > 0) { 636 std::vector<uint8_t> zeros(reg_info.byte_size, '\0'); 637 AppendHexValue(response, zeros.data(), zeros.size(), false); 638 } 639 } 640} 641 642static std::optional<json::Object> 643GetRegistersAsJSON(NativeThreadProtocol &thread) { 644 Log *log = GetLog(LLDBLog::Thread); 645 646 NativeRegisterContext& reg_ctx = thread.GetRegisterContext(); 647 648 json::Object register_object; 649 650#ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET 651 const auto expedited_regs = 652 reg_ctx.GetExpeditedRegisters(ExpeditedRegs::Full); 653#else 654 const auto expedited_regs = 655 reg_ctx.GetExpeditedRegisters(ExpeditedRegs::Minimal); 656#endif 657 if (expedited_regs.empty()) 658 return std::nullopt; 659 660 for (auto ®_num : expedited_regs) { 661 const RegisterInfo *const reg_info_p = 662 reg_ctx.GetRegisterInfoAtIndex(reg_num); 663 if (reg_info_p == nullptr) { 664 LLDB_LOGF(log, 665 "%s failed to get register info for register index %" PRIu32, 666 __FUNCTION__, reg_num); 667 continue; 668 } 669 670 if (reg_info_p->value_regs != nullptr) 671 continue; // Only expedite registers that are not contained in other 672 // registers. 673 674 RegisterValue reg_value; 675 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 676 if (error.Fail()) { 677 LLDB_LOGF(log, "%s failed to read register '%s' index %" PRIu32 ": %s", 678 __FUNCTION__, 679 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 680 reg_num, error.AsCString()); 681 continue; 682 } 683 684 StreamString stream; 685 WriteRegisterValueInHexFixedWidth(stream, reg_ctx, *reg_info_p, 686 ®_value, lldb::eByteOrderBig); 687 688 register_object.try_emplace(llvm::to_string(reg_num), 689 stream.GetString().str()); 690 } 691 692 return register_object; 693} 694 695static const char *GetStopReasonString(StopReason stop_reason) { 696 switch (stop_reason) { 697 case eStopReasonTrace: 698 return "trace"; 699 case eStopReasonBreakpoint: 700 return "breakpoint"; 701 case eStopReasonWatchpoint: 702 return "watchpoint"; 703 case eStopReasonSignal: 704 return "signal"; 705 case eStopReasonException: 706 return "exception"; 707 case eStopReasonExec: 708 return "exec"; 709 case eStopReasonProcessorTrace: 710 return "processor trace"; 711 case eStopReasonFork: 712 return "fork"; 713 case eStopReasonVFork: 714 return "vfork"; 715 case eStopReasonVForkDone: 716 return "vforkdone"; 717 case eStopReasonInstrumentation: 718 case eStopReasonInvalid: 719 case eStopReasonPlanComplete: 720 case eStopReasonThreadExiting: 721 case eStopReasonNone: 722 break; // ignored 723 } 724 return nullptr; 725} 726 727static llvm::Expected<json::Array> 728GetJSONThreadsInfo(NativeProcessProtocol &process, bool abridged) { 729 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 730 731 json::Array threads_array; 732 733 // Ensure we can get info on the given thread. 734 for (NativeThreadProtocol &thread : process.Threads()) { 735 lldb::tid_t tid = thread.GetID(); 736 // Grab the reason this thread stopped. 737 struct ThreadStopInfo tid_stop_info; 738 std::string description; 739 if (!thread.GetStopReason(tid_stop_info, description)) 740 return llvm::make_error<llvm::StringError>( 741 "failed to get stop reason", llvm::inconvertibleErrorCode()); 742 743 const int signum = tid_stop_info.signo; 744 if (log) { 745 LLDB_LOGF(log, 746 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 747 " tid %" PRIu64 748 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 749 __FUNCTION__, process.GetID(), tid, signum, 750 tid_stop_info.reason, tid_stop_info.details.exception.type); 751 } 752 753 json::Object thread_obj; 754 755 if (!abridged) { 756 if (std::optional<json::Object> registers = GetRegistersAsJSON(thread)) 757 thread_obj.try_emplace("registers", std::move(*registers)); 758 } 759 760 thread_obj.try_emplace("tid", static_cast<int64_t>(tid)); 761 762 if (signum != 0) 763 thread_obj.try_emplace("signal", signum); 764 765 const std::string thread_name = thread.GetName(); 766 if (!thread_name.empty()) 767 thread_obj.try_emplace("name", thread_name); 768 769 const char *stop_reason = GetStopReasonString(tid_stop_info.reason); 770 if (stop_reason) 771 thread_obj.try_emplace("reason", stop_reason); 772 773 if (!description.empty()) 774 thread_obj.try_emplace("description", description); 775 776 if ((tid_stop_info.reason == eStopReasonException) && 777 tid_stop_info.details.exception.type) { 778 thread_obj.try_emplace( 779 "metype", static_cast<int64_t>(tid_stop_info.details.exception.type)); 780 781 json::Array medata_array; 782 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; 783 ++i) { 784 medata_array.push_back( 785 static_cast<int64_t>(tid_stop_info.details.exception.data[i])); 786 } 787 thread_obj.try_emplace("medata", std::move(medata_array)); 788 } 789 threads_array.push_back(std::move(thread_obj)); 790 } 791 return threads_array; 792} 793 794StreamString 795GDBRemoteCommunicationServerLLGS::PrepareStopReplyPacketForThread( 796 NativeThreadProtocol &thread) { 797 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 798 799 NativeProcessProtocol &process = thread.GetProcess(); 800 801 LLDB_LOG(log, "preparing packet for pid {0} tid {1}", process.GetID(), 802 thread.GetID()); 803 804 // Grab the reason this thread stopped. 805 StreamString response; 806 struct ThreadStopInfo tid_stop_info; 807 std::string description; 808 if (!thread.GetStopReason(tid_stop_info, description)) 809 return response; 810 811 // FIXME implement register handling for exec'd inferiors. 812 // if (tid_stop_info.reason == eStopReasonExec) { 813 // const bool force = true; 814 // InitializeRegisters(force); 815 // } 816 817 // Output the T packet with the thread 818 response.PutChar('T'); 819 int signum = tid_stop_info.signo; 820 LLDB_LOG( 821 log, 822 "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}", 823 process.GetID(), thread.GetID(), signum, int(tid_stop_info.reason), 824 tid_stop_info.details.exception.type); 825 826 // Print the signal number. 827 response.PutHex8(signum & 0xff); 828 829 // Include the (pid and) tid. 830 response.PutCString("thread:"); 831 AppendThreadIDToResponse(response, process.GetID(), thread.GetID()); 832 response.PutChar(';'); 833 834 // Include the thread name if there is one. 835 const std::string thread_name = thread.GetName(); 836 if (!thread_name.empty()) { 837 size_t thread_name_len = thread_name.length(); 838 839 if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) { 840 response.PutCString("name:"); 841 response.PutCString(thread_name); 842 } else { 843 // The thread name contains special chars, send as hex bytes. 844 response.PutCString("hexname:"); 845 response.PutStringAsRawHex8(thread_name); 846 } 847 response.PutChar(';'); 848 } 849 850 // If a 'QListThreadsInStopReply' was sent to enable this feature, we will 851 // send all thread IDs back in the "threads" key whose value is a list of hex 852 // thread IDs separated by commas: 853 // "threads:10a,10b,10c;" 854 // This will save the debugger from having to send a pair of qfThreadInfo and 855 // qsThreadInfo packets, but it also might take a lot of room in the stop 856 // reply packet, so it must be enabled only on systems where there are no 857 // limits on packet lengths. 858 if (m_list_threads_in_stop_reply) { 859 response.PutCString("threads:"); 860 861 uint32_t thread_num = 0; 862 for (NativeThreadProtocol &listed_thread : process.Threads()) { 863 if (thread_num > 0) 864 response.PutChar(','); 865 response.Printf("%" PRIx64, listed_thread.GetID()); 866 ++thread_num; 867 } 868 response.PutChar(';'); 869 870 // Include JSON info that describes the stop reason for any threads that 871 // actually have stop reasons. We use the new "jstopinfo" key whose values 872 // is hex ascii JSON that contains the thread IDs thread stop info only for 873 // threads that have stop reasons. Only send this if we have more than one 874 // thread otherwise this packet has all the info it needs. 875 if (thread_num > 1) { 876 const bool threads_with_valid_stop_info_only = true; 877 llvm::Expected<json::Array> threads_info = GetJSONThreadsInfo( 878 *m_current_process, threads_with_valid_stop_info_only); 879 if (threads_info) { 880 response.PutCString("jstopinfo:"); 881 StreamString unescaped_response; 882 unescaped_response.AsRawOstream() << std::move(*threads_info); 883 response.PutStringAsRawHex8(unescaped_response.GetData()); 884 response.PutChar(';'); 885 } else { 886 LLDB_LOG_ERROR(log, threads_info.takeError(), 887 "failed to prepare a jstopinfo field for pid {1}: {0}", 888 process.GetID()); 889 } 890 } 891 892 response.PutCString("thread-pcs"); 893 char delimiter = ':'; 894 for (NativeThreadProtocol &thread : process.Threads()) { 895 NativeRegisterContext ®_ctx = thread.GetRegisterContext(); 896 897 uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber( 898 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 899 const RegisterInfo *const reg_info_p = 900 reg_ctx.GetRegisterInfoAtIndex(reg_to_read); 901 902 RegisterValue reg_value; 903 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 904 if (error.Fail()) { 905 LLDB_LOGF(log, "%s failed to read register '%s' index %" PRIu32 ": %s", 906 __FUNCTION__, 907 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 908 reg_to_read, error.AsCString()); 909 continue; 910 } 911 912 response.PutChar(delimiter); 913 delimiter = ','; 914 WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p, 915 ®_value, endian::InlHostByteOrder()); 916 } 917 918 response.PutChar(';'); 919 } 920 921 // 922 // Expedite registers. 923 // 924 925 // Grab the register context. 926 NativeRegisterContext ®_ctx = thread.GetRegisterContext(); 927 const auto expedited_regs = 928 reg_ctx.GetExpeditedRegisters(ExpeditedRegs::Full); 929 930 for (auto ®_num : expedited_regs) { 931 const RegisterInfo *const reg_info_p = 932 reg_ctx.GetRegisterInfoAtIndex(reg_num); 933 // Only expediate registers that are not contained in other registers. 934 if (reg_info_p != nullptr && reg_info_p->value_regs == nullptr) { 935 RegisterValue reg_value; 936 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 937 if (error.Success()) { 938 response.Printf("%.02x:", reg_num); 939 WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p, 940 ®_value, lldb::eByteOrderBig); 941 response.PutChar(';'); 942 } else { 943 LLDB_LOGF(log, 944 "GDBRemoteCommunicationServerLLGS::%s failed to read " 945 "register '%s' index %" PRIu32 ": %s", 946 __FUNCTION__, 947 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 948 reg_num, error.AsCString()); 949 } 950 } 951 } 952 953 const char *reason_str = GetStopReasonString(tid_stop_info.reason); 954 if (reason_str != nullptr) { 955 response.Printf("reason:%s;", reason_str); 956 } 957 958 if (!description.empty()) { 959 // Description may contains special chars, send as hex bytes. 960 response.PutCString("description:"); 961 response.PutStringAsRawHex8(description); 962 response.PutChar(';'); 963 } else if ((tid_stop_info.reason == eStopReasonException) && 964 tid_stop_info.details.exception.type) { 965 response.PutCString("metype:"); 966 response.PutHex64(tid_stop_info.details.exception.type); 967 response.PutCString(";mecount:"); 968 response.PutHex32(tid_stop_info.details.exception.data_count); 969 response.PutChar(';'); 970 971 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) { 972 response.PutCString("medata:"); 973 response.PutHex64(tid_stop_info.details.exception.data[i]); 974 response.PutChar(';'); 975 } 976 } 977 978 // Include child process PID/TID for forks. 979 if (tid_stop_info.reason == eStopReasonFork || 980 tid_stop_info.reason == eStopReasonVFork) { 981 assert(bool(m_extensions_supported & 982 NativeProcessProtocol::Extension::multiprocess)); 983 if (tid_stop_info.reason == eStopReasonFork) 984 assert(bool(m_extensions_supported & 985 NativeProcessProtocol::Extension::fork)); 986 if (tid_stop_info.reason == eStopReasonVFork) 987 assert(bool(m_extensions_supported & 988 NativeProcessProtocol::Extension::vfork)); 989 response.Printf("%s:p%" PRIx64 ".%" PRIx64 ";", reason_str, 990 tid_stop_info.details.fork.child_pid, 991 tid_stop_info.details.fork.child_tid); 992 } 993 994 return response; 995} 996 997GDBRemoteCommunication::PacketResult 998GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 999 NativeProcessProtocol &process, lldb::tid_t tid, bool force_synchronous) { 1000 // Ensure we can get info on the given thread. 1001 NativeThreadProtocol *thread = process.GetThreadByID(tid); 1002 if (!thread) 1003 return SendErrorResponse(51); 1004 1005 StreamString response = PrepareStopReplyPacketForThread(*thread); 1006 if (response.Empty()) 1007 return SendErrorResponse(42); 1008 1009 if (m_non_stop && !force_synchronous) { 1010 PacketResult ret = SendNotificationPacketNoLock( 1011 "Stop", m_stop_notification_queue, response.GetString()); 1012 // Queue notification events for the remaining threads. 1013 EnqueueStopReplyPackets(tid); 1014 return ret; 1015 } 1016 1017 return SendPacketNoLock(response.GetString()); 1018} 1019 1020void GDBRemoteCommunicationServerLLGS::EnqueueStopReplyPackets( 1021 lldb::tid_t thread_to_skip) { 1022 if (!m_non_stop) 1023 return; 1024 1025 for (NativeThreadProtocol &listed_thread : m_current_process->Threads()) { 1026 if (listed_thread.GetID() != thread_to_skip) { 1027 StreamString stop_reply = PrepareStopReplyPacketForThread(listed_thread); 1028 if (!stop_reply.Empty()) 1029 m_stop_notification_queue.push_back(stop_reply.GetString().str()); 1030 } 1031 } 1032} 1033 1034void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited( 1035 NativeProcessProtocol *process) { 1036 assert(process && "process cannot be NULL"); 1037 1038 Log *log = GetLog(LLDBLog::Process); 1039 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1040 1041 PacketResult result = SendStopReasonForState( 1042 *process, StateType::eStateExited, /*force_synchronous=*/false); 1043 if (result != PacketResult::Success) { 1044 LLDB_LOGF(log, 1045 "GDBRemoteCommunicationServerLLGS::%s failed to send stop " 1046 "notification for PID %" PRIu64 ", state: eStateExited", 1047 __FUNCTION__, process->GetID()); 1048 } 1049 1050 if (m_current_process == process) 1051 m_current_process = nullptr; 1052 if (m_continue_process == process) 1053 m_continue_process = nullptr; 1054 1055 lldb::pid_t pid = process->GetID(); 1056 m_mainloop.AddPendingCallback([this, pid](MainLoopBase &loop) { 1057 auto find_it = m_debugged_processes.find(pid); 1058 assert(find_it != m_debugged_processes.end()); 1059 bool vkilled = bool(find_it->second.flags & DebuggedProcess::Flag::vkilled); 1060 m_debugged_processes.erase(find_it); 1061 // Terminate the main loop only if vKill has not been used. 1062 // When running in non-stop mode, wait for the vStopped to clear 1063 // the notification queue. 1064 if (m_debugged_processes.empty() && !m_non_stop && !vkilled) { 1065 // Close the pipe to the inferior terminal i/o if we launched it and set 1066 // one up. 1067 MaybeCloseInferiorTerminalConnection(); 1068 1069 // We are ready to exit the debug monitor. 1070 m_exit_now = true; 1071 loop.RequestTermination(); 1072 } 1073 }); 1074} 1075 1076void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped( 1077 NativeProcessProtocol *process) { 1078 assert(process && "process cannot be NULL"); 1079 1080 Log *log = GetLog(LLDBLog::Process); 1081 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1082 1083 PacketResult result = SendStopReasonForState( 1084 *process, StateType::eStateStopped, /*force_synchronous=*/false); 1085 if (result != PacketResult::Success) { 1086 LLDB_LOGF(log, 1087 "GDBRemoteCommunicationServerLLGS::%s failed to send stop " 1088 "notification for PID %" PRIu64 ", state: eStateExited", 1089 __FUNCTION__, process->GetID()); 1090 } 1091} 1092 1093void GDBRemoteCommunicationServerLLGS::ProcessStateChanged( 1094 NativeProcessProtocol *process, lldb::StateType state) { 1095 assert(process && "process cannot be NULL"); 1096 Log *log = GetLog(LLDBLog::Process); 1097 if (log) { 1098 LLDB_LOGF(log, 1099 "GDBRemoteCommunicationServerLLGS::%s called with " 1100 "NativeProcessProtocol pid %" PRIu64 ", state: %s", 1101 __FUNCTION__, process->GetID(), StateAsCString(state)); 1102 } 1103 1104 switch (state) { 1105 case StateType::eStateRunning: 1106 break; 1107 1108 case StateType::eStateStopped: 1109 // Make sure we get all of the pending stdout/stderr from the inferior and 1110 // send it to the lldb host before we send the state change notification 1111 SendProcessOutput(); 1112 // Then stop the forwarding, so that any late output (see llvm.org/pr25652) 1113 // does not interfere with our protocol. 1114 if (!m_non_stop) 1115 StopSTDIOForwarding(); 1116 HandleInferiorState_Stopped(process); 1117 break; 1118 1119 case StateType::eStateExited: 1120 // Same as above 1121 SendProcessOutput(); 1122 if (!m_non_stop) 1123 StopSTDIOForwarding(); 1124 HandleInferiorState_Exited(process); 1125 break; 1126 1127 default: 1128 if (log) { 1129 LLDB_LOGF(log, 1130 "GDBRemoteCommunicationServerLLGS::%s didn't handle state " 1131 "change for pid %" PRIu64 ", new state: %s", 1132 __FUNCTION__, process->GetID(), StateAsCString(state)); 1133 } 1134 break; 1135 } 1136} 1137 1138void GDBRemoteCommunicationServerLLGS::DidExec(NativeProcessProtocol *process) { 1139 ClearProcessSpecificData(); 1140} 1141 1142void GDBRemoteCommunicationServerLLGS::NewSubprocess( 1143 NativeProcessProtocol *parent_process, 1144 std::unique_ptr<NativeProcessProtocol> child_process) { 1145 lldb::pid_t child_pid = child_process->GetID(); 1146 assert(child_pid != LLDB_INVALID_PROCESS_ID); 1147 assert(m_debugged_processes.find(child_pid) == m_debugged_processes.end()); 1148 m_debugged_processes.emplace( 1149 child_pid, 1150 DebuggedProcess{std::move(child_process), DebuggedProcess::Flag{}}); 1151} 1152 1153void GDBRemoteCommunicationServerLLGS::DataAvailableCallback() { 1154 Log *log = GetLog(GDBRLog::Comm); 1155 1156 bool interrupt = false; 1157 bool done = false; 1158 Status error; 1159 while (true) { 1160 const PacketResult result = GetPacketAndSendResponse( 1161 std::chrono::microseconds(0), error, interrupt, done); 1162 if (result == PacketResult::ErrorReplyTimeout) 1163 break; // No more packets in the queue 1164 1165 if ((result != PacketResult::Success)) { 1166 LLDB_LOGF(log, 1167 "GDBRemoteCommunicationServerLLGS::%s processing a packet " 1168 "failed: %s", 1169 __FUNCTION__, error.AsCString()); 1170 m_mainloop.RequestTermination(); 1171 break; 1172 } 1173 } 1174} 1175 1176Status GDBRemoteCommunicationServerLLGS::InitializeConnection( 1177 std::unique_ptr<Connection> connection) { 1178 IOObjectSP read_object_sp = connection->GetReadObject(); 1179 GDBRemoteCommunicationServer::SetConnection(std::move(connection)); 1180 1181 Status error; 1182 m_network_handle_up = m_mainloop.RegisterReadObject( 1183 read_object_sp, [this](MainLoopBase &) { DataAvailableCallback(); }, 1184 error); 1185 return error; 1186} 1187 1188GDBRemoteCommunication::PacketResult 1189GDBRemoteCommunicationServerLLGS::SendONotification(const char *buffer, 1190 uint32_t len) { 1191 if ((buffer == nullptr) || (len == 0)) { 1192 // Nothing to send. 1193 return PacketResult::Success; 1194 } 1195 1196 StreamString response; 1197 response.PutChar('O'); 1198 response.PutBytesAsRawHex8(buffer, len); 1199 1200 if (m_non_stop) 1201 return SendNotificationPacketNoLock("Stdio", m_stdio_notification_queue, 1202 response.GetString()); 1203 return SendPacketNoLock(response.GetString()); 1204} 1205 1206Status GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) { 1207 Status error; 1208 1209 // Set up the reading/handling of process I/O 1210 std::unique_ptr<ConnectionFileDescriptor> conn_up( 1211 new ConnectionFileDescriptor(fd, true)); 1212 if (!conn_up) { 1213 error.SetErrorString("failed to create ConnectionFileDescriptor"); 1214 return error; 1215 } 1216 1217 m_stdio_communication.SetCloseOnEOF(false); 1218 m_stdio_communication.SetConnection(std::move(conn_up)); 1219 if (!m_stdio_communication.IsConnected()) { 1220 error.SetErrorString( 1221 "failed to set connection for inferior I/O communication"); 1222 return error; 1223 } 1224 1225 return Status(); 1226} 1227 1228void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() { 1229 // Don't forward if not connected (e.g. when attaching). 1230 if (!m_stdio_communication.IsConnected()) 1231 return; 1232 1233 Status error; 1234 assert(!m_stdio_handle_up); 1235 m_stdio_handle_up = m_mainloop.RegisterReadObject( 1236 m_stdio_communication.GetConnection()->GetReadObject(), 1237 [this](MainLoopBase &) { SendProcessOutput(); }, error); 1238 1239 if (!m_stdio_handle_up) { 1240 // Not much we can do about the failure. Log it and continue without 1241 // forwarding. 1242 if (Log *log = GetLog(LLDBLog::Process)) 1243 LLDB_LOG(log, "Failed to set up stdio forwarding: {0}", error); 1244 } 1245} 1246 1247void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() { 1248 m_stdio_handle_up.reset(); 1249} 1250 1251void GDBRemoteCommunicationServerLLGS::SendProcessOutput() { 1252 char buffer[1024]; 1253 ConnectionStatus status; 1254 Status error; 1255 while (true) { 1256 size_t bytes_read = m_stdio_communication.Read( 1257 buffer, sizeof buffer, std::chrono::microseconds(0), status, &error); 1258 switch (status) { 1259 case eConnectionStatusSuccess: 1260 SendONotification(buffer, bytes_read); 1261 break; 1262 case eConnectionStatusLostConnection: 1263 case eConnectionStatusEndOfFile: 1264 case eConnectionStatusError: 1265 case eConnectionStatusNoConnection: 1266 if (Log *log = GetLog(LLDBLog::Process)) 1267 LLDB_LOGF(log, 1268 "GDBRemoteCommunicationServerLLGS::%s Stopping stdio " 1269 "forwarding as communication returned status %d (error: " 1270 "%s)", 1271 __FUNCTION__, status, error.AsCString()); 1272 m_stdio_handle_up.reset(); 1273 return; 1274 1275 case eConnectionStatusInterrupted: 1276 case eConnectionStatusTimedOut: 1277 return; 1278 } 1279 } 1280} 1281 1282GDBRemoteCommunication::PacketResult 1283GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupported( 1284 StringExtractorGDBRemote &packet) { 1285 1286 // Fail if we don't have a current process. 1287 if (!m_current_process || 1288 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1289 return SendErrorResponse(Status("Process not running.")); 1290 1291 return SendJSONResponse(m_current_process->TraceSupported()); 1292} 1293 1294GDBRemoteCommunication::PacketResult 1295GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop( 1296 StringExtractorGDBRemote &packet) { 1297 // Fail if we don't have a current process. 1298 if (!m_current_process || 1299 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1300 return SendErrorResponse(Status("Process not running.")); 1301 1302 packet.ConsumeFront("jLLDBTraceStop:"); 1303 Expected<TraceStopRequest> stop_request = 1304 json::parse<TraceStopRequest>(packet.Peek(), "TraceStopRequest"); 1305 if (!stop_request) 1306 return SendErrorResponse(stop_request.takeError()); 1307 1308 if (Error err = m_current_process->TraceStop(*stop_request)) 1309 return SendErrorResponse(std::move(err)); 1310 1311 return SendOKResponse(); 1312} 1313 1314GDBRemoteCommunication::PacketResult 1315GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart( 1316 StringExtractorGDBRemote &packet) { 1317 1318 // Fail if we don't have a current process. 1319 if (!m_current_process || 1320 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1321 return SendErrorResponse(Status("Process not running.")); 1322 1323 packet.ConsumeFront("jLLDBTraceStart:"); 1324 Expected<TraceStartRequest> request = 1325 json::parse<TraceStartRequest>(packet.Peek(), "TraceStartRequest"); 1326 if (!request) 1327 return SendErrorResponse(request.takeError()); 1328 1329 if (Error err = m_current_process->TraceStart(packet.Peek(), request->type)) 1330 return SendErrorResponse(std::move(err)); 1331 1332 return SendOKResponse(); 1333} 1334 1335GDBRemoteCommunication::PacketResult 1336GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState( 1337 StringExtractorGDBRemote &packet) { 1338 1339 // Fail if we don't have a current process. 1340 if (!m_current_process || 1341 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1342 return SendErrorResponse(Status("Process not running.")); 1343 1344 packet.ConsumeFront("jLLDBTraceGetState:"); 1345 Expected<TraceGetStateRequest> request = 1346 json::parse<TraceGetStateRequest>(packet.Peek(), "TraceGetStateRequest"); 1347 if (!request) 1348 return SendErrorResponse(request.takeError()); 1349 1350 return SendJSONResponse(m_current_process->TraceGetState(request->type)); 1351} 1352 1353GDBRemoteCommunication::PacketResult 1354GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData( 1355 StringExtractorGDBRemote &packet) { 1356 1357 // Fail if we don't have a current process. 1358 if (!m_current_process || 1359 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1360 return SendErrorResponse(Status("Process not running.")); 1361 1362 packet.ConsumeFront("jLLDBTraceGetBinaryData:"); 1363 llvm::Expected<TraceGetBinaryDataRequest> request = 1364 llvm::json::parse<TraceGetBinaryDataRequest>(packet.Peek(), 1365 "TraceGetBinaryDataRequest"); 1366 if (!request) 1367 return SendErrorResponse(Status(request.takeError())); 1368 1369 if (Expected<std::vector<uint8_t>> bytes = 1370 m_current_process->TraceGetBinaryData(*request)) { 1371 StreamGDBRemote response; 1372 response.PutEscapedBytes(bytes->data(), bytes->size()); 1373 return SendPacketNoLock(response.GetString()); 1374 } else 1375 return SendErrorResponse(bytes.takeError()); 1376} 1377 1378GDBRemoteCommunication::PacketResult 1379GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo( 1380 StringExtractorGDBRemote &packet) { 1381 // Fail if we don't have a current process. 1382 if (!m_current_process || 1383 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1384 return SendErrorResponse(68); 1385 1386 lldb::pid_t pid = m_current_process->GetID(); 1387 1388 if (pid == LLDB_INVALID_PROCESS_ID) 1389 return SendErrorResponse(1); 1390 1391 ProcessInstanceInfo proc_info; 1392 if (!Host::GetProcessInfo(pid, proc_info)) 1393 return SendErrorResponse(1); 1394 1395 StreamString response; 1396 CreateProcessInfoResponse_DebugServerStyle(proc_info, response); 1397 return SendPacketNoLock(response.GetString()); 1398} 1399 1400GDBRemoteCommunication::PacketResult 1401GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) { 1402 // Fail if we don't have a current process. 1403 if (!m_current_process || 1404 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1405 return SendErrorResponse(68); 1406 1407 // Make sure we set the current thread so g and p packets return the data the 1408 // gdb will expect. 1409 lldb::tid_t tid = m_current_process->GetCurrentThreadID(); 1410 SetCurrentThreadID(tid); 1411 1412 NativeThreadProtocol *thread = m_current_process->GetCurrentThread(); 1413 if (!thread) 1414 return SendErrorResponse(69); 1415 1416 StreamString response; 1417 response.PutCString("QC"); 1418 AppendThreadIDToResponse(response, m_current_process->GetID(), 1419 thread->GetID()); 1420 1421 return SendPacketNoLock(response.GetString()); 1422} 1423 1424GDBRemoteCommunication::PacketResult 1425GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) { 1426 Log *log = GetLog(LLDBLog::Process); 1427 1428 if (!m_non_stop) 1429 StopSTDIOForwarding(); 1430 1431 if (m_debugged_processes.empty()) { 1432 LLDB_LOG(log, "No debugged process found."); 1433 return PacketResult::Success; 1434 } 1435 1436 for (auto it = m_debugged_processes.begin(); it != m_debugged_processes.end(); 1437 ++it) { 1438 LLDB_LOG(log, "Killing process {0}", it->first); 1439 Status error = it->second.process_up->Kill(); 1440 if (error.Fail()) 1441 LLDB_LOG(log, "Failed to kill debugged process {0}: {1}", it->first, 1442 error); 1443 } 1444 1445 // The response to kill packet is undefined per the spec. LLDB 1446 // follows the same rules as for continue packets, i.e. no response 1447 // in all-stop mode, and "OK" in non-stop mode; in both cases this 1448 // is followed by the actual stop reason. 1449 return SendContinueSuccessResponse(); 1450} 1451 1452GDBRemoteCommunication::PacketResult 1453GDBRemoteCommunicationServerLLGS::Handle_vKill( 1454 StringExtractorGDBRemote &packet) { 1455 if (!m_non_stop) 1456 StopSTDIOForwarding(); 1457 1458 packet.SetFilePos(6); // vKill; 1459 uint32_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 1460 if (pid == LLDB_INVALID_PROCESS_ID) 1461 return SendIllFormedResponse(packet, 1462 "vKill failed to parse the process id"); 1463 1464 auto it = m_debugged_processes.find(pid); 1465 if (it == m_debugged_processes.end()) 1466 return SendErrorResponse(42); 1467 1468 Status error = it->second.process_up->Kill(); 1469 if (error.Fail()) 1470 return SendErrorResponse(error.ToError()); 1471 1472 // OK response is sent when the process dies. 1473 it->second.flags |= DebuggedProcess::Flag::vkilled; 1474 return PacketResult::Success; 1475} 1476 1477GDBRemoteCommunication::PacketResult 1478GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR( 1479 StringExtractorGDBRemote &packet) { 1480 packet.SetFilePos(::strlen("QSetDisableASLR:")); 1481 if (packet.GetU32(0)) 1482 m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR); 1483 else 1484 m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR); 1485 return SendOKResponse(); 1486} 1487 1488GDBRemoteCommunication::PacketResult 1489GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir( 1490 StringExtractorGDBRemote &packet) { 1491 packet.SetFilePos(::strlen("QSetWorkingDir:")); 1492 std::string path; 1493 packet.GetHexByteString(path); 1494 m_process_launch_info.SetWorkingDirectory(FileSpec(path)); 1495 return SendOKResponse(); 1496} 1497 1498GDBRemoteCommunication::PacketResult 1499GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir( 1500 StringExtractorGDBRemote &packet) { 1501 FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()}; 1502 if (working_dir) { 1503 StreamString response; 1504 response.PutStringAsRawHex8(working_dir.GetPath().c_str()); 1505 return SendPacketNoLock(response.GetString()); 1506 } 1507 1508 return SendErrorResponse(14); 1509} 1510 1511GDBRemoteCommunication::PacketResult 1512GDBRemoteCommunicationServerLLGS::Handle_QThreadSuffixSupported( 1513 StringExtractorGDBRemote &packet) { 1514 m_thread_suffix_supported = true; 1515 return SendOKResponse(); 1516} 1517 1518GDBRemoteCommunication::PacketResult 1519GDBRemoteCommunicationServerLLGS::Handle_QListThreadsInStopReply( 1520 StringExtractorGDBRemote &packet) { 1521 m_list_threads_in_stop_reply = true; 1522 return SendOKResponse(); 1523} 1524 1525GDBRemoteCommunication::PacketResult 1526GDBRemoteCommunicationServerLLGS::ResumeProcess( 1527 NativeProcessProtocol &process, const ResumeActionList &actions) { 1528 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 1529 1530 // In non-stop protocol mode, the process could be running already. 1531 // We do not support resuming threads independently, so just error out. 1532 if (!process.CanResume()) { 1533 LLDB_LOG(log, "process {0} cannot be resumed (state={1})", process.GetID(), 1534 process.GetState()); 1535 return SendErrorResponse(0x37); 1536 } 1537 1538 Status error = process.Resume(actions); 1539 if (error.Fail()) { 1540 LLDB_LOG(log, "process {0} failed to resume: {1}", process.GetID(), error); 1541 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1542 } 1543 1544 LLDB_LOG(log, "process {0} resumed", process.GetID()); 1545 1546 return PacketResult::Success; 1547} 1548 1549GDBRemoteCommunication::PacketResult 1550GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) { 1551 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 1552 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1553 1554 // Ensure we have a native process. 1555 if (!m_continue_process) { 1556 LLDB_LOGF(log, 1557 "GDBRemoteCommunicationServerLLGS::%s no debugged process " 1558 "shared pointer", 1559 __FUNCTION__); 1560 return SendErrorResponse(0x36); 1561 } 1562 1563 // Pull out the signal number. 1564 packet.SetFilePos(::strlen("C")); 1565 if (packet.GetBytesLeft() < 1) { 1566 // Shouldn't be using a C without a signal. 1567 return SendIllFormedResponse(packet, "C packet specified without signal."); 1568 } 1569 const uint32_t signo = 1570 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1571 if (signo == std::numeric_limits<uint32_t>::max()) 1572 return SendIllFormedResponse(packet, "failed to parse signal number"); 1573 1574 // Handle optional continue address. 1575 if (packet.GetBytesLeft() > 0) { 1576 // FIXME add continue at address support for $C{signo}[;{continue-address}]. 1577 if (*packet.Peek() == ';') 1578 return SendUnimplementedResponse(packet.GetStringRef().data()); 1579 else 1580 return SendIllFormedResponse( 1581 packet, "unexpected content after $C{signal-number}"); 1582 } 1583 1584 // In non-stop protocol mode, the process could be running already. 1585 // We do not support resuming threads independently, so just error out. 1586 if (!m_continue_process->CanResume()) { 1587 LLDB_LOG(log, "process cannot be resumed (state={0})", 1588 m_continue_process->GetState()); 1589 return SendErrorResponse(0x37); 1590 } 1591 1592 ResumeActionList resume_actions(StateType::eStateRunning, 1593 LLDB_INVALID_SIGNAL_NUMBER); 1594 Status error; 1595 1596 // We have two branches: what to do if a continue thread is specified (in 1597 // which case we target sending the signal to that thread), or when we don't 1598 // have a continue thread set (in which case we send a signal to the 1599 // process). 1600 1601 // TODO discuss with Greg Clayton, make sure this makes sense. 1602 1603 lldb::tid_t signal_tid = GetContinueThreadID(); 1604 if (signal_tid != LLDB_INVALID_THREAD_ID) { 1605 // The resume action for the continue thread (or all threads if a continue 1606 // thread is not set). 1607 ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning, 1608 static_cast<int>(signo)}; 1609 1610 // Add the action for the continue thread (or all threads when the continue 1611 // thread isn't present). 1612 resume_actions.Append(action); 1613 } else { 1614 // Send the signal to the process since we weren't targeting a specific 1615 // continue thread with the signal. 1616 error = m_continue_process->Signal(signo); 1617 if (error.Fail()) { 1618 LLDB_LOG(log, "failed to send signal for process {0}: {1}", 1619 m_continue_process->GetID(), error); 1620 1621 return SendErrorResponse(0x52); 1622 } 1623 } 1624 1625 // NB: this checks CanResume() twice but using a single code path for 1626 // resuming still seems worth it. 1627 PacketResult resume_res = ResumeProcess(*m_continue_process, resume_actions); 1628 if (resume_res != PacketResult::Success) 1629 return resume_res; 1630 1631 // Don't send an "OK" packet, except in non-stop mode; 1632 // otherwise, the response is the stopped/exited message. 1633 return SendContinueSuccessResponse(); 1634} 1635 1636GDBRemoteCommunication::PacketResult 1637GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) { 1638 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 1639 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1640 1641 packet.SetFilePos(packet.GetFilePos() + ::strlen("c")); 1642 1643 // For now just support all continue. 1644 const bool has_continue_address = (packet.GetBytesLeft() > 0); 1645 if (has_continue_address) { 1646 LLDB_LOG(log, "not implemented for c[address] variant [{0} remains]", 1647 packet.Peek()); 1648 return SendUnimplementedResponse(packet.GetStringRef().data()); 1649 } 1650 1651 // Ensure we have a native process. 1652 if (!m_continue_process) { 1653 LLDB_LOGF(log, 1654 "GDBRemoteCommunicationServerLLGS::%s no debugged process " 1655 "shared pointer", 1656 __FUNCTION__); 1657 return SendErrorResponse(0x36); 1658 } 1659 1660 // Build the ResumeActionList 1661 ResumeActionList actions(StateType::eStateRunning, 1662 LLDB_INVALID_SIGNAL_NUMBER); 1663 1664 PacketResult resume_res = ResumeProcess(*m_continue_process, actions); 1665 if (resume_res != PacketResult::Success) 1666 return resume_res; 1667 1668 return SendContinueSuccessResponse(); 1669} 1670 1671GDBRemoteCommunication::PacketResult 1672GDBRemoteCommunicationServerLLGS::Handle_vCont_actions( 1673 StringExtractorGDBRemote &packet) { 1674 StreamString response; 1675 response.Printf("vCont;c;C;s;S;t"); 1676 1677 return SendPacketNoLock(response.GetString()); 1678} 1679 1680static bool ResumeActionListStopsAllThreads(ResumeActionList &actions) { 1681 // We're doing a stop-all if and only if our only action is a "t" for all 1682 // threads. 1683 if (const ResumeAction *default_action = 1684 actions.GetActionForThread(LLDB_INVALID_THREAD_ID, false)) { 1685 if (default_action->state == eStateSuspended && actions.GetSize() == 1) 1686 return true; 1687 } 1688 1689 return false; 1690} 1691 1692GDBRemoteCommunication::PacketResult 1693GDBRemoteCommunicationServerLLGS::Handle_vCont( 1694 StringExtractorGDBRemote &packet) { 1695 Log *log = GetLog(LLDBLog::Process); 1696 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s handling vCont packet", 1697 __FUNCTION__); 1698 1699 packet.SetFilePos(::strlen("vCont")); 1700 1701 if (packet.GetBytesLeft() == 0) { 1702 LLDB_LOGF(log, 1703 "GDBRemoteCommunicationServerLLGS::%s missing action from " 1704 "vCont package", 1705 __FUNCTION__); 1706 return SendIllFormedResponse(packet, "Missing action from vCont package"); 1707 } 1708 1709 if (::strcmp(packet.Peek(), ";s") == 0) { 1710 // Move past the ';', then do a simple 's'. 1711 packet.SetFilePos(packet.GetFilePos() + 1); 1712 return Handle_s(packet); 1713 } 1714 1715 std::unordered_map<lldb::pid_t, ResumeActionList> thread_actions; 1716 1717 while (packet.GetBytesLeft() && *packet.Peek() == ';') { 1718 // Skip the semi-colon. 1719 packet.GetChar(); 1720 1721 // Build up the thread action. 1722 ResumeAction thread_action; 1723 thread_action.tid = LLDB_INVALID_THREAD_ID; 1724 thread_action.state = eStateInvalid; 1725 thread_action.signal = LLDB_INVALID_SIGNAL_NUMBER; 1726 1727 const char action = packet.GetChar(); 1728 switch (action) { 1729 case 'C': 1730 thread_action.signal = packet.GetHexMaxU32(false, 0); 1731 if (thread_action.signal == 0) 1732 return SendIllFormedResponse( 1733 packet, "Could not parse signal in vCont packet C action"); 1734 [[fallthrough]]; 1735 1736 case 'c': 1737 // Continue 1738 thread_action.state = eStateRunning; 1739 break; 1740 1741 case 'S': 1742 thread_action.signal = packet.GetHexMaxU32(false, 0); 1743 if (thread_action.signal == 0) 1744 return SendIllFormedResponse( 1745 packet, "Could not parse signal in vCont packet S action"); 1746 [[fallthrough]]; 1747 1748 case 's': 1749 // Step 1750 thread_action.state = eStateStepping; 1751 break; 1752 1753 case 't': 1754 // Stop 1755 thread_action.state = eStateSuspended; 1756 break; 1757 1758 default: 1759 return SendIllFormedResponse(packet, "Unsupported vCont action"); 1760 break; 1761 } 1762 1763 // If there's no thread-id (e.g. "vCont;c"), it's "p-1.-1". 1764 lldb::pid_t pid = StringExtractorGDBRemote::AllProcesses; 1765 lldb::tid_t tid = StringExtractorGDBRemote::AllThreads; 1766 1767 // Parse out optional :{thread-id} value. 1768 if (packet.GetBytesLeft() && (*packet.Peek() == ':')) { 1769 // Consume the separator. 1770 packet.GetChar(); 1771 1772 auto pid_tid = packet.GetPidTid(LLDB_INVALID_PROCESS_ID); 1773 if (!pid_tid) 1774 return SendIllFormedResponse(packet, "Malformed thread-id"); 1775 1776 pid = pid_tid->first; 1777 tid = pid_tid->second; 1778 } 1779 1780 if (thread_action.state == eStateSuspended && 1781 tid != StringExtractorGDBRemote::AllThreads) { 1782 return SendIllFormedResponse( 1783 packet, "'t' action not supported for individual threads"); 1784 } 1785 1786 // If we get TID without PID, it's the current process. 1787 if (pid == LLDB_INVALID_PROCESS_ID) { 1788 if (!m_continue_process) { 1789 LLDB_LOG(log, "no process selected via Hc"); 1790 return SendErrorResponse(0x36); 1791 } 1792 pid = m_continue_process->GetID(); 1793 } 1794 1795 assert(pid != LLDB_INVALID_PROCESS_ID); 1796 if (tid == StringExtractorGDBRemote::AllThreads) 1797 tid = LLDB_INVALID_THREAD_ID; 1798 thread_action.tid = tid; 1799 1800 if (pid == StringExtractorGDBRemote::AllProcesses) { 1801 if (tid != LLDB_INVALID_THREAD_ID) 1802 return SendIllFormedResponse( 1803 packet, "vCont: p-1 is not valid with a specific tid"); 1804 for (auto &process_it : m_debugged_processes) 1805 thread_actions[process_it.first].Append(thread_action); 1806 } else 1807 thread_actions[pid].Append(thread_action); 1808 } 1809 1810 assert(thread_actions.size() >= 1); 1811 if (thread_actions.size() > 1 && !m_non_stop) 1812 return SendIllFormedResponse( 1813 packet, 1814 "Resuming multiple processes is supported in non-stop mode only"); 1815 1816 for (std::pair<lldb::pid_t, ResumeActionList> x : thread_actions) { 1817 auto process_it = m_debugged_processes.find(x.first); 1818 if (process_it == m_debugged_processes.end()) { 1819 LLDB_LOG(log, "vCont failed for process {0}: process not debugged", 1820 x.first); 1821 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1822 } 1823 1824 // There are four possible scenarios here. These are: 1825 // 1. vCont on a stopped process that resumes at least one thread. 1826 // In this case, we call Resume(). 1827 // 2. vCont on a stopped process that leaves all threads suspended. 1828 // A no-op. 1829 // 3. vCont on a running process that requests suspending all 1830 // running threads. In this case, we call Interrupt(). 1831 // 4. vCont on a running process that requests suspending a subset 1832 // of running threads or resuming a subset of suspended threads. 1833 // Since we do not support full nonstop mode, this is unsupported 1834 // and we return an error. 1835 1836 assert(process_it->second.process_up); 1837 if (ResumeActionListStopsAllThreads(x.second)) { 1838 if (process_it->second.process_up->IsRunning()) { 1839 assert(m_non_stop); 1840 1841 Status error = process_it->second.process_up->Interrupt(); 1842 if (error.Fail()) { 1843 LLDB_LOG(log, "vCont failed to halt process {0}: {1}", x.first, 1844 error); 1845 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1846 } 1847 1848 LLDB_LOG(log, "halted process {0}", x.first); 1849 1850 // hack to avoid enabling stdio forwarding after stop 1851 // TODO: remove this when we improve stdio forwarding for nonstop 1852 assert(thread_actions.size() == 1); 1853 return SendOKResponse(); 1854 } 1855 } else { 1856 PacketResult resume_res = 1857 ResumeProcess(*process_it->second.process_up, x.second); 1858 if (resume_res != PacketResult::Success) 1859 return resume_res; 1860 } 1861 } 1862 1863 return SendContinueSuccessResponse(); 1864} 1865 1866void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) { 1867 Log *log = GetLog(LLDBLog::Thread); 1868 LLDB_LOG(log, "setting current thread id to {0}", tid); 1869 1870 m_current_tid = tid; 1871 if (m_current_process) 1872 m_current_process->SetCurrentThreadID(m_current_tid); 1873} 1874 1875void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) { 1876 Log *log = GetLog(LLDBLog::Thread); 1877 LLDB_LOG(log, "setting continue thread id to {0}", tid); 1878 1879 m_continue_tid = tid; 1880} 1881 1882GDBRemoteCommunication::PacketResult 1883GDBRemoteCommunicationServerLLGS::Handle_stop_reason( 1884 StringExtractorGDBRemote &packet) { 1885 // Handle the $? gdbremote command. 1886 1887 if (m_non_stop) { 1888 // Clear the notification queue first, except for pending exit 1889 // notifications. 1890 llvm::erase_if(m_stop_notification_queue, [](const std::string &x) { 1891 return x.front() != 'W' && x.front() != 'X'; 1892 }); 1893 1894 if (m_current_process) { 1895 // Queue stop reply packets for all active threads. Start with 1896 // the current thread (for clients that don't actually support multiple 1897 // stop reasons). 1898 NativeThreadProtocol *thread = m_current_process->GetCurrentThread(); 1899 if (thread) { 1900 StreamString stop_reply = PrepareStopReplyPacketForThread(*thread); 1901 if (!stop_reply.Empty()) 1902 m_stop_notification_queue.push_back(stop_reply.GetString().str()); 1903 } 1904 EnqueueStopReplyPackets(thread ? thread->GetID() 1905 : LLDB_INVALID_THREAD_ID); 1906 } 1907 1908 // If the notification queue is empty (i.e. everything is running), send OK. 1909 if (m_stop_notification_queue.empty()) 1910 return SendOKResponse(); 1911 1912 // Send the first item from the new notification queue synchronously. 1913 return SendPacketNoLock(m_stop_notification_queue.front()); 1914 } 1915 1916 // If no process, indicate error 1917 if (!m_current_process) 1918 return SendErrorResponse(02); 1919 1920 return SendStopReasonForState(*m_current_process, 1921 m_current_process->GetState(), 1922 /*force_synchronous=*/true); 1923} 1924 1925GDBRemoteCommunication::PacketResult 1926GDBRemoteCommunicationServerLLGS::SendStopReasonForState( 1927 NativeProcessProtocol &process, lldb::StateType process_state, 1928 bool force_synchronous) { 1929 Log *log = GetLog(LLDBLog::Process); 1930 1931 if (m_disabling_non_stop) { 1932 // Check if we are waiting for any more processes to stop. If we are, 1933 // do not send the OK response yet. 1934 for (const auto &it : m_debugged_processes) { 1935 if (it.second.process_up->IsRunning()) 1936 return PacketResult::Success; 1937 } 1938 1939 // If all expected processes were stopped after a QNonStop:0 request, 1940 // send the OK response. 1941 m_disabling_non_stop = false; 1942 return SendOKResponse(); 1943 } 1944 1945 switch (process_state) { 1946 case eStateAttaching: 1947 case eStateLaunching: 1948 case eStateRunning: 1949 case eStateStepping: 1950 case eStateDetached: 1951 // NOTE: gdb protocol doc looks like it should return $OK 1952 // when everything is running (i.e. no stopped result). 1953 return PacketResult::Success; // Ignore 1954 1955 case eStateSuspended: 1956 case eStateStopped: 1957 case eStateCrashed: { 1958 lldb::tid_t tid = process.GetCurrentThreadID(); 1959 // Make sure we set the current thread so g and p packets return the data 1960 // the gdb will expect. 1961 SetCurrentThreadID(tid); 1962 return SendStopReplyPacketForThread(process, tid, force_synchronous); 1963 } 1964 1965 case eStateInvalid: 1966 case eStateUnloaded: 1967 case eStateExited: 1968 return SendWResponse(&process); 1969 1970 default: 1971 LLDB_LOG(log, "pid {0}, current state reporting not handled: {1}", 1972 process.GetID(), process_state); 1973 break; 1974 } 1975 1976 return SendErrorResponse(0); 1977} 1978 1979GDBRemoteCommunication::PacketResult 1980GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo( 1981 StringExtractorGDBRemote &packet) { 1982 // Fail if we don't have a current process. 1983 if (!m_current_process || 1984 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1985 return SendErrorResponse(68); 1986 1987 // Ensure we have a thread. 1988 NativeThreadProtocol *thread = m_current_process->GetThreadAtIndex(0); 1989 if (!thread) 1990 return SendErrorResponse(69); 1991 1992 // Get the register context for the first thread. 1993 NativeRegisterContext ®_context = thread->GetRegisterContext(); 1994 1995 // Parse out the register number from the request. 1996 packet.SetFilePos(strlen("qRegisterInfo")); 1997 const uint32_t reg_index = 1998 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1999 if (reg_index == std::numeric_limits<uint32_t>::max()) 2000 return SendErrorResponse(69); 2001 2002 // Return the end of registers response if we've iterated one past the end of 2003 // the register set. 2004 if (reg_index >= reg_context.GetUserRegisterCount()) 2005 return SendErrorResponse(69); 2006 2007 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2008 if (!reg_info) 2009 return SendErrorResponse(69); 2010 2011 // Build the reginfos response. 2012 StreamGDBRemote response; 2013 2014 response.PutCString("name:"); 2015 response.PutCString(reg_info->name); 2016 response.PutChar(';'); 2017 2018 if (reg_info->alt_name && reg_info->alt_name[0]) { 2019 response.PutCString("alt-name:"); 2020 response.PutCString(reg_info->alt_name); 2021 response.PutChar(';'); 2022 } 2023 2024 response.Printf("bitsize:%" PRIu32 ";", reg_info->byte_size * 8); 2025 2026 if (!reg_context.RegisterOffsetIsDynamic()) 2027 response.Printf("offset:%" PRIu32 ";", reg_info->byte_offset); 2028 2029 llvm::StringRef encoding = GetEncodingNameOrEmpty(*reg_info); 2030 if (!encoding.empty()) 2031 response << "encoding:" << encoding << ';'; 2032 2033 llvm::StringRef format = GetFormatNameOrEmpty(*reg_info); 2034 if (!format.empty()) 2035 response << "format:" << format << ';'; 2036 2037 const char *const register_set_name = 2038 reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index); 2039 if (register_set_name) 2040 response << "set:" << register_set_name << ';'; 2041 2042 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != 2043 LLDB_INVALID_REGNUM) 2044 response.Printf("ehframe:%" PRIu32 ";", 2045 reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 2046 2047 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 2048 response.Printf("dwarf:%" PRIu32 ";", 2049 reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 2050 2051 llvm::StringRef kind_generic = GetKindGenericOrEmpty(*reg_info); 2052 if (!kind_generic.empty()) 2053 response << "generic:" << kind_generic << ';'; 2054 2055 if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) { 2056 response.PutCString("container-regs:"); 2057 CollectRegNums(reg_info->value_regs, response, true); 2058 response.PutChar(';'); 2059 } 2060 2061 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) { 2062 response.PutCString("invalidate-regs:"); 2063 CollectRegNums(reg_info->invalidate_regs, response, true); 2064 response.PutChar(';'); 2065 } 2066 2067 return SendPacketNoLock(response.GetString()); 2068} 2069 2070void GDBRemoteCommunicationServerLLGS::AddProcessThreads( 2071 StreamGDBRemote &response, NativeProcessProtocol &process, bool &had_any) { 2072 Log *log = GetLog(LLDBLog::Thread); 2073 2074 lldb::pid_t pid = process.GetID(); 2075 if (pid == LLDB_INVALID_PROCESS_ID) 2076 return; 2077 2078 LLDB_LOG(log, "iterating over threads of process {0}", process.GetID()); 2079 for (NativeThreadProtocol &thread : process.Threads()) { 2080 LLDB_LOG(log, "iterated thread tid={0}", thread.GetID()); 2081 response.PutChar(had_any ? ',' : 'm'); 2082 AppendThreadIDToResponse(response, pid, thread.GetID()); 2083 had_any = true; 2084 } 2085} 2086 2087GDBRemoteCommunication::PacketResult 2088GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo( 2089 StringExtractorGDBRemote &packet) { 2090 assert(m_debugged_processes.size() == 1 || 2091 bool(m_extensions_supported & 2092 NativeProcessProtocol::Extension::multiprocess)); 2093 2094 bool had_any = false; 2095 StreamGDBRemote response; 2096 2097 for (auto &pid_ptr : m_debugged_processes) 2098 AddProcessThreads(response, *pid_ptr.second.process_up, had_any); 2099 2100 if (!had_any) 2101 return SendOKResponse(); 2102 return SendPacketNoLock(response.GetString()); 2103} 2104 2105GDBRemoteCommunication::PacketResult 2106GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo( 2107 StringExtractorGDBRemote &packet) { 2108 // FIXME for now we return the full thread list in the initial packet and 2109 // always do nothing here. 2110 return SendPacketNoLock("l"); 2111} 2112 2113GDBRemoteCommunication::PacketResult 2114GDBRemoteCommunicationServerLLGS::Handle_g(StringExtractorGDBRemote &packet) { 2115 Log *log = GetLog(LLDBLog::Thread); 2116 2117 // Move past packet name. 2118 packet.SetFilePos(strlen("g")); 2119 2120 // Get the thread to use. 2121 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2122 if (!thread) { 2123 LLDB_LOG(log, "failed, no thread available"); 2124 return SendErrorResponse(0x15); 2125 } 2126 2127 // Get the thread's register context. 2128 NativeRegisterContext ®_ctx = thread->GetRegisterContext(); 2129 2130 std::vector<uint8_t> regs_buffer; 2131 for (uint32_t reg_num = 0; reg_num < reg_ctx.GetUserRegisterCount(); 2132 ++reg_num) { 2133 const RegisterInfo *reg_info = reg_ctx.GetRegisterInfoAtIndex(reg_num); 2134 2135 if (reg_info == nullptr) { 2136 LLDB_LOG(log, "failed to get register info for register index {0}", 2137 reg_num); 2138 return SendErrorResponse(0x15); 2139 } 2140 2141 if (reg_info->value_regs != nullptr) 2142 continue; // skip registers that are contained in other registers 2143 2144 RegisterValue reg_value; 2145 Status error = reg_ctx.ReadRegister(reg_info, reg_value); 2146 if (error.Fail()) { 2147 LLDB_LOG(log, "failed to read register at index {0}", reg_num); 2148 return SendErrorResponse(0x15); 2149 } 2150 2151 if (reg_info->byte_offset + reg_info->byte_size >= regs_buffer.size()) 2152 // Resize the buffer to guarantee it can store the register offsetted 2153 // data. 2154 regs_buffer.resize(reg_info->byte_offset + reg_info->byte_size); 2155 2156 // Copy the register offsetted data to the buffer. 2157 memcpy(regs_buffer.data() + reg_info->byte_offset, reg_value.GetBytes(), 2158 reg_info->byte_size); 2159 } 2160 2161 // Write the response. 2162 StreamGDBRemote response; 2163 response.PutBytesAsRawHex8(regs_buffer.data(), regs_buffer.size()); 2164 2165 return SendPacketNoLock(response.GetString()); 2166} 2167 2168GDBRemoteCommunication::PacketResult 2169GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) { 2170 Log *log = GetLog(LLDBLog::Thread); 2171 2172 // Parse out the register number from the request. 2173 packet.SetFilePos(strlen("p")); 2174 const uint32_t reg_index = 2175 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2176 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2177 LLDB_LOGF(log, 2178 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 2179 "parse register number from request \"%s\"", 2180 __FUNCTION__, packet.GetStringRef().data()); 2181 return SendErrorResponse(0x15); 2182 } 2183 2184 // Get the thread to use. 2185 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2186 if (!thread) { 2187 LLDB_LOG(log, "failed, no thread available"); 2188 return SendErrorResponse(0x15); 2189 } 2190 2191 // Get the thread's register context. 2192 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2193 2194 // Return the end of registers response if we've iterated one past the end of 2195 // the register set. 2196 if (reg_index >= reg_context.GetUserRegisterCount()) { 2197 LLDB_LOGF(log, 2198 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2199 "register %" PRIu32 " beyond register count %" PRIu32, 2200 __FUNCTION__, reg_index, reg_context.GetUserRegisterCount()); 2201 return SendErrorResponse(0x15); 2202 } 2203 2204 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2205 if (!reg_info) { 2206 LLDB_LOGF(log, 2207 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2208 "register %" PRIu32 " returned NULL", 2209 __FUNCTION__, reg_index); 2210 return SendErrorResponse(0x15); 2211 } 2212 2213 // Build the reginfos response. 2214 StreamGDBRemote response; 2215 2216 // Retrieve the value 2217 RegisterValue reg_value; 2218 Status error = reg_context.ReadRegister(reg_info, reg_value); 2219 if (error.Fail()) { 2220 LLDB_LOGF(log, 2221 "GDBRemoteCommunicationServerLLGS::%s failed, read of " 2222 "requested register %" PRIu32 " (%s) failed: %s", 2223 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2224 return SendErrorResponse(0x15); 2225 } 2226 2227 const uint8_t *const data = 2228 static_cast<const uint8_t *>(reg_value.GetBytes()); 2229 if (!data) { 2230 LLDB_LOGF(log, 2231 "GDBRemoteCommunicationServerLLGS::%s failed to get data " 2232 "bytes from requested register %" PRIu32, 2233 __FUNCTION__, reg_index); 2234 return SendErrorResponse(0x15); 2235 } 2236 2237 // FIXME flip as needed to get data in big/little endian format for this host. 2238 for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i) 2239 response.PutHex8(data[i]); 2240 2241 return SendPacketNoLock(response.GetString()); 2242} 2243 2244GDBRemoteCommunication::PacketResult 2245GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) { 2246 Log *log = GetLog(LLDBLog::Thread); 2247 2248 // Ensure there is more content. 2249 if (packet.GetBytesLeft() < 1) 2250 return SendIllFormedResponse(packet, "Empty P packet"); 2251 2252 // Parse out the register number from the request. 2253 packet.SetFilePos(strlen("P")); 2254 const uint32_t reg_index = 2255 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2256 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2257 LLDB_LOGF(log, 2258 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 2259 "parse register number from request \"%s\"", 2260 __FUNCTION__, packet.GetStringRef().data()); 2261 return SendErrorResponse(0x29); 2262 } 2263 2264 // Note debugserver would send an E30 here. 2265 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '=')) 2266 return SendIllFormedResponse( 2267 packet, "P packet missing '=' char after register number"); 2268 2269 // Parse out the value. 2270 size_t reg_size = packet.GetHexBytesAvail(m_reg_bytes); 2271 2272 // Get the thread to use. 2273 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2274 if (!thread) { 2275 LLDB_LOGF(log, 2276 "GDBRemoteCommunicationServerLLGS::%s failed, no thread " 2277 "available (thread index 0)", 2278 __FUNCTION__); 2279 return SendErrorResponse(0x28); 2280 } 2281 2282 // Get the thread's register context. 2283 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2284 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2285 if (!reg_info) { 2286 LLDB_LOGF(log, 2287 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2288 "register %" PRIu32 " returned NULL", 2289 __FUNCTION__, reg_index); 2290 return SendErrorResponse(0x48); 2291 } 2292 2293 // Return the end of registers response if we've iterated one past the end of 2294 // the register set. 2295 if (reg_index >= reg_context.GetUserRegisterCount()) { 2296 LLDB_LOGF(log, 2297 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2298 "register %" PRIu32 " beyond register count %" PRIu32, 2299 __FUNCTION__, reg_index, reg_context.GetUserRegisterCount()); 2300 return SendErrorResponse(0x47); 2301 } 2302 2303 if (reg_size != reg_info->byte_size) 2304 return SendIllFormedResponse(packet, "P packet register size is incorrect"); 2305 2306 // Build the reginfos response. 2307 StreamGDBRemote response; 2308 2309 RegisterValue reg_value(ArrayRef<uint8_t>(m_reg_bytes, reg_size), 2310 m_current_process->GetArchitecture().GetByteOrder()); 2311 Status error = reg_context.WriteRegister(reg_info, reg_value); 2312 if (error.Fail()) { 2313 LLDB_LOGF(log, 2314 "GDBRemoteCommunicationServerLLGS::%s failed, write of " 2315 "requested register %" PRIu32 " (%s) failed: %s", 2316 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2317 return SendErrorResponse(0x32); 2318 } 2319 2320 return SendOKResponse(); 2321} 2322 2323GDBRemoteCommunication::PacketResult 2324GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) { 2325 Log *log = GetLog(LLDBLog::Thread); 2326 2327 // Parse out which variant of $H is requested. 2328 packet.SetFilePos(strlen("H")); 2329 if (packet.GetBytesLeft() < 1) { 2330 LLDB_LOGF(log, 2331 "GDBRemoteCommunicationServerLLGS::%s failed, H command " 2332 "missing {g,c} variant", 2333 __FUNCTION__); 2334 return SendIllFormedResponse(packet, "H command missing {g,c} variant"); 2335 } 2336 2337 const char h_variant = packet.GetChar(); 2338 NativeProcessProtocol *default_process; 2339 switch (h_variant) { 2340 case 'g': 2341 default_process = m_current_process; 2342 break; 2343 2344 case 'c': 2345 default_process = m_continue_process; 2346 break; 2347 2348 default: 2349 LLDB_LOGF( 2350 log, 2351 "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c", 2352 __FUNCTION__, h_variant); 2353 return SendIllFormedResponse(packet, 2354 "H variant unsupported, should be c or g"); 2355 } 2356 2357 // Parse out the thread number. 2358 auto pid_tid = packet.GetPidTid(default_process ? default_process->GetID() 2359 : LLDB_INVALID_PROCESS_ID); 2360 if (!pid_tid) 2361 return SendErrorResponse(llvm::make_error<StringError>( 2362 inconvertibleErrorCode(), "Malformed thread-id")); 2363 2364 lldb::pid_t pid = pid_tid->first; 2365 lldb::tid_t tid = pid_tid->second; 2366 2367 if (pid == StringExtractorGDBRemote::AllProcesses) 2368 return SendUnimplementedResponse("Selecting all processes not supported"); 2369 if (pid == LLDB_INVALID_PROCESS_ID) 2370 return SendErrorResponse(llvm::make_error<StringError>( 2371 inconvertibleErrorCode(), "No current process and no PID provided")); 2372 2373 // Check the process ID and find respective process instance. 2374 auto new_process_it = m_debugged_processes.find(pid); 2375 if (new_process_it == m_debugged_processes.end()) 2376 return SendErrorResponse(llvm::make_error<StringError>( 2377 inconvertibleErrorCode(), 2378 llvm::formatv("No process with PID {0} debugged", pid))); 2379 2380 // Ensure we have the given thread when not specifying -1 (all threads) or 0 2381 // (any thread). 2382 if (tid != LLDB_INVALID_THREAD_ID && tid != 0) { 2383 NativeThreadProtocol *thread = 2384 new_process_it->second.process_up->GetThreadByID(tid); 2385 if (!thread) { 2386 LLDB_LOGF(log, 2387 "GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64 2388 " not found", 2389 __FUNCTION__, tid); 2390 return SendErrorResponse(0x15); 2391 } 2392 } 2393 2394 // Now switch the given process and thread type. 2395 switch (h_variant) { 2396 case 'g': 2397 m_current_process = new_process_it->second.process_up.get(); 2398 SetCurrentThreadID(tid); 2399 break; 2400 2401 case 'c': 2402 m_continue_process = new_process_it->second.process_up.get(); 2403 SetContinueThreadID(tid); 2404 break; 2405 2406 default: 2407 assert(false && "unsupported $H variant - shouldn't get here"); 2408 return SendIllFormedResponse(packet, 2409 "H variant unsupported, should be c or g"); 2410 } 2411 2412 return SendOKResponse(); 2413} 2414 2415GDBRemoteCommunication::PacketResult 2416GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) { 2417 Log *log = GetLog(LLDBLog::Thread); 2418 2419 // Fail if we don't have a current process. 2420 if (!m_current_process || 2421 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2422 LLDB_LOGF( 2423 log, 2424 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2425 __FUNCTION__); 2426 return SendErrorResponse(0x15); 2427 } 2428 2429 packet.SetFilePos(::strlen("I")); 2430 uint8_t tmp[4096]; 2431 for (;;) { 2432 size_t read = packet.GetHexBytesAvail(tmp); 2433 if (read == 0) { 2434 break; 2435 } 2436 // write directly to stdin *this might block if stdin buffer is full* 2437 // TODO: enqueue this block in circular buffer and send window size to 2438 // remote host 2439 ConnectionStatus status; 2440 Status error; 2441 m_stdio_communication.WriteAll(tmp, read, status, &error); 2442 if (error.Fail()) { 2443 return SendErrorResponse(0x15); 2444 } 2445 } 2446 2447 return SendOKResponse(); 2448} 2449 2450GDBRemoteCommunication::PacketResult 2451GDBRemoteCommunicationServerLLGS::Handle_interrupt( 2452 StringExtractorGDBRemote &packet) { 2453 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 2454 2455 // Fail if we don't have a current process. 2456 if (!m_current_process || 2457 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2458 LLDB_LOG(log, "failed, no process available"); 2459 return SendErrorResponse(0x15); 2460 } 2461 2462 // Interrupt the process. 2463 Status error = m_current_process->Interrupt(); 2464 if (error.Fail()) { 2465 LLDB_LOG(log, "failed for process {0}: {1}", m_current_process->GetID(), 2466 error); 2467 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 2468 } 2469 2470 LLDB_LOG(log, "stopped process {0}", m_current_process->GetID()); 2471 2472 // No response required from stop all. 2473 return PacketResult::Success; 2474} 2475 2476GDBRemoteCommunication::PacketResult 2477GDBRemoteCommunicationServerLLGS::Handle_memory_read( 2478 StringExtractorGDBRemote &packet) { 2479 Log *log = GetLog(LLDBLog::Process); 2480 2481 if (!m_current_process || 2482 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2483 LLDB_LOGF( 2484 log, 2485 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2486 __FUNCTION__); 2487 return SendErrorResponse(0x15); 2488 } 2489 2490 // Parse out the memory address. 2491 packet.SetFilePos(strlen("m")); 2492 if (packet.GetBytesLeft() < 1) 2493 return SendIllFormedResponse(packet, "Too short m packet"); 2494 2495 // Read the address. Punting on validation. 2496 // FIXME replace with Hex U64 read with no default value that fails on failed 2497 // read. 2498 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2499 2500 // Validate comma. 2501 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2502 return SendIllFormedResponse(packet, "Comma sep missing in m packet"); 2503 2504 // Get # bytes to read. 2505 if (packet.GetBytesLeft() < 1) 2506 return SendIllFormedResponse(packet, "Length missing in m packet"); 2507 2508 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2509 if (byte_count == 0) { 2510 LLDB_LOGF(log, 2511 "GDBRemoteCommunicationServerLLGS::%s nothing to read: " 2512 "zero-length packet", 2513 __FUNCTION__); 2514 return SendOKResponse(); 2515 } 2516 2517 // Allocate the response buffer. 2518 std::string buf(byte_count, '\0'); 2519 if (buf.empty()) 2520 return SendErrorResponse(0x78); 2521 2522 // Retrieve the process memory. 2523 size_t bytes_read = 0; 2524 Status error = m_current_process->ReadMemoryWithoutTrap( 2525 read_addr, &buf[0], byte_count, bytes_read); 2526 if (error.Fail()) { 2527 LLDB_LOGF(log, 2528 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2529 " mem 0x%" PRIx64 ": failed to read. Error: %s", 2530 __FUNCTION__, m_current_process->GetID(), read_addr, 2531 error.AsCString()); 2532 return SendErrorResponse(0x08); 2533 } 2534 2535 if (bytes_read == 0) { 2536 LLDB_LOGF(log, 2537 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2538 " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes", 2539 __FUNCTION__, m_current_process->GetID(), read_addr, byte_count); 2540 return SendErrorResponse(0x08); 2541 } 2542 2543 StreamGDBRemote response; 2544 packet.SetFilePos(0); 2545 char kind = packet.GetChar('?'); 2546 if (kind == 'x') 2547 response.PutEscapedBytes(buf.data(), byte_count); 2548 else { 2549 assert(kind == 'm'); 2550 for (size_t i = 0; i < bytes_read; ++i) 2551 response.PutHex8(buf[i]); 2552 } 2553 2554 return SendPacketNoLock(response.GetString()); 2555} 2556 2557GDBRemoteCommunication::PacketResult 2558GDBRemoteCommunicationServerLLGS::Handle__M(StringExtractorGDBRemote &packet) { 2559 Log *log = GetLog(LLDBLog::Process); 2560 2561 if (!m_current_process || 2562 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2563 LLDB_LOGF( 2564 log, 2565 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2566 __FUNCTION__); 2567 return SendErrorResponse(0x15); 2568 } 2569 2570 // Parse out the memory address. 2571 packet.SetFilePos(strlen("_M")); 2572 if (packet.GetBytesLeft() < 1) 2573 return SendIllFormedResponse(packet, "Too short _M packet"); 2574 2575 const lldb::addr_t size = packet.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 2576 if (size == LLDB_INVALID_ADDRESS) 2577 return SendIllFormedResponse(packet, "Address not valid"); 2578 if (packet.GetChar() != ',') 2579 return SendIllFormedResponse(packet, "Bad packet"); 2580 Permissions perms = {}; 2581 while (packet.GetBytesLeft() > 0) { 2582 switch (packet.GetChar()) { 2583 case 'r': 2584 perms |= ePermissionsReadable; 2585 break; 2586 case 'w': 2587 perms |= ePermissionsWritable; 2588 break; 2589 case 'x': 2590 perms |= ePermissionsExecutable; 2591 break; 2592 default: 2593 return SendIllFormedResponse(packet, "Bad permissions"); 2594 } 2595 } 2596 2597 llvm::Expected<addr_t> addr = m_current_process->AllocateMemory(size, perms); 2598 if (!addr) 2599 return SendErrorResponse(addr.takeError()); 2600 2601 StreamGDBRemote response; 2602 response.PutHex64(*addr); 2603 return SendPacketNoLock(response.GetString()); 2604} 2605 2606GDBRemoteCommunication::PacketResult 2607GDBRemoteCommunicationServerLLGS::Handle__m(StringExtractorGDBRemote &packet) { 2608 Log *log = GetLog(LLDBLog::Process); 2609 2610 if (!m_current_process || 2611 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2612 LLDB_LOGF( 2613 log, 2614 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2615 __FUNCTION__); 2616 return SendErrorResponse(0x15); 2617 } 2618 2619 // Parse out the memory address. 2620 packet.SetFilePos(strlen("_m")); 2621 if (packet.GetBytesLeft() < 1) 2622 return SendIllFormedResponse(packet, "Too short m packet"); 2623 2624 const lldb::addr_t addr = packet.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 2625 if (addr == LLDB_INVALID_ADDRESS) 2626 return SendIllFormedResponse(packet, "Address not valid"); 2627 2628 if (llvm::Error Err = m_current_process->DeallocateMemory(addr)) 2629 return SendErrorResponse(std::move(Err)); 2630 2631 return SendOKResponse(); 2632} 2633 2634GDBRemoteCommunication::PacketResult 2635GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) { 2636 Log *log = GetLog(LLDBLog::Process); 2637 2638 if (!m_current_process || 2639 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2640 LLDB_LOGF( 2641 log, 2642 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2643 __FUNCTION__); 2644 return SendErrorResponse(0x15); 2645 } 2646 2647 // Parse out the memory address. 2648 packet.SetFilePos(strlen("M")); 2649 if (packet.GetBytesLeft() < 1) 2650 return SendIllFormedResponse(packet, "Too short M packet"); 2651 2652 // Read the address. Punting on validation. 2653 // FIXME replace with Hex U64 read with no default value that fails on failed 2654 // read. 2655 const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0); 2656 2657 // Validate comma. 2658 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2659 return SendIllFormedResponse(packet, "Comma sep missing in M packet"); 2660 2661 // Get # bytes to read. 2662 if (packet.GetBytesLeft() < 1) 2663 return SendIllFormedResponse(packet, "Length missing in M packet"); 2664 2665 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2666 if (byte_count == 0) { 2667 LLDB_LOG(log, "nothing to write: zero-length packet"); 2668 return PacketResult::Success; 2669 } 2670 2671 // Validate colon. 2672 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':')) 2673 return SendIllFormedResponse( 2674 packet, "Comma sep missing in M packet after byte length"); 2675 2676 // Allocate the conversion buffer. 2677 std::vector<uint8_t> buf(byte_count, 0); 2678 if (buf.empty()) 2679 return SendErrorResponse(0x78); 2680 2681 // Convert the hex memory write contents to bytes. 2682 StreamGDBRemote response; 2683 const uint64_t convert_count = packet.GetHexBytes(buf, 0); 2684 if (convert_count != byte_count) { 2685 LLDB_LOG(log, 2686 "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} " 2687 "to convert.", 2688 m_current_process->GetID(), write_addr, byte_count, convert_count); 2689 return SendIllFormedResponse(packet, "M content byte length specified did " 2690 "not match hex-encoded content " 2691 "length"); 2692 } 2693 2694 // Write the process memory. 2695 size_t bytes_written = 0; 2696 Status error = m_current_process->WriteMemory(write_addr, &buf[0], byte_count, 2697 bytes_written); 2698 if (error.Fail()) { 2699 LLDB_LOG(log, "pid {0} mem {1:x}: failed to write. Error: {2}", 2700 m_current_process->GetID(), write_addr, error); 2701 return SendErrorResponse(0x09); 2702 } 2703 2704 if (bytes_written == 0) { 2705 LLDB_LOG(log, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes", 2706 m_current_process->GetID(), write_addr, byte_count); 2707 return SendErrorResponse(0x09); 2708 } 2709 2710 return SendOKResponse(); 2711} 2712 2713GDBRemoteCommunication::PacketResult 2714GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported( 2715 StringExtractorGDBRemote &packet) { 2716 Log *log = GetLog(LLDBLog::Process); 2717 2718 // Currently only the NativeProcessProtocol knows if it can handle a 2719 // qMemoryRegionInfoSupported request, but we're not guaranteed to be 2720 // attached to a process. For now we'll assume the client only asks this 2721 // when a process is being debugged. 2722 2723 // Ensure we have a process running; otherwise, we can't figure this out 2724 // since we won't have a NativeProcessProtocol. 2725 if (!m_current_process || 2726 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2727 LLDB_LOGF( 2728 log, 2729 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2730 __FUNCTION__); 2731 return SendErrorResponse(0x15); 2732 } 2733 2734 // Test if we can get any region back when asking for the region around NULL. 2735 MemoryRegionInfo region_info; 2736 const Status error = m_current_process->GetMemoryRegionInfo(0, region_info); 2737 if (error.Fail()) { 2738 // We don't support memory region info collection for this 2739 // NativeProcessProtocol. 2740 return SendUnimplementedResponse(""); 2741 } 2742 2743 return SendOKResponse(); 2744} 2745 2746GDBRemoteCommunication::PacketResult 2747GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo( 2748 StringExtractorGDBRemote &packet) { 2749 Log *log = GetLog(LLDBLog::Process); 2750 2751 // Ensure we have a process. 2752 if (!m_current_process || 2753 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2754 LLDB_LOGF( 2755 log, 2756 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2757 __FUNCTION__); 2758 return SendErrorResponse(0x15); 2759 } 2760 2761 // Parse out the memory address. 2762 packet.SetFilePos(strlen("qMemoryRegionInfo:")); 2763 if (packet.GetBytesLeft() < 1) 2764 return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet"); 2765 2766 // Read the address. Punting on validation. 2767 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2768 2769 StreamGDBRemote response; 2770 2771 // Get the memory region info for the target address. 2772 MemoryRegionInfo region_info; 2773 const Status error = 2774 m_current_process->GetMemoryRegionInfo(read_addr, region_info); 2775 if (error.Fail()) { 2776 // Return the error message. 2777 2778 response.PutCString("error:"); 2779 response.PutStringAsRawHex8(error.AsCString()); 2780 response.PutChar(';'); 2781 } else { 2782 // Range start and size. 2783 response.Printf("start:%" PRIx64 ";size:%" PRIx64 ";", 2784 region_info.GetRange().GetRangeBase(), 2785 region_info.GetRange().GetByteSize()); 2786 2787 // Permissions. 2788 if (region_info.GetReadable() || region_info.GetWritable() || 2789 region_info.GetExecutable()) { 2790 // Write permissions info. 2791 response.PutCString("permissions:"); 2792 2793 if (region_info.GetReadable()) 2794 response.PutChar('r'); 2795 if (region_info.GetWritable()) 2796 response.PutChar('w'); 2797 if (region_info.GetExecutable()) 2798 response.PutChar('x'); 2799 2800 response.PutChar(';'); 2801 } 2802 2803 // Flags 2804 MemoryRegionInfo::OptionalBool memory_tagged = 2805 region_info.GetMemoryTagged(); 2806 if (memory_tagged != MemoryRegionInfo::eDontKnow) { 2807 response.PutCString("flags:"); 2808 if (memory_tagged == MemoryRegionInfo::eYes) { 2809 response.PutCString("mt"); 2810 } 2811 response.PutChar(';'); 2812 } 2813 2814 // Name 2815 ConstString name = region_info.GetName(); 2816 if (name) { 2817 response.PutCString("name:"); 2818 response.PutStringAsRawHex8(name.GetStringRef()); 2819 response.PutChar(';'); 2820 } 2821 } 2822 2823 return SendPacketNoLock(response.GetString()); 2824} 2825 2826GDBRemoteCommunication::PacketResult 2827GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) { 2828 // Ensure we have a process. 2829 if (!m_current_process || 2830 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2831 Log *log = GetLog(LLDBLog::Process); 2832 LLDB_LOG(log, "failed, no process available"); 2833 return SendErrorResponse(0x15); 2834 } 2835 2836 // Parse out software or hardware breakpoint or watchpoint requested. 2837 packet.SetFilePos(strlen("Z")); 2838 if (packet.GetBytesLeft() < 1) 2839 return SendIllFormedResponse( 2840 packet, "Too short Z packet, missing software/hardware specifier"); 2841 2842 bool want_breakpoint = true; 2843 bool want_hardware = false; 2844 uint32_t watch_flags = 0; 2845 2846 const GDBStoppointType stoppoint_type = 2847 GDBStoppointType(packet.GetS32(eStoppointInvalid)); 2848 switch (stoppoint_type) { 2849 case eBreakpointSoftware: 2850 want_hardware = false; 2851 want_breakpoint = true; 2852 break; 2853 case eBreakpointHardware: 2854 want_hardware = true; 2855 want_breakpoint = true; 2856 break; 2857 case eWatchpointWrite: 2858 watch_flags = 1; 2859 want_hardware = true; 2860 want_breakpoint = false; 2861 break; 2862 case eWatchpointRead: 2863 watch_flags = 2; 2864 want_hardware = true; 2865 want_breakpoint = false; 2866 break; 2867 case eWatchpointReadWrite: 2868 watch_flags = 3; 2869 want_hardware = true; 2870 want_breakpoint = false; 2871 break; 2872 case eStoppointInvalid: 2873 return SendIllFormedResponse( 2874 packet, "Z packet had invalid software/hardware specifier"); 2875 } 2876 2877 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2878 return SendIllFormedResponse( 2879 packet, "Malformed Z packet, expecting comma after stoppoint type"); 2880 2881 // Parse out the stoppoint address. 2882 if (packet.GetBytesLeft() < 1) 2883 return SendIllFormedResponse(packet, "Too short Z packet, missing address"); 2884 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2885 2886 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2887 return SendIllFormedResponse( 2888 packet, "Malformed Z packet, expecting comma after address"); 2889 2890 // Parse out the stoppoint size (i.e. size hint for opcode size). 2891 const uint32_t size = 2892 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2893 if (size == std::numeric_limits<uint32_t>::max()) 2894 return SendIllFormedResponse( 2895 packet, "Malformed Z packet, failed to parse size argument"); 2896 2897 if (want_breakpoint) { 2898 // Try to set the breakpoint. 2899 const Status error = 2900 m_current_process->SetBreakpoint(addr, size, want_hardware); 2901 if (error.Success()) 2902 return SendOKResponse(); 2903 Log *log = GetLog(LLDBLog::Breakpoints); 2904 LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}", 2905 m_current_process->GetID(), error); 2906 return SendErrorResponse(0x09); 2907 } else { 2908 // Try to set the watchpoint. 2909 const Status error = m_current_process->SetWatchpoint( 2910 addr, size, watch_flags, want_hardware); 2911 if (error.Success()) 2912 return SendOKResponse(); 2913 Log *log = GetLog(LLDBLog::Watchpoints); 2914 LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}", 2915 m_current_process->GetID(), error); 2916 return SendErrorResponse(0x09); 2917 } 2918} 2919 2920GDBRemoteCommunication::PacketResult 2921GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) { 2922 // Ensure we have a process. 2923 if (!m_current_process || 2924 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2925 Log *log = GetLog(LLDBLog::Process); 2926 LLDB_LOG(log, "failed, no process available"); 2927 return SendErrorResponse(0x15); 2928 } 2929 2930 // Parse out software or hardware breakpoint or watchpoint requested. 2931 packet.SetFilePos(strlen("z")); 2932 if (packet.GetBytesLeft() < 1) 2933 return SendIllFormedResponse( 2934 packet, "Too short z packet, missing software/hardware specifier"); 2935 2936 bool want_breakpoint = true; 2937 bool want_hardware = false; 2938 2939 const GDBStoppointType stoppoint_type = 2940 GDBStoppointType(packet.GetS32(eStoppointInvalid)); 2941 switch (stoppoint_type) { 2942 case eBreakpointHardware: 2943 want_breakpoint = true; 2944 want_hardware = true; 2945 break; 2946 case eBreakpointSoftware: 2947 want_breakpoint = true; 2948 break; 2949 case eWatchpointWrite: 2950 want_breakpoint = false; 2951 break; 2952 case eWatchpointRead: 2953 want_breakpoint = false; 2954 break; 2955 case eWatchpointReadWrite: 2956 want_breakpoint = false; 2957 break; 2958 default: 2959 return SendIllFormedResponse( 2960 packet, "z packet had invalid software/hardware specifier"); 2961 } 2962 2963 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2964 return SendIllFormedResponse( 2965 packet, "Malformed z packet, expecting comma after stoppoint type"); 2966 2967 // Parse out the stoppoint address. 2968 if (packet.GetBytesLeft() < 1) 2969 return SendIllFormedResponse(packet, "Too short z packet, missing address"); 2970 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2971 2972 if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',') 2973 return SendIllFormedResponse( 2974 packet, "Malformed z packet, expecting comma after address"); 2975 2976 /* 2977 // Parse out the stoppoint size (i.e. size hint for opcode size). 2978 const uint32_t size = packet.GetHexMaxU32 (false, 2979 std::numeric_limits<uint32_t>::max ()); 2980 if (size == std::numeric_limits<uint32_t>::max ()) 2981 return SendIllFormedResponse(packet, "Malformed z packet, failed to parse 2982 size argument"); 2983 */ 2984 2985 if (want_breakpoint) { 2986 // Try to clear the breakpoint. 2987 const Status error = 2988 m_current_process->RemoveBreakpoint(addr, want_hardware); 2989 if (error.Success()) 2990 return SendOKResponse(); 2991 Log *log = GetLog(LLDBLog::Breakpoints); 2992 LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}", 2993 m_current_process->GetID(), error); 2994 return SendErrorResponse(0x09); 2995 } else { 2996 // Try to clear the watchpoint. 2997 const Status error = m_current_process->RemoveWatchpoint(addr); 2998 if (error.Success()) 2999 return SendOKResponse(); 3000 Log *log = GetLog(LLDBLog::Watchpoints); 3001 LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}", 3002 m_current_process->GetID(), error); 3003 return SendErrorResponse(0x09); 3004 } 3005} 3006 3007GDBRemoteCommunication::PacketResult 3008GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) { 3009 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 3010 3011 // Ensure we have a process. 3012 if (!m_continue_process || 3013 (m_continue_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3014 LLDB_LOGF( 3015 log, 3016 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3017 __FUNCTION__); 3018 return SendErrorResponse(0x32); 3019 } 3020 3021 // We first try to use a continue thread id. If any one or any all set, use 3022 // the current thread. Bail out if we don't have a thread id. 3023 lldb::tid_t tid = GetContinueThreadID(); 3024 if (tid == 0 || tid == LLDB_INVALID_THREAD_ID) 3025 tid = GetCurrentThreadID(); 3026 if (tid == LLDB_INVALID_THREAD_ID) 3027 return SendErrorResponse(0x33); 3028 3029 // Double check that we have such a thread. 3030 // TODO investigate: on MacOSX we might need to do an UpdateThreads () here. 3031 NativeThreadProtocol *thread = m_continue_process->GetThreadByID(tid); 3032 if (!thread) 3033 return SendErrorResponse(0x33); 3034 3035 // Create the step action for the given thread. 3036 ResumeAction action = {tid, eStateStepping, LLDB_INVALID_SIGNAL_NUMBER}; 3037 3038 // Setup the actions list. 3039 ResumeActionList actions; 3040 actions.Append(action); 3041 3042 // All other threads stop while we're single stepping a thread. 3043 actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0); 3044 3045 PacketResult resume_res = ResumeProcess(*m_continue_process, actions); 3046 if (resume_res != PacketResult::Success) 3047 return resume_res; 3048 3049 // No response here, unless in non-stop mode. 3050 // Otherwise, the stop or exit will come from the resulting action. 3051 return SendContinueSuccessResponse(); 3052} 3053 3054llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> 3055GDBRemoteCommunicationServerLLGS::BuildTargetXml() { 3056 // Ensure we have a thread. 3057 NativeThreadProtocol *thread = m_current_process->GetThreadAtIndex(0); 3058 if (!thread) 3059 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3060 "No thread available"); 3061 3062 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 3063 // Get the register context for the first thread. 3064 NativeRegisterContext ®_context = thread->GetRegisterContext(); 3065 3066 StreamString response; 3067 3068 response.Printf("<?xml version=\"1.0\"?>\n"); 3069 response.Printf("<target version=\"1.0\">\n"); 3070 response.IndentMore(); 3071 3072 response.Indent(); 3073 response.Printf("<architecture>%s</architecture>\n", 3074 m_current_process->GetArchitecture() 3075 .GetTriple() 3076 .getArchName() 3077 .str() 3078 .c_str()); 3079 3080 response.Indent("<feature>\n"); 3081 3082 const int registers_count = reg_context.GetUserRegisterCount(); 3083 if (registers_count) 3084 response.IndentMore(); 3085 3086 for (int reg_index = 0; reg_index < registers_count; reg_index++) { 3087 const RegisterInfo *reg_info = 3088 reg_context.GetRegisterInfoAtIndex(reg_index); 3089 3090 if (!reg_info) { 3091 LLDB_LOGF(log, 3092 "%s failed to get register info for register index %" PRIu32, 3093 "target.xml", reg_index); 3094 continue; 3095 } 3096 3097 if (reg_info->flags_type) { 3098 response.IndentMore(); 3099 reg_info->flags_type->ToXML(response); 3100 response.IndentLess(); 3101 } 3102 3103 response.Indent(); 3104 response.Printf("<reg name=\"%s\" bitsize=\"%" PRIu32 3105 "\" regnum=\"%d\" ", 3106 reg_info->name, reg_info->byte_size * 8, reg_index); 3107 3108 if (!reg_context.RegisterOffsetIsDynamic()) 3109 response.Printf("offset=\"%" PRIu32 "\" ", reg_info->byte_offset); 3110 3111 if (reg_info->alt_name && reg_info->alt_name[0]) 3112 response.Printf("altname=\"%s\" ", reg_info->alt_name); 3113 3114 llvm::StringRef encoding = GetEncodingNameOrEmpty(*reg_info); 3115 if (!encoding.empty()) 3116 response << "encoding=\"" << encoding << "\" "; 3117 3118 llvm::StringRef format = GetFormatNameOrEmpty(*reg_info); 3119 if (!format.empty()) 3120 response << "format=\"" << format << "\" "; 3121 3122 if (reg_info->flags_type) 3123 response << "type=\"" << reg_info->flags_type->GetID() << "\" "; 3124 3125 const char *const register_set_name = 3126 reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index); 3127 if (register_set_name) 3128 response << "group=\"" << register_set_name << "\" "; 3129 3130 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != 3131 LLDB_INVALID_REGNUM) 3132 response.Printf("ehframe_regnum=\"%" PRIu32 "\" ", 3133 reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 3134 3135 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != 3136 LLDB_INVALID_REGNUM) 3137 response.Printf("dwarf_regnum=\"%" PRIu32 "\" ", 3138 reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 3139 3140 llvm::StringRef kind_generic = GetKindGenericOrEmpty(*reg_info); 3141 if (!kind_generic.empty()) 3142 response << "generic=\"" << kind_generic << "\" "; 3143 3144 if (reg_info->value_regs && 3145 reg_info->value_regs[0] != LLDB_INVALID_REGNUM) { 3146 response.PutCString("value_regnums=\""); 3147 CollectRegNums(reg_info->value_regs, response, false); 3148 response.Printf("\" "); 3149 } 3150 3151 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) { 3152 response.PutCString("invalidate_regnums=\""); 3153 CollectRegNums(reg_info->invalidate_regs, response, false); 3154 response.Printf("\" "); 3155 } 3156 3157 response.Printf("/>\n"); 3158 } 3159 3160 if (registers_count) 3161 response.IndentLess(); 3162 3163 response.Indent("</feature>\n"); 3164 response.IndentLess(); 3165 response.Indent("</target>\n"); 3166 return MemoryBuffer::getMemBufferCopy(response.GetString(), "target.xml"); 3167} 3168 3169llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> 3170GDBRemoteCommunicationServerLLGS::ReadXferObject(llvm::StringRef object, 3171 llvm::StringRef annex) { 3172 // Make sure we have a valid process. 3173 if (!m_current_process || 3174 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3175 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3176 "No process available"); 3177 } 3178 3179 if (object == "auxv") { 3180 // Grab the auxv data. 3181 auto buffer_or_error = m_current_process->GetAuxvData(); 3182 if (!buffer_or_error) 3183 return llvm::errorCodeToError(buffer_or_error.getError()); 3184 return std::move(*buffer_or_error); 3185 } 3186 3187 if (object == "siginfo") { 3188 NativeThreadProtocol *thread = m_current_process->GetCurrentThread(); 3189 if (!thread) 3190 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3191 "no current thread"); 3192 3193 auto buffer_or_error = thread->GetSiginfo(); 3194 if (!buffer_or_error) 3195 return buffer_or_error.takeError(); 3196 return std::move(*buffer_or_error); 3197 } 3198 3199 if (object == "libraries-svr4") { 3200 auto library_list = m_current_process->GetLoadedSVR4Libraries(); 3201 if (!library_list) 3202 return library_list.takeError(); 3203 3204 StreamString response; 3205 response.Printf("<library-list-svr4 version=\"1.0\">"); 3206 for (auto const &library : *library_list) { 3207 response.Printf("<library name=\"%s\" ", 3208 XMLEncodeAttributeValue(library.name.c_str()).c_str()); 3209 response.Printf("lm=\"0x%" PRIx64 "\" ", library.link_map); 3210 response.Printf("l_addr=\"0x%" PRIx64 "\" ", library.base_addr); 3211 response.Printf("l_ld=\"0x%" PRIx64 "\" />", library.ld_addr); 3212 } 3213 response.Printf("</library-list-svr4>"); 3214 return MemoryBuffer::getMemBufferCopy(response.GetString(), __FUNCTION__); 3215 } 3216 3217 if (object == "features" && annex == "target.xml") 3218 return BuildTargetXml(); 3219 3220 return llvm::make_error<UnimplementedError>(); 3221} 3222 3223GDBRemoteCommunication::PacketResult 3224GDBRemoteCommunicationServerLLGS::Handle_qXfer( 3225 StringExtractorGDBRemote &packet) { 3226 SmallVector<StringRef, 5> fields; 3227 // The packet format is "qXfer:<object>:<action>:<annex>:offset,length" 3228 StringRef(packet.GetStringRef()).split(fields, ':', 4); 3229 if (fields.size() != 5) 3230 return SendIllFormedResponse(packet, "malformed qXfer packet"); 3231 StringRef &xfer_object = fields[1]; 3232 StringRef &xfer_action = fields[2]; 3233 StringRef &xfer_annex = fields[3]; 3234 StringExtractor offset_data(fields[4]); 3235 if (xfer_action != "read") 3236 return SendUnimplementedResponse("qXfer action not supported"); 3237 // Parse offset. 3238 const uint64_t xfer_offset = 3239 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 3240 if (xfer_offset == std::numeric_limits<uint64_t>::max()) 3241 return SendIllFormedResponse(packet, "qXfer packet missing offset"); 3242 // Parse out comma. 3243 if (offset_data.GetChar() != ',') 3244 return SendIllFormedResponse(packet, 3245 "qXfer packet missing comma after offset"); 3246 // Parse out the length. 3247 const uint64_t xfer_length = 3248 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 3249 if (xfer_length == std::numeric_limits<uint64_t>::max()) 3250 return SendIllFormedResponse(packet, "qXfer packet missing length"); 3251 3252 // Get a previously constructed buffer if it exists or create it now. 3253 std::string buffer_key = (xfer_object + xfer_action + xfer_annex).str(); 3254 auto buffer_it = m_xfer_buffer_map.find(buffer_key); 3255 if (buffer_it == m_xfer_buffer_map.end()) { 3256 auto buffer_up = ReadXferObject(xfer_object, xfer_annex); 3257 if (!buffer_up) 3258 return SendErrorResponse(buffer_up.takeError()); 3259 buffer_it = m_xfer_buffer_map 3260 .insert(std::make_pair(buffer_key, std::move(*buffer_up))) 3261 .first; 3262 } 3263 3264 // Send back the response 3265 StreamGDBRemote response; 3266 bool done_with_buffer = false; 3267 llvm::StringRef buffer = buffer_it->second->getBuffer(); 3268 if (xfer_offset >= buffer.size()) { 3269 // We have nothing left to send. Mark the buffer as complete. 3270 response.PutChar('l'); 3271 done_with_buffer = true; 3272 } else { 3273 // Figure out how many bytes are available starting at the given offset. 3274 buffer = buffer.drop_front(xfer_offset); 3275 // Mark the response type according to whether we're reading the remainder 3276 // of the data. 3277 if (xfer_length >= buffer.size()) { 3278 // There will be nothing left to read after this 3279 response.PutChar('l'); 3280 done_with_buffer = true; 3281 } else { 3282 // There will still be bytes to read after this request. 3283 response.PutChar('m'); 3284 buffer = buffer.take_front(xfer_length); 3285 } 3286 // Now write the data in encoded binary form. 3287 response.PutEscapedBytes(buffer.data(), buffer.size()); 3288 } 3289 3290 if (done_with_buffer) 3291 m_xfer_buffer_map.erase(buffer_it); 3292 3293 return SendPacketNoLock(response.GetString()); 3294} 3295 3296GDBRemoteCommunication::PacketResult 3297GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( 3298 StringExtractorGDBRemote &packet) { 3299 Log *log = GetLog(LLDBLog::Thread); 3300 3301 // Move past packet name. 3302 packet.SetFilePos(strlen("QSaveRegisterState")); 3303 3304 // Get the thread to use. 3305 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 3306 if (!thread) { 3307 if (m_thread_suffix_supported) 3308 return SendIllFormedResponse( 3309 packet, "No thread specified in QSaveRegisterState packet"); 3310 else 3311 return SendIllFormedResponse(packet, 3312 "No thread was is set with the Hg packet"); 3313 } 3314 3315 // Grab the register context for the thread. 3316 NativeRegisterContext& reg_context = thread->GetRegisterContext(); 3317 3318 // Save registers to a buffer. 3319 WritableDataBufferSP register_data_sp; 3320 Status error = reg_context.ReadAllRegisterValues(register_data_sp); 3321 if (error.Fail()) { 3322 LLDB_LOG(log, "pid {0} failed to save all register values: {1}", 3323 m_current_process->GetID(), error); 3324 return SendErrorResponse(0x75); 3325 } 3326 3327 // Allocate a new save id. 3328 const uint32_t save_id = GetNextSavedRegistersID(); 3329 assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && 3330 "GetNextRegisterSaveID() returned an existing register save id"); 3331 3332 // Save the register data buffer under the save id. 3333 { 3334 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3335 m_saved_registers_map[save_id] = register_data_sp; 3336 } 3337 3338 // Write the response. 3339 StreamGDBRemote response; 3340 response.Printf("%" PRIu32, save_id); 3341 return SendPacketNoLock(response.GetString()); 3342} 3343 3344GDBRemoteCommunication::PacketResult 3345GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( 3346 StringExtractorGDBRemote &packet) { 3347 Log *log = GetLog(LLDBLog::Thread); 3348 3349 // Parse out save id. 3350 packet.SetFilePos(strlen("QRestoreRegisterState:")); 3351 if (packet.GetBytesLeft() < 1) 3352 return SendIllFormedResponse( 3353 packet, "QRestoreRegisterState packet missing register save id"); 3354 3355 const uint32_t save_id = packet.GetU32(0); 3356 if (save_id == 0) { 3357 LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, " 3358 "expecting decimal uint32_t"); 3359 return SendErrorResponse(0x76); 3360 } 3361 3362 // Get the thread to use. 3363 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 3364 if (!thread) { 3365 if (m_thread_suffix_supported) 3366 return SendIllFormedResponse( 3367 packet, "No thread specified in QRestoreRegisterState packet"); 3368 else 3369 return SendIllFormedResponse(packet, 3370 "No thread was is set with the Hg packet"); 3371 } 3372 3373 // Grab the register context for the thread. 3374 NativeRegisterContext ®_context = thread->GetRegisterContext(); 3375 3376 // Retrieve register state buffer, then remove from the list. 3377 DataBufferSP register_data_sp; 3378 { 3379 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3380 3381 // Find the register set buffer for the given save id. 3382 auto it = m_saved_registers_map.find(save_id); 3383 if (it == m_saved_registers_map.end()) { 3384 LLDB_LOG(log, 3385 "pid {0} does not have a register set save buffer for id {1}", 3386 m_current_process->GetID(), save_id); 3387 return SendErrorResponse(0x77); 3388 } 3389 register_data_sp = it->second; 3390 3391 // Remove it from the map. 3392 m_saved_registers_map.erase(it); 3393 } 3394 3395 Status error = reg_context.WriteAllRegisterValues(register_data_sp); 3396 if (error.Fail()) { 3397 LLDB_LOG(log, "pid {0} failed to restore all register values: {1}", 3398 m_current_process->GetID(), error); 3399 return SendErrorResponse(0x77); 3400 } 3401 3402 return SendOKResponse(); 3403} 3404 3405GDBRemoteCommunication::PacketResult 3406GDBRemoteCommunicationServerLLGS::Handle_vAttach( 3407 StringExtractorGDBRemote &packet) { 3408 Log *log = GetLog(LLDBLog::Process); 3409 3410 // Consume the ';' after vAttach. 3411 packet.SetFilePos(strlen("vAttach")); 3412 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3413 return SendIllFormedResponse(packet, "vAttach missing expected ';'"); 3414 3415 // Grab the PID to which we will attach (assume hex encoding). 3416 lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3417 if (pid == LLDB_INVALID_PROCESS_ID) 3418 return SendIllFormedResponse(packet, 3419 "vAttach failed to parse the process id"); 3420 3421 // Attempt to attach. 3422 LLDB_LOGF(log, 3423 "GDBRemoteCommunicationServerLLGS::%s attempting to attach to " 3424 "pid %" PRIu64, 3425 __FUNCTION__, pid); 3426 3427 Status error = AttachToProcess(pid); 3428 3429 if (error.Fail()) { 3430 LLDB_LOGF(log, 3431 "GDBRemoteCommunicationServerLLGS::%s failed to attach to " 3432 "pid %" PRIu64 ": %s\n", 3433 __FUNCTION__, pid, error.AsCString()); 3434 return SendErrorResponse(error); 3435 } 3436 3437 // Notify we attached by sending a stop packet. 3438 assert(m_current_process); 3439 return SendStopReasonForState(*m_current_process, 3440 m_current_process->GetState(), 3441 /*force_synchronous=*/false); 3442} 3443 3444GDBRemoteCommunication::PacketResult 3445GDBRemoteCommunicationServerLLGS::Handle_vAttachWait( 3446 StringExtractorGDBRemote &packet) { 3447 Log *log = GetLog(LLDBLog::Process); 3448 3449 // Consume the ';' after the identifier. 3450 packet.SetFilePos(strlen("vAttachWait")); 3451 3452 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3453 return SendIllFormedResponse(packet, "vAttachWait missing expected ';'"); 3454 3455 // Allocate the buffer for the process name from vAttachWait. 3456 std::string process_name; 3457 if (!packet.GetHexByteString(process_name)) 3458 return SendIllFormedResponse(packet, 3459 "vAttachWait failed to parse process name"); 3460 3461 LLDB_LOG(log, "attempting to attach to process named '{0}'", process_name); 3462 3463 Status error = AttachWaitProcess(process_name, false); 3464 if (error.Fail()) { 3465 LLDB_LOG(log, "failed to attach to process named '{0}': {1}", process_name, 3466 error); 3467 return SendErrorResponse(error); 3468 } 3469 3470 // Notify we attached by sending a stop packet. 3471 assert(m_current_process); 3472 return SendStopReasonForState(*m_current_process, 3473 m_current_process->GetState(), 3474 /*force_synchronous=*/false); 3475} 3476 3477GDBRemoteCommunication::PacketResult 3478GDBRemoteCommunicationServerLLGS::Handle_qVAttachOrWaitSupported( 3479 StringExtractorGDBRemote &packet) { 3480 return SendOKResponse(); 3481} 3482 3483GDBRemoteCommunication::PacketResult 3484GDBRemoteCommunicationServerLLGS::Handle_vAttachOrWait( 3485 StringExtractorGDBRemote &packet) { 3486 Log *log = GetLog(LLDBLog::Process); 3487 3488 // Consume the ';' after the identifier. 3489 packet.SetFilePos(strlen("vAttachOrWait")); 3490 3491 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3492 return SendIllFormedResponse(packet, "vAttachOrWait missing expected ';'"); 3493 3494 // Allocate the buffer for the process name from vAttachWait. 3495 std::string process_name; 3496 if (!packet.GetHexByteString(process_name)) 3497 return SendIllFormedResponse(packet, 3498 "vAttachOrWait failed to parse process name"); 3499 3500 LLDB_LOG(log, "attempting to attach to process named '{0}'", process_name); 3501 3502 Status error = AttachWaitProcess(process_name, true); 3503 if (error.Fail()) { 3504 LLDB_LOG(log, "failed to attach to process named '{0}': {1}", process_name, 3505 error); 3506 return SendErrorResponse(error); 3507 } 3508 3509 // Notify we attached by sending a stop packet. 3510 assert(m_current_process); 3511 return SendStopReasonForState(*m_current_process, 3512 m_current_process->GetState(), 3513 /*force_synchronous=*/false); 3514} 3515 3516GDBRemoteCommunication::PacketResult 3517GDBRemoteCommunicationServerLLGS::Handle_vRun( 3518 StringExtractorGDBRemote &packet) { 3519 Log *log = GetLog(LLDBLog::Process); 3520 3521 llvm::StringRef s = packet.GetStringRef(); 3522 if (!s.consume_front("vRun;")) 3523 return SendErrorResponse(8); 3524 3525 llvm::SmallVector<llvm::StringRef, 16> argv; 3526 s.split(argv, ';'); 3527 3528 for (llvm::StringRef hex_arg : argv) { 3529 StringExtractor arg_ext{hex_arg}; 3530 std::string arg; 3531 arg_ext.GetHexByteString(arg); 3532 m_process_launch_info.GetArguments().AppendArgument(arg); 3533 LLDB_LOGF(log, "LLGSPacketHandler::%s added arg: \"%s\"", __FUNCTION__, 3534 arg.c_str()); 3535 } 3536 3537 if (argv.empty()) 3538 return SendErrorResponse(Status("No arguments")); 3539 m_process_launch_info.GetExecutableFile().SetFile( 3540 m_process_launch_info.GetArguments()[0].ref(), FileSpec::Style::native); 3541 m_process_launch_error = LaunchProcess(); 3542 if (m_process_launch_error.Fail()) 3543 return SendErrorResponse(m_process_launch_error); 3544 assert(m_current_process); 3545 return SendStopReasonForState(*m_current_process, 3546 m_current_process->GetState(), 3547 /*force_synchronous=*/true); 3548} 3549 3550GDBRemoteCommunication::PacketResult 3551GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) { 3552 Log *log = GetLog(LLDBLog::Process); 3553 if (!m_non_stop) 3554 StopSTDIOForwarding(); 3555 3556 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 3557 3558 // Consume the ';' after D. 3559 packet.SetFilePos(1); 3560 if (packet.GetBytesLeft()) { 3561 if (packet.GetChar() != ';') 3562 return SendIllFormedResponse(packet, "D missing expected ';'"); 3563 3564 // Grab the PID from which we will detach (assume hex encoding). 3565 pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3566 if (pid == LLDB_INVALID_PROCESS_ID) 3567 return SendIllFormedResponse(packet, "D failed to parse the process id"); 3568 } 3569 3570 // Detach forked children if their PID was specified *or* no PID was requested 3571 // (i.e. detach-all packet). 3572 llvm::Error detach_error = llvm::Error::success(); 3573 bool detached = false; 3574 for (auto it = m_debugged_processes.begin(); 3575 it != m_debugged_processes.end();) { 3576 if (pid == LLDB_INVALID_PROCESS_ID || pid == it->first) { 3577 LLDB_LOGF(log, 3578 "GDBRemoteCommunicationServerLLGS::%s detaching %" PRId64, 3579 __FUNCTION__, it->first); 3580 if (llvm::Error e = it->second.process_up->Detach().ToError()) 3581 detach_error = llvm::joinErrors(std::move(detach_error), std::move(e)); 3582 else { 3583 if (it->second.process_up.get() == m_current_process) 3584 m_current_process = nullptr; 3585 if (it->second.process_up.get() == m_continue_process) 3586 m_continue_process = nullptr; 3587 it = m_debugged_processes.erase(it); 3588 detached = true; 3589 continue; 3590 } 3591 } 3592 ++it; 3593 } 3594 3595 if (detach_error) 3596 return SendErrorResponse(std::move(detach_error)); 3597 if (!detached) 3598 return SendErrorResponse(Status("PID %" PRIu64 " not traced", pid)); 3599 return SendOKResponse(); 3600} 3601 3602GDBRemoteCommunication::PacketResult 3603GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo( 3604 StringExtractorGDBRemote &packet) { 3605 Log *log = GetLog(LLDBLog::Thread); 3606 3607 if (!m_current_process || 3608 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 3609 return SendErrorResponse(50); 3610 3611 packet.SetFilePos(strlen("qThreadStopInfo")); 3612 const lldb::tid_t tid = packet.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID); 3613 if (tid == LLDB_INVALID_THREAD_ID) { 3614 LLDB_LOGF(log, 3615 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 3616 "parse thread id from request \"%s\"", 3617 __FUNCTION__, packet.GetStringRef().data()); 3618 return SendErrorResponse(0x15); 3619 } 3620 return SendStopReplyPacketForThread(*m_current_process, tid, 3621 /*force_synchronous=*/true); 3622} 3623 3624GDBRemoteCommunication::PacketResult 3625GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo( 3626 StringExtractorGDBRemote &) { 3627 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 3628 3629 // Ensure we have a debugged process. 3630 if (!m_current_process || 3631 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 3632 return SendErrorResponse(50); 3633 LLDB_LOG(log, "preparing packet for pid {0}", m_current_process->GetID()); 3634 3635 StreamString response; 3636 const bool threads_with_valid_stop_info_only = false; 3637 llvm::Expected<json::Value> threads_info = 3638 GetJSONThreadsInfo(*m_current_process, threads_with_valid_stop_info_only); 3639 if (!threads_info) { 3640 LLDB_LOG_ERROR(log, threads_info.takeError(), 3641 "failed to prepare a packet for pid {1}: {0}", 3642 m_current_process->GetID()); 3643 return SendErrorResponse(52); 3644 } 3645 3646 response.AsRawOstream() << *threads_info; 3647 StreamGDBRemote escaped_response; 3648 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 3649 return SendPacketNoLock(escaped_response.GetString()); 3650} 3651 3652GDBRemoteCommunication::PacketResult 3653GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo( 3654 StringExtractorGDBRemote &packet) { 3655 // Fail if we don't have a current process. 3656 if (!m_current_process || 3657 m_current_process->GetID() == LLDB_INVALID_PROCESS_ID) 3658 return SendErrorResponse(68); 3659 3660 packet.SetFilePos(strlen("qWatchpointSupportInfo")); 3661 if (packet.GetBytesLeft() == 0) 3662 return SendOKResponse(); 3663 if (packet.GetChar() != ':') 3664 return SendErrorResponse(67); 3665 3666 auto hw_debug_cap = m_current_process->GetHardwareDebugSupportInfo(); 3667 3668 StreamGDBRemote response; 3669 if (hw_debug_cap == std::nullopt) 3670 response.Printf("num:0;"); 3671 else 3672 response.Printf("num:%d;", hw_debug_cap->second); 3673 3674 return SendPacketNoLock(response.GetString()); 3675} 3676 3677GDBRemoteCommunication::PacketResult 3678GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress( 3679 StringExtractorGDBRemote &packet) { 3680 // Fail if we don't have a current process. 3681 if (!m_current_process || 3682 m_current_process->GetID() == LLDB_INVALID_PROCESS_ID) 3683 return SendErrorResponse(67); 3684 3685 packet.SetFilePos(strlen("qFileLoadAddress:")); 3686 if (packet.GetBytesLeft() == 0) 3687 return SendErrorResponse(68); 3688 3689 std::string file_name; 3690 packet.GetHexByteString(file_name); 3691 3692 lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS; 3693 Status error = 3694 m_current_process->GetFileLoadAddress(file_name, file_load_address); 3695 if (error.Fail()) 3696 return SendErrorResponse(69); 3697 3698 if (file_load_address == LLDB_INVALID_ADDRESS) 3699 return SendErrorResponse(1); // File not loaded 3700 3701 StreamGDBRemote response; 3702 response.PutHex64(file_load_address); 3703 return SendPacketNoLock(response.GetString()); 3704} 3705 3706GDBRemoteCommunication::PacketResult 3707GDBRemoteCommunicationServerLLGS::Handle_QPassSignals( 3708 StringExtractorGDBRemote &packet) { 3709 std::vector<int> signals; 3710 packet.SetFilePos(strlen("QPassSignals:")); 3711 3712 // Read sequence of hex signal numbers divided by a semicolon and optionally 3713 // spaces. 3714 while (packet.GetBytesLeft() > 0) { 3715 int signal = packet.GetS32(-1, 16); 3716 if (signal < 0) 3717 return SendIllFormedResponse(packet, "Failed to parse signal number."); 3718 signals.push_back(signal); 3719 3720 packet.SkipSpaces(); 3721 char separator = packet.GetChar(); 3722 if (separator == '\0') 3723 break; // End of string 3724 if (separator != ';') 3725 return SendIllFormedResponse(packet, "Invalid separator," 3726 " expected semicolon."); 3727 } 3728 3729 // Fail if we don't have a current process. 3730 if (!m_current_process) 3731 return SendErrorResponse(68); 3732 3733 Status error = m_current_process->IgnoreSignals(signals); 3734 if (error.Fail()) 3735 return SendErrorResponse(69); 3736 3737 return SendOKResponse(); 3738} 3739 3740GDBRemoteCommunication::PacketResult 3741GDBRemoteCommunicationServerLLGS::Handle_qMemTags( 3742 StringExtractorGDBRemote &packet) { 3743 Log *log = GetLog(LLDBLog::Process); 3744 3745 // Ensure we have a process. 3746 if (!m_current_process || 3747 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3748 LLDB_LOGF( 3749 log, 3750 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3751 __FUNCTION__); 3752 return SendErrorResponse(1); 3753 } 3754 3755 // We are expecting 3756 // qMemTags:<hex address>,<hex length>:<hex type> 3757 3758 // Address 3759 packet.SetFilePos(strlen("qMemTags:")); 3760 const char *current_char = packet.Peek(); 3761 if (!current_char || *current_char == ',') 3762 return SendIllFormedResponse(packet, "Missing address in qMemTags packet"); 3763 const lldb::addr_t addr = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3764 3765 // Length 3766 char previous_char = packet.GetChar(); 3767 current_char = packet.Peek(); 3768 // If we don't have a separator or the length field is empty 3769 if (previous_char != ',' || (current_char && *current_char == ':')) 3770 return SendIllFormedResponse(packet, 3771 "Invalid addr,length pair in qMemTags packet"); 3772 3773 if (packet.GetBytesLeft() < 1) 3774 return SendIllFormedResponse( 3775 packet, "Too short qMemtags: packet (looking for length)"); 3776 const size_t length = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3777 3778 // Type 3779 const char *invalid_type_err = "Invalid type field in qMemTags: packet"; 3780 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ':') 3781 return SendIllFormedResponse(packet, invalid_type_err); 3782 3783 // Type is a signed integer but packed into the packet as its raw bytes. 3784 // However, our GetU64 uses strtoull which allows +/-. We do not want this. 3785 const char *first_type_char = packet.Peek(); 3786 if (first_type_char && (*first_type_char == '+' || *first_type_char == '-')) 3787 return SendIllFormedResponse(packet, invalid_type_err); 3788 3789 // Extract type as unsigned then cast to signed. 3790 // Using a uint64_t here so that we have some value outside of the 32 bit 3791 // range to use as the invalid return value. 3792 uint64_t raw_type = 3793 packet.GetU64(std::numeric_limits<uint64_t>::max(), /*base=*/16); 3794 3795 if ( // Make sure the cast below would be valid 3796 raw_type > std::numeric_limits<uint32_t>::max() || 3797 // To catch inputs like "123aardvark" that will parse but clearly aren't 3798 // valid in this case. 3799 packet.GetBytesLeft()) { 3800 return SendIllFormedResponse(packet, invalid_type_err); 3801 } 3802 3803 // First narrow to 32 bits otherwise the copy into type would take 3804 // the wrong 4 bytes on big endian. 3805 uint32_t raw_type_32 = raw_type; 3806 int32_t type = reinterpret_cast<int32_t &>(raw_type_32); 3807 3808 StreamGDBRemote response; 3809 std::vector<uint8_t> tags; 3810 Status error = m_current_process->ReadMemoryTags(type, addr, length, tags); 3811 if (error.Fail()) 3812 return SendErrorResponse(1); 3813 3814 // This m is here in case we want to support multi part replies in the future. 3815 // In the same manner as qfThreadInfo/qsThreadInfo. 3816 response.PutChar('m'); 3817 response.PutBytesAsRawHex8(tags.data(), tags.size()); 3818 return SendPacketNoLock(response.GetString()); 3819} 3820 3821GDBRemoteCommunication::PacketResult 3822GDBRemoteCommunicationServerLLGS::Handle_QMemTags( 3823 StringExtractorGDBRemote &packet) { 3824 Log *log = GetLog(LLDBLog::Process); 3825 3826 // Ensure we have a process. 3827 if (!m_current_process || 3828 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3829 LLDB_LOGF( 3830 log, 3831 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3832 __FUNCTION__); 3833 return SendErrorResponse(1); 3834 } 3835 3836 // We are expecting 3837 // QMemTags:<hex address>,<hex length>:<hex type>:<tags as hex bytes> 3838 3839 // Address 3840 packet.SetFilePos(strlen("QMemTags:")); 3841 const char *current_char = packet.Peek(); 3842 if (!current_char || *current_char == ',') 3843 return SendIllFormedResponse(packet, "Missing address in QMemTags packet"); 3844 const lldb::addr_t addr = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3845 3846 // Length 3847 char previous_char = packet.GetChar(); 3848 current_char = packet.Peek(); 3849 // If we don't have a separator or the length field is empty 3850 if (previous_char != ',' || (current_char && *current_char == ':')) 3851 return SendIllFormedResponse(packet, 3852 "Invalid addr,length pair in QMemTags packet"); 3853 3854 if (packet.GetBytesLeft() < 1) 3855 return SendIllFormedResponse( 3856 packet, "Too short QMemtags: packet (looking for length)"); 3857 const size_t length = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3858 3859 // Type 3860 const char *invalid_type_err = "Invalid type field in QMemTags: packet"; 3861 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ':') 3862 return SendIllFormedResponse(packet, invalid_type_err); 3863 3864 // Our GetU64 uses strtoull which allows leading +/-, we don't want that. 3865 const char *first_type_char = packet.Peek(); 3866 if (first_type_char && (*first_type_char == '+' || *first_type_char == '-')) 3867 return SendIllFormedResponse(packet, invalid_type_err); 3868 3869 // The type is a signed integer but is in the packet as its raw bytes. 3870 // So parse first as unsigned then cast to signed later. 3871 // We extract to 64 bit, even though we only expect 32, so that we've 3872 // got some invalid value we can check for. 3873 uint64_t raw_type = 3874 packet.GetU64(std::numeric_limits<uint64_t>::max(), /*base=*/16); 3875 if (raw_type > std::numeric_limits<uint32_t>::max()) 3876 return SendIllFormedResponse(packet, invalid_type_err); 3877 3878 // First narrow to 32 bits. Otherwise the copy below would get the wrong 3879 // 4 bytes on big endian. 3880 uint32_t raw_type_32 = raw_type; 3881 int32_t type = reinterpret_cast<int32_t &>(raw_type_32); 3882 3883 // Tag data 3884 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ':') 3885 return SendIllFormedResponse(packet, 3886 "Missing tag data in QMemTags: packet"); 3887 3888 // Must be 2 chars per byte 3889 const char *invalid_data_err = "Invalid tag data in QMemTags: packet"; 3890 if (packet.GetBytesLeft() % 2) 3891 return SendIllFormedResponse(packet, invalid_data_err); 3892 3893 // This is bytes here and is unpacked into target specific tags later 3894 // We cannot assume that number of bytes == length here because the server 3895 // can repeat tags to fill a given range. 3896 std::vector<uint8_t> tag_data; 3897 // Zero length writes will not have any tag data 3898 // (but we pass them on because it will still check that tagging is enabled) 3899 if (packet.GetBytesLeft()) { 3900 size_t byte_count = packet.GetBytesLeft() / 2; 3901 tag_data.resize(byte_count); 3902 size_t converted_bytes = packet.GetHexBytes(tag_data, 0); 3903 if (converted_bytes != byte_count) { 3904 return SendIllFormedResponse(packet, invalid_data_err); 3905 } 3906 } 3907 3908 Status status = 3909 m_current_process->WriteMemoryTags(type, addr, length, tag_data); 3910 return status.Success() ? SendOKResponse() : SendErrorResponse(1); 3911} 3912 3913GDBRemoteCommunication::PacketResult 3914GDBRemoteCommunicationServerLLGS::Handle_qSaveCore( 3915 StringExtractorGDBRemote &packet) { 3916 // Fail if we don't have a current process. 3917 if (!m_current_process || 3918 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 3919 return SendErrorResponse(Status("Process not running.")); 3920 3921 std::string path_hint; 3922 3923 StringRef packet_str{packet.GetStringRef()}; 3924 assert(packet_str.starts_with("qSaveCore")); 3925 if (packet_str.consume_front("qSaveCore;")) { 3926 for (auto x : llvm::split(packet_str, ';')) { 3927 if (x.consume_front("path-hint:")) 3928 StringExtractor(x).GetHexByteString(path_hint); 3929 else 3930 return SendErrorResponse(Status("Unsupported qSaveCore option")); 3931 } 3932 } 3933 3934 llvm::Expected<std::string> ret = m_current_process->SaveCore(path_hint); 3935 if (!ret) 3936 return SendErrorResponse(ret.takeError()); 3937 3938 StreamString response; 3939 response.PutCString("core-path:"); 3940 response.PutStringAsRawHex8(ret.get()); 3941 return SendPacketNoLock(response.GetString()); 3942} 3943 3944GDBRemoteCommunication::PacketResult 3945GDBRemoteCommunicationServerLLGS::Handle_QNonStop( 3946 StringExtractorGDBRemote &packet) { 3947 Log *log = GetLog(LLDBLog::Process); 3948 3949 StringRef packet_str{packet.GetStringRef()}; 3950 assert(packet_str.starts_with("QNonStop:")); 3951 packet_str.consume_front("QNonStop:"); 3952 if (packet_str == "0") { 3953 if (m_non_stop) 3954 StopSTDIOForwarding(); 3955 for (auto &process_it : m_debugged_processes) { 3956 if (process_it.second.process_up->IsRunning()) { 3957 assert(m_non_stop); 3958 Status error = process_it.second.process_up->Interrupt(); 3959 if (error.Fail()) { 3960 LLDB_LOG(log, 3961 "while disabling nonstop, failed to halt process {0}: {1}", 3962 process_it.first, error); 3963 return SendErrorResponse(0x41); 3964 } 3965 // we must not send stop reasons after QNonStop 3966 m_disabling_non_stop = true; 3967 } 3968 } 3969 m_stdio_notification_queue.clear(); 3970 m_stop_notification_queue.clear(); 3971 m_non_stop = false; 3972 // If we are stopping anything, defer sending the OK response until we're 3973 // done. 3974 if (m_disabling_non_stop) 3975 return PacketResult::Success; 3976 } else if (packet_str == "1") { 3977 if (!m_non_stop) 3978 StartSTDIOForwarding(); 3979 m_non_stop = true; 3980 } else 3981 return SendErrorResponse(Status("Invalid QNonStop packet")); 3982 return SendOKResponse(); 3983} 3984 3985GDBRemoteCommunication::PacketResult 3986GDBRemoteCommunicationServerLLGS::HandleNotificationAck( 3987 std::deque<std::string> &queue) { 3988 // Per the protocol, the first message put into the queue is sent 3989 // immediately. However, it remains the queue until the client ACKs it -- 3990 // then we pop it and send the next message. The process repeats until 3991 // the last message in the queue is ACK-ed, in which case the packet sends 3992 // an OK response. 3993 if (queue.empty()) 3994 return SendErrorResponse(Status("No pending notification to ack")); 3995 queue.pop_front(); 3996 if (!queue.empty()) 3997 return SendPacketNoLock(queue.front()); 3998 return SendOKResponse(); 3999} 4000 4001GDBRemoteCommunication::PacketResult 4002GDBRemoteCommunicationServerLLGS::Handle_vStdio( 4003 StringExtractorGDBRemote &packet) { 4004 return HandleNotificationAck(m_stdio_notification_queue); 4005} 4006 4007GDBRemoteCommunication::PacketResult 4008GDBRemoteCommunicationServerLLGS::Handle_vStopped( 4009 StringExtractorGDBRemote &packet) { 4010 PacketResult ret = HandleNotificationAck(m_stop_notification_queue); 4011 // If this was the last notification and all the processes exited, 4012 // terminate the server. 4013 if (m_stop_notification_queue.empty() && m_debugged_processes.empty()) { 4014 m_exit_now = true; 4015 m_mainloop.RequestTermination(); 4016 } 4017 return ret; 4018} 4019 4020GDBRemoteCommunication::PacketResult 4021GDBRemoteCommunicationServerLLGS::Handle_vCtrlC( 4022 StringExtractorGDBRemote &packet) { 4023 if (!m_non_stop) 4024 return SendErrorResponse(Status("vCtrl is only valid in non-stop mode")); 4025 4026 PacketResult interrupt_res = Handle_interrupt(packet); 4027 // If interrupting the process failed, pass the result through. 4028 if (interrupt_res != PacketResult::Success) 4029 return interrupt_res; 4030 // Otherwise, vCtrlC should issue an OK response (normal interrupts do not). 4031 return SendOKResponse(); 4032} 4033 4034GDBRemoteCommunication::PacketResult 4035GDBRemoteCommunicationServerLLGS::Handle_T(StringExtractorGDBRemote &packet) { 4036 packet.SetFilePos(strlen("T")); 4037 auto pid_tid = packet.GetPidTid(m_current_process ? m_current_process->GetID() 4038 : LLDB_INVALID_PROCESS_ID); 4039 if (!pid_tid) 4040 return SendErrorResponse(llvm::make_error<StringError>( 4041 inconvertibleErrorCode(), "Malformed thread-id")); 4042 4043 lldb::pid_t pid = pid_tid->first; 4044 lldb::tid_t tid = pid_tid->second; 4045 4046 // Technically, this would also be caught by the PID check but let's be more 4047 // explicit about the error. 4048 if (pid == LLDB_INVALID_PROCESS_ID) 4049 return SendErrorResponse(llvm::make_error<StringError>( 4050 inconvertibleErrorCode(), "No current process and no PID provided")); 4051 4052 // Check the process ID and find respective process instance. 4053 auto new_process_it = m_debugged_processes.find(pid); 4054 if (new_process_it == m_debugged_processes.end()) 4055 return SendErrorResponse(1); 4056 4057 // Check the thread ID 4058 if (!new_process_it->second.process_up->GetThreadByID(tid)) 4059 return SendErrorResponse(2); 4060 4061 return SendOKResponse(); 4062} 4063 4064void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() { 4065 Log *log = GetLog(LLDBLog::Process); 4066 4067 // Tell the stdio connection to shut down. 4068 if (m_stdio_communication.IsConnected()) { 4069 auto connection = m_stdio_communication.GetConnection(); 4070 if (connection) { 4071 Status error; 4072 connection->Disconnect(&error); 4073 4074 if (error.Success()) { 4075 LLDB_LOGF(log, 4076 "GDBRemoteCommunicationServerLLGS::%s disconnect process " 4077 "terminal stdio - SUCCESS", 4078 __FUNCTION__); 4079 } else { 4080 LLDB_LOGF(log, 4081 "GDBRemoteCommunicationServerLLGS::%s disconnect process " 4082 "terminal stdio - FAIL: %s", 4083 __FUNCTION__, error.AsCString()); 4084 } 4085 } 4086 } 4087} 4088 4089NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( 4090 StringExtractorGDBRemote &packet) { 4091 // We have no thread if we don't have a process. 4092 if (!m_current_process || 4093 m_current_process->GetID() == LLDB_INVALID_PROCESS_ID) 4094 return nullptr; 4095 4096 // If the client hasn't asked for thread suffix support, there will not be a 4097 // thread suffix. Use the current thread in that case. 4098 if (!m_thread_suffix_supported) { 4099 const lldb::tid_t current_tid = GetCurrentThreadID(); 4100 if (current_tid == LLDB_INVALID_THREAD_ID) 4101 return nullptr; 4102 else if (current_tid == 0) { 4103 // Pick a thread. 4104 return m_current_process->GetThreadAtIndex(0); 4105 } else 4106 return m_current_process->GetThreadByID(current_tid); 4107 } 4108 4109 Log *log = GetLog(LLDBLog::Thread); 4110 4111 // Parse out the ';'. 4112 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') { 4113 LLDB_LOGF(log, 4114 "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 4115 "error: expected ';' prior to start of thread suffix: packet " 4116 "contents = '%s'", 4117 __FUNCTION__, packet.GetStringRef().data()); 4118 return nullptr; 4119 } 4120 4121 if (!packet.GetBytesLeft()) 4122 return nullptr; 4123 4124 // Parse out thread: portion. 4125 if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) { 4126 LLDB_LOGF(log, 4127 "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 4128 "error: expected 'thread:' but not found, packet contents = " 4129 "'%s'", 4130 __FUNCTION__, packet.GetStringRef().data()); 4131 return nullptr; 4132 } 4133 packet.SetFilePos(packet.GetFilePos() + strlen("thread:")); 4134 const lldb::tid_t tid = packet.GetHexMaxU64(false, 0); 4135 if (tid != 0) 4136 return m_current_process->GetThreadByID(tid); 4137 4138 return nullptr; 4139} 4140 4141lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const { 4142 if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) { 4143 // Use whatever the debug process says is the current thread id since the 4144 // protocol either didn't specify or specified we want any/all threads 4145 // marked as the current thread. 4146 if (!m_current_process) 4147 return LLDB_INVALID_THREAD_ID; 4148 return m_current_process->GetCurrentThreadID(); 4149 } 4150 // Use the specific current thread id set by the gdb remote protocol. 4151 return m_current_tid; 4152} 4153 4154uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() { 4155 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 4156 return m_next_saved_registers_id++; 4157} 4158 4159void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() { 4160 Log *log = GetLog(LLDBLog::Process); 4161 4162 LLDB_LOG(log, "clearing {0} xfer buffers", m_xfer_buffer_map.size()); 4163 m_xfer_buffer_map.clear(); 4164} 4165 4166FileSpec 4167GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path, 4168 const ArchSpec &arch) { 4169 if (m_current_process) { 4170 FileSpec file_spec; 4171 if (m_current_process 4172 ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec) 4173 .Success()) { 4174 if (FileSystem::Instance().Exists(file_spec)) 4175 return file_spec; 4176 } 4177 } 4178 4179 return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch); 4180} 4181 4182std::string GDBRemoteCommunicationServerLLGS::XMLEncodeAttributeValue( 4183 llvm::StringRef value) { 4184 std::string result; 4185 for (const char &c : value) { 4186 switch (c) { 4187 case '\'': 4188 result += "'"; 4189 break; 4190 case '"': 4191 result += """; 4192 break; 4193 case '<': 4194 result += "<"; 4195 break; 4196 case '>': 4197 result += ">"; 4198 break; 4199 default: 4200 result += c; 4201 break; 4202 } 4203 } 4204 return result; 4205} 4206 4207std::vector<std::string> GDBRemoteCommunicationServerLLGS::HandleFeatures( 4208 const llvm::ArrayRef<llvm::StringRef> client_features) { 4209 std::vector<std::string> ret = 4210 GDBRemoteCommunicationServerCommon::HandleFeatures(client_features); 4211 ret.insert(ret.end(), { 4212 "QThreadSuffixSupported+", 4213 "QListThreadsInStopReply+", 4214 "qXfer:features:read+", 4215 "QNonStop+", 4216 }); 4217 4218 // report server-only features 4219 using Extension = NativeProcessProtocol::Extension; 4220 Extension plugin_features = m_process_manager.GetSupportedExtensions(); 4221 if (bool(plugin_features & Extension::pass_signals)) 4222 ret.push_back("QPassSignals+"); 4223 if (bool(plugin_features & Extension::auxv)) 4224 ret.push_back("qXfer:auxv:read+"); 4225 if (bool(plugin_features & Extension::libraries_svr4)) 4226 ret.push_back("qXfer:libraries-svr4:read+"); 4227 if (bool(plugin_features & Extension::siginfo_read)) 4228 ret.push_back("qXfer:siginfo:read+"); 4229 if (bool(plugin_features & Extension::memory_tagging)) 4230 ret.push_back("memory-tagging+"); 4231 if (bool(plugin_features & Extension::savecore)) 4232 ret.push_back("qSaveCore+"); 4233 4234 // check for client features 4235 m_extensions_supported = {}; 4236 for (llvm::StringRef x : client_features) 4237 m_extensions_supported |= 4238 llvm::StringSwitch<Extension>(x) 4239 .Case("multiprocess+", Extension::multiprocess) 4240 .Case("fork-events+", Extension::fork) 4241 .Case("vfork-events+", Extension::vfork) 4242 .Default({}); 4243 4244 m_extensions_supported &= plugin_features; 4245 4246 // fork & vfork require multiprocess 4247 if (!bool(m_extensions_supported & Extension::multiprocess)) 4248 m_extensions_supported &= ~(Extension::fork | Extension::vfork); 4249 4250 // report only if actually supported 4251 if (bool(m_extensions_supported & Extension::multiprocess)) 4252 ret.push_back("multiprocess+"); 4253 if (bool(m_extensions_supported & Extension::fork)) 4254 ret.push_back("fork-events+"); 4255 if (bool(m_extensions_supported & Extension::vfork)) 4256 ret.push_back("vfork-events+"); 4257 4258 for (auto &x : m_debugged_processes) 4259 SetEnabledExtensions(*x.second.process_up); 4260 return ret; 4261} 4262 4263void GDBRemoteCommunicationServerLLGS::SetEnabledExtensions( 4264 NativeProcessProtocol &process) { 4265 NativeProcessProtocol::Extension flags = m_extensions_supported; 4266 assert(!bool(flags & ~m_process_manager.GetSupportedExtensions())); 4267 process.SetEnabledExtensions(flags); 4268} 4269 4270GDBRemoteCommunication::PacketResult 4271GDBRemoteCommunicationServerLLGS::SendContinueSuccessResponse() { 4272 if (m_non_stop) 4273 return SendOKResponse(); 4274 StartSTDIOForwarding(); 4275 return PacketResult::Success; 4276} 4277 4278void GDBRemoteCommunicationServerLLGS::AppendThreadIDToResponse( 4279 Stream &response, lldb::pid_t pid, lldb::tid_t tid) { 4280 if (bool(m_extensions_supported & 4281 NativeProcessProtocol::Extension::multiprocess)) 4282 response.Format("p{0:x-}.", pid); 4283 response.Format("{0:x-}", tid); 4284} 4285 4286std::string 4287lldb_private::process_gdb_remote::LLGSArgToURL(llvm::StringRef url_arg, 4288 bool reverse_connect) { 4289 // Try parsing the argument as URL. 4290 if (std::optional<URI> url = URI::Parse(url_arg)) { 4291 if (reverse_connect) 4292 return url_arg.str(); 4293 4294 // Translate the scheme from LLGS notation to ConnectionFileDescriptor. 4295 // If the scheme doesn't match any, pass it through to support using CFD 4296 // schemes directly. 4297 std::string new_url = llvm::StringSwitch<std::string>(url->scheme) 4298 .Case("tcp", "listen") 4299 .Case("unix", "unix-accept") 4300 .Case("unix-abstract", "unix-abstract-accept") 4301 .Default(url->scheme.str()); 4302 llvm::append_range(new_url, url_arg.substr(url->scheme.size())); 4303 return new_url; 4304 } 4305 4306 std::string host_port = url_arg.str(); 4307 // If host_and_port starts with ':', default the host to be "localhost" and 4308 // expect the remainder to be the port. 4309 if (url_arg.starts_with(":")) 4310 host_port.insert(0, "localhost"); 4311 4312 // Try parsing the (preprocessed) argument as host:port pair. 4313 if (!llvm::errorToBool(Socket::DecodeHostAndPort(host_port).takeError())) 4314 return (reverse_connect ? "connect://" : "listen://") + host_port; 4315 4316 // If none of the above applied, interpret the argument as UNIX socket path. 4317 return (reverse_connect ? "unix-connect://" : "unix-accept://") + 4318 url_arg.str(); 4319} 4320