75f47c3a5d
With this change, both local-process llgs and remote-target llgs stdout/stderr
handling from inferior work correctly.
Several log lines have been added around PTY and stdout/stderr redirection
logic on the lldb client side.
Regarding remote llgs execution, see the following:
With these changes, remote llgs with $O now works properly:
$ lldb
(lldb) platform select remote-linux
(lldb) target create ~/some/inferior/exe
(lldb) gdb-remote {some-target}:{port}
(lldb) run
The sequence above will correctly redirect stdout/stderr over gdb-remote $O,
as is needed for remote debugging. That sequence assumes there is a lldb-gdbserver
exe running on the target with {some-host}:{port}.
You can replace the gdb-remote command with a '(lldb) platform connect
connect://{target-ip}:{target-port}'. If you do this and have a
lldb-platform running on the remote end, it will go ahead and launch
llgs for lldb for each target instance that is run/attached.
For local debugging with llgs, the following sequence also works, and
uses local PTYs instead to avoid $O and extra gdb-remote messages:
$ lldb
(lldb) settings set platform.plugin.linux.use-llgs true
(lldb) target create ~/some/inferior/exe
(lldb) run
The above will run the inferior using llgs on the local host, and
will use PTYs rather than $O redirection.
This change also removes the logging that happened after the fork but
before the exec when llgs is launching a new inferior process. Some
aspect of the file handling during that portion of code would not do
the right thing with log handling. We might want to go back later
and have that communicate over a pipe from the child to parent to pass
along any messages that previously were logged in that section of code.
llvm-svn: 219578
400 lines
14 KiB
C++
400 lines
14 KiB
C++
//===-- NativeProcessLinux.h ---------------------------------- -*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef liblldb_NativeProcessLinux_H_
|
|
#define liblldb_NativeProcessLinux_H_
|
|
|
|
// C Includes
|
|
#include <semaphore.h>
|
|
#include <signal.h>
|
|
|
|
// C++ Includes
|
|
#include <unordered_set>
|
|
|
|
// Other libraries and framework includes
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/lldb-types.h"
|
|
#include "lldb/Host/Debug.h"
|
|
#include "lldb/Host/HostThread.h"
|
|
#include "lldb/Host/Mutex.h"
|
|
#include "lldb/Target/MemoryRegionInfo.h"
|
|
|
|
#include "Host/common/NativeProcessProtocol.h"
|
|
|
|
namespace lldb_private
|
|
{
|
|
class Error;
|
|
class Module;
|
|
class Scalar;
|
|
|
|
/// @class NativeProcessLinux
|
|
/// @brief Manages communication with the inferior (debugee) process.
|
|
///
|
|
/// Upon construction, this class prepares and launches an inferior process for
|
|
/// debugging.
|
|
///
|
|
/// Changes in the inferior process state are broadcasted.
|
|
class NativeProcessLinux: public NativeProcessProtocol
|
|
{
|
|
public:
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Public Static Methods
|
|
// ---------------------------------------------------------------------
|
|
static lldb_private::Error
|
|
LaunchProcess (
|
|
Module *exe_module,
|
|
ProcessLaunchInfo &launch_info,
|
|
lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
|
|
NativeProcessProtocolSP &native_process_sp);
|
|
|
|
static lldb_private::Error
|
|
AttachToProcess (
|
|
lldb::pid_t pid,
|
|
lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate,
|
|
NativeProcessProtocolSP &native_process_sp);
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Public Instance Methods
|
|
// ---------------------------------------------------------------------
|
|
|
|
~NativeProcessLinux() override;
|
|
|
|
// ---------------------------------------------------------------------
|
|
// NativeProcessProtocol Interface
|
|
// ---------------------------------------------------------------------
|
|
Error
|
|
Resume (const ResumeActionList &resume_actions) override;
|
|
|
|
Error
|
|
Halt () override;
|
|
|
|
Error
|
|
Detach () override;
|
|
|
|
Error
|
|
Signal (int signo) override;
|
|
|
|
Error
|
|
Kill () override;
|
|
|
|
Error
|
|
GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info) override;
|
|
|
|
Error
|
|
ReadMemory (lldb::addr_t addr, void *buf, lldb::addr_t size, lldb::addr_t &bytes_read) override;
|
|
|
|
Error
|
|
WriteMemory (lldb::addr_t addr, const void *buf, lldb::addr_t size, lldb::addr_t &bytes_written) override;
|
|
|
|
Error
|
|
AllocateMemory (lldb::addr_t size, uint32_t permissions, lldb::addr_t &addr) override;
|
|
|
|
Error
|
|
DeallocateMemory (lldb::addr_t addr) override;
|
|
|
|
lldb::addr_t
|
|
GetSharedLibraryInfoAddress () override;
|
|
|
|
size_t
|
|
UpdateThreads () override;
|
|
|
|
bool
|
|
GetArchitecture (ArchSpec &arch) const override;
|
|
|
|
Error
|
|
SetBreakpoint (lldb::addr_t addr, uint32_t size, bool hardware) override;
|
|
|
|
void
|
|
DoStopIDBumped (uint32_t newBumpId) override;
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Interface used by NativeRegisterContext-derived classes.
|
|
// ---------------------------------------------------------------------
|
|
|
|
/// Reads the contents from the register identified by the given (architecture
|
|
/// dependent) offset.
|
|
///
|
|
/// This method is provided for use by RegisterContextLinux derivatives.
|
|
bool
|
|
ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
|
|
unsigned size, lldb_private::RegisterValue &value);
|
|
|
|
/// Writes the given value to the register identified by the given
|
|
/// (architecture dependent) offset.
|
|
///
|
|
/// This method is provided for use by RegisterContextLinux derivatives.
|
|
bool
|
|
WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
|
|
const lldb_private::RegisterValue &value);
|
|
|
|
/// Reads all general purpose registers into the specified buffer.
|
|
bool
|
|
ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size);
|
|
|
|
/// Reads generic floating point registers into the specified buffer.
|
|
bool
|
|
ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size);
|
|
|
|
/// Reads the specified register set into the specified buffer.
|
|
/// For instance, the extended floating-point register set.
|
|
bool
|
|
ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
|
|
|
|
/// Writes all general purpose registers into the specified buffer.
|
|
bool
|
|
WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size);
|
|
|
|
/// Writes generic floating point registers into the specified buffer.
|
|
bool
|
|
WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size);
|
|
|
|
/// Writes the specified register set into the specified buffer.
|
|
/// For instance, the extended floating-point register set.
|
|
bool
|
|
WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset);
|
|
|
|
protected:
|
|
// ---------------------------------------------------------------------
|
|
// NativeProcessProtocol protected interface
|
|
// ---------------------------------------------------------------------
|
|
Error
|
|
GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
|
|
|
|
private:
|
|
|
|
lldb_private::ArchSpec m_arch;
|
|
|
|
HostThread m_operation_thread;
|
|
HostThread m_monitor_thread;
|
|
|
|
// current operation which must be executed on the priviliged thread
|
|
void *m_operation;
|
|
lldb_private::Mutex m_operation_mutex;
|
|
|
|
// semaphores notified when Operation is ready to be processed and when
|
|
// the operation is complete.
|
|
sem_t m_operation_pending;
|
|
sem_t m_operation_done;
|
|
|
|
// Set of tids we're waiting to stop before we notify the delegate of
|
|
// the stopped state. We only notify the delegate after all threads
|
|
// ordered to stop have signaled their stop.
|
|
std::unordered_set<lldb::tid_t> m_wait_for_stop_tids;
|
|
lldb_private::Mutex m_wait_for_stop_tids_mutex;
|
|
|
|
std::unordered_set<lldb::tid_t> m_wait_for_group_stop_tids;
|
|
lldb::tid_t m_group_stop_signal_tid;
|
|
int m_group_stop_signal;
|
|
lldb_private::Mutex m_wait_for_group_stop_tids_mutex;
|
|
|
|
lldb_private::LazyBool m_supports_mem_region;
|
|
std::vector<MemoryRegionInfo> m_mem_region_cache;
|
|
lldb_private::Mutex m_mem_region_cache_mutex;
|
|
|
|
|
|
struct OperationArgs
|
|
{
|
|
OperationArgs(NativeProcessLinux *monitor);
|
|
|
|
~OperationArgs();
|
|
|
|
NativeProcessLinux *m_monitor; // The monitor performing the attach.
|
|
sem_t m_semaphore; // Posted to once operation complete.
|
|
lldb_private::Error m_error; // Set if process operation failed.
|
|
};
|
|
|
|
/// @class LauchArgs
|
|
///
|
|
/// @brief Simple structure to pass data to the thread responsible for
|
|
/// launching a child process.
|
|
struct LaunchArgs : OperationArgs
|
|
{
|
|
LaunchArgs(NativeProcessLinux *monitor,
|
|
lldb_private::Module *module,
|
|
char const **argv,
|
|
char const **envp,
|
|
const std::string &stdin_path,
|
|
const std::string &stdout_path,
|
|
const std::string &stderr_path,
|
|
const char *working_dir,
|
|
const lldb_private::ProcessLaunchInfo &launch_info);
|
|
|
|
~LaunchArgs();
|
|
|
|
lldb_private::Module *m_module; // The executable image to launch.
|
|
char const **m_argv; // Process arguments.
|
|
char const **m_envp; // Process environment.
|
|
const std::string &m_stdin_path; // Redirect stdin if not empty.
|
|
const std::string &m_stdout_path; // Redirect stdout if not empty.
|
|
const std::string &m_stderr_path; // Redirect stderr if not empty.
|
|
const char *m_working_dir; // Working directory or NULL.
|
|
const lldb_private::ProcessLaunchInfo &m_launch_info;
|
|
};
|
|
|
|
struct AttachArgs : OperationArgs
|
|
{
|
|
AttachArgs(NativeProcessLinux *monitor,
|
|
lldb::pid_t pid);
|
|
|
|
~AttachArgs();
|
|
|
|
lldb::pid_t m_pid; // pid of the process to be attached.
|
|
};
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Private Instance Methods
|
|
// ---------------------------------------------------------------------
|
|
NativeProcessLinux ();
|
|
|
|
/// Launches an inferior process ready for debugging. Forms the
|
|
/// implementation of Process::DoLaunch.
|
|
void
|
|
LaunchInferior (
|
|
Module *module,
|
|
char const *argv[],
|
|
char const *envp[],
|
|
const std::string &stdin_path,
|
|
const std::string &stdout_path,
|
|
const std::string &stderr_path,
|
|
const char *working_dir,
|
|
const lldb_private::ProcessLaunchInfo &launch_info,
|
|
Error &error);
|
|
|
|
/// Attaches to an existing process. Forms the
|
|
/// implementation of Process::DoLaunch.
|
|
void
|
|
AttachToInferior (lldb::pid_t pid, Error &error);
|
|
|
|
void
|
|
StartLaunchOpThread(LaunchArgs *args, lldb_private::Error &error);
|
|
|
|
static void *
|
|
LaunchOpThread(void *arg);
|
|
|
|
static bool
|
|
Launch(LaunchArgs *args);
|
|
|
|
void
|
|
StartAttachOpThread(AttachArgs *args, lldb_private::Error &error);
|
|
|
|
static void *
|
|
AttachOpThread(void *args);
|
|
|
|
static bool
|
|
Attach(AttachArgs *args);
|
|
|
|
static bool
|
|
SetDefaultPtraceOpts(const lldb::pid_t);
|
|
|
|
static void
|
|
ServeOperation(OperationArgs *args);
|
|
|
|
static bool
|
|
DupDescriptor(const char *path, int fd, int flags);
|
|
|
|
static bool
|
|
MonitorCallback(void *callback_baton,
|
|
lldb::pid_t pid, bool exited, int signal, int status);
|
|
|
|
void
|
|
MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
|
|
|
|
void
|
|
MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited);
|
|
|
|
#if 0
|
|
static ::ProcessMessage::CrashReason
|
|
GetCrashReasonForSIGSEGV(const siginfo_t *info);
|
|
|
|
static ::ProcessMessage::CrashReason
|
|
GetCrashReasonForSIGILL(const siginfo_t *info);
|
|
|
|
static ::ProcessMessage::CrashReason
|
|
GetCrashReasonForSIGFPE(const siginfo_t *info);
|
|
|
|
static ::ProcessMessage::CrashReason
|
|
GetCrashReasonForSIGBUS(const siginfo_t *info);
|
|
#endif
|
|
|
|
void
|
|
DoOperation(void *op);
|
|
|
|
/// Stops the child monitor thread.
|
|
void
|
|
StopMonitoringChildProcess();
|
|
|
|
/// Stops the operation thread used to attach/launch a process.
|
|
void
|
|
StopOpThread();
|
|
|
|
/// Stops monitoring the child process thread.
|
|
void
|
|
StopMonitor();
|
|
|
|
bool
|
|
HasThreadNoLock (lldb::tid_t thread_id);
|
|
|
|
NativeThreadProtocolSP
|
|
MaybeGetThreadNoLock (lldb::tid_t thread_id);
|
|
|
|
bool
|
|
StopTrackingThread (lldb::tid_t thread_id);
|
|
|
|
NativeThreadProtocolSP
|
|
AddThread (lldb::tid_t thread_id);
|
|
|
|
NativeThreadProtocolSP
|
|
GetOrCreateThread (lldb::tid_t thread_id, bool &created);
|
|
|
|
Error
|
|
GetSoftwareBreakpointSize (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size);
|
|
|
|
Error
|
|
FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp);
|
|
|
|
/// Writes a siginfo_t structure corresponding to the given thread ID to the
|
|
/// memory region pointed to by @p siginfo.
|
|
bool
|
|
GetSignalInfo(lldb::tid_t tid, void *siginfo, int &ptrace_err);
|
|
|
|
/// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
|
|
/// corresponding to the given thread ID to the memory pointed to by @p
|
|
/// message.
|
|
bool
|
|
GetEventMessage(lldb::tid_t tid, unsigned long *message);
|
|
|
|
/// Resumes the given thread. If @p signo is anything but
|
|
/// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
|
|
bool
|
|
Resume(lldb::tid_t tid, uint32_t signo);
|
|
|
|
/// Single steps the given thread. If @p signo is anything but
|
|
/// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
|
|
bool
|
|
SingleStep(lldb::tid_t tid, uint32_t signo);
|
|
|
|
/// Safely mark all existing threads as waiting for group stop.
|
|
/// When the final group stop comes in from the set of group stop threads,
|
|
/// we'll mark the current thread as signaled_thread_tid and set its stop
|
|
/// reason as the given signo. All other threads from group stop notification
|
|
/// will have thread stop reason marked as signaled with no signo.
|
|
void
|
|
SetGroupStopTids (lldb::tid_t signaled_thread_tid, int signo);
|
|
|
|
void
|
|
OnGroupStop (lldb::tid_t tid);
|
|
|
|
lldb_private::Error
|
|
Detach(lldb::tid_t tid);
|
|
};
|
|
} // End lldb_private namespace.
|
|
|
|
#endif // #ifndef liblldb_NativeProcessLinux_H_
|