LLDB mainline
ProcessLaunchInfo.cpp
Go to the documentation of this file.
1//===-- ProcessLaunchInfo.cpp ---------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include <climits>
10
11#include "lldb/Host/Config.h"
14#include "lldb/Host/HostInfo.h"
17#include "lldb/Utility/Log.h"
19
20#include "llvm/Support/ConvertUTF.h"
21#include "llvm/Support/FileSystem.h"
22
23#if !defined(_WIN32)
24#include <climits>
25#endif
26
27using namespace lldb;
28using namespace lldb_private;
29
30// ProcessLaunchInfo member functions
31
33 : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
34 m_file_actions(), m_pty(new PseudoTerminal), m_monitor_callback(nullptr) {
35}
36
38 const FileSpec &stdout_file_spec,
39 const FileSpec &stderr_file_spec,
40 const FileSpec &working_directory,
41 uint32_t launch_flags)
42 : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
43 m_file_actions(), m_pty(new PseudoTerminal) {
44 if (stdin_file_spec) {
45 FileAction file_action;
46 const bool read = true;
47 const bool write = false;
48 if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
49 AppendFileAction(file_action);
50 }
51 if (stdout_file_spec) {
52 FileAction file_action;
53 const bool read = false;
54 const bool write = true;
55 if (file_action.Open(STDOUT_FILENO, stdout_file_spec, read, write))
56 AppendFileAction(file_action);
57 }
58 if (stderr_file_spec) {
59 FileAction file_action;
60 const bool read = false;
61 const bool write = true;
62 if (file_action.Open(STDERR_FILENO, stderr_file_spec, read, write))
63 AppendFileAction(file_action);
64 }
65 if (working_directory)
66 SetWorkingDirectory(working_directory);
67}
68
70 FileAction file_action;
71 if (file_action.Close(fd)) {
72 AppendFileAction(file_action);
73 return true;
74 }
75 return false;
76}
77
79 FileAction file_action;
80 if (file_action.Duplicate(fd, dup_fd)) {
81 AppendFileAction(file_action);
82 return true;
83 }
84 return false;
85}
86
88 bool read, bool write) {
89 FileAction file_action;
90 if (file_action.Open(fd, file_spec, read, write)) {
91 AppendFileAction(file_action);
92 return true;
93 }
94 return false;
95}
96
98 bool write) {
99 FileAction file_action;
100 if (file_action.Open(fd, FileSpec(FileSystem::DEV_NULL), read, write)) {
101 AppendFileAction(file_action);
102 return true;
103 }
104 return false;
105}
106
108 if (idx < m_file_actions.size())
109 return &m_file_actions[idx];
110 return nullptr;
111}
112
114 for (size_t idx = 0, count = m_file_actions.size(); idx < count; ++idx) {
115 if (m_file_actions[idx].GetFD() == fd)
116 return &m_file_actions[idx];
117 }
118 return nullptr;
119}
120
122 return m_working_dir;
123}
124
126 m_working_dir = working_dir;
127}
128
130 return llvm::StringRef(m_plugin_name);
131}
132
133void ProcessLaunchInfo::SetProcessPluginName(llvm::StringRef plugin) {
134 m_plugin_name = std::string(plugin);
135}
136
138
140 m_shell = shell;
141 if (m_shell) {
143 m_flags.Set(lldb::eLaunchFlagLaunchInShell);
144 } else
145 m_flags.Clear(lldb::eLaunchFlagLaunchInShell);
146}
147
149 if (separate)
150 m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
151 else
152 m_flags.Clear(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
153}
154
156 if (expand)
157 m_flags.Set(lldb::eLaunchFlagShellExpandArguments);
158 else
159 m_flags.Clear(lldb::eLaunchFlagShellExpandArguments);
160}
161
165 m_plugin_name.clear();
166 m_shell.Clear();
167 m_flags.Clear();
168 m_file_actions.clear();
169 m_resume_count = 0;
170 m_listener_sp.reset();
171 m_hijack_listener_sp.reset();
172}
173
175 int status) {
177 LLDB_LOG(log, "pid = {0}, signal = {1}, status = {2}", pid, signal, status);
178}
179
182 llvm::Expected<HostThread> maybe_thread =
184 if (!maybe_thread)
185 LLDB_LOG_ERROR(GetLog(LLDBLog::Host), maybe_thread.takeError(),
186 "failed to launch host thread: {0}");
187 return true;
188 }
189 return false;
190}
191
193 if (enable)
194 m_flags.Set(lldb::eLaunchFlagDetachOnError);
195 else
196 m_flags.Clear(lldb::eLaunchFlagDetachOnError);
197}
198
201
202 bool stdin_free = GetFileActionForFD(STDIN_FILENO) == nullptr;
203 bool stdout_free = GetFileActionForFD(STDOUT_FILENO) == nullptr;
204 bool stderr_free = GetFileActionForFD(STDERR_FILENO) == nullptr;
205 bool any_free = stdin_free || stdout_free || stderr_free;
206 if (!any_free)
207 return llvm::Error::success();
208
209 LLDB_LOG(log, "Generating a pty to use for stdin/out/err");
210
211 int open_flags = O_RDWR | O_NOCTTY;
212#if !defined(_WIN32)
213 // We really shouldn't be specifying platform specific flags that are
214 // intended for a system call in generic code. But this will have to
215 // do for now.
216 open_flags |= O_CLOEXEC;
217#endif
218 if (llvm::Error Err = m_pty->OpenFirstAvailablePrimary(open_flags))
219 return Err;
220
221 const FileSpec secondary_file_spec(m_pty->GetSecondaryName());
222
223 if (stdin_free)
224 AppendOpenFileAction(STDIN_FILENO, secondary_file_spec, true, false);
225
226 if (stdout_free)
227 AppendOpenFileAction(STDOUT_FILENO, secondary_file_spec, false, true);
228
229 if (stderr_free)
230 AppendOpenFileAction(STDERR_FILENO, secondary_file_spec, false, true);
231 return llvm::Error::success();
232}
233
235 Status &error, bool will_debug, bool first_arg_is_full_shell_command,
236 uint32_t num_resumes) {
237 error.Clear();
238
239 if (GetFlags().Test(eLaunchFlagLaunchInShell)) {
240 if (m_shell) {
241 std::string shell_executable = m_shell.GetPath();
242
243 const char **argv = GetArguments().GetConstArgumentVector();
244 if (argv == nullptr || argv[0] == nullptr)
245 return false;
246 Args shell_arguments;
247 shell_arguments.AppendArgument(shell_executable);
248 const llvm::Triple &triple = GetArchitecture().GetTriple();
249 if (triple.getOS() == llvm::Triple::Win32 &&
250 !triple.isWindowsCygwinEnvironment())
251 shell_arguments.AppendArgument(llvm::StringRef("/C"));
252 else
253 shell_arguments.AppendArgument(llvm::StringRef("-c"));
254
255 StreamString shell_command;
256 if (will_debug) {
257 // Add a modified PATH environment variable in case argv[0] is a
258 // relative path.
259 const char *argv0 = argv[0];
260 FileSpec arg_spec(argv0);
261 if (arg_spec.IsRelative()) {
262 // We have a relative path to our executable which may not work if we
263 // just try to run "a.out" (without it being converted to "./a.out")
264 FileSpec working_dir = GetWorkingDirectory();
265 // Be sure to put quotes around PATH's value in case any paths have
266 // spaces...
267 std::string new_path("PATH=\"");
268 const size_t empty_path_len = new_path.size();
269
270 if (working_dir) {
271 new_path += working_dir.GetPath();
272 } else {
273 llvm::SmallString<64> cwd;
274 if (! llvm::sys::fs::current_path(cwd))
275 new_path += cwd;
276 }
277 std::string curr_path;
278 if (HostInfo::GetEnvironmentVar("PATH", curr_path)) {
279 if (new_path.size() > empty_path_len)
280 new_path += ':';
281 new_path += curr_path;
282 }
283 new_path += "\" ";
284 shell_command.PutCString(new_path);
285 }
286
287 if (triple.getOS() != llvm::Triple::Win32 ||
288 triple.isWindowsCygwinEnvironment())
289 shell_command.PutCString("exec");
290
291 // Only Apple supports /usr/bin/arch being able to specify the
292 // architecture
293 if (GetArchitecture().IsValid() && // Valid architecture
294 GetArchitecture().GetTriple().getVendor() ==
295 llvm::Triple::Apple && // Apple only
296 GetArchitecture().GetCore() !=
297 ArchSpec::eCore_x86_64_x86_64h) // Don't do this for x86_64h
298 {
299 shell_command.Printf(" /usr/bin/arch -arch %s",
300 GetArchitecture().GetArchitectureName());
301 // Set the resume count to 2:
302 // 1 - stop in shell
303 // 2 - stop in /usr/bin/arch
304 // 3 - then we will stop in our program
305 SetResumeCount(num_resumes + 1);
306 } else {
307 // Set the resume count to 1:
308 // 1 - stop in shell
309 // 2 - then we will stop in our program
310 SetResumeCount(num_resumes);
311 }
312 }
313
314 if (first_arg_is_full_shell_command) {
315 // There should only be one argument that is the shell command itself
316 // to be used as is
317 if (argv[0] && !argv[1])
318 shell_command.Printf("%s", argv[0]);
319 else
320 return false;
321 } else {
322 for (size_t i = 0; argv[i] != nullptr; ++i) {
323 std::string safe_arg = Args::GetShellSafeArgument(m_shell, argv[i]);
324 if (safe_arg.empty())
325 safe_arg = "\"\"";
326 // Add a space to separate this arg from the previous one.
327 shell_command.PutCString(" ");
328 shell_command.PutCString(safe_arg);
329 }
330 }
331 shell_arguments.AppendArgument(shell_command.GetString());
333 m_arguments = shell_arguments;
334 return true;
335 } else {
336 error.SetErrorString("invalid shell path");
337 }
338 } else {
339 error.SetErrorString("not launching in shell");
340 }
341 return false;
342}
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:359
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:382
static bool separate(size_t count)
Definition: UUID.cpp:24
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
A command line argument class.
Definition: Args.h:33
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:322
static std::string GetShellSafeArgument(const FileSpec &shell, llvm::StringRef unsafe_arg)
Definition: Args.cpp:384
const char ** GetConstArgumentVector() const
Gets the argument vector.
Definition: Args.cpp:279
bool Duplicate(int fd, int dup_fd)
Definition: FileAction.cpp:62
bool Open(int fd, const FileSpec &file_spec, bool read, bool write)
Definition: FileAction.cpp:34
A file utility class.
Definition: FileSpec.h:56
bool IsRelative() const
Returns true if the filespec represents a relative path.
Definition: FileSpec.cpp:507
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
void Clear()
Clears the object state.
Definition: FileSpec.cpp:259
static const char * DEV_NULL
Definition: FileSystem.h:32
bool ResolveExecutableLocation(FileSpec &file_spec)
Call into the Host to see if it can help find the file.
static FileSystem & Instance()
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
static llvm::Expected< HostThread > StartMonitoringChildProcess(const MonitorChildProcessCallback &callback, lldb::pid_t pid)
Start monitoring a child process.
bool ProcessIDIsValid() const
Definition: ProcessInfo.h:71
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
lldb::ListenerSP m_hijack_listener_sp
Definition: ProcessInfo.h:132
lldb::ListenerSP m_listener_sp
Definition: ProcessInfo.h:131
ArchSpec & GetArchitecture()
Definition: ProcessInfo.h:61
llvm::StringRef GetProcessPluginName() const
const FileSpec & GetShell() const
std::vector< FileAction > m_file_actions
bool AppendOpenFileAction(int fd, const FileSpec &file_spec, bool read, bool write)
bool AppendSuppressFileAction(int fd, bool read, bool write)
static void NoOpMonitorCallback(lldb::pid_t pid, int signal, int status)
A Monitor callback which does not take any action on process events.
const FileAction * GetFileActionAtIndex(size_t idx) const
std::shared_ptr< PseudoTerminal > m_pty
void SetShell(const FileSpec &shell)
const FileAction * GetFileActionForFD(int fd) const
void SetProcessPluginName(llvm::StringRef plugin)
bool ConvertArgumentsForLaunchingInShell(Status &error, bool will_debug, bool first_arg_is_full_shell_command, uint32_t num_resumes)
bool AppendDuplicateFileAction(int fd, int dup_fd)
void AppendFileAction(const FileAction &info)
void SetLaunchInSeparateProcessGroup(bool separate)
void SetWorkingDirectory(const FileSpec &working_dir)
Host::MonitorChildProcessCallback m_monitor_callback
const FileSpec & GetWorkingDirectory() const
A pseudo terminal helper class.
An error handling class.
Definition: Status.h:44
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
Definition: SBAddress.h:15
uint64_t pid_t
Definition: lldb-types.h:81
#define O_NOCTTY