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 PseudoTerminal), m_resume_count(0),
43 m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
44 m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {}
46 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
47 const FileSpec &stdout_file_spec,
48 const FileSpec &stderr_file_spec,
49 const FileSpec &working_directory,
50 uint32_t launch_flags)
51 : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
52 m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
53 m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
54 m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {
55 if (stdin_file_spec) {
56 FileAction file_action;
57 const bool read = true;
58 const bool write = false;
59 if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
60 AppendFileAction(file_action);
62 if (stdout_file_spec) {
63 FileAction file_action;
64 const bool read = false;
65 const bool write = true;
66 if (file_action.Open(STDOUT_FILENO, stdout_file_spec, read, write))
67 AppendFileAction(file_action);
69 if (stderr_file_spec) {
70 FileAction file_action;
71 const bool read = false;
72 const bool write = true;
73 if (file_action.Open(STDERR_FILENO, stderr_file_spec, read, write))
74 AppendFileAction(file_action);
76 if (working_directory)
77 SetWorkingDirectory(working_directory);
80 bool ProcessLaunchInfo::AppendCloseFileAction(int fd) {
81 FileAction file_action;
82 if (file_action.Close(fd)) {
83 AppendFileAction(file_action);
89 bool ProcessLaunchInfo::AppendDuplicateFileAction(int fd, int dup_fd) {
90 FileAction file_action;
91 if (file_action.Duplicate(fd, dup_fd)) {
92 AppendFileAction(file_action);
98 bool ProcessLaunchInfo::AppendOpenFileAction(int fd, const FileSpec &file_spec,
99 bool read, bool write) {
100 FileAction file_action;
101 if (file_action.Open(fd, file_spec, read, write)) {
102 AppendFileAction(file_action);
108 bool ProcessLaunchInfo::AppendSuppressFileAction(int fd, bool read,
110 FileAction file_action;
111 if (file_action.Open(fd, FileSpec{FileSystem::DEV_NULL, false}, read,
113 AppendFileAction(file_action);
119 const FileAction *ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const {
120 if (idx < m_file_actions.size())
121 return &m_file_actions[idx];
125 const FileAction *ProcessLaunchInfo::GetFileActionForFD(int fd) const {
126 for (size_t idx = 0, count = m_file_actions.size(); idx < count; ++idx) {
127 if (m_file_actions[idx].GetFD() == fd)
128 return &m_file_actions[idx];
133 const FileSpec &ProcessLaunchInfo::GetWorkingDirectory() const {
134 return m_working_dir;
137 void ProcessLaunchInfo::SetWorkingDirectory(const FileSpec &working_dir) {
138 m_working_dir = working_dir;
141 const char *ProcessLaunchInfo::GetProcessPluginName() const {
142 return (m_plugin_name.empty() ? nullptr : m_plugin_name.c_str());
145 void ProcessLaunchInfo::SetProcessPluginName(llvm::StringRef plugin) {
146 m_plugin_name = plugin;
149 const FileSpec &ProcessLaunchInfo::GetShell() const { return m_shell; }
151 void ProcessLaunchInfo::SetShell(const FileSpec &shell) {
154 m_shell.ResolveExecutableLocation();
155 m_flags.Set(lldb::eLaunchFlagLaunchInShell);
157 m_flags.Clear(lldb::eLaunchFlagLaunchInShell);
160 void ProcessLaunchInfo::SetLaunchInSeparateProcessGroup(bool separate) {
162 m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
164 m_flags.Clear(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
167 void ProcessLaunchInfo::SetShellExpandArguments(bool expand) {
169 m_flags.Set(lldb::eLaunchFlagShellExpandArguments);
171 m_flags.Clear(lldb::eLaunchFlagShellExpandArguments);
174 void ProcessLaunchInfo::Clear() {
175 ProcessInfo::Clear();
176 m_working_dir.Clear();
177 m_plugin_name.clear();
180 m_file_actions.clear();
182 m_listener_sp.reset();
183 m_hijack_listener_sp.reset();
186 void ProcessLaunchInfo::SetMonitorProcessCallback(
187 const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
188 m_monitor_callback = callback;
189 m_monitor_signals = monitor_signals;
192 bool ProcessLaunchInfo::NoOpMonitorCallback(lldb::pid_t pid, bool exited, int signal, int status) {
193 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
194 LLDB_LOG(log, "pid = {0}, exited = {1}, signal = {2}, status = {3}", pid,
195 exited, signal, status);
199 bool ProcessLaunchInfo::MonitorProcess() const {
200 if (m_monitor_callback && ProcessIDIsValid()) {
201 Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID(),
208 void ProcessLaunchInfo::SetDetachOnError(bool enable) {
210 m_flags.Set(lldb::eLaunchFlagDetachOnError);
212 m_flags.Clear(lldb::eLaunchFlagDetachOnError);
215 void ProcessLaunchInfo::FinalizeFileActions(Target *target,
216 bool default_to_use_pty) {
217 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
219 // If nothing for stdin or stdout or stderr was specified, then check the
220 // process for any default settings that were set with "settings set"
221 if (GetFileActionForFD(STDIN_FILENO) == nullptr ||
222 GetFileActionForFD(STDOUT_FILENO) == nullptr ||
223 GetFileActionForFD(STDERR_FILENO) == nullptr) {
225 log->Printf("ProcessLaunchInfo::%s at least one of stdin/stdout/stderr "
226 "was not set, evaluating default handling",
229 if (m_flags.Test(eLaunchFlagLaunchInTTY)) {
230 // Do nothing, if we are launching in a remote terminal no file actions
231 // should be done at all.
235 if (m_flags.Test(eLaunchFlagDisableSTDIO)) {
237 log->Printf("ProcessLaunchInfo::%s eLaunchFlagDisableSTDIO set, adding "
238 "suppression action for stdin, stdout and stderr",
240 AppendSuppressFileAction(STDIN_FILENO, true, false);
241 AppendSuppressFileAction(STDOUT_FILENO, false, true);
242 AppendSuppressFileAction(STDERR_FILENO, false, true);
244 // Check for any values that might have gotten set with any of: (lldb)
245 // settings set target.input-path (lldb) settings set target.output-path
246 // (lldb) settings set target.error-path
247 FileSpec in_file_spec;
248 FileSpec out_file_spec;
249 FileSpec err_file_spec;
251 // Only override with the target settings if we don't already have an
252 // action for in, out or error
253 if (GetFileActionForFD(STDIN_FILENO) == nullptr)
254 in_file_spec = target->GetStandardInputPath();
255 if (GetFileActionForFD(STDOUT_FILENO) == nullptr)
256 out_file_spec = target->GetStandardOutputPath();
257 if (GetFileActionForFD(STDERR_FILENO) == nullptr)
258 err_file_spec = target->GetStandardErrorPath();
262 log->Printf("ProcessLaunchInfo::%s target stdin='%s', target "
263 "stdout='%s', stderr='%s'",
265 in_file_spec ? in_file_spec.GetCString() : "<null>",
266 out_file_spec ? out_file_spec.GetCString() : "<null>",
267 err_file_spec ? err_file_spec.GetCString() : "<null>");
270 AppendOpenFileAction(STDIN_FILENO, in_file_spec, true, false);
273 "ProcessLaunchInfo::%s appended stdin open file action for %s",
274 __FUNCTION__, in_file_spec.GetCString());
278 AppendOpenFileAction(STDOUT_FILENO, out_file_spec, false, true);
281 "ProcessLaunchInfo::%s appended stdout open file action for %s",
282 __FUNCTION__, out_file_spec.GetCString());
286 AppendOpenFileAction(STDERR_FILENO, err_file_spec, false, true);
289 "ProcessLaunchInfo::%s appended stderr open file action for %s",
290 __FUNCTION__, err_file_spec.GetCString());
293 if (default_to_use_pty &&
294 (!in_file_spec || !out_file_spec || !err_file_spec)) {
296 log->Printf("ProcessLaunchInfo::%s default_to_use_pty is set, and at "
297 "least one stdin/stderr/stdout is unset, so generating a "
301 int open_flags = O_RDWR | O_NOCTTY;
303 // We really shouldn't be specifying platform specific flags that are
304 // intended for a system call in generic code. But this will have to
306 open_flags |= O_CLOEXEC;
308 if (m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
309 const FileSpec slave_file_spec{m_pty->GetSlaveName(nullptr, 0),
312 // Only use the slave tty if we don't have anything specified for
313 // input and don't have an action for stdin
314 if (!in_file_spec && GetFileActionForFD(STDIN_FILENO) == nullptr) {
315 AppendOpenFileAction(STDIN_FILENO, slave_file_spec, true, false);
318 // Only use the slave tty if we don't have anything specified for
319 // output and don't have an action for stdout
320 if (!out_file_spec && GetFileActionForFD(STDOUT_FILENO) == nullptr) {
321 AppendOpenFileAction(STDOUT_FILENO, slave_file_spec, false, true);
324 // Only use the slave tty if we don't have anything specified for
325 // error and don't have an action for stderr
326 if (!err_file_spec && GetFileActionForFD(STDERR_FILENO) == nullptr) {
327 AppendOpenFileAction(STDERR_FILENO, slave_file_spec, false, true);
335 bool ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell(
336 Status &error, bool localhost, bool will_debug,
337 bool first_arg_is_full_shell_command, int32_t num_resumes) {
340 if (GetFlags().Test(eLaunchFlagLaunchInShell)) {
342 std::string shell_executable = m_shell.GetPath();
344 const char **argv = GetArguments().GetConstArgumentVector();
345 if (argv == nullptr || argv[0] == nullptr)
347 Args shell_arguments;
348 std::string safe_arg;
349 shell_arguments.AppendArgument(shell_executable);
350 const llvm::Triple &triple = GetArchitecture().GetTriple();
351 if (triple.getOS() == llvm::Triple::Win32 &&
352 !triple.isWindowsCygwinEnvironment())
353 shell_arguments.AppendArgument(llvm::StringRef("/C"));
355 shell_arguments.AppendArgument(llvm::StringRef("-c"));
357 StreamString shell_command;
359 // Add a modified PATH environment variable in case argv[0] is a
361 const char *argv0 = argv[0];
362 FileSpec arg_spec(argv0, false);
363 if (arg_spec.IsRelative()) {
364 // We have a relative path to our executable which may not work if we
365 // just try to run "a.out" (without it being converted to "./a.out")
366 FileSpec working_dir = GetWorkingDirectory();
367 // Be sure to put quotes around PATH's value in case any paths have
369 std::string new_path("PATH=\"");
370 const size_t empty_path_len = new_path.size();
373 new_path += working_dir.GetPath();
375 llvm::SmallString<64> cwd;
376 if (! llvm::sys::fs::current_path(cwd))
379 std::string curr_path;
380 if (HostInfo::GetEnvironmentVar("PATH", curr_path)) {
381 if (new_path.size() > empty_path_len)
383 new_path += curr_path;
386 shell_command.PutCString(new_path);
389 if (triple.getOS() != llvm::Triple::Win32 ||
390 triple.isWindowsCygwinEnvironment())
391 shell_command.PutCString("exec");
393 // Only Apple supports /usr/bin/arch being able to specify the
395 if (GetArchitecture().IsValid() && // Valid architecture
396 GetArchitecture().GetTriple().getVendor() ==
397 llvm::Triple::Apple && // Apple only
398 GetArchitecture().GetCore() !=
399 ArchSpec::eCore_x86_64_x86_64h) // Don't do this for x86_64h
401 shell_command.Printf(" /usr/bin/arch -arch %s",
402 GetArchitecture().GetArchitectureName());
403 // Set the resume count to 2:
405 // 2 - stop in /usr/bin/arch
406 // 3 - then we will stop in our program
407 SetResumeCount(num_resumes + 1);
409 // Set the resume count to 1:
411 // 2 - then we will stop in our program
412 SetResumeCount(num_resumes);
416 if (first_arg_is_full_shell_command) {
417 // There should only be one argument that is the shell command itself
419 if (argv[0] && !argv[1])
420 shell_command.Printf("%s", argv[0]);
424 for (size_t i = 0; argv[i] != nullptr; ++i) {
426 Args::GetShellSafeArgument(m_shell, argv[i], safe_arg);
427 shell_command.Printf(" %s", arg);
430 shell_arguments.AppendArgument(shell_command.GetString());
431 m_executable = m_shell;
432 m_arguments = shell_arguments;
435 error.SetErrorString("invalid shell path");
438 error.SetErrorString("not launching in shell");
443 ListenerSP ProcessLaunchInfo::GetListenerForProcess(Debugger &debugger) {
445 return m_listener_sp;
447 return debugger.GetListener();