contrib/llvm/tools/lldb/source/Host/posix/ProcessLauncherPosixFork.cpp

   1 //===-- ProcessLauncherPosixFork.cpp ----------------------------*- C++ -*-===//
   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 "lldb/Host/posix/ProcessLauncherPosixFork.h"
  10 #include "lldb/Host/Host.h"
  11 #include "lldb/Host/HostProcess.h"
  12 #include "lldb/Host/Pipe.h"
  13 #include "lldb/Host/ProcessLaunchInfo.h"
  14 #include "lldb/Utility/FileSpec.h"
  15 #include "lldb/Utility/Log.h"
  16 #include "llvm/Support/Errno.h"
  17
  18 #include <limits.h>
  19 #include <sys/ptrace.h>
  20 #include <sys/wait.h>
  21 #include <unistd.h>
  22
  23 #include <sstream>
  24 #include <csignal>
  25
  26 #ifdef __ANDROID__
  27 #include <android/api-level.h>
  28 #define PT_TRACE_ME PTRACE_TRACEME
  29 #endif
  30
  31 #if defined(__ANDROID_API__) && __ANDROID_API__ < 15
  32 #include <linux/personality.h>
  33 #elif defined(__linux__)
  34 #include <sys/personality.h>
  35 #endif
  36
  37 using namespace lldb;
  38 using namespace lldb_private;
  39
  40 static void FixupEnvironment(Environment &env) {
  41 #ifdef __ANDROID__
  42   // If there is no PATH variable specified inside the environment then set the
  43   // path to /system/bin. It is required because the default path used by
  44   // execve() is wrong on android.
  45   env.try_emplace("PATH", "/system/bin");
  46 #endif
  47 }
  48
  49 static void LLVM_ATTRIBUTE_NORETURN ExitWithError(int error_fd,
  50                                                   const char *operation) {
  51   int err = errno;
  52   llvm::raw_fd_ostream os(error_fd, true);
  53   os << operation << " failed: " << llvm::sys::StrError(err);
  54   os.flush();
  55   _exit(1);
  56 }
  57
  58 static void DisableASLRIfRequested(int error_fd, const ProcessLaunchInfo &info) {
  59 #if defined(__linux__)
  60   if (info.GetFlags().Test(lldb::eLaunchFlagDisableASLR)) {
  61     const unsigned long personality_get_current = 0xffffffff;
  62     int value = personality(personality_get_current);
  63     if (value == -1)
  64       ExitWithError(error_fd, "personality get");
  65
  66     value = personality(ADDR_NO_RANDOMIZE | value);
  67     if (value == -1)
  68       ExitWithError(error_fd, "personality set");
  69   }
  70 #endif
  71 }
  72
  73 static void DupDescriptor(int error_fd, const FileSpec &file_spec, int fd,
  74                           int flags) {
  75   int target_fd = llvm::sys::RetryAfterSignal(-1, ::open,
  76       file_spec.GetCString(), flags, 0666);
  77
  78   if (target_fd == -1)
  79     ExitWithError(error_fd, "DupDescriptor-open");
  80
  81   if (target_fd == fd)
  82     return;
  83
  84   if (::dup2(target_fd, fd) == -1)
  85     ExitWithError(error_fd, "DupDescriptor-dup2");
  86
  87   ::close(target_fd);
  88   return;
  89 }
  90
  91 static void LLVM_ATTRIBUTE_NORETURN ChildFunc(int error_fd,
  92                                               const ProcessLaunchInfo &info) {
  93   if (info.GetFlags().Test(eLaunchFlagLaunchInSeparateProcessGroup)) {
  94     if (setpgid(0, 0) != 0)
  95       ExitWithError(error_fd, "setpgid");
  96   }
  97
  98   for (size_t i = 0; i < info.GetNumFileActions(); ++i) {
  99     const FileAction &action = *info.GetFileActionAtIndex(i);
 100     switch (action.GetAction()) {
 101     case FileAction::eFileActionClose:
 102       if (close(action.GetFD()) != 0)
 103         ExitWithError(error_fd, "close");
 104       break;
 105     case FileAction::eFileActionDuplicate:
 106       if (dup2(action.GetFD(), action.GetActionArgument()) == -1)
 107         ExitWithError(error_fd, "dup2");
 108       break;
 109     case FileAction::eFileActionOpen:
 110       DupDescriptor(error_fd, action.GetFileSpec(), action.GetFD(),
 111                     action.GetActionArgument());
 112       break;
 113     case FileAction::eFileActionNone:
 114       break;
 115     }
 116   }
 117
 118   const char **argv = info.GetArguments().GetConstArgumentVector();
 119
 120   // Change working directory
 121   if (info.GetWorkingDirectory() &&
 122       0 != ::chdir(info.GetWorkingDirectory().GetCString()))
 123     ExitWithError(error_fd, "chdir");
 124
 125   DisableASLRIfRequested(error_fd, info);
 126   Environment env = info.GetEnvironment();
 127   FixupEnvironment(env);
 128   Environment::Envp envp = env.getEnvp();
 129
 130   // Clear the signal mask to prevent the child from being affected by any
 131   // masking done by the parent.
 132   sigset_t set;
 133   if (sigemptyset(&set) != 0 ||
 134       pthread_sigmask(SIG_SETMASK, &set, nullptr) != 0)
 135     ExitWithError(error_fd, "pthread_sigmask");
 136
 137   if (info.GetFlags().Test(eLaunchFlagDebug)) {
 138     // Do not inherit setgid powers.
 139     if (setgid(getgid()) != 0)
 140       ExitWithError(error_fd, "setgid");
 141
 142     // HACK:
 143     // Close everything besides stdin, stdout, and stderr that has no file
 144     // action to avoid leaking. Only do this when debugging, as elsewhere we
 145     // actually rely on passing open descriptors to child processes.
 146     for (int fd = 3; fd < sysconf(_SC_OPEN_MAX); ++fd)
 147       if (!info.GetFileActionForFD(fd) && fd != error_fd)
 148         close(fd);
 149
 150     // Start tracing this child that is about to exec.
 151     if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1)
 152       ExitWithError(error_fd, "ptrace");
 153   }
 154
 155   // Execute.  We should never return...
 156   execve(argv[0], const_cast<char *const *>(argv), envp);
 157
 158 #if defined(__linux__)
 159   if (errno == ETXTBSY) {
 160     // On android M and earlier we can get this error because the adb daemon
 161     // can hold a write handle on the executable even after it has finished
 162     // uploading it. This state lasts only a short time and happens only when
 163     // there are many concurrent adb commands being issued, such as when
 164     // running the test suite. (The file remains open when someone does an "adb
 165     // shell" command in the fork() child before it has had a chance to exec.)
 166     // Since this state should clear up quickly, wait a while and then give it
 167     // one more go.
 168     usleep(50000);
 169     execve(argv[0], const_cast<char *const *>(argv), envp);
 170   }
 171 #endif
 172
 173   // ...unless exec fails.  In which case we definitely need to end the child
 174   // here.
 175   ExitWithError(error_fd, "execve");
 176 }
 177
 178 HostProcess
 179 ProcessLauncherPosixFork::LaunchProcess(const ProcessLaunchInfo &launch_info,
 180                                         Status &error) {
 181   char exe_path[PATH_MAX];
 182   launch_info.GetExecutableFile().GetPath(exe_path, sizeof(exe_path));
 183
 184   // A pipe used by the child process to report errors.
 185   PipePosix pipe;
 186   const bool child_processes_inherit = false;
 187   error = pipe.CreateNew(child_processes_inherit);
 188   if (error.Fail())
 189     return HostProcess();
 190
 191   ::pid_t pid = ::fork();
 192   if (pid == -1) {
 193     // Fork failed
 194     error.SetErrorStringWithFormatv("Fork failed with error message: {0}",
 195                                     llvm::sys::StrError());
 196     return HostProcess(LLDB_INVALID_PROCESS_ID);
 197   }
 198   if (pid == 0) {
 199     // child process
 200     pipe.CloseReadFileDescriptor();
 201     ChildFunc(pipe.ReleaseWriteFileDescriptor(), launch_info);
 202   }
 203
 204   // parent process
 205
 206   pipe.CloseWriteFileDescriptor();
 207   char buf[1000];
 208   int r = read(pipe.GetReadFileDescriptor(), buf, sizeof buf);
 209
 210   if (r == 0)
 211     return HostProcess(pid); // No error. We're done.
 212
 213   error.SetErrorString(buf);
 214
 215   llvm::sys::RetryAfterSignal(-1, waitpid, pid, nullptr, 0);
 216
 217   return HostProcess();
 218 }