mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-27 02:36:05 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/lldb/tools/lldb-server/lldb-platform.cpp
Pavel Labath 77dc9569c6 Introduce a MainLoop class and switch llgs to use it 
Summary:
This is the first part of our effort to make llgs single threaded. Currently, llgs consists of
about three threads and the synchronisation between them is a major source of latency when
debugging linux and android applications.

In order to be able to go single threaded, we must have the ability to listen for events from
multiple sources (primarily, client commands coming over the network and debug events from the
inferior) and perform necessary actions. For this reason I introduce the concept of a MainLoop.
A main loop has the ability to register callback's which will be invoked upon receipt of certain
events. MainLoopPosix has the ability to listen for file descriptors and signals.

For the moment, I have merely made the GDBRemoteCommunicationServerLLGS class use MainLoop
instead of waiting on the network socket directly, but the other threads still remain. In the
followup patches I indend to migrate NativeProcessLinux to this class and remove the remaining
threads.

Reviewers: ovyalov, clayborg, amccarth, zturner, emaste

Subscribers: tberghammer, lldb-commits

Differential Revision: http://reviews.llvm.org/D11066

llvm-svn: 242018
2015-07-13 10:44:55 +00:00

391 lines
13 KiB
C++
Raw Blame History

//===-- lldb-platform.cpp ---------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#include <errno.h>
#if defined(__APPLE__)
#include <netinet/in.h>
#endif
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
// C++ Includes
#include <fstream>
// Other libraries and framework includes
#include "lldb/Core/Error.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostGetOpt.h"
#include "lldb/Host/OptionParser.h"
#include "lldb/Host/Socket.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/FileUtilities.h"
#include "LLDBServerUtilities.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
#include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::lldb_server;
using namespace lldb_private::process_gdb_remote;
using namespace llvm;
//----------------------------------------------------------------------
// option descriptors for getopt_long_only()
//----------------------------------------------------------------------
static int g_debug = 0;
static int g_verbose = 0;
static int g_server = 0;
static struct option g_long_options[] =
{
{ "debug", no_argument, &g_debug, 1 },
{ "verbose", no_argument, &g_verbose, 1 },
{ "log-file", required_argument, NULL, 'l' },
{ "log-channels", required_argument, NULL, 'c' },
{ "listen", required_argument, NULL, 'L' },
{ "port-offset", required_argument, NULL, 'p' },
{ "gdbserver-port", required_argument, NULL, 'P' },
{ "min-gdbserver-port", required_argument, NULL, 'm' },
{ "max-gdbserver-port", required_argument, NULL, 'M' },
{ "port-file", required_argument, NULL, 'f' },
{ "server", no_argument, &g_server, 1 },
{ NULL, 0, NULL, 0 }
};
#if defined (__APPLE__)
#define LOW_PORT (IPPORT_RESERVED)
#define HIGH_PORT (IPPORT_HIFIRSTAUTO)
#else
#define LOW_PORT (1024u)
#define HIGH_PORT (49151u)
#endif
//----------------------------------------------------------------------
// Watch for signals
//----------------------------------------------------------------------
static void
signal_handler(int signo)
{
switch (signo)
{
case SIGHUP:
// Use SIGINT first, if that does not work, use SIGHUP as a last resort.
// And we should not call exit() here because it results in the global destructors
// to be invoked and wreaking havoc on the threads still running.
Host::SystemLog(Host::eSystemLogWarning, "SIGHUP received, exiting lldb-server...\n");
abort();
break;
}
}
static void
display_usage (const char *progname, const char *subcommand)
{
fprintf(stderr, "Usage:\n %s %s [--log-file log-file-name] [--log-channels log-channel-list] [--port-file port-file-path] --server --listen port\n", progname, subcommand);
exit(0);
}
static Error
save_port_to_file(const uint16_t port, const FileSpec &port_file_spec)
{
const ConstString& port_file_dir = port_file_spec.GetDirectory();
auto error = FileSystem::MakeDirectory(
FileSpec(port_file_dir.AsCString(), false), eFilePermissionsDirectoryDefault);
if (error.Fail())
return Error("Failed to create directory %s: %s", port_file_dir.AsCString(), error.AsCString());
llvm::SmallString<PATH_MAX> temp_file_path;
auto err_code = llvm::sys::fs::createTemporaryFile(
port_file_spec.GetPath().c_str(), "", temp_file_path);
if (err_code)
return Error("Failed to create temp file: %s", err_code.message().c_str());
llvm::FileRemover tmp_file_remover(temp_file_path.c_str());
{
std::ofstream temp_file(temp_file_path.c_str(), std::ios::out);
if (!temp_file.is_open())
return Error("Failed to open temp file %s", temp_file_path.c_str());
temp_file << port;
}
err_code = llvm::sys::fs::rename(temp_file_path.c_str(), port_file_spec.GetPath().c_str());
if (err_code)
return Error("Failed to rename file %s to %s: %s",
temp_file_path.c_str(), port_file_spec.GetPath().c_str(), err_code.message().c_str());
tmp_file_remover.releaseFile();
return Error();
}
//----------------------------------------------------------------------
// main
//----------------------------------------------------------------------
int
main_platform (int argc, char *argv[])
{
const char *progname = argv[0];
const char *subcommand = argv[1];
argc--;
argv++;
signal (SIGPIPE, SIG_IGN);
signal (SIGHUP, signal_handler);
int long_option_index = 0;
Error error;
std::string listen_host_port;
int ch;
std::string log_file;
StringRef log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
GDBRemoteCommunicationServerPlatform::PortMap gdbserver_portmap;
int min_gdbserver_port = 0;
int max_gdbserver_port = 0;
uint16_t port_offset = 0;
FileSpec port_file;
bool show_usage = false;
int option_error = 0;
int socket_error = -1;
std::string short_options(OptionParser::GetShortOptionString(g_long_options));
#if __GLIBC__
optind = 0;
#else
optreset = 1;
optind = 1;
#endif
while ((ch = getopt_long_only(argc, argv, short_options.c_str(), g_long_options, &long_option_index)) != -1)
{
switch (ch)
{
case 0: // Any optional that auto set themselves will return 0
break;
case 'L':
listen_host_port.append (optarg);
break;
case 'l': // Set Log File
if (optarg && optarg[0])
log_file.assign(optarg);
break;
case 'c': // Log Channels
if (optarg && optarg[0])
log_channels = StringRef(optarg);
break;
case 'f': // Port file
if (optarg && optarg[0])
port_file.SetFile(optarg, false);
break;
case 'p':
{
char *end = NULL;
long tmp_port_offset = strtoul(optarg, &end, 0);
if (end && *end == '\0')
{
if (LOW_PORT <= tmp_port_offset && tmp_port_offset <= HIGH_PORT)
{
port_offset = (uint16_t)tmp_port_offset;
}
else
{
fprintf (stderr, "error: port offset %li is not in the valid user port range of %u - %u\n", tmp_port_offset, LOW_PORT, HIGH_PORT);
option_error = 5;
}
}
else
{
fprintf (stderr, "error: invalid port offset string %s\n", optarg);
option_error = 4;
}
}
break;
case 'P':
case 'm':
case 'M':
{
char *end = NULL;
long portnum = strtoul(optarg, &end, 0);
if (end && *end == '\0')
{
if (LOW_PORT <= portnum && portnum <= HIGH_PORT)
{
if (ch == 'P')
gdbserver_portmap[(uint16_t)portnum] = LLDB_INVALID_PROCESS_ID;
else if (ch == 'm')
min_gdbserver_port = portnum;
else
max_gdbserver_port = portnum;
}
else
{
fprintf (stderr, "error: port number %li is not in the valid user port range of %u - %u\n", portnum, LOW_PORT, HIGH_PORT);
option_error = 1;
}
}
else
{
fprintf (stderr, "error: invalid port number string %s\n", optarg);
option_error = 2;
}
}
break;
case 'h': /* fall-through is intentional */
case '?':
show_usage = true;
break;
}
}
if (!LLDBServerUtilities::SetupLogging(log_file, log_channels, 0))
return -1;
// Make a port map for a port range that was specified.
if (min_gdbserver_port < max_gdbserver_port)
{
for (uint16_t port = min_gdbserver_port; port < max_gdbserver_port; ++port)
gdbserver_portmap[port] = LLDB_INVALID_PROCESS_ID;
}
else if (min_gdbserver_port != max_gdbserver_port)
{
fprintf (stderr, "error: --min-gdbserver-port (%u) is greater than --max-gdbserver-port (%u)\n", min_gdbserver_port, max_gdbserver_port);
option_error = 3;
}
// Print usage and exit if no listening port is specified.
if (listen_host_port.empty())
show_usage = true;
if (show_usage || option_error)
{
display_usage(progname, subcommand);
exit(option_error);
}
std::unique_ptr<Socket> listening_socket_up;
Socket *socket = nullptr;
const bool children_inherit_listen_socket = false;
// the test suite makes many connections in parallel, let's not miss any.
// The highest this should get reasonably is a function of the number
// of target CPUs. For now, let's just use 100
const int backlog = 100;
error = Socket::TcpListen(listen_host_port.c_str(), children_inherit_listen_socket, socket, NULL, backlog);
if (error.Fail())
{
printf("error: %s\n", error.AsCString());
exit(socket_error);
}
listening_socket_up.reset(socket);
printf ("Listening for a connection from %u...\n", listening_socket_up->GetLocalPortNumber());
if (port_file)
{
error = save_port_to_file(listening_socket_up->GetLocalPortNumber(), port_file);
if (error.Fail())
{
fprintf(stderr, "failed to write port to %s: %s", port_file.GetPath().c_str(), error.AsCString());
return 1;
}
}
do {
GDBRemoteCommunicationServerPlatform platform;
if (port_offset > 0)
platform.SetPortOffset(port_offset);
if (!gdbserver_portmap.empty())
{
platform.SetPortMap(std::move(gdbserver_portmap));
}
const bool children_inherit_accept_socket = true;
socket = nullptr;
error = listening_socket_up->BlockingAccept(listen_host_port.c_str(), children_inherit_accept_socket, socket);
if (error.Fail())
{
printf ("error: %s\n", error.AsCString());
exit(socket_error);
}
printf ("Connection established.\n");
if (g_server)
{
// Collect child zombie processes.
while (waitpid(-1, nullptr, WNOHANG) > 0);
if (fork())
{
// Parent doesn't need a connection to the lldb client
delete socket;
socket = nullptr;
// Parent will continue to listen for new connections.
continue;
}
else
{
// Child process will handle the connection and exit.
g_server = 0;
// Listening socket is owned by parent process.
listening_socket_up.release();
}
}
else
{
// If not running as a server, this process will not accept
// connections while a connection is active.
listening_socket_up.reset();
}
platform.SetConnection (new ConnectionFileDescriptor(socket));
if (platform.IsConnected())
{
// After we connected, we need to get an initial ack from...
if (platform.HandshakeWithClient())
{
bool interrupt = false;
bool done = false;
while (!interrupt && !done)
{
if (platform.GetPacketAndSendResponse (UINT32_MAX, error, interrupt, done) != GDBRemoteCommunication::PacketResult::Success)
break;
}
if (error.Fail())
{
fprintf(stderr, "error: %s\n", error.AsCString());
}
}
else
{
fprintf(stderr, "error: handshake with client failed\n");
}
}
} while (g_server);
fprintf(stderr, "lldb-server exiting...\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink