llvm-project

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 <cerrno>
10
#include <cstdint>
11
#include <cstdio>
12
#include <cstdlib>
13
#include <cstring>
14

15
#ifndef _WIN32
16
#include <csignal>
17
#include <unistd.h>
18
#endif
19

20
#include "LLDBServerUtilities.h"
21
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h"
22
#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
23
#include "lldb/Host/Config.h"
24
#include "lldb/Host/ConnectionFileDescriptor.h"
25
#include "lldb/Host/FileSystem.h"
26
#include "lldb/Host/Pipe.h"
27
#include "lldb/Host/Socket.h"
28
#include "lldb/Host/common/NativeProcessProtocol.h"
29
#include "lldb/Target/Process.h"
30
#include "lldb/Utility/LLDBLog.h"
31
#include "lldb/Utility/Status.h"
32
#include "llvm/ADT/StringRef.h"
33
#include "llvm/Option/ArgList.h"
34
#include "llvm/Option/OptTable.h"
35
#include "llvm/Option/Option.h"
36
#include "llvm/Support/Errno.h"
37
#include "llvm/Support/Error.h"
38
#include "llvm/Support/WithColor.h"
39

40
#if defined(__linux__)
41
#include "Plugins/Process/Linux/NativeProcessLinux.h"
42
#elif defined(__FreeBSD__)
43
#include "Plugins/Process/FreeBSD/NativeProcessFreeBSD.h"
44
#elif defined(__NetBSD__)
45
#include "Plugins/Process/NetBSD/NativeProcessNetBSD.h"
46
#elif defined(_WIN32)
47
#include "Plugins/Process/Windows/Common/NativeProcessWindows.h"
48
#endif
49

50
#ifndef LLGS_PROGRAM_NAME
51
#define LLGS_PROGRAM_NAME "lldb-server"
52
#endif
53

54
#ifndef LLGS_VERSION_STR
55
#define LLGS_VERSION_STR "local_build"
56
#endif
57

58
using namespace llvm;
59
using namespace lldb;
60
using namespace lldb_private;
61
using namespace lldb_private::lldb_server;
62
using namespace lldb_private::process_gdb_remote;
63

64
namespace {
65
#if defined(__linux__)
66
typedef process_linux::NativeProcessLinux::Manager NativeProcessManager;
67
#elif defined(__FreeBSD__)
68
typedef process_freebsd::NativeProcessFreeBSD::Manager NativeProcessManager;
69
#elif defined(__NetBSD__)
70
typedef process_netbsd::NativeProcessNetBSD::Manager NativeProcessManager;
71
#elif defined(_WIN32)
72
typedef NativeProcessWindows::Manager NativeProcessManager;
73
#else
74
// Dummy implementation to make sure the code compiles
75
class NativeProcessManager : public NativeProcessProtocol::Manager {
76
public:
77
  NativeProcessManager(MainLoop &mainloop)
78
      : NativeProcessProtocol::Manager(mainloop) {}
79

80
  llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
81
  Launch(ProcessLaunchInfo &launch_info,
82
         NativeProcessProtocol::NativeDelegate &native_delegate) override {
83
    llvm_unreachable("Not implemented");
84
  }
85
  llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
86
  Attach(lldb::pid_t pid,
87
         NativeProcessProtocol::NativeDelegate &native_delegate) override {
88
    llvm_unreachable("Not implemented");
89
  }
90
};
91
#endif
92
}
93

94
#ifndef _WIN32
95
// Watch for signals
96
static int g_sighup_received_count = 0;
97

98
static void sighup_handler(MainLoopBase &mainloop) {
99
  ++g_sighup_received_count;
100

101
  Log *log = GetLog(LLDBLog::Process);
102
  LLDB_LOGF(log, "lldb-server:%s swallowing SIGHUP (receive count=%d)",
103
            __FUNCTION__, g_sighup_received_count);
104

105
  if (g_sighup_received_count >= 2)
106
    mainloop.RequestTermination();
107
}
108
#endif // #ifndef _WIN32
109

