1 //===-- GDBRemoteCommunicationServerLLGS.cpp --------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include <errno.h> 11 12 #include "lldb/Host/Config.h" 13 14 #include "GDBRemoteCommunicationServerLLGS.h" 15 #include "lldb/Core/StreamGDBRemote.h" 16 17 // C Includes 18 // C++ Includes 19 #include <cstring> 20 #include <chrono> 21 #include <thread> 22 23 // Other libraries and framework includes 24 #include "llvm/ADT/Triple.h" 25 #include "lldb/Interpreter/Args.h" 26 #include "lldb/Core/DataBuffer.h" 27 #include "lldb/Core/Log.h" 28 #include "lldb/Core/RegisterValue.h" 29 #include "lldb/Core/State.h" 30 #include "lldb/Core/StreamString.h" 31 #include "lldb/Host/ConnectionFileDescriptor.h" 32 #include "lldb/Host/Debug.h" 33 #include "lldb/Host/Endian.h" 34 #include "lldb/Host/File.h" 35 #include "lldb/Host/FileSystem.h" 36 #include "lldb/Host/Host.h" 37 #include "lldb/Host/HostInfo.h" 38 #include "lldb/Host/StringConvert.h" 39 #include "lldb/Host/TimeValue.h" 40 #include "lldb/Target/FileAction.h" 41 #include "lldb/Target/MemoryRegionInfo.h" 42 #include "lldb/Target/Platform.h" 43 #include "lldb/Host/common/NativeRegisterContext.h" 44 #include "lldb/Host/common/NativeProcessProtocol.h" 45 #include "lldb/Host/common/NativeThreadProtocol.h" 46 #include "lldb/Utility/JSON.h" 47 #include "lldb/Utility/LLDBAssert.h" 48 49 // Project includes 50 #include "Utility/StringExtractorGDBRemote.h" 51 #include "Utility/UriParser.h" 52 #include "ProcessGDBRemote.h" 53 #include "ProcessGDBRemoteLog.h" 54 55 using namespace lldb; 56 using namespace lldb_private; 57 using namespace lldb_private::process_gdb_remote; 58 using namespace llvm; 59 60 //---------------------------------------------------------------------- 61 // GDBRemote Errors 62 //---------------------------------------------------------------------- 63 64 namespace 65 { 66 enum GDBRemoteServerError 67 { 68 // Set to the first unused error number in literal form below 69 eErrorFirst = 29, 70 eErrorNoProcess = eErrorFirst, 71 eErrorResume, 72 eErrorExitStatus 73 }; 74 } 75 76 //---------------------------------------------------------------------- 77 // GDBRemoteCommunicationServerLLGS constructor 78 //---------------------------------------------------------------------- 79 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS( 80 const lldb::PlatformSP& platform_sp, 81 MainLoop &mainloop) : 82 GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"), 83 m_platform_sp (platform_sp), 84 m_mainloop (mainloop), 85 m_current_tid (LLDB_INVALID_THREAD_ID), 86 m_continue_tid (LLDB_INVALID_THREAD_ID), 87 m_debugged_process_mutex (Mutex::eMutexTypeRecursive), 88 m_debugged_process_sp (), 89 m_stdio_communication ("process.stdio"), 90 m_inferior_prev_state (StateType::eStateInvalid), 91 m_active_auxv_buffer_sp (), 92 m_saved_registers_mutex (), 93 m_saved_registers_map (), 94 m_next_saved_registers_id (1), 95 m_handshake_completed (false) 96 { 97 assert(platform_sp); 98 RegisterPacketHandlers(); 99 } 100 101 void 102 GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() 103 { 104 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C, 105 &GDBRemoteCommunicationServerLLGS::Handle_C); 106 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c, 107 &GDBRemoteCommunicationServerLLGS::Handle_c); 108 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D, 109 &GDBRemoteCommunicationServerLLGS::Handle_D); 110 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H, 111 &GDBRemoteCommunicationServerLLGS::Handle_H); 112 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I, 113 &GDBRemoteCommunicationServerLLGS::Handle_I); 114 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_interrupt, 115 &GDBRemoteCommunicationServerLLGS::Handle_interrupt); 116 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_m, 117 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 118 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M, 119 &GDBRemoteCommunicationServerLLGS::Handle_M); 120 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p, 121 &GDBRemoteCommunicationServerLLGS::Handle_p); 122 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P, 123 &GDBRemoteCommunicationServerLLGS::Handle_P); 124 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC, 125 &GDBRemoteCommunicationServerLLGS::Handle_qC); 126 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qfThreadInfo, 127 &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo); 128 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress, 129 &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress); 130 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir, 131 &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir); 132 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo, 133 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo); 134 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported, 135 &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported); 136 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qProcessInfo, 137 &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo); 138 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qRegisterInfo, 139 &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo); 140 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState, 141 &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState); 142 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState, 143 &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState); 144 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR, 145 &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR); 146 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir, 147 &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir); 148 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qsThreadInfo, 149 &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo); 150 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo, 151 &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo); 152 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_jThreadsInfo, 153 &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo); 154 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo, 155 &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo); 156 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read, 157 &GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read); 158 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s, 159 &GDBRemoteCommunicationServerLLGS::Handle_s); 160 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_stop_reason, 161 &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ? 162 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_vAttach, 163 &GDBRemoteCommunicationServerLLGS::Handle_vAttach); 164 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_vCont, 165 &GDBRemoteCommunicationServerLLGS::Handle_vCont); 166 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_vCont_actions, 167 &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions); 168 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_x, 169 &GDBRemoteCommunicationServerLLGS::Handle_memory_read); 170 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z, 171 &GDBRemoteCommunicationServerLLGS::Handle_Z); 172 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z, 173 &GDBRemoteCommunicationServerLLGS::Handle_z); 174 175 RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k, 176 [this](StringExtractorGDBRemote packet, 177 Error &error, 178 bool &interrupt, 179 bool &quit) 180 { 181 quit = true; 182 return this->Handle_k (packet); 183 }); 184 } 185 186 Error 187 GDBRemoteCommunicationServerLLGS::SetLaunchArguments (const char *const args[], int argc) 188 { 189 if ((argc < 1) || !args || !args[0] || !args[0][0]) 190 return Error ("%s: no process command line specified to launch", __FUNCTION__); 191 192 m_process_launch_info.SetArguments (const_cast<const char**> (args), true); 193 return Error (); 194 } 195 196 Error 197 GDBRemoteCommunicationServerLLGS::SetLaunchFlags (unsigned int launch_flags) 198 { 199 m_process_launch_info.GetFlags ().Set (launch_flags); 200 return Error (); 201 } 202 203 Error 204 GDBRemoteCommunicationServerLLGS::LaunchProcess () 205 { 206 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 207 208 if (!m_process_launch_info.GetArguments ().GetArgumentCount ()) 209 return Error ("%s: no process command line specified to launch", __FUNCTION__); 210 211 Error error; 212 { 213 Mutex::Locker locker (m_debugged_process_mutex); 214 assert (!m_debugged_process_sp && "lldb-gdbserver creating debugged process but one already exists"); 215 error = NativeProcessProtocol::Launch( 216 m_process_launch_info, 217 *this, 218 m_mainloop, 219 m_debugged_process_sp); 220 } 221 222 if (!error.Success ()) 223 { 224 fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0)); 225 return error; 226 } 227 228 // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol 229 // as needed. 230 // llgs local-process debugging may specify PTY paths, which will make these 231 // file actions non-null 232 // process launch -i/e/o will also make these file actions non-null 233 // nullptr means that the traffic is expected to flow over gdb-remote protocol 234 if ( 235 m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr || 236 m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr || 237 m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr 238 ) 239 { 240 // nullptr means it's not redirected to file or pty (in case of LLGS local) 241 // at least one of stdio will be transferred pty<->gdb-remote 242 // we need to give the pty master handle to this object to read and/or write 243 if (log) 244 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " setting up stdout/stderr redirection via $O gdb-remote commands", __FUNCTION__, m_debugged_process_sp->GetID ()); 245 246 // Setup stdout/stderr mapping from inferior to $O 247 auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor (); 248 if (terminal_fd >= 0) 249 { 250 if (log) 251 log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd); 252 error = SetSTDIOFileDescriptor (terminal_fd); 253 if (error.Fail ()) 254 return error; 255 } 256 else 257 { 258 if (log) 259 log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd); 260 } 261 } 262 else 263 { 264 if (log) 265 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " skipping stdout/stderr redirection via $O: inferior will communicate over client-provided file descriptors", __FUNCTION__, m_debugged_process_sp->GetID ()); 266 } 267 268 printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID ()); 269 270 return error; 271 } 272 273 Error 274 GDBRemoteCommunicationServerLLGS::AttachToProcess (lldb::pid_t pid) 275 { 276 Error error; 277 278 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS)); 279 if (log) 280 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, __FUNCTION__, pid); 281 282 // Before we try to attach, make sure we aren't already monitoring something else. 283 if (m_debugged_process_sp && m_debugged_process_sp->GetID() != LLDB_INVALID_PROCESS_ID) 284 return Error("cannot attach to a process %" PRIu64 " when another process with pid %" PRIu64 " is being debugged.", pid, m_debugged_process_sp->GetID()); 285 286 // Try to attach. 287 error = NativeProcessProtocol::Attach(pid, *this, m_mainloop, m_debugged_process_sp); 288 if (!error.Success ()) 289 { 290 fprintf (stderr, "%s: failed to attach to process %" PRIu64 ": %s", __FUNCTION__, pid, error.AsCString ()); 291 return error; 292 } 293 294 // Setup stdout/stderr mapping from inferior. 295 auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor (); 296 if (terminal_fd >= 0) 297 { 298 if (log) 299 log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd); 300 error = SetSTDIOFileDescriptor (terminal_fd); 301 if (error.Fail ()) 302 return error; 303 } 304 else 305 { 306 if (log) 307 log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd); 308 } 309 310 printf ("Attached to process %" PRIu64 "...\n", pid); 311 312 return error; 313 } 314 315 void 316 GDBRemoteCommunicationServerLLGS::InitializeDelegate (NativeProcessProtocol *process) 317 { 318 assert (process && "process cannot be NULL"); 319 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 320 if (log) 321 { 322 log->Printf ("GDBRemoteCommunicationServerLLGS::%s called with NativeProcessProtocol pid %" PRIu64 ", current state: %s", 323 __FUNCTION__, 324 process->GetID (), 325 StateAsCString (process->GetState ())); 326 } 327 } 328 329 GDBRemoteCommunication::PacketResult 330 GDBRemoteCommunicationServerLLGS::SendWResponse (NativeProcessProtocol *process) 331 { 332 assert (process && "process cannot be NULL"); 333 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 334 335 // send W notification 336 ExitType exit_type = ExitType::eExitTypeInvalid; 337 int return_code = 0; 338 std::string exit_description; 339 340 const bool got_exit_info = process->GetExitStatus (&exit_type, &return_code, exit_description); 341 if (!got_exit_info) 342 { 343 if (log) 344 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 ", failed to retrieve process exit status", __FUNCTION__, process->GetID ()); 345 346 StreamGDBRemote response; 347 response.PutChar ('E'); 348 response.PutHex8 (GDBRemoteServerError::eErrorExitStatus); 349 return SendPacketNoLock(response.GetData(), response.GetSize()); 350 } 351 else 352 { 353 if (log) 354 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 ", returning exit type %d, return code %d [%s]", __FUNCTION__, process->GetID (), exit_type, return_code, exit_description.c_str ()); 355 356 StreamGDBRemote response; 357 358 char return_type_code; 359 switch (exit_type) 360 { 361 case ExitType::eExitTypeExit: 362 return_type_code = 'W'; 363 break; 364 case ExitType::eExitTypeSignal: 365 return_type_code = 'X'; 366 break; 367 case ExitType::eExitTypeStop: 368 return_type_code = 'S'; 369 break; 370 case ExitType::eExitTypeInvalid: 371 return_type_code = 'E'; 372 break; 373 } 374 response.PutChar (return_type_code); 375 376 // POSIX exit status limited to unsigned 8 bits. 377 response.PutHex8 (return_code); 378 379 return SendPacketNoLock(response.GetData(), response.GetSize()); 380 } 381 } 382 383 static void 384 AppendHexValue (StreamString &response, const uint8_t* buf, uint32_t buf_size, bool swap) 385 { 386 int64_t i; 387 if (swap) 388 { 389 for (i = buf_size-1; i >= 0; i--) 390 response.PutHex8 (buf[i]); 391 } 392 else 393 { 394 for (i = 0; i < buf_size; i++) 395 response.PutHex8 (buf[i]); 396 } 397 } 398 399 static void 400 WriteRegisterValueInHexFixedWidth (StreamString &response, 401 NativeRegisterContextSP ®_ctx_sp, 402 const RegisterInfo ®_info, 403 const RegisterValue *reg_value_p) 404 { 405 RegisterValue reg_value; 406 if (!reg_value_p) 407 { 408 Error error = reg_ctx_sp->ReadRegister (®_info, reg_value); 409 if (error.Success ()) 410 reg_value_p = ®_value; 411 // else log. 412 } 413 414 if (reg_value_p) 415 { 416 AppendHexValue (response, (const uint8_t*) reg_value_p->GetBytes (), reg_value_p->GetByteSize (), false); 417 } 418 else 419 { 420 // Zero-out any unreadable values. 421 if (reg_info.byte_size > 0) 422 { 423 std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0'); 424 AppendHexValue (response, zeros.data(), zeros.size(), false); 425 } 426 } 427 } 428 429 static JSONObject::SP 430 GetRegistersAsJSON(NativeThreadProtocol &thread, bool abridged) 431 { 432 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD)); 433 434 NativeRegisterContextSP reg_ctx_sp = thread.GetRegisterContext (); 435 if (! reg_ctx_sp) 436 return nullptr; 437 438 JSONObject::SP register_object_sp = std::make_shared<JSONObject>(); 439 440 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET 441 // Expedite all registers in the first register set (i.e. should be GPRs) that are not contained in other registers. 442 const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0); 443 if (! reg_set_p) 444 return nullptr; 445 for (const uint32_t *reg_num_p = reg_set_p->registers; *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) 446 { 447 uint32_t reg_num = *reg_num_p; 448 #else 449 // Expedite only a couple of registers until we figure out why sending registers is 450 // expensive. 451 static const uint32_t k_expedited_registers[] = { 452 LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM 453 }; 454 static const uint32_t k_abridged_expedited_registers[] = { 455 LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM 456 }; 457 458 for (const uint32_t *generic_reg_p = abridged ? k_abridged_expedited_registers : k_expedited_registers; 459 *generic_reg_p != LLDB_INVALID_REGNUM; 460 ++generic_reg_p) 461 { 462 uint32_t reg_num = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, *generic_reg_p); 463 if (reg_num == LLDB_INVALID_REGNUM) 464 continue; // Target does not support the given register. 465 #endif 466 467 const RegisterInfo *const reg_info_p = reg_ctx_sp->GetRegisterInfoAtIndex(reg_num); 468 if (reg_info_p == nullptr) 469 { 470 if (log) 471 log->Printf("%s failed to get register info for register index %" PRIu32, 472 __FUNCTION__, reg_num); 473 continue; 474 } 475 476 if (reg_info_p->value_regs != nullptr) 477 continue; // Only expedite registers that are not contained in other registers. 478 479 RegisterValue reg_value; 480 Error error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value); 481 if (error.Fail()) 482 { 483 if (log) 484 log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s", __FUNCTION__, 485 reg_info_p->name ? reg_info_p->name : "<unnamed-register>", reg_num, 486 error.AsCString ()); 487 continue; 488 } 489 490 StreamString stream; 491 WriteRegisterValueInHexFixedWidth(stream, reg_ctx_sp, *reg_info_p, ®_value); 492 493 register_object_sp->SetObject(std::to_string(reg_num), 494 std::make_shared<JSONString>(stream.GetString())); 495 } 496 497 return register_object_sp; 498 } 499 500 static const char * 501 GetStopReasonString(StopReason stop_reason) 502 { 503 switch (stop_reason) 504 { 505 case eStopReasonTrace: 506 return "trace"; 507 case eStopReasonBreakpoint: 508 return "breakpoint"; 509 case eStopReasonWatchpoint: 510 return "watchpoint"; 511 case eStopReasonSignal: 512 return "signal"; 513 case eStopReasonException: 514 return "exception"; 515 case eStopReasonExec: 516 return "exec"; 517 case eStopReasonInstrumentation: 518 case eStopReasonInvalid: 519 case eStopReasonPlanComplete: 520 case eStopReasonThreadExiting: 521 case eStopReasonNone: 522 break; // ignored 523 } 524 return nullptr; 525 } 526 527 static JSONArray::SP 528 GetJSONThreadsInfo(NativeProcessProtocol &process, bool abridged) 529 { 530 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 531 532 JSONArray::SP threads_array_sp = std::make_shared<JSONArray>(); 533 534 // Ensure we can get info on the given thread. 535 uint32_t thread_idx = 0; 536 for ( NativeThreadProtocolSP thread_sp; 537 (thread_sp = process.GetThreadAtIndex(thread_idx)) != nullptr; 538 ++thread_idx) 539 { 540 541 lldb::tid_t tid = thread_sp->GetID(); 542 543 // Grab the reason this thread stopped. 544 struct ThreadStopInfo tid_stop_info; 545 std::string description; 546 if (!thread_sp->GetStopReason (tid_stop_info, description)) 547 return nullptr; 548 549 const int signum = tid_stop_info.details.signal.signo; 550 if (log) 551 { 552 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 553 __FUNCTION__, 554 process.GetID (), 555 tid, 556 signum, 557 tid_stop_info.reason, 558 tid_stop_info.details.exception.type); 559 } 560 561 JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>(); 562 threads_array_sp->AppendObject(thread_obj_sp); 563 564 if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp, abridged)) 565 thread_obj_sp->SetObject("registers", registers_sp); 566 567 thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid)); 568 if (signum != 0) 569 thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum)); 570 571 const std::string thread_name = thread_sp->GetName (); 572 if (! thread_name.empty()) 573 thread_obj_sp->SetObject("name", std::make_shared<JSONString>(thread_name)); 574 575 if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason)) 576 thread_obj_sp->SetObject("reason", std::make_shared<JSONString>(stop_reason_str)); 577 578 if (! description.empty()) 579 thread_obj_sp->SetObject("description", std::make_shared<JSONString>(description)); 580 581 if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type) 582 { 583 thread_obj_sp->SetObject("metype", 584 std::make_shared<JSONNumber>(tid_stop_info.details.exception.type)); 585 586 JSONArray::SP medata_array_sp = std::make_shared<JSONArray>(); 587 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) 588 { 589 medata_array_sp->AppendObject(std::make_shared<JSONNumber>( 590 tid_stop_info.details.exception.data[i])); 591 } 592 thread_obj_sp->SetObject("medata", medata_array_sp); 593 } 594 595 // TODO: Expedite interesting regions of inferior memory 596 } 597 598 return threads_array_sp; 599 } 600 601 GDBRemoteCommunication::PacketResult 602 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread (lldb::tid_t tid) 603 { 604 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 605 606 // Ensure we have a debugged process. 607 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 608 return SendErrorResponse (50); 609 610 if (log) 611 log->Printf ("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64 " tid %" PRIu64, 612 __FUNCTION__, m_debugged_process_sp->GetID (), tid); 613 614 // Ensure we can get info on the given thread. 615 NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadByID (tid)); 616 if (!thread_sp) 617 return SendErrorResponse (51); 618 619 // Grab the reason this thread stopped. 620 struct ThreadStopInfo tid_stop_info; 621 std::string description; 622 if (!thread_sp->GetStopReason (tid_stop_info, description)) 623 return SendErrorResponse (52); 624 625 // FIXME implement register handling for exec'd inferiors. 626 // if (tid_stop_info.reason == eStopReasonExec) 627 // { 628 // const bool force = true; 629 // InitializeRegisters(force); 630 // } 631 632 StreamString response; 633 // Output the T packet with the thread 634 response.PutChar ('T'); 635 int signum = tid_stop_info.details.signal.signo; 636 if (log) 637 { 638 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 639 __FUNCTION__, 640 m_debugged_process_sp->GetID (), 641 tid, 642 signum, 643 tid_stop_info.reason, 644 tid_stop_info.details.exception.type); 645 } 646 647 // Print the signal number. 648 response.PutHex8 (signum & 0xff); 649 650 // Include the tid. 651 response.Printf ("thread:%" PRIx64 ";", tid); 652 653 // Include the thread name if there is one. 654 const std::string thread_name = thread_sp->GetName (); 655 if (!thread_name.empty ()) 656 { 657 size_t thread_name_len = thread_name.length (); 658 659 if (::strcspn (thread_name.c_str (), "$#+-;:") == thread_name_len) 660 { 661 response.PutCString ("name:"); 662 response.PutCString (thread_name.c_str ()); 663 } 664 else 665 { 666 // The thread name contains special chars, send as hex bytes. 667 response.PutCString ("hexname:"); 668 response.PutCStringAsRawHex8 (thread_name.c_str ()); 669 } 670 response.PutChar (';'); 671 } 672 673 // If a 'QListThreadsInStopReply' was sent to enable this feature, we 674 // will send all thread IDs back in the "threads" key whose value is 675 // a list of hex thread IDs separated by commas: 676 // "threads:10a,10b,10c;" 677 // This will save the debugger from having to send a pair of qfThreadInfo 678 // and qsThreadInfo packets, but it also might take a lot of room in the 679 // stop reply packet, so it must be enabled only on systems where there 680 // are no limits on packet lengths. 681 if (m_list_threads_in_stop_reply) 682 { 683 response.PutCString ("threads:"); 684 685 uint32_t thread_index = 0; 686 NativeThreadProtocolSP listed_thread_sp; 687 for (listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index); listed_thread_sp; ++thread_index, listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index)) 688 { 689 if (thread_index > 0) 690 response.PutChar (','); 691 response.Printf ("%" PRIx64, listed_thread_sp->GetID ()); 692 } 693 response.PutChar (';'); 694 695 // Include JSON info that describes the stop reason for any threads 696 // that actually have stop reasons. We use the new "jstopinfo" key 697 // whose values is hex ascii JSON that contains the thread IDs 698 // thread stop info only for threads that have stop reasons. Only send 699 // this if we have more than one thread otherwise this packet has all 700 // the info it needs. 701 if (thread_index > 0) 702 { 703 const bool threads_with_valid_stop_info_only = true; 704 JSONArray::SP threads_info_sp = GetJSONThreadsInfo(*m_debugged_process_sp, 705 threads_with_valid_stop_info_only); 706 if (threads_info_sp) 707 { 708 response.PutCString("jstopinfo:"); 709 StreamString unescaped_response; 710 threads_info_sp->Write(unescaped_response); 711 response.PutCStringAsRawHex8(unescaped_response.GetData()); 712 response.PutChar(';'); 713 } 714 else if (log) 715 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to prepare a jstopinfo field for pid %" PRIu64, 716 __FUNCTION__, m_debugged_process_sp->GetID()); 717 718 } 719 } 720 721 // 722 // Expedite registers. 723 // 724 725 // Grab the register context. 726 NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext (); 727 if (reg_ctx_sp) 728 { 729 // Expedite all registers in the first register set (i.e. should be GPRs) that are not contained in other registers. 730 const RegisterSet *reg_set_p; 731 if (reg_ctx_sp->GetRegisterSetCount () > 0 && ((reg_set_p = reg_ctx_sp->GetRegisterSet (0)) != nullptr)) 732 { 733 if (log) 734 log->Printf ("GDBRemoteCommunicationServerLLGS::%s expediting registers from set '%s' (registers set count: %zu)", __FUNCTION__, reg_set_p->name ? reg_set_p->name : "<unnamed-set>", reg_set_p->num_registers); 735 736 for (const uint32_t *reg_num_p = reg_set_p->registers; *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) 737 { 738 const RegisterInfo *const reg_info_p = reg_ctx_sp->GetRegisterInfoAtIndex (*reg_num_p); 739 if (reg_info_p == nullptr) 740 { 741 if (log) 742 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to get register info for register set '%s', register index %" PRIu32, __FUNCTION__, reg_set_p->name ? reg_set_p->name : "<unnamed-set>", *reg_num_p); 743 } 744 else if (reg_info_p->value_regs == nullptr) 745 { 746 // Only expediate registers that are not contained in other registers. 747 RegisterValue reg_value; 748 Error error = reg_ctx_sp->ReadRegister (reg_info_p, reg_value); 749 if (error.Success ()) 750 { 751 response.Printf ("%.02x:", *reg_num_p); 752 WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p, ®_value); 753 response.PutChar (';'); 754 } 755 else 756 { 757 if (log) 758 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to read register '%s' index %" PRIu32 ": %s", __FUNCTION__, reg_info_p->name ? reg_info_p->name : "<unnamed-register>", *reg_num_p, error.AsCString ()); 759 760 } 761 } 762 } 763 } 764 } 765 766 const char* reason_str = GetStopReasonString(tid_stop_info.reason); 767 if (reason_str != nullptr) 768 { 769 response.Printf ("reason:%s;", reason_str); 770 } 771 772 if (!description.empty()) 773 { 774 // Description may contains special chars, send as hex bytes. 775 response.PutCString ("description:"); 776 response.PutCStringAsRawHex8 (description.c_str ()); 777 response.PutChar (';'); 778 } 779 else if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type) 780 { 781 response.PutCString ("metype:"); 782 response.PutHex64 (tid_stop_info.details.exception.type); 783 response.PutCString (";mecount:"); 784 response.PutHex32 (tid_stop_info.details.exception.data_count); 785 response.PutChar (';'); 786 787 for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) 788 { 789 response.PutCString ("medata:"); 790 response.PutHex64 (tid_stop_info.details.exception.data[i]); 791 response.PutChar (';'); 792 } 793 } 794 795 return SendPacketNoLock (response.GetData(), response.GetSize()); 796 } 797 798 void 799 GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited (NativeProcessProtocol *process) 800 { 801 assert (process && "process cannot be NULL"); 802 803 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 804 if (log) 805 log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 806 807 PacketResult result = SendStopReasonForState(StateType::eStateExited); 808 if (result != PacketResult::Success) 809 { 810 if (log) 811 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ()); 812 } 813 814 // Close the pipe to the inferior terminal i/o if we launched it 815 // and set one up. 816 MaybeCloseInferiorTerminalConnection (); 817 818 // We are ready to exit the debug monitor. 819 m_exit_now = true; 820 } 821 822 void 823 GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped (NativeProcessProtocol *process) 824 { 825 assert (process && "process cannot be NULL"); 826 827 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 828 if (log) 829 log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 830 831 // Send the stop reason unless this is the stop after the 832 // launch or attach. 833 switch (m_inferior_prev_state) 834 { 835 case eStateLaunching: 836 case eStateAttaching: 837 // Don't send anything per debugserver behavior. 838 break; 839 default: 840 // In all other cases, send the stop reason. 841 PacketResult result = SendStopReasonForState(StateType::eStateStopped); 842 if (result != PacketResult::Success) 843 { 844 if (log) 845 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ()); 846 } 847 break; 848 } 849 } 850 851 void 852 GDBRemoteCommunicationServerLLGS::ProcessStateChanged (NativeProcessProtocol *process, lldb::StateType state) 853 { 854 assert (process && "process cannot be NULL"); 855 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 856 if (log) 857 { 858 log->Printf ("GDBRemoteCommunicationServerLLGS::%s called with NativeProcessProtocol pid %" PRIu64 ", state: %s", 859 __FUNCTION__, 860 process->GetID (), 861 StateAsCString (state)); 862 } 863 864 switch (state) 865 { 866 case StateType::eStateRunning: 867 StartSTDIOForwarding(); 868 break; 869 870 case StateType::eStateStopped: 871 // Make sure we get all of the pending stdout/stderr from the inferior 872 // and send it to the lldb host before we send the state change 873 // notification 874 SendProcessOutput(); 875 // Then stop the forwarding, so that any late output (see llvm.org/pr25652) does not 876 // interfere with our protocol. 877 StopSTDIOForwarding(); 878 HandleInferiorState_Stopped (process); 879 break; 880 881 case StateType::eStateExited: 882 // Same as above 883 SendProcessOutput(); 884 StopSTDIOForwarding(); 885 HandleInferiorState_Exited (process); 886 break; 887 888 default: 889 if (log) 890 { 891 log->Printf ("GDBRemoteCommunicationServerLLGS::%s didn't handle state change for pid %" PRIu64 ", new state: %s", 892 __FUNCTION__, 893 process->GetID (), 894 StateAsCString (state)); 895 } 896 break; 897 } 898 899 // Remember the previous state reported to us. 900 m_inferior_prev_state = state; 901 } 902 903 void 904 GDBRemoteCommunicationServerLLGS::DidExec (NativeProcessProtocol *process) 905 { 906 ClearProcessSpecificData (); 907 } 908 909 void 910 GDBRemoteCommunicationServerLLGS::DataAvailableCallback () 911 { 912 Log *log (GetLogIfAnyCategoriesSet(GDBR_LOG_COMM)); 913 914 if (! m_handshake_completed) 915 { 916 if (! HandshakeWithClient()) 917 { 918 if(log) 919 log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with client failed, exiting", 920 __FUNCTION__); 921 m_mainloop.RequestTermination(); 922 return; 923 } 924 m_handshake_completed = true; 925 } 926 927 bool interrupt = false; 928 bool done = false; 929 Error error; 930 while (true) 931 { 932 const PacketResult result = GetPacketAndSendResponse (0, error, interrupt, done); 933 if (result == PacketResult::ErrorReplyTimeout) 934 break; // No more packets in the queue 935 936 if ((result != PacketResult::Success)) 937 { 938 if(log) 939 log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet failed: %s", 940 __FUNCTION__, error.AsCString()); 941 m_mainloop.RequestTermination(); 942 break; 943 } 944 } 945 } 946 947 Error 948 GDBRemoteCommunicationServerLLGS::InitializeConnection (std::unique_ptr<Connection> &&connection) 949 { 950 IOObjectSP read_object_sp = connection->GetReadObject(); 951 GDBRemoteCommunicationServer::SetConnection(connection.release()); 952 953 Error error; 954 m_network_handle_up = m_mainloop.RegisterReadObject(read_object_sp, 955 [this] (MainLoopBase &) { DataAvailableCallback(); }, error); 956 return error; 957 } 958 959 GDBRemoteCommunication::PacketResult 960 GDBRemoteCommunicationServerLLGS::SendONotification (const char *buffer, uint32_t len) 961 { 962 if ((buffer == nullptr) || (len == 0)) 963 { 964 // Nothing to send. 965 return PacketResult::Success; 966 } 967 968 StreamString response; 969 response.PutChar ('O'); 970 response.PutBytesAsRawHex8 (buffer, len); 971 972 return SendPacketNoLock (response.GetData (), response.GetSize ()); 973 } 974 975 Error 976 GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor (int fd) 977 { 978 Error error; 979 980 // Set up the reading/handling of process I/O 981 std::unique_ptr<ConnectionFileDescriptor> conn_up (new ConnectionFileDescriptor (fd, true)); 982 if (!conn_up) 983 { 984 error.SetErrorString ("failed to create ConnectionFileDescriptor"); 985 return error; 986 } 987 988 m_stdio_communication.SetCloseOnEOF (false); 989 m_stdio_communication.SetConnection (conn_up.release()); 990 if (!m_stdio_communication.IsConnected ()) 991 { 992 error.SetErrorString ("failed to set connection for inferior I/O communication"); 993 return error; 994 } 995 996 return Error(); 997 } 998 999 void 1000 GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() 1001 { 1002 // Don't forward if not connected (e.g. when attaching). 1003 if (! m_stdio_communication.IsConnected()) 1004 return; 1005 1006 // llgs local-process debugging may specify PTY paths, which will make these 1007 // file actions non-null 1008 // process launch -e/o will also make these file actions non-null 1009 // nullptr means that the traffic is expected to flow over gdb-remote protocol 1010 if ( m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) && 1011 m_process_launch_info.GetFileActionForFD(STDERR_FILENO)) 1012 return; 1013 1014 Error error; 1015 lldbassert(! m_stdio_handle_up); 1016 m_stdio_handle_up = m_mainloop.RegisterReadObject( 1017 m_stdio_communication.GetConnection()->GetReadObject(), 1018 [this] (MainLoopBase &) { SendProcessOutput(); }, error); 1019 1020 if (! m_stdio_handle_up) 1021 { 1022 // Not much we can do about the failure. Log it and continue without forwarding. 1023 if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)) 1024 log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio forwarding: %s", 1025 __FUNCTION__, error.AsCString()); 1026 } 1027 } 1028 1029 void 1030 GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() 1031 { 1032 m_stdio_handle_up.reset(); 1033 } 1034 1035 void 1036 GDBRemoteCommunicationServerLLGS::SendProcessOutput() 1037 { 1038 char buffer[1024]; 1039 ConnectionStatus status; 1040 Error error; 1041 while (true) 1042 { 1043 size_t bytes_read = m_stdio_communication.Read(buffer, sizeof buffer, 0, status, &error); 1044 switch (status) 1045 { 1046 case eConnectionStatusSuccess: 1047 SendONotification(buffer, bytes_read); 1048 break; 1049 case eConnectionStatusLostConnection: 1050 case eConnectionStatusEndOfFile: 1051 case eConnectionStatusError: 1052 case eConnectionStatusNoConnection: 1053 if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)) 1054 log->Printf("GDBRemoteCommunicationServerLLGS::%s Stopping stdio forwarding as communication returned status %d (error: %s)", __FUNCTION__, status, error.AsCString()); 1055 m_stdio_handle_up.reset(); 1056 return; 1057 1058 case eConnectionStatusInterrupted: 1059 case eConnectionStatusTimedOut: 1060 return; 1061 } 1062 } 1063 } 1064 1065 GDBRemoteCommunication::PacketResult 1066 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo (StringExtractorGDBRemote &packet) 1067 { 1068 // Fail if we don't have a current process. 1069 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1070 return SendErrorResponse (68); 1071 1072 lldb::pid_t pid = m_debugged_process_sp->GetID (); 1073 1074 if (pid == LLDB_INVALID_PROCESS_ID) 1075 return SendErrorResponse (1); 1076 1077 ProcessInstanceInfo proc_info; 1078 if (!Host::GetProcessInfo (pid, proc_info)) 1079 return SendErrorResponse (1); 1080 1081 StreamString response; 1082 CreateProcessInfoResponse_DebugServerStyle(proc_info, response); 1083 return SendPacketNoLock (response.GetData (), response.GetSize ()); 1084 } 1085 1086 GDBRemoteCommunication::PacketResult 1087 GDBRemoteCommunicationServerLLGS::Handle_qC (StringExtractorGDBRemote &packet) 1088 { 1089 // Fail if we don't have a current process. 1090 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1091 return SendErrorResponse (68); 1092 1093 // Make sure we set the current thread so g and p packets return 1094 // the data the gdb will expect. 1095 lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID (); 1096 SetCurrentThreadID (tid); 1097 1098 NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetCurrentThread (); 1099 if (!thread_sp) 1100 return SendErrorResponse (69); 1101 1102 StreamString response; 1103 response.Printf ("QC%" PRIx64, thread_sp->GetID ()); 1104 1105 return SendPacketNoLock (response.GetData(), response.GetSize()); 1106 } 1107 1108 GDBRemoteCommunication::PacketResult 1109 GDBRemoteCommunicationServerLLGS::Handle_k (StringExtractorGDBRemote &packet) 1110 { 1111 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1112 1113 StopSTDIOForwarding(); 1114 1115 if (! m_debugged_process_sp) 1116 { 1117 if (log) 1118 log->Printf("GDBRemoteCommunicationServerLLGS::%s No debugged process found.", __FUNCTION__); 1119 return PacketResult::Success; 1120 } 1121 1122 Error error = m_debugged_process_sp->Kill(); 1123 if (error.Fail() && log) 1124 log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to kill debugged process %" PRIu64 ": %s", 1125 __FUNCTION__, m_debugged_process_sp->GetID(), error.AsCString()); 1126 1127 // No OK response for kill packet. 1128 // return SendOKResponse (); 1129 return PacketResult::Success; 1130 } 1131 1132 GDBRemoteCommunication::PacketResult 1133 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR (StringExtractorGDBRemote &packet) 1134 { 1135 packet.SetFilePos(::strlen ("QSetDisableASLR:")); 1136 if (packet.GetU32(0)) 1137 m_process_launch_info.GetFlags().Set (eLaunchFlagDisableASLR); 1138 else 1139 m_process_launch_info.GetFlags().Clear (eLaunchFlagDisableASLR); 1140 return SendOKResponse (); 1141 } 1142 1143 GDBRemoteCommunication::PacketResult 1144 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir (StringExtractorGDBRemote &packet) 1145 { 1146 packet.SetFilePos (::strlen ("QSetWorkingDir:")); 1147 std::string path; 1148 packet.GetHexByteString (path); 1149 m_process_launch_info.SetWorkingDirectory(FileSpec{path, true}); 1150 return SendOKResponse (); 1151 } 1152 1153 GDBRemoteCommunication::PacketResult 1154 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir (StringExtractorGDBRemote &packet) 1155 { 1156 FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()}; 1157 if (working_dir) 1158 { 1159 StreamString response; 1160 response.PutCStringAsRawHex8(working_dir.GetCString()); 1161 return SendPacketNoLock(response.GetData(), response.GetSize()); 1162 } 1163 1164 return SendErrorResponse(14); 1165 } 1166 1167 GDBRemoteCommunication::PacketResult 1168 GDBRemoteCommunicationServerLLGS::Handle_C (StringExtractorGDBRemote &packet) 1169 { 1170 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD)); 1171 if (log) 1172 log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1173 1174 // Ensure we have a native process. 1175 if (!m_debugged_process_sp) 1176 { 1177 if (log) 1178 log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__); 1179 return SendErrorResponse (0x36); 1180 } 1181 1182 // Pull out the signal number. 1183 packet.SetFilePos (::strlen ("C")); 1184 if (packet.GetBytesLeft () < 1) 1185 { 1186 // Shouldn't be using a C without a signal. 1187 return SendIllFormedResponse (packet, "C packet specified without signal."); 1188 } 1189 const uint32_t signo = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ()); 1190 if (signo == std::numeric_limits<uint32_t>::max ()) 1191 return SendIllFormedResponse (packet, "failed to parse signal number"); 1192 1193 // Handle optional continue address. 1194 if (packet.GetBytesLeft () > 0) 1195 { 1196 // FIXME add continue at address support for $C{signo}[;{continue-address}]. 1197 if (*packet.Peek () == ';') 1198 return SendUnimplementedResponse (packet.GetStringRef().c_str()); 1199 else 1200 return SendIllFormedResponse (packet, "unexpected content after $C{signal-number}"); 1201 } 1202 1203 ResumeActionList resume_actions (StateType::eStateRunning, 0); 1204 Error error; 1205 1206 // We have two branches: what to do if a continue thread is specified (in which case we target 1207 // sending the signal to that thread), or when we don't have a continue thread set (in which 1208 // case we send a signal to the process). 1209 1210 // TODO discuss with Greg Clayton, make sure this makes sense. 1211 1212 lldb::tid_t signal_tid = GetContinueThreadID (); 1213 if (signal_tid != LLDB_INVALID_THREAD_ID) 1214 { 1215 // The resume action for the continue thread (or all threads if a continue thread is not set). 1216 ResumeAction action = { GetContinueThreadID (), StateType::eStateRunning, static_cast<int> (signo) }; 1217 1218 // Add the action for the continue thread (or all threads when the continue thread isn't present). 1219 resume_actions.Append (action); 1220 } 1221 else 1222 { 1223 // Send the signal to the process since we weren't targeting a specific continue thread with the signal. 1224 error = m_debugged_process_sp->Signal (signo); 1225 if (error.Fail ()) 1226 { 1227 if (log) 1228 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send signal for process %" PRIu64 ": %s", 1229 __FUNCTION__, 1230 m_debugged_process_sp->GetID (), 1231 error.AsCString ()); 1232 1233 return SendErrorResponse (0x52); 1234 } 1235 } 1236 1237 // Resume the threads. 1238 error = m_debugged_process_sp->Resume (resume_actions); 1239 if (error.Fail ()) 1240 { 1241 if (log) 1242 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to resume threads for process %" PRIu64 ": %s", 1243 __FUNCTION__, 1244 m_debugged_process_sp->GetID (), 1245 error.AsCString ()); 1246 1247 return SendErrorResponse (0x38); 1248 } 1249 1250 // Don't send an "OK" packet; response is the stopped/exited message. 1251 return PacketResult::Success; 1252 } 1253 1254 GDBRemoteCommunication::PacketResult 1255 GDBRemoteCommunicationServerLLGS::Handle_c (StringExtractorGDBRemote &packet) 1256 { 1257 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD)); 1258 if (log) 1259 log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__); 1260 1261 packet.SetFilePos (packet.GetFilePos() + ::strlen ("c")); 1262 1263 // For now just support all continue. 1264 const bool has_continue_address = (packet.GetBytesLeft () > 0); 1265 if (has_continue_address) 1266 { 1267 if (log) 1268 log->Printf ("GDBRemoteCommunicationServerLLGS::%s not implemented for c{address} variant [%s remains]", __FUNCTION__, packet.Peek ()); 1269 return SendUnimplementedResponse (packet.GetStringRef().c_str()); 1270 } 1271 1272 // Ensure we have a native process. 1273 if (!m_debugged_process_sp) 1274 { 1275 if (log) 1276 log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__); 1277 return SendErrorResponse (0x36); 1278 } 1279 1280 // Build the ResumeActionList 1281 ResumeActionList actions (StateType::eStateRunning, 0); 1282 1283 Error error = m_debugged_process_sp->Resume (actions); 1284 if (error.Fail ()) 1285 { 1286 if (log) 1287 { 1288 log->Printf ("GDBRemoteCommunicationServerLLGS::%s c failed for process %" PRIu64 ": %s", 1289 __FUNCTION__, 1290 m_debugged_process_sp->GetID (), 1291 error.AsCString ()); 1292 } 1293 return SendErrorResponse (GDBRemoteServerError::eErrorResume); 1294 } 1295 1296 if (log) 1297 log->Printf ("GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ()); 1298 1299 // No response required from continue. 1300 return PacketResult::Success; 1301 } 1302 1303 GDBRemoteCommunication::PacketResult 1304 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions (StringExtractorGDBRemote &packet) 1305 { 1306 StreamString response; 1307 response.Printf("vCont;c;C;s;S"); 1308 1309 return SendPacketNoLock(response.GetData(), response.GetSize()); 1310 } 1311 1312 GDBRemoteCommunication::PacketResult 1313 GDBRemoteCommunicationServerLLGS::Handle_vCont (StringExtractorGDBRemote &packet) 1314 { 1315 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1316 if (log) 1317 log->Printf ("GDBRemoteCommunicationServerLLGS::%s handling vCont packet", __FUNCTION__); 1318 1319 packet.SetFilePos (::strlen ("vCont")); 1320 1321 if (packet.GetBytesLeft() == 0) 1322 { 1323 if (log) 1324 log->Printf ("GDBRemoteCommunicationServerLLGS::%s missing action from vCont package", __FUNCTION__); 1325 return SendIllFormedResponse (packet, "Missing action from vCont package"); 1326 } 1327 1328 // Check if this is all continue (no options or ";c"). 1329 if (::strcmp (packet.Peek (), ";c") == 0) 1330 { 1331 // Move past the ';', then do a simple 'c'. 1332 packet.SetFilePos (packet.GetFilePos () + 1); 1333 return Handle_c (packet); 1334 } 1335 else if (::strcmp (packet.Peek (), ";s") == 0) 1336 { 1337 // Move past the ';', then do a simple 's'. 1338 packet.SetFilePos (packet.GetFilePos () + 1); 1339 return Handle_s (packet); 1340 } 1341 1342 // Ensure we have a native process. 1343 if (!m_debugged_process_sp) 1344 { 1345 if (log) 1346 log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__); 1347 return SendErrorResponse (0x36); 1348 } 1349 1350 ResumeActionList thread_actions; 1351 1352 while (packet.GetBytesLeft () && *packet.Peek () == ';') 1353 { 1354 // Skip the semi-colon. 1355 packet.GetChar (); 1356 1357 // Build up the thread action. 1358 ResumeAction thread_action; 1359 thread_action.tid = LLDB_INVALID_THREAD_ID; 1360 thread_action.state = eStateInvalid; 1361 thread_action.signal = 0; 1362 1363 const char action = packet.GetChar (); 1364 switch (action) 1365 { 1366 case 'C': 1367 thread_action.signal = packet.GetHexMaxU32 (false, 0); 1368 if (thread_action.signal == 0) 1369 return SendIllFormedResponse (packet, "Could not parse signal in vCont packet C action"); 1370 // Fall through to next case... 1371 1372 case 'c': 1373 // Continue 1374 thread_action.state = eStateRunning; 1375 break; 1376 1377 case 'S': 1378 thread_action.signal = packet.GetHexMaxU32 (false, 0); 1379 if (thread_action.signal == 0) 1380 return SendIllFormedResponse (packet, "Could not parse signal in vCont packet S action"); 1381 // Fall through to next case... 1382 1383 case 's': 1384 // Step 1385 thread_action.state = eStateStepping; 1386 break; 1387 1388 default: 1389 return SendIllFormedResponse (packet, "Unsupported vCont action"); 1390 break; 1391 } 1392 1393 // Parse out optional :{thread-id} value. 1394 if (packet.GetBytesLeft () && (*packet.Peek () == ':')) 1395 { 1396 // Consume the separator. 1397 packet.GetChar (); 1398 1399 thread_action.tid = packet.GetHexMaxU32 (false, LLDB_INVALID_THREAD_ID); 1400 if (thread_action.tid == LLDB_INVALID_THREAD_ID) 1401 return SendIllFormedResponse (packet, "Could not parse thread number in vCont packet"); 1402 } 1403 1404 thread_actions.Append (thread_action); 1405 } 1406 1407 Error error = m_debugged_process_sp->Resume (thread_actions); 1408 if (error.Fail ()) 1409 { 1410 if (log) 1411 { 1412 log->Printf ("GDBRemoteCommunicationServerLLGS::%s vCont failed for process %" PRIu64 ": %s", 1413 __FUNCTION__, 1414 m_debugged_process_sp->GetID (), 1415 error.AsCString ()); 1416 } 1417 return SendErrorResponse (GDBRemoteServerError::eErrorResume); 1418 } 1419 1420 if (log) 1421 log->Printf ("GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ()); 1422 1423 // No response required from vCont. 1424 return PacketResult::Success; 1425 } 1426 1427 void 1428 GDBRemoteCommunicationServerLLGS::SetCurrentThreadID (lldb::tid_t tid) 1429 { 1430 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD)); 1431 if (log) 1432 log->Printf ("GDBRemoteCommunicationServerLLGS::%s setting current thread id to %" PRIu64, __FUNCTION__, tid); 1433 1434 m_current_tid = tid; 1435 if (m_debugged_process_sp) 1436 m_debugged_process_sp->SetCurrentThreadID (m_current_tid); 1437 } 1438 1439 void 1440 GDBRemoteCommunicationServerLLGS::SetContinueThreadID (lldb::tid_t tid) 1441 { 1442 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD)); 1443 if (log) 1444 log->Printf ("GDBRemoteCommunicationServerLLGS::%s setting continue thread id to %" PRIu64, __FUNCTION__, tid); 1445 1446 m_continue_tid = tid; 1447 } 1448 1449 GDBRemoteCommunication::PacketResult 1450 GDBRemoteCommunicationServerLLGS::Handle_stop_reason (StringExtractorGDBRemote &packet) 1451 { 1452 // Handle the $? gdbremote command. 1453 1454 // If no process, indicate error 1455 if (!m_debugged_process_sp) 1456 return SendErrorResponse (02); 1457 1458 return SendStopReasonForState (m_debugged_process_sp->GetState()); 1459 } 1460 1461 GDBRemoteCommunication::PacketResult 1462 GDBRemoteCommunicationServerLLGS::SendStopReasonForState (lldb::StateType process_state) 1463 { 1464 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1465 1466 switch (process_state) 1467 { 1468 case eStateAttaching: 1469 case eStateLaunching: 1470 case eStateRunning: 1471 case eStateStepping: 1472 case eStateDetached: 1473 // NOTE: gdb protocol doc looks like it should return $OK 1474 // when everything is running (i.e. no stopped result). 1475 return PacketResult::Success; // Ignore 1476 1477 case eStateSuspended: 1478 case eStateStopped: 1479 case eStateCrashed: 1480 { 1481 lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID (); 1482 // Make sure we set the current thread so g and p packets return 1483 // the data the gdb will expect. 1484 SetCurrentThreadID (tid); 1485 return SendStopReplyPacketForThread (tid); 1486 } 1487 1488 case eStateInvalid: 1489 case eStateUnloaded: 1490 case eStateExited: 1491 return SendWResponse(m_debugged_process_sp.get()); 1492 1493 default: 1494 if (log) 1495 { 1496 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 ", current state reporting not handled: %s", 1497 __FUNCTION__, 1498 m_debugged_process_sp->GetID (), 1499 StateAsCString (process_state)); 1500 } 1501 break; 1502 } 1503 1504 return SendErrorResponse (0); 1505 } 1506 1507 GDBRemoteCommunication::PacketResult 1508 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo (StringExtractorGDBRemote &packet) 1509 { 1510 // Fail if we don't have a current process. 1511 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1512 return SendErrorResponse (68); 1513 1514 // Ensure we have a thread. 1515 NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadAtIndex (0)); 1516 if (!thread_sp) 1517 return SendErrorResponse (69); 1518 1519 // Get the register context for the first thread. 1520 NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ()); 1521 if (!reg_context_sp) 1522 return SendErrorResponse (69); 1523 1524 // Parse out the register number from the request. 1525 packet.SetFilePos (strlen("qRegisterInfo")); 1526 const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ()); 1527 if (reg_index == std::numeric_limits<uint32_t>::max ()) 1528 return SendErrorResponse (69); 1529 1530 // Return the end of registers response if we've iterated one past the end of the register set. 1531 if (reg_index >= reg_context_sp->GetUserRegisterCount ()) 1532 return SendErrorResponse (69); 1533 1534 const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index); 1535 if (!reg_info) 1536 return SendErrorResponse (69); 1537 1538 // Build the reginfos response. 1539 StreamGDBRemote response; 1540 1541 response.PutCString ("name:"); 1542 response.PutCString (reg_info->name); 1543 response.PutChar (';'); 1544 1545 if (reg_info->alt_name && reg_info->alt_name[0]) 1546 { 1547 response.PutCString ("alt-name:"); 1548 response.PutCString (reg_info->alt_name); 1549 response.PutChar (';'); 1550 } 1551 1552 response.Printf ("bitsize:%" PRIu32 ";offset:%" PRIu32 ";", reg_info->byte_size * 8, reg_info->byte_offset); 1553 1554 switch (reg_info->encoding) 1555 { 1556 case eEncodingUint: response.PutCString ("encoding:uint;"); break; 1557 case eEncodingSint: response.PutCString ("encoding:sint;"); break; 1558 case eEncodingIEEE754: response.PutCString ("encoding:ieee754;"); break; 1559 case eEncodingVector: response.PutCString ("encoding:vector;"); break; 1560 default: break; 1561 } 1562 1563 switch (reg_info->format) 1564 { 1565 case eFormatBinary: response.PutCString ("format:binary;"); break; 1566 case eFormatDecimal: response.PutCString ("format:decimal;"); break; 1567 case eFormatHex: response.PutCString ("format:hex;"); break; 1568 case eFormatFloat: response.PutCString ("format:float;"); break; 1569 case eFormatVectorOfSInt8: response.PutCString ("format:vector-sint8;"); break; 1570 case eFormatVectorOfUInt8: response.PutCString ("format:vector-uint8;"); break; 1571 case eFormatVectorOfSInt16: response.PutCString ("format:vector-sint16;"); break; 1572 case eFormatVectorOfUInt16: response.PutCString ("format:vector-uint16;"); break; 1573 case eFormatVectorOfSInt32: response.PutCString ("format:vector-sint32;"); break; 1574 case eFormatVectorOfUInt32: response.PutCString ("format:vector-uint32;"); break; 1575 case eFormatVectorOfFloat32: response.PutCString ("format:vector-float32;"); break; 1576 case eFormatVectorOfUInt128: response.PutCString ("format:vector-uint128;"); break; 1577 default: break; 1578 }; 1579 1580 const char *const register_set_name = reg_context_sp->GetRegisterSetNameForRegisterAtIndex(reg_index); 1581 if (register_set_name) 1582 { 1583 response.PutCString ("set:"); 1584 response.PutCString (register_set_name); 1585 response.PutChar (';'); 1586 } 1587 1588 if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) 1589 response.Printf ("ehframe:%" PRIu32 ";", reg_info->kinds[RegisterKind::eRegisterKindEHFrame]); 1590 1591 if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 1592 response.Printf ("dwarf:%" PRIu32 ";", reg_info->kinds[RegisterKind::eRegisterKindDWARF]); 1593 1594 switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) 1595 { 1596 case LLDB_REGNUM_GENERIC_PC: response.PutCString("generic:pc;"); break; 1597 case LLDB_REGNUM_GENERIC_SP: response.PutCString("generic:sp;"); break; 1598 case LLDB_REGNUM_GENERIC_FP: response.PutCString("generic:fp;"); break; 1599 case LLDB_REGNUM_GENERIC_RA: response.PutCString("generic:ra;"); break; 1600 case LLDB_REGNUM_GENERIC_FLAGS: response.PutCString("generic:flags;"); break; 1601 case LLDB_REGNUM_GENERIC_ARG1: response.PutCString("generic:arg1;"); break; 1602 case LLDB_REGNUM_GENERIC_ARG2: response.PutCString("generic:arg2;"); break; 1603 case LLDB_REGNUM_GENERIC_ARG3: response.PutCString("generic:arg3;"); break; 1604 case LLDB_REGNUM_GENERIC_ARG4: response.PutCString("generic:arg4;"); break; 1605 case LLDB_REGNUM_GENERIC_ARG5: response.PutCString("generic:arg5;"); break; 1606 case LLDB_REGNUM_GENERIC_ARG6: response.PutCString("generic:arg6;"); break; 1607 case LLDB_REGNUM_GENERIC_ARG7: response.PutCString("generic:arg7;"); break; 1608 case LLDB_REGNUM_GENERIC_ARG8: response.PutCString("generic:arg8;"); break; 1609 default: break; 1610 } 1611 1612 if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) 1613 { 1614 response.PutCString ("container-regs:"); 1615 int i = 0; 1616 for (const uint32_t *reg_num = reg_info->value_regs; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) 1617 { 1618 if (i > 0) 1619 response.PutChar (','); 1620 response.Printf ("%" PRIx32, *reg_num); 1621 } 1622 response.PutChar (';'); 1623 } 1624 1625 if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) 1626 { 1627 response.PutCString ("invalidate-regs:"); 1628 int i = 0; 1629 for (const uint32_t *reg_num = reg_info->invalidate_regs; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) 1630 { 1631 if (i > 0) 1632 response.PutChar (','); 1633 response.Printf ("%" PRIx32, *reg_num); 1634 } 1635 response.PutChar (';'); 1636 } 1637 1638 return SendPacketNoLock(response.GetData(), response.GetSize()); 1639 } 1640 1641 GDBRemoteCommunication::PacketResult 1642 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo (StringExtractorGDBRemote &packet) 1643 { 1644 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1645 1646 // Fail if we don't have a current process. 1647 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1648 { 1649 if (log) 1650 log->Printf ("GDBRemoteCommunicationServerLLGS::%s() no process (%s), returning OK", __FUNCTION__, m_debugged_process_sp ? "invalid process id" : "null m_debugged_process_sp"); 1651 return SendOKResponse (); 1652 } 1653 1654 StreamGDBRemote response; 1655 response.PutChar ('m'); 1656 1657 if (log) 1658 log->Printf ("GDBRemoteCommunicationServerLLGS::%s() starting thread iteration", __FUNCTION__); 1659 1660 NativeThreadProtocolSP thread_sp; 1661 uint32_t thread_index; 1662 for (thread_index = 0, thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index); 1663 thread_sp; 1664 ++thread_index, thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index)) 1665 { 1666 if (log) 1667 log->Printf ("GDBRemoteCommunicationServerLLGS::%s() iterated thread %" PRIu32 "(%s, tid=0x%" PRIx64 ")", __FUNCTION__, thread_index, thread_sp ? "is not null" : "null", thread_sp ? thread_sp->GetID () : LLDB_INVALID_THREAD_ID); 1668 if (thread_index > 0) 1669 response.PutChar(','); 1670 response.Printf ("%" PRIx64, thread_sp->GetID ()); 1671 } 1672 1673 if (log) 1674 log->Printf ("GDBRemoteCommunicationServerLLGS::%s() finished thread iteration", __FUNCTION__); 1675 1676 return SendPacketNoLock(response.GetData(), response.GetSize()); 1677 } 1678 1679 GDBRemoteCommunication::PacketResult 1680 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo (StringExtractorGDBRemote &packet) 1681 { 1682 // FIXME for now we return the full thread list in the initial packet and always do nothing here. 1683 return SendPacketNoLock ("l", 1); 1684 } 1685 1686 GDBRemoteCommunication::PacketResult 1687 GDBRemoteCommunicationServerLLGS::Handle_p (StringExtractorGDBRemote &packet) 1688 { 1689 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1690 1691 // Parse out the register number from the request. 1692 packet.SetFilePos (strlen("p")); 1693 const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ()); 1694 if (reg_index == std::numeric_limits<uint32_t>::max ()) 1695 { 1696 if (log) 1697 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ()); 1698 return SendErrorResponse (0x15); 1699 } 1700 1701 // Get the thread to use. 1702 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet); 1703 if (!thread_sp) 1704 { 1705 if (log) 1706 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no thread available", __FUNCTION__); 1707 return SendErrorResponse (0x15); 1708 } 1709 1710 // Get the thread's register context. 1711 NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ()); 1712 if (!reg_context_sp) 1713 { 1714 if (log) 1715 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ()); 1716 return SendErrorResponse (0x15); 1717 } 1718 1719 // Return the end of registers response if we've iterated one past the end of the register set. 1720 if (reg_index >= reg_context_sp->GetUserRegisterCount ()) 1721 { 1722 if (log) 1723 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetUserRegisterCount ()); 1724 return SendErrorResponse (0x15); 1725 } 1726 1727 const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index); 1728 if (!reg_info) 1729 { 1730 if (log) 1731 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " returned NULL", __FUNCTION__, reg_index); 1732 return SendErrorResponse (0x15); 1733 } 1734 1735 // Build the reginfos response. 1736 StreamGDBRemote response; 1737 1738 // Retrieve the value 1739 RegisterValue reg_value; 1740 Error error = reg_context_sp->ReadRegister (reg_info, reg_value); 1741 if (error.Fail ()) 1742 { 1743 if (log) 1744 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, read of requested register %" PRIu32 " (%s) failed: %s", __FUNCTION__, reg_index, reg_info->name, error.AsCString ()); 1745 return SendErrorResponse (0x15); 1746 } 1747 1748 const uint8_t *const data = reinterpret_cast<const uint8_t*> (reg_value.GetBytes ()); 1749 if (!data) 1750 { 1751 if (log) 1752 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to get data bytes from requested register %" PRIu32, __FUNCTION__, reg_index); 1753 return SendErrorResponse (0x15); 1754 } 1755 1756 // FIXME flip as needed to get data in big/little endian format for this host. 1757 for (uint32_t i = 0; i < reg_value.GetByteSize (); ++i) 1758 response.PutHex8 (data[i]); 1759 1760 return SendPacketNoLock (response.GetData (), response.GetSize ()); 1761 } 1762 1763 GDBRemoteCommunication::PacketResult 1764 GDBRemoteCommunicationServerLLGS::Handle_P (StringExtractorGDBRemote &packet) 1765 { 1766 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1767 1768 // Ensure there is more content. 1769 if (packet.GetBytesLeft () < 1) 1770 return SendIllFormedResponse (packet, "Empty P packet"); 1771 1772 // Parse out the register number from the request. 1773 packet.SetFilePos (strlen("P")); 1774 const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ()); 1775 if (reg_index == std::numeric_limits<uint32_t>::max ()) 1776 { 1777 if (log) 1778 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ()); 1779 return SendErrorResponse (0x29); 1780 } 1781 1782 // Note debugserver would send an E30 here. 1783 if ((packet.GetBytesLeft () < 1) || (packet.GetChar () != '=')) 1784 return SendIllFormedResponse (packet, "P packet missing '=' char after register number"); 1785 1786 // Get process architecture. 1787 ArchSpec process_arch; 1788 if (!m_debugged_process_sp || !m_debugged_process_sp->GetArchitecture (process_arch)) 1789 { 1790 if (log) 1791 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to retrieve inferior architecture", __FUNCTION__); 1792 return SendErrorResponse (0x49); 1793 } 1794 1795 // Parse out the value. 1796 uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register 1797 size_t reg_size = packet.GetHexBytesAvail (reg_bytes, sizeof(reg_bytes)); 1798 1799 // Get the thread to use. 1800 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet); 1801 if (!thread_sp) 1802 { 1803 if (log) 1804 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no thread available (thread index 0)", __FUNCTION__); 1805 return SendErrorResponse (0x28); 1806 } 1807 1808 // Get the thread's register context. 1809 NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ()); 1810 if (!reg_context_sp) 1811 { 1812 if (log) 1813 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ()); 1814 return SendErrorResponse (0x15); 1815 } 1816 1817 const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex (reg_index); 1818 if (!reg_info) 1819 { 1820 if (log) 1821 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " returned NULL", __FUNCTION__, reg_index); 1822 return SendErrorResponse (0x48); 1823 } 1824 1825 // Return the end of registers response if we've iterated one past the end of the register set. 1826 if (reg_index >= reg_context_sp->GetUserRegisterCount ()) 1827 { 1828 if (log) 1829 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetUserRegisterCount ()); 1830 return SendErrorResponse (0x47); 1831 } 1832 1833 if (reg_size != reg_info->byte_size) 1834 { 1835 return SendIllFormedResponse (packet, "P packet register size is incorrect"); 1836 } 1837 1838 // Build the reginfos response. 1839 StreamGDBRemote response; 1840 1841 RegisterValue reg_value (reg_bytes, reg_size, process_arch.GetByteOrder ()); 1842 Error error = reg_context_sp->WriteRegister (reg_info, reg_value); 1843 if (error.Fail ()) 1844 { 1845 if (log) 1846 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, write of requested register %" PRIu32 " (%s) failed: %s", __FUNCTION__, reg_index, reg_info->name, error.AsCString ()); 1847 return SendErrorResponse (0x32); 1848 } 1849 1850 return SendOKResponse(); 1851 } 1852 1853 GDBRemoteCommunication::PacketResult 1854 GDBRemoteCommunicationServerLLGS::Handle_H (StringExtractorGDBRemote &packet) 1855 { 1856 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1857 1858 // Fail if we don't have a current process. 1859 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1860 { 1861 if (log) 1862 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 1863 return SendErrorResponse (0x15); 1864 } 1865 1866 // Parse out which variant of $H is requested. 1867 packet.SetFilePos (strlen("H")); 1868 if (packet.GetBytesLeft () < 1) 1869 { 1870 if (log) 1871 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, H command missing {g,c} variant", __FUNCTION__); 1872 return SendIllFormedResponse (packet, "H command missing {g,c} variant"); 1873 } 1874 1875 const char h_variant = packet.GetChar (); 1876 switch (h_variant) 1877 { 1878 case 'g': 1879 break; 1880 1881 case 'c': 1882 break; 1883 1884 default: 1885 if (log) 1886 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c", __FUNCTION__, h_variant); 1887 return SendIllFormedResponse (packet, "H variant unsupported, should be c or g"); 1888 } 1889 1890 // Parse out the thread number. 1891 // FIXME return a parse success/fail value. All values are valid here. 1892 const lldb::tid_t tid = packet.GetHexMaxU64 (false, std::numeric_limits<lldb::tid_t>::max ()); 1893 1894 // Ensure we have the given thread when not specifying -1 (all threads) or 0 (any thread). 1895 if (tid != LLDB_INVALID_THREAD_ID && tid != 0) 1896 { 1897 NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadByID (tid)); 1898 if (!thread_sp) 1899 { 1900 if (log) 1901 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64 " not found", __FUNCTION__, tid); 1902 return SendErrorResponse (0x15); 1903 } 1904 } 1905 1906 // Now switch the given thread type. 1907 switch (h_variant) 1908 { 1909 case 'g': 1910 SetCurrentThreadID (tid); 1911 break; 1912 1913 case 'c': 1914 SetContinueThreadID (tid); 1915 break; 1916 1917 default: 1918 assert (false && "unsupported $H variant - shouldn't get here"); 1919 return SendIllFormedResponse (packet, "H variant unsupported, should be c or g"); 1920 } 1921 1922 return SendOKResponse(); 1923 } 1924 1925 GDBRemoteCommunication::PacketResult 1926 GDBRemoteCommunicationServerLLGS::Handle_I (StringExtractorGDBRemote &packet) 1927 { 1928 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 1929 1930 // Fail if we don't have a current process. 1931 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1932 { 1933 if (log) 1934 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 1935 return SendErrorResponse (0x15); 1936 } 1937 1938 packet.SetFilePos (::strlen("I")); 1939 char tmp[4096]; 1940 for (;;) 1941 { 1942 size_t read = packet.GetHexBytesAvail(tmp, sizeof(tmp)); 1943 if (read == 0) 1944 { 1945 break; 1946 } 1947 // write directly to stdin *this might block if stdin buffer is full* 1948 // TODO: enqueue this block in circular buffer and send window size to remote host 1949 ConnectionStatus status; 1950 Error error; 1951 m_stdio_communication.Write(tmp, read, status, &error); 1952 if (error.Fail()) 1953 { 1954 return SendErrorResponse (0x15); 1955 } 1956 } 1957 1958 return SendOKResponse(); 1959 } 1960 1961 GDBRemoteCommunication::PacketResult 1962 GDBRemoteCommunicationServerLLGS::Handle_interrupt (StringExtractorGDBRemote &packet) 1963 { 1964 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 1965 1966 // Fail if we don't have a current process. 1967 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 1968 { 1969 if (log) 1970 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 1971 return SendErrorResponse (0x15); 1972 } 1973 1974 // Interrupt the process. 1975 Error error = m_debugged_process_sp->Interrupt (); 1976 if (error.Fail ()) 1977 { 1978 if (log) 1979 { 1980 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed for process %" PRIu64 ": %s", 1981 __FUNCTION__, 1982 m_debugged_process_sp->GetID (), 1983 error.AsCString ()); 1984 } 1985 return SendErrorResponse (GDBRemoteServerError::eErrorResume); 1986 } 1987 1988 if (log) 1989 log->Printf ("GDBRemoteCommunicationServerLLGS::%s stopped process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ()); 1990 1991 // No response required from stop all. 1992 return PacketResult::Success; 1993 } 1994 1995 GDBRemoteCommunication::PacketResult 1996 GDBRemoteCommunicationServerLLGS::Handle_memory_read(StringExtractorGDBRemote &packet) 1997 { 1998 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 1999 2000 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2001 { 2002 if (log) 2003 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2004 return SendErrorResponse (0x15); 2005 } 2006 2007 // Parse out the memory address. 2008 packet.SetFilePos (strlen("m")); 2009 if (packet.GetBytesLeft() < 1) 2010 return SendIllFormedResponse(packet, "Too short m packet"); 2011 2012 // Read the address. Punting on validation. 2013 // FIXME replace with Hex U64 read with no default value that fails on failed read. 2014 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2015 2016 // Validate comma. 2017 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2018 return SendIllFormedResponse(packet, "Comma sep missing in m packet"); 2019 2020 // Get # bytes to read. 2021 if (packet.GetBytesLeft() < 1) 2022 return SendIllFormedResponse(packet, "Length missing in m packet"); 2023 2024 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2025 if (byte_count == 0) 2026 { 2027 if (log) 2028 log->Printf ("GDBRemoteCommunicationServerLLGS::%s nothing to read: zero-length packet", __FUNCTION__); 2029 return SendOKResponse(); 2030 } 2031 2032 // Allocate the response buffer. 2033 std::string buf(byte_count, '\0'); 2034 if (buf.empty()) 2035 return SendErrorResponse (0x78); 2036 2037 2038 // Retrieve the process memory. 2039 size_t bytes_read = 0; 2040 Error error = m_debugged_process_sp->ReadMemoryWithoutTrap(read_addr, &buf[0], byte_count, bytes_read); 2041 if (error.Fail ()) 2042 { 2043 if (log) 2044 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to read. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, error.AsCString ()); 2045 return SendErrorResponse (0x08); 2046 } 2047 2048 if (bytes_read == 0) 2049 { 2050 if (log) 2051 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, byte_count); 2052 return SendErrorResponse (0x08); 2053 } 2054 2055 StreamGDBRemote response; 2056 packet.SetFilePos(0); 2057 char kind = packet.GetChar('?'); 2058 if (kind == 'x') 2059 response.PutEscapedBytes(buf.data(), byte_count); 2060 else 2061 { 2062 assert(kind == 'm'); 2063 for (size_t i = 0; i < bytes_read; ++i) 2064 response.PutHex8(buf[i]); 2065 } 2066 2067 return SendPacketNoLock(response.GetData(), response.GetSize()); 2068 } 2069 2070 GDBRemoteCommunication::PacketResult 2071 GDBRemoteCommunicationServerLLGS::Handle_M (StringExtractorGDBRemote &packet) 2072 { 2073 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2074 2075 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2076 { 2077 if (log) 2078 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2079 return SendErrorResponse (0x15); 2080 } 2081 2082 // Parse out the memory address. 2083 packet.SetFilePos (strlen("M")); 2084 if (packet.GetBytesLeft() < 1) 2085 return SendIllFormedResponse(packet, "Too short M packet"); 2086 2087 // Read the address. Punting on validation. 2088 // FIXME replace with Hex U64 read with no default value that fails on failed read. 2089 const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0); 2090 2091 // Validate comma. 2092 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ',')) 2093 return SendIllFormedResponse(packet, "Comma sep missing in M packet"); 2094 2095 // Get # bytes to read. 2096 if (packet.GetBytesLeft() < 1) 2097 return SendIllFormedResponse(packet, "Length missing in M packet"); 2098 2099 const uint64_t byte_count = packet.GetHexMaxU64(false, 0); 2100 if (byte_count == 0) 2101 { 2102 if (log) 2103 log->Printf ("GDBRemoteCommunicationServerLLGS::%s nothing to write: zero-length packet", __FUNCTION__); 2104 return PacketResult::Success; 2105 } 2106 2107 // Validate colon. 2108 if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':')) 2109 return SendIllFormedResponse(packet, "Comma sep missing in M packet after byte length"); 2110 2111 // Allocate the conversion buffer. 2112 std::vector<uint8_t> buf(byte_count, 0); 2113 if (buf.empty()) 2114 return SendErrorResponse (0x78); 2115 2116 // Convert the hex memory write contents to bytes. 2117 StreamGDBRemote response; 2118 const uint64_t convert_count = packet.GetHexBytes(&buf[0], byte_count, 0); 2119 if (convert_count != byte_count) 2120 { 2121 if (log) 2122 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": asked to write %" PRIu64 " bytes, but only found %" PRIu64 " to convert.", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, byte_count, convert_count); 2123 return SendIllFormedResponse (packet, "M content byte length specified did not match hex-encoded content length"); 2124 } 2125 2126 // Write the process memory. 2127 size_t bytes_written = 0; 2128 Error error = m_debugged_process_sp->WriteMemory (write_addr, &buf[0], byte_count, bytes_written); 2129 if (error.Fail ()) 2130 { 2131 if (log) 2132 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to write. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, error.AsCString ()); 2133 return SendErrorResponse (0x09); 2134 } 2135 2136 if (bytes_written == 0) 2137 { 2138 if (log) 2139 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": wrote 0 of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, byte_count); 2140 return SendErrorResponse (0x09); 2141 } 2142 2143 return SendOKResponse (); 2144 } 2145 2146 GDBRemoteCommunication::PacketResult 2147 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported (StringExtractorGDBRemote &packet) 2148 { 2149 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2150 2151 // Currently only the NativeProcessProtocol knows if it can handle a qMemoryRegionInfoSupported 2152 // request, but we're not guaranteed to be attached to a process. For now we'll assume the 2153 // client only asks this when a process is being debugged. 2154 2155 // Ensure we have a process running; otherwise, we can't figure this out 2156 // since we won't have a NativeProcessProtocol. 2157 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2158 { 2159 if (log) 2160 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2161 return SendErrorResponse (0x15); 2162 } 2163 2164 // Test if we can get any region back when asking for the region around NULL. 2165 MemoryRegionInfo region_info; 2166 const Error error = m_debugged_process_sp->GetMemoryRegionInfo (0, region_info); 2167 if (error.Fail ()) 2168 { 2169 // We don't support memory region info collection for this NativeProcessProtocol. 2170 return SendUnimplementedResponse (""); 2171 } 2172 2173 return SendOKResponse(); 2174 } 2175 2176 GDBRemoteCommunication::PacketResult 2177 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo (StringExtractorGDBRemote &packet) 2178 { 2179 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2180 2181 // Ensure we have a process. 2182 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2183 { 2184 if (log) 2185 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2186 return SendErrorResponse (0x15); 2187 } 2188 2189 // Parse out the memory address. 2190 packet.SetFilePos (strlen("qMemoryRegionInfo:")); 2191 if (packet.GetBytesLeft() < 1) 2192 return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet"); 2193 2194 // Read the address. Punting on validation. 2195 const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0); 2196 2197 StreamGDBRemote response; 2198 2199 // Get the memory region info for the target address. 2200 MemoryRegionInfo region_info; 2201 const Error error = m_debugged_process_sp->GetMemoryRegionInfo (read_addr, region_info); 2202 if (error.Fail ()) 2203 { 2204 // Return the error message. 2205 2206 response.PutCString ("error:"); 2207 response.PutCStringAsRawHex8 (error.AsCString ()); 2208 response.PutChar (';'); 2209 } 2210 else 2211 { 2212 // Range start and size. 2213 response.Printf ("start:%" PRIx64 ";size:%" PRIx64 ";", region_info.GetRange ().GetRangeBase (), region_info.GetRange ().GetByteSize ()); 2214 2215 // Permissions. 2216 if (region_info.GetReadable () || 2217 region_info.GetWritable () || 2218 region_info.GetExecutable ()) 2219 { 2220 // Write permissions info. 2221 response.PutCString ("permissions:"); 2222 2223 if (region_info.GetReadable ()) 2224 response.PutChar ('r'); 2225 if (region_info.GetWritable ()) 2226 response.PutChar('w'); 2227 if (region_info.GetExecutable()) 2228 response.PutChar ('x'); 2229 2230 response.PutChar (';'); 2231 } 2232 } 2233 2234 return SendPacketNoLock(response.GetData(), response.GetSize()); 2235 } 2236 2237 GDBRemoteCommunication::PacketResult 2238 GDBRemoteCommunicationServerLLGS::Handle_Z (StringExtractorGDBRemote &packet) 2239 { 2240 // Ensure we have a process. 2241 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2242 { 2243 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2244 if (log) 2245 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2246 return SendErrorResponse (0x15); 2247 } 2248 2249 // Parse out software or hardware breakpoint or watchpoint requested. 2250 packet.SetFilePos (strlen("Z")); 2251 if (packet.GetBytesLeft() < 1) 2252 return SendIllFormedResponse(packet, "Too short Z packet, missing software/hardware specifier"); 2253 2254 bool want_breakpoint = true; 2255 bool want_hardware = false; 2256 uint32_t watch_flags = 0; 2257 2258 const GDBStoppointType stoppoint_type = 2259 GDBStoppointType(packet.GetS32 (eStoppointInvalid)); 2260 switch (stoppoint_type) 2261 { 2262 case eBreakpointSoftware: 2263 want_hardware = false; want_breakpoint = true; break; 2264 case eBreakpointHardware: 2265 want_hardware = true; want_breakpoint = true; break; 2266 case eWatchpointWrite: 2267 watch_flags = 1; 2268 want_hardware = true; want_breakpoint = false; break; 2269 case eWatchpointRead: 2270 watch_flags = 2; 2271 want_hardware = true; want_breakpoint = false; break; 2272 case eWatchpointReadWrite: 2273 watch_flags = 3; 2274 want_hardware = true; want_breakpoint = false; break; 2275 case eStoppointInvalid: 2276 return SendIllFormedResponse(packet, "Z packet had invalid software/hardware specifier"); 2277 2278 } 2279 2280 if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',') 2281 return SendIllFormedResponse(packet, "Malformed Z packet, expecting comma after stoppoint type"); 2282 2283 // Parse out the stoppoint address. 2284 if (packet.GetBytesLeft() < 1) 2285 return SendIllFormedResponse(packet, "Too short Z packet, missing address"); 2286 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2287 2288 if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',') 2289 return SendIllFormedResponse(packet, "Malformed Z packet, expecting comma after address"); 2290 2291 // Parse out the stoppoint size (i.e. size hint for opcode size). 2292 const uint32_t size = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ()); 2293 if (size == std::numeric_limits<uint32_t>::max ()) 2294 return SendIllFormedResponse(packet, "Malformed Z packet, failed to parse size argument"); 2295 2296 if (want_breakpoint) 2297 { 2298 // Try to set the breakpoint. 2299 const Error error = m_debugged_process_sp->SetBreakpoint (addr, size, want_hardware); 2300 if (error.Success ()) 2301 return SendOKResponse (); 2302 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 2303 if (log) 2304 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2305 " failed to set breakpoint: %s", 2306 __FUNCTION__, 2307 m_debugged_process_sp->GetID (), 2308 error.AsCString ()); 2309 return SendErrorResponse (0x09); 2310 } 2311 else 2312 { 2313 // Try to set the watchpoint. 2314 const Error error = m_debugged_process_sp->SetWatchpoint ( 2315 addr, size, watch_flags, want_hardware); 2316 if (error.Success ()) 2317 return SendOKResponse (); 2318 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 2319 if (log) 2320 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2321 " failed to set watchpoint: %s", 2322 __FUNCTION__, 2323 m_debugged_process_sp->GetID (), 2324 error.AsCString ()); 2325 return SendErrorResponse (0x09); 2326 } 2327 } 2328 2329 GDBRemoteCommunication::PacketResult 2330 GDBRemoteCommunicationServerLLGS::Handle_z (StringExtractorGDBRemote &packet) 2331 { 2332 // Ensure we have a process. 2333 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2334 { 2335 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2336 if (log) 2337 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2338 return SendErrorResponse (0x15); 2339 } 2340 2341 // Parse out software or hardware breakpoint or watchpoint requested. 2342 packet.SetFilePos (strlen("z")); 2343 if (packet.GetBytesLeft() < 1) 2344 return SendIllFormedResponse(packet, "Too short z packet, missing software/hardware specifier"); 2345 2346 bool want_breakpoint = true; 2347 2348 const GDBStoppointType stoppoint_type = 2349 GDBStoppointType(packet.GetS32 (eStoppointInvalid)); 2350 switch (stoppoint_type) 2351 { 2352 case eBreakpointHardware: want_breakpoint = true; break; 2353 case eBreakpointSoftware: want_breakpoint = true; break; 2354 case eWatchpointWrite: want_breakpoint = false; break; 2355 case eWatchpointRead: want_breakpoint = false; break; 2356 case eWatchpointReadWrite: want_breakpoint = false; break; 2357 default: 2358 return SendIllFormedResponse(packet, "z packet had invalid software/hardware specifier"); 2359 2360 } 2361 2362 if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',') 2363 return SendIllFormedResponse(packet, "Malformed z packet, expecting comma after stoppoint type"); 2364 2365 // Parse out the stoppoint address. 2366 if (packet.GetBytesLeft() < 1) 2367 return SendIllFormedResponse(packet, "Too short z packet, missing address"); 2368 const lldb::addr_t addr = packet.GetHexMaxU64(false, 0); 2369 2370 if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',') 2371 return SendIllFormedResponse(packet, "Malformed z packet, expecting comma after address"); 2372 2373 /* 2374 // Parse out the stoppoint size (i.e. size hint for opcode size). 2375 const uint32_t size = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ()); 2376 if (size == std::numeric_limits<uint32_t>::max ()) 2377 return SendIllFormedResponse(packet, "Malformed z packet, failed to parse size argument"); 2378 */ 2379 2380 if (want_breakpoint) 2381 { 2382 // Try to clear the breakpoint. 2383 const Error error = m_debugged_process_sp->RemoveBreakpoint (addr); 2384 if (error.Success ()) 2385 return SendOKResponse (); 2386 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 2387 if (log) 2388 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2389 " failed to remove breakpoint: %s", 2390 __FUNCTION__, 2391 m_debugged_process_sp->GetID (), 2392 error.AsCString ()); 2393 return SendErrorResponse (0x09); 2394 } 2395 else 2396 { 2397 // Try to clear the watchpoint. 2398 const Error error = m_debugged_process_sp->RemoveWatchpoint (addr); 2399 if (error.Success ()) 2400 return SendOKResponse (); 2401 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS)); 2402 if (log) 2403 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 2404 " failed to remove watchpoint: %s", 2405 __FUNCTION__, 2406 m_debugged_process_sp->GetID (), 2407 error.AsCString ()); 2408 return SendErrorResponse (0x09); 2409 } 2410 } 2411 2412 GDBRemoteCommunication::PacketResult 2413 GDBRemoteCommunicationServerLLGS::Handle_s (StringExtractorGDBRemote &packet) 2414 { 2415 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD)); 2416 2417 // Ensure we have a process. 2418 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2419 { 2420 if (log) 2421 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2422 return SendErrorResponse (0x32); 2423 } 2424 2425 // We first try to use a continue thread id. If any one or any all set, use the current thread. 2426 // Bail out if we don't have a thread id. 2427 lldb::tid_t tid = GetContinueThreadID (); 2428 if (tid == 0 || tid == LLDB_INVALID_THREAD_ID) 2429 tid = GetCurrentThreadID (); 2430 if (tid == LLDB_INVALID_THREAD_ID) 2431 return SendErrorResponse (0x33); 2432 2433 // Double check that we have such a thread. 2434 // TODO investigate: on MacOSX we might need to do an UpdateThreads () here. 2435 NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetThreadByID (tid); 2436 if (!thread_sp || thread_sp->GetID () != tid) 2437 return SendErrorResponse (0x33); 2438 2439 // Create the step action for the given thread. 2440 ResumeAction action = { tid, eStateStepping, 0 }; 2441 2442 // Setup the actions list. 2443 ResumeActionList actions; 2444 actions.Append (action); 2445 2446 // All other threads stop while we're single stepping a thread. 2447 actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0); 2448 Error error = m_debugged_process_sp->Resume (actions); 2449 if (error.Fail ()) 2450 { 2451 if (log) 2452 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " Resume() failed with error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), tid, error.AsCString ()); 2453 return SendErrorResponse(0x49); 2454 } 2455 2456 // No response here - the stop or exit will come from the resulting action. 2457 return PacketResult::Success; 2458 } 2459 2460 GDBRemoteCommunication::PacketResult 2461 GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read (StringExtractorGDBRemote &packet) 2462 { 2463 // *BSD impls should be able to do this too. 2464 #if defined(__linux__) 2465 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2466 2467 // Parse out the offset. 2468 packet.SetFilePos (strlen("qXfer:auxv:read::")); 2469 if (packet.GetBytesLeft () < 1) 2470 return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing offset"); 2471 2472 const uint64_t auxv_offset = packet.GetHexMaxU64 (false, std::numeric_limits<uint64_t>::max ()); 2473 if (auxv_offset == std::numeric_limits<uint64_t>::max ()) 2474 return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing offset"); 2475 2476 // Parse out comma. 2477 if (packet.GetBytesLeft () < 1 || packet.GetChar () != ',') 2478 return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing comma after offset"); 2479 2480 // Parse out the length. 2481 const uint64_t auxv_length = packet.GetHexMaxU64 (false, std::numeric_limits<uint64_t>::max ()); 2482 if (auxv_length == std::numeric_limits<uint64_t>::max ()) 2483 return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing length"); 2484 2485 // Grab the auxv data if we need it. 2486 if (!m_active_auxv_buffer_sp) 2487 { 2488 // Make sure we have a valid process. 2489 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2490 { 2491 if (log) 2492 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2493 return SendErrorResponse (0x10); 2494 } 2495 2496 // Grab the auxv data. 2497 m_active_auxv_buffer_sp = Host::GetAuxvData (m_debugged_process_sp->GetID ()); 2498 if (!m_active_auxv_buffer_sp || m_active_auxv_buffer_sp->GetByteSize () == 0) 2499 { 2500 // Hmm, no auxv data, call that an error. 2501 if (log) 2502 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no auxv data retrieved", __FUNCTION__); 2503 m_active_auxv_buffer_sp.reset (); 2504 return SendErrorResponse (0x11); 2505 } 2506 } 2507 2508 // FIXME find out if/how I lock the stream here. 2509 2510 StreamGDBRemote response; 2511 bool done_with_buffer = false; 2512 2513 if (auxv_offset >= m_active_auxv_buffer_sp->GetByteSize ()) 2514 { 2515 // We have nothing left to send. Mark the buffer as complete. 2516 response.PutChar ('l'); 2517 done_with_buffer = true; 2518 } 2519 else 2520 { 2521 // Figure out how many bytes are available starting at the given offset. 2522 const uint64_t bytes_remaining = m_active_auxv_buffer_sp->GetByteSize () - auxv_offset; 2523 2524 // Figure out how many bytes we're going to read. 2525 const uint64_t bytes_to_read = (auxv_length > bytes_remaining) ? bytes_remaining : auxv_length; 2526 2527 // Mark the response type according to whether we're reading the remainder of the auxv data. 2528 if (bytes_to_read >= bytes_remaining) 2529 { 2530 // There will be nothing left to read after this 2531 response.PutChar ('l'); 2532 done_with_buffer = true; 2533 } 2534 else 2535 { 2536 // There will still be bytes to read after this request. 2537 response.PutChar ('m'); 2538 } 2539 2540 // Now write the data in encoded binary form. 2541 response.PutEscapedBytes (m_active_auxv_buffer_sp->GetBytes () + auxv_offset, bytes_to_read); 2542 } 2543 2544 if (done_with_buffer) 2545 m_active_auxv_buffer_sp.reset (); 2546 2547 return SendPacketNoLock(response.GetData(), response.GetSize()); 2548 #else 2549 return SendUnimplementedResponse ("not implemented on this platform"); 2550 #endif 2551 } 2552 2553 GDBRemoteCommunication::PacketResult 2554 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState (StringExtractorGDBRemote &packet) 2555 { 2556 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2557 2558 // Move past packet name. 2559 packet.SetFilePos (strlen ("QSaveRegisterState")); 2560 2561 // Get the thread to use. 2562 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet); 2563 if (!thread_sp) 2564 { 2565 if (m_thread_suffix_supported) 2566 return SendIllFormedResponse (packet, "No thread specified in QSaveRegisterState packet"); 2567 else 2568 return SendIllFormedResponse (packet, "No thread was is set with the Hg packet"); 2569 } 2570 2571 // Grab the register context for the thread. 2572 NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ()); 2573 if (!reg_context_sp) 2574 { 2575 if (log) 2576 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ()); 2577 return SendErrorResponse (0x15); 2578 } 2579 2580 // Save registers to a buffer. 2581 DataBufferSP register_data_sp; 2582 Error error = reg_context_sp->ReadAllRegisterValues (register_data_sp); 2583 if (error.Fail ()) 2584 { 2585 if (log) 2586 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " failed to save all register values: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ()); 2587 return SendErrorResponse (0x75); 2588 } 2589 2590 // Allocate a new save id. 2591 const uint32_t save_id = GetNextSavedRegistersID (); 2592 assert ((m_saved_registers_map.find (save_id) == m_saved_registers_map.end ()) && "GetNextRegisterSaveID() returned an existing register save id"); 2593 2594 // Save the register data buffer under the save id. 2595 { 2596 Mutex::Locker locker (m_saved_registers_mutex); 2597 m_saved_registers_map[save_id] = register_data_sp; 2598 } 2599 2600 // Write the response. 2601 StreamGDBRemote response; 2602 response.Printf ("%" PRIu32, save_id); 2603 return SendPacketNoLock(response.GetData(), response.GetSize()); 2604 } 2605 2606 GDBRemoteCommunication::PacketResult 2607 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState (StringExtractorGDBRemote &packet) 2608 { 2609 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2610 2611 // Parse out save id. 2612 packet.SetFilePos (strlen ("QRestoreRegisterState:")); 2613 if (packet.GetBytesLeft () < 1) 2614 return SendIllFormedResponse (packet, "QRestoreRegisterState packet missing register save id"); 2615 2616 const uint32_t save_id = packet.GetU32 (0); 2617 if (save_id == 0) 2618 { 2619 if (log) 2620 log->Printf ("GDBRemoteCommunicationServerLLGS::%s QRestoreRegisterState packet has malformed save id, expecting decimal uint32_t", __FUNCTION__); 2621 return SendErrorResponse (0x76); 2622 } 2623 2624 // Get the thread to use. 2625 NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet); 2626 if (!thread_sp) 2627 { 2628 if (m_thread_suffix_supported) 2629 return SendIllFormedResponse (packet, "No thread specified in QRestoreRegisterState packet"); 2630 else 2631 return SendIllFormedResponse (packet, "No thread was is set with the Hg packet"); 2632 } 2633 2634 // Grab the register context for the thread. 2635 NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ()); 2636 if (!reg_context_sp) 2637 { 2638 if (log) 2639 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ()); 2640 return SendErrorResponse (0x15); 2641 } 2642 2643 // Retrieve register state buffer, then remove from the list. 2644 DataBufferSP register_data_sp; 2645 { 2646 Mutex::Locker locker (m_saved_registers_mutex); 2647 2648 // Find the register set buffer for the given save id. 2649 auto it = m_saved_registers_map.find (save_id); 2650 if (it == m_saved_registers_map.end ()) 2651 { 2652 if (log) 2653 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " does not have a register set save buffer for id %" PRIu32, __FUNCTION__, m_debugged_process_sp->GetID (), save_id); 2654 return SendErrorResponse (0x77); 2655 } 2656 register_data_sp = it->second; 2657 2658 // Remove it from the map. 2659 m_saved_registers_map.erase (it); 2660 } 2661 2662 Error error = reg_context_sp->WriteAllRegisterValues (register_data_sp); 2663 if (error.Fail ()) 2664 { 2665 if (log) 2666 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " failed to restore all register values: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ()); 2667 return SendErrorResponse (0x77); 2668 } 2669 2670 return SendOKResponse(); 2671 } 2672 2673 GDBRemoteCommunication::PacketResult 2674 GDBRemoteCommunicationServerLLGS::Handle_vAttach (StringExtractorGDBRemote &packet) 2675 { 2676 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2677 2678 // Consume the ';' after vAttach. 2679 packet.SetFilePos (strlen ("vAttach")); 2680 if (!packet.GetBytesLeft () || packet.GetChar () != ';') 2681 return SendIllFormedResponse (packet, "vAttach missing expected ';'"); 2682 2683 // Grab the PID to which we will attach (assume hex encoding). 2684 lldb::pid_t pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID, 16); 2685 if (pid == LLDB_INVALID_PROCESS_ID) 2686 return SendIllFormedResponse (packet, "vAttach failed to parse the process id"); 2687 2688 // Attempt to attach. 2689 if (log) 2690 log->Printf ("GDBRemoteCommunicationServerLLGS::%s attempting to attach to pid %" PRIu64, __FUNCTION__, pid); 2691 2692 Error error = AttachToProcess (pid); 2693 2694 if (error.Fail ()) 2695 { 2696 if (log) 2697 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to attach to pid %" PRIu64 ": %s\n", __FUNCTION__, pid, error.AsCString()); 2698 return SendErrorResponse (0x01); 2699 } 2700 2701 // Notify we attached by sending a stop packet. 2702 return SendStopReasonForState (m_debugged_process_sp->GetState ()); 2703 } 2704 2705 GDBRemoteCommunication::PacketResult 2706 GDBRemoteCommunicationServerLLGS::Handle_D (StringExtractorGDBRemote &packet) 2707 { 2708 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS)); 2709 2710 StopSTDIOForwarding(); 2711 2712 // Fail if we don't have a current process. 2713 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2714 { 2715 if (log) 2716 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__); 2717 return SendErrorResponse (0x15); 2718 } 2719 2720 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 2721 2722 // Consume the ';' after D. 2723 packet.SetFilePos (1); 2724 if (packet.GetBytesLeft ()) 2725 { 2726 if (packet.GetChar () != ';') 2727 return SendIllFormedResponse (packet, "D missing expected ';'"); 2728 2729 // Grab the PID from which we will detach (assume hex encoding). 2730 pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID, 16); 2731 if (pid == LLDB_INVALID_PROCESS_ID) 2732 return SendIllFormedResponse (packet, "D failed to parse the process id"); 2733 } 2734 2735 if (pid != LLDB_INVALID_PROCESS_ID && 2736 m_debugged_process_sp->GetID () != pid) 2737 { 2738 return SendIllFormedResponse (packet, "Invalid pid"); 2739 } 2740 2741 const Error error = m_debugged_process_sp->Detach (); 2742 if (error.Fail ()) 2743 { 2744 if (log) 2745 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to detach from pid %" PRIu64 ": %s\n", 2746 __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ()); 2747 return SendErrorResponse (0x01); 2748 } 2749 2750 return SendOKResponse (); 2751 } 2752 2753 GDBRemoteCommunication::PacketResult 2754 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo (StringExtractorGDBRemote &packet) 2755 { 2756 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2757 2758 packet.SetFilePos (strlen("qThreadStopInfo")); 2759 const lldb::tid_t tid = packet.GetHexMaxU32 (false, LLDB_INVALID_THREAD_ID); 2760 if (tid == LLDB_INVALID_THREAD_ID) 2761 { 2762 if (log) 2763 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse thread id from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ()); 2764 return SendErrorResponse (0x15); 2765 } 2766 return SendStopReplyPacketForThread (tid); 2767 } 2768 2769 GDBRemoteCommunication::PacketResult 2770 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo (StringExtractorGDBRemote &) 2771 { 2772 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD)); 2773 2774 // Ensure we have a debugged process. 2775 if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)) 2776 return SendErrorResponse (50); 2777 2778 if (log) 2779 log->Printf ("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64, 2780 __FUNCTION__, m_debugged_process_sp->GetID()); 2781 2782 2783 StreamString response; 2784 const bool threads_with_valid_stop_info_only = false; 2785 JSONArray::SP threads_array_sp = GetJSONThreadsInfo(*m_debugged_process_sp, 2786 threads_with_valid_stop_info_only); 2787 if (! threads_array_sp) 2788 { 2789 if (log) 2790 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to prepare a packet for pid %" PRIu64, 2791 __FUNCTION__, m_debugged_process_sp->GetID()); 2792 return SendErrorResponse(52); 2793 } 2794 2795 threads_array_sp->Write(response); 2796 StreamGDBRemote escaped_response; 2797 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 2798 return SendPacketNoLock (escaped_response.GetData(), escaped_response.GetSize()); 2799 } 2800 2801 GDBRemoteCommunication::PacketResult 2802 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo (StringExtractorGDBRemote &packet) 2803 { 2804 // Fail if we don't have a current process. 2805 if (!m_debugged_process_sp || 2806 m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID) 2807 return SendErrorResponse (68); 2808 2809 packet.SetFilePos(strlen("qWatchpointSupportInfo")); 2810 if (packet.GetBytesLeft() == 0) 2811 return SendOKResponse(); 2812 if (packet.GetChar() != ':') 2813 return SendErrorResponse(67); 2814 2815 uint32_t num = m_debugged_process_sp->GetMaxWatchpoints(); 2816 StreamGDBRemote response; 2817 response.Printf ("num:%d;", num); 2818 return SendPacketNoLock(response.GetData(), response.GetSize()); 2819 } 2820 2821 GDBRemoteCommunication::PacketResult 2822 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress (StringExtractorGDBRemote &packet) 2823 { 2824 // Fail if we don't have a current process. 2825 if (!m_debugged_process_sp || 2826 m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID) 2827 return SendErrorResponse(67); 2828 2829 packet.SetFilePos(strlen("qFileLoadAddress:")); 2830 if (packet.GetBytesLeft() == 0) 2831 return SendErrorResponse(68); 2832 2833 std::string file_name; 2834 packet.GetHexByteString(file_name); 2835 2836 lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS; 2837 Error error = m_debugged_process_sp->GetFileLoadAddress(file_name, file_load_address); 2838 if (error.Fail()) 2839 return SendErrorResponse(69); 2840 2841 if (file_load_address == LLDB_INVALID_ADDRESS) 2842 return SendErrorResponse(1); // File not loaded 2843 2844 StreamGDBRemote response; 2845 response.PutHex64(file_load_address); 2846 return SendPacketNoLock(response.GetData(), response.GetSize()); 2847 } 2848 2849 void 2850 GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection () 2851 { 2852 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); 2853 2854 // Tell the stdio connection to shut down. 2855 if (m_stdio_communication.IsConnected()) 2856 { 2857 auto connection = m_stdio_communication.GetConnection(); 2858 if (connection) 2859 { 2860 Error error; 2861 connection->Disconnect (&error); 2862 2863 if (error.Success ()) 2864 { 2865 if (log) 2866 log->Printf ("GDBRemoteCommunicationServerLLGS::%s disconnect process terminal stdio - SUCCESS", __FUNCTION__); 2867 } 2868 else 2869 { 2870 if (log) 2871 log->Printf ("GDBRemoteCommunicationServerLLGS::%s disconnect process terminal stdio - FAIL: %s", __FUNCTION__, error.AsCString ()); 2872 } 2873 } 2874 } 2875 } 2876 2877 2878 NativeThreadProtocolSP 2879 GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix (StringExtractorGDBRemote &packet) 2880 { 2881 NativeThreadProtocolSP thread_sp; 2882 2883 // We have no thread if we don't have a process. 2884 if (!m_debugged_process_sp || m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID) 2885 return thread_sp; 2886 2887 // If the client hasn't asked for thread suffix support, there will not be a thread suffix. 2888 // Use the current thread in that case. 2889 if (!m_thread_suffix_supported) 2890 { 2891 const lldb::tid_t current_tid = GetCurrentThreadID (); 2892 if (current_tid == LLDB_INVALID_THREAD_ID) 2893 return thread_sp; 2894 else if (current_tid == 0) 2895 { 2896 // Pick a thread. 2897 return m_debugged_process_sp->GetThreadAtIndex (0); 2898 } 2899 else 2900 return m_debugged_process_sp->GetThreadByID (current_tid); 2901 } 2902 2903 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD)); 2904 2905 // Parse out the ';'. 2906 if (packet.GetBytesLeft () < 1 || packet.GetChar () != ';') 2907 { 2908 if (log) 2909 log->Printf ("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected ';' prior to start of thread suffix: packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ()); 2910 return thread_sp; 2911 } 2912 2913 if (!packet.GetBytesLeft ()) 2914 return thread_sp; 2915 2916 // Parse out thread: portion. 2917 if (strncmp (packet.Peek (), "thread:", strlen("thread:")) != 0) 2918 { 2919 if (log) 2920 log->Printf ("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected 'thread:' but not found, packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ()); 2921 return thread_sp; 2922 } 2923 packet.SetFilePos (packet.GetFilePos () + strlen("thread:")); 2924 const lldb::tid_t tid = packet.GetHexMaxU64(false, 0); 2925 if (tid != 0) 2926 return m_debugged_process_sp->GetThreadByID (tid); 2927 2928 return thread_sp; 2929 } 2930 2931 lldb::tid_t 2932 GDBRemoteCommunicationServerLLGS::GetCurrentThreadID () const 2933 { 2934 if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) 2935 { 2936 // Use whatever the debug process says is the current thread id 2937 // since the protocol either didn't specify or specified we want 2938 // any/all threads marked as the current thread. 2939 if (!m_debugged_process_sp) 2940 return LLDB_INVALID_THREAD_ID; 2941 return m_debugged_process_sp->GetCurrentThreadID (); 2942 } 2943 // Use the specific current thread id set by the gdb remote protocol. 2944 return m_current_tid; 2945 } 2946 2947 uint32_t 2948 GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID () 2949 { 2950 Mutex::Locker locker (m_saved_registers_mutex); 2951 return m_next_saved_registers_id++; 2952 } 2953 2954 void 2955 GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData () 2956 { 2957 Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|GDBR_LOG_PROCESS)); 2958 if (log) 2959 log->Printf ("GDBRemoteCommunicationServerLLGS::%s()", __FUNCTION__); 2960 2961 // Clear any auxv cached data. 2962 // *BSD impls should be able to do this too. 2963 #if defined(__linux__) 2964 if (log) 2965 log->Printf ("GDBRemoteCommunicationServerLLGS::%s clearing auxv buffer (previously %s)", 2966 __FUNCTION__, 2967 m_active_auxv_buffer_sp ? "was set" : "was not set"); 2968 m_active_auxv_buffer_sp.reset (); 2969 #endif 2970 } 2971 2972 FileSpec 2973 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string& module_path, 2974 const ArchSpec& arch) 2975 { 2976 if (m_debugged_process_sp) 2977 { 2978 FileSpec file_spec; 2979 if (m_debugged_process_sp->GetLoadedModuleFileSpec(module_path.c_str(), file_spec).Success()) 2980 { 2981 if (file_spec.Exists()) 2982 return file_spec; 2983 } 2984 } 2985 2986 return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch); 2987 } 2988