620 lines
18 KiB
C++
620 lines
18 KiB
C++
//===-- ProcessLaunchInfo.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/Host/Config.h"
|
|
|
|
#include "lldb/Target/ProcessLaunchInfo.h"
|
|
|
|
#ifndef LLDB_DISABLE_POSIX
|
|
#include <spawn.h>
|
|
#endif
|
|
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------------
|
|
// ProcessLaunchInfo::FileAction member functions
|
|
//----------------------------------------------------------------------------
|
|
|
|
ProcessLaunchInfo::FileAction::FileAction () :
|
|
m_action (eFileActionNone),
|
|
m_fd (-1),
|
|
m_arg (-1),
|
|
m_path ()
|
|
{
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::FileAction::Clear()
|
|
{
|
|
m_action = eFileActionNone;
|
|
m_fd = -1;
|
|
m_arg = -1;
|
|
m_path.clear();
|
|
}
|
|
|
|
const char *
|
|
ProcessLaunchInfo::FileAction::GetPath () const
|
|
{
|
|
if (m_path.empty())
|
|
return NULL;
|
|
return m_path.c_str();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// ProcessLaunchInfo member functions
|
|
//----------------------------------------------------------------------------
|
|
|
|
ProcessLaunchInfo::ProcessLaunchInfo () :
|
|
ProcessInfo(),
|
|
m_working_dir (),
|
|
m_plugin_name (),
|
|
m_shell (),
|
|
m_flags (0),
|
|
m_file_actions (),
|
|
m_pty (),
|
|
m_resume_count (0),
|
|
m_monitor_callback (NULL),
|
|
m_monitor_callback_baton (NULL),
|
|
m_monitor_signals (false),
|
|
m_hijack_listener_sp ()
|
|
{
|
|
}
|
|
|
|
ProcessLaunchInfo::ProcessLaunchInfo (
|
|
const char *stdin_path,
|
|
const char *stdout_path,
|
|
const char *stderr_path,
|
|
const char *working_directory,
|
|
uint32_t launch_flags) :
|
|
ProcessInfo(),
|
|
m_working_dir (),
|
|
m_plugin_name (),
|
|
m_shell (),
|
|
m_flags (launch_flags),
|
|
m_file_actions (),
|
|
m_pty (),
|
|
m_resume_count (0),
|
|
m_monitor_callback (NULL),
|
|
m_monitor_callback_baton (NULL),
|
|
m_monitor_signals (false),
|
|
m_hijack_listener_sp ()
|
|
{
|
|
if (stdin_path)
|
|
{
|
|
ProcessLaunchInfo::FileAction file_action;
|
|
const bool read = true;
|
|
const bool write = false;
|
|
if (file_action.Open(STDIN_FILENO, stdin_path, read, write))
|
|
AppendFileAction (file_action);
|
|
}
|
|
if (stdout_path)
|
|
{
|
|
ProcessLaunchInfo::FileAction file_action;
|
|
const bool read = false;
|
|
const bool write = true;
|
|
if (file_action.Open(STDOUT_FILENO, stdout_path, read, write))
|
|
AppendFileAction (file_action);
|
|
}
|
|
if (stderr_path)
|
|
{
|
|
ProcessLaunchInfo::FileAction file_action;
|
|
const bool read = false;
|
|
const bool write = true;
|
|
if (file_action.Open(STDERR_FILENO, stderr_path, read, write))
|
|
AppendFileAction (file_action);
|
|
}
|
|
if (working_directory)
|
|
SetWorkingDirectory(working_directory);
|
|
}
|
|
|
|
bool
|
|
ProcessLaunchInfo::AppendCloseFileAction (int fd)
|
|
{
|
|
FileAction file_action;
|
|
if (file_action.Close (fd))
|
|
{
|
|
AppendFileAction (file_action);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ProcessLaunchInfo::AppendDuplicateFileAction (int fd, int dup_fd)
|
|
{
|
|
FileAction file_action;
|
|
if (file_action.Duplicate (fd, dup_fd))
|
|
{
|
|
AppendFileAction (file_action);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ProcessLaunchInfo::AppendOpenFileAction (int fd, const char *path, bool read, bool write)
|
|
{
|
|
FileAction file_action;
|
|
if (file_action.Open (fd, path, read, write))
|
|
{
|
|
AppendFileAction (file_action);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ProcessLaunchInfo::AppendSuppressFileAction (int fd, bool read, bool write)
|
|
{
|
|
FileAction file_action;
|
|
if (file_action.Open (fd, "/dev/null", read, write))
|
|
{
|
|
AppendFileAction (file_action);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const ProcessLaunchInfo::FileAction *
|
|
ProcessLaunchInfo::GetFileActionAtIndex (size_t idx) const
|
|
{
|
|
if (idx < m_file_actions.size())
|
|
return &m_file_actions[idx];
|
|
return NULL;
|
|
}
|
|
|
|
const ProcessLaunchInfo::FileAction *
|
|
ProcessLaunchInfo::GetFileActionForFD (int fd) const
|
|
{
|
|
for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
|
|
{
|
|
if (m_file_actions[idx].GetFD () == fd)
|
|
return &m_file_actions[idx];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char *
|
|
ProcessLaunchInfo::GetWorkingDirectory () const
|
|
{
|
|
if (m_working_dir.empty())
|
|
return NULL;
|
|
return m_working_dir.c_str();
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::SetWorkingDirectory (const char *working_dir)
|
|
{
|
|
if (working_dir && working_dir[0])
|
|
m_working_dir.assign (working_dir);
|
|
else
|
|
m_working_dir.clear();
|
|
}
|
|
|
|
const char *
|
|
ProcessLaunchInfo::GetProcessPluginName () const
|
|
{
|
|
if (m_plugin_name.empty())
|
|
return NULL;
|
|
return m_plugin_name.c_str();
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::SetProcessPluginName (const char *plugin)
|
|
{
|
|
if (plugin && plugin[0])
|
|
m_plugin_name.assign (plugin);
|
|
else
|
|
m_plugin_name.clear();
|
|
}
|
|
|
|
const char *
|
|
ProcessLaunchInfo::GetShell () const
|
|
{
|
|
if (m_shell.empty())
|
|
return NULL;
|
|
return m_shell.c_str();
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::SetShell (const char * path)
|
|
{
|
|
if (path && path[0])
|
|
{
|
|
m_shell.assign (path);
|
|
m_flags.Set (lldb::eLaunchFlagLaunchInShell);
|
|
}
|
|
else
|
|
{
|
|
m_shell.clear();
|
|
m_flags.Clear (lldb::eLaunchFlagLaunchInShell);
|
|
}
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::SetLaunchInSeparateProcessGroup (bool separate)
|
|
{
|
|
if (separate)
|
|
m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
|
|
else
|
|
m_flags.Clear (lldb::eLaunchFlagLaunchInSeparateProcessGroup);
|
|
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::Clear ()
|
|
{
|
|
ProcessInfo::Clear();
|
|
m_working_dir.clear();
|
|
m_plugin_name.clear();
|
|
m_shell.clear();
|
|
m_flags.Clear();
|
|
m_file_actions.clear();
|
|
m_resume_count = 0;
|
|
m_hijack_listener_sp.reset();
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::SetMonitorProcessCallback (Host::MonitorChildProcessCallback callback,
|
|
void *baton,
|
|
bool monitor_signals)
|
|
{
|
|
m_monitor_callback = callback;
|
|
m_monitor_callback_baton = baton;
|
|
m_monitor_signals = monitor_signals;
|
|
}
|
|
|
|
bool
|
|
ProcessLaunchInfo::MonitorProcess () const
|
|
{
|
|
if (m_monitor_callback && ProcessIDIsValid())
|
|
{
|
|
Host::StartMonitoringChildProcess (m_monitor_callback,
|
|
m_monitor_callback_baton,
|
|
GetProcessID(),
|
|
m_monitor_signals);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::SetDetachOnError (bool enable)
|
|
{
|
|
if (enable)
|
|
m_flags.Set(lldb::eLaunchFlagDetachOnError);
|
|
else
|
|
m_flags.Clear(lldb::eLaunchFlagDetachOnError);
|
|
}
|
|
|
|
void
|
|
ProcessLaunchInfo::FinalizeFileActions (Target *target, bool default_to_use_pty)
|
|
{
|
|
// If nothing for stdin or stdout or stderr was specified, then check the process for any default
|
|
// settings that were set with "settings set"
|
|
if (GetFileActionForFD(STDIN_FILENO) == NULL || GetFileActionForFD(STDOUT_FILENO) == NULL ||
|
|
GetFileActionForFD(STDERR_FILENO) == NULL)
|
|
{
|
|
if (m_flags.Test(eLaunchFlagDisableSTDIO))
|
|
{
|
|
AppendSuppressFileAction (STDIN_FILENO , true, false);
|
|
AppendSuppressFileAction (STDOUT_FILENO, false, true);
|
|
AppendSuppressFileAction (STDERR_FILENO, false, true);
|
|
}
|
|
else
|
|
{
|
|
// Check for any values that might have gotten set with any of:
|
|
// (lldb) settings set target.input-path
|
|
// (lldb) settings set target.output-path
|
|
// (lldb) settings set target.error-path
|
|
FileSpec in_path;
|
|
FileSpec out_path;
|
|
FileSpec err_path;
|
|
if (target)
|
|
{
|
|
in_path = target->GetStandardInputPath();
|
|
out_path = target->GetStandardOutputPath();
|
|
err_path = target->GetStandardErrorPath();
|
|
}
|
|
|
|
char path[PATH_MAX];
|
|
if (in_path && in_path.GetPath(path, sizeof(path)))
|
|
AppendOpenFileAction(STDIN_FILENO, path, true, false);
|
|
|
|
if (out_path && out_path.GetPath(path, sizeof(path)))
|
|
AppendOpenFileAction(STDOUT_FILENO, path, false, true);
|
|
|
|
if (err_path && err_path.GetPath(path, sizeof(path)))
|
|
AppendOpenFileAction(STDERR_FILENO, path, false, true);
|
|
|
|
if (default_to_use_pty && (!in_path || !out_path || !err_path)) {
|
|
if (m_pty.OpenFirstAvailableMaster(O_RDWR| O_NOCTTY, NULL, 0)) {
|
|
const char *slave_path = m_pty.GetSlaveName(NULL, 0);
|
|
|
|
if (!in_path) {
|
|
AppendOpenFileAction(STDIN_FILENO, slave_path, true, false);
|
|
}
|
|
|
|
if (!out_path) {
|
|
AppendOpenFileAction(STDOUT_FILENO, slave_path, false, true);
|
|
}
|
|
|
|
if (!err_path) {
|
|
AppendOpenFileAction(STDERR_FILENO, slave_path, false, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell (Error &error,
|
|
bool localhost,
|
|
bool will_debug,
|
|
bool first_arg_is_full_shell_command,
|
|
int32_t num_resumes)
|
|
{
|
|
error.Clear();
|
|
|
|
if (GetFlags().Test (eLaunchFlagLaunchInShell))
|
|
{
|
|
const char *shell_executable = GetShell();
|
|
if (shell_executable)
|
|
{
|
|
char shell_resolved_path[PATH_MAX];
|
|
|
|
if (localhost)
|
|
{
|
|
FileSpec shell_filespec (shell_executable, true);
|
|
|
|
if (!shell_filespec.Exists())
|
|
{
|
|
// Resolve the path in case we just got "bash", "sh" or "tcsh"
|
|
if (!shell_filespec.ResolveExecutableLocation ())
|
|
{
|
|
error.SetErrorStringWithFormat("invalid shell path '%s'", shell_executable);
|
|
return false;
|
|
}
|
|
}
|
|
shell_filespec.GetPath (shell_resolved_path, sizeof(shell_resolved_path));
|
|
shell_executable = shell_resolved_path;
|
|
}
|
|
|
|
const char **argv = GetArguments().GetConstArgumentVector ();
|
|
if (argv == NULL || argv[0] == NULL)
|
|
return false;
|
|
Args shell_arguments;
|
|
std::string safe_arg;
|
|
shell_arguments.AppendArgument (shell_executable);
|
|
shell_arguments.AppendArgument ("-c");
|
|
StreamString shell_command;
|
|
if (will_debug)
|
|
{
|
|
// Add a modified PATH environment variable in case argv[0]
|
|
// is a relative path
|
|
const char *argv0 = argv[0];
|
|
if (argv0 && (argv0[0] != '/' && argv0[0] != '~'))
|
|
{
|
|
// We have a relative path to our executable which may not work if
|
|
// we just try to run "a.out" (without it being converted to "./a.out")
|
|
const char *working_dir = GetWorkingDirectory();
|
|
// Be sure to put quotes around PATH's value in case any paths have spaces...
|
|
std::string new_path("PATH=\"");
|
|
const size_t empty_path_len = new_path.size();
|
|
|
|
if (working_dir && working_dir[0])
|
|
{
|
|
new_path += working_dir;
|
|
}
|
|
else
|
|
{
|
|
char current_working_dir[PATH_MAX];
|
|
const char *cwd = getcwd(current_working_dir, sizeof(current_working_dir));
|
|
if (cwd && cwd[0])
|
|
new_path += cwd;
|
|
}
|
|
const char *curr_path = getenv("PATH");
|
|
if (curr_path)
|
|
{
|
|
if (new_path.size() > empty_path_len)
|
|
new_path += ':';
|
|
new_path += curr_path;
|
|
}
|
|
new_path += "\" ";
|
|
shell_command.PutCString(new_path.c_str());
|
|
}
|
|
|
|
shell_command.PutCString ("exec");
|
|
|
|
// Only Apple supports /usr/bin/arch being able to specify the architecture
|
|
if (GetArchitecture().IsValid())
|
|
{
|
|
shell_command.Printf(" /usr/bin/arch -arch %s", GetArchitecture().GetArchitectureName());
|
|
// Set the resume count to 2:
|
|
// 1 - stop in shell
|
|
// 2 - stop in /usr/bin/arch
|
|
// 3 - then we will stop in our program
|
|
SetResumeCount(num_resumes + 1);
|
|
}
|
|
else
|
|
{
|
|
// Set the resume count to 1:
|
|
// 1 - stop in shell
|
|
// 2 - then we will stop in our program
|
|
SetResumeCount(num_resumes);
|
|
}
|
|
}
|
|
|
|
if (first_arg_is_full_shell_command)
|
|
{
|
|
// There should only be one argument that is the shell command itself to be used as is
|
|
if (argv[0] && !argv[1])
|
|
shell_command.Printf("%s", argv[0]);
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
for (size_t i=0; argv[i] != NULL; ++i)
|
|
{
|
|
const char *arg = Args::GetShellSafeArgument (argv[i], safe_arg);
|
|
shell_command.Printf(" %s", arg);
|
|
}
|
|
}
|
|
shell_arguments.AppendArgument (shell_command.GetString().c_str());
|
|
m_executable.SetFile(shell_executable, false);
|
|
m_arguments = shell_arguments;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("invalid shell path");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorString ("not launching in shell");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
ProcessLaunchInfo::FileAction::Open (int fd, const char *path, bool read, bool write)
|
|
{
|
|
if ((read || write) && fd >= 0 && path && path[0])
|
|
{
|
|
m_action = eFileActionOpen;
|
|
m_fd = fd;
|
|
if (read && write)
|
|
m_arg = O_NOCTTY | O_CREAT | O_RDWR;
|
|
else if (read)
|
|
m_arg = O_NOCTTY | O_RDONLY;
|
|
else
|
|
m_arg = O_NOCTTY | O_CREAT | O_WRONLY;
|
|
m_path.assign (path);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Clear();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ProcessLaunchInfo::FileAction::Close (int fd)
|
|
{
|
|
Clear();
|
|
if (fd >= 0)
|
|
{
|
|
m_action = eFileActionClose;
|
|
m_fd = fd;
|
|
}
|
|
return m_fd >= 0;
|
|
}
|
|
|
|
|
|
bool
|
|
ProcessLaunchInfo::FileAction::Duplicate (int fd, int dup_fd)
|
|
{
|
|
Clear();
|
|
if (fd >= 0 && dup_fd >= 0)
|
|
{
|
|
m_action = eFileActionDuplicate;
|
|
m_fd = fd;
|
|
m_arg = dup_fd;
|
|
}
|
|
return m_fd >= 0;
|
|
}
|
|
|
|
|
|
|
|
#ifndef LLDB_DISABLE_POSIX
|
|
bool
|
|
ProcessLaunchInfo::FileAction::AddPosixSpawnFileAction (void *_file_actions,
|
|
const FileAction *info,
|
|
Log *log,
|
|
Error& error)
|
|
{
|
|
if (info == NULL)
|
|
return false;
|
|
|
|
posix_spawn_file_actions_t *file_actions = reinterpret_cast<posix_spawn_file_actions_t *>(_file_actions);
|
|
|
|
switch (info->m_action)
|
|
{
|
|
case eFileActionNone:
|
|
error.Clear();
|
|
break;
|
|
|
|
case eFileActionClose:
|
|
if (info->m_fd == -1)
|
|
error.SetErrorString ("invalid fd for posix_spawn_file_actions_addclose(...)");
|
|
else
|
|
{
|
|
error.SetError (::posix_spawn_file_actions_addclose (file_actions, info->m_fd),
|
|
eErrorTypePOSIX);
|
|
if (log && (error.Fail() || log))
|
|
error.PutToLog(log, "posix_spawn_file_actions_addclose (action=%p, fd=%i)",
|
|
static_cast<void*>(file_actions), info->m_fd);
|
|
}
|
|
break;
|
|
|
|
case eFileActionDuplicate:
|
|
if (info->m_fd == -1)
|
|
error.SetErrorString ("invalid fd for posix_spawn_file_actions_adddup2(...)");
|
|
else if (info->m_arg == -1)
|
|
error.SetErrorString ("invalid duplicate fd for posix_spawn_file_actions_adddup2(...)");
|
|
else
|
|
{
|
|
error.SetError (::posix_spawn_file_actions_adddup2 (file_actions, info->m_fd, info->m_arg),
|
|
eErrorTypePOSIX);
|
|
if (log && (error.Fail() || log))
|
|
error.PutToLog(log, "posix_spawn_file_actions_adddup2 (action=%p, fd=%i, dup_fd=%i)",
|
|
static_cast<void*>(file_actions), info->m_fd,
|
|
info->m_arg);
|
|
}
|
|
break;
|
|
|
|
case eFileActionOpen:
|
|
if (info->m_fd == -1)
|
|
error.SetErrorString ("invalid fd in posix_spawn_file_actions_addopen(...)");
|
|
else
|
|
{
|
|
int oflag = info->m_arg;
|
|
|
|
mode_t mode = 0;
|
|
|
|
if (oflag & O_CREAT)
|
|
mode = 0640;
|
|
|
|
error.SetError (::posix_spawn_file_actions_addopen (file_actions,
|
|
info->m_fd,
|
|
info->m_path.c_str(),
|
|
oflag,
|
|
mode),
|
|
eErrorTypePOSIX);
|
|
if (error.Fail() || log)
|
|
error.PutToLog(log,
|
|
"posix_spawn_file_actions_addopen (action=%p, fd=%i, path='%s', oflag=%i, mode=%i)",
|
|
static_cast<void*>(file_actions), info->m_fd,
|
|
info->m_path.c_str(), oflag, mode);
|
|
}
|
|
break;
|
|
}
|
|
return error.Success();
|
|
}
|
|
#endif
|