1 //===-- ProcessLaunchInfo.cpp -----------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
14 // Other libraries and framework includes
16 #include "lldb/Core/Debugger.h"
17 #include "lldb/Host/Config.h"
18 #include "lldb/Host/FileSystem.h"
19 #include "lldb/Host/HostInfo.h"
20 #include "lldb/Target/FileAction.h"
21 #include "lldb/Target/ProcessLaunchInfo.h"
22 #include "lldb/Target/Target.h"
23 #include "lldb/Utility/Log.h"
24 #include "lldb/Utility/StreamString.h"
26 #include "llvm/Support/ConvertUTF.h"
27 #include "llvm/Support/FileSystem.h"
34 using namespace lldb_private;
36 //----------------------------------------------------------------------------
37 // ProcessLaunchInfo member functions
38 //----------------------------------------------------------------------------
40 ProcessLaunchInfo::ProcessLaunchInfo()
41 : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
42 m_file_actions(), m_pty(new lldb_utility::PseudoTerminal),
43 m_resume_count(0), m_monitor_callback(nullptr),
44 m_monitor_callback_baton(nullptr), m_monitor_signals(false),
45 m_listener_sp(), m_hijack_listener_sp() {}
47 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
48 const FileSpec &stdout_file_spec,
49 const FileSpec &stderr_file_spec,
50 const FileSpec &working_directory,
51 uint32_t launch_flags)
52 : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
53 m_file_actions(), m_pty(new lldb_utility::PseudoTerminal),
54 m_resume_count(0), m_monitor_callback(nullptr),
55 m_monitor_callback_baton(nullptr), m_monitor_signals(false),
56 m_listener_sp(), m_hijack_listener_sp() {
57 if (stdin_file_spec) {
58 FileAction file_action;
59 const bool read = true;
60 const bool write = false;
61 if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
62 AppendFileAction(file_action);
64 if (stdout_file_spec) {
65 FileAction file_action;
66 const bool read = false;
67 const bool write = true;
68 if (file_action.Open(STDOUT_FILENO, stdout_file_spec, read, write))
69 AppendFileAction(file_action);
71 if (stderr_file_spec) {
72 FileAction file_action;
73 const bool read = false;
74 const bool write = true;
75 if (file_action.Open(STDERR_FILENO, stderr_file_spec, read, write))
76 AppendFileAction(file_action);
78 if (working_directory)
79 SetWorkingDirectory(working_directory);
82 bool ProcessLaunchInfo::AppendCloseFileAction(int fd) {
83 FileAction file_action;
84 if (file_action.Close(fd)) {
85 AppendFileAction(file_action);
91 bool ProcessLaunchInfo::AppendDuplicateFileAction(int fd, int dup_fd) {
92 FileAction file_action;
93 if (file_action.Duplicate(fd, dup_fd)) {
94 AppendFileAction(file_action);
100 bool ProcessLaunchInfo::AppendOpenFileAction(int fd, const FileSpec &file_spec,
101 bool read, bool write) {
102 FileAction file_action;
103 if (file_action.Open(fd, file_spec, read, write)) {
104 AppendFileAction(file_action);
110 bool ProcessLaunchInfo::AppendSuppressFileAction(int fd, bool read,
112 FileAction file_action;
113 if (file_action.Open(fd, FileSpec{FileSystem::DEV_NULL, false}, read,
115 AppendFileAction(file_action);
121 const FileAction *ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const {
122 if (idx < m_file_actions.size())
123 return &m_file_actions[idx];
127 const FileAction *ProcessLaunchInfo::GetFileActionForFD(int fd) const {
128 for (size_t idx = 0, count = m_file_actions.size(); idx < count; ++idx) {
129 if (m_file_actions[idx].GetFD() == fd)
130 return &m_file_actions[idx];
135 const FileSpec &ProcessLaunchInfo::GetWorkingDirectory() const {
136 return m_working_dir;
139 void ProcessLaunchInfo::SetWorkingDirectory(const FileSpec &working_dir) {
140 m_working_dir = working_dir;
143 const char *ProcessLaunchInfo::GetProcessPluginName() const {
144 return (m_plugin_name.empty() ? nullptr : m_plugin_name.c_str());
147 void ProcessLaunchInfo::SetProcessPluginName(llvm::StringRef plugin) {
148 m_plugin_name = plugin;
151 const FileSpec &ProcessLaunchInfo::GetShell() const { return m_shell; }
153 void ProcessLaunchInfo::SetShell(const FileSpec &shell) {
156 m_shell.ResolveExecutableLocation();
157 m_flags.Set(lldb::eLaunchFlagLaunchInShell);
159 m_flags.Clear(lldb::eLaunchFlagLaunchInShell);
162 void ProcessLaunchInfo::SetLaunchInSeparateProcessGroup(bool separate) {
164 m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
166 m_flags.Clear(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
169 void ProcessLaunchInfo::SetShellExpandArguments(bool expand) {
171 m_flags.Set(lldb::eLaunchFlagShellExpandArguments);
173 m_flags.Clear(lldb::eLaunchFlagShellExpandArguments);
176 void ProcessLaunchInfo::Clear() {
177 ProcessInfo::Clear();
178 m_working_dir.Clear();
179 m_plugin_name.clear();
182 m_file_actions.clear();
184 m_listener_sp.reset();
185 m_hijack_listener_sp.reset();
188 void ProcessLaunchInfo::SetMonitorProcessCallback(
189 const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
190 m_monitor_callback = callback;
191 m_monitor_signals = monitor_signals;
194 bool ProcessLaunchInfo::MonitorProcess() const {
195 if (m_monitor_callback && ProcessIDIsValid()) {
196 Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID(),
203 void ProcessLaunchInfo::SetDetachOnError(bool enable) {
205 m_flags.Set(lldb::eLaunchFlagDetachOnError);
207 m_flags.Clear(lldb::eLaunchFlagDetachOnError);
210 void ProcessLaunchInfo::FinalizeFileActions(Target *target,
211 bool default_to_use_pty) {
212 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
214 // If nothing for stdin or stdout or stderr was specified, then check the
215 // process for any default
216 // settings that were set with "settings set"
217 if (GetFileActionForFD(STDIN_FILENO) == nullptr ||
218 GetFileActionForFD(STDOUT_FILENO) == nullptr ||
219 GetFileActionForFD(STDERR_FILENO) == nullptr) {
221 log->Printf("ProcessLaunchInfo::%s at least one of stdin/stdout/stderr "
222 "was not set, evaluating default handling",
225 if (m_flags.Test(eLaunchFlagLaunchInTTY)) {
226 // Do nothing, if we are launching in a remote terminal
227 // no file actions should be done at all.
231 if (m_flags.Test(eLaunchFlagDisableSTDIO)) {
233 log->Printf("ProcessLaunchInfo::%s eLaunchFlagDisableSTDIO set, adding "
234 "suppression action for stdin, stdout and stderr",
236 AppendSuppressFileAction(STDIN_FILENO, true, false);
237 AppendSuppressFileAction(STDOUT_FILENO, false, true);
238 AppendSuppressFileAction(STDERR_FILENO, false, true);
240 // Check for any values that might have gotten set with any of:
241 // (lldb) settings set target.input-path
242 // (lldb) settings set target.output-path
243 // (lldb) settings set target.error-path
244 FileSpec in_file_spec;
245 FileSpec out_file_spec;
246 FileSpec err_file_spec;
248 // Only override with the target settings if we don't already have
249 // an action for in, out or error
250 if (GetFileActionForFD(STDIN_FILENO) == nullptr)
251 in_file_spec = target->GetStandardInputPath();
252 if (GetFileActionForFD(STDOUT_FILENO) == nullptr)
253 out_file_spec = target->GetStandardOutputPath();
254 if (GetFileActionForFD(STDERR_FILENO) == nullptr)
255 err_file_spec = target->GetStandardErrorPath();
259 log->Printf("ProcessLaunchInfo::%s target stdin='%s', target "
260 "stdout='%s', stderr='%s'",
262 in_file_spec ? in_file_spec.GetCString() : "<null>",
263 out_file_spec ? out_file_spec.GetCString() : "<null>",
264 err_file_spec ? err_file_spec.GetCString() : "<null>");
267 AppendOpenFileAction(STDIN_FILENO, in_file_spec, true, false);
270 "ProcessLaunchInfo::%s appended stdin open file action for %s",
271 __FUNCTION__, in_file_spec.GetCString());
275 AppendOpenFileAction(STDOUT_FILENO, out_file_spec, false, true);
278 "ProcessLaunchInfo::%s appended stdout open file action for %s",
279 __FUNCTION__, out_file_spec.GetCString());
283 AppendOpenFileAction(STDERR_FILENO, err_file_spec, false, true);
286 "ProcessLaunchInfo::%s appended stderr open file action for %s",
287 __FUNCTION__, err_file_spec.GetCString());
290 if (default_to_use_pty &&
291 (!in_file_spec || !out_file_spec || !err_file_spec)) {
293 log->Printf("ProcessLaunchInfo::%s default_to_use_pty is set, and at "
294 "least one stdin/stderr/stdout is unset, so generating a "
298 int open_flags = O_RDWR | O_NOCTTY;
300 // We really shouldn't be specifying platform specific flags
301 // that are intended for a system call in generic code. But
302 // this will have to do for now.
303 open_flags |= O_CLOEXEC;
305 if (m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
306 const FileSpec slave_file_spec{m_pty->GetSlaveName(nullptr, 0),
309 // Only use the slave tty if we don't have anything specified for
310 // input and don't have an action for stdin
311 if (!in_file_spec && GetFileActionForFD(STDIN_FILENO) == nullptr) {
312 AppendOpenFileAction(STDIN_FILENO, slave_file_spec, true, false);
315 // Only use the slave tty if we don't have anything specified for
316 // output and don't have an action for stdout
317 if (!out_file_spec && GetFileActionForFD(STDOUT_FILENO) == nullptr) {
318 AppendOpenFileAction(STDOUT_FILENO, slave_file_spec, false, true);
321 // Only use the slave tty if we don't have anything specified for
322 // error and don't have an action for stderr
323 if (!err_file_spec && GetFileActionForFD(STDERR_FILENO) == nullptr) {
324 AppendOpenFileAction(STDERR_FILENO, slave_file_spec, false, true);
332 bool ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell(
333 Status &error, bool localhost, bool will_debug,
334 bool first_arg_is_full_shell_command, int32_t num_resumes) {
337 if (GetFlags().Test(eLaunchFlagLaunchInShell)) {
339 std::string shell_executable = m_shell.GetPath();
341 const char **argv = GetArguments().GetConstArgumentVector();
342 if (argv == nullptr || argv[0] == nullptr)
344 Args shell_arguments;
345 std::string safe_arg;
346 shell_arguments.AppendArgument(shell_executable);
347 const llvm::Triple &triple = GetArchitecture().GetTriple();
348 if (triple.getOS() == llvm::Triple::Win32 &&
349 !triple.isWindowsCygwinEnvironment())
350 shell_arguments.AppendArgument(llvm::StringRef("/C"));
352 shell_arguments.AppendArgument(llvm::StringRef("-c"));
354 StreamString shell_command;
356 // Add a modified PATH environment variable in case argv[0]
357 // is a relative path.
358 const char *argv0 = argv[0];
359 FileSpec arg_spec(argv0, false);
360 if (arg_spec.IsRelative()) {
361 // We have a relative path to our executable which may not work if
362 // we just try to run "a.out" (without it being converted to
364 FileSpec working_dir = GetWorkingDirectory();
365 // Be sure to put quotes around PATH's value in case any paths have
367 std::string new_path("PATH=\"");
368 const size_t empty_path_len = new_path.size();
371 new_path += working_dir.GetPath();
373 llvm::SmallString<64> cwd;
374 if (! llvm::sys::fs::current_path(cwd))
377 std::string curr_path;
378 if (HostInfo::GetEnvironmentVar("PATH", curr_path)) {
379 if (new_path.size() > empty_path_len)
381 new_path += curr_path;
384 shell_command.PutCString(new_path);
387 if (triple.getOS() != llvm::Triple::Win32 ||
388 triple.isWindowsCygwinEnvironment())
389 shell_command.PutCString("exec");
391 // Only Apple supports /usr/bin/arch being able to specify the
393 if (GetArchitecture().IsValid() && // Valid architecture
394 GetArchitecture().GetTriple().getVendor() ==
395 llvm::Triple::Apple && // Apple only
396 GetArchitecture().GetCore() !=
397 ArchSpec::eCore_x86_64_x86_64h) // Don't do this for x86_64h
399 shell_command.Printf(" /usr/bin/arch -arch %s",
400 GetArchitecture().GetArchitectureName());
401 // Set the resume count to 2:
403 // 2 - stop in /usr/bin/arch
404 // 3 - then we will stop in our program
405 SetResumeCount(num_resumes + 1);
407 // Set the resume count to 1:
409 // 2 - then we will stop in our program
410 SetResumeCount(num_resumes);
414 if (first_arg_is_full_shell_command) {
415 // There should only be one argument that is the shell command itself to
417 if (argv[0] && !argv[1])
418 shell_command.Printf("%s", argv[0]);
422 for (size_t i = 0; argv[i] != nullptr; ++i) {
424 Args::GetShellSafeArgument(m_shell, argv[i], safe_arg);
425 shell_command.Printf(" %s", arg);
428 shell_arguments.AppendArgument(shell_command.GetString());
429 m_executable = m_shell;
430 m_arguments = shell_arguments;
433 error.SetErrorString("invalid shell path");
436 error.SetErrorString("not launching in shell");
441 ListenerSP ProcessLaunchInfo::GetListenerForProcess(Debugger &debugger) {
443 return m_listener_sp;
445 return debugger.GetListener();