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 //----------------------------------------------------------------------
GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,const char * socket_scheme)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 //----------------------------------------------------------------------
~GDBRemoteCommunicationServerPlatform()93 GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform() {}
94
LaunchGDBServer(const lldb_private::Args & args,std::string hostname,lldb::pid_t & pid,uint16_t & port,std::string & socket_name)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
Handle_qLaunchGDBServer(StringExtractorGDBRemote & packet)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
Handle_qQueryGDBServer(StringExtractorGDBRemote & packet)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
Handle_qKillSpawnedProcess(StringExtractorGDBRemote & packet)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
KillSpawnedProcess(lldb::pid_t pid)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
Handle_qProcessInfo(StringExtractorGDBRemote & packet)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
Handle_qGetWorkingDir(StringExtractorGDBRemote & packet)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
Handle_QSetWorkingDir(StringExtractorGDBRemote & packet)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
Handle_qC(StringExtractorGDBRemote & packet)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
Handle_jSignalsInfo(StringExtractorGDBRemote & packet)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
DebugserverProcessReaped(lldb::pid_t pid)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
LaunchProcess()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
SetPortMap(PortMap && port_map)470 void GDBRemoteCommunicationServerPlatform::SetPortMap(PortMap &&port_map) {
471 m_port_map = port_map;
472 }
473
GetNextAvailablePort()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
AssociatePortWithProcess(uint16_t port,lldb::pid_t pid)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
FreePort(uint16_t port)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
FreePortForProcess(lldb::pid_t pid)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
GetDomainSocketDir()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
GetDomainSocketPath(const char * prefix)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
SetPortOffset(uint16_t port_offset)548 void GDBRemoteCommunicationServerPlatform::SetPortOffset(uint16_t port_offset) {
549 m_port_offset = port_offset;
550 }
551
SetPendingGdbServer(lldb::pid_t pid,uint16_t port,const std::string & socket_name)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 }
558