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" 12#include "lldb/Host/FileAction.h" 13#include "lldb/Host/FileSystem.h" 14#include "lldb/Host/HostInfo.h" 15#include "lldb/Host/ProcessLaunchInfo.h" 16#include "lldb/Utility/LLDBLog.h" 17#include "lldb/Utility/Log.h" 18#include "lldb/Utility/StreamString.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 32ProcessLaunchInfo::ProcessLaunchInfo() 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 37ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec, 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 69bool ProcessLaunchInfo::AppendCloseFileAction(int fd) { 70 FileAction file_action; 71 if (file_action.Close(fd)) { 72 AppendFileAction(file_action); 73 return true; 74 } 75 return false; 76} 77 78bool ProcessLaunchInfo::AppendDuplicateFileAction(int fd, int dup_fd) { 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 87bool ProcessLaunchInfo::AppendOpenFileAction(int fd, const FileSpec &file_spec, 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 97bool ProcessLaunchInfo::AppendSuppressFileAction(int fd, bool read, 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 107const FileAction *ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const { 108 if (idx < m_file_actions.size()) 109 return &m_file_actions[idx]; 110 return nullptr; 111} 112 113const FileAction *ProcessLaunchInfo::GetFileActionForFD(int fd) const { 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 121const FileSpec &ProcessLaunchInfo::GetWorkingDirectory() const { 122 return m_working_dir; 123} 124 125void ProcessLaunchInfo::SetWorkingDirectory(const FileSpec &working_dir) { 126 m_working_dir = working_dir; 127} 128 129llvm::StringRef ProcessLaunchInfo::GetProcessPluginName() const { 130 return llvm::StringRef(m_plugin_name); 131} 132 133void ProcessLaunchInfo::SetProcessPluginName(llvm::StringRef plugin) { 134 m_plugin_name = std::string(plugin); 135} 136 137const FileSpec &ProcessLaunchInfo::GetShell() const { return m_shell; } 138 139void ProcessLaunchInfo::SetShell(const FileSpec &shell) { 140 m_shell = shell; 141 if (m_shell) { 142 FileSystem::Instance().ResolveExecutableLocation(m_shell); 143 m_flags.Set(lldb::eLaunchFlagLaunchInShell); 144 } else 145 m_flags.Clear(lldb::eLaunchFlagLaunchInShell); 146} 147 148void ProcessLaunchInfo::SetLaunchInSeparateProcessGroup(bool separate) { 149 if (separate) 150 m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup); 151 else 152 m_flags.Clear(lldb::eLaunchFlagLaunchInSeparateProcessGroup); 153} 154 155void ProcessLaunchInfo::SetShellExpandArguments(bool expand) { 156 if (expand) 157 m_flags.Set(lldb::eLaunchFlagShellExpandArguments); 158 else 159 m_flags.Clear(lldb::eLaunchFlagShellExpandArguments); 160} 161 162void ProcessLaunchInfo::Clear() { 163 ProcessInfo::Clear(); 164 m_working_dir.Clear(); 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 174void ProcessLaunchInfo::NoOpMonitorCallback(lldb::pid_t pid, int signal, 175 int status) { 176 Log *log = GetLog(LLDBLog::Process); 177 LLDB_LOG(log, "pid = {0}, signal = {1}, status = {2}", pid, signal, status); 178} 179 180bool ProcessLaunchInfo::MonitorProcess() const { 181 if (m_monitor_callback && ProcessIDIsValid()) { 182 llvm::Expected<HostThread> maybe_thread = 183 Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID()); 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 192void ProcessLaunchInfo::SetDetachOnError(bool enable) { 193 if (enable) 194 m_flags.Set(lldb::eLaunchFlagDetachOnError); 195 else 196 m_flags.Clear(lldb::eLaunchFlagDetachOnError); 197} 198 199llvm::Error ProcessLaunchInfo::SetUpPtyRedirection() { 200 Log *log = GetLog(LLDBLog::Process); 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 234bool ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell( 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()); 332 m_executable = m_shell; 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} 343