110
void handle_attach_to_pid(GDBRemoteCommunicationServerLLGS &gdb_server,
111
                          lldb::pid_t pid) {
112
  Status error = gdb_server.AttachToProcess(pid);
113
  if (error.Fail()) {
114
    fprintf(stderr, "error: failed to attach to pid %" PRIu64 ": %s\n", pid,
115
            error.AsCString());
116
    exit(1);
117
  }
118
}
119

120
void handle_attach_to_process_name(GDBRemoteCommunicationServerLLGS &gdb_server,
121
                                   const std::string &process_name) {
122
  // FIXME implement.
123
}
124

125
void handle_attach(GDBRemoteCommunicationServerLLGS &gdb_server,
126
                   const std::string &attach_target) {
127
  assert(!attach_target.empty() && "attach_target cannot be empty");
128

129
  // First check if the attach_target is convertible to a long. If so, we'll use
130
  // it as a pid.
131
  char *end_p = nullptr;
132
  const long int pid = strtol(attach_target.c_str(), &end_p, 10);
133

134
  // We'll call it a match if the entire argument is consumed.
135
  if (end_p &&
136
      static_cast<size_t>(end_p - attach_target.c_str()) ==
137
          attach_target.size())
138
    handle_attach_to_pid(gdb_server, static_cast<lldb::pid_t>(pid));
139
  else
140
    handle_attach_to_process_name(gdb_server, attach_target);
141
}
142

143
void handle_launch(GDBRemoteCommunicationServerLLGS &gdb_server,
144
                   llvm::ArrayRef<llvm::StringRef> Arguments) {
145
  ProcessLaunchInfo info;
146
  info.GetFlags().Set(eLaunchFlagStopAtEntry | eLaunchFlagDebug |
147
                      eLaunchFlagDisableASLR);
148
  info.SetArguments(Args(Arguments), true);
149

150
  llvm::SmallString<64> cwd;
151
  if (std::error_code ec = llvm::sys::fs::current_path(cwd)) {
152
    llvm::errs() << "Error getting current directory: " << ec.message() << "\n";
153
    exit(1);
154
  }
155
  FileSpec cwd_spec(cwd);
156
  FileSystem::Instance().Resolve(cwd_spec);
157
  info.SetWorkingDirectory(cwd_spec);
158
  info.GetEnvironment() = Host::GetEnvironment();
159

160
  gdb_server.SetLaunchInfo(info);
161

162
  Status error = gdb_server.LaunchProcess();
163
  if (error.Fail()) {
164
    llvm::errs() << llvm::formatv("error: failed to launch '{0}': {1}\n",
165
                                  Arguments[0], error);
166
    exit(1);
167
  }
168
}
169

170
Status writeSocketIdToPipe(Pipe &port_pipe, llvm::StringRef socket_id) {
171
  size_t bytes_written = 0;
172
  // Write the port number as a C string with the NULL terminator.
173
  return port_pipe.Write(socket_id.data(), socket_id.size() + 1, bytes_written);
174
}
175

176
Status writeSocketIdToPipe(const char *const named_pipe_path,
177
                           llvm::StringRef socket_id) {
178
  Pipe port_name_pipe;
179
  // Wait for 10 seconds for pipe to be opened.
180
  auto error = port_name_pipe.OpenAsWriterWithTimeout(named_pipe_path, false,
181
                                                      std::chrono::seconds{10});
182
  if (error.Fail())
183
    return error;
184
  return writeSocketIdToPipe(port_name_pipe, socket_id);
185
}
186

187
Status writeSocketIdToPipe(lldb::pipe_t unnamed_pipe,
188
                           llvm::StringRef socket_id) {
189
  Pipe port_pipe{LLDB_INVALID_PIPE, unnamed_pipe};
190
  return writeSocketIdToPipe(port_pipe, socket_id);
191
}
192

