1 //===-- GDBRemoteCommunicationServerPlatform.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 "GDBRemoteCommunicationServerPlatform.h" 11 12 #include <errno.h> 13 14 // C Includes 15 // C++ Includes 16 #include <cstring> 17 #include <chrono> 18 #include <mutex> 19 #include <sstream> 20 21 // Other libraries and framework includes 22 #include "llvm/Support/FileSystem.h" 23 24 #include "lldb/Core/Log.h" 25 #include "lldb/Core/StreamGDBRemote.h" 26 #include "lldb/Core/StreamString.h" 27 #include "lldb/Core/StructuredData.h" 28 #include "lldb/Host/Config.h" 29 #include "lldb/Host/ConnectionFileDescriptor.h" 30 #include "lldb/Host/Host.h" 31 #include "lldb/Host/HostInfo.h" 32 #include "lldb/Host/StringConvert.h" 33 #include "lldb/Target/FileAction.h" 34 #include "lldb/Target/Platform.h" 35 #include "lldb/Target/Process.h" 36 #include "lldb/Target/UnixSignals.h" 37 #include "lldb/Utility/JSON.h" 38 39 // Project includes 40 #include "Utility/StringExtractorGDBRemote.h" 41 #include "Utility/UriParser.h" 42 43 using namespace lldb; 44 using namespace lldb_private; 45 using namespace lldb_private::process_gdb_remote; 46 47 //---------------------------------------------------------------------- 48 // GDBRemoteCommunicationServerPlatform constructor 49 //---------------------------------------------------------------------- 50 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol, 51 const char *socket_scheme) 52 : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"), 53 m_socket_protocol(socket_protocol), 54 m_socket_scheme(socket_scheme), 55 m_spawned_pids_mutex(), 56 m_port_map(), 57 m_port_offset(0) 58 { 59 m_pending_gdb_server.pid = LLDB_INVALID_PROCESS_ID; 60 m_pending_gdb_server.port = 0; 61 62 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC, 63 &GDBRemoteCommunicationServerPlatform::Handle_qC); 64 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir, 65 &GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir); 66 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qLaunchGDBServer, 67 &GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer); 68 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qQueryGDBServer, 69 &GDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer); 70 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qKillSpawnedProcess, 71 &GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess); 72 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qProcessInfo, 73 &GDBRemoteCommunicationServerPlatform::Handle_qProcessInfo); 74 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir, 75 &GDBRemoteCommunicationServerPlatform::Handle_QSetWorkingDir); 76 RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_jSignalsInfo, 77 &GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo); 78 79 RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_interrupt, 80 [this](StringExtractorGDBRemote packet, Error &error, bool &interrupt, bool &quit) { 81 error.SetErrorString("interrupt received"); 82 interrupt = true; 83 return PacketResult::Success; 84 }); 85 } 86 87 //---------------------------------------------------------------------- 88 // Destructor 89 //---------------------------------------------------------------------- 90 GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform() 91 { 92 } 93 94 Error 95 GDBRemoteCommunicationServerPlatform::LaunchGDBServer(const lldb_private::Args& args, 96 std::string hostname, 97 lldb::pid_t& pid, 98 uint16_t& port, 99 std::string& socket_name) 100 { 101 if (port == UINT16_MAX) 102 port = GetNextAvailablePort(); 103 104 // Spawn a new thread to accept the port that gets bound after 105 // binding to port 0 (zero). 106 107 // ignore the hostname send from the remote end, just use the ip address 108 // that we're currently communicating with as the hostname 109 110 // Spawn a debugserver and try to get the port it listens to. 111 ProcessLaunchInfo debugserver_launch_info; 112 if (hostname.empty()) 113 hostname = "127.0.0.1"; 114 115 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM)); 116 if (log) 117 log->Printf("Launching debugserver with: %s:%u...", hostname.c_str(), port); 118 119 // Do not run in a new session so that it can not linger after the 120 // platform closes. 121 debugserver_launch_info.SetLaunchInSeparateProcessGroup(false); 122 debugserver_launch_info.SetMonitorProcessCallback( 123 std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped, this, std::placeholders::_1), false); 124 125 std::string platform_scheme; 126 std::string platform_ip; 127 int platform_port; 128 std::string platform_path; 129 bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path); 130 UNUSED_IF_ASSERT_DISABLED(ok); 131 assert(ok); 132 133 std::ostringstream url; 134 // debugserver does not accept the URL scheme prefix. 135 #if !defined(__APPLE__) 136 url << m_socket_scheme << "://"; 137 #endif 138 uint16_t* port_ptr = &port; 139 if (m_socket_protocol == Socket::ProtocolTcp) 140 url << platform_ip << ":" << port; 141 else 142 { 143 socket_name = GetDomainSocketPath("gdbserver").GetPath(); 144 url << socket_name; 145 port_ptr = nullptr; 146 } 147 148 Error error = StartDebugserverProcess (url.str().c_str(), 149 nullptr, 150 debugserver_launch_info, 151 port_ptr, 152 &args, 153 -1); 154 155 pid = debugserver_launch_info.GetProcessID(); 156 if (pid != LLDB_INVALID_PROCESS_ID) 157 { 158 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 159 m_spawned_pids.insert(pid); 160 if (port > 0) 161 AssociatePortWithProcess(port, pid); 162 } 163 else 164 { 165 if (port > 0) 166 FreePort(port); 167 } 168 return error; 169 } 170 171 GDBRemoteCommunication::PacketResult 172 GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer (StringExtractorGDBRemote &packet) 173 { 174 #ifdef _WIN32 175 return SendErrorResponse(9); 176 #else 177 // Spawn a local debugserver as a platform so we can then attach or launch 178 // a process... 179 180 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM)); 181 if (log) 182 log->Printf ("GDBRemoteCommunicationServerPlatform::%s() called", __FUNCTION__); 183 184 ConnectionFileDescriptor file_conn; 185 std::string hostname; 186 packet.SetFilePos(::strlen ("qLaunchGDBServer;")); 187 std::string name; 188 std::string value; 189 uint16_t port = UINT16_MAX; 190 while (packet.GetNameColonValue(name, value)) 191 { 192 if (name.compare ("host") == 0) 193 hostname.swap(value); 194 else if (name.compare ("port") == 0) 195 port = StringConvert::ToUInt32(value.c_str(), 0, 0); 196 } 197 198 lldb::pid_t debugserver_pid = LLDB_INVALID_PROCESS_ID; 199 std::string socket_name; 200 Error error = LaunchGDBServer(Args(), hostname, debugserver_pid, port, socket_name); 201 if (error.Fail()) 202 { 203 if (log) 204 log->Printf("GDBRemoteCommunicationServerPlatform::%s() debugserver launch failed: %s", __FUNCTION__, error.AsCString ()); 205 return SendErrorResponse(9); 206 } 207 208 if (log) 209 log->Printf ("GDBRemoteCommunicationServerPlatform::%s() debugserver launched successfully as pid %" PRIu64, __FUNCTION__, debugserver_pid); 210 211 StreamGDBRemote response; 212 response.Printf("pid:%" PRIu64 ";port:%u;", debugserver_pid, port + m_port_offset); 213 if (!socket_name.empty()) 214 { 215 response.PutCString("socket_name:"); 216 response.PutCStringAsRawHex8(socket_name.c_str()); 217 response.PutChar(';'); 218 } 219 220 PacketResult packet_result = SendPacketNoLock(response.GetData(), response.GetSize()); 221 if (packet_result != PacketResult::Success) 222 { 223 if (debugserver_pid != LLDB_INVALID_PROCESS_ID) 224 ::kill (debugserver_pid, SIGINT); 225 } 226 return packet_result; 227 #endif 228 } 229 230 GDBRemoteCommunication::PacketResult 231 GDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer (StringExtractorGDBRemote &packet) 232 { 233 if (m_pending_gdb_server.pid == LLDB_INVALID_PROCESS_ID) 234 return SendErrorResponse(4); 235 236 JSONObject::SP server_sp = std::make_shared<JSONObject>(); 237 server_sp->SetObject("port", std::make_shared<JSONNumber>(m_pending_gdb_server.port)); 238 if (!m_pending_gdb_server.socket_name.empty()) 239 server_sp->SetObject("socket_name", 240 std::make_shared<JSONString>(m_pending_gdb_server.socket_name.c_str())); 241 242 JSONArray server_list; 243 server_list.AppendObject(server_sp); 244 245 StreamGDBRemote response; 246 server_list.Write(response); 247 248 StreamGDBRemote escaped_response; 249 escaped_response.PutEscapedBytes(response.GetData(), response.GetSize()); 250 return SendPacketNoLock(escaped_response.GetData(), escaped_response.GetSize()); 251 } 252 253 GDBRemoteCommunication::PacketResult 254 GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess (StringExtractorGDBRemote &packet) 255 { 256 packet.SetFilePos(::strlen ("qKillSpawnedProcess:")); 257 258 lldb::pid_t pid = packet.GetU64(LLDB_INVALID_PROCESS_ID); 259 260 // verify that we know anything about this pid. 261 // Scope for locker 262 { 263 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 264 if (m_spawned_pids.find(pid) == m_spawned_pids.end()) 265 { 266 // not a pid we know about 267 return SendErrorResponse (10); 268 } 269 } 270 271 // go ahead and attempt to kill the spawned process 272 if (KillSpawnedProcess (pid)) 273 return SendOKResponse (); 274 else 275 return SendErrorResponse (11); 276 } 277 278 bool 279 GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid) 280 { 281 // make sure we know about this process 282 { 283 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 284 if (m_spawned_pids.find(pid) == m_spawned_pids.end()) 285 return false; 286 } 287 288 // first try a SIGTERM (standard kill) 289 Host::Kill (pid, SIGTERM); 290 291 // check if that worked 292 for (size_t i=0; i<10; ++i) 293 { 294 { 295 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 296 if (m_spawned_pids.find(pid) == m_spawned_pids.end()) 297 { 298 // it is now killed 299 return true; 300 } 301 } 302 usleep (10000); 303 } 304 305 // check one more time after the final usleep 306 { 307 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 308 if (m_spawned_pids.find(pid) == m_spawned_pids.end()) 309 return true; 310 } 311 312 // the launched process still lives. Now try killing it again, 313 // this time with an unblockable signal. 314 Host::Kill (pid, SIGKILL); 315 316 for (size_t i=0; i<10; ++i) 317 { 318 { 319 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 320 if (m_spawned_pids.find(pid) == m_spawned_pids.end()) 321 { 322 // it is now killed 323 return true; 324 } 325 } 326 usleep (10000); 327 } 328 329 // check one more time after the final usleep 330 // Scope for locker 331 { 332 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 333 if (m_spawned_pids.find(pid) == m_spawned_pids.end()) 334 return true; 335 } 336 337 // no luck - the process still lives 338 return false; 339 } 340 341 GDBRemoteCommunication::PacketResult 342 GDBRemoteCommunicationServerPlatform::Handle_qProcessInfo (StringExtractorGDBRemote &packet) 343 { 344 lldb::pid_t pid = m_process_launch_info.GetProcessID (); 345 m_process_launch_info.Clear (); 346 347 if (pid == LLDB_INVALID_PROCESS_ID) 348 return SendErrorResponse (1); 349 350 ProcessInstanceInfo proc_info; 351 if (!Host::GetProcessInfo (pid, proc_info)) 352 return SendErrorResponse (1); 353 354 StreamString response; 355 CreateProcessInfoResponse_DebugServerStyle(proc_info, response); 356 return SendPacketNoLock (response.GetData (), response.GetSize ()); 357 } 358 359 GDBRemoteCommunication::PacketResult 360 GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir (StringExtractorGDBRemote &packet) 361 { 362 // If this packet is sent to a platform, then change the current working directory 363 364 char cwd[PATH_MAX]; 365 if (getcwd(cwd, sizeof(cwd)) == NULL) 366 return SendErrorResponse(errno); 367 368 StreamString response; 369 response.PutBytesAsRawHex8(cwd, strlen(cwd)); 370 return SendPacketNoLock(response.GetData(), response.GetSize()); 371 } 372 373 GDBRemoteCommunication::PacketResult 374 GDBRemoteCommunicationServerPlatform::Handle_QSetWorkingDir (StringExtractorGDBRemote &packet) 375 { 376 packet.SetFilePos (::strlen ("QSetWorkingDir:")); 377 std::string path; 378 packet.GetHexByteString (path); 379 380 // If this packet is sent to a platform, then change the current working directory 381 if (::chdir(path.c_str()) != 0) 382 return SendErrorResponse (errno); 383 return SendOKResponse (); 384 } 385 386 GDBRemoteCommunication::PacketResult 387 GDBRemoteCommunicationServerPlatform::Handle_qC (StringExtractorGDBRemote &packet) 388 { 389 // NOTE: lldb should now be using qProcessInfo for process IDs. This path here 390 // should not be used. It is reporting process id instead of thread id. The 391 // correct answer doesn't seem to make much sense for lldb-platform. 392 // CONSIDER: flip to "unsupported". 393 lldb::pid_t pid = m_process_launch_info.GetProcessID(); 394 395 StreamString response; 396 response.Printf("QC%" PRIx64, pid); 397 398 // If we launch a process and this GDB server is acting as a platform, 399 // then we need to clear the process launch state so we can start 400 // launching another process. In order to launch a process a bunch or 401 // packets need to be sent: environment packets, working directory, 402 // disable ASLR, and many more settings. When we launch a process we 403 // then need to know when to clear this information. Currently we are 404 // selecting the 'qC' packet as that packet which seems to make the most 405 // sense. 406 if (pid != LLDB_INVALID_PROCESS_ID) 407 { 408 m_process_launch_info.Clear(); 409 } 410 411 return SendPacketNoLock (response.GetData(), response.GetSize()); 412 } 413 414 GDBRemoteCommunication::PacketResult 415 GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo(StringExtractorGDBRemote &packet) 416 { 417 StructuredData::Array signal_array; 418 419 const auto &signals = Host::GetUnixSignals(); 420 for (auto signo = signals->GetFirstSignalNumber(); 421 signo != LLDB_INVALID_SIGNAL_NUMBER; 422 signo = signals->GetNextSignalNumber(signo)) 423 { 424 auto dictionary = std::make_shared<StructuredData::Dictionary>(); 425 426 dictionary->AddIntegerItem("signo", signo); 427 dictionary->AddStringItem("name", signals->GetSignalAsCString(signo)); 428 429 bool suppress, stop, notify; 430 signals->GetSignalInfo(signo, suppress, stop, notify); 431 dictionary->AddBooleanItem("suppress", suppress); 432 dictionary->AddBooleanItem("stop", stop); 433 dictionary->AddBooleanItem("notify", notify); 434 435 signal_array.Push(dictionary); 436 } 437 438 StreamString response; 439 signal_array.Dump(response); 440 return SendPacketNoLock(response.GetData(), response.GetSize()); 441 } 442 443 bool 444 GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped (lldb::pid_t pid) 445 { 446 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 447 FreePortForProcess(pid); 448 m_spawned_pids.erase(pid); 449 return true; 450 } 451 452 Error 453 GDBRemoteCommunicationServerPlatform::LaunchProcess () 454 { 455 if (!m_process_launch_info.GetArguments ().GetArgumentCount ()) 456 return Error ("%s: no process command line specified to launch", __FUNCTION__); 457 458 // specify the process monitor if not already set. This should 459 // generally be what happens since we need to reap started 460 // processes. 461 if (!m_process_launch_info.GetMonitorProcessCallback ()) 462 m_process_launch_info.SetMonitorProcessCallback( 463 std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped, this, std::placeholders::_1), 464 false); 465 466 Error error = Host::LaunchProcess(m_process_launch_info); 467 if (!error.Success ()) 468 { 469 fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0)); 470 return error; 471 } 472 473 printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID()); 474 475 // add to list of spawned processes. On an lldb-gdbserver, we 476 // would expect there to be only one. 477 const auto pid = m_process_launch_info.GetProcessID(); 478 if (pid != LLDB_INVALID_PROCESS_ID) 479 { 480 // add to spawned pids 481 std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex); 482 m_spawned_pids.insert(pid); 483 } 484 485 return error; 486 } 487 488 void 489 GDBRemoteCommunicationServerPlatform::SetPortMap (PortMap &&port_map) 490 { 491 m_port_map = port_map; 492 } 493 494 uint16_t 495 GDBRemoteCommunicationServerPlatform::GetNextAvailablePort () 496 { 497 if (m_port_map.empty()) 498 return 0; // Bind to port zero and get a port, we didn't have any limitations 499 500 for (auto &pair : m_port_map) 501 { 502 if (pair.second == LLDB_INVALID_PROCESS_ID) 503 { 504 pair.second = ~(lldb::pid_t)LLDB_INVALID_PROCESS_ID; 505 return pair.first; 506 } 507 } 508 return UINT16_MAX; 509 } 510 511 bool 512 GDBRemoteCommunicationServerPlatform::AssociatePortWithProcess (uint16_t port, lldb::pid_t pid) 513 { 514 PortMap::iterator pos = m_port_map.find(port); 515 if (pos != m_port_map.end()) 516 { 517 pos->second = pid; 518 return true; 519 } 520 return false; 521 } 522 523 bool 524 GDBRemoteCommunicationServerPlatform::FreePort (uint16_t port) 525 { 526 PortMap::iterator pos = m_port_map.find(port); 527 if (pos != m_port_map.end()) 528 { 529 pos->second = LLDB_INVALID_PROCESS_ID; 530 return true; 531 } 532 return false; 533 } 534 535 bool 536 GDBRemoteCommunicationServerPlatform::FreePortForProcess (lldb::pid_t pid) 537 { 538 if (!m_port_map.empty()) 539 { 540 for (auto &pair : m_port_map) 541 { 542 if (pair.second == pid) 543 { 544 pair.second = LLDB_INVALID_PROCESS_ID; 545 return true; 546 } 547 } 548 } 549 return false; 550 } 551 552 const FileSpec& 553 GDBRemoteCommunicationServerPlatform::GetDomainSocketDir() 554 { 555 static FileSpec g_domainsocket_dir; 556 static std::once_flag g_once_flag; 557 558 std::call_once(g_once_flag, []() { 559 const char* domainsocket_dir_env = ::getenv("LLDB_DEBUGSERVER_DOMAINSOCKET_DIR"); 560 if (domainsocket_dir_env != nullptr) 561 g_domainsocket_dir = FileSpec(domainsocket_dir_env, false); 562 else 563 HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, g_domainsocket_dir); 564 }); 565 566 return g_domainsocket_dir; 567 } 568 569 FileSpec 570 GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char* prefix) 571 { 572 llvm::SmallString<PATH_MAX> socket_path; 573 llvm::SmallString<PATH_MAX> socket_name((llvm::StringRef(prefix) + ".%%%%%%").str()); 574 575 FileSpec socket_path_spec(GetDomainSocketDir()); 576 socket_path_spec.AppendPathComponent(socket_name.c_str()); 577 578 llvm::sys::fs::createUniqueFile(socket_path_spec.GetCString(), socket_path); 579 return FileSpec(socket_path.c_str(), false); 580 } 581 582 void 583 GDBRemoteCommunicationServerPlatform::SetPortOffset(uint16_t port_offset) 584 { 585 m_port_offset = port_offset; 586 } 587 588 void 589 GDBRemoteCommunicationServerPlatform::SetPendingGdbServer(lldb::pid_t pid, 590 uint16_t port, 591 const std::string& socket_name) 592 { 593 m_pending_gdb_server.pid = pid; 594 m_pending_gdb_server.port = port; 595 m_pending_gdb_server.socket_name = socket_name; 596 } 597