contrib/llvm/tools/lldb/tools/lldb-server/lldb-platform.cpp

   1 //===-- lldb-platform.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 // C Includes
  11 #include <errno.h>
  12 #if defined(__APPLE__)
  13 #include <netinet/in.h>
  14 #endif
  15 #include <signal.h>
  16 #include <stdint.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/wait.h>
  21
  22 // C++ Includes
  23 #include <fstream>
  24
  25 // Other libraries and framework includes
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/FileUtilities.h"
  28
  29 #include "Acceptor.h"
  30 #include "LLDBServerUtilities.h"
  31 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
  32 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
  33 #include "lldb/Host/ConnectionFileDescriptor.h"
  34 #include "lldb/Host/HostGetOpt.h"
  35 #include "lldb/Host/OptionParser.h"
  36 #include "lldb/Host/common/TCPSocket.h"
  37 #include "lldb/Utility/FileSpec.h"
  38 #include "lldb/Utility/Status.h"
  39
  40 using namespace lldb;
  41 using namespace lldb_private;
  42 using namespace lldb_private::lldb_server;
  43 using namespace lldb_private::process_gdb_remote;
  44 using namespace llvm;
  45
  46 //----------------------------------------------------------------------
  47 // option descriptors for getopt_long_only()
  48 //----------------------------------------------------------------------
  49
  50 static int g_debug = 0;
  51 static int g_verbose = 0;
  52 static int g_server = 0;
  53
  54 static struct option g_long_options[] = {
  55     {"debug", no_argument, &g_debug, 1},
  56     {"verbose", no_argument, &g_verbose, 1},
  57     {"log-file", required_argument, NULL, 'l'},
  58     {"log-channels", required_argument, NULL, 'c'},
  59     {"listen", required_argument, NULL, 'L'},
  60     {"port-offset", required_argument, NULL, 'p'},
  61     {"gdbserver-port", required_argument, NULL, 'P'},
  62     {"min-gdbserver-port", required_argument, NULL, 'm'},
  63     {"max-gdbserver-port", required_argument, NULL, 'M'},
  64     {"socket-file", required_argument, NULL, 'f'},
  65     {"server", no_argument, &g_server, 1},
  66     {NULL, 0, NULL, 0}};
  67
  68 #if defined(__APPLE__)
  69 #define LOW_PORT (IPPORT_RESERVED)
  70 #define HIGH_PORT (IPPORT_HIFIRSTAUTO)
  71 #else
  72 #define LOW_PORT (1024u)
  73 #define HIGH_PORT (49151u)
  74 #endif
  75
  76 //----------------------------------------------------------------------
  77 // Watch for signals
  78 //----------------------------------------------------------------------
  79 static void signal_handler(int signo) {
  80   switch (signo) {
  81   case SIGHUP:
  82     // Use SIGINT first, if that does not work, use SIGHUP as a last resort.
  83     // And we should not call exit() here because it results in the global
  84     // destructors
  85     // to be invoked and wreaking havoc on the threads still running.
  86     Host::SystemLog(Host::eSystemLogWarning,
  87                     "SIGHUP received, exiting lldb-server...\n");
  88     abort();
  89     break;
  90   }
  91 }
  92
  93 static void display_usage(const char *progname, const char *subcommand) {
  94   fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels "
  95                   "log-channel-list] [--port-file port-file-path] --server "
  96                   "--listen port\n",
  97           progname, subcommand);
  98   exit(0);
  99 }
 100
 101 static Status save_socket_id_to_file(const std::string &socket_id,
 102                                      const FileSpec &file_spec) {
 103   FileSpec temp_file_spec(file_spec.GetDirectory().AsCString(), false);
 104   Status error(llvm::sys::fs::create_directory(temp_file_spec.GetPath()));
 105   if (error.Fail())
 106     return Status("Failed to create directory %s: %s",
 107                   temp_file_spec.GetCString(), error.AsCString());
 108
 109   llvm::SmallString<64> temp_file_path;
 110   temp_file_spec.AppendPathComponent("port-file.%%%%%%");
 111   int FD;
 112   auto err_code = llvm::sys::fs::createUniqueFile(temp_file_spec.GetPath(), FD,
 113                                                   temp_file_path);
 114   if (err_code)
 115     return Status("Failed to create temp file: %s", err_code.message().c_str());
 116
 117   llvm::FileRemover tmp_file_remover(temp_file_path);
 118
 119   {
 120     llvm::raw_fd_ostream temp_file(FD, true);
 121     temp_file << socket_id;
 122     temp_file.close();
 123     if (temp_file.has_error())
 124       return Status("Failed to write to port file.");
 125   }
 126
 127   err_code = llvm::sys::fs::rename(temp_file_path, file_spec.GetPath());
 128   if (err_code)
 129     return Status("Failed to rename file %s to %s: %s", temp_file_path.c_str(),
 130                   file_spec.GetPath().c_str(), err_code.message().c_str());
 131
 132   tmp_file_remover.releaseFile();
 133   return Status();
 134 }
 135
 136 //----------------------------------------------------------------------
 137 // main
 138 //----------------------------------------------------------------------
 139 int main_platform(int argc, char *argv[]) {
 140   const char *progname = argv[0];
 141   const char *subcommand = argv[1];
 142   argc--;
 143   argv++;
 144   signal(SIGPIPE, SIG_IGN);
 145   signal(SIGHUP, signal_handler);
 146   int long_option_index = 0;
 147   Status error;
 148   std::string listen_host_port;
 149   int ch;
 150
 151   std::string log_file;
 152   StringRef
 153       log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
 154
 155   GDBRemoteCommunicationServerPlatform::PortMap gdbserver_portmap;
 156   int min_gdbserver_port = 0;
 157   int max_gdbserver_port = 0;
 158   uint16_t port_offset = 0;
 159
 160   FileSpec socket_file;
 161   bool show_usage = false;
 162   int option_error = 0;
 163   int socket_error = -1;
 164
 165   std::string short_options(OptionParser::GetShortOptionString(g_long_options));
 166
 167 #if __GLIBC__
 168   optind = 0;
 169 #else
 170   optreset = 1;
 171   optind = 1;
 172 #endif
 173
 174   while ((ch = getopt_long_only(argc, argv, short_options.c_str(),
 175                                 g_long_options, &long_option_index)) != -1) {
 176     switch (ch) {
 177     case 0: // Any optional that auto set themselves will return 0
 178       break;
 179
 180     case 'L':
 181       listen_host_port.append(optarg);
 182       break;
 183
 184     case 'l': // Set Log File
 185       if (optarg && optarg[0])
 186         log_file.assign(optarg);
 187       break;
 188
 189     case 'c': // Log Channels
 190       if (optarg && optarg[0])
 191         log_channels = StringRef(optarg);
 192       break;
 193
 194     case 'f': // Socket file
 195       if (optarg && optarg[0])
 196         socket_file.SetFile(optarg, false);
 197       break;
 198
 199     case 'p': {
 200       if (!llvm::to_integer(optarg, port_offset)) {
 201         llvm::errs() << "error: invalid port offset string " << optarg << "\n";
 202         option_error = 4;
 203         break;
 204       }
 205       if (port_offset < LOW_PORT || port_offset > HIGH_PORT) {
 206         llvm::errs() << llvm::formatv("error: port offset {0} is not in the "
 207                                       "valid user port range of {1} - {2}\n",
 208                                       port_offset, LOW_PORT, HIGH_PORT);
 209         option_error = 5;
 210       }
 211     } break;
 212
 213     case 'P':
 214     case 'm':
 215     case 'M': {
 216       uint16_t portnum;
 217       if (!llvm::to_integer(optarg, portnum)) {
 218         llvm::errs() << "error: invalid port number string " << optarg << "\n";
 219         option_error = 2;
 220         break;
 221       }
 222       if (portnum < LOW_PORT || portnum > HIGH_PORT) {
 223         llvm::errs() << llvm::formatv("error: port number {0} is not in the "
 224                                       "valid user port range of {1} - {2}\n",
 225                                       portnum, LOW_PORT, HIGH_PORT);
 226         option_error = 1;
 227         break;
 228       }
 229       if (ch == 'P')
 230         gdbserver_portmap[portnum] = LLDB_INVALID_PROCESS_ID;
 231       else if (ch == 'm')
 232         min_gdbserver_port = portnum;
 233       else
 234         max_gdbserver_port = portnum;
 235     } break;
 236
 237     case 'h': /* fall-through is intentional */
 238     case '?':
 239       show_usage = true;
 240       break;
 241     }
 242   }
 243
 244   if (!LLDBServerUtilities::SetupLogging(log_file, log_channels, 0))
 245     return -1;
 246
 247   // Make a port map for a port range that was specified.
 248   if (min_gdbserver_port < max_gdbserver_port) {
 249     for (uint16_t port = min_gdbserver_port; port < max_gdbserver_port; ++port)
 250       gdbserver_portmap[port] = LLDB_INVALID_PROCESS_ID;
 251   } else if (min_gdbserver_port != max_gdbserver_port) {
 252     fprintf(stderr, "error: --min-gdbserver-port (%u) is greater than "
 253                     "--max-gdbserver-port (%u)\n",
 254             min_gdbserver_port, max_gdbserver_port);
 255     option_error = 3;
 256   }
 257
 258   // Print usage and exit if no listening port is specified.
 259   if (listen_host_port.empty())
 260     show_usage = true;
 261
 262   if (show_usage || option_error) {
 263     display_usage(progname, subcommand);
 264     exit(option_error);
 265   }
 266
 267   // Skip any options we consumed with getopt_long_only.
 268   argc -= optind;
 269   argv += optind;
 270   lldb_private::Args inferior_arguments;
 271   inferior_arguments.SetArguments(argc, const_cast<const char **>(argv));
 272
 273   const bool children_inherit_listen_socket = false;
 274   // the test suite makes many connections in parallel, let's not miss any.
 275   // The highest this should get reasonably is a function of the number
 276   // of target CPUs. For now, let's just use 100.
 277   const int backlog = 100;
 278
 279   std::unique_ptr<Acceptor> acceptor_up(Acceptor::Create(
 280       listen_host_port, children_inherit_listen_socket, error));
 281   if (error.Fail()) {
 282     fprintf(stderr, "failed to create acceptor: %s", error.AsCString());
 283     exit(socket_error);
 284   }
 285
 286   error = acceptor_up->Listen(backlog);
 287   if (error.Fail()) {
 288     printf("failed to listen: %s\n", error.AsCString());
 289     exit(socket_error);
 290   }
 291   if (socket_file) {
 292     error =
 293         save_socket_id_to_file(acceptor_up->GetLocalSocketId(), socket_file);
 294     if (error.Fail()) {
 295       fprintf(stderr, "failed to write socket id to %s: %s\n",
 296               socket_file.GetPath().c_str(), error.AsCString());
 297       return 1;
 298     }
 299   }
 300
 301   do {
 302     GDBRemoteCommunicationServerPlatform platform(
 303         acceptor_up->GetSocketProtocol(), acceptor_up->GetSocketScheme());
 304
 305     if (port_offset > 0)
 306       platform.SetPortOffset(port_offset);
 307
 308     if (!gdbserver_portmap.empty()) {
 309       platform.SetPortMap(std::move(gdbserver_portmap));
 310     }
 311
 312     const bool children_inherit_accept_socket = true;
 313     Connection *conn = nullptr;
 314     error = acceptor_up->Accept(children_inherit_accept_socket, conn);
 315     if (error.Fail()) {
 316       printf("error: %s\n", error.AsCString());
 317       exit(socket_error);
 318     }
 319     printf("Connection established.\n");
 320     if (g_server) {
 321       // Collect child zombie processes.
 322       while (waitpid(-1, nullptr, WNOHANG) > 0)
 323         ;
 324       if (fork()) {
 325         // Parent doesn't need a connection to the lldb client
 326         delete conn;
 327
 328         // Parent will continue to listen for new connections.
 329         continue;
 330       } else {
 331         // Child process will handle the connection and exit.
 332         g_server = 0;
 333         // Listening socket is owned by parent process.
 334         acceptor_up.release();
 335       }
 336     } else {
 337       // If not running as a server, this process will not accept
 338       // connections while a connection is active.
 339       acceptor_up.reset();
 340     }
 341     platform.SetConnection(conn);
 342
 343     if (platform.IsConnected()) {
 344       if (inferior_arguments.GetArgumentCount() > 0) {
 345         lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
 346         uint16_t port = 0;
 347         std::string socket_name;
 348         Status error = platform.LaunchGDBServer(inferior_arguments,
 349                                                 "", // hostname
 350                                                 pid, port, socket_name);
 351         if (error.Success())
 352           platform.SetPendingGdbServer(pid, port, socket_name);
 353         else
 354           fprintf(stderr, "failed to start gdbserver: %s\n", error.AsCString());
 355       }
 356
 357       // After we connected, we need to get an initial ack from...
 358       if (platform.HandshakeWithClient()) {
 359         bool interrupt = false;
 360         bool done = false;
 361         while (!interrupt && !done) {
 362           if (platform.GetPacketAndSendResponse(llvm::None, error, interrupt,
 363                                                 done) !=
 364               GDBRemoteCommunication::PacketResult::Success)
 365             break;
 366         }
 367
 368         if (error.Fail()) {
 369           fprintf(stderr, "error: %s\n", error.AsCString());
 370         }
 371       } else {
 372         fprintf(stderr, "error: handshake with client failed\n");
 373       }
 374     }
 375   } while (g_server);
 376
 377   fprintf(stderr, "lldb-server exiting...\n");
 378
 379   return 0;
 380 }