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 52 using namespace lldb; 53 using namespace lldb_private; 54 using namespace lldb_private::process_gdb_remote; 55 using namespace llvm; 56 57 // GDBRemote Errors 58 59 namespace { 60 enum GDBRemoteServerError { 61 // Set to the first unused error number in literal form below 62 eErrorFirst = 29, 63 eErrorNoProcess = eErrorFirst, 64 eErrorResume, 65 eErrorExitStatus 66 }; 67 } 68 69 // GDBRemoteCommunicationServerLLGS constructor 70 GDBRemoteCommunicationServerLLGS::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 78 void 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 256 void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) { 257 m_process_launch_info = info; 258 } 259 260 Status GDBRemoteCommunicationServerLLGS::LaunchProcess() { 261 Log *log = GetLog(LLDBLog::Process); 262 263 if (!m_process_launch_info.GetArguments().GetArgumentCount()) 264 return Status::FromErrorStringWithFormat( 265 "%s: no process command line specified to launch", __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::FromError(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::FromError(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 343 Status 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::FromErrorStringWithFormat( 352 "cannot attach to process %" PRIu64 353 " when another process with pid %" PRIu64 " 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 = Status::FromError(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 391 Status 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 = Status(error_stream.GetString().str()); 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 460 void 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 473 GDBRemoteCommunication::PacketResult 474 GDBRemoteCommunicationServerLLGS::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 510 static 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 522 static 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 537 static 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 570 static 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 605 static 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 617 static 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 642 static std::optional<json::Object> 643 GetRegistersAsJSON(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 695 static 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 eStopReasonInterrupt: 718 return "async interrupt"; 719 case eStopReasonInstrumentation: 720 case eStopReasonInvalid: 721 case eStopReasonPlanComplete: 722 case eStopReasonThreadExiting: 723 case eStopReasonNone: 724 break; // ignored 725 } 726 return nullptr; 727 } 728 729 static llvm::Expected<json::Array> 730 GetJSONThreadsInfo(NativeProcessProtocol &process, bool abridged) { 731 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 732 733 json::Array threads_array; 734 735 // Ensure we can get info on the given thread. 736 for (NativeThreadProtocol &thread : process.Threads()) { 737 lldb::tid_t tid = thread.GetID(); 738 // Grab the reason this thread stopped. 739 struct ThreadStopInfo tid_stop_info; 740 std::string description; 741 if (!thread.GetStopReason(tid_stop_info, description)) 742 return llvm::make_error<llvm::StringError>( 743 "failed to get stop reason", llvm::inconvertibleErrorCode()); 744 745 const int signum = tid_stop_info.signo; 746 if (log) { 747 LLDB_LOGF(log, 748 "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 749 " tid %" PRIu64 750 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 751 __FUNCTION__, process.GetID(), tid, signum, 752 tid_stop_info.reason, tid_stop_info.details.exception.type); 753 } 754 755 json::Object thread_obj; 756 757 if (!abridged) { 758 if (std::optional<json::Object> registers = GetRegistersAsJSON(thread)) 759 thread_obj.try_emplace("registers", std::move(*registers)); 760 } 761 762 thread_obj.try_emplace("tid", static_cast<int64_t>(tid)); 763 764 if (signum != 0) 765 thread_obj.try_emplace("signal", signum); 766 767 const std::string thread_name = thread.GetName(); 768 if (!thread_name.empty()) 769 thread_obj.try_emplace("name", thread_name); 770 771 const char *stop_reason = GetStopReasonString(tid_stop_info.reason); 772 if (stop_reason) 773 thread_obj.try_emplace("reason", stop_reason); 774 775 if (!description.empty()) 776 thread_obj.try_emplace("description", description); 777 778 if ((tid_stop_info.reason == eStopReasonException) && 779 tid_stop_info.details.exception.type) { 780 thread_obj.try_emplace( 781 "metype", static_cast<int64_t>(tid_stop_info.details.exception.type)); 782 783 json::Array medata_array; 784 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; 785 ++i) { 786 medata_array.push_back( 787 static_cast<int64_t>(tid_stop_info.details.exception.data[i])); 788 } 789 thread_obj.try_emplace("medata", std::move(medata_array)); 790 } 791 threads_array.push_back(std::move(thread_obj)); 792 } 793 return threads_array; 794 } 795 796 StreamString 797 GDBRemoteCommunicationServerLLGS::PrepareStopReplyPacketForThread( 798 NativeThreadProtocol &thread) { 799 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 800 801 NativeProcessProtocol &process = thread.GetProcess(); 802 803 LLDB_LOG(log, "preparing packet for pid {0} tid {1}", process.GetID(), 804 thread.GetID()); 805 806 // Grab the reason this thread stopped. 807 StreamString response; 808 struct ThreadStopInfo tid_stop_info; 809 std::string description; 810 if (!thread.GetStopReason(tid_stop_info, description)) 811 return response; 812 813 // FIXME implement register handling for exec'd inferiors. 814 // if (tid_stop_info.reason == eStopReasonExec) { 815 // const bool force = true; 816 // InitializeRegisters(force); 817 // } 818 819 // Output the T packet with the thread 820 response.PutChar('T'); 821 int signum = tid_stop_info.signo; 822 LLDB_LOG( 823 log, 824 "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}", 825 process.GetID(), thread.GetID(), signum, int(tid_stop_info.reason), 826 tid_stop_info.details.exception.type); 827 828 // Print the signal number. 829 response.PutHex8(signum & 0xff); 830 831 // Include the (pid and) tid. 832 response.PutCString("thread:"); 833 AppendThreadIDToResponse(response, process.GetID(), thread.GetID()); 834 response.PutChar(';'); 835 836 // Include the thread name if there is one. 837 const std::string thread_name = thread.GetName(); 838 if (!thread_name.empty()) { 839 size_t thread_name_len = thread_name.length(); 840 841 if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) { 842 response.PutCString("name:"); 843 response.PutCString(thread_name); 844 } else { 845 // The thread name contains special chars, send as hex bytes. 846 response.PutCString("hexname:"); 847 response.PutStringAsRawHex8(thread_name); 848 } 849 response.PutChar(';'); 850 } 851 852 // If a 'QListThreadsInStopReply' was sent to enable this feature, we will 853 // send all thread IDs back in the "threads" key whose value is a list of hex 854 // thread IDs separated by commas: 855 // "threads:10a,10b,10c;" 856 // This will save the debugger from having to send a pair of qfThreadInfo and 857 // qsThreadInfo packets, but it also might take a lot of room in the stop 858 // reply packet, so it must be enabled only on systems where there are no 859 // limits on packet lengths. 860 if (m_list_threads_in_stop_reply) { 861 response.PutCString("threads:"); 862 863 uint32_t thread_num = 0; 864 for (NativeThreadProtocol &listed_thread : process.Threads()) { 865 if (thread_num > 0) 866 response.PutChar(','); 867 response.Printf("%" PRIx64, listed_thread.GetID()); 868 ++thread_num; 869 } 870 response.PutChar(';'); 871 872 // Include JSON info that describes the stop reason for any threads that 873 // actually have stop reasons. We use the new "jstopinfo" key whose values 874 // is hex ascii JSON that contains the thread IDs thread stop info only for 875 // threads that have stop reasons. Only send this if we have more than one 876 // thread otherwise this packet has all the info it needs. 877 if (thread_num > 1) { 878 const bool threads_with_valid_stop_info_only = true; 879 llvm::Expected<json::Array> threads_info = GetJSONThreadsInfo( 880 *m_current_process, threads_with_valid_stop_info_only); 881 if (threads_info) { 882 response.PutCString("jstopinfo:"); 883 StreamString unescaped_response; 884 unescaped_response.AsRawOstream() << std::move(*threads_info); 885 response.PutStringAsRawHex8(unescaped_response.GetData()); 886 response.PutChar(';'); 887 } else { 888 LLDB_LOG_ERROR(log, threads_info.takeError(), 889 "failed to prepare a jstopinfo field for pid {1}: {0}", 890 process.GetID()); 891 } 892 } 893 894 response.PutCString("thread-pcs"); 895 char delimiter = ':'; 896 for (NativeThreadProtocol &thread : process.Threads()) { 897 NativeRegisterContext ®_ctx = thread.GetRegisterContext(); 898 899 uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber( 900 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 901 const RegisterInfo *const reg_info_p = 902 reg_ctx.GetRegisterInfoAtIndex(reg_to_read); 903 904 RegisterValue reg_value; 905 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 906 if (error.Fail()) { 907 LLDB_LOGF(log, "%s failed to read register '%s' index %" PRIu32 ": %s", 908 __FUNCTION__, 909 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 910 reg_to_read, error.AsCString()); 911 continue; 912 } 913 914 response.PutChar(delimiter); 915 delimiter = ','; 916 WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p, 917 ®_value, endian::InlHostByteOrder()); 918 } 919 920 response.PutChar(';'); 921 } 922 923 // 924 // Expedite registers. 925 // 926 927 // Grab the register context. 928 NativeRegisterContext ®_ctx = thread.GetRegisterContext(); 929 const auto expedited_regs = 930 reg_ctx.GetExpeditedRegisters(ExpeditedRegs::Full); 931 932 for (auto ®_num : expedited_regs) { 933 const RegisterInfo *const reg_info_p = 934 reg_ctx.GetRegisterInfoAtIndex(reg_num); 935 // Only expediate registers that are not contained in other registers. 936 if (reg_info_p != nullptr && reg_info_p->value_regs == nullptr) { 937 RegisterValue reg_value; 938 Status error = reg_ctx.ReadRegister(reg_info_p, reg_value); 939 if (error.Success()) { 940 response.Printf("%.02x:", reg_num); 941 WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p, 942 ®_value, lldb::eByteOrderBig); 943 response.PutChar(';'); 944 } else { 945 LLDB_LOGF(log, 946 "GDBRemoteCommunicationServerLLGS::%s failed to read " 947 "register '%s' index %" PRIu32 ": %s", 948 __FUNCTION__, 949 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", 950 reg_num, error.AsCString()); 951 } 952 } 953 } 954 955 const char *reason_str = GetStopReasonString(tid_stop_info.reason); 956 if (reason_str != nullptr) { 957 response.Printf("reason:%s;", reason_str); 958 } 959 960 if (!description.empty()) { 961 // Description may contains special chars, send as hex bytes. 962 response.PutCString("description:"); 963 response.PutStringAsRawHex8(description); 964 response.PutChar(';'); 965 } else if ((tid_stop_info.reason == eStopReasonException) && 966 tid_stop_info.details.exception.type) { 967 response.PutCString("metype:"); 968 response.PutHex64(tid_stop_info.details.exception.type); 969 response.PutCString(";mecount:"); 970 response.PutHex32(tid_stop_info.details.exception.data_count); 971 response.PutChar(';'); 972 973 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) { 974 response.PutCString("medata:"); 975 response.PutHex64(tid_stop_info.details.exception.data[i]); 976 response.PutChar(';'); 977 } 978 } 979 980 // Include child process PID/TID for forks. 981 if (tid_stop_info.reason == eStopReasonFork || 982 tid_stop_info.reason == eStopReasonVFork) { 983 assert(bool(m_extensions_supported & 984 NativeProcessProtocol::Extension::multiprocess)); 985 if (tid_stop_info.reason == eStopReasonFork) 986 assert(bool(m_extensions_supported & 987 NativeProcessProtocol::Extension::fork)); 988 if (tid_stop_info.reason == eStopReasonVFork) 989 assert(bool(m_extensions_supported & 990 NativeProcessProtocol::Extension::vfork)); 991 response.Printf("%s:p%" PRIx64 ".%" PRIx64 ";", reason_str, 992 tid_stop_info.details.fork.child_pid, 993 tid_stop_info.details.fork.child_tid); 994 } 995 996 return response; 997 } 998 999 GDBRemoteCommunication::PacketResult 1000 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 1001 NativeProcessProtocol &process, lldb::tid_t tid, bool force_synchronous) { 1002 // Ensure we can get info on the given thread. 1003 NativeThreadProtocol *thread = process.GetThreadByID(tid); 1004 if (!thread) 1005 return SendErrorResponse(51); 1006 1007 StreamString response = PrepareStopReplyPacketForThread(*thread); 1008 if (response.Empty()) 1009 return SendErrorResponse(42); 1010 1011 if (m_non_stop && !force_synchronous) { 1012 PacketResult ret = SendNotificationPacketNoLock( 1013 "Stop", m_stop_notification_queue, response.GetString()); 1014 // Queue notification events for the remaining threads. 1015 EnqueueStopReplyPackets(tid); 1016 return ret; 1017 } 1018 1019 return SendPacketNoLock(response.GetString()); 1020 } 1021 1022 void GDBRemoteCommunicationServerLLGS::EnqueueStopReplyPackets( 1023 lldb::tid_t thread_to_skip) { 1024 if (!m_non_stop) 1025 return; 1026 1027 for (NativeThreadProtocol &listed_thread : m_current_process->Threads()) { 1028 if (listed_thread.GetID() != thread_to_skip) { 1029 StreamString stop_reply = PrepareStopReplyPacketForThread(listed_thread); 1030 if (!stop_reply.Empty()) 1031 m_stop_notification_queue.push_back(stop_reply.GetString().str()); 1032 } 1033 } 1034 } 1035 1036 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited( 1037 NativeProcessProtocol *process) { 1038 assert(process && "process cannot be NULL"); 1039 1040 Log *log = GetLog(LLDBLog::Process); 1041 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1042 1043 PacketResult result = SendStopReasonForState( 1044 *process, StateType::eStateExited, /*force_synchronous=*/false); 1045 if (result != PacketResult::Success) { 1046 LLDB_LOGF(log, 1047 "GDBRemoteCommunicationServerLLGS::%s failed to send stop " 1048 "notification for PID %" PRIu64 ", state: eStateExited", 1049 __FUNCTION__, process->GetID()); 1050 } 1051 1052 if (m_current_process == process) 1053 m_current_process = nullptr; 1054 if (m_continue_process == process) 1055 m_continue_process = nullptr; 1056 1057 lldb::pid_t pid = process->GetID(); 1058 m_mainloop.AddPendingCallback([this, pid](MainLoopBase &loop) { 1059 auto find_it = m_debugged_processes.find(pid); 1060 assert(find_it != m_debugged_processes.end()); 1061 bool vkilled = bool(find_it->second.flags & DebuggedProcess::Flag::vkilled); 1062 m_debugged_processes.erase(find_it); 1063 // Terminate the main loop only if vKill has not been used. 1064 // When running in non-stop mode, wait for the vStopped to clear 1065 // the notification queue. 1066 if (m_debugged_processes.empty() && !m_non_stop && !vkilled) { 1067 // Close the pipe to the inferior terminal i/o if we launched it and set 1068 // one up. 1069 MaybeCloseInferiorTerminalConnection(); 1070 1071 // We are ready to exit the debug monitor. 1072 m_exit_now = true; 1073 loop.RequestTermination(); 1074 } 1075 }); 1076 } 1077 1078 void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped( 1079 NativeProcessProtocol *process) { 1080 assert(process && "process cannot be NULL"); 1081 1082 Log *log = GetLog(LLDBLog::Process); 1083 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1084 1085 PacketResult result = SendStopReasonForState( 1086 *process, StateType::eStateStopped, /*force_synchronous=*/false); 1087 if (result != PacketResult::Success) { 1088 LLDB_LOGF(log, 1089 "GDBRemoteCommunicationServerLLGS::%s failed to send stop " 1090 "notification for PID %" PRIu64 ", state: eStateExited", 1091 __FUNCTION__, process->GetID()); 1092 } 1093 } 1094 1095 void GDBRemoteCommunicationServerLLGS::ProcessStateChanged( 1096 NativeProcessProtocol *process, lldb::StateType state) { 1097 assert(process && "process cannot be NULL"); 1098 Log *log = GetLog(LLDBLog::Process); 1099 if (log) { 1100 LLDB_LOGF(log, 1101 "GDBRemoteCommunicationServerLLGS::%s called with " 1102 "NativeProcessProtocol pid %" PRIu64 ", state: %s", 1103 __FUNCTION__, process->GetID(), StateAsCString(state)); 1104 } 1105 1106 switch (state) { 1107 case StateType::eStateRunning: 1108 break; 1109 1110 case StateType::eStateStopped: 1111 // Make sure we get all of the pending stdout/stderr from the inferior and 1112 // send it to the lldb host before we send the state change notification 1113 SendProcessOutput(); 1114 // Then stop the forwarding, so that any late output (see llvm.org/pr25652) 1115 // does not interfere with our protocol. 1116 if (!m_non_stop) 1117 StopSTDIOForwarding(); 1118 HandleInferiorState_Stopped(process); 1119 break; 1120 1121 case StateType::eStateExited: 1122 // Same as above 1123 SendProcessOutput(); 1124 if (!m_non_stop) 1125 StopSTDIOForwarding(); 1126 HandleInferiorState_Exited(process); 1127 break; 1128 1129 default: 1130 if (log) { 1131 LLDB_LOGF(log, 1132 "GDBRemoteCommunicationServerLLGS::%s didn't handle state " 1133 "change for pid %" PRIu64 ", new state: %s", 1134 __FUNCTION__, process->GetID(), StateAsCString(state)); 1135 } 1136 break; 1137 } 1138 } 1139 1140 void GDBRemoteCommunicationServerLLGS::DidExec(NativeProcessProtocol *process) { 1141 ClearProcessSpecificData(); 1142 } 1143 1144 void GDBRemoteCommunicationServerLLGS::NewSubprocess( 1145 NativeProcessProtocol *parent_process, 1146 std::unique_ptr<NativeProcessProtocol> child_process) { 1147 lldb::pid_t child_pid = child_process->GetID(); 1148 assert(child_pid != LLDB_INVALID_PROCESS_ID); 1149 assert(m_debugged_processes.find(child_pid) == m_debugged_processes.end()); 1150 m_debugged_processes.emplace( 1151 child_pid, 1152 DebuggedProcess{std::move(child_process), DebuggedProcess::Flag{}}); 1153 } 1154 1155 void GDBRemoteCommunicationServerLLGS::DataAvailableCallback() { 1156 Log *log = GetLog(GDBRLog::Comm); 1157 1158 bool interrupt = false; 1159 bool done = false; 1160 Status error; 1161 while (true) { 1162 const PacketResult result = GetPacketAndSendResponse( 1163 std::chrono::microseconds(0), error, interrupt, done); 1164 if (result == PacketResult::ErrorReplyTimeout) 1165 break; // No more packets in the queue 1166 1167 if ((result != PacketResult::Success)) { 1168 LLDB_LOGF(log, 1169 "GDBRemoteCommunicationServerLLGS::%s processing a packet " 1170 "failed: %s", 1171 __FUNCTION__, error.AsCString()); 1172 m_mainloop.RequestTermination(); 1173 break; 1174 } 1175 } 1176 } 1177 1178 Status GDBRemoteCommunicationServerLLGS::InitializeConnection( 1179 std::unique_ptr<Connection> connection) { 1180 IOObjectSP read_object_sp = connection->GetReadObject(); 1181 GDBRemoteCommunicationServer::SetConnection(std::move(connection)); 1182 1183 Status error; 1184 m_network_handle_up = m_mainloop.RegisterReadObject( 1185 read_object_sp, [this](MainLoopBase &) { DataAvailableCallback(); }, 1186 error); 1187 return error; 1188 } 1189 1190 GDBRemoteCommunication::PacketResult 1191 GDBRemoteCommunicationServerLLGS::SendONotification(const char *buffer, 1192 uint32_t len) { 1193 if ((buffer == nullptr) || (len == 0)) { 1194 // Nothing to send. 1195 return PacketResult::Success; 1196 } 1197 1198 StreamString response; 1199 response.PutChar('O'); 1200 response.PutBytesAsRawHex8(buffer, len); 1201 1202 if (m_non_stop) 1203 return SendNotificationPacketNoLock("Stdio", m_stdio_notification_queue, 1204 response.GetString()); 1205 return SendPacketNoLock(response.GetString()); 1206 } 1207 1208 Status GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) { 1209 Status error; 1210 1211 // Set up the reading/handling of process I/O 1212 std::unique_ptr<ConnectionFileDescriptor> conn_up( 1213 new ConnectionFileDescriptor(fd, true)); 1214 if (!conn_up) { 1215 error = 1216 Status::FromErrorString("failed to create ConnectionFileDescriptor"); 1217 return error; 1218 } 1219 1220 m_stdio_communication.SetCloseOnEOF(false); 1221 m_stdio_communication.SetConnection(std::move(conn_up)); 1222 if (!m_stdio_communication.IsConnected()) { 1223 error = Status::FromErrorString( 1224 "failed to set connection for inferior I/O communication"); 1225 return error; 1226 } 1227 1228 return Status(); 1229 } 1230 1231 void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() { 1232 // Don't forward if not connected (e.g. when attaching). 1233 if (!m_stdio_communication.IsConnected()) 1234 return; 1235 1236 Status error; 1237 assert(!m_stdio_handle_up); 1238 m_stdio_handle_up = m_mainloop.RegisterReadObject( 1239 m_stdio_communication.GetConnection()->GetReadObject(), 1240 [this](MainLoopBase &) { SendProcessOutput(); }, error); 1241 1242 if (!m_stdio_handle_up) { 1243 // Not much we can do about the failure. Log it and continue without 1244 // forwarding. 1245 if (Log *log = GetLog(LLDBLog::Process)) 1246 LLDB_LOG(log, "Failed to set up stdio forwarding: {0}", error); 1247 } 1248 } 1249 1250 void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() { 1251 m_stdio_handle_up.reset(); 1252 } 1253 1254 void GDBRemoteCommunicationServerLLGS::SendProcessOutput() { 1255 char buffer[1024]; 1256 ConnectionStatus status; 1257 Status error; 1258 while (true) { 1259 size_t bytes_read = m_stdio_communication.Read( 1260 buffer, sizeof buffer, std::chrono::microseconds(0), status, &error); 1261 switch (status) { 1262 case eConnectionStatusSuccess: 1263 SendONotification(buffer, bytes_read); 1264 break; 1265 case eConnectionStatusLostConnection: 1266 case eConnectionStatusEndOfFile: 1267 case eConnectionStatusError: 1268 case eConnectionStatusNoConnection: 1269 if (Log *log = GetLog(LLDBLog::Process)) 1270 LLDB_LOGF(log, 1271 "GDBRemoteCommunicationServerLLGS::%s Stopping stdio " 1272 "forwarding as communication returned status %d (error: " 1273 "%s)", 1274 __FUNCTION__, status, error.AsCString()); 1275 m_stdio_handle_up.reset(); 1276 return; 1277 1278 case eConnectionStatusInterrupted: 1279 case eConnectionStatusTimedOut: 1280 return; 1281 } 1282 } 1283 } 1284 1285 GDBRemoteCommunication::PacketResult 1286 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceSupported( 1287 StringExtractorGDBRemote &packet) { 1288 1289 // Fail if we don't have a current process. 1290 if (!m_current_process || 1291 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1292 return SendErrorResponse(Status::FromErrorString("Process not running.")); 1293 1294 return SendJSONResponse(m_current_process->TraceSupported()); 1295 } 1296 1297 GDBRemoteCommunication::PacketResult 1298 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStop( 1299 StringExtractorGDBRemote &packet) { 1300 // Fail if we don't have a current process. 1301 if (!m_current_process || 1302 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1303 return SendErrorResponse(Status::FromErrorString("Process not running.")); 1304 1305 packet.ConsumeFront("jLLDBTraceStop:"); 1306 Expected<TraceStopRequest> stop_request = 1307 json::parse<TraceStopRequest>(packet.Peek(), "TraceStopRequest"); 1308 if (!stop_request) 1309 return SendErrorResponse(stop_request.takeError()); 1310 1311 if (Error err = m_current_process->TraceStop(*stop_request)) 1312 return SendErrorResponse(std::move(err)); 1313 1314 return SendOKResponse(); 1315 } 1316 1317 GDBRemoteCommunication::PacketResult 1318 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceStart( 1319 StringExtractorGDBRemote &packet) { 1320 1321 // Fail if we don't have a current process. 1322 if (!m_current_process || 1323 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1324 return SendErrorResponse(Status::FromErrorString("Process not running.")); 1325 1326 packet.ConsumeFront("jLLDBTraceStart:"); 1327 Expected<TraceStartRequest> request = 1328 json::parse<TraceStartRequest>(packet.Peek(), "TraceStartRequest"); 1329 if (!request) 1330 return SendErrorResponse(request.takeError()); 1331 1332 if (Error err = m_current_process->TraceStart(packet.Peek(), request->type)) 1333 return SendErrorResponse(std::move(err)); 1334 1335 return SendOKResponse(); 1336 } 1337 1338 GDBRemoteCommunication::PacketResult 1339 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState( 1340 StringExtractorGDBRemote &packet) { 1341 1342 // Fail if we don't have a current process. 1343 if (!m_current_process || 1344 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1345 return SendErrorResponse(Status::FromErrorString("Process not running.")); 1346 1347 packet.ConsumeFront("jLLDBTraceGetState:"); 1348 Expected<TraceGetStateRequest> request = 1349 json::parse<TraceGetStateRequest>(packet.Peek(), "TraceGetStateRequest"); 1350 if (!request) 1351 return SendErrorResponse(request.takeError()); 1352 1353 return SendJSONResponse(m_current_process->TraceGetState(request->type)); 1354 } 1355 1356 GDBRemoteCommunication::PacketResult 1357 GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData( 1358 StringExtractorGDBRemote &packet) { 1359 1360 // Fail if we don't have a current process. 1361 if (!m_current_process || 1362 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1363 return SendErrorResponse(Status::FromErrorString("Process not running.")); 1364 1365 packet.ConsumeFront("jLLDBTraceGetBinaryData:"); 1366 llvm::Expected<TraceGetBinaryDataRequest> request = 1367 llvm::json::parse<TraceGetBinaryDataRequest>(packet.Peek(), 1368 "TraceGetBinaryDataRequest"); 1369 if (!request) 1370 return SendErrorResponse(Status::FromError(request.takeError())); 1371 1372 if (Expected<std::vector<uint8_t>> bytes = 1373 m_current_process->TraceGetBinaryData(*request)) { 1374 StreamGDBRemote response; 1375 response.PutEscapedBytes(bytes->data(), bytes->size()); 1376 return SendPacketNoLock(response.GetString()); 1377 } else 1378 return SendErrorResponse(bytes.takeError()); 1379 } 1380 1381 GDBRemoteCommunication::PacketResult 1382 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo( 1383 StringExtractorGDBRemote &packet) { 1384 // Fail if we don't have a current process. 1385 if (!m_current_process || 1386 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1387 return SendErrorResponse(68); 1388 1389 lldb::pid_t pid = m_current_process->GetID(); 1390 1391 if (pid == LLDB_INVALID_PROCESS_ID) 1392 return SendErrorResponse(1); 1393 1394 ProcessInstanceInfo proc_info; 1395 if (!Host::GetProcessInfo(pid, proc_info)) 1396 return SendErrorResponse(1); 1397 1398 StreamString response; 1399 CreateProcessInfoResponse_DebugServerStyle(proc_info, response); 1400 return SendPacketNoLock(response.GetString()); 1401 } 1402 1403 GDBRemoteCommunication::PacketResult 1404 GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) { 1405 // Fail if we don't have a current process. 1406 if (!m_current_process || 1407 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1408 return SendErrorResponse(68); 1409 1410 // Make sure we set the current thread so g and p packets return the data the 1411 // gdb will expect. 1412 lldb::tid_t tid = m_current_process->GetCurrentThreadID(); 1413 SetCurrentThreadID(tid); 1414 1415 NativeThreadProtocol *thread = m_current_process->GetCurrentThread(); 1416 if (!thread) 1417 return SendErrorResponse(69); 1418 1419 StreamString response; 1420 response.PutCString("QC"); 1421 AppendThreadIDToResponse(response, m_current_process->GetID(), 1422 thread->GetID()); 1423 1424 return SendPacketNoLock(response.GetString()); 1425 } 1426 1427 GDBRemoteCommunication::PacketResult 1428 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) { 1429 Log *log = GetLog(LLDBLog::Process); 1430 1431 if (!m_non_stop) 1432 StopSTDIOForwarding(); 1433 1434 if (m_debugged_processes.empty()) { 1435 LLDB_LOG(log, "No debugged process found."); 1436 return PacketResult::Success; 1437 } 1438 1439 for (auto it = m_debugged_processes.begin(); it != m_debugged_processes.end(); 1440 ++it) { 1441 LLDB_LOG(log, "Killing process {0}", it->first); 1442 Status error = it->second.process_up->Kill(); 1443 if (error.Fail()) 1444 LLDB_LOG(log, "Failed to kill debugged process {0}: {1}", it->first, 1445 error); 1446 } 1447 1448 // The response to kill packet is undefined per the spec. LLDB 1449 // follows the same rules as for continue packets, i.e. no response 1450 // in all-stop mode, and "OK" in non-stop mode; in both cases this 1451 // is followed by the actual stop reason. 1452 return SendContinueSuccessResponse(); 1453 } 1454 1455 GDBRemoteCommunication::PacketResult 1456 GDBRemoteCommunicationServerLLGS::Handle_vKill( 1457 StringExtractorGDBRemote &packet) { 1458 if (!m_non_stop) 1459 StopSTDIOForwarding(); 1460 1461 packet.SetFilePos(6); // vKill; 1462 uint32_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 1463 if (pid == LLDB_INVALID_PROCESS_ID) 1464 return SendIllFormedResponse(packet, 1465 "vKill failed to parse the process id"); 1466 1467 auto it = m_debugged_processes.find(pid); 1468 if (it == m_debugged_processes.end()) 1469 return SendErrorResponse(42); 1470 1471 Status error = it->second.process_up->Kill(); 1472 if (error.Fail()) 1473 return SendErrorResponse(error.ToError()); 1474 1475 // OK response is sent when the process dies. 1476 it->second.flags |= DebuggedProcess::Flag::vkilled; 1477 return PacketResult::Success; 1478 } 1479 1480 GDBRemoteCommunication::PacketResult 1481 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR( 1482 StringExtractorGDBRemote &packet) { 1483 packet.SetFilePos(::strlen("QSetDisableASLR:")); 1484 if (packet.GetU32(0)) 1485 m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR); 1486 else 1487 m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR); 1488 return SendOKResponse(); 1489 } 1490 1491 GDBRemoteCommunication::PacketResult 1492 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir( 1493 StringExtractorGDBRemote &packet) { 1494 packet.SetFilePos(::strlen("QSetWorkingDir:")); 1495 std::string path; 1496 packet.GetHexByteString(path); 1497 m_process_launch_info.SetWorkingDirectory(FileSpec(path)); 1498 return SendOKResponse(); 1499 } 1500 1501 GDBRemoteCommunication::PacketResult 1502 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir( 1503 StringExtractorGDBRemote &packet) { 1504 FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()}; 1505 if (working_dir) { 1506 StreamString response; 1507 response.PutStringAsRawHex8(working_dir.GetPath().c_str()); 1508 return SendPacketNoLock(response.GetString()); 1509 } 1510 1511 return SendErrorResponse(14); 1512 } 1513 1514 GDBRemoteCommunication::PacketResult 1515 GDBRemoteCommunicationServerLLGS::Handle_QThreadSuffixSupported( 1516 StringExtractorGDBRemote &packet) { 1517 m_thread_suffix_supported = true; 1518 return SendOKResponse(); 1519 } 1520 1521 GDBRemoteCommunication::PacketResult 1522 GDBRemoteCommunicationServerLLGS::Handle_QListThreadsInStopReply( 1523 StringExtractorGDBRemote &packet) { 1524 m_list_threads_in_stop_reply = true; 1525 return SendOKResponse(); 1526 } 1527 1528 GDBRemoteCommunication::PacketResult 1529 GDBRemoteCommunicationServerLLGS::ResumeProcess( 1530 NativeProcessProtocol &process, const ResumeActionList &actions) { 1531 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 1532 1533 // In non-stop protocol mode, the process could be running already. 1534 // We do not support resuming threads independently, so just error out. 1535 if (!process.CanResume()) { 1536 LLDB_LOG(log, "process {0} cannot be resumed (state={1})", process.GetID(), 1537 process.GetState()); 1538 return SendErrorResponse(0x37); 1539 } 1540 1541 Status error = process.Resume(actions); 1542 if (error.Fail()) { 1543 LLDB_LOG(log, "process {0} failed to resume: {1}", process.GetID(), error); 1544 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1545 } 1546 1547 LLDB_LOG(log, "process {0} resumed", process.GetID()); 1548 1549 return PacketResult::Success; 1550 } 1551 1552 GDBRemoteCommunication::PacketResult 1553 GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) { 1554 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 1555 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1556 1557 // Ensure we have a native process. 1558 if (!m_continue_process) { 1559 LLDB_LOGF(log, 1560 "GDBRemoteCommunicationServerLLGS::%s no debugged process " 1561 "shared pointer", 1562 __FUNCTION__); 1563 return SendErrorResponse(0x36); 1564 } 1565 1566 // Pull out the signal number. 1567 packet.SetFilePos(::strlen("C")); 1568 if (packet.GetBytesLeft() < 1) { 1569 // Shouldn't be using a C without a signal. 1570 return SendIllFormedResponse(packet, "C packet specified without signal."); 1571 } 1572 const uint32_t signo = 1573 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 1574 if (signo == std::numeric_limits<uint32_t>::max()) 1575 return SendIllFormedResponse(packet, "failed to parse signal number"); 1576 1577 // Handle optional continue address. 1578 if (packet.GetBytesLeft() > 0) { 1579 // FIXME add continue at address support for $C{signo}[;{continue-address}]. 1580 if (*packet.Peek() == ';') 1581 return SendUnimplementedResponse(packet.GetStringRef().data()); 1582 else 1583 return SendIllFormedResponse( 1584 packet, "unexpected content after $C{signal-number}"); 1585 } 1586 1587 // In non-stop protocol mode, the process could be running already. 1588 // We do not support resuming threads independently, so just error out. 1589 if (!m_continue_process->CanResume()) { 1590 LLDB_LOG(log, "process cannot be resumed (state={0})", 1591 m_continue_process->GetState()); 1592 return SendErrorResponse(0x37); 1593 } 1594 1595 ResumeActionList resume_actions(StateType::eStateRunning, 1596 LLDB_INVALID_SIGNAL_NUMBER); 1597 Status error; 1598 1599 // We have two branches: what to do if a continue thread is specified (in 1600 // which case we target sending the signal to that thread), or when we don't 1601 // have a continue thread set (in which case we send a signal to the 1602 // process). 1603 1604 // TODO discuss with Greg Clayton, make sure this makes sense. 1605 1606 lldb::tid_t signal_tid = GetContinueThreadID(); 1607 if (signal_tid != LLDB_INVALID_THREAD_ID) { 1608 // The resume action for the continue thread (or all threads if a continue 1609 // thread is not set). 1610 ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning, 1611 static_cast<int>(signo)}; 1612 1613 // Add the action for the continue thread (or all threads when the continue 1614 // thread isn't present). 1615 resume_actions.Append(action); 1616 } else { 1617 // Send the signal to the process since we weren't targeting a specific 1618 // continue thread with the signal. 1619 error = m_continue_process->Signal(signo); 1620 if (error.Fail()) { 1621 LLDB_LOG(log, "failed to send signal for process {0}: {1}", 1622 m_continue_process->GetID(), error); 1623 1624 return SendErrorResponse(0x52); 1625 } 1626 } 1627 1628 // NB: this checks CanResume() twice but using a single code path for 1629 // resuming still seems worth it. 1630 PacketResult resume_res = ResumeProcess(*m_continue_process, resume_actions); 1631 if (resume_res != PacketResult::Success) 1632 return resume_res; 1633 1634 // Don't send an "OK" packet, except in non-stop mode; 1635 // otherwise, the response is the stopped/exited message. 1636 return SendContinueSuccessResponse(); 1637 } 1638 1639 GDBRemoteCommunication::PacketResult 1640 GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) { 1641 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 1642 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1643 1644 packet.SetFilePos(packet.GetFilePos() + ::strlen("c")); 1645 1646 // For now just support all continue. 1647 const bool has_continue_address = (packet.GetBytesLeft() > 0); 1648 if (has_continue_address) { 1649 LLDB_LOG(log, "not implemented for c[address] variant [{0} remains]", 1650 packet.Peek()); 1651 return SendUnimplementedResponse(packet.GetStringRef().data()); 1652 } 1653 1654 // Ensure we have a native process. 1655 if (!m_continue_process) { 1656 LLDB_LOGF(log, 1657 "GDBRemoteCommunicationServerLLGS::%s no debugged process " 1658 "shared pointer", 1659 __FUNCTION__); 1660 return SendErrorResponse(0x36); 1661 } 1662 1663 // Build the ResumeActionList 1664 ResumeActionList actions(StateType::eStateRunning, 1665 LLDB_INVALID_SIGNAL_NUMBER); 1666 1667 PacketResult resume_res = ResumeProcess(*m_continue_process, actions); 1668 if (resume_res != PacketResult::Success) 1669 return resume_res; 1670 1671 return SendContinueSuccessResponse(); 1672 } 1673 1674 GDBRemoteCommunication::PacketResult 1675 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions( 1676 StringExtractorGDBRemote &packet) { 1677 StreamString response; 1678 response.Printf("vCont;c;C;s;S;t"); 1679 1680 return SendPacketNoLock(response.GetString()); 1681 } 1682 1683 static bool ResumeActionListStopsAllThreads(ResumeActionList &actions) { 1684 // We're doing a stop-all if and only if our only action is a "t" for all 1685 // threads. 1686 if (const ResumeAction *default_action = 1687 actions.GetActionForThread(LLDB_INVALID_THREAD_ID, false)) { 1688 if (default_action->state == eStateSuspended && actions.GetSize() == 1) 1689 return true; 1690 } 1691 1692 return false; 1693 } 1694 1695 GDBRemoteCommunication::PacketResult 1696 GDBRemoteCommunicationServerLLGS::Handle_vCont( 1697 StringExtractorGDBRemote &packet) { 1698 Log *log = GetLog(LLDBLog::Process); 1699 LLDB_LOGF(log, "GDBRemoteCommunicationServerLLGS::%s handling vCont packet", 1700 __FUNCTION__); 1701 1702 packet.SetFilePos(::strlen("vCont")); 1703 1704 if (packet.GetBytesLeft() == 0) { 1705 LLDB_LOGF(log, 1706 "GDBRemoteCommunicationServerLLGS::%s missing action from " 1707 "vCont package", 1708 __FUNCTION__); 1709 return SendIllFormedResponse(packet, "Missing action from vCont package"); 1710 } 1711 1712 if (::strcmp(packet.Peek(), ";s") == 0) { 1713 // Move past the ';', then do a simple 's'. 1714 packet.SetFilePos(packet.GetFilePos() + 1); 1715 return Handle_s(packet); 1716 } 1717 1718 std::unordered_map<lldb::pid_t, ResumeActionList> thread_actions; 1719 1720 while (packet.GetBytesLeft() && *packet.Peek() == ';') { 1721 // Skip the semi-colon. 1722 packet.GetChar(); 1723 1724 // Build up the thread action. 1725 ResumeAction thread_action; 1726 thread_action.tid = LLDB_INVALID_THREAD_ID; 1727 thread_action.state = eStateInvalid; 1728 thread_action.signal = LLDB_INVALID_SIGNAL_NUMBER; 1729 1730 const char action = packet.GetChar(); 1731 switch (action) { 1732 case 'C': 1733 thread_action.signal = packet.GetHexMaxU32(false, 0); 1734 if (thread_action.signal == 0) 1735 return SendIllFormedResponse( 1736 packet, "Could not parse signal in vCont packet C action"); 1737 [[fallthrough]]; 1738 1739 case 'c': 1740 // Continue 1741 thread_action.state = eStateRunning; 1742 break; 1743 1744 case 'S': 1745 thread_action.signal = packet.GetHexMaxU32(false, 0); 1746 if (thread_action.signal == 0) 1747 return SendIllFormedResponse( 1748 packet, "Could not parse signal in vCont packet S action"); 1749 [[fallthrough]]; 1750 1751 case 's': 1752 // Step 1753 thread_action.state = eStateStepping; 1754 break; 1755 1756 case 't': 1757 // Stop 1758 thread_action.state = eStateSuspended; 1759 break; 1760 1761 default: 1762 return SendIllFormedResponse(packet, "Unsupported vCont action"); 1763 break; 1764 } 1765 1766 // If there's no thread-id (e.g. "vCont;c"), it's "p-1.-1". 1767 lldb::pid_t pid = StringExtractorGDBRemote::AllProcesses; 1768 lldb::tid_t tid = StringExtractorGDBRemote::AllThreads; 1769 1770 // Parse out optional :{thread-id} value. 1771 if (packet.GetBytesLeft() && (*packet.Peek() == ':')) { 1772 // Consume the separator. 1773 packet.GetChar(); 1774 1775 auto pid_tid = packet.GetPidTid(LLDB_INVALID_PROCESS_ID); 1776 if (!pid_tid) 1777 return SendIllFormedResponse(packet, "Malformed thread-id"); 1778 1779 pid = pid_tid->first; 1780 tid = pid_tid->second; 1781 } 1782 1783 if (thread_action.state == eStateSuspended && 1784 tid != StringExtractorGDBRemote::AllThreads) { 1785 return SendIllFormedResponse( 1786 packet, "'t' action not supported for individual threads"); 1787 } 1788 1789 // If we get TID without PID, it's the current process. 1790 if (pid == LLDB_INVALID_PROCESS_ID) { 1791 if (!m_continue_process) { 1792 LLDB_LOG(log, "no process selected via Hc"); 1793 return SendErrorResponse(0x36); 1794 } 1795 pid = m_continue_process->GetID(); 1796 } 1797 1798 assert(pid != LLDB_INVALID_PROCESS_ID); 1799 if (tid == StringExtractorGDBRemote::AllThreads) 1800 tid = LLDB_INVALID_THREAD_ID; 1801 thread_action.tid = tid; 1802 1803 if (pid == StringExtractorGDBRemote::AllProcesses) { 1804 if (tid != LLDB_INVALID_THREAD_ID) 1805 return SendIllFormedResponse( 1806 packet, "vCont: p-1 is not valid with a specific tid"); 1807 for (auto &process_it : m_debugged_processes) 1808 thread_actions[process_it.first].Append(thread_action); 1809 } else 1810 thread_actions[pid].Append(thread_action); 1811 } 1812 1813 assert(thread_actions.size() >= 1); 1814 if (thread_actions.size() > 1 && !m_non_stop) 1815 return SendIllFormedResponse( 1816 packet, 1817 "Resuming multiple processes is supported in non-stop mode only"); 1818 1819 for (std::pair<lldb::pid_t, ResumeActionList> x : thread_actions) { 1820 auto process_it = m_debugged_processes.find(x.first); 1821 if (process_it == m_debugged_processes.end()) { 1822 LLDB_LOG(log, "vCont failed for process {0}: process not debugged", 1823 x.first); 1824 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1825 } 1826 1827 // There are four possible scenarios here. These are: 1828 // 1. vCont on a stopped process that resumes at least one thread. 1829 // In this case, we call Resume(). 1830 // 2. vCont on a stopped process that leaves all threads suspended. 1831 // A no-op. 1832 // 3. vCont on a running process that requests suspending all 1833 // running threads. In this case, we call Interrupt(). 1834 // 4. vCont on a running process that requests suspending a subset 1835 // of running threads or resuming a subset of suspended threads. 1836 // Since we do not support full nonstop mode, this is unsupported 1837 // and we return an error. 1838 1839 assert(process_it->second.process_up); 1840 if (ResumeActionListStopsAllThreads(x.second)) { 1841 if (process_it->second.process_up->IsRunning()) { 1842 assert(m_non_stop); 1843 1844 Status error = process_it->second.process_up->Interrupt(); 1845 if (error.Fail()) { 1846 LLDB_LOG(log, "vCont failed to halt process {0}: {1}", x.first, 1847 error); 1848 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 1849 } 1850 1851 LLDB_LOG(log, "halted process {0}", x.first); 1852 1853 // hack to avoid enabling stdio forwarding after stop 1854 // TODO: remove this when we improve stdio forwarding for nonstop 1855 assert(thread_actions.size() == 1); 1856 return SendOKResponse(); 1857 } 1858 } else { 1859 PacketResult resume_res = 1860 ResumeProcess(*process_it->second.process_up, x.second); 1861 if (resume_res != PacketResult::Success) 1862 return resume_res; 1863 } 1864 } 1865 1866 return SendContinueSuccessResponse(); 1867 } 1868 1869 void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) { 1870 Log *log = GetLog(LLDBLog::Thread); 1871 LLDB_LOG(log, "setting current thread id to {0}", tid); 1872 1873 m_current_tid = tid; 1874 if (m_current_process) 1875 m_current_process->SetCurrentThreadID(m_current_tid); 1876 } 1877 1878 void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) { 1879 Log *log = GetLog(LLDBLog::Thread); 1880 LLDB_LOG(log, "setting continue thread id to {0}", tid); 1881 1882 m_continue_tid = tid; 1883 } 1884 1885 GDBRemoteCommunication::PacketResult 1886 GDBRemoteCommunicationServerLLGS::Handle_stop_reason( 1887 StringExtractorGDBRemote &packet) { 1888 // Handle the $? gdbremote command. 1889 1890 if (m_non_stop) { 1891 // Clear the notification queue first, except for pending exit 1892 // notifications. 1893 llvm::erase_if(m_stop_notification_queue, [](const std::string &x) { 1894 return x.front() != 'W' && x.front() != 'X'; 1895 }); 1896 1897 if (m_current_process) { 1898 // Queue stop reply packets for all active threads. Start with 1899 // the current thread (for clients that don't actually support multiple 1900 // stop reasons). 1901 NativeThreadProtocol *thread = m_current_process->GetCurrentThread(); 1902 if (thread) { 1903 StreamString stop_reply = PrepareStopReplyPacketForThread(*thread); 1904 if (!stop_reply.Empty()) 1905 m_stop_notification_queue.push_back(stop_reply.GetString().str()); 1906 } 1907 EnqueueStopReplyPackets(thread ? thread->GetID() 1908 : LLDB_INVALID_THREAD_ID); 1909 } 1910 1911 // If the notification queue is empty (i.e. everything is running), send OK. 1912 if (m_stop_notification_queue.empty()) 1913 return SendOKResponse(); 1914 1915 // Send the first item from the new notification queue synchronously. 1916 return SendPacketNoLock(m_stop_notification_queue.front()); 1917 } 1918 1919 // If no process, indicate error 1920 if (!m_current_process) 1921 return SendErrorResponse(02); 1922 1923 return SendStopReasonForState(*m_current_process, 1924 m_current_process->GetState(), 1925 /*force_synchronous=*/true); 1926 } 1927 1928 GDBRemoteCommunication::PacketResult 1929 GDBRemoteCommunicationServerLLGS::SendStopReasonForState( 1930 NativeProcessProtocol &process, lldb::StateType process_state, 1931 bool force_synchronous) { 1932 Log *log = GetLog(LLDBLog::Process); 1933 1934 if (m_disabling_non_stop) { 1935 // Check if we are waiting for any more processes to stop. If we are, 1936 // do not send the OK response yet. 1937 for (const auto &it : m_debugged_processes) { 1938 if (it.second.process_up->IsRunning()) 1939 return PacketResult::Success; 1940 } 1941 1942 // If all expected processes were stopped after a QNonStop:0 request, 1943 // send the OK response. 1944 m_disabling_non_stop = false; 1945 return SendOKResponse(); 1946 } 1947 1948 switch (process_state) { 1949 case eStateAttaching: 1950 case eStateLaunching: 1951 case eStateRunning: 1952 case eStateStepping: 1953 case eStateDetached: 1954 // NOTE: gdb protocol doc looks like it should return $OK 1955 // when everything is running (i.e. no stopped result). 1956 return PacketResult::Success; // Ignore 1957 1958 case eStateSuspended: 1959 case eStateStopped: 1960 case eStateCrashed: { 1961 lldb::tid_t tid = process.GetCurrentThreadID(); 1962 // Make sure we set the current thread so g and p packets return the data 1963 // the gdb will expect. 1964 SetCurrentThreadID(tid); 1965 return SendStopReplyPacketForThread(process, tid, force_synchronous); 1966 } 1967 1968 case eStateInvalid: 1969 case eStateUnloaded: 1970 case eStateExited: 1971 return SendWResponse(&process); 1972 1973 default: 1974 LLDB_LOG(log, "pid {0}, current state reporting not handled: {1}", 1975 process.GetID(), process_state); 1976 break; 1977 } 1978 1979 return SendErrorResponse(0); 1980 } 1981 1982 GDBRemoteCommunication::PacketResult 1983 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo( 1984 StringExtractorGDBRemote &packet) { 1985 // Fail if we don't have a current process. 1986 if (!m_current_process || 1987 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 1988 return SendErrorResponse(68); 1989 1990 // Ensure we have a thread. 1991 NativeThreadProtocol *thread = m_current_process->GetThreadAtIndex(0); 1992 if (!thread) 1993 return SendErrorResponse(69); 1994 1995 // Get the register context for the first thread. 1996 NativeRegisterContext ®_context = thread->GetRegisterContext(); 1997 1998 // Parse out the register number from the request. 1999 packet.SetFilePos(strlen("qRegisterInfo")); 2000 const uint32_t reg_index = 2001 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2002 if (reg_index == std::numeric_limits<uint32_t>::max()) 2003 return SendErrorResponse(69); 2004 2005 // Return the end of registers response if we've iterated one past the end of 2006 // the register set. 2007 if (reg_index >= reg_context.GetUserRegisterCount()) 2008 return SendErrorResponse(69); 2009 2010 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2011 if (!reg_info) 2012 return SendErrorResponse(69); 2013 2014 // Build the reginfos response. 2015 StreamGDBRemote response; 2016 2017 response.PutCString("name:"); 2018 response.PutCString(reg_info->name); 2019 response.PutChar(';'); 2020 2021 if (reg_info->alt_name && reg_info->alt_name[0]) { 2022 response.PutCString("alt-name:"); 2023 response.PutCString(reg_info->alt_name); 2024 response.PutChar(';'); 2025 } 2026 2027 response.Printf("bitsize:%" PRIu32 ";", reg_info->byte_size * 8); 2028 2029 if (!reg_context.RegisterOffsetIsDynamic()) 2030 response.Printf("offset:%" PRIu32 ";", reg_info->byte_offset); 2031 2032 llvm::StringRef encoding = GetEncodingNameOrEmpty(*reg_info); 2033 if (!encoding.empty()) 2034 response << "encoding:" << encoding << ';'; 2035 2036 llvm::StringRef format = GetFormatNameOrEmpty(*reg_info); 2037 if (!format.empty()) 2038 response << "format:" << format << ';'; 2039 2040 const char *const register_set_name = 2041 reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index); 2042 if (register_set_name) 2043 response << "set:" << register_set_name << ';'; 2044 2045 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != 2046 LLDB_INVALID_REGNUM) 2047 response.Printf("ehframe:%" PRIu32 ";", 2048 reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 2049 2050 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 2051 response.Printf("dwarf:%" PRIu32 ";", 2052 reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 2053 2054 llvm::StringRef kind_generic = GetKindGenericOrEmpty(*reg_info); 2055 if (!kind_generic.empty()) 2056 response << "generic:" << kind_generic << ';'; 2057 2058 if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) { 2059 response.PutCString("container-regs:"); 2060 CollectRegNums(reg_info->value_regs, response, true); 2061 response.PutChar(';'); 2062 } 2063 2064 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) { 2065 response.PutCString("invalidate-regs:"); 2066 CollectRegNums(reg_info->invalidate_regs, response, true); 2067 response.PutChar(';'); 2068 } 2069 2070 return SendPacketNoLock(response.GetString()); 2071 } 2072 2073 void GDBRemoteCommunicationServerLLGS::AddProcessThreads( 2074 StreamGDBRemote &response, NativeProcessProtocol &process, bool &had_any) { 2075 Log *log = GetLog(LLDBLog::Thread); 2076 2077 lldb::pid_t pid = process.GetID(); 2078 if (pid == LLDB_INVALID_PROCESS_ID) 2079 return; 2080 2081 LLDB_LOG(log, "iterating over threads of process {0}", process.GetID()); 2082 for (NativeThreadProtocol &thread : process.Threads()) { 2083 LLDB_LOG(log, "iterated thread tid={0}", thread.GetID()); 2084 response.PutChar(had_any ? ',' : 'm'); 2085 AppendThreadIDToResponse(response, pid, thread.GetID()); 2086 had_any = true; 2087 } 2088 } 2089 2090 GDBRemoteCommunication::PacketResult 2091 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo( 2092 StringExtractorGDBRemote &packet) { 2093 assert(m_debugged_processes.size() <= 1 || 2094 bool(m_extensions_supported & 2095 NativeProcessProtocol::Extension::multiprocess)); 2096 2097 bool had_any = false; 2098 StreamGDBRemote response; 2099 2100 for (auto &pid_ptr : m_debugged_processes) 2101 AddProcessThreads(response, *pid_ptr.second.process_up, had_any); 2102 2103 if (!had_any) 2104 return SendOKResponse(); 2105 return SendPacketNoLock(response.GetString()); 2106 } 2107 2108 GDBRemoteCommunication::PacketResult 2109 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo( 2110 StringExtractorGDBRemote &packet) { 2111 // FIXME for now we return the full thread list in the initial packet and 2112 // always do nothing here. 2113 return SendPacketNoLock("l"); 2114 } 2115 2116 GDBRemoteCommunication::PacketResult 2117 GDBRemoteCommunicationServerLLGS::Handle_g(StringExtractorGDBRemote &packet) { 2118 Log *log = GetLog(LLDBLog::Thread); 2119 2120 // Move past packet name. 2121 packet.SetFilePos(strlen("g")); 2122 2123 // Get the thread to use. 2124 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2125 if (!thread) { 2126 LLDB_LOG(log, "failed, no thread available"); 2127 return SendErrorResponse(0x15); 2128 } 2129 2130 // Get the thread's register context. 2131 NativeRegisterContext ®_ctx = thread->GetRegisterContext(); 2132 2133 std::vector<uint8_t> regs_buffer; 2134 for (uint32_t reg_num = 0; reg_num < reg_ctx.GetUserRegisterCount(); 2135 ++reg_num) { 2136 const RegisterInfo *reg_info = reg_ctx.GetRegisterInfoAtIndex(reg_num); 2137 2138 if (reg_info == nullptr) { 2139 LLDB_LOG(log, "failed to get register info for register index {0}", 2140 reg_num); 2141 return SendErrorResponse(0x15); 2142 } 2143 2144 if (reg_info->value_regs != nullptr) 2145 continue; // skip registers that are contained in other registers 2146 2147 RegisterValue reg_value; 2148 Status error = reg_ctx.ReadRegister(reg_info, reg_value); 2149 if (error.Fail()) { 2150 LLDB_LOG(log, "failed to read register at index {0}", reg_num); 2151 return SendErrorResponse(0x15); 2152 } 2153 2154 if (reg_info->byte_offset + reg_info->byte_size >= regs_buffer.size()) 2155 // Resize the buffer to guarantee it can store the register offsetted 2156 // data. 2157 regs_buffer.resize(reg_info->byte_offset + reg_info->byte_size); 2158 2159 // Copy the register offsetted data to the buffer. 2160 memcpy(regs_buffer.data() + reg_info->byte_offset, reg_value.GetBytes(), 2161 reg_info->byte_size); 2162 } 2163 2164 // Write the response. 2165 StreamGDBRemote response; 2166 response.PutBytesAsRawHex8(regs_buffer.data(), regs_buffer.size()); 2167 2168 return SendPacketNoLock(response.GetString()); 2169 } 2170 2171 GDBRemoteCommunication::PacketResult 2172 GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) { 2173 Log *log = GetLog(LLDBLog::Thread); 2174 2175 // Parse out the register number from the request. 2176 packet.SetFilePos(strlen("p")); 2177 const uint32_t reg_index = 2178 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2179 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2180 LLDB_LOGF(log, 2181 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 2182 "parse register number from request \"%s\"", 2183 __FUNCTION__, packet.GetStringRef().data()); 2184 return SendErrorResponse(0x15); 2185 } 2186 2187 // Get the thread to use. 2188 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2189 if (!thread) { 2190 LLDB_LOG(log, "failed, no thread available"); 2191 return SendErrorResponse(0x15); 2192 } 2193 2194 // Get the thread's register context. 2195 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2196 2197 // Return the end of registers response if we've iterated one past the end of 2198 // the register set. 2199 if (reg_index >= reg_context.GetUserRegisterCount()) { 2200 LLDB_LOGF(log, 2201 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2202 "register %" PRIu32 " beyond register count %" PRIu32, 2203 __FUNCTION__, reg_index, reg_context.GetUserRegisterCount()); 2204 return SendErrorResponse(0x15); 2205 } 2206 2207 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2208 if (!reg_info) { 2209 LLDB_LOGF(log, 2210 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2211 "register %" PRIu32 " returned NULL", 2212 __FUNCTION__, reg_index); 2213 return SendErrorResponse(0x15); 2214 } 2215 2216 // Build the reginfos response. 2217 StreamGDBRemote response; 2218 2219 // Retrieve the value 2220 RegisterValue reg_value; 2221 Status error = reg_context.ReadRegister(reg_info, reg_value); 2222 if (error.Fail()) { 2223 LLDB_LOGF(log, 2224 "GDBRemoteCommunicationServerLLGS::%s failed, read of " 2225 "requested register %" PRIu32 " (%s) failed: %s", 2226 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2227 return SendErrorResponse(0x15); 2228 } 2229 2230 const uint8_t *const data = 2231 static_cast<const uint8_t *>(reg_value.GetBytes()); 2232 if (!data) { 2233 LLDB_LOGF(log, 2234 "GDBRemoteCommunicationServerLLGS::%s failed to get data " 2235 "bytes from requested register %" PRIu32, 2236 __FUNCTION__, reg_index); 2237 return SendErrorResponse(0x15); 2238 } 2239 2240 // FIXME flip as needed to get data in big/little endian format for this host. 2241 for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i) 2242 response.PutHex8(data[i]); 2243 2244 return SendPacketNoLock(response.GetString()); 2245 } 2246 2247 GDBRemoteCommunication::PacketResult 2248 GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) { 2249 Log *log = GetLog(LLDBLog::Thread); 2250 2251 // Ensure there is more content. 2252 if (packet.GetBytesLeft() < 1) 2253 return SendIllFormedResponse(packet, "Empty P packet"); 2254 2255 // Parse out the register number from the request. 2256 packet.SetFilePos(strlen("P")); 2257 const uint32_t reg_index = 2258 packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max()); 2259 if (reg_index == std::numeric_limits<uint32_t>::max()) { 2260 LLDB_LOGF(log, 2261 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 2262 "parse register number from request \"%s\"", 2263 __FUNCTION__, packet.GetStringRef().data()); 2264 return SendErrorResponse(0x29); 2265 } 2266 2267 // Note debugserver would send an E30 here. 2268 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '=')) 2269 return SendIllFormedResponse( 2270 packet, "P packet missing '=' char after register number"); 2271 2272 // Parse out the value. 2273 size_t reg_size = packet.GetHexBytesAvail(m_reg_bytes); 2274 2275 // Get the thread to use. 2276 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 2277 if (!thread) { 2278 LLDB_LOGF(log, 2279 "GDBRemoteCommunicationServerLLGS::%s failed, no thread " 2280 "available (thread index 0)", 2281 __FUNCTION__); 2282 return SendErrorResponse(0x28); 2283 } 2284 2285 // Get the thread's register context. 2286 NativeRegisterContext ®_context = thread->GetRegisterContext(); 2287 const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index); 2288 if (!reg_info) { 2289 LLDB_LOGF(log, 2290 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2291 "register %" PRIu32 " returned NULL", 2292 __FUNCTION__, reg_index); 2293 return SendErrorResponse(0x48); 2294 } 2295 2296 // Return the end of registers response if we've iterated one past the end of 2297 // the register set. 2298 if (reg_index >= reg_context.GetUserRegisterCount()) { 2299 LLDB_LOGF(log, 2300 "GDBRemoteCommunicationServerLLGS::%s failed, requested " 2301 "register %" PRIu32 " beyond register count %" PRIu32, 2302 __FUNCTION__, reg_index, reg_context.GetUserRegisterCount()); 2303 return SendErrorResponse(0x47); 2304 } 2305 2306 if (reg_size != reg_info->byte_size) 2307 return SendIllFormedResponse(packet, "P packet register size is incorrect"); 2308 2309 // Build the reginfos response. 2310 StreamGDBRemote response; 2311 2312 RegisterValue reg_value(ArrayRef<uint8_t>(m_reg_bytes, reg_size), 2313 m_current_process->GetArchitecture().GetByteOrder()); 2314 Status error = reg_context.WriteRegister(reg_info, reg_value); 2315 if (error.Fail()) { 2316 LLDB_LOGF(log, 2317 "GDBRemoteCommunicationServerLLGS::%s failed, write of " 2318 "requested register %" PRIu32 " (%s) failed: %s", 2319 __FUNCTION__, reg_index, reg_info->name, error.AsCString()); 2320 return SendErrorResponse(0x32); 2321 } 2322 2323 return SendOKResponse(); 2324 } 2325 2326 GDBRemoteCommunication::PacketResult 2327 GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) { 2328 Log *log = GetLog(LLDBLog::Thread); 2329 2330 // Parse out which variant of $H is requested. 2331 packet.SetFilePos(strlen("H")); 2332 if (packet.GetBytesLeft() < 1) { 2333 LLDB_LOGF(log, 2334 "GDBRemoteCommunicationServerLLGS::%s failed, H command " 2335 "missing {g,c} variant", 2336 __FUNCTION__); 2337 return SendIllFormedResponse(packet, "H command missing {g,c} variant"); 2338 } 2339 2340 const char h_variant = packet.GetChar(); 2341 NativeProcessProtocol *default_process; 2342 switch (h_variant) { 2343 case 'g': 2344 default_process = m_current_process; 2345 break; 2346 2347 case 'c': 2348 default_process = m_continue_process; 2349 break; 2350 2351 default: 2352 LLDB_LOGF( 2353 log, 2354 "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c", 2355 __FUNCTION__, h_variant); 2356 return SendIllFormedResponse(packet, 2357 "H variant unsupported, should be c or g"); 2358 } 2359 2360 // Parse out the thread number. 2361 auto pid_tid = packet.GetPidTid(default_process ? default_process->GetID() 2362 : LLDB_INVALID_PROCESS_ID); 2363 if (!pid_tid) 2364 return SendErrorResponse(llvm::make_error<StringError>( 2365 inconvertibleErrorCode(), "Malformed thread-id")); 2366 2367 lldb::pid_t pid = pid_tid->first; 2368 lldb::tid_t tid = pid_tid->second; 2369 2370 if (pid == StringExtractorGDBRemote::AllProcesses) 2371 return SendUnimplementedResponse("Selecting all processes not supported"); 2372 if (pid == LLDB_INVALID_PROCESS_ID) 2373 return SendErrorResponse(llvm::make_error<StringError>( 2374 inconvertibleErrorCode(), "No current process and no PID provided")); 2375 2376 // Check the process ID and find respective process instance. 2377 auto new_process_it = m_debugged_processes.find(pid); 2378 if (new_process_it == m_debugged_processes.end()) 2379 return SendErrorResponse(llvm::make_error<StringError>( 2380 inconvertibleErrorCode(), 2381 llvm::formatv("No process with PID {0} debugged", pid))); 2382 2383 // Ensure we have the given thread when not specifying -1 (all threads) or 0 2384 // (any thread). 2385 if (tid != LLDB_INVALID_THREAD_ID && tid != 0) { 2386 NativeThreadProtocol *thread = 2387 new_process_it->second.process_up->GetThreadByID(tid); 2388 if (!thread) { 2389 LLDB_LOGF(log, 2390 "GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64 2391 " not found", 2392 __FUNCTION__, tid); 2393 return SendErrorResponse(0x15); 2394 } 2395 } 2396 2397 // Now switch the given process and thread type. 2398 switch (h_variant) { 2399 case 'g': 2400 m_current_process = new_process_it->second.process_up.get(); 2401 SetCurrentThreadID(tid); 2402 break; 2403 2404 case 'c': 2405 m_continue_process = new_process_it->second.process_up.get(); 2406 SetContinueThreadID(tid); 2407 break; 2408 2409 default: 2410 assert(false && "unsupported $H variant - shouldn't get here"); 2411 return SendIllFormedResponse(packet, 2412 "H variant unsupported, should be c or g"); 2413 } 2414 2415 return SendOKResponse(); 2416 } 2417 2418 GDBRemoteCommunication::PacketResult 2419 GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) { 2420 Log *log = GetLog(LLDBLog::Thread); 2421 2422 // Fail if we don't have a current process. 2423 if (!m_current_process || 2424 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2425 LLDB_LOGF( 2426 log, 2427 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2428 __FUNCTION__); 2429 return SendErrorResponse(0x15); 2430 } 2431 2432 packet.SetFilePos(::strlen("I")); 2433 uint8_t tmp[4096]; 2434 for (;;) { 2435 size_t read = packet.GetHexBytesAvail(tmp); 2436 if (read == 0) { 2437 break; 2438 } 2439 // write directly to stdin *this might block if stdin buffer is full* 2440 // TODO: enqueue this block in circular buffer and send window size to 2441 // remote host 2442 ConnectionStatus status; 2443 Status error; 2444 m_stdio_communication.WriteAll(tmp, read, status, &error); 2445 if (error.Fail()) { 2446 return SendErrorResponse(0x15); 2447 } 2448 } 2449 2450 return SendOKResponse(); 2451 } 2452 2453 GDBRemoteCommunication::PacketResult 2454 GDBRemoteCommunicationServerLLGS::Handle_interrupt( 2455 StringExtractorGDBRemote &packet) { 2456 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 2457 2458 // Fail if we don't have a current process. 2459 if (!m_current_process || 2460 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2461 LLDB_LOG(log, "failed, no process available"); 2462 return SendErrorResponse(0x15); 2463 } 2464 2465 // Interrupt the process. 2466 Status error = m_current_process->Interrupt(); 2467 if (error.Fail()) { 2468 LLDB_LOG(log, "failed for process {0}: {1}", m_current_process->GetID(), 2469 error); 2470 return SendErrorResponse(GDBRemoteServerError::eErrorResume); 2471 } 2472 2473 LLDB_LOG(log, "stopped process {0}", m_current_process->GetID()); 2474 2475 // No response required from stop all. 2476 return PacketResult::Success; 2477 } 2478 2479 GDBRemoteCommunication::PacketResult 2480 GDBRemoteCommunicationServerLLGS::Handle_memory_read( 2481 StringExtractorGDBRemote &packet) { 2482 Log *log = GetLog(LLDBLog::Process); 2483 2484 if (!m_current_process || 2485 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2486 LLDB_LOGF( 2487 log, 2488 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2489 __FUNCTION__); 2490 return SendErrorResponse(0x15); 2491 } 2492 2493 // Parse out the memory address. 2494 packet.SetFilePos(strlen("m")); 2495 if (packet.GetBytesLeft() < 1) 2496 return SendIllFormedResponse(packet, "Too short m packet"); 2497 2498 // Read the address. Punting on validation. 2499 // FIXME replace with Hex U64 read with no default value that fails on failed 2500 // read. 2501 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2502 2503 // Validate comma. 2504 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2505 return SendIllFormedResponse(packet, "Comma sep missing in m packet"); 2506 2507 // Get # bytes to read. 2508 if (packet.GetBytesLeft() < 1) 2509 return SendIllFormedResponse(packet, "Length missing in m packet"); 2510 2511 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2512 if (byte_count == 0) { 2513 LLDB_LOGF(log, 2514 "GDBRemoteCommunicationServerLLGS::%s nothing to read: " 2515 "zero-length packet", 2516 __FUNCTION__); 2517 return SendOKResponse(); 2518 } 2519 2520 // Allocate the response buffer. 2521 std::string buf(byte_count, '\0'); 2522 if (buf.empty()) 2523 return SendErrorResponse(0x78); 2524 2525 // Retrieve the process memory. 2526 size_t bytes_read = 0; 2527 Status error = m_current_process->ReadMemoryWithoutTrap( 2528 read_addr, &buf[0], byte_count, bytes_read); 2529 LLDB_LOG( 2530 log, 2531 "ReadMemoryWithoutTrap({0}) read {1} of {2} requested bytes (error: {3})", 2532 read_addr, byte_count, bytes_read, error); 2533 if (bytes_read == 0) 2534 return SendErrorResponse(0x08); 2535 2536 StreamGDBRemote response; 2537 packet.SetFilePos(0); 2538 char kind = packet.GetChar('?'); 2539 if (kind == 'x') 2540 response.PutEscapedBytes(buf.data(), bytes_read); 2541 else { 2542 assert(kind == 'm'); 2543 for (size_t i = 0; i < bytes_read; ++i) 2544 response.PutHex8(buf[i]); 2545 } 2546 2547 return SendPacketNoLock(response.GetString()); 2548 } 2549 2550 GDBRemoteCommunication::PacketResult 2551 GDBRemoteCommunicationServerLLGS::Handle__M(StringExtractorGDBRemote &packet) { 2552 Log *log = GetLog(LLDBLog::Process); 2553 2554 if (!m_current_process || 2555 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2556 LLDB_LOGF( 2557 log, 2558 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2559 __FUNCTION__); 2560 return SendErrorResponse(0x15); 2561 } 2562 2563 // Parse out the memory address. 2564 packet.SetFilePos(strlen("_M")); 2565 if (packet.GetBytesLeft() < 1) 2566 return SendIllFormedResponse(packet, "Too short _M packet"); 2567 2568 const lldb::addr_t size = packet.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 2569 if (size == LLDB_INVALID_ADDRESS) 2570 return SendIllFormedResponse(packet, "Address not valid"); 2571 if (packet.GetChar() != ',') 2572 return SendIllFormedResponse(packet, "Bad packet"); 2573 Permissions perms = {}; 2574 while (packet.GetBytesLeft() > 0) { 2575 switch (packet.GetChar()) { 2576 case 'r': 2577 perms |= ePermissionsReadable; 2578 break; 2579 case 'w': 2580 perms |= ePermissionsWritable; 2581 break; 2582 case 'x': 2583 perms |= ePermissionsExecutable; 2584 break; 2585 default: 2586 return SendIllFormedResponse(packet, "Bad permissions"); 2587 } 2588 } 2589 2590 llvm::Expected<addr_t> addr = m_current_process->AllocateMemory(size, perms); 2591 if (!addr) 2592 return SendErrorResponse(addr.takeError()); 2593 2594 StreamGDBRemote response; 2595 response.PutHex64(*addr); 2596 return SendPacketNoLock(response.GetString()); 2597 } 2598 2599 GDBRemoteCommunication::PacketResult 2600 GDBRemoteCommunicationServerLLGS::Handle__m(StringExtractorGDBRemote &packet) { 2601 Log *log = GetLog(LLDBLog::Process); 2602 2603 if (!m_current_process || 2604 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2605 LLDB_LOGF( 2606 log, 2607 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2608 __FUNCTION__); 2609 return SendErrorResponse(0x15); 2610 } 2611 2612 // Parse out the memory address. 2613 packet.SetFilePos(strlen("_m")); 2614 if (packet.GetBytesLeft() < 1) 2615 return SendIllFormedResponse(packet, "Too short m packet"); 2616 2617 const lldb::addr_t addr = packet.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 2618 if (addr == LLDB_INVALID_ADDRESS) 2619 return SendIllFormedResponse(packet, "Address not valid"); 2620 2621 if (llvm::Error Err = m_current_process->DeallocateMemory(addr)) 2622 return SendErrorResponse(std::move(Err)); 2623 2624 return SendOKResponse(); 2625 } 2626 2627 GDBRemoteCommunication::PacketResult 2628 GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) { 2629 Log *log = GetLog(LLDBLog::Process); 2630 2631 if (!m_current_process || 2632 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2633 LLDB_LOGF( 2634 log, 2635 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2636 __FUNCTION__); 2637 return SendErrorResponse(0x15); 2638 } 2639 2640 // Parse out the memory address. 2641 packet.SetFilePos(strlen("M")); 2642 if (packet.GetBytesLeft() < 1) 2643 return SendIllFormedResponse(packet, "Too short M packet"); 2644 2645 // Read the address. Punting on validation. 2646 // FIXME replace with Hex U64 read with no default value that fails on failed 2647 // read. 2648 const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0); 2649 2650 // Validate comma. 2651 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2652 return SendIllFormedResponse(packet, "Comma sep missing in M packet"); 2653 2654 // Get # bytes to read. 2655 if (packet.GetBytesLeft() < 1) 2656 return SendIllFormedResponse(packet, "Length missing in M packet"); 2657 2658 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2659 if (byte_count == 0) { 2660 LLDB_LOG(log, "nothing to write: zero-length packet"); 2661 return PacketResult::Success; 2662 } 2663 2664 // Validate colon. 2665 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':')) 2666 return SendIllFormedResponse( 2667 packet, "Comma sep missing in M packet after byte length"); 2668 2669 // Allocate the conversion buffer. 2670 std::vector<uint8_t> buf(byte_count, 0); 2671 if (buf.empty()) 2672 return SendErrorResponse(0x78); 2673 2674 // Convert the hex memory write contents to bytes. 2675 StreamGDBRemote response; 2676 const uint64_t convert_count = packet.GetHexBytes(buf, 0); 2677 if (convert_count != byte_count) { 2678 LLDB_LOG(log, 2679 "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} " 2680 "to convert.", 2681 m_current_process->GetID(), write_addr, byte_count, convert_count); 2682 return SendIllFormedResponse(packet, "M content byte length specified did " 2683 "not match hex-encoded content " 2684 "length"); 2685 } 2686 2687 // Write the process memory. 2688 size_t bytes_written = 0; 2689 Status error = m_current_process->WriteMemory(write_addr, &buf[0], byte_count, 2690 bytes_written); 2691 if (error.Fail()) { 2692 LLDB_LOG(log, "pid {0} mem {1:x}: failed to write. Error: {2}", 2693 m_current_process->GetID(), write_addr, error); 2694 return SendErrorResponse(0x09); 2695 } 2696 2697 if (bytes_written == 0) { 2698 LLDB_LOG(log, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes", 2699 m_current_process->GetID(), write_addr, byte_count); 2700 return SendErrorResponse(0x09); 2701 } 2702 2703 return SendOKResponse(); 2704 } 2705 2706 GDBRemoteCommunication::PacketResult 2707 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported( 2708 StringExtractorGDBRemote &packet) { 2709 Log *log = GetLog(LLDBLog::Process); 2710 2711 // Currently only the NativeProcessProtocol knows if it can handle a 2712 // qMemoryRegionInfoSupported request, but we're not guaranteed to be 2713 // attached to a process. For now we'll assume the client only asks this 2714 // when a process is being debugged. 2715 2716 // Ensure we have a process running; otherwise, we can't figure this out 2717 // since we won't have a NativeProcessProtocol. 2718 if (!m_current_process || 2719 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2720 LLDB_LOGF( 2721 log, 2722 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2723 __FUNCTION__); 2724 return SendErrorResponse(0x15); 2725 } 2726 2727 // Test if we can get any region back when asking for the region around NULL. 2728 MemoryRegionInfo region_info; 2729 const Status error = m_current_process->GetMemoryRegionInfo(0, region_info); 2730 if (error.Fail()) { 2731 // We don't support memory region info collection for this 2732 // NativeProcessProtocol. 2733 return SendUnimplementedResponse(""); 2734 } 2735 2736 return SendOKResponse(); 2737 } 2738 2739 GDBRemoteCommunication::PacketResult 2740 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo( 2741 StringExtractorGDBRemote &packet) { 2742 Log *log = GetLog(LLDBLog::Process); 2743 2744 // Ensure we have a process. 2745 if (!m_current_process || 2746 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 2747 LLDB_LOGF( 2748 log, 2749 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 2750 __FUNCTION__); 2751 return SendErrorResponse(0x15); 2752 } 2753 2754 // Parse out the memory address. 2755 packet.SetFilePos(strlen("qMemoryRegionInfo:")); 2756 if (packet.GetBytesLeft() < 1) 2757 return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet"); 2758 2759 // Read the address. Punting on validation. 2760 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2761 2762 StreamGDBRemote response; 2763 2764 // Get the memory region info for the target address. 2765 MemoryRegionInfo region_info; 2766 const Status error = 2767 m_current_process->GetMemoryRegionInfo(read_addr, region_info); 2768 if (error.Fail()) { 2769 // Return the error message. 2770 2771 response.PutCString("error:"); 2772 response.PutStringAsRawHex8(error.AsCString()); 2773 response.PutChar(';'); 2774 } else { 2775 // Range start and size. 2776 response.Printf("start:%" PRIx64 ";size:%" PRIx64 ";", 2777 region_info.GetRange().GetRangeBase(), 2778 region_info.GetRange().GetByteSize()); 2779 2780 // Permissions. 2781 if (region_info.GetReadable() || region_info.GetWritable() || 2782 region_info.GetExecutable()) { 2783 // Write permissions info. 2784 response.PutCString("permissions:"); 2785 2786 if (region_info.GetReadable()) 2787 response.PutChar('r'); 2788 if (region_info.GetWritable()) 2789 response.PutChar('w'); 2790 if (region_info.GetExecutable()) 2791 response.PutChar('x'); 2792 2793 response.PutChar(';'); 2794 } 2795 2796 // Flags 2797 MemoryRegionInfo::OptionalBool memory_tagged = 2798 region_info.GetMemoryTagged(); 2799 MemoryRegionInfo::OptionalBool is_shadow_stack = 2800 region_info.IsShadowStack(); 2801 2802 if (memory_tagged != MemoryRegionInfo::eDontKnow || 2803 is_shadow_stack != MemoryRegionInfo::eDontKnow) { 2804 response.PutCString("flags:"); 2805 // Space is the separator. 2806 if (memory_tagged == MemoryRegionInfo::eYes) 2807 response.PutCString("mt "); 2808 if (is_shadow_stack == MemoryRegionInfo::eYes) 2809 response.PutCString("ss "); 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 2826 GDBRemoteCommunication::PacketResult 2827 GDBRemoteCommunicationServerLLGS::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 2920 GDBRemoteCommunication::PacketResult 2921 GDBRemoteCommunicationServerLLGS::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 3007 GDBRemoteCommunication::PacketResult 3008 GDBRemoteCommunicationServerLLGS::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 3054 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> 3055 GDBRemoteCommunicationServerLLGS::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 llvm::StringSet<> field_enums_seen; 3087 for (int reg_index = 0; reg_index < registers_count; reg_index++) { 3088 const RegisterInfo *reg_info = 3089 reg_context.GetRegisterInfoAtIndex(reg_index); 3090 3091 if (!reg_info) { 3092 LLDB_LOGF(log, 3093 "%s failed to get register info for register index %" PRIu32, 3094 "target.xml", reg_index); 3095 continue; 3096 } 3097 3098 if (reg_info->flags_type) { 3099 response.IndentMore(); 3100 reg_info->flags_type->EnumsToXML(response, field_enums_seen); 3101 reg_info->flags_type->ToXML(response); 3102 response.IndentLess(); 3103 } 3104 3105 response.Indent(); 3106 response.Printf("<reg name=\"%s\" bitsize=\"%" PRIu32 3107 "\" regnum=\"%d\" ", 3108 reg_info->name, reg_info->byte_size * 8, reg_index); 3109 3110 if (!reg_context.RegisterOffsetIsDynamic()) 3111 response.Printf("offset=\"%" PRIu32 "\" ", reg_info->byte_offset); 3112 3113 if (reg_info->alt_name && reg_info->alt_name[0]) 3114 response.Printf("altname=\"%s\" ", reg_info->alt_name); 3115 3116 llvm::StringRef encoding = GetEncodingNameOrEmpty(*reg_info); 3117 if (!encoding.empty()) 3118 response << "encoding=\"" << encoding << "\" "; 3119 3120 llvm::StringRef format = GetFormatNameOrEmpty(*reg_info); 3121 if (!format.empty()) 3122 response << "format=\"" << format << "\" "; 3123 3124 if (reg_info->flags_type) 3125 response << "type=\"" << reg_info->flags_type->GetID() << "\" "; 3126 3127 const char *const register_set_name = 3128 reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index); 3129 if (register_set_name) 3130 response << "group=\"" << register_set_name << "\" "; 3131 3132 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != 3133 LLDB_INVALID_REGNUM) 3134 response.Printf("ehframe_regnum=\"%" PRIu32 "\" ", 3135 reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 3136 3137 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != 3138 LLDB_INVALID_REGNUM) 3139 response.Printf("dwarf_regnum=\"%" PRIu32 "\" ", 3140 reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 3141 3142 llvm::StringRef kind_generic = GetKindGenericOrEmpty(*reg_info); 3143 if (!kind_generic.empty()) 3144 response << "generic=\"" << kind_generic << "\" "; 3145 3146 if (reg_info->value_regs && 3147 reg_info->value_regs[0] != LLDB_INVALID_REGNUM) { 3148 response.PutCString("value_regnums=\""); 3149 CollectRegNums(reg_info->value_regs, response, false); 3150 response.Printf("\" "); 3151 } 3152 3153 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) { 3154 response.PutCString("invalidate_regnums=\""); 3155 CollectRegNums(reg_info->invalidate_regs, response, false); 3156 response.Printf("\" "); 3157 } 3158 3159 response.Printf("/>\n"); 3160 } 3161 3162 if (registers_count) 3163 response.IndentLess(); 3164 3165 response.Indent("</feature>\n"); 3166 response.IndentLess(); 3167 response.Indent("</target>\n"); 3168 return MemoryBuffer::getMemBufferCopy(response.GetString(), "target.xml"); 3169 } 3170 3171 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> 3172 GDBRemoteCommunicationServerLLGS::ReadXferObject(llvm::StringRef object, 3173 llvm::StringRef annex) { 3174 // Make sure we have a valid process. 3175 if (!m_current_process || 3176 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3177 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3178 "No process available"); 3179 } 3180 3181 if (object == "auxv") { 3182 // Grab the auxv data. 3183 auto buffer_or_error = m_current_process->GetAuxvData(); 3184 if (!buffer_or_error) 3185 return llvm::errorCodeToError(buffer_or_error.getError()); 3186 return std::move(*buffer_or_error); 3187 } 3188 3189 if (object == "siginfo") { 3190 NativeThreadProtocol *thread = m_current_process->GetCurrentThread(); 3191 if (!thread) 3192 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3193 "no current thread"); 3194 3195 auto buffer_or_error = thread->GetSiginfo(); 3196 if (!buffer_or_error) 3197 return buffer_or_error.takeError(); 3198 return std::move(*buffer_or_error); 3199 } 3200 3201 if (object == "libraries-svr4") { 3202 auto library_list = m_current_process->GetLoadedSVR4Libraries(); 3203 if (!library_list) 3204 return library_list.takeError(); 3205 3206 StreamString response; 3207 response.Printf("<library-list-svr4 version=\"1.0\">"); 3208 for (auto const &library : *library_list) { 3209 response.Printf("<library name=\"%s\" ", 3210 XMLEncodeAttributeValue(library.name.c_str()).c_str()); 3211 response.Printf("lm=\"0x%" PRIx64 "\" ", library.link_map); 3212 response.Printf("l_addr=\"0x%" PRIx64 "\" ", library.base_addr); 3213 response.Printf("l_ld=\"0x%" PRIx64 "\" />", library.ld_addr); 3214 } 3215 response.Printf("</library-list-svr4>"); 3216 return MemoryBuffer::getMemBufferCopy(response.GetString(), __FUNCTION__); 3217 } 3218 3219 if (object == "features" && annex == "target.xml") 3220 return BuildTargetXml(); 3221 3222 return llvm::make_error<UnimplementedError>(); 3223 } 3224 3225 GDBRemoteCommunication::PacketResult 3226 GDBRemoteCommunicationServerLLGS::Handle_qXfer( 3227 StringExtractorGDBRemote &packet) { 3228 SmallVector<StringRef, 5> fields; 3229 // The packet format is "qXfer:<object>:<action>:<annex>:offset,length" 3230 StringRef(packet.GetStringRef()).split(fields, ':', 4); 3231 if (fields.size() != 5) 3232 return SendIllFormedResponse(packet, "malformed qXfer packet"); 3233 StringRef &xfer_object = fields[1]; 3234 StringRef &xfer_action = fields[2]; 3235 StringRef &xfer_annex = fields[3]; 3236 StringExtractor offset_data(fields[4]); 3237 if (xfer_action != "read") 3238 return SendUnimplementedResponse("qXfer action not supported"); 3239 // Parse offset. 3240 const uint64_t xfer_offset = 3241 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 3242 if (xfer_offset == std::numeric_limits<uint64_t>::max()) 3243 return SendIllFormedResponse(packet, "qXfer packet missing offset"); 3244 // Parse out comma. 3245 if (offset_data.GetChar() != ',') 3246 return SendIllFormedResponse(packet, 3247 "qXfer packet missing comma after offset"); 3248 // Parse out the length. 3249 const uint64_t xfer_length = 3250 offset_data.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max()); 3251 if (xfer_length == std::numeric_limits<uint64_t>::max()) 3252 return SendIllFormedResponse(packet, "qXfer packet missing length"); 3253 3254 // Get a previously constructed buffer if it exists or create it now. 3255 std::string buffer_key = (xfer_object + xfer_action + xfer_annex).str(); 3256 auto buffer_it = m_xfer_buffer_map.find(buffer_key); 3257 if (buffer_it == m_xfer_buffer_map.end()) { 3258 auto buffer_up = ReadXferObject(xfer_object, xfer_annex); 3259 if (!buffer_up) 3260 return SendErrorResponse(buffer_up.takeError()); 3261 buffer_it = m_xfer_buffer_map 3262 .insert(std::make_pair(buffer_key, std::move(*buffer_up))) 3263 .first; 3264 } 3265 3266 // Send back the response 3267 StreamGDBRemote response; 3268 bool done_with_buffer = false; 3269 llvm::StringRef buffer = buffer_it->second->getBuffer(); 3270 if (xfer_offset >= buffer.size()) { 3271 // We have nothing left to send. Mark the buffer as complete. 3272 response.PutChar('l'); 3273 done_with_buffer = true; 3274 } else { 3275 // Figure out how many bytes are available starting at the given offset. 3276 buffer = buffer.drop_front(xfer_offset); 3277 // Mark the response type according to whether we're reading the remainder 3278 // of the data. 3279 if (xfer_length >= buffer.size()) { 3280 // There will be nothing left to read after this 3281 response.PutChar('l'); 3282 done_with_buffer = true; 3283 } else { 3284 // There will still be bytes to read after this request. 3285 response.PutChar('m'); 3286 buffer = buffer.take_front(xfer_length); 3287 } 3288 // Now write the data in encoded binary form. 3289 response.PutEscapedBytes(buffer.data(), buffer.size()); 3290 } 3291 3292 if (done_with_buffer) 3293 m_xfer_buffer_map.erase(buffer_it); 3294 3295 return SendPacketNoLock(response.GetString()); 3296 } 3297 3298 GDBRemoteCommunication::PacketResult 3299 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( 3300 StringExtractorGDBRemote &packet) { 3301 Log *log = GetLog(LLDBLog::Thread); 3302 3303 // Move past packet name. 3304 packet.SetFilePos(strlen("QSaveRegisterState")); 3305 3306 // Get the thread to use. 3307 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 3308 if (!thread) { 3309 if (m_thread_suffix_supported) 3310 return SendIllFormedResponse( 3311 packet, "No thread specified in QSaveRegisterState packet"); 3312 else 3313 return SendIllFormedResponse(packet, 3314 "No thread was is set with the Hg packet"); 3315 } 3316 3317 // Grab the register context for the thread. 3318 NativeRegisterContext& reg_context = thread->GetRegisterContext(); 3319 3320 // Save registers to a buffer. 3321 WritableDataBufferSP register_data_sp; 3322 Status error = reg_context.ReadAllRegisterValues(register_data_sp); 3323 if (error.Fail()) { 3324 LLDB_LOG(log, "pid {0} failed to save all register values: {1}", 3325 m_current_process->GetID(), error); 3326 return SendErrorResponse(0x75); 3327 } 3328 3329 // Allocate a new save id. 3330 const uint32_t save_id = GetNextSavedRegistersID(); 3331 assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && 3332 "GetNextRegisterSaveID() returned an existing register save id"); 3333 3334 // Save the register data buffer under the save id. 3335 { 3336 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3337 m_saved_registers_map[save_id] = register_data_sp; 3338 } 3339 3340 // Write the response. 3341 StreamGDBRemote response; 3342 response.Printf("%" PRIu32, save_id); 3343 return SendPacketNoLock(response.GetString()); 3344 } 3345 3346 GDBRemoteCommunication::PacketResult 3347 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( 3348 StringExtractorGDBRemote &packet) { 3349 Log *log = GetLog(LLDBLog::Thread); 3350 3351 // Parse out save id. 3352 packet.SetFilePos(strlen("QRestoreRegisterState:")); 3353 if (packet.GetBytesLeft() < 1) 3354 return SendIllFormedResponse( 3355 packet, "QRestoreRegisterState packet missing register save id"); 3356 3357 const uint32_t save_id = packet.GetU32(0); 3358 if (save_id == 0) { 3359 LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, " 3360 "expecting decimal uint32_t"); 3361 return SendErrorResponse(0x76); 3362 } 3363 3364 // Get the thread to use. 3365 NativeThreadProtocol *thread = GetThreadFromSuffix(packet); 3366 if (!thread) { 3367 if (m_thread_suffix_supported) 3368 return SendIllFormedResponse( 3369 packet, "No thread specified in QRestoreRegisterState packet"); 3370 else 3371 return SendIllFormedResponse(packet, 3372 "No thread was is set with the Hg packet"); 3373 } 3374 3375 // Grab the register context for the thread. 3376 NativeRegisterContext ®_context = thread->GetRegisterContext(); 3377 3378 // Retrieve register state buffer, then remove from the list. 3379 DataBufferSP register_data_sp; 3380 { 3381 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 3382 3383 // Find the register set buffer for the given save id. 3384 auto it = m_saved_registers_map.find(save_id); 3385 if (it == m_saved_registers_map.end()) { 3386 LLDB_LOG(log, 3387 "pid {0} does not have a register set save buffer for id {1}", 3388 m_current_process->GetID(), save_id); 3389 return SendErrorResponse(0x77); 3390 } 3391 register_data_sp = it->second; 3392 3393 // Remove it from the map. 3394 m_saved_registers_map.erase(it); 3395 } 3396 3397 Status error = reg_context.WriteAllRegisterValues(register_data_sp); 3398 if (error.Fail()) { 3399 LLDB_LOG(log, "pid {0} failed to restore all register values: {1}", 3400 m_current_process->GetID(), error); 3401 return SendErrorResponse(0x77); 3402 } 3403 3404 return SendOKResponse(); 3405 } 3406 3407 GDBRemoteCommunication::PacketResult 3408 GDBRemoteCommunicationServerLLGS::Handle_vAttach( 3409 StringExtractorGDBRemote &packet) { 3410 Log *log = GetLog(LLDBLog::Process); 3411 3412 // Consume the ';' after vAttach. 3413 packet.SetFilePos(strlen("vAttach")); 3414 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3415 return SendIllFormedResponse(packet, "vAttach missing expected ';'"); 3416 3417 // Grab the PID to which we will attach (assume hex encoding). 3418 lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3419 if (pid == LLDB_INVALID_PROCESS_ID) 3420 return SendIllFormedResponse(packet, 3421 "vAttach failed to parse the process id"); 3422 3423 // Attempt to attach. 3424 LLDB_LOGF(log, 3425 "GDBRemoteCommunicationServerLLGS::%s attempting to attach to " 3426 "pid %" PRIu64, 3427 __FUNCTION__, pid); 3428 3429 Status error = AttachToProcess(pid); 3430 3431 if (error.Fail()) { 3432 LLDB_LOGF(log, 3433 "GDBRemoteCommunicationServerLLGS::%s failed to attach to " 3434 "pid %" PRIu64 ": %s\n", 3435 __FUNCTION__, pid, error.AsCString()); 3436 return SendErrorResponse(error); 3437 } 3438 3439 // Notify we attached by sending a stop packet. 3440 assert(m_current_process); 3441 return SendStopReasonForState(*m_current_process, 3442 m_current_process->GetState(), 3443 /*force_synchronous=*/false); 3444 } 3445 3446 GDBRemoteCommunication::PacketResult 3447 GDBRemoteCommunicationServerLLGS::Handle_vAttachWait( 3448 StringExtractorGDBRemote &packet) { 3449 Log *log = GetLog(LLDBLog::Process); 3450 3451 // Consume the ';' after the identifier. 3452 packet.SetFilePos(strlen("vAttachWait")); 3453 3454 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3455 return SendIllFormedResponse(packet, "vAttachWait missing expected ';'"); 3456 3457 // Allocate the buffer for the process name from vAttachWait. 3458 std::string process_name; 3459 if (!packet.GetHexByteString(process_name)) 3460 return SendIllFormedResponse(packet, 3461 "vAttachWait failed to parse process name"); 3462 3463 LLDB_LOG(log, "attempting to attach to process named '{0}'", process_name); 3464 3465 Status error = AttachWaitProcess(process_name, false); 3466 if (error.Fail()) { 3467 LLDB_LOG(log, "failed to attach to process named '{0}': {1}", process_name, 3468 error); 3469 return SendErrorResponse(error); 3470 } 3471 3472 // Notify we attached by sending a stop packet. 3473 assert(m_current_process); 3474 return SendStopReasonForState(*m_current_process, 3475 m_current_process->GetState(), 3476 /*force_synchronous=*/false); 3477 } 3478 3479 GDBRemoteCommunication::PacketResult 3480 GDBRemoteCommunicationServerLLGS::Handle_qVAttachOrWaitSupported( 3481 StringExtractorGDBRemote &packet) { 3482 return SendOKResponse(); 3483 } 3484 3485 GDBRemoteCommunication::PacketResult 3486 GDBRemoteCommunicationServerLLGS::Handle_vAttachOrWait( 3487 StringExtractorGDBRemote &packet) { 3488 Log *log = GetLog(LLDBLog::Process); 3489 3490 // Consume the ';' after the identifier. 3491 packet.SetFilePos(strlen("vAttachOrWait")); 3492 3493 if (!packet.GetBytesLeft() || packet.GetChar() != ';') 3494 return SendIllFormedResponse(packet, "vAttachOrWait missing expected ';'"); 3495 3496 // Allocate the buffer for the process name from vAttachWait. 3497 std::string process_name; 3498 if (!packet.GetHexByteString(process_name)) 3499 return SendIllFormedResponse(packet, 3500 "vAttachOrWait failed to parse process name"); 3501 3502 LLDB_LOG(log, "attempting to attach to process named '{0}'", process_name); 3503 3504 Status error = AttachWaitProcess(process_name, true); 3505 if (error.Fail()) { 3506 LLDB_LOG(log, "failed to attach to process named '{0}': {1}", process_name, 3507 error); 3508 return SendErrorResponse(error); 3509 } 3510 3511 // Notify we attached by sending a stop packet. 3512 assert(m_current_process); 3513 return SendStopReasonForState(*m_current_process, 3514 m_current_process->GetState(), 3515 /*force_synchronous=*/false); 3516 } 3517 3518 GDBRemoteCommunication::PacketResult 3519 GDBRemoteCommunicationServerLLGS::Handle_vRun( 3520 StringExtractorGDBRemote &packet) { 3521 Log *log = GetLog(LLDBLog::Process); 3522 3523 llvm::StringRef s = packet.GetStringRef(); 3524 if (!s.consume_front("vRun;")) 3525 return SendErrorResponse(8); 3526 3527 llvm::SmallVector<llvm::StringRef, 16> argv; 3528 s.split(argv, ';'); 3529 3530 for (llvm::StringRef hex_arg : argv) { 3531 StringExtractor arg_ext{hex_arg}; 3532 std::string arg; 3533 arg_ext.GetHexByteString(arg); 3534 m_process_launch_info.GetArguments().AppendArgument(arg); 3535 LLDB_LOGF(log, "LLGSPacketHandler::%s added arg: \"%s\"", __FUNCTION__, 3536 arg.c_str()); 3537 } 3538 3539 if (argv.empty()) 3540 return SendErrorResponse(Status::FromErrorString("No arguments")); 3541 m_process_launch_info.GetExecutableFile().SetFile( 3542 m_process_launch_info.GetArguments()[0].ref(), FileSpec::Style::native); 3543 m_process_launch_error = LaunchProcess(); 3544 if (m_process_launch_error.Fail()) 3545 return SendErrorResponse(m_process_launch_error); 3546 assert(m_current_process); 3547 return SendStopReasonForState(*m_current_process, 3548 m_current_process->GetState(), 3549 /*force_synchronous=*/true); 3550 } 3551 3552 GDBRemoteCommunication::PacketResult 3553 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) { 3554 Log *log = GetLog(LLDBLog::Process); 3555 if (!m_non_stop) 3556 StopSTDIOForwarding(); 3557 3558 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 3559 3560 // Consume the ';' after D. 3561 packet.SetFilePos(1); 3562 if (packet.GetBytesLeft()) { 3563 if (packet.GetChar() != ';') 3564 return SendIllFormedResponse(packet, "D missing expected ';'"); 3565 3566 // Grab the PID from which we will detach (assume hex encoding). 3567 pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16); 3568 if (pid == LLDB_INVALID_PROCESS_ID) 3569 return SendIllFormedResponse(packet, "D failed to parse the process id"); 3570 } 3571 3572 // Detach forked children if their PID was specified *or* no PID was requested 3573 // (i.e. detach-all packet). 3574 llvm::Error detach_error = llvm::Error::success(); 3575 bool detached = false; 3576 for (auto it = m_debugged_processes.begin(); 3577 it != m_debugged_processes.end();) { 3578 if (pid == LLDB_INVALID_PROCESS_ID || pid == it->first) { 3579 LLDB_LOGF(log, 3580 "GDBRemoteCommunicationServerLLGS::%s detaching %" PRId64, 3581 __FUNCTION__, it->first); 3582 if (llvm::Error e = it->second.process_up->Detach().ToError()) 3583 detach_error = llvm::joinErrors(std::move(detach_error), std::move(e)); 3584 else { 3585 if (it->second.process_up.get() == m_current_process) 3586 m_current_process = nullptr; 3587 if (it->second.process_up.get() == m_continue_process) 3588 m_continue_process = nullptr; 3589 it = m_debugged_processes.erase(it); 3590 detached = true; 3591 continue; 3592 } 3593 } 3594 ++it; 3595 } 3596 3597 if (detach_error) 3598 return SendErrorResponse(std::move(detach_error)); 3599 if (!detached) 3600 return SendErrorResponse( 3601 Status::FromErrorStringWithFormat("PID %" PRIu64 " not traced", pid)); 3602 return SendOKResponse(); 3603 } 3604 3605 GDBRemoteCommunication::PacketResult 3606 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo( 3607 StringExtractorGDBRemote &packet) { 3608 Log *log = GetLog(LLDBLog::Thread); 3609 3610 if (!m_current_process || 3611 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 3612 return SendErrorResponse(50); 3613 3614 packet.SetFilePos(strlen("qThreadStopInfo")); 3615 const lldb::tid_t tid = packet.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID); 3616 if (tid == LLDB_INVALID_THREAD_ID) { 3617 LLDB_LOGF(log, 3618 "GDBRemoteCommunicationServerLLGS::%s failed, could not " 3619 "parse thread id from request \"%s\"", 3620 __FUNCTION__, packet.GetStringRef().data()); 3621 return SendErrorResponse(0x15); 3622 } 3623 return SendStopReplyPacketForThread(*m_current_process, tid, 3624 /*force_synchronous=*/true); 3625 } 3626 3627 GDBRemoteCommunication::PacketResult 3628 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo( 3629 StringExtractorGDBRemote &) { 3630 Log *log = GetLog(LLDBLog::Process | LLDBLog::Thread); 3631 3632 // Ensure we have a debugged process. 3633 if (!m_current_process || 3634 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 3635 return SendErrorResponse(50); 3636 LLDB_LOG(log, "preparing packet for pid {0}", m_current_process->GetID()); 3637 3638 StreamString response; 3639 const bool threads_with_valid_stop_info_only = false; 3640 llvm::Expected<json::Value> threads_info = 3641 GetJSONThreadsInfo(*m_current_process, threads_with_valid_stop_info_only); 3642 if (!threads_info) { 3643 LLDB_LOG_ERROR(log, threads_info.takeError(), 3644 "failed to prepare a packet for pid {1}: {0}", 3645 m_current_process->GetID()); 3646 return SendErrorResponse(52); 3647 } 3648 3649 response.AsRawOstream() << *threads_info; 3650 StreamGDBRemote escaped_response; 3651 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 3652 return SendPacketNoLock(escaped_response.GetString()); 3653 } 3654 3655 GDBRemoteCommunication::PacketResult 3656 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo( 3657 StringExtractorGDBRemote &packet) { 3658 // Fail if we don't have a current process. 3659 if (!m_current_process || 3660 m_current_process->GetID() == LLDB_INVALID_PROCESS_ID) 3661 return SendErrorResponse(68); 3662 3663 packet.SetFilePos(strlen("qWatchpointSupportInfo")); 3664 if (packet.GetBytesLeft() == 0) 3665 return SendOKResponse(); 3666 if (packet.GetChar() != ':') 3667 return SendErrorResponse(67); 3668 3669 auto hw_debug_cap = m_current_process->GetHardwareDebugSupportInfo(); 3670 3671 StreamGDBRemote response; 3672 if (hw_debug_cap == std::nullopt) 3673 response.Printf("num:0;"); 3674 else 3675 response.Printf("num:%d;", hw_debug_cap->second); 3676 3677 return SendPacketNoLock(response.GetString()); 3678 } 3679 3680 GDBRemoteCommunication::PacketResult 3681 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress( 3682 StringExtractorGDBRemote &packet) { 3683 // Fail if we don't have a current process. 3684 if (!m_current_process || 3685 m_current_process->GetID() == LLDB_INVALID_PROCESS_ID) 3686 return SendErrorResponse(67); 3687 3688 packet.SetFilePos(strlen("qFileLoadAddress:")); 3689 if (packet.GetBytesLeft() == 0) 3690 return SendErrorResponse(68); 3691 3692 std::string file_name; 3693 packet.GetHexByteString(file_name); 3694 3695 lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS; 3696 Status error = 3697 m_current_process->GetFileLoadAddress(file_name, file_load_address); 3698 if (error.Fail()) 3699 return SendErrorResponse(69); 3700 3701 if (file_load_address == LLDB_INVALID_ADDRESS) 3702 return SendErrorResponse(1); // File not loaded 3703 3704 StreamGDBRemote response; 3705 response.PutHex64(file_load_address); 3706 return SendPacketNoLock(response.GetString()); 3707 } 3708 3709 GDBRemoteCommunication::PacketResult 3710 GDBRemoteCommunicationServerLLGS::Handle_QPassSignals( 3711 StringExtractorGDBRemote &packet) { 3712 std::vector<int> signals; 3713 packet.SetFilePos(strlen("QPassSignals:")); 3714 3715 // Read sequence of hex signal numbers divided by a semicolon and optionally 3716 // spaces. 3717 while (packet.GetBytesLeft() > 0) { 3718 int signal = packet.GetS32(-1, 16); 3719 if (signal < 0) 3720 return SendIllFormedResponse(packet, "Failed to parse signal number."); 3721 signals.push_back(signal); 3722 3723 packet.SkipSpaces(); 3724 char separator = packet.GetChar(); 3725 if (separator == '\0') 3726 break; // End of string 3727 if (separator != ';') 3728 return SendIllFormedResponse(packet, "Invalid separator," 3729 " expected semicolon."); 3730 } 3731 3732 // Fail if we don't have a current process. 3733 if (!m_current_process) 3734 return SendErrorResponse(68); 3735 3736 Status error = m_current_process->IgnoreSignals(signals); 3737 if (error.Fail()) 3738 return SendErrorResponse(69); 3739 3740 return SendOKResponse(); 3741 } 3742 3743 GDBRemoteCommunication::PacketResult 3744 GDBRemoteCommunicationServerLLGS::Handle_qMemTags( 3745 StringExtractorGDBRemote &packet) { 3746 Log *log = GetLog(LLDBLog::Process); 3747 3748 // Ensure we have a process. 3749 if (!m_current_process || 3750 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3751 LLDB_LOGF( 3752 log, 3753 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3754 __FUNCTION__); 3755 return SendErrorResponse(1); 3756 } 3757 3758 // We are expecting 3759 // qMemTags:<hex address>,<hex length>:<hex type> 3760 3761 // Address 3762 packet.SetFilePos(strlen("qMemTags:")); 3763 const char *current_char = packet.Peek(); 3764 if (!current_char || *current_char == ',') 3765 return SendIllFormedResponse(packet, "Missing address in qMemTags packet"); 3766 const lldb::addr_t addr = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3767 3768 // Length 3769 char previous_char = packet.GetChar(); 3770 current_char = packet.Peek(); 3771 // If we don't have a separator or the length field is empty 3772 if (previous_char != ',' || (current_char && *current_char == ':')) 3773 return SendIllFormedResponse(packet, 3774 "Invalid addr,length pair in qMemTags packet"); 3775 3776 if (packet.GetBytesLeft() < 1) 3777 return SendIllFormedResponse( 3778 packet, "Too short qMemtags: packet (looking for length)"); 3779 const size_t length = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3780 3781 // Type 3782 const char *invalid_type_err = "Invalid type field in qMemTags: packet"; 3783 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ':') 3784 return SendIllFormedResponse(packet, invalid_type_err); 3785 3786 // Type is a signed integer but packed into the packet as its raw bytes. 3787 // However, our GetU64 uses strtoull which allows +/-. We do not want this. 3788 const char *first_type_char = packet.Peek(); 3789 if (first_type_char && (*first_type_char == '+' || *first_type_char == '-')) 3790 return SendIllFormedResponse(packet, invalid_type_err); 3791 3792 // Extract type as unsigned then cast to signed. 3793 // Using a uint64_t here so that we have some value outside of the 32 bit 3794 // range to use as the invalid return value. 3795 uint64_t raw_type = 3796 packet.GetU64(std::numeric_limits<uint64_t>::max(), /*base=*/16); 3797 3798 if ( // Make sure the cast below would be valid 3799 raw_type > std::numeric_limits<uint32_t>::max() || 3800 // To catch inputs like "123aardvark" that will parse but clearly aren't 3801 // valid in this case. 3802 packet.GetBytesLeft()) { 3803 return SendIllFormedResponse(packet, invalid_type_err); 3804 } 3805 3806 // First narrow to 32 bits otherwise the copy into type would take 3807 // the wrong 4 bytes on big endian. 3808 uint32_t raw_type_32 = raw_type; 3809 int32_t type = reinterpret_cast<int32_t &>(raw_type_32); 3810 3811 StreamGDBRemote response; 3812 std::vector<uint8_t> tags; 3813 Status error = m_current_process->ReadMemoryTags(type, addr, length, tags); 3814 if (error.Fail()) 3815 return SendErrorResponse(1); 3816 3817 // This m is here in case we want to support multi part replies in the future. 3818 // In the same manner as qfThreadInfo/qsThreadInfo. 3819 response.PutChar('m'); 3820 response.PutBytesAsRawHex8(tags.data(), tags.size()); 3821 return SendPacketNoLock(response.GetString()); 3822 } 3823 3824 GDBRemoteCommunication::PacketResult 3825 GDBRemoteCommunicationServerLLGS::Handle_QMemTags( 3826 StringExtractorGDBRemote &packet) { 3827 Log *log = GetLog(LLDBLog::Process); 3828 3829 // Ensure we have a process. 3830 if (!m_current_process || 3831 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) { 3832 LLDB_LOGF( 3833 log, 3834 "GDBRemoteCommunicationServerLLGS::%s failed, no process available", 3835 __FUNCTION__); 3836 return SendErrorResponse(1); 3837 } 3838 3839 // We are expecting 3840 // QMemTags:<hex address>,<hex length>:<hex type>:<tags as hex bytes> 3841 3842 // Address 3843 packet.SetFilePos(strlen("QMemTags:")); 3844 const char *current_char = packet.Peek(); 3845 if (!current_char || *current_char == ',') 3846 return SendIllFormedResponse(packet, "Missing address in QMemTags packet"); 3847 const lldb::addr_t addr = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3848 3849 // Length 3850 char previous_char = packet.GetChar(); 3851 current_char = packet.Peek(); 3852 // If we don't have a separator or the length field is empty 3853 if (previous_char != ',' || (current_char && *current_char == ':')) 3854 return SendIllFormedResponse(packet, 3855 "Invalid addr,length pair in QMemTags packet"); 3856 3857 if (packet.GetBytesLeft() < 1) 3858 return SendIllFormedResponse( 3859 packet, "Too short QMemtags: packet (looking for length)"); 3860 const size_t length = packet.GetHexMaxU64(/*little_endian=*/false, 0); 3861 3862 // Type 3863 const char *invalid_type_err = "Invalid type field in QMemTags: packet"; 3864 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ':') 3865 return SendIllFormedResponse(packet, invalid_type_err); 3866 3867 // Our GetU64 uses strtoull which allows leading +/-, we don't want that. 3868 const char *first_type_char = packet.Peek(); 3869 if (first_type_char && (*first_type_char == '+' || *first_type_char == '-')) 3870 return SendIllFormedResponse(packet, invalid_type_err); 3871 3872 // The type is a signed integer but is in the packet as its raw bytes. 3873 // So parse first as unsigned then cast to signed later. 3874 // We extract to 64 bit, even though we only expect 32, so that we've 3875 // got some invalid value we can check for. 3876 uint64_t raw_type = 3877 packet.GetU64(std::numeric_limits<uint64_t>::max(), /*base=*/16); 3878 if (raw_type > std::numeric_limits<uint32_t>::max()) 3879 return SendIllFormedResponse(packet, invalid_type_err); 3880 3881 // First narrow to 32 bits. Otherwise the copy below would get the wrong 3882 // 4 bytes on big endian. 3883 uint32_t raw_type_32 = raw_type; 3884 int32_t type = reinterpret_cast<int32_t &>(raw_type_32); 3885 3886 // Tag data 3887 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ':') 3888 return SendIllFormedResponse(packet, 3889 "Missing tag data in QMemTags: packet"); 3890 3891 // Must be 2 chars per byte 3892 const char *invalid_data_err = "Invalid tag data in QMemTags: packet"; 3893 if (packet.GetBytesLeft() % 2) 3894 return SendIllFormedResponse(packet, invalid_data_err); 3895 3896 // This is bytes here and is unpacked into target specific tags later 3897 // We cannot assume that number of bytes == length here because the server 3898 // can repeat tags to fill a given range. 3899 std::vector<uint8_t> tag_data; 3900 // Zero length writes will not have any tag data 3901 // (but we pass them on because it will still check that tagging is enabled) 3902 if (packet.GetBytesLeft()) { 3903 size_t byte_count = packet.GetBytesLeft() / 2; 3904 tag_data.resize(byte_count); 3905 size_t converted_bytes = packet.GetHexBytes(tag_data, 0); 3906 if (converted_bytes != byte_count) { 3907 return SendIllFormedResponse(packet, invalid_data_err); 3908 } 3909 } 3910 3911 Status status = 3912 m_current_process->WriteMemoryTags(type, addr, length, tag_data); 3913 return status.Success() ? SendOKResponse() : SendErrorResponse(1); 3914 } 3915 3916 GDBRemoteCommunication::PacketResult 3917 GDBRemoteCommunicationServerLLGS::Handle_qSaveCore( 3918 StringExtractorGDBRemote &packet) { 3919 // Fail if we don't have a current process. 3920 if (!m_current_process || 3921 (m_current_process->GetID() == LLDB_INVALID_PROCESS_ID)) 3922 return SendErrorResponse(Status::FromErrorString("Process not running.")); 3923 3924 std::string path_hint; 3925 3926 StringRef packet_str{packet.GetStringRef()}; 3927 assert(packet_str.starts_with("qSaveCore")); 3928 if (packet_str.consume_front("qSaveCore;")) { 3929 for (auto x : llvm::split(packet_str, ';')) { 3930 if (x.consume_front("path-hint:")) 3931 StringExtractor(x).GetHexByteString(path_hint); 3932 else 3933 return SendErrorResponse( 3934 Status::FromErrorString("Unsupported qSaveCore option")); 3935 } 3936 } 3937 3938 llvm::Expected<std::string> ret = m_current_process->SaveCore(path_hint); 3939 if (!ret) 3940 return SendErrorResponse(ret.takeError()); 3941 3942 StreamString response; 3943 response.PutCString("core-path:"); 3944 response.PutStringAsRawHex8(ret.get()); 3945 return SendPacketNoLock(response.GetString()); 3946 } 3947 3948 GDBRemoteCommunication::PacketResult 3949 GDBRemoteCommunicationServerLLGS::Handle_QNonStop( 3950 StringExtractorGDBRemote &packet) { 3951 Log *log = GetLog(LLDBLog::Process); 3952 3953 StringRef packet_str{packet.GetStringRef()}; 3954 assert(packet_str.starts_with("QNonStop:")); 3955 packet_str.consume_front("QNonStop:"); 3956 if (packet_str == "0") { 3957 if (m_non_stop) 3958 StopSTDIOForwarding(); 3959 for (auto &process_it : m_debugged_processes) { 3960 if (process_it.second.process_up->IsRunning()) { 3961 assert(m_non_stop); 3962 Status error = process_it.second.process_up->Interrupt(); 3963 if (error.Fail()) { 3964 LLDB_LOG(log, 3965 "while disabling nonstop, failed to halt process {0}: {1}", 3966 process_it.first, error); 3967 return SendErrorResponse(0x41); 3968 } 3969 // we must not send stop reasons after QNonStop 3970 m_disabling_non_stop = true; 3971 } 3972 } 3973 m_stdio_notification_queue.clear(); 3974 m_stop_notification_queue.clear(); 3975 m_non_stop = false; 3976 // If we are stopping anything, defer sending the OK response until we're 3977 // done. 3978 if (m_disabling_non_stop) 3979 return PacketResult::Success; 3980 } else if (packet_str == "1") { 3981 if (!m_non_stop) 3982 StartSTDIOForwarding(); 3983 m_non_stop = true; 3984 } else 3985 return SendErrorResponse( 3986 Status::FromErrorString("Invalid QNonStop packet")); 3987 return SendOKResponse(); 3988 } 3989 3990 GDBRemoteCommunication::PacketResult 3991 GDBRemoteCommunicationServerLLGS::HandleNotificationAck( 3992 std::deque<std::string> &queue) { 3993 // Per the protocol, the first message put into the queue is sent 3994 // immediately. However, it remains the queue until the client ACKs it -- 3995 // then we pop it and send the next message. The process repeats until 3996 // the last message in the queue is ACK-ed, in which case the packet sends 3997 // an OK response. 3998 if (queue.empty()) 3999 return SendErrorResponse( 4000 Status::FromErrorString("No pending notification to ack")); 4001 queue.pop_front(); 4002 if (!queue.empty()) 4003 return SendPacketNoLock(queue.front()); 4004 return SendOKResponse(); 4005 } 4006 4007 GDBRemoteCommunication::PacketResult 4008 GDBRemoteCommunicationServerLLGS::Handle_vStdio( 4009 StringExtractorGDBRemote &packet) { 4010 return HandleNotificationAck(m_stdio_notification_queue); 4011 } 4012 4013 GDBRemoteCommunication::PacketResult 4014 GDBRemoteCommunicationServerLLGS::Handle_vStopped( 4015 StringExtractorGDBRemote &packet) { 4016 PacketResult ret = HandleNotificationAck(m_stop_notification_queue); 4017 // If this was the last notification and all the processes exited, 4018 // terminate the server. 4019 if (m_stop_notification_queue.empty() && m_debugged_processes.empty()) { 4020 m_exit_now = true; 4021 m_mainloop.RequestTermination(); 4022 } 4023 return ret; 4024 } 4025 4026 GDBRemoteCommunication::PacketResult 4027 GDBRemoteCommunicationServerLLGS::Handle_vCtrlC( 4028 StringExtractorGDBRemote &packet) { 4029 if (!m_non_stop) 4030 return SendErrorResponse( 4031 Status::FromErrorString("vCtrl is only valid in non-stop mode")); 4032 4033 PacketResult interrupt_res = Handle_interrupt(packet); 4034 // If interrupting the process failed, pass the result through. 4035 if (interrupt_res != PacketResult::Success) 4036 return interrupt_res; 4037 // Otherwise, vCtrlC should issue an OK response (normal interrupts do not). 4038 return SendOKResponse(); 4039 } 4040 4041 GDBRemoteCommunication::PacketResult 4042 GDBRemoteCommunicationServerLLGS::Handle_T(StringExtractorGDBRemote &packet) { 4043 packet.SetFilePos(strlen("T")); 4044 auto pid_tid = packet.GetPidTid(m_current_process ? m_current_process->GetID() 4045 : LLDB_INVALID_PROCESS_ID); 4046 if (!pid_tid) 4047 return SendErrorResponse(llvm::make_error<StringError>( 4048 inconvertibleErrorCode(), "Malformed thread-id")); 4049 4050 lldb::pid_t pid = pid_tid->first; 4051 lldb::tid_t tid = pid_tid->second; 4052 4053 // Technically, this would also be caught by the PID check but let's be more 4054 // explicit about the error. 4055 if (pid == LLDB_INVALID_PROCESS_ID) 4056 return SendErrorResponse(llvm::make_error<StringError>( 4057 inconvertibleErrorCode(), "No current process and no PID provided")); 4058 4059 // Check the process ID and find respective process instance. 4060 auto new_process_it = m_debugged_processes.find(pid); 4061 if (new_process_it == m_debugged_processes.end()) 4062 return SendErrorResponse(1); 4063 4064 // Check the thread ID 4065 if (!new_process_it->second.process_up->GetThreadByID(tid)) 4066 return SendErrorResponse(2); 4067 4068 return SendOKResponse(); 4069 } 4070 4071 void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() { 4072 Log *log = GetLog(LLDBLog::Process); 4073 4074 // Tell the stdio connection to shut down. 4075 if (m_stdio_communication.IsConnected()) { 4076 auto connection = m_stdio_communication.GetConnection(); 4077 if (connection) { 4078 Status error; 4079 connection->Disconnect(&error); 4080 4081 if (error.Success()) { 4082 LLDB_LOGF(log, 4083 "GDBRemoteCommunicationServerLLGS::%s disconnect process " 4084 "terminal stdio - SUCCESS", 4085 __FUNCTION__); 4086 } else { 4087 LLDB_LOGF(log, 4088 "GDBRemoteCommunicationServerLLGS::%s disconnect process " 4089 "terminal stdio - FAIL: %s", 4090 __FUNCTION__, error.AsCString()); 4091 } 4092 } 4093 } 4094 } 4095 4096 NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( 4097 StringExtractorGDBRemote &packet) { 4098 // We have no thread if we don't have a process. 4099 if (!m_current_process || 4100 m_current_process->GetID() == LLDB_INVALID_PROCESS_ID) 4101 return nullptr; 4102 4103 // If the client hasn't asked for thread suffix support, there will not be a 4104 // thread suffix. Use the current thread in that case. 4105 if (!m_thread_suffix_supported) { 4106 const lldb::tid_t current_tid = GetCurrentThreadID(); 4107 if (current_tid == LLDB_INVALID_THREAD_ID) 4108 return nullptr; 4109 else if (current_tid == 0) { 4110 // Pick a thread. 4111 return m_current_process->GetThreadAtIndex(0); 4112 } else 4113 return m_current_process->GetThreadByID(current_tid); 4114 } 4115 4116 Log *log = GetLog(LLDBLog::Thread); 4117 4118 // Parse out the ';'. 4119 if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') { 4120 LLDB_LOGF(log, 4121 "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 4122 "error: expected ';' prior to start of thread suffix: packet " 4123 "contents = '%s'", 4124 __FUNCTION__, packet.GetStringRef().data()); 4125 return nullptr; 4126 } 4127 4128 if (!packet.GetBytesLeft()) 4129 return nullptr; 4130 4131 // Parse out thread: portion. 4132 if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) { 4133 LLDB_LOGF(log, 4134 "GDBRemoteCommunicationServerLLGS::%s gdb-remote parse " 4135 "error: expected 'thread:' but not found, packet contents = " 4136 "'%s'", 4137 __FUNCTION__, packet.GetStringRef().data()); 4138 return nullptr; 4139 } 4140 packet.SetFilePos(packet.GetFilePos() + strlen("thread:")); 4141 const lldb::tid_t tid = packet.GetHexMaxU64(false, 0); 4142 if (tid != 0) 4143 return m_current_process->GetThreadByID(tid); 4144 4145 return nullptr; 4146 } 4147 4148 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const { 4149 if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) { 4150 // Use whatever the debug process says is the current thread id since the 4151 // protocol either didn't specify or specified we want any/all threads 4152 // marked as the current thread. 4153 if (!m_current_process) 4154 return LLDB_INVALID_THREAD_ID; 4155 return m_current_process->GetCurrentThreadID(); 4156 } 4157 // Use the specific current thread id set by the gdb remote protocol. 4158 return m_current_tid; 4159 } 4160 4161 uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() { 4162 std::lock_guard<std::mutex> guard(m_saved_registers_mutex); 4163 return m_next_saved_registers_id++; 4164 } 4165 4166 void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() { 4167 Log *log = GetLog(LLDBLog::Process); 4168 4169 LLDB_LOG(log, "clearing {0} xfer buffers", m_xfer_buffer_map.size()); 4170 m_xfer_buffer_map.clear(); 4171 } 4172 4173 FileSpec 4174 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path, 4175 const ArchSpec &arch) { 4176 if (m_current_process) { 4177 FileSpec file_spec; 4178 if (m_current_process 4179 ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec) 4180 .Success()) { 4181 if (FileSystem::Instance().Exists(file_spec)) 4182 return file_spec; 4183 } 4184 } 4185 4186 return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch); 4187 } 4188 4189 std::string GDBRemoteCommunicationServerLLGS::XMLEncodeAttributeValue( 4190 llvm::StringRef value) { 4191 std::string result; 4192 for (const char &c : value) { 4193 switch (c) { 4194 case '\'': 4195 result += "'"; 4196 break; 4197 case '"': 4198 result += """; 4199 break; 4200 case '<': 4201 result += "<"; 4202 break; 4203 case '>': 4204 result += ">"; 4205 break; 4206 default: 4207 result += c; 4208 break; 4209 } 4210 } 4211 return result; 4212 } 4213 4214 std::vector<std::string> GDBRemoteCommunicationServerLLGS::HandleFeatures( 4215 const llvm::ArrayRef<llvm::StringRef> client_features) { 4216 std::vector<std::string> ret = 4217 GDBRemoteCommunicationServerCommon::HandleFeatures(client_features); 4218 ret.insert(ret.end(), { 4219 "QThreadSuffixSupported+", 4220 "QListThreadsInStopReply+", 4221 "qXfer:features:read+", 4222 "QNonStop+", 4223 }); 4224 4225 // report server-only features 4226 using Extension = NativeProcessProtocol::Extension; 4227 Extension plugin_features = m_process_manager.GetSupportedExtensions(); 4228 if (bool(plugin_features & Extension::pass_signals)) 4229 ret.push_back("QPassSignals+"); 4230 if (bool(plugin_features & Extension::auxv)) 4231 ret.push_back("qXfer:auxv:read+"); 4232 if (bool(plugin_features & Extension::libraries_svr4)) 4233 ret.push_back("qXfer:libraries-svr4:read+"); 4234 if (bool(plugin_features & Extension::siginfo_read)) 4235 ret.push_back("qXfer:siginfo:read+"); 4236 if (bool(plugin_features & Extension::memory_tagging)) 4237 ret.push_back("memory-tagging+"); 4238 if (bool(plugin_features & Extension::savecore)) 4239 ret.push_back("qSaveCore+"); 4240 4241 // check for client features 4242 m_extensions_supported = {}; 4243 for (llvm::StringRef x : client_features) 4244 m_extensions_supported |= 4245 llvm::StringSwitch<Extension>(x) 4246 .Case("multiprocess+", Extension::multiprocess) 4247 .Case("fork-events+", Extension::fork) 4248 .Case("vfork-events+", Extension::vfork) 4249 .Default({}); 4250 4251 // We consume lldb's swbreak/hwbreak feature, but it doesn't change the 4252 // behaviour of lldb-server. We always adjust the program counter for targets 4253 // like x86 4254 4255 m_extensions_supported &= plugin_features; 4256 4257 // fork & vfork require multiprocess 4258 if (!bool(m_extensions_supported & Extension::multiprocess)) 4259 m_extensions_supported &= ~(Extension::fork | Extension::vfork); 4260 4261 // report only if actually supported 4262 if (bool(m_extensions_supported & Extension::multiprocess)) 4263 ret.push_back("multiprocess+"); 4264 if (bool(m_extensions_supported & Extension::fork)) 4265 ret.push_back("fork-events+"); 4266 if (bool(m_extensions_supported & Extension::vfork)) 4267 ret.push_back("vfork-events+"); 4268 4269 for (auto &x : m_debugged_processes) 4270 SetEnabledExtensions(*x.second.process_up); 4271 return ret; 4272 } 4273 4274 void GDBRemoteCommunicationServerLLGS::SetEnabledExtensions( 4275 NativeProcessProtocol &process) { 4276 NativeProcessProtocol::Extension flags = m_extensions_supported; 4277 assert(!bool(flags & ~m_process_manager.GetSupportedExtensions())); 4278 process.SetEnabledExtensions(flags); 4279 } 4280 4281 GDBRemoteCommunication::PacketResult 4282 GDBRemoteCommunicationServerLLGS::SendContinueSuccessResponse() { 4283 if (m_non_stop) 4284 return SendOKResponse(); 4285 StartSTDIOForwarding(); 4286 return PacketResult::Success; 4287 } 4288 4289 void GDBRemoteCommunicationServerLLGS::AppendThreadIDToResponse( 4290 Stream &response, lldb::pid_t pid, lldb::tid_t tid) { 4291 if (bool(m_extensions_supported & 4292 NativeProcessProtocol::Extension::multiprocess)) 4293 response.Format("p{0:x-}.", pid); 4294 response.Format("{0:x-}", tid); 4295 } 4296 4297 std::string 4298 lldb_private::process_gdb_remote::LLGSArgToURL(llvm::StringRef url_arg, 4299 bool reverse_connect) { 4300 // Try parsing the argument as URL. 4301 if (std::optional<URI> url = URI::Parse(url_arg)) { 4302 if (reverse_connect) 4303 return url_arg.str(); 4304 4305 // Translate the scheme from LLGS notation to ConnectionFileDescriptor. 4306 // If the scheme doesn't match any, pass it through to support using CFD 4307 // schemes directly. 4308 std::string new_url = llvm::StringSwitch<std::string>(url->scheme) 4309 .Case("tcp", "listen") 4310 .Case("unix", "unix-accept") 4311 .Case("unix-abstract", "unix-abstract-accept") 4312 .Default(url->scheme.str()); 4313 llvm::append_range(new_url, url_arg.substr(url->scheme.size())); 4314 return new_url; 4315 } 4316 4317 std::string host_port = url_arg.str(); 4318 // If host_and_port starts with ':', default the host to be "localhost" and 4319 // expect the remainder to be the port. 4320 if (url_arg.starts_with(":")) 4321 host_port.insert(0, "localhost"); 4322 4323 // Try parsing the (preprocessed) argument as host:port pair. 4324 if (!llvm::errorToBool(Socket::DecodeHostAndPort(host_port).takeError())) 4325 return (reverse_connect ? "connect://" : "listen://") + host_port; 4326 4327 // If none of the above applied, interpret the argument as UNIX socket path. 4328 return (reverse_connect ? "unix-connect://" : "unix-accept://") + 4329 url_arg.str(); 4330 } 4331