193
void ConnectToRemote(MainLoop &mainloop,
194
                     GDBRemoteCommunicationServerLLGS &gdb_server,
195
                     bool reverse_connect, llvm::StringRef host_and_port,
196
                     const char *const progname, const char *const subcommand,
197
                     const char *const named_pipe_path, pipe_t unnamed_pipe,
198
                     int connection_fd) {
199
  Status error;
200

201
  std::unique_ptr<Connection> connection_up;
202
  std::string url;
203

204
  if (connection_fd != -1) {
205
    url = llvm::formatv("fd://{0}", connection_fd).str();
206

207
    // Create the connection.
208
#if LLDB_ENABLE_POSIX && !defined _WIN32
209
    ::fcntl(connection_fd, F_SETFD, FD_CLOEXEC);
210
#endif
211
  } else if (!host_and_port.empty()) {
212
    llvm::Expected<std::string> url_exp =
213
        LLGSArgToURL(host_and_port, reverse_connect);
214
    if (!url_exp) {
215
      llvm::errs() << llvm::formatv("error: invalid host:port or URL '{0}': "
216
                                    "{1}\n",
217
                                    host_and_port,
218
                                    llvm::toString(url_exp.takeError()));
219
      exit(-1);
220
    }
221

222
    url = std::move(url_exp.get());
223
  }
224

225
  if (!url.empty()) {
226
    // Create the connection or server.
227
    std::unique_ptr<ConnectionFileDescriptor> conn_fd_up{
228
        new ConnectionFileDescriptor};
229
    auto connection_result = conn_fd_up->Connect(
230
        url,
231
        [named_pipe_path, unnamed_pipe](llvm::StringRef socket_id) {
232
          // If we have a named pipe to write the socket id back to, do that
233
          // now.
234
          if (named_pipe_path && named_pipe_path[0]) {
235
            Status error = writeSocketIdToPipe(named_pipe_path, socket_id);
236
            if (error.Fail())
237
              llvm::errs() << llvm::formatv(
238
                  "failed to write to the named pipe '{0}': {1}\n",
239
                  named_pipe_path, error.AsCString());
240
          }
241
          // If we have an unnamed pipe to write the socket id back to, do
242
          // that now.
243
          else if (unnamed_pipe != LLDB_INVALID_PIPE) {
244
            Status error = writeSocketIdToPipe(unnamed_pipe, socket_id);
245
            if (error.Fail())
246
              llvm::errs() << llvm::formatv(
247
                  "failed to write to the unnamed pipe: {0}\n", error);
248
          }
249
        },
250
        &error);
251

252
    if (error.Fail()) {
253
      llvm::errs() << llvm::formatv(
254
          "error: failed to connect to client at '{0}': {1}\n", url, error);
255
      exit(-1);
256
    }
257
    if (connection_result != eConnectionStatusSuccess) {
258
      llvm::errs() << llvm::formatv(
259
          "error: failed to connect to client at '{0}' "
260
          "(connection status: {1})\n",
261
          url, static_cast<int>(connection_result));
262
      exit(-1);
263
    }
264
    connection_up = std::move(conn_fd_up);
265
  }
266
  error = gdb_server.InitializeConnection(std::move(connection_up));
267
  if (error.Fail()) {
268
    llvm::errs() << llvm::formatv("failed to initialize connection\n", error);
269
    exit(-1);
270
  }
271
  llvm::outs() << "Connection established.\n";
272
}
273

