llvm/lib/Support/Unix/Program.inc

   1 //===- llvm/Support/Unix/Program.inc ----------------------------*- 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 // This file implements the Unix specific portion of the Program class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 //===----------------------------------------------------------------------===//
  14 //=== WARNING: Implementation here must contain only generic UNIX
  15 //===          code that is guaranteed to work on *all* UNIX variants.
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "llvm/Support/Program.h"
  19
  20 #include "Unix.h"
  21 #include "llvm/ADT/StringExtras.h"
  22 #include "llvm/Config/config.h"
  23 #include "llvm/Support/AutoConvert.h"
  24 #include "llvm/Support/Compiler.h"
  25 #include "llvm/Support/Errc.h"
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/Path.h"
  28 #include "llvm/Support/StringSaver.h"
  29 #include "llvm/Support/SystemZ/zOSSupport.h"
  30 #include "llvm/Support/raw_ostream.h"
  31 #if HAVE_SYS_STAT_H
  32 #include <sys/stat.h>
  33 #endif
  34 #if HAVE_SYS_RESOURCE_H
  35 #include <sys/resource.h>
  36 #endif
  37 #if HAVE_SIGNAL_H
  38 #include <signal.h>
  39 #endif
  40 #if HAVE_FCNTL_H
  41 #include <fcntl.h>
  42 #endif
  43 #if HAVE_UNISTD_H
  44 #include <unistd.h>
  45 #endif
  46 #ifdef HAVE_POSIX_SPAWN
  47 #include <spawn.h>
  48
  49 #if defined(__APPLE__)
  50 #include <TargetConditionals.h>
  51 #endif
  52
  53 #if defined(__APPLE__) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
  54 #define USE_NSGETENVIRON 1
  55 #else
  56 #define USE_NSGETENVIRON 0
  57 #endif
  58
  59 #if !USE_NSGETENVIRON
  60 extern char **environ;
  61 #else
  62 #include <crt_externs.h> // _NSGetEnviron
  63 #endif
  64 #endif
  65
  66 using namespace llvm;
  67 using namespace sys;
  68
  69 ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {}
  70
  71 ErrorOr<std::string> sys::findProgramByName(StringRef Name,
  72                                             ArrayRef<StringRef> Paths) {
  73   assert(!Name.empty() && "Must have a name!");
  74   // Use the given path verbatim if it contains any slashes; this matches
  75   // the behavior of sh(1) and friends.
  76   if (Name.contains('/'))
  77     return std::string(Name);
  78
  79   SmallVector<StringRef, 16> EnvironmentPaths;
  80   if (Paths.empty())
  81     if (const char *PathEnv = std::getenv("PATH")) {
  82       SplitString(PathEnv, EnvironmentPaths, ":");
  83       Paths = EnvironmentPaths;
  84     }
  85
  86   for (auto Path : Paths) {
  87     if (Path.empty())
  88       continue;
  89
  90     // Check to see if this first directory contains the executable...
  91     SmallString<128> FilePath(Path);
  92     sys::path::append(FilePath, Name);
  93     if (sys::fs::can_execute(FilePath.c_str()))
  94       return std::string(FilePath); // Found the executable!
  95   }
  96   return errc::no_such_file_or_directory;
  97 }
  98
  99 static bool RedirectIO(std::optional<StringRef> Path, int FD, std::string *ErrMsg) {
 100   if (!Path) // Noop
 101     return false;
 102   std::string File;
 103   if (Path->empty())
 104     // Redirect empty paths to /dev/null
 105     File = "/dev/null";
 106   else
 107     File = std::string(*Path);
 108
 109   // Open the file
 110   int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666);
 111   if (InFD == -1) {
 112     MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for " +
 113                            (FD == 0 ? "input" : "output"));
 114     return true;
 115   }
 116
 117   // Install it as the requested FD
 118   if (dup2(InFD, FD) == -1) {
 119     MakeErrMsg(ErrMsg, "Cannot dup2");
 120     close(InFD);
 121     return true;
 122   }
 123   close(InFD); // Close the original FD
 124   return false;
 125 }
 126
 127 #ifdef HAVE_POSIX_SPAWN
 128 static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg,
 129                           posix_spawn_file_actions_t *FileActions) {
 130   if (!Path) // Noop
 131     return false;
 132   const char *File;
 133   if (Path->empty())
 134     // Redirect empty paths to /dev/null
 135     File = "/dev/null";
 136   else
 137     File = Path->c_str();
 138
 139   if (int Err = posix_spawn_file_actions_addopen(
 140           FileActions, FD, File, FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
 141     return MakeErrMsg(ErrMsg, "Cannot posix_spawn_file_actions_addopen", Err);
 142   return false;
 143 }
 144 #endif
 145
 146 static void TimeOutHandler(int Sig) {}
 147
 148 static void SetMemoryLimits(unsigned size) {
 149 #if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT
 150   struct rlimit r;
 151   __typeof__(r.rlim_cur) limit = (__typeof__(r.rlim_cur))(size)*1048576;
 152
 153   // Heap size
 154   getrlimit(RLIMIT_DATA, &r);
 155   r.rlim_cur = limit;
 156   setrlimit(RLIMIT_DATA, &r);
 157 #ifdef RLIMIT_RSS
 158   // Resident set size.
 159   getrlimit(RLIMIT_RSS, &r);
 160   r.rlim_cur = limit;
 161   setrlimit(RLIMIT_RSS, &r);
 162 #endif
 163 #endif
 164 }
 165
 166 static std::vector<const char *>
 167 toNullTerminatedCStringArray(ArrayRef<StringRef> Strings, StringSaver &Saver) {
 168   std::vector<const char *> Result;
 169   for (StringRef S : Strings)
 170     Result.push_back(Saver.save(S).data());
 171   Result.push_back(nullptr);
 172   return Result;
 173 }
 174
 175 static bool Execute(ProcessInfo &PI, StringRef Program,
 176                     ArrayRef<StringRef> Args,
 177                     std::optional<ArrayRef<StringRef>> Env,
 178                     ArrayRef<std::optional<StringRef>> Redirects,
 179                     unsigned MemoryLimit, std::string *ErrMsg,
 180                     BitVector *AffinityMask, bool DetachProcess) {
 181   if (!llvm::sys::fs::exists(Program)) {
 182     if (ErrMsg)
 183       *ErrMsg = std::string("Executable \"") + Program.str() +
 184                 std::string("\" doesn't exist!");
 185     return false;
 186   }
 187
 188   assert(!AffinityMask && "Starting a process with an affinity mask is "
 189                           "currently not supported on Unix!");
 190
 191   BumpPtrAllocator Allocator;
 192   StringSaver Saver(Allocator);
 193   std::vector<const char *> ArgVector, EnvVector;
 194   const char **Argv = nullptr;
 195   const char **Envp = nullptr;
 196   ArgVector = toNullTerminatedCStringArray(Args, Saver);
 197   Argv = ArgVector.data();
 198   if (Env) {
 199     EnvVector = toNullTerminatedCStringArray(*Env, Saver);
 200     Envp = EnvVector.data();
 201   }
 202
 203   // If this OS has posix_spawn and there is no memory limit being implied, use
 204   // posix_spawn.  It is more efficient than fork/exec.
 205 #ifdef HAVE_POSIX_SPAWN
 206   // Cannot use posix_spawn if you would like to detach the process
 207   if (MemoryLimit == 0 && !DetachProcess) {
 208     posix_spawn_file_actions_t FileActionsStore;
 209     posix_spawn_file_actions_t *FileActions = nullptr;
 210
 211     // If we call posix_spawn_file_actions_addopen we have to make sure the
 212     // c strings we pass to it stay alive until the call to posix_spawn,
 213     // so we copy any StringRefs into this variable.
 214     std::string RedirectsStorage[3];
 215
 216     if (!Redirects.empty()) {
 217       assert(Redirects.size() == 3);
 218       std::string *RedirectsStr[3] = {nullptr, nullptr, nullptr};
 219       for (int I = 0; I < 3; ++I) {
 220         if (Redirects[I]) {
 221           RedirectsStorage[I] = std::string(*Redirects[I]);
 222           RedirectsStr[I] = &RedirectsStorage[I];
 223         }
 224       }
 225
 226       FileActions = &FileActionsStore;
 227       posix_spawn_file_actions_init(FileActions);
 228
 229       // Redirect stdin/stdout.
 230       if (RedirectIO_PS(RedirectsStr[0], 0, ErrMsg, FileActions) ||
 231           RedirectIO_PS(RedirectsStr[1], 1, ErrMsg, FileActions))
 232         return false;
 233       if (!Redirects[1] || !Redirects[2] || *Redirects[1] != *Redirects[2]) {
 234         // Just redirect stderr
 235         if (RedirectIO_PS(RedirectsStr[2], 2, ErrMsg, FileActions))
 236           return false;
 237       } else {
 238         // If stdout and stderr should go to the same place, redirect stderr
 239         // to the FD already open for stdout.
 240         if (int Err = posix_spawn_file_actions_adddup2(FileActions, 1, 2))
 241           return !MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout", Err);
 242       }
 243     }
 244
 245     if (!Envp)
 246 #if !USE_NSGETENVIRON
 247       Envp = const_cast<const char **>(environ);
 248 #else
 249       // environ is missing in dylibs.
 250       Envp = const_cast<const char **>(*_NSGetEnviron());
 251 #endif
 252
 253     constexpr int maxRetries = 8;
 254     int retries = 0;
 255     pid_t PID;
 256     int Err;
 257     do {
 258       PID = 0; // Make Valgrind happy.
 259       Err = posix_spawn(&PID, Program.str().c_str(), FileActions,
 260                         /*attrp*/ nullptr, const_cast<char **>(Argv),
 261                         const_cast<char **>(Envp));
 262     } while (Err == EINTR && ++retries < maxRetries);
 263
 264     if (FileActions)
 265       posix_spawn_file_actions_destroy(FileActions);
 266
 267     if (Err)
 268       return !MakeErrMsg(ErrMsg, "posix_spawn failed", Err);
 269
 270     PI.Pid = PID;
 271     PI.Process = PID;
 272
 273     return true;
 274   }
 275 #endif // HAVE_POSIX_SPAWN
 276
 277   // Create a child process.
 278   int child = fork();
 279   switch (child) {
 280   // An error occurred:  Return to the caller.
 281   case -1:
 282     MakeErrMsg(ErrMsg, "Couldn't fork");
 283     return false;
 284
 285   // Child process: Execute the program.
 286   case 0: {
 287     // Redirect file descriptors...
 288     if (!Redirects.empty()) {
 289       // Redirect stdin
 290       if (RedirectIO(Redirects[0], 0, ErrMsg)) {
 291         return false;
 292       }
 293       // Redirect stdout
 294       if (RedirectIO(Redirects[1], 1, ErrMsg)) {
 295         return false;
 296       }
 297       if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) {
 298         // If stdout and stderr should go to the same place, redirect stderr
 299         // to the FD already open for stdout.
 300         if (-1 == dup2(1, 2)) {
 301           MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
 302           return false;
 303         }
 304       } else {
 305         // Just redirect stderr
 306         if (RedirectIO(Redirects[2], 2, ErrMsg)) {
 307           return false;
 308         }
 309       }
 310     }
 311
 312     if (DetachProcess) {
 313       // Detach from controlling terminal
 314       if (::setsid() == -1) {
 315         MakeErrMsg(ErrMsg, "Could not detach process, ::setsid failed");
 316         return false;
 317       }
 318     }
 319
 320     // Set memory limits
 321     if (MemoryLimit != 0) {
 322       SetMemoryLimits(MemoryLimit);
 323     }
 324
 325     // Execute!
 326     std::string PathStr = std::string(Program);
 327     if (Envp != nullptr)
 328       execve(PathStr.c_str(), const_cast<char **>(Argv),
 329              const_cast<char **>(Envp));
 330     else
 331       execv(PathStr.c_str(), const_cast<char **>(Argv));
 332     // If the execve() failed, we should exit. Follow Unix protocol and
 333     // return 127 if the executable was not found, and 126 otherwise.
 334     // Use _exit rather than exit so that atexit functions and static
 335     // object destructors cloned from the parent process aren't
 336     // redundantly run, and so that any data buffered in stdio buffers
 337     // cloned from the parent aren't redundantly written out.
 338     _exit(errno == ENOENT ? 127 : 126);
 339   }
 340
 341   // Parent process: Break out of the switch to do our processing.
 342   default:
 343     break;
 344   }
 345
 346   PI.Pid = child;
 347   PI.Process = child;
 348
 349   return true;
 350 }
 351
 352 namespace llvm {
 353 namespace sys {
 354
 355 #if defined(_AIX)
 356 static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage);
 357 #elif !defined(__Fuchsia__)
 358 using ::wait4;
 359 #endif
 360
 361 } // namespace sys
 362 } // namespace llvm
 363
 364 #ifdef _AIX
 365 #ifndef _ALL_SOURCE
 366 extern "C" pid_t(wait4)(pid_t pid, int *status, int options,
 367                         struct rusage *usage);
 368 #endif
 369 pid_t(llvm::sys::wait4)(pid_t pid, int *status, int options,
 370                         struct rusage *usage) {
 371   assert(pid > 0 && "Only expecting to handle actual PID values!");
 372   assert((options & ~WNOHANG) == 0 && "Expecting WNOHANG at most!");
 373   assert(usage && "Expecting usage collection!");
 374
 375   // AIX wait4 does not work well with WNOHANG.
 376   if (!(options & WNOHANG))
 377     return ::wait4(pid, status, options, usage);
 378
 379   // For WNOHANG, we use waitid (which supports WNOWAIT) until the child process
 380   // has terminated.
 381   siginfo_t WaitIdInfo;
 382   WaitIdInfo.si_pid = 0;
 383   int WaitIdRetVal =
 384       waitid(P_PID, pid, &WaitIdInfo, WNOWAIT | WEXITED | options);
 385
 386   if (WaitIdRetVal == -1 || WaitIdInfo.si_pid == 0)
 387     return WaitIdRetVal;
 388
 389   assert(WaitIdInfo.si_pid == pid);
 390
 391   // The child has already terminated, so a blocking wait on it is okay in the
 392   // absence of indiscriminate `wait` calls from the current process (which
 393   // would cause the call here to fail with ECHILD).
 394   return ::wait4(pid, status, options & ~WNOHANG, usage);
 395 }
 396 #endif
 397
 398 ProcessInfo llvm::sys::Wait(const ProcessInfo &PI,
 399                             std::optional<unsigned> SecondsToWait,
 400                             std::string *ErrMsg,
 401                             std::optional<ProcessStatistics> *ProcStat,
 402                             bool Polling) {
 403   struct sigaction Act, Old;
 404   assert(PI.Pid && "invalid pid to wait on, process not started?");
 405
 406   int WaitPidOptions = 0;
 407   pid_t ChildPid = PI.Pid;
 408   bool WaitUntilTerminates = false;
 409   if (!SecondsToWait) {
 410     WaitUntilTerminates = true;
 411   } else {
 412     if (*SecondsToWait == 0)
 413       WaitPidOptions = WNOHANG;
 414
 415     // Install a timeout handler.  The handler itself does nothing, but the
 416     // simple fact of having a handler at all causes the wait below to return
 417     // with EINTR, unlike if we used SIG_IGN.
 418     memset(&Act, 0, sizeof(Act));
 419     Act.sa_handler = TimeOutHandler;
 420     sigemptyset(&Act.sa_mask);
 421     sigaction(SIGALRM, &Act, &Old);
 422     // FIXME The alarm signal may be delivered to another thread.
 423     alarm(*SecondsToWait);
 424   }
 425
 426   // Parent process: Wait for the child process to terminate.
 427   int status = 0;
 428   ProcessInfo WaitResult;
 429 #ifndef __Fuchsia__
 430   rusage Info;
 431   if (ProcStat)
 432     ProcStat->reset();
 433
 434   do {
 435     WaitResult.Pid = sys::wait4(ChildPid, &status, WaitPidOptions, &Info);
 436   } while (WaitUntilTerminates && WaitResult.Pid == -1 && errno == EINTR);
 437 #endif
 438
 439   if (WaitResult.Pid != PI.Pid) {
 440     if (WaitResult.Pid == 0) {
 441       // Non-blocking wait.
 442       return WaitResult;
 443     } else {
 444       if (SecondsToWait && errno == EINTR && !Polling) {
 445         // Kill the child.
 446         kill(PI.Pid, SIGKILL);
 447
 448         // Turn off the alarm and restore the signal handler
 449         alarm(0);
 450         sigaction(SIGALRM, &Old, nullptr);
 451
 452         // Wait for child to die
 453         // FIXME This could grab some other child process out from another
 454         // waiting thread and then leave a zombie anyway.
 455         if (wait(&status) != ChildPid)
 456           MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
 457         else
 458           MakeErrMsg(ErrMsg, "Child timed out", 0);
 459
 460         WaitResult.ReturnCode = -2; // Timeout detected
 461         return WaitResult;
 462       } else if (errno != EINTR) {
 463         MakeErrMsg(ErrMsg, "Error waiting for child process");
 464         WaitResult.ReturnCode = -1;
 465         return WaitResult;
 466       }
 467     }
 468   }
 469
 470   // We exited normally without timeout, so turn off the timer.
 471   if (SecondsToWait && !WaitUntilTerminates) {
 472     alarm(0);
 473     sigaction(SIGALRM, &Old, nullptr);
 474   }
 475
 476 #ifndef __Fuchsia__
 477   if (ProcStat) {
 478     std::chrono::microseconds UserT = toDuration(Info.ru_utime);
 479     std::chrono::microseconds KernelT = toDuration(Info.ru_stime);
 480     uint64_t PeakMemory = 0;
 481 #if !defined(__HAIKU__) && !defined(__MVS__)
 482     PeakMemory = static_cast<uint64_t>(Info.ru_maxrss);
 483 #endif
 484     *ProcStat = ProcessStatistics{UserT + KernelT, UserT, PeakMemory};
 485   }
 486 #endif
 487
 488   // Return the proper exit status. Detect error conditions
 489   // so we can return -1 for them and set ErrMsg informatively.
 490   int result = 0;
 491   if (WIFEXITED(status)) {
 492     result = WEXITSTATUS(status);
 493     WaitResult.ReturnCode = result;
 494
 495     if (result == 127) {
 496       if (ErrMsg)
 497         *ErrMsg = llvm::sys::StrError(ENOENT);
 498       WaitResult.ReturnCode = -1;
 499       return WaitResult;
 500     }
 501     if (result == 126) {
 502       if (ErrMsg)
 503         *ErrMsg = "Program could not be executed";
 504       WaitResult.ReturnCode = -1;
 505       return WaitResult;
 506     }
 507   } else if (WIFSIGNALED(status)) {
 508     if (ErrMsg) {
 509       *ErrMsg = strsignal(WTERMSIG(status));
 510 #ifdef WCOREDUMP
 511       if (WCOREDUMP(status))
 512         *ErrMsg += " (core dumped)";
 513 #endif
 514     }
 515     // Return a special value to indicate that the process received an unhandled
 516     // signal during execution as opposed to failing to execute.
 517     WaitResult.ReturnCode = -2;
 518   }
 519   return WaitResult;
 520 }
 521
 522 std::error_code llvm::sys::ChangeStdinMode(fs::OpenFlags Flags) {
 523   if (!(Flags & fs::OF_Text))
 524     return ChangeStdinToBinary();
 525   return std::error_code();
 526 }
 527
 528 std::error_code llvm::sys::ChangeStdoutMode(fs::OpenFlags Flags) {
 529   if (!(Flags & fs::OF_Text))
 530     return ChangeStdoutToBinary();
 531   return std::error_code();
 532 }
 533
 534 std::error_code llvm::sys::ChangeStdinToBinary() {
 535 #ifdef __MVS__
 536   return disablezOSAutoConversion(STDIN_FILENO);
 537 #else
 538   // Do nothing, as Unix doesn't differentiate between text and binary.
 539   return std::error_code();
 540 #endif
 541 }
 542
 543 std::error_code llvm::sys::ChangeStdoutToBinary() {
 544   // Do nothing, as Unix doesn't differentiate between text and binary.
 545   return std::error_code();
 546 }
 547
 548 std::error_code
 549 llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
 550                                  WindowsEncodingMethod Encoding /*unused*/) {
 551   std::error_code EC;
 552   llvm::raw_fd_ostream OS(FileName, EC,
 553                           llvm::sys::fs::OpenFlags::OF_TextWithCRLF);
 554
 555   if (EC)
 556     return EC;
 557
 558   OS << Contents;
 559
 560   if (OS.has_error())
 561     return make_error_code(errc::io_error);
 562
 563   return EC;
 564 }
 565
 566 bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program,
 567                                                   ArrayRef<StringRef> Args) {
 568   static long ArgMax = sysconf(_SC_ARG_MAX);
 569   // POSIX requires that _POSIX_ARG_MAX is 4096, which is the lowest possible
 570   // value for ARG_MAX on a POSIX compliant system.
 571   static long ArgMin = _POSIX_ARG_MAX;
 572
 573   // This the same baseline used by xargs.
 574   long EffectiveArgMax = 128 * 1024;
 575
 576   if (EffectiveArgMax > ArgMax)
 577     EffectiveArgMax = ArgMax;
 578   else if (EffectiveArgMax < ArgMin)
 579     EffectiveArgMax = ArgMin;
 580
 581   // System says no practical limit.
 582   if (ArgMax == -1)
 583     return true;
 584
 585   // Conservatively account for space required by environment variables.
 586   long HalfArgMax = EffectiveArgMax / 2;
 587
 588   size_t ArgLength = Program.size() + 1;
 589   for (StringRef Arg : Args) {
 590     // Ensure that we do not exceed the MAX_ARG_STRLEN constant on Linux, which
 591     // does not have a constant unlike what the man pages would have you
 592     // believe. Since this limit is pretty high, perform the check
 593     // unconditionally rather than trying to be aggressive and limiting it to
 594     // Linux only.
 595     if (Arg.size() >= (32 * 4096))
 596       return false;
 597
 598     ArgLength += Arg.size() + 1;
 599     if (ArgLength > size_t(HalfArgMax)) {
 600       return false;
 601     }
 602   }
 603
 604   return true;
 605 }