lldb-gdbserver.cpp revision 360784 
1//===-- lldb-gdbserver.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 <errno.h>
10#include <stdint.h>
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14
15#ifndef _WIN32
16#include <signal.h>
17#include <unistd.h>
18#endif
19
20
21#include "Acceptor.h"
22#include "LLDBServerUtilities.h"
23#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h"
24#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
25#include "lldb/Host/Config.h"
26#include "lldb/Host/ConnectionFileDescriptor.h"
27#include "lldb/Host/FileSystem.h"
28#include "lldb/Host/HostGetOpt.h"
29#include "lldb/Host/OptionParser.h"
30#include "lldb/Host/Pipe.h"
31#include "lldb/Host/Socket.h"
32#include "lldb/Host/StringConvert.h"
33#include "lldb/Host/common/NativeProcessProtocol.h"
34#include "lldb/Target/Process.h"
35#include "lldb/Utility/Status.h"
36#include "llvm/ADT/StringRef.h"
37#include "llvm/Support/Errno.h"
38
39#if defined(__linux__)
40#include "Plugins/Process/Linux/NativeProcessLinux.h"
41#elif defined(__NetBSD__)
42#include "Plugins/Process/NetBSD/NativeProcessNetBSD.h"
43#elif defined(_WIN32)
44#include "Plugins/Process/Windows/Common/NativeProcessWindows.h"
45#endif
46
47#ifndef LLGS_PROGRAM_NAME
48#define LLGS_PROGRAM_NAME "lldb-server"
49#endif
50
51#ifndef LLGS_VERSION_STR
52#define LLGS_VERSION_STR "local_build"
53#endif
54
55using namespace llvm;
56using namespace lldb;
57using namespace lldb_private;
58using namespace lldb_private::lldb_server;
59using namespace lldb_private::process_gdb_remote;
60
61namespace {
62#if defined(__linux__)
63typedef process_linux::NativeProcessLinux::Factory NativeProcessFactory;
64#elif defined(__NetBSD__)
65typedef process_netbsd::NativeProcessNetBSD::Factory NativeProcessFactory;
66#elif defined(_WIN32)
67typedef NativeProcessWindows::Factory NativeProcessFactory;
68#else
69// Dummy implementation to make sure the code compiles
70class NativeProcessFactory : public NativeProcessProtocol::Factory {
71public:
72  llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
73  Launch(ProcessLaunchInfo &launch_info,
74         NativeProcessProtocol::NativeDelegate &delegate,
75         MainLoop &mainloop) const override {
76    llvm_unreachable("Not implemented");
77  }
78  llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
79  Attach(lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &delegate,
80         MainLoop &mainloop) const override {
81    llvm_unreachable("Not implemented");
82  }
83};
84#endif
85}
86
87// option descriptors for getopt_long_only()
88
89static int g_debug = 0;
90static int g_verbose = 0;
91
92static struct option g_long_options[] = {
93    {"debug", no_argument, &g_debug, 1},
94    {"verbose", no_argument, &g_verbose, 1},
95    {"log-file", required_argument, nullptr, 'l'},
96    {"log-channels", required_argument, nullptr, 'c'},
97    {"attach", required_argument, nullptr, 'a'},
98    {"named-pipe", required_argument, nullptr, 'N'},
99    {"pipe", required_argument, nullptr, 'U'},
100    {"native-regs", no_argument, nullptr,
101     'r'}, // Specify to use the native registers instead of the gdb defaults
102           // for the architecture.  NOTE: this is a do-nothing arg as it's
103           // behavior is default now.  FIXME remove call from lldb-platform.
104    {"reverse-connect", no_argument, nullptr,
105     'R'}, // Specifies that llgs attaches to the client address:port rather
106           // than llgs listening for a connection from address on port.
107    {"setsid", no_argument, nullptr,
108     'S'}, // Call setsid() to make llgs run in its own session.
109    {"fd", required_argument, nullptr, 'F'},
110    {nullptr, 0, nullptr, 0}};
111
112#ifndef _WIN32
113// Watch for signals
114static int g_sighup_received_count = 0;
115
116static void sighup_handler(MainLoopBase &mainloop) {
117  ++g_sighup_received_count;
118
119  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
120  LLDB_LOGF(log, "lldb-server:%s swallowing SIGHUP (receive count=%d)",
121            __FUNCTION__, g_sighup_received_count);
122
123  if (g_sighup_received_count >= 2)
124    mainloop.RequestTermination();
125}
126#endif // #ifndef _WIN32
127
128static void display_usage(const char *progname, const char *subcommand) {
129  fprintf(stderr, "Usage:\n  %s %s "
130                  "[--log-file log-file-name] "
131                  "[--log-channels log-channel-list] "
132                  "[--setsid] "
133                  "[--fd file-descriptor]"
134                  "[--named-pipe named-pipe-path] "
135                  "[--native-regs] "
136                  "[--attach pid] "
137                  "[[HOST]:PORT] "
138                  "[-- PROGRAM ARG1 ARG2 ...]\n",
139          progname, subcommand);
140}
141
142void handle_attach_to_pid(GDBRemoteCommunicationServerLLGS &gdb_server,
143                          lldb::pid_t pid) {
144  Status error = gdb_server.AttachToProcess(pid);
145  if (error.Fail()) {
146    fprintf(stderr, "error: failed to attach to pid %" PRIu64 ": %s\n", pid,
147            error.AsCString());
148    exit(1);
149  }
150}
151
152void handle_attach_to_process_name(GDBRemoteCommunicationServerLLGS &gdb_server,
153                                   const std::string &process_name) {
154  // FIXME implement.
155}
156
157void handle_attach(GDBRemoteCommunicationServerLLGS &gdb_server,
158                   const std::string &attach_target) {
159  assert(!attach_target.empty() && "attach_target cannot be empty");
160
161  // First check if the attach_target is convertible to a long. If so, we'll use
162  // it as a pid.
163  char *end_p = nullptr;
164  const long int pid = strtol(attach_target.c_str(), &end_p, 10);
165
166  // We'll call it a match if the entire argument is consumed.
167  if (end_p &&
168      static_cast<size_t>(end_p - attach_target.c_str()) ==
169          attach_target.size())
170    handle_attach_to_pid(gdb_server, static_cast<lldb::pid_t>(pid));
171  else
172    handle_attach_to_process_name(gdb_server, attach_target);
173}
174
175void handle_launch(GDBRemoteCommunicationServerLLGS &gdb_server, int argc,
176                   const char *const argv[]) {
177  ProcessLaunchInfo info;
178  info.GetFlags().Set(eLaunchFlagStopAtEntry | eLaunchFlagDebug |
179                      eLaunchFlagDisableASLR);
180  info.SetArguments(const_cast<const char **>(argv), true);
181
182  llvm::SmallString<64> cwd;
183  if (std::error_code ec = llvm::sys::fs::current_path(cwd)) {
184    llvm::errs() << "Error getting current directory: " << ec.message() << "\n";
185    exit(1);
186  }
187  FileSpec cwd_spec(cwd);
188  FileSystem::Instance().Resolve(cwd_spec);
189  info.SetWorkingDirectory(cwd_spec);
190  info.GetEnvironment() = Host::GetEnvironment();
191
192  gdb_server.SetLaunchInfo(info);
193
194  Status error = gdb_server.LaunchProcess();
195  if (error.Fail()) {
196    llvm::errs() << llvm::formatv("error: failed to launch '{0}': {1}\n",
197                                  argv[0], error);
198    exit(1);
199  }
200}
201
202Status writeSocketIdToPipe(Pipe &port_pipe, const std::string &socket_id) {
203  size_t bytes_written = 0;
204  // Write the port number as a C string with the NULL terminator.
205  return port_pipe.Write(socket_id.c_str(), socket_id.size() + 1,
206                         bytes_written);
207}
208
209Status writeSocketIdToPipe(const char *const named_pipe_path,
210                           const std::string &socket_id) {
211  Pipe port_name_pipe;
212  // Wait for 10 seconds for pipe to be opened.
213  auto error = port_name_pipe.OpenAsWriterWithTimeout(named_pipe_path, false,
214                                                      std::chrono::seconds{10});
215  if (error.Fail())
216    return error;
217  return writeSocketIdToPipe(port_name_pipe, socket_id);
218}
219
220Status writeSocketIdToPipe(lldb::pipe_t unnamed_pipe,
221                           const std::string &socket_id) {
222  Pipe port_pipe{LLDB_INVALID_PIPE, unnamed_pipe};
223  return writeSocketIdToPipe(port_pipe, socket_id);
224}
225
226void ConnectToRemote(MainLoop &mainloop,
227                     GDBRemoteCommunicationServerLLGS &gdb_server,
228                     bool reverse_connect, const char *const host_and_port,
229                     const char *const progname, const char *const subcommand,
230                     const char *const named_pipe_path, pipe_t unnamed_pipe,
231                     int connection_fd) {
232  Status error;
233
234  std::unique_ptr<Connection> connection_up;
235  if (connection_fd != -1) {
236    // Build the connection string.
237    char connection_url[512];
238    snprintf(connection_url, sizeof(connection_url), "fd://%d", connection_fd);
239
240    // Create the connection.
241#if LLDB_ENABLE_POSIX && !defined _WIN32
242    ::fcntl(connection_fd, F_SETFD, FD_CLOEXEC);
243#endif
244    connection_up.reset(new ConnectionFileDescriptor);
245    auto connection_result = connection_up->Connect(connection_url, &error);
246    if (connection_result != eConnectionStatusSuccess) {
247      fprintf(stderr, "error: failed to connect to client at '%s' "
248                      "(connection status: %d)\n",
249              connection_url, static_cast<int>(connection_result));
250      exit(-1);
251    }
252    if (error.Fail()) {
253      fprintf(stderr, "error: failed to connect to client at '%s': %s\n",
254              connection_url, error.AsCString());
255      exit(-1);
256    }
257  } else if (host_and_port && host_and_port[0]) {
258    // Parse out host and port.
259    std::string final_host_and_port;
260    std::string connection_host;
261    std::string connection_port;
262    uint32_t connection_portno = 0;
263
264    // If host_and_port starts with ':', default the host to be "localhost" and
265    // expect the remainder to be the port.
266    if (host_and_port[0] == ':')
267      final_host_and_port.append("localhost");
268    final_host_and_port.append(host_and_port);
269
270    const std::string::size_type colon_pos = final_host_and_port.find(':');
271    if (colon_pos != std::string::npos) {
272      connection_host = final_host_and_port.substr(0, colon_pos);
273      connection_port = final_host_and_port.substr(colon_pos + 1);
274      connection_portno = StringConvert::ToUInt32(connection_port.c_str(), 0);
275    }
276
277
278    if (reverse_connect) {
279      // llgs will connect to the gdb-remote client.
280
281      // Ensure we have a port number for the connection.
282      if (connection_portno == 0) {
283        fprintf(stderr, "error: port number must be specified on when using "
284                        "reverse connect\n");
285        exit(1);
286      }
287
288      // Build the connection string.
289      char connection_url[512];
290      snprintf(connection_url, sizeof(connection_url), "connect://%s",
291               final_host_and_port.c_str());
292
293      // Create the connection.
294      connection_up.reset(new ConnectionFileDescriptor);
295      auto connection_result = connection_up->Connect(connection_url, &error);
296      if (connection_result != eConnectionStatusSuccess) {
297        fprintf(stderr, "error: failed to connect to client at '%s' "
298                        "(connection status: %d)\n",
299                connection_url, static_cast<int>(connection_result));
300        exit(-1);
301      }
302      if (error.Fail()) {
303        fprintf(stderr, "error: failed to connect to client at '%s': %s\n",
304                connection_url, error.AsCString());
305        exit(-1);
306      }
307    } else {
308      std::unique_ptr<Acceptor> acceptor_up(
309          Acceptor::Create(final_host_and_port, false, error));
310      if (error.Fail()) {
311        fprintf(stderr, "failed to create acceptor: %s\n", error.AsCString());
312        exit(1);
313      }
314      error = acceptor_up->Listen(1);
315      if (error.Fail()) {
316        fprintf(stderr, "failed to listen: %s\n", error.AsCString());
317        exit(1);
318      }
319      const std::string socket_id = acceptor_up->GetLocalSocketId();
320      if (!socket_id.empty()) {
321        // If we have a named pipe to write the socket id back to, do that now.
322        if (named_pipe_path && named_pipe_path[0]) {
323          error = writeSocketIdToPipe(named_pipe_path, socket_id);
324          if (error.Fail())
325            fprintf(stderr, "failed to write to the named pipe \'%s\': %s\n",
326                    named_pipe_path, error.AsCString());
327        }
328        // If we have an unnamed pipe to write the socket id back to, do that
329        // now.
330        else if (unnamed_pipe != LLDB_INVALID_PIPE) {
331          error = writeSocketIdToPipe(unnamed_pipe, socket_id);
332          if (error.Fail())
333            fprintf(stderr, "failed to write to the unnamed pipe: %s\n",
334                    error.AsCString());
335        }
336      } else {
337        fprintf(stderr,
338                "unable to get the socket id for the listening connection\n");
339      }
340
341      Connection *conn = nullptr;
342      error = acceptor_up->Accept(false, conn);
343      if (error.Fail()) {
344        printf("failed to accept new connection: %s\n", error.AsCString());
345        exit(1);
346      }
347      connection_up.reset(conn);
348    }
349  }
350  error = gdb_server.InitializeConnection(std::move(connection_up));
351  if (error.Fail()) {
352    fprintf(stderr, "Failed to initialize connection: %s\n",
353            error.AsCString());
354    exit(-1);
355  }
356  printf("Connection established.\n");
357}
358
359// main
360int main_gdbserver(int argc, char *argv[]) {
361  Status error;
362  MainLoop mainloop;
363#ifndef _WIN32
364  // Setup signal handlers first thing.
365  signal(SIGPIPE, SIG_IGN);
366  MainLoop::SignalHandleUP sighup_handle =
367      mainloop.RegisterSignal(SIGHUP, sighup_handler, error);
368#endif
369
370  const char *progname = argv[0];
371  const char *subcommand = argv[1];
372  argc--;
373  argv++;
374  int long_option_index = 0;
375  int ch;
376  std::string attach_target;
377  std::string named_pipe_path;
378  std::string log_file;
379  StringRef
380      log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
381  lldb::pipe_t unnamed_pipe = LLDB_INVALID_PIPE;
382  bool reverse_connect = false;
383  int connection_fd = -1;
384
385  // ProcessLaunchInfo launch_info;
386  ProcessAttachInfo attach_info;
387
388  bool show_usage = false;
389  int option_error = 0;
390#if __GLIBC__
391  optind = 0;
392#else
393  optreset = 1;
394  optind = 1;
395#endif
396
397  std::string short_options(OptionParser::GetShortOptionString(g_long_options));
398
399  while ((ch = getopt_long_only(argc, argv, short_options.c_str(),
400                                g_long_options, &long_option_index)) != -1) {
401    switch (ch) {
402    case 0: // Any optional that auto set themselves will return 0
403      break;
404
405    case 'l': // Set Log File
406      if (optarg && optarg[0])
407        log_file.assign(optarg);
408      break;
409
410    case 'c': // Log Channels
411      if (optarg && optarg[0])
412        log_channels = StringRef(optarg);
413      break;
414
415    case 'N': // named pipe
416      if (optarg && optarg[0])
417        named_pipe_path = optarg;
418      break;
419
420    case 'U': // unnamed pipe
421      if (optarg && optarg[0])
422        unnamed_pipe = (pipe_t)StringConvert::ToUInt64(optarg, -1);
423      break;
424
425    case 'r':
426      // Do nothing, native regs is the default these days
427      break;
428
429    case 'R':
430      reverse_connect = true;
431      break;
432
433    case 'F':
434      connection_fd = StringConvert::ToUInt32(optarg, -1);
435      break;
436
437#ifndef _WIN32
438    case 'S':
439      // Put llgs into a new session. Terminals group processes
440      // into sessions and when a special terminal key sequences
441      // (like control+c) are typed they can cause signals to go out to
442      // all processes in a session. Using this --setsid (-S) option
443      // will cause debugserver to run in its own sessions and be free
444      // from such issues.
445      //
446      // This is useful when llgs is spawned from a command
447      // line application that uses llgs to do the debugging,
448      // yet that application doesn't want llgs receiving the
449      // signals sent to the session (i.e. dying when anyone hits ^C).
450      {
451        const ::pid_t new_sid = setsid();
452        if (new_sid == -1) {
453          llvm::errs() << llvm::formatv(
454              "failed to set new session id for {0} ({1})\n", LLGS_PROGRAM_NAME,
455              llvm::sys::StrError());
456        }
457      }
458      break;
459#endif
460
461    case 'a': // attach {pid|process_name}
462      if (optarg && optarg[0])
463        attach_target = optarg;
464      break;
465
466    case 'h': /* fall-through is intentional */
467    case '?':
468      show_usage = true;
469      break;
470    }
471  }
472
473  if (show_usage || option_error) {
474    display_usage(progname, subcommand);
475    exit(option_error);
476  }
477
478  if (!LLDBServerUtilities::SetupLogging(
479          log_file, log_channels,
480          LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
481              LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION))
482    return -1;
483
484  Log *log(lldb_private::GetLogIfAnyCategoriesSet(GDBR_LOG_PROCESS));
485  if (log) {
486    LLDB_LOGF(log, "lldb-server launch");
487    for (int i = 0; i < argc; i++) {
488      LLDB_LOGF(log, "argv[%i] = '%s'", i, argv[i]);
489    }
490  }
491
492  // Skip any options we consumed with getopt_long_only.
493  argc -= optind;
494  argv += optind;
495
496  if (argc == 0 && connection_fd == -1) {
497    fputs("No arguments\n", stderr);
498    display_usage(progname, subcommand);
499    exit(255);
500  }
501
502  NativeProcessFactory factory;
503  GDBRemoteCommunicationServerLLGS gdb_server(mainloop, factory);
504
505  const char *const host_and_port = argv[0];
506  argc -= 1;
507  argv += 1;
508
509  // Any arguments left over are for the program that we need to launch. If
510  // there
511  // are no arguments, then the GDB server will start up and wait for an 'A'
512  // packet
513  // to launch a program, or a vAttach packet to attach to an existing process,
514  // unless
515  // explicitly asked to attach with the --attach={pid|program_name} form.
516  if (!attach_target.empty())
517    handle_attach(gdb_server, attach_target);
518  else if (argc > 0)
519    handle_launch(gdb_server, argc, argv);
520
521  // Print version info.
522  printf("%s-%s\n", LLGS_PROGRAM_NAME, LLGS_VERSION_STR);
523
524  ConnectToRemote(mainloop, gdb_server, reverse_connect, host_and_port,
525                  progname, subcommand, named_pipe_path.c_str(),
526                  unnamed_pipe, connection_fd);
527
528  if (!gdb_server.IsConnected()) {
529    fprintf(stderr, "no connection information provided, unable to run\n");
530    display_usage(progname, subcommand);
531    return 1;
532  }
533
534  Status ret = mainloop.Run();
535  if (ret.Fail()) {
536    fprintf(stderr, "lldb-server terminating due to error: %s\n",
537            ret.AsCString());
538    return 1;
539  }
540  fprintf(stderr, "lldb-server exiting...\n");
541
542  return 0;
543}
544