274
namespace {
275
using namespace llvm::opt;
276

277
enum ID {
278
  OPT_INVALID = 0, // This is not an option ID.
279
#define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__),
280
#include "LLGSOptions.inc"
281
#undef OPTION
282
};
283

284
#define PREFIX(NAME, VALUE)                                                    \
285
  constexpr llvm::StringLiteral NAME##_init[] = VALUE;                         \
286
  constexpr llvm::ArrayRef<llvm::StringLiteral> NAME(                          \
287
      NAME##_init, std::size(NAME##_init) - 1);
288
#include "LLGSOptions.inc"
289
#undef PREFIX
290

291
static constexpr opt::OptTable::Info InfoTable[] = {
292
#define OPTION(...) LLVM_CONSTRUCT_OPT_INFO(__VA_ARGS__),
293
#include "LLGSOptions.inc"
294
#undef OPTION
295
};
296

297
class LLGSOptTable : public opt::GenericOptTable {
298
public:
299
  LLGSOptTable() : opt::GenericOptTable(InfoTable) {}
300

301
  void PrintHelp(llvm::StringRef Name) {
302
    std::string Usage =
303
        (Name + " [options] [[host]:port] [[--] program args...]").str();
304
    OptTable::printHelp(llvm::outs(), Usage.c_str(), "lldb-server");
305
    llvm::outs() << R"(
306
DESCRIPTION
307
  lldb-server connects to the LLDB client, which drives the debugging session.
308
  If no connection options are given, the [host]:port argument must be present
309
  and will denote the address that lldb-server will listen on. [host] defaults
310
  to "localhost" if empty. Port can be zero, in which case the port number will
311
  be chosen dynamically and written to destinations given by --named-pipe and
312
  --pipe arguments.
313

314
  If no target is selected at startup, lldb-server can be directed by the LLDB
315
  client to launch or attach to a process.
316

317
)";
318
  }
319
};
320
} // namespace
321

