maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Plugins/Process/POSIX/ProcessPOSIX.cpp

639 lines
16 KiB
C++
Raw Blame History

//===-- ProcessPOSIX.cpp ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/lldb-python.h"
// C Includes
#include <errno.h>
// C++ Includes
// Other libraries and framework includes
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/Target.h"
#include "ProcessPOSIX.h"
#include "ProcessPOSIXLog.h"
#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
#include "ProcessMonitor.h"
#include "POSIXThread.h"
using namespace lldb;
using namespace lldb_private;
//------------------------------------------------------------------------------
// Static functions.
#if 0
Process*
ProcessPOSIX::CreateInstance(Target& target, Listener &listener)
{
return new ProcessPOSIX(target, listener);
}
void
ProcessPOSIX::Initialize()
{
static bool g_initialized = false;
if (!g_initialized)
{
g_initialized = true;
PluginManager::RegisterPlugin(GetPluginNameStatic(),
GetPluginDescriptionStatic(),
CreateInstance);
Log::Callbacks log_callbacks = {
ProcessPOSIXLog::DisableLog,
ProcessPOSIXLog::EnableLog,
ProcessPOSIXLog::ListLogCategories
};
Log::RegisterLogChannel (ProcessPOSIX::GetPluginNameStatic(), log_callbacks);
}
}
#endif
//------------------------------------------------------------------------------
// Constructors and destructors.
ProcessPOSIX::ProcessPOSIX(Target& target, Listener &listener)
: Process(target, listener),
m_byte_order(lldb::endian::InlHostByteOrder()),
m_monitor(NULL),
m_module(NULL),
m_in_limbo(false),
m_exit_now(false)
{
// FIXME: Putting this code in the ctor and saving the byte order in a
// member variable is a hack to avoid const qual issues in GetByteOrder.
lldb::ModuleSP module = GetTarget().GetExecutableModule();
if (module != NULL && module->GetObjectFile() != NULL)
m_byte_order = module->GetObjectFile()->GetByteOrder();
}
ProcessPOSIX::~ProcessPOSIX()
{
delete m_monitor;
}
//------------------------------------------------------------------------------
// Process protocol.
bool
ProcessPOSIX::CanDebug(Target &target, bool plugin_specified_by_name)
{
// For now we are just making sure the file exists for a given module
ModuleSP exe_module_sp(target.GetExecutableModule());
if (exe_module_sp.get())
return exe_module_sp->GetFileSpec().Exists();
return false;
}
Error
ProcessPOSIX::DoAttachToProcessWithID(lldb::pid_t pid)
{
Error error;
assert(m_monitor == NULL);
Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
log->Printf ("ProcessPOSIX::%s(pid = %" PRIi64 ")", __FUNCTION__, GetID());
m_monitor = new ProcessMonitor(this, pid, error);
if (!error.Success())
return error;
SetID(pid);
return error;
}
Error
ProcessPOSIX::DoAttachToProcessWithID (lldb::pid_t pid, const ProcessAttachInfo &attach_info)
{
return DoAttachToProcessWithID(pid);
}
Error
ProcessPOSIX::WillLaunch(Module* module)
{
Error error;
return error;
}
const char *
ProcessPOSIX::GetFilePath(
const lldb_private::ProcessLaunchInfo::FileAction *file_action,
const char *default_path)
{
const char *pts_name = "/dev/pts/";
const char *path = NULL;
if (file_action)
{
if (file_action->GetAction () == ProcessLaunchInfo::FileAction::eFileActionOpen)
path = file_action->GetPath();
// By default the stdio paths passed in will be pseudo-terminal
// (/dev/pts). If so, convert to using a different default path
// instead to redirect I/O to the debugger console. This should
// also handle user overrides to /dev/null or a different file.
if (::strncmp(path, pts_name, ::strlen(pts_name)) == 0)
path = default_path;
}
return path;
}
Error
ProcessPOSIX::DoLaunch (Module *module,
const ProcessLaunchInfo &launch_info)
{
Error error;
assert(m_monitor == NULL);
const char* working_dir = launch_info.GetWorkingDirectory();
if (working_dir) {
FileSpec WorkingDir(working_dir, true);
if (!WorkingDir || WorkingDir.GetFileType() != FileSpec::eFileTypeDirectory)
{
error.SetErrorStringWithFormat("No such file or directory: %s", working_dir);
return error;
}
}
SetPrivateState(eStateLaunching);
const lldb_private::ProcessLaunchInfo::FileAction *file_action;
// Default of NULL will mean to use existing open file descriptors
const char *stdin_path = NULL;
const char *stdout_path = NULL;
const char *stderr_path = NULL;
file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
stdin_path = GetFilePath(file_action, stdin_path);
file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
stdout_path = GetFilePath(file_action, stdout_path);
file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
stderr_path = GetFilePath(file_action, stderr_path);
m_monitor = new ProcessMonitor (this,
module,
launch_info.GetArguments().GetConstArgumentVector(),
launch_info.GetEnvironmentEntries().GetConstArgumentVector(),
stdin_path,
stdout_path,
stderr_path,
working_dir,
error);
m_module = module;
if (!error.Success())
return error;
SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
SetID(m_monitor->GetPID());
return error;
}
void
ProcessPOSIX::DidLaunch()
{
}
Error
ProcessPOSIX::DoResume()
{
StateType state = GetPrivateState();
assert(state == eStateStopped || state == eStateCrashed);
// We are about to resume a thread that will cause the process to exit so
// set our exit status now. Do not change our state if the inferior
// crashed.
if (state == eStateStopped)
{
if (m_in_limbo)
SetExitStatus(m_exit_status, NULL);
else
SetPrivateState(eStateRunning);
}
bool did_resume = false;
uint32_t thread_count = m_thread_list.GetSize(false);
for (uint32_t i = 0; i < thread_count; ++i)
{
POSIXThread *thread = static_cast<POSIXThread*>(
m_thread_list.GetThreadAtIndex(i, false).get());
did_resume = thread->Resume() || did_resume;
}
assert(did_resume && "Process resume failed!");
return Error();
}
addr_t
ProcessPOSIX::GetImageInfoAddress()
{
Target *target = &GetTarget();
ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
Address addr = obj_file->GetImageInfoAddress();
if (addr.IsValid())
return addr.GetLoadAddress(target);
else
return LLDB_INVALID_ADDRESS;
}
Error
ProcessPOSIX::DoHalt(bool &caused_stop)
{
Error error;
if (IsStopped())
{
caused_stop = false;
}
else if (kill(GetID(), SIGSTOP))
{
caused_stop = false;
error.SetErrorToErrno();
}
else
{
caused_stop = true;
}
return error;
}
Error
ProcessPOSIX::DoDetach(bool keep_stopped)
{
Error error;
if (keep_stopped)
{
// FIXME: If you want to implement keep_stopped on Linux,
// this would be the place to do it.
error.SetErrorString("Detaching with keep_stopped true is not currently supported on Linux.");
return error;
}
error = m_monitor->Detach();
if (error.Success())
SetPrivateState(eStateDetached);
return error;
}
Error
ProcessPOSIX::DoSignal(int signal)
{
Error error;
if (kill(GetID(), signal))
error.SetErrorToErrno();
return error;
}
Error
ProcessPOSIX::DoDestroy()
{
Error error;
if (!HasExited())
{
// Drive the exit event to completion (do not keep the inferior in
// limbo).
m_exit_now = true;
if ((m_monitor == NULL || kill(m_monitor->GetPID(), SIGKILL)) && error.Success())
{
error.SetErrorToErrno();
return error;
}
SetPrivateState(eStateExited);
}
return error;
}
void
ProcessPOSIX::SendMessage(const ProcessMessage &message)
{
Mutex::Locker lock(m_message_mutex);
switch (message.GetKind())
{
case ProcessMessage::eInvalidMessage:
return;
case ProcessMessage::eLimboMessage:
m_in_limbo = true;
m_exit_status = message.GetExitStatus();
if (m_exit_now)
{
SetPrivateState(eStateExited);
m_monitor->Detach();
}
else
SetPrivateState(eStateStopped);
break;
case ProcessMessage::eExitMessage:
m_exit_status = message.GetExitStatus();
SetExitStatus(m_exit_status, NULL);
break;
case ProcessMessage::eTraceMessage:
case ProcessMessage::eBreakpointMessage:
SetPrivateState(eStateStopped);
break;
case ProcessMessage::eSignalMessage:
case ProcessMessage::eSignalDeliveredMessage:
{
lldb::tid_t tid = message.GetTID();
lldb::tid_t pid = GetID();
if (tid == pid) {
SetPrivateState(eStateStopped);
break;
} else {
// FIXME: Ignore any signals generated by children.
return;
}
}
case ProcessMessage::eCrashMessage:
// FIXME: Update stop reason as per bugzilla 14598
SetPrivateState(eStateStopped);
break;
case ProcessMessage::eNewThreadMessage:
SetPrivateState(eStateStopped);
break;
}
m_message_queue.push(message);
}
void
ProcessPOSIX::RefreshStateAfterStop()
{
Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
log->Printf ("ProcessPOSIX::%s()", __FUNCTION__);
Mutex::Locker lock(m_message_mutex);
if (m_message_queue.empty())
return;
ProcessMessage &message = m_message_queue.front();
// Resolve the thread this message corresponds to and pass it along.
// FIXME: we're really dealing with the pid here. This should get
// fixed when this code is fixed to handle multiple threads.
lldb::tid_t tid = message.GetTID();
if (log)
log->Printf ("ProcessPOSIX::%s() pid = %" PRIi64, __FUNCTION__, tid);
POSIXThread *thread = static_cast<POSIXThread*>(
GetThreadList().FindThreadByID(tid, false).get());
if (message.GetKind() == ProcessMessage::eNewThreadMessage) {
ThreadSP thread_sp;
thread_sp.reset(new POSIXThread(*this, message.GetChildTID()));
m_thread_list.AddThread(thread_sp);
}
assert(thread);
thread->Notify(message);
m_message_queue.pop();
}
bool
ProcessPOSIX::IsAlive()
{
StateType state = GetPrivateState();
return state != eStateDetached
&& state != eStateExited
&& state != eStateInvalid
&& state != eStateUnloaded;
}
size_t
ProcessPOSIX::DoReadMemory(addr_t vm_addr,
void *buf, size_t size, Error &error)
{
assert(m_monitor);
return m_monitor->ReadMemory(vm_addr, buf, size, error);
}
size_t
ProcessPOSIX::DoWriteMemory(addr_t vm_addr, const void *buf, size_t size,
Error &error)
{
assert(m_monitor);
return m_monitor->WriteMemory(vm_addr, buf, size, error);
}
addr_t
ProcessPOSIX::DoAllocateMemory(size_t size, uint32_t permissions,
Error &error)
{
addr_t allocated_addr = LLDB_INVALID_ADDRESS;
unsigned prot = 0;
if (permissions & lldb::ePermissionsReadable)
prot |= eMmapProtRead;
if (permissions & lldb::ePermissionsWritable)
prot |= eMmapProtWrite;
if (permissions & lldb::ePermissionsExecutable)
prot |= eMmapProtExec;
if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
m_addr_to_mmap_size[allocated_addr] = size;
error.Clear();
} else {
allocated_addr = LLDB_INVALID_ADDRESS;
error.SetErrorStringWithFormat("unable to allocate %zu bytes of memory with permissions %s", size, GetPermissionsAsCString (permissions));
}
return allocated_addr;
}
Error
ProcessPOSIX::DoDeallocateMemory(lldb::addr_t addr)
{
Error error;
MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
if (pos != m_addr_to_mmap_size.end() &&
InferiorCallMunmap(this, addr, pos->second))
m_addr_to_mmap_size.erase (pos);
else
error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64, addr);
return error;
}
addr_t
ProcessPOSIX::ResolveIndirectFunction(const Address *address, Error &error)
{
addr_t function_addr = LLDB_INVALID_ADDRESS;
if (address == NULL) {
error.SetErrorStringWithFormat("unable to determine direct function call for NULL address");
} else if (!InferiorCall(this, address, function_addr)) {
function_addr = LLDB_INVALID_ADDRESS;
error.SetErrorStringWithFormat("unable to determine direct function call for indirect function %s",
address->CalculateSymbolContextSymbol()->GetName().AsCString());
}
return function_addr;
}
size_t
ProcessPOSIX::GetSoftwareBreakpointTrapOpcode(BreakpointSite* bp_site)
{
static const uint8_t g_i386_opcode[] = { 0xCC };
ArchSpec arch = GetTarget().GetArchitecture();
const uint8_t *opcode = NULL;
size_t opcode_size = 0;
switch (arch.GetCore())
{
default:
assert(false && "CPU type not supported!");
break;
case ArchSpec::eCore_x86_32_i386:
case ArchSpec::eCore_x86_64_x86_64:
opcode = g_i386_opcode;
opcode_size = sizeof(g_i386_opcode);
break;
}
bp_site->SetTrapOpcode(opcode, opcode_size);
return opcode_size;
}
Error
ProcessPOSIX::EnableBreakpointSite(BreakpointSite *bp_site)
{
return EnableSoftwareBreakpoint(bp_site);
}
Error
ProcessPOSIX::DisableBreakpointSite(BreakpointSite *bp_site)
{
return DisableSoftwareBreakpoint(bp_site);
}
uint32_t
ProcessPOSIX::UpdateThreadListIfNeeded()
{
// Do not allow recursive updates.
return m_thread_list.GetSize(false);
}
bool
ProcessPOSIX::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
{
Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
log->Printf ("ProcessPOSIX::%s() (pid = %" PRIi64 ")", __FUNCTION__, GetID());
// Update the process thread list with this new thread.
// FIXME: We should be using tid, not pid.
assert(m_monitor);
ThreadSP thread_sp (old_thread_list.FindThreadByID (GetID(), false));
if (!thread_sp) {
thread_sp.reset(new POSIXThread(*this, GetID()));
}
if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
log->Printf ("ProcessPOSIX::%s() updated pid = %" PRIi64, __FUNCTION__, GetID());
new_thread_list.AddThread(thread_sp);
return new_thread_list.GetSize(false) > 0;
}
ByteOrder
ProcessPOSIX::GetByteOrder() const
{
// FIXME: We should be able to extract this value directly. See comment in
// ProcessPOSIX().
return m_byte_order;
}
size_t
ProcessPOSIX::PutSTDIN(const char *buf, size_t len, Error &error)
{
ssize_t status;
if ((status = write(m_monitor->GetTerminalFD(), buf, len)) < 0)
{
error.SetErrorToErrno();
return 0;
}
return status;
}
UnixSignals &
ProcessPOSIX::GetUnixSignals()
{
return m_signals;
}
//------------------------------------------------------------------------------
// Utility functions.
bool
ProcessPOSIX::HasExited()
{
switch (GetPrivateState())
{
default:
break;
case eStateDetached:
case eStateExited:
return true;
}
return false;
}
bool
ProcessPOSIX::IsStopped()
{
switch (GetPrivateState())
{
default:
break;
case eStateStopped:
case eStateCrashed:
case eStateSuspended:
return true;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink