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