LLDB  mainline
GDBRemoteCommunicationServerPlatform.cpp
Go to the documentation of this file.
1 //===-- GDBRemoteCommunicationServerPlatform.cpp --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
11 #include <cerrno>
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"
26 #include "lldb/Host/FileAction.h"
27 #include "lldb/Host/Host.h"
28 #include "lldb/Host/HostInfo.h"
30 #include "lldb/Target/Platform.h"
32 #include "lldb/Utility/GDBRemote.h"
33 #include "lldb/Utility/Log.h"
37 #include "lldb/Utility/UriParser.h"
38 
40 
41 using namespace lldb;
42 using namespace lldb_private::process_gdb_remote;
43 using namespace lldb_private;
44 
45 GDBRemoteCommunicationServerPlatform::PortMap::PortMap(uint16_t min_port,
46  uint16_t max_port) {
47  for (; min_port < max_port; ++min_port)
48  m_port_map[min_port] = LLDB_INVALID_PROCESS_ID;
49 }
50 
51 void GDBRemoteCommunicationServerPlatform::PortMap::AllowPort(uint16_t port) {
52  // Do not modify existing mappings
53  m_port_map.insert({port, LLDB_INVALID_PROCESS_ID});
54 }
55 
56 llvm::Expected<uint16_t>
57 GDBRemoteCommunicationServerPlatform::PortMap::GetNextAvailablePort() {
58  if (m_port_map.empty())
59  return 0; // Bind to port zero and get a port, we didn't have any
60  // limitations
61 
62  for (auto &pair : m_port_map) {
63  if (pair.second == LLDB_INVALID_PROCESS_ID) {
64  pair.second = ~(lldb::pid_t)LLDB_INVALID_PROCESS_ID;
65  return pair.first;
66  }
67  }
68  return llvm::createStringError(llvm::inconvertibleErrorCode(),
69  "No free port found in port map");
70 }
71 
72 bool GDBRemoteCommunicationServerPlatform::PortMap::AssociatePortWithProcess(
73  uint16_t port, lldb::pid_t pid) {
74  auto pos = m_port_map.find(port);
75  if (pos != m_port_map.end()) {
76  pos->second = pid;
77  return true;
78  }
79  return false;
80 }
81 
82 bool GDBRemoteCommunicationServerPlatform::PortMap::FreePort(uint16_t port) {
83  std::map<uint16_t, lldb::pid_t>::iterator pos = m_port_map.find(port);
84  if (pos != m_port_map.end()) {
85  pos->second = LLDB_INVALID_PROCESS_ID;
86  return true;
87  }
88  return false;
89 }
90 
91 bool GDBRemoteCommunicationServerPlatform::PortMap::FreePortForProcess(
92  lldb::pid_t pid) {
93  if (!m_port_map.empty()) {
94  for (auto &pair : m_port_map) {
95  if (pair.second == pid) {
96  pair.second = LLDB_INVALID_PROCESS_ID;
97  return true;
98  }
99  }
100  }
101  return false;
102 }
103 
104 bool GDBRemoteCommunicationServerPlatform::PortMap::empty() const {
105  return m_port_map.empty();
106 }
107 
108 // GDBRemoteCommunicationServerPlatform constructor
109 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(
110  const Socket::SocketProtocol socket_protocol, const char *socket_scheme)
111  : GDBRemoteCommunicationServerCommon("gdb-remote.server",
112  "gdb-remote.server.rx_packet"),
113  m_socket_protocol(socket_protocol), m_socket_scheme(socket_scheme),
114  m_spawned_pids_mutex(), m_port_map(), m_port_offset(0) {
116  m_pending_gdb_server.port = 0;
117 
145 
148  bool &interrupt, bool &quit) {
149  error.SetErrorString("interrupt received");
150  interrupt = true;
151  return PacketResult::Success;
152  });
153 }
154 
155 // Destructor
157  default;
158 
160  const lldb_private::Args &args, std::string hostname, lldb::pid_t &pid,
161  llvm::Optional<uint16_t> &port, std::string &socket_name) {
162  if (!port) {
163  llvm::Expected<uint16_t> available_port = m_port_map.GetNextAvailablePort();
164  if (available_port)
165  port = *available_port;
166  else
167  return Status(available_port.takeError());
168  }
169 
170  // Spawn a new thread to accept the port that gets bound after binding to
171  // port 0 (zero).
172 
173  // ignore the hostname send from the remote end, just use the ip address that
174  // we're currently communicating with as the hostname
175 
176  // Spawn a debugserver and try to get the port it listens to.
177  ProcessLaunchInfo debugserver_launch_info;
178  if (hostname.empty())
179  hostname = "127.0.0.1";
180 
182  LLDB_LOGF(log, "Launching debugserver with: %s:%u...", hostname.c_str(),
183  *port);
184 
185  // Do not run in a new session so that it can not linger after the platform
186  // closes.
187  debugserver_launch_info.SetLaunchInSeparateProcessGroup(false);
188  debugserver_launch_info.SetMonitorProcessCallback(
190  this, std::placeholders::_1),
191  false);
192 
193  std::ostringstream url;
194 // debugserver does not accept the URL scheme prefix.
195 #if !defined(__APPLE__)
196  url << m_socket_scheme << "://";
197 #endif
198  uint16_t *port_ptr = port.getPointer();
200  llvm::StringRef platform_scheme;
201  llvm::StringRef platform_ip;
202  llvm::Optional<uint16_t> platform_port;
203  llvm::StringRef platform_path;
204  std::string platform_uri = GetConnection()->GetURI();
205  bool ok = UriParser::Parse(platform_uri, platform_scheme, platform_ip,
206  platform_port, platform_path);
208  assert(ok);
209  url << '[' << platform_ip.str() << "]:" << *port;
210  } else {
211  socket_name = GetDomainSocketPath("gdbserver").GetPath();
212  url << socket_name;
213  port_ptr = nullptr;
214  }
215 
217  url.str().c_str(), nullptr, debugserver_launch_info, port_ptr, &args, -1);
218 
219  pid = debugserver_launch_info.GetProcessID();
220  if (pid != LLDB_INVALID_PROCESS_ID) {
221  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
222  m_spawned_pids.insert(pid);
223  if (*port > 0)
225  } else {
226  if (*port > 0)
228  }
229  return error;
230 }
231 
234  StringExtractorGDBRemote &packet) {
235  // Spawn a local debugserver as a platform so we can then attach or launch a
236  // process...
237 
239  LLDB_LOGF(log, "GDBRemoteCommunicationServerPlatform::%s() called",
240  __FUNCTION__);
241 
242  ConnectionFileDescriptor file_conn;
243  std::string hostname;
244  packet.SetFilePos(::strlen("qLaunchGDBServer;"));
245  llvm::StringRef name;
246  llvm::StringRef value;
247  llvm::Optional<uint16_t> port;
248  while (packet.GetNameColonValue(name, value)) {
249  if (name.equals("host"))
250  hostname = std::string(value);
251  else if (name.equals("port")) {
252  // Make the Optional valid so we can use its value
253  port = 0;
254  value.getAsInteger(0, port.getValue());
255  }
256  }
257 
258  lldb::pid_t debugserver_pid = LLDB_INVALID_PROCESS_ID;
260  Status error =
261  LaunchGDBServer(Args(), hostname, debugserver_pid, port, socket_name);
262  if (error.Fail()) {
263  LLDB_LOGF(log,
264  "GDBRemoteCommunicationServerPlatform::%s() debugserver "
265  "launch failed: %s",
266  __FUNCTION__, error.AsCString());
267  return SendErrorResponse(9);
268  }
269 
270  LLDB_LOGF(log,
271  "GDBRemoteCommunicationServerPlatform::%s() debugserver "
272  "launched successfully as pid %" PRIu64,
273  __FUNCTION__, debugserver_pid);
274 
275  StreamGDBRemote response;
276  assert(port);
277  response.Printf("pid:%" PRIu64 ";port:%u;", debugserver_pid,
278  *port + m_port_offset);
279  if (!socket_name.empty()) {
280  response.PutCString("socket_name:");
282  response.PutChar(';');
283  }
284 
285  PacketResult packet_result = SendPacketNoLock(response.GetString());
286  if (packet_result != PacketResult::Success) {
287  if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
288  Host::Kill(debugserver_pid, SIGINT);
289  }
290  return packet_result;
291 }
292 
295  StringExtractorGDBRemote &packet) {
296  namespace json = llvm::json;
297 
299  return SendErrorResponse(4);
300 
301  json::Object server{{"port", m_pending_gdb_server.port}};
302 
303  if (!m_pending_gdb_server.socket_name.empty())
304  server.try_emplace("socket_name", m_pending_gdb_server.socket_name);
305 
306  json::Array server_list;
307  server_list.push_back(std::move(server));
308 
309  StreamGDBRemote response;
310  response.AsRawOstream() << std::move(server_list);
311 
312  StreamGDBRemote escaped_response;
313  escaped_response.PutEscapedBytes(response.GetString().data(),
314  response.GetSize());
315  return SendPacketNoLock(escaped_response.GetString());
316 }
317 
320  StringExtractorGDBRemote &packet) {
321  packet.SetFilePos(::strlen("qKillSpawnedProcess:"));
322 
324 
325  // verify that we know anything about this pid. Scope for locker
326  {
327  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
328  if (m_spawned_pids.find(pid) == m_spawned_pids.end()) {
329  // not a pid we know about
330  return SendErrorResponse(10);
331  }
332  }
333 
334  // go ahead and attempt to kill the spawned process
335  if (KillSpawnedProcess(pid))
336  return SendOKResponse();
337  else
338  return SendErrorResponse(11);
339 }
340 
342  // make sure we know about this process
343  {
344  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
345  if (m_spawned_pids.find(pid) == m_spawned_pids.end())
346  return false;
347  }
348 
349  // first try a SIGTERM (standard kill)
350  Host::Kill(pid, SIGTERM);
351 
352  // check if that worked
353  for (size_t i = 0; i < 10; ++i) {
354  {
355  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
356  if (m_spawned_pids.find(pid) == m_spawned_pids.end()) {
357  // it is now killed
358  return true;
359  }
360  }
361  std::this_thread::sleep_for(std::chrono::milliseconds(10));
362  }
363 
364  {
365  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
366  if (m_spawned_pids.find(pid) == m_spawned_pids.end())
367  return true;
368  }
369 
370  // the launched process still lives. Now try killing it again, this time
371  // with an unblockable signal.
373 
374  for (size_t i = 0; i < 10; ++i) {
375  {
376  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
377  if (m_spawned_pids.find(pid) == m_spawned_pids.end()) {
378  // it is now killed
379  return true;
380  }
381  }
382  std::this_thread::sleep_for(std::chrono::milliseconds(10));
383  }
384 
385  // check one more time after the final sleep
386  {
387  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
388  if (m_spawned_pids.find(pid) == m_spawned_pids.end())
389  return true;
390  }
391 
392  // no luck - the process still lives
393  return false;
394 }
395 
398  StringExtractorGDBRemote &packet) {
401 
403  return SendErrorResponse(1);
404 
405  ProcessInstanceInfo proc_info;
406  if (!Host::GetProcessInfo(pid, proc_info))
407  return SendErrorResponse(1);
408 
409  StreamString response;
410  CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
411  return SendPacketNoLock(response.GetString());
412 }
413 
416  StringExtractorGDBRemote &packet) {
417  packet.SetFilePos(::strlen("qPathComplete:"));
418  const bool only_dir = (packet.GetHexMaxU32(false, 0) == 1);
419  if (packet.GetChar() != ',')
420  return SendErrorResponse(85);
421  std::string path;
422  packet.GetHexByteString(path);
423 
424  StringList matches;
426  if (only_dir)
427  CommandCompletions::DiskDirectories(path, matches, resolver);
428  else
429  CommandCompletions::DiskFiles(path, matches, resolver);
430 
431  StreamString response;
432  response.PutChar('M');
433  llvm::StringRef separator;
434  std::sort(matches.begin(), matches.end());
435  for (const auto &match : matches) {
436  response << separator;
437  separator = ",";
438  // encode result strings into hex bytes to avoid unexpected error caused by
439  // special characters like '$'.
440  response.PutStringAsRawHex8(match.c_str());
441  }
442 
443  return SendPacketNoLock(response.GetString());
444 }
445 
448  StringExtractorGDBRemote &packet) {
449 
450  llvm::SmallString<64> cwd;
451  if (std::error_code ec = llvm::sys::fs::current_path(cwd))
452  return SendErrorResponse(ec.value());
453 
454  StreamString response;
455  response.PutBytesAsRawHex8(cwd.data(), cwd.size());
456  return SendPacketNoLock(response.GetString());
457 }
458 
461  StringExtractorGDBRemote &packet) {
462  packet.SetFilePos(::strlen("QSetWorkingDir:"));
463  std::string path;
464  packet.GetHexByteString(path);
465 
466  if (std::error_code ec = llvm::sys::fs::set_current_path(path))
467  return SendErrorResponse(ec.value());
468  return SendOKResponse();
469 }
470 
473  StringExtractorGDBRemote &packet) {
474  // NOTE: lldb should now be using qProcessInfo for process IDs. This path
475  // here
476  // should not be used. It is reporting process id instead of thread id. The
477  // correct answer doesn't seem to make much sense for lldb-platform.
478  // CONSIDER: flip to "unsupported".
480 
481  StreamString response;
482  response.Printf("QC%" PRIx64, pid);
483 
484  // If we launch a process and this GDB server is acting as a platform, then
485  // we need to clear the process launch state so we can start launching
486  // another process. In order to launch a process a bunch or packets need to
487  // be sent: environment packets, working directory, disable ASLR, and many
488  // more settings. When we launch a process we then need to know when to clear
489  // this information. Currently we are selecting the 'qC' packet as that
490  // packet which seems to make the most sense.
491  if (pid != LLDB_INVALID_PROCESS_ID) {
493  }
494 
495  return SendPacketNoLock(response.GetString());
496 }
497 
500  StringExtractorGDBRemote &packet) {
501  StructuredData::Array signal_array;
502 
503  lldb::UnixSignalsSP signals = UnixSignals::CreateForHost();
504  for (auto signo = signals->GetFirstSignalNumber();
506  signo = signals->GetNextSignalNumber(signo)) {
507  auto dictionary = std::make_shared<StructuredData::Dictionary>();
508 
509  dictionary->AddIntegerItem("signo", signo);
510  dictionary->AddStringItem("name", signals->GetSignalAsCString(signo));
511 
512  bool suppress, stop, notify;
513  signals->GetSignalInfo(signo, suppress, stop, notify);
514  dictionary->AddBooleanItem("suppress", suppress);
515  dictionary->AddBooleanItem("stop", stop);
516  dictionary->AddBooleanItem("notify", notify);
517 
518  signal_array.Push(dictionary);
519  }
520 
521  StreamString response;
522  signal_array.Dump(response);
523  return SendPacketNoLock(response.GetString());
524 }
525 
527  lldb::pid_t pid) {
528  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
530  m_spawned_pids.erase(pid);
531  return true;
532 }
533 
536  return Status("%s: no process command line specified to launch",
537  __FUNCTION__);
538 
539  // specify the process monitor if not already set. This should generally be
540  // what happens since we need to reap started processes.
543  std::bind(
545  this, std::placeholders::_1),
546  false);
547 
549  if (!error.Success()) {
550  fprintf(stderr, "%s: failed to launch executable %s", __FUNCTION__,
552  return error;
553  }
554 
555  printf("Launched '%s' as process %" PRIu64 "...\n",
558 
559  // add to list of spawned processes. On an lldb-gdbserver, we would expect
560  // there to be only one.
561  const auto pid = m_process_launch_info.GetProcessID();
562  if (pid != LLDB_INVALID_PROCESS_ID) {
563  // add to spawned pids
564  std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
565  m_spawned_pids.insert(pid);
566  }
567 
568  return error;
569 }
570 
572  m_port_map = port_map;
573 }
574 
576  static FileSpec g_domainsocket_dir;
577  static llvm::once_flag g_once_flag;
578 
579  llvm::call_once(g_once_flag, []() {
580  const char *domainsocket_dir_env =
581  ::getenv("LLDB_DEBUGSERVER_DOMAINSOCKET_DIR");
582  if (domainsocket_dir_env != nullptr)
583  g_domainsocket_dir = FileSpec(domainsocket_dir_env);
584  else
585  g_domainsocket_dir = HostInfo::GetProcessTempDir();
586  });
587 
588  return g_domainsocket_dir;
589 }
590 
591 FileSpec
593  llvm::SmallString<128> socket_path;
594  llvm::SmallString<128> socket_name(
595  (llvm::StringRef(prefix) + ".%%%%%%").str());
596 
597  FileSpec socket_path_spec(GetDomainSocketDir());
598  socket_path_spec.AppendPathComponent(socket_name.c_str());
599 
600  llvm::sys::fs::createUniqueFile(socket_path_spec.GetCString(), socket_path);
601  return FileSpec(socket_path.c_str());
602 }
603 
605  m_port_offset = port_offset;
606 }
607 
609  lldb::pid_t pid, uint16_t port, const std::string &socket_name) {
611  m_pending_gdb_server.port = port;
612  m_pending_gdb_server.socket_name = socket_name;
613 }
lldb_private::ProcessInfo::GetArguments
Args & GetArguments()
Definition: ProcessInfo.h:75
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qProcessInfo
PacketResult Handle_qProcessInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:397
lldb_private::ProcessInstanceInfo
Definition: ProcessInfo.h:108
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir
PacketResult Handle_qGetWorkingDir(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:447
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo
PacketResult Handle_jSignalsInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:499
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_socket_protocol
const Socket::SocketProtocol m_socket_protocol
Definition: GDBRemoteCommunicationServerPlatform.h:100
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer::SendErrorResponse
PacketResult SendErrorResponse(const Status &error)
Definition: GDBRemoteCommunicationServer.cpp:106
lldb_private::StandardTildeExpressionResolver
Definition: TildeExpressionResolver.h:56
lldb_private::Host::LaunchProcess
static Status LaunchProcess(ProcessLaunchInfo &launch_info)
Launch the process specified in launch_info.
Definition: common/Host.cpp:616
UNUSED_IF_ASSERT_DISABLED
#define UNUSED_IF_ASSERT_DISABLED(x)
Definition: lldb-defines.h:137
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::LaunchProcess
Status LaunchProcess() override
Launch a process with the current launch settings.
Definition: GDBRemoteCommunicationServerPlatform.cpp:534
lldb_private::StringList::begin
iterator begin()
Definition: StringList.h:60
LLDB_INVALID_PROCESS_ID
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:93
lldb_private::ProcessLaunchInfo::GetMonitorProcessCallback
Host::MonitorChildProcessCallback GetMonitorProcessCallback() const
Definition: ProcessLaunchInfo.h:106
StringExtractor::SetFilePos
void SetFilePos(uint32_t idx)
Definition: StringExtractor.h:39
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer::RegisterPacketHandler
void RegisterPacketHandler(StringExtractorGDBRemote::ServerPacketType packet_type, PacketHandler handler)
Definition: GDBRemoteCommunicationServer.cpp:38
lldb_private::StructuredData::Array
Definition: StructuredData.h:165
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer
PacketResult Handle_qQueryGDBServer(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:294
StructuredData.h
lldb_private::Socket::SocketProtocol
SocketProtocol
Definition: Socket.h:44
Host.h
lldb_private::Connection::GetURI
virtual std::string GetURI()=0
Returns a URI that describes this connection object.
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::PortMap::AssociatePortWithProcess
bool AssociatePortWithProcess(uint16_t port, lldb::pid_t pid)
Definition: GDBRemoteCommunicationServerPlatform.cpp:72
StringExtractorGDBRemote::eServerPacketType_qQueryGDBServer
@ eServerPacketType_qQueryGDBServer
Definition: StringExtractorGDBRemote.h:60
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::GetDomainSocketPath
static FileSpec GetDomainSocketPath(const char *prefix)
Definition: GDBRemoteCommunicationServerPlatform.cpp:592
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::PortMap
Definition: GDBRemoteCommunicationServerPlatform.h:28
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform
~GDBRemoteCommunicationServerPlatform() override
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult
PacketResult
Definition: GDBRemoteCommunication.h:92
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::SetPortMap
void SetPortMap(PortMap &&port_map)
Definition: GDBRemoteCommunicationServerPlatform.cpp:571
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:249
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_pending_gdb_server
struct lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::@75 m_pending_gdb_server
LIBLLDB_LOG_PLATFORM
#define LIBLLDB_LOG_PLATFORM
Definition: Logging.h:39
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_port_map
PortMap m_port_map
Definition: GDBRemoteCommunicationServerPlatform.h:105
StringExtractorGDBRemote::eServerPacketType_qC
@ eServerPacketType_qC
Definition: StringExtractorGDBRemote.h:55
StringExtractorGDBRemote::eServerPacketType_qProcessInfo
@ eServerPacketType_qProcessInfo
Definition: StringExtractorGDBRemote.h:116
lldb_private::ProcessInfo::GetProcessID
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
StringExtractor::GetHexMaxU32
uint32_t GetHexMaxU32(bool little_endian, uint32_t fail_value)
Definition: StringExtractor.cpp:155
StringExtractorGDBRemote.h
lldb_private::Args
Definition: Args.h:33
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer
PacketResult Handle_qLaunchGDBServer(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:233
lldb_private::UriParser::Parse
static bool Parse(llvm::StringRef uri, llvm::StringRef &scheme, llvm::StringRef &hostname, llvm::Optional< uint16_t > &port, llvm::StringRef &path)
Definition: UriParser.cpp:19
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon
Definition: GDBRemoteCommunicationServerCommon.h:27
lldb_private::Stream::PutStringAsRawHex8
size_t PutStringAsRawHex8(llvm::StringRef s)
Definition: Stream.cpp:382
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::LaunchGDBServer
Status LaunchGDBServer(const lldb_private::Args &args, std::string hostname, lldb::pid_t &pid, llvm::Optional< uint16_t > &port, std::string &socket_name)
Definition: GDBRemoteCommunicationServerPlatform.cpp:159
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::SetPortOffset
void SetPortOffset(uint16_t port_offset)
Definition: GDBRemoteCommunicationServerPlatform.cpp:604
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_spawned_pids
std::set< lldb::pid_t > m_spawned_pids
Definition: GDBRemoteCommunicationServerPlatform.h:103
lldb_private::FileSpec::GetCString
const char * GetCString(bool denormalize=true) const
Definition: FileSpec.cpp:364
lldb_private::StringList::end
iterator end()
Definition: StringList.h:61
llvm::json
Definition: TraceJSONStructs.cpp:19
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::PortMap::GetNextAvailablePort
llvm::Expected< uint16_t > GetNextAvailablePort()
Definition: GDBRemoteCommunicationServerPlatform.cpp:57
Platform.h
lldb_private::FileSpec
Definition: FileSpec.h:56
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
LLDB_INVALID_SIGNAL_NUMBER
#define LLDB_INVALID_SIGNAL_NUMBER
Definition: lldb-defines.h:96
lldb_private::StreamString::GetSize
size_t GetSize() const
Definition: StreamString.cpp:38
lldb_private::ProcessLaunchInfo::Clear
void Clear()
Definition: ProcessLaunchInfo.cpp:165
lldb_private::process_gdb_remote::GDBRemoteCommunication::StartDebugserverProcess
Status StartDebugserverProcess(const char *url, Platform *platform, ProcessLaunchInfo &launch_info, uint16_t *port, const Args *inferior_args, int pass_comm_fd)
Definition: GDBRemoteCommunication.cpp:903
lldb_private::StructuredData::Object::Dump
void Dump(lldb_private::Stream &s, bool pretty_print=true) const
Definition: StructuredData.h:156
SIGKILL
#define SIGKILL
Definition: windows/PosixApi.h:31
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::PortMap::FreePortForProcess
bool FreePortForProcess(lldb::pid_t pid)
Definition: GDBRemoteCommunicationServerPlatform.cpp:91
Log.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::PortMap::FreePort
bool FreePort(uint16_t port)
Definition: GDBRemoteCommunicationServerPlatform.cpp:82
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qC
PacketResult Handle_qC(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:472
UnixSignals.h
StringExtractorGDBRemote::eServerPacketType_qPathComplete
@ eServerPacketType_qPathComplete
Definition: StringExtractorGDBRemote.h:79
StreamString.h
StringExtractorGDBRemote::eServerPacketType_jSignalsInfo
@ eServerPacketType_jSignalsInfo
Definition: StringExtractorGDBRemote.h:130
lldb_private::UnixSignals::CreateForHost
static lldb::UnixSignalsSP CreateForHost()
Definition: UnixSignals.cpp:53
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::RegisterMemberFunctionHandler
void RegisterMemberFunctionHandler(StringExtractorGDBRemote::ServerPacketType packet_type, PacketResult(T::*handler)(StringExtractorGDBRemote &packet))
Definition: GDBRemoteCommunicationServerCommon.h:119
StringExtractorGDBRemote::eServerPacketType_qKillSpawnedProcess
@ eServerPacketType_qKillSpawnedProcess
Definition: StringExtractorGDBRemote.h:61
lldb_private::StringList
Definition: StringList.h:25
lldb_private::StreamString
Definition: StreamString.h:23
GDBRemote.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qPathComplete
PacketResult Handle_qPathComplete(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:415
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_QSetWorkingDir
PacketResult Handle_QSetWorkingDir(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:460
ConnectionFileDescriptor.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_spawned_pids_mutex
std::recursive_mutex m_spawned_pids_mutex
Definition: GDBRemoteCommunicationServerPlatform.h:102
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_socket_scheme
const std::string m_socket_scheme
Definition: GDBRemoteCommunicationServerPlatform.h:101
lldb_private::StructuredData::Array::Push
void Push(const ObjectSP &item)
Definition: StructuredData.h:274
HostInfo.h
lldb_private::CommandCompletions::DiskDirectories
static void DiskDirectories(CommandInterpreter &interpreter, CompletionRequest &request, SearchFilter *searcher)
Definition: CommandCompletions.cpp:484
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::pid
lldb::pid_t pid
Definition: GDBRemoteCommunicationServerPlatform.h:108
StringExtractor::GetChar
char GetChar(char fail_value='\0')
Definition: StringExtractor.cpp:45
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
StringExtractor::GetNameColonValue
bool GetNameColonValue(llvm::StringRef &name, llvm::StringRef &value)
Definition: StringExtractor.cpp:335
lldb_private::Stream::PutChar
size_t PutChar(char ch)
Definition: Stream.cpp:104
lldb_private::process_gdb_remote
Definition: GDBRemoteClientBase.h:17
lldb_private::CommandCompletions::DiskFiles
static void DiskFiles(CommandInterpreter &interpreter, CompletionRequest &request, SearchFilter *searcher)
Definition: CommandCompletions.cpp:472
StringExtractorGDBRemote::eServerPacketType_qLaunchGDBServer
@ eServerPacketType_qLaunchGDBServer
Definition: StringExtractorGDBRemote.h:59
StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir
@ eServerPacketType_QSetWorkingDir
Definition: StringExtractorGDBRemote.h:77
lldb_private::ProcessLaunchInfo::SetLaunchInSeparateProcessGroup
void SetLaunchInSeparateProcessGroup(bool separate)
Definition: ProcessLaunchInfo.cpp:151
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult::Success
@ Success
StringExtractor::GetHexByteString
size_t GetHexByteString(std::string &str)
Definition: StringExtractor.cpp:300
StringExtractor::GetU64
uint64_t GetU64(uint64_t fail_value, int base=0)
Definition: StringExtractor.cpp:125
lldb_private::ProcessLaunchInfo::SetMonitorProcessCallback
void SetMonitorProcessCallback(const Host::MonitorChildProcessCallback &callback, bool monitor_signals)
Definition: ProcessLaunchInfo.cpp:179
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::socket_name
std::string socket_name
Definition: GDBRemoteCommunicationServerPlatform.h:110
GDBRemoteCommunicationServerPlatform.h
lldb_private::Stream::PutBytesAsRawHex8
size_t PutBytesAsRawHex8(const void *src, size_t src_len, lldb::ByteOrder src_byte_order=lldb::eByteOrderInvalid, lldb::ByteOrder dst_byte_order=lldb::eByteOrderInvalid)
Definition: Stream.cpp:356
lldb_private::Status
Definition: Status.h:44
lldb_private::Socket::ProtocolTcp
@ ProtocolTcp
Definition: Socket.h:45
lldb_private::Args::GetArgumentAtIndex
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
Definition: Args.cpp:259
TildeExpressionResolver.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess
PacketResult Handle_qKillSpawnedProcess(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerPlatform.cpp:319
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped
bool DebugserverProcessReaped(lldb::pid_t pid)
Definition: GDBRemoteCommunicationServerPlatform.cpp:526
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::GetDomainSocketDir
static const FileSpec & GetDomainSocketDir()
Definition: GDBRemoteCommunicationServerPlatform.cpp:575
StringExtractorGDBRemote::eServerPacketType_interrupt
@ eServerPacketType_interrupt
Definition: StringExtractorGDBRemote.h:51
lldb_private::Host::GetProcessInfo
static bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info)
Definition: freebsd/Host.cpp:230
lldb_private::StreamGDBRemote
Definition: GDBRemote.h:27
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
lldb_private::process_gdb_remote::GDBRemoteCommunication::SendPacketNoLock
PacketResult SendPacketNoLock(llvm::StringRef payload)
Definition: GDBRemoteCommunication.cpp:121
uint16_t
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::SetPendingGdbServer
void SetPendingGdbServer(lldb::pid_t pid, uint16_t port, const std::string &socket_name)
Definition: GDBRemoteCommunicationServerPlatform.cpp:608
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::port
uint16_t port
Definition: GDBRemoteCommunicationServerPlatform.h:109
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::m_port_offset
uint16_t m_port_offset
Definition: GDBRemoteCommunicationServerPlatform.h:106
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer::SendOKResponse
PacketResult SendOKResponse()
Definition: GDBRemoteCommunicationServer.cpp:149
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse_DebugServerStyle
static void CreateProcessInfoResponse_DebugServerStyle(const ProcessInstanceInfo &proc_info, StreamString &response)
Definition: GDBRemoteCommunicationServerCommon.cpp:1233
lldb_private::FileSpec::AppendPathComponent
void AppendPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:435
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::StreamGDBRemote::PutEscapedBytes
int PutEscapedBytes(const void *s, size_t src_len)
Output a block of data to the stream performing GDB-remote escaping.
Definition: GDBRemote.cpp:29
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::m_process_launch_info
ProcessLaunchInfo m_process_launch_info
Definition: GDBRemoteCommunicationServerCommon.h:35
StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir
@ eServerPacketType_qGetWorkingDir
Definition: StringExtractorGDBRemote.h:67
StringExtractorGDBRemote
Definition: StringExtractorGDBRemote.h:21
lldb_private::Communication::GetConnection
lldb_private::Connection * GetConnection()
Definition: Communication.h:162
lldb_private::Log
Definition: Log.h:49
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
UriParser.h
lldb_private::GetLogIfAnyCategoriesSet
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
FileAction.h
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:348
lldb_private::Host::Kill
static void Kill(lldb::pid_t pid, int signo)
Definition: common/Host.cpp:637
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerPlatform::KillSpawnedProcess
bool KillSpawnedProcess(lldb::pid_t pid)
Definition: GDBRemoteCommunicationServerPlatform.cpp:341
lldb_private::Args::GetArgumentCount
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:118
lldb_private::ConnectionFileDescriptor
Definition: ConnectionFileDescriptorPosix.h:29
lldb
Definition: SBAddress.h:15
CommandCompletions.h