1 //===-- ProcessLaunchInfo.cpp -----------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // C Includes 11 // C++ Includes 12 #include <climits> 13 14 // Other libraries and framework includes 15 // Project 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" 25 26 #include "llvm/Support/ConvertUTF.h" 27 #include "llvm/Support/FileSystem.h" 28 29 #if !defined(_WIN32) 30 #include <limits.h> 31 #endif 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 //---------------------------------------------------------------------------- 37 // ProcessLaunchInfo member functions 38 //---------------------------------------------------------------------------- 39 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() {} 45 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); 61 } 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); 68 } 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); 75 } 76 if (working_directory) 77 SetWorkingDirectory(working_directory); 78 } 79 80 bool ProcessLaunchInfo::AppendCloseFileAction(int fd) { 81 FileAction file_action; 82 if (file_action.Close(fd)) { 83 AppendFileAction(file_action); 84 return true; 85 } 86 return false; 87 } 88 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); 93 return true; 94 } 95 return false; 96 } 97 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); 103 return true; 104 } 105 return false; 106 } 107 108 bool ProcessLaunchInfo::AppendSuppressFileAction(int fd, bool read, 109 bool write) { 110 FileAction file_action; 111 if (file_action.Open(fd, FileSpec{FileSystem::DEV_NULL, false}, read, 112 write)) { 113 AppendFileAction(file_action); 114 return true; 115 } 116 return false; 117 } 118 119 const FileAction *ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const { 120 if (idx < m_file_actions.size()) 121 return &m_file_actions[idx]; 122 return nullptr; 123 } 124 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]; 129 } 130 return nullptr; 131 } 132 133 const FileSpec &ProcessLaunchInfo::GetWorkingDirectory() const { 134 return m_working_dir; 135 } 136 137 void ProcessLaunchInfo::SetWorkingDirectory(const FileSpec &working_dir) { 138 m_working_dir = working_dir; 139 } 140 141 const char *ProcessLaunchInfo::GetProcessPluginName() const { 142 return (m_plugin_name.empty() ? nullptr : m_plugin_name.c_str()); 143 } 144 145 void ProcessLaunchInfo::SetProcessPluginName(llvm::StringRef plugin) { 146 m_plugin_name = plugin; 147 } 148 149 const FileSpec &ProcessLaunchInfo::GetShell() const { return m_shell; } 150 151 void ProcessLaunchInfo::SetShell(const FileSpec &shell) { 152 m_shell = shell; 153 if (m_shell) { 154 m_shell.ResolveExecutableLocation(); 155 m_flags.Set(lldb::eLaunchFlagLaunchInShell); 156 } else 157 m_flags.Clear(lldb::eLaunchFlagLaunchInShell); 158 } 159 160 void ProcessLaunchInfo::SetLaunchInSeparateProcessGroup(bool separate) { 161 if (separate) 162 m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup); 163 else 164 m_flags.Clear(lldb::eLaunchFlagLaunchInSeparateProcessGroup); 165 } 166 167 void ProcessLaunchInfo::SetShellExpandArguments(bool expand) { 168 if (expand) 169 m_flags.Set(lldb::eLaunchFlagShellExpandArguments); 170 else 171 m_flags.Clear(lldb::eLaunchFlagShellExpandArguments); 172 } 173 174 void ProcessLaunchInfo::Clear() { 175 ProcessInfo::Clear(); 176 m_working_dir.Clear(); 177 m_plugin_name.clear(); 178 m_shell.Clear(); 179 m_flags.Clear(); 180 m_file_actions.clear(); 181 m_resume_count = 0; 182 m_listener_sp.reset(); 183 m_hijack_listener_sp.reset(); 184 } 185 186 void ProcessLaunchInfo::SetMonitorProcessCallback( 187 const Host::MonitorChildProcessCallback &callback, bool monitor_signals) { 188 m_monitor_callback = callback; 189 m_monitor_signals = monitor_signals; 190 } 191 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); 196 return true; 197 } 198 199 bool ProcessLaunchInfo::MonitorProcess() const { 200 if (m_monitor_callback && ProcessIDIsValid()) { 201 Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID(), 202 m_monitor_signals); 203 return true; 204 } 205 return false; 206 } 207 208 void ProcessLaunchInfo::SetDetachOnError(bool enable) { 209 if (enable) 210 m_flags.Set(lldb::eLaunchFlagDetachOnError); 211 else 212 m_flags.Clear(lldb::eLaunchFlagDetachOnError); 213 } 214 215 void ProcessLaunchInfo::FinalizeFileActions(Target *target, 216 bool default_to_use_pty) { 217 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 218 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) { 224 if (log) 225 log->Printf("ProcessLaunchInfo::%s at least one of stdin/stdout/stderr " 226 "was not set, evaluating default handling", 227 __FUNCTION__); 228 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. 232 return; 233 } 234 235 if (m_flags.Test(eLaunchFlagDisableSTDIO)) { 236 if (log) 237 log->Printf("ProcessLaunchInfo::%s eLaunchFlagDisableSTDIO set, adding " 238 "suppression action for stdin, stdout and stderr", 239 __FUNCTION__); 240 AppendSuppressFileAction(STDIN_FILENO, true, false); 241 AppendSuppressFileAction(STDOUT_FILENO, false, true); 242 AppendSuppressFileAction(STDERR_FILENO, false, true); 243 } else { 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; 250 if (target) { 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(); 259 } 260 261 if (log) 262 log->Printf("ProcessLaunchInfo::%s target stdin='%s', target " 263 "stdout='%s', stderr='%s'", 264 __FUNCTION__, 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>"); 268 269 if (in_file_spec) { 270 AppendOpenFileAction(STDIN_FILENO, in_file_spec, true, false); 271 if (log) 272 log->Printf( 273 "ProcessLaunchInfo::%s appended stdin open file action for %s", 274 __FUNCTION__, in_file_spec.GetCString()); 275 } 276 277 if (out_file_spec) { 278 AppendOpenFileAction(STDOUT_FILENO, out_file_spec, false, true); 279 if (log) 280 log->Printf( 281 "ProcessLaunchInfo::%s appended stdout open file action for %s", 282 __FUNCTION__, out_file_spec.GetCString()); 283 } 284 285 if (err_file_spec) { 286 AppendOpenFileAction(STDERR_FILENO, err_file_spec, false, true); 287 if (log) 288 log->Printf( 289 "ProcessLaunchInfo::%s appended stderr open file action for %s", 290 __FUNCTION__, err_file_spec.GetCString()); 291 } 292 293 if (default_to_use_pty && 294 (!in_file_spec || !out_file_spec || !err_file_spec)) { 295 if (log) 296 log->Printf("ProcessLaunchInfo::%s default_to_use_pty is set, and at " 297 "least one stdin/stderr/stdout is unset, so generating a " 298 "pty to use for it", 299 __FUNCTION__); 300 301 int open_flags = O_RDWR | O_NOCTTY; 302 #if !defined(_WIN32) 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 305 // do for now. 306 open_flags |= O_CLOEXEC; 307 #endif 308 if (m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) { 309 const FileSpec slave_file_spec{m_pty->GetSlaveName(nullptr, 0), 310 false}; 311 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); 316 } 317 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); 322 } 323 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); 328 } 329 } 330 } 331 } 332 } 333 } 334 335 bool ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell( 336 Status &error, bool localhost, bool will_debug, 337 bool first_arg_is_full_shell_command, int32_t num_resumes) { 338 error.Clear(); 339 340 if (GetFlags().Test(eLaunchFlagLaunchInShell)) { 341 if (m_shell) { 342 std::string shell_executable = m_shell.GetPath(); 343 344 const char **argv = GetArguments().GetConstArgumentVector(); 345 if (argv == nullptr || argv[0] == nullptr) 346 return false; 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")); 354 else 355 shell_arguments.AppendArgument(llvm::StringRef("-c")); 356 357 StreamString shell_command; 358 if (will_debug) { 359 // Add a modified PATH environment variable in case argv[0] is a 360 // relative path. 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 368 // spaces... 369 std::string new_path("PATH=\""); 370 const size_t empty_path_len = new_path.size(); 371 372 if (working_dir) { 373 new_path += working_dir.GetPath(); 374 } else { 375 llvm::SmallString<64> cwd; 376 if (! llvm::sys::fs::current_path(cwd)) 377 new_path += cwd; 378 } 379 std::string curr_path; 380 if (HostInfo::GetEnvironmentVar("PATH", curr_path)) { 381 if (new_path.size() > empty_path_len) 382 new_path += ':'; 383 new_path += curr_path; 384 } 385 new_path += "\" "; 386 shell_command.PutCString(new_path); 387 } 388 389 if (triple.getOS() != llvm::Triple::Win32 || 390 triple.isWindowsCygwinEnvironment()) 391 shell_command.PutCString("exec"); 392 393 // Only Apple supports /usr/bin/arch being able to specify the 394 // architecture 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 400 { 401 shell_command.Printf(" /usr/bin/arch -arch %s", 402 GetArchitecture().GetArchitectureName()); 403 // Set the resume count to 2: 404 // 1 - stop in shell 405 // 2 - stop in /usr/bin/arch 406 // 3 - then we will stop in our program 407 SetResumeCount(num_resumes + 1); 408 } else { 409 // Set the resume count to 1: 410 // 1 - stop in shell 411 // 2 - then we will stop in our program 412 SetResumeCount(num_resumes); 413 } 414 } 415 416 if (first_arg_is_full_shell_command) { 417 // There should only be one argument that is the shell command itself 418 // to be used as is 419 if (argv[0] && !argv[1]) 420 shell_command.Printf("%s", argv[0]); 421 else 422 return false; 423 } else { 424 for (size_t i = 0; argv[i] != nullptr; ++i) { 425 const char *arg = 426 Args::GetShellSafeArgument(m_shell, argv[i], safe_arg); 427 shell_command.Printf(" %s", arg); 428 } 429 } 430 shell_arguments.AppendArgument(shell_command.GetString()); 431 m_executable = m_shell; 432 m_arguments = shell_arguments; 433 return true; 434 } else { 435 error.SetErrorString("invalid shell path"); 436 } 437 } else { 438 error.SetErrorString("not launching in shell"); 439 } 440 return false; 441 } 442 443 ListenerSP ProcessLaunchInfo::GetListenerForProcess(Debugger &debugger) { 444 if (m_listener_sp) 445 return m_listener_sp; 446 else 447 return debugger.GetListener(); 448 } 449