322
int main_gdbserver(int argc, char *argv[]) {
323
  Status error;
324
  MainLoop mainloop;
325
#ifndef _WIN32
326
  // Setup signal handlers first thing.
327
  signal(SIGPIPE, SIG_IGN);
328
  MainLoop::SignalHandleUP sighup_handle =
329
      mainloop.RegisterSignal(SIGHUP, sighup_handler, error);
330
#endif
331

332
  const char *progname = argv[0];
333
  const char *subcommand = argv[1];
334
  std::string attach_target;
335
  std::string named_pipe_path;
336
  std::string log_file;
337
  StringRef
338
      log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
339
  lldb::pipe_t unnamed_pipe = LLDB_INVALID_PIPE;
340
  bool reverse_connect = false;
341
  int connection_fd = -1;
342

343
  // ProcessLaunchInfo launch_info;
344
  ProcessAttachInfo attach_info;
345

346
  LLGSOptTable Opts;
347
  llvm::BumpPtrAllocator Alloc;
348
  llvm::StringSaver Saver(Alloc);
349
  bool HasError = false;
350
  opt::InputArgList Args = Opts.parseArgs(argc - 1, argv + 1, OPT_UNKNOWN,
351
                                          Saver, [&](llvm::StringRef Msg) {
352
                                            WithColor::error() << Msg << "\n";
353
                                            HasError = true;
354
                                          });
355
  std::string Name =
356
      (llvm::sys::path::filename(argv[0]) + " g[dbserver]").str();
357
  std::string HelpText =
358
      "Use '" + Name + " --help' for a complete list of options.\n";
359
  if (HasError) {
360
    llvm::errs() << HelpText;
361
    return 1;
362
  }
363

364
  if (Args.hasArg(OPT_help)) {
365
    Opts.PrintHelp(Name);
366
    return 0;
367
  }
368

369
#ifndef _WIN32
370
  if (Args.hasArg(OPT_setsid)) {
371
    // Put llgs into a new session. Terminals group processes
372
    // into sessions and when a special terminal key sequences
373
    // (like control+c) are typed they can cause signals to go out to
374
    // all processes in a session. Using this --setsid (-S) option
375
    // will cause debugserver to run in its own sessions and be free
376
    // from such issues.
377
    //
378
    // This is useful when llgs is spawned from a command
379
    // line application that uses llgs to do the debugging,
380
    // yet that application doesn't want llgs receiving the
381
    // signals sent to the session (i.e. dying when anyone hits ^C).
382
    {
383
      const ::pid_t new_sid = setsid();
384
      if (new_sid == -1) {
385
        WithColor::warning()
386
            << llvm::formatv("failed to set new session id for {0} ({1})\n",
387
                             LLGS_PROGRAM_NAME, llvm::sys::StrError());
388
      }
389
    }
390
  }
391
#endif
392

393
  log_file = Args.getLastArgValue(OPT_log_file).str();
394
  log_channels = Args.getLastArgValue(OPT_log_channels);
395
  named_pipe_path = Args.getLastArgValue(OPT_named_pipe).str();
396
  reverse_connect = Args.hasArg(OPT_reverse_connect);
397
  attach_target = Args.getLastArgValue(OPT_attach).str();
398
  if (Args.hasArg(OPT_pipe)) {
399
    uint64_t Arg;
400
    if (!llvm::to_integer(Args.getLastArgValue(OPT_pipe), Arg)) {
401
      WithColor::error() << "invalid '--pipe' argument\n" << HelpText;
402
      return 1;
403
    }
404
    unnamed_pipe = (pipe_t)Arg;
405
  }
406
  if (Args.hasArg(OPT_fd)) {
407
    if (!llvm::to_integer(Args.getLastArgValue(OPT_fd), connection_fd)) {
408
      WithColor::error() << "invalid '--fd' argument\n" << HelpText;
409
      return 1;
410
    }
411
  }
412

413
  if (!LLDBServerUtilities::SetupLogging(
414
          log_file, log_channels,
415
          LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
416
              LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION))
417
    return -1;
418

419
  std::vector<llvm::StringRef> Inputs;
420
  for (opt::Arg *Arg : Args.filtered(OPT_INPUT))
421
    Inputs.push_back(Arg->getValue());
422
  if (opt::Arg *Arg = Args.getLastArg(OPT_REM)) {
423
    for (const char *Val : Arg->getValues())
424
      Inputs.push_back(Val);
425
  }
426
  if (Inputs.empty() && connection_fd == -1) {
427
    WithColor::error() << "no connection arguments\n" << HelpText;
428
    return 1;
429
  }
430

431
  NativeProcessManager manager(mainloop);
432
  GDBRemoteCommunicationServerLLGS gdb_server(mainloop, manager);
433

434
  llvm::StringRef host_and_port;
435
  if (!Inputs.empty()) {
436
    host_and_port = Inputs.front();
437
    Inputs.erase(Inputs.begin());
438
  }
439

440
  // Any arguments left over are for the program that we need to launch. If
441
  // there
442
  // are no arguments, then the GDB server will start up and wait for an 'A'
443
  // packet
444
  // to launch a program, or a vAttach packet to attach to an existing process,
445
  // unless
446
  // explicitly asked to attach with the --attach={pid|program_name} form.
447
  if (!attach_target.empty())
448
    handle_attach(gdb_server, attach_target);
449
  else if (!Inputs.empty())
450
    handle_launch(gdb_server, Inputs);
451

452
  // Print version info.
453
  printf("%s-%s\n", LLGS_PROGRAM_NAME, LLGS_VERSION_STR);
454

455
  ConnectToRemote(mainloop, gdb_server, reverse_connect, host_and_port,
456
                  progname, subcommand, named_pipe_path.c_str(),
457
                  unnamed_pipe, connection_fd);
458

459
  if (!gdb_server.IsConnected()) {
460
    fprintf(stderr, "no connection information provided, unable to run\n");
461
    return 1;
462
  }
463

464
  Status ret = mainloop.Run();
465
  if (ret.Fail()) {
466
    fprintf(stderr, "lldb-server terminating due to error: %s\n",
467
            ret.AsCString());
468
    return 1;
469
  }
470
  fprintf(stderr, "lldb-server exiting...\n");
471

472
  return 0;
473
}
474