contrib/llvm-project/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

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