source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

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