contrib/llvm/tools/lldb/source/Target/ProcessLaunchInfo.cpp

   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 #include <climits>
  11
  12 #include "lldb/Host/Config.h"
  13 #include "lldb/Host/FileSystem.h"
  14 #include "lldb/Host/HostInfo.h"
  15 #include "lldb/Target/FileAction.h"
  16 #include "lldb/Target/ProcessLaunchInfo.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 <limits.h>
  25 #endif
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 //----------------------------------------------------------------------------
  31 // ProcessLaunchInfo member functions
  32 //----------------------------------------------------------------------------
  33
  34 ProcessLaunchInfo::ProcessLaunchInfo()
  35     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
  36       m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
  37       m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
  38       m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {}
  39
  40 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
  41                                      const FileSpec &stdout_file_spec,
  42                                      const FileSpec &stderr_file_spec,
  43                                      const FileSpec &working_directory,
  44                                      uint32_t launch_flags)
  45     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
  46       m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
  47       m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
  48       m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp() {
  49   if (stdin_file_spec) {
  50     FileAction file_action;
  51     const bool read = true;
  52     const bool write = false;
  53     if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
  54       AppendFileAction(file_action);
  55   }
  56   if (stdout_file_spec) {
  57     FileAction file_action;
  58     const bool read = false;
  59     const bool write = true;
  60     if (file_action.Open(STDOUT_FILENO, stdout_file_spec, read, write))
  61       AppendFileAction(file_action);
  62   }
  63   if (stderr_file_spec) {
  64     FileAction file_action;
  65     const bool read = false;
  66     const bool write = true;
  67     if (file_action.Open(STDERR_FILENO, stderr_file_spec, read, write))
  68       AppendFileAction(file_action);
  69   }
  70   if (working_directory)
  71     SetWorkingDirectory(working_directory);
  72 }
  73
  74 bool ProcessLaunchInfo::AppendCloseFileAction(int fd) {
  75   FileAction file_action;
  76   if (file_action.Close(fd)) {
  77     AppendFileAction(file_action);
  78     return true;
  79   }
  80   return false;
  81 }
  82
  83 bool ProcessLaunchInfo::AppendDuplicateFileAction(int fd, int dup_fd) {
  84   FileAction file_action;
  85   if (file_action.Duplicate(fd, dup_fd)) {
  86     AppendFileAction(file_action);
  87     return true;
  88   }
  89   return false;
  90 }
  91
  92 bool ProcessLaunchInfo::AppendOpenFileAction(int fd, const FileSpec &file_spec,
  93                                              bool read, bool write) {
  94   FileAction file_action;
  95   if (file_action.Open(fd, file_spec, read, write)) {
  96     AppendFileAction(file_action);
  97     return true;
  98   }
  99   return false;
 100 }
 101
 102 bool ProcessLaunchInfo::AppendSuppressFileAction(int fd, bool read,
 103                                                  bool write) {
 104   FileAction file_action;
 105   if (file_action.Open(fd, FileSpec(FileSystem::DEV_NULL), read, write)) {
 106     AppendFileAction(file_action);
 107     return true;
 108   }
 109   return false;
 110 }
 111
 112 const FileAction *ProcessLaunchInfo::GetFileActionAtIndex(size_t idx) const {
 113   if (idx < m_file_actions.size())
 114     return &m_file_actions[idx];
 115   return nullptr;
 116 }
 117
 118 const FileAction *ProcessLaunchInfo::GetFileActionForFD(int fd) const {
 119   for (size_t idx = 0, count = m_file_actions.size(); idx < count; ++idx) {
 120     if (m_file_actions[idx].GetFD() == fd)
 121       return &m_file_actions[idx];
 122   }
 123   return nullptr;
 124 }
 125
 126 const FileSpec &ProcessLaunchInfo::GetWorkingDirectory() const {
 127   return m_working_dir;
 128 }
 129
 130 void ProcessLaunchInfo::SetWorkingDirectory(const FileSpec &working_dir) {
 131   m_working_dir = working_dir;
 132 }
 133
 134 const char *ProcessLaunchInfo::GetProcessPluginName() const {
 135   return (m_plugin_name.empty() ? nullptr : m_plugin_name.c_str());
 136 }
 137
 138 void ProcessLaunchInfo::SetProcessPluginName(llvm::StringRef plugin) {
 139   m_plugin_name = plugin;
 140 }
 141
 142 const FileSpec &ProcessLaunchInfo::GetShell() const { return m_shell; }
 143
 144 void ProcessLaunchInfo::SetShell(const FileSpec &shell) {
 145   m_shell = shell;
 146   if (m_shell) {
 147     FileSystem::Instance().ResolveExecutableLocation(m_shell);
 148     m_flags.Set(lldb::eLaunchFlagLaunchInShell);
 149   } else
 150     m_flags.Clear(lldb::eLaunchFlagLaunchInShell);
 151 }
 152
 153 void ProcessLaunchInfo::SetLaunchInSeparateProcessGroup(bool separate) {
 154   if (separate)
 155     m_flags.Set(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
 156   else
 157     m_flags.Clear(lldb::eLaunchFlagLaunchInSeparateProcessGroup);
 158 }
 159
 160 void ProcessLaunchInfo::SetShellExpandArguments(bool expand) {
 161   if (expand)
 162     m_flags.Set(lldb::eLaunchFlagShellExpandArguments);
 163   else
 164     m_flags.Clear(lldb::eLaunchFlagShellExpandArguments);
 165 }
 166
 167 void ProcessLaunchInfo::Clear() {
 168   ProcessInfo::Clear();
 169   m_working_dir.Clear();
 170   m_plugin_name.clear();
 171   m_shell.Clear();
 172   m_flags.Clear();
 173   m_file_actions.clear();
 174   m_resume_count = 0;
 175   m_listener_sp.reset();
 176   m_hijack_listener_sp.reset();
 177 }
 178
 179 void ProcessLaunchInfo::SetMonitorProcessCallback(
 180     const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
 181   m_monitor_callback = callback;
 182   m_monitor_signals = monitor_signals;
 183 }
 184
 185 bool ProcessLaunchInfo::NoOpMonitorCallback(lldb::pid_t pid, bool exited, int signal, int status) {
 186   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
 187   LLDB_LOG(log, "pid = {0}, exited = {1}, signal = {2}, status = {3}", pid,
 188            exited, signal, status);
 189   return true;
 190 }
 191
 192 bool ProcessLaunchInfo::MonitorProcess() const {
 193   if (m_monitor_callback && ProcessIDIsValid()) {
 194     Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID(),
 195                                       m_monitor_signals);
 196     return true;
 197   }
 198   return false;
 199 }
 200
 201 void ProcessLaunchInfo::SetDetachOnError(bool enable) {
 202   if (enable)
 203     m_flags.Set(lldb::eLaunchFlagDetachOnError);
 204   else
 205     m_flags.Clear(lldb::eLaunchFlagDetachOnError);
 206 }
 207
 208 llvm::Error ProcessLaunchInfo::SetUpPtyRedirection() {
 209   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS);
 210   LLDB_LOG(log, "Generating a pty to use for stdin/out/err");
 211
 212   int open_flags = O_RDWR | O_NOCTTY;
 213 #if !defined(_WIN32)
 214   // We really shouldn't be specifying platform specific flags that are
 215   // intended for a system call in generic code.  But this will have to
 216   // do for now.
 217   open_flags |= O_CLOEXEC;
 218 #endif
 219   if (!m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
 220     return llvm::createStringError(llvm::inconvertibleErrorCode(),
 221                                    "PTY::OpenFirstAvailableMaster failed");
 222   }
 223   const FileSpec slave_file_spec(m_pty->GetSlaveName(nullptr, 0));
 224
 225   // Only use the slave tty if we don't have anything specified for
 226   // input and don't have an action for stdin
 227   if (GetFileActionForFD(STDIN_FILENO) == nullptr)
 228     AppendOpenFileAction(STDIN_FILENO, slave_file_spec, true, false);
 229
 230   // Only use the slave tty if we don't have anything specified for
 231   // output and don't have an action for stdout
 232   if (GetFileActionForFD(STDOUT_FILENO) == nullptr)
 233     AppendOpenFileAction(STDOUT_FILENO, slave_file_spec, false, true);
 234
 235   // Only use the slave tty if we don't have anything specified for
 236   // error and don't have an action for stderr
 237   if (GetFileActionForFD(STDERR_FILENO) == nullptr)
 238     AppendOpenFileAction(STDERR_FILENO, slave_file_spec, false, true);
 239   return llvm::Error::success();
 240 }
 241
 242 bool ProcessLaunchInfo::ConvertArgumentsForLaunchingInShell(
 243     Status &error, bool localhost, bool will_debug,
 244     bool first_arg_is_full_shell_command, int32_t num_resumes) {
 245   error.Clear();
 246
 247   if (GetFlags().Test(eLaunchFlagLaunchInShell)) {
 248     if (m_shell) {
 249       std::string shell_executable = m_shell.GetPath();
 250
 251       const char **argv = GetArguments().GetConstArgumentVector();
 252       if (argv == nullptr || argv[0] == nullptr)
 253         return false;
 254       Args shell_arguments;
 255       std::string safe_arg;
 256       shell_arguments.AppendArgument(shell_executable);
 257       const llvm::Triple &triple = GetArchitecture().GetTriple();
 258       if (triple.getOS() == llvm::Triple::Win32 &&
 259           !triple.isWindowsCygwinEnvironment())
 260         shell_arguments.AppendArgument(llvm::StringRef("/C"));
 261       else
 262         shell_arguments.AppendArgument(llvm::StringRef("-c"));
 263
 264       StreamString shell_command;
 265       if (will_debug) {
 266         // Add a modified PATH environment variable in case argv[0] is a
 267         // relative path.
 268         const char *argv0 = argv[0];
 269         FileSpec arg_spec(argv0);
 270         if (arg_spec.IsRelative()) {
 271           // We have a relative path to our executable which may not work if we
 272           // just try to run "a.out" (without it being converted to "./a.out")
 273           FileSpec working_dir = GetWorkingDirectory();
 274           // Be sure to put quotes around PATH's value in case any paths have
 275           // spaces...
 276           std::string new_path("PATH=\"");
 277           const size_t empty_path_len = new_path.size();
 278
 279           if (working_dir) {
 280             new_path += working_dir.GetPath();
 281           } else {
 282             llvm::SmallString<64> cwd;
 283             if (! llvm::sys::fs::current_path(cwd))
 284               new_path += cwd;
 285           }
 286           std::string curr_path;
 287           if (HostInfo::GetEnvironmentVar("PATH", curr_path)) {
 288             if (new_path.size() > empty_path_len)
 289               new_path += ':';
 290             new_path += curr_path;
 291           }
 292           new_path += "\" ";
 293           shell_command.PutCString(new_path);
 294         }
 295
 296         if (triple.getOS() != llvm::Triple::Win32 ||
 297             triple.isWindowsCygwinEnvironment())
 298           shell_command.PutCString("exec");
 299
 300         // Only Apple supports /usr/bin/arch being able to specify the
 301         // architecture
 302         if (GetArchitecture().IsValid() && // Valid architecture
 303             GetArchitecture().GetTriple().getVendor() ==
 304                 llvm::Triple::Apple && // Apple only
 305             GetArchitecture().GetCore() !=
 306                 ArchSpec::eCore_x86_64_x86_64h) // Don't do this for x86_64h
 307         {
 308           shell_command.Printf(" /usr/bin/arch -arch %s",
 309                                GetArchitecture().GetArchitectureName());
 310           // Set the resume count to 2:
 311           // 1 - stop in shell
 312           // 2 - stop in /usr/bin/arch
 313           // 3 - then we will stop in our program
 314           SetResumeCount(num_resumes + 1);
 315         } else {
 316           // Set the resume count to 1:
 317           // 1 - stop in shell
 318           // 2 - then we will stop in our program
 319           SetResumeCount(num_resumes);
 320         }
 321       }
 322
 323       if (first_arg_is_full_shell_command) {
 324         // There should only be one argument that is the shell command itself
 325         // to be used as is
 326         if (argv[0] && !argv[1])
 327           shell_command.Printf("%s", argv[0]);
 328         else
 329           return false;
 330       } else {
 331         for (size_t i = 0; argv[i] != nullptr; ++i) {
 332           const char *arg =
 333               Args::GetShellSafeArgument(m_shell, argv[i], safe_arg);
 334           shell_command.Printf(" %s", arg);
 335         }
 336       }
 337       shell_arguments.AppendArgument(shell_command.GetString());
 338       m_executable = m_shell;
 339       m_arguments = shell_arguments;
 340       return true;
 341     } else {
 342       error.SetErrorString("invalid shell path");
 343     }
 344   } else {
 345     error.SetErrorString("not launching in shell");
 346   }
 347   return false;
 348 }