• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1//===- llvm/Support/Unix/Program.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// This file implements the Unix specific portion of the Program class.
11//
12//===----------------------------------------------------------------------===//
13
14//===----------------------------------------------------------------------===//
15//=== WARNING: Implementation here must contain only generic UNIX code that
16//===          is guaranteed to work on *all* UNIX variants.
17//===----------------------------------------------------------------------===//
18
19#include "Unix.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/Config/config.h"
22#include "llvm/Support/Compiler.h"
23#include "llvm/Support/FileSystem.h"
24#include "llvm/Support/Path.h"
25#include "llvm/Support/raw_ostream.h"
26#if HAVE_SYS_STAT_H
27#include <sys/stat.h>
28#endif
29#if HAVE_SYS_RESOURCE_H
30#include <sys/resource.h>
31#endif
32#if HAVE_SIGNAL_H
33#include <signal.h>
34#endif
35#if HAVE_FCNTL_H
36#include <fcntl.h>
37#endif
38#if HAVE_UNISTD_H
39#include <unistd.h>
40#endif
41#ifdef HAVE_POSIX_SPAWN
42#ifdef __sun__
43#define  _RESTRICT_KYWD
44#endif
45#include <spawn.h>
46
47#if defined(__APPLE__)
48#include <TargetConditionals.h>
49#endif
50
51#if defined(__APPLE__) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
52#define USE_NSGETENVIRON 1
53#else
54#define USE_NSGETENVIRON 0
55#endif
56
57#if !USE_NSGETENVIRON
58  extern char **environ;
59#else
60#include <crt_externs.h> // _NSGetEnviron
61#endif
62#endif
63
64namespace llvm {
65
66using namespace sys;
67
68ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {}
69
70ErrorOr<std::string> sys::findProgramByName(StringRef Name,
71                                            ArrayRef<StringRef> Paths) {
72  assert(!Name.empty() && "Must have a name!");
73  // Use the given path verbatim if it contains any slashes; this matches
74  // the behavior of sh(1) and friends.
75  if (Name.find('/') != StringRef::npos)
76    return std::string(Name);
77
78  SmallVector<StringRef, 16> EnvironmentPaths;
79  if (Paths.empty())
80    if (const char *PathEnv = std::getenv("PATH")) {
81      SplitString(PathEnv, EnvironmentPaths, ":");
82      Paths = EnvironmentPaths;
83    }
84
85  for (auto Path : Paths) {
86    if (Path.empty())
87      continue;
88
89    // Check to see if this first directory contains the executable...
90    SmallString<128> FilePath(Path);
91    sys::path::append(FilePath, Name);
92    if (sys::fs::can_execute(FilePath.c_str()))
93      return std::string(FilePath.str()); // Found the executable!
94  }
95  return std::errc::no_such_file_or_directory;
96}
97
98static bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) {
99  if (!Path) // Noop
100    return false;
101  std::string File;
102  if (Path->empty())
103    // Redirect empty paths to /dev/null
104    File = "/dev/null";
105  else
106    File = *Path;
107
108  // Open the file
109  int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
110  if (InFD == -1) {
111    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
112              + (FD == 0 ? "input" : "output"));
113    return true;
114  }
115
116  // Install it as the requested FD
117  if (dup2(InFD, FD) == -1) {
118    MakeErrMsg(ErrMsg, "Cannot dup2");
119    close(InFD);
120    return true;
121  }
122  close(InFD);      // Close the original FD
123  return false;
124}
125
126#ifdef HAVE_POSIX_SPAWN
127static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg,
128                          posix_spawn_file_actions_t *FileActions) {
129  if (!Path) // Noop
130    return false;
131  const char *File;
132  if (Path->empty())
133    // Redirect empty paths to /dev/null
134    File = "/dev/null";
135  else
136    File = Path->c_str();
137
138  if (int Err = posix_spawn_file_actions_addopen(
139          FileActions, FD, File,
140          FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
141    return MakeErrMsg(ErrMsg, "Cannot dup2", Err);
142  return false;
143}
144#endif
145
146static void TimeOutHandler(int Sig) {
147}
148
149static void SetMemoryLimits (unsigned size)
150{
151#if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT
152  struct rlimit r;
153  __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576;
154
155  // Heap size
156  getrlimit (RLIMIT_DATA, &r);
157  r.rlim_cur = limit;
158  setrlimit (RLIMIT_DATA, &r);
159#ifdef RLIMIT_RSS
160  // Resident set size.
161  getrlimit (RLIMIT_RSS, &r);
162  r.rlim_cur = limit;
163  setrlimit (RLIMIT_RSS, &r);
164#endif
165#ifdef RLIMIT_AS  // e.g. NetBSD doesn't have it.
166  // Don't set virtual memory limit if built with any Sanitizer. They need 80Tb
167  // of virtual memory for shadow memory mapping.
168#if !LLVM_MEMORY_SANITIZER_BUILD && !LLVM_ADDRESS_SANITIZER_BUILD
169  // Virtual memory.
170  getrlimit (RLIMIT_AS, &r);
171  r.rlim_cur = limit;
172  setrlimit (RLIMIT_AS, &r);
173#endif
174#endif
175#endif
176}
177
178}
179
180static bool Execute(ProcessInfo &PI, StringRef Program, const char **args,
181                    const char **envp, const StringRef **redirects,
182                    unsigned memoryLimit, std::string *ErrMsg) {
183  if (!llvm::sys::fs::exists(Program)) {
184    if (ErrMsg)
185      *ErrMsg = std::string("Executable \"") + Program.str() +
186                std::string("\" doesn't exist!");
187    return false;
188  }
189
190  // If this OS has posix_spawn and there is no memory limit being implied, use
191  // posix_spawn.  It is more efficient than fork/exec.
192#ifdef HAVE_POSIX_SPAWN
193  if (memoryLimit == 0) {
194    posix_spawn_file_actions_t FileActionsStore;
195    posix_spawn_file_actions_t *FileActions = nullptr;
196
197    // If we call posix_spawn_file_actions_addopen we have to make sure the
198    // c strings we pass to it stay alive until the call to posix_spawn,
199    // so we copy any StringRefs into this variable.
200    std::string RedirectsStorage[3];
201
202    if (redirects) {
203      std::string *RedirectsStr[3] = {nullptr, nullptr, nullptr};
204      for (int I = 0; I < 3; ++I) {
205        if (redirects[I]) {
206          RedirectsStorage[I] = *redirects[I];
207          RedirectsStr[I] = &RedirectsStorage[I];
208        }
209      }
210
211      FileActions = &FileActionsStore;
212      posix_spawn_file_actions_init(FileActions);
213
214      // Redirect stdin/stdout.
215      if (RedirectIO_PS(RedirectsStr[0], 0, ErrMsg, FileActions) ||
216          RedirectIO_PS(RedirectsStr[1], 1, ErrMsg, FileActions))
217        return false;
218      if (redirects[1] == nullptr || redirects[2] == nullptr ||
219          *redirects[1] != *redirects[2]) {
220        // Just redirect stderr
221        if (RedirectIO_PS(RedirectsStr[2], 2, ErrMsg, FileActions))
222          return false;
223      } else {
224        // If stdout and stderr should go to the same place, redirect stderr
225        // to the FD already open for stdout.
226        if (int Err = posix_spawn_file_actions_adddup2(FileActions, 1, 2))
227          return !MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout", Err);
228      }
229    }
230
231    if (!envp)
232#if !USE_NSGETENVIRON
233      envp = const_cast<const char **>(environ);
234#else
235      // environ is missing in dylibs.
236      envp = const_cast<const char **>(*_NSGetEnviron());
237#endif
238
239    // Explicitly initialized to prevent what appears to be a valgrind false
240    // positive.
241    pid_t PID = 0;
242    int Err = posix_spawn(&PID, Program.str().c_str(), FileActions,
243                          /*attrp*/nullptr, const_cast<char **>(args),
244                          const_cast<char **>(envp));
245
246    if (FileActions)
247      posix_spawn_file_actions_destroy(FileActions);
248
249    if (Err)
250     return !MakeErrMsg(ErrMsg, "posix_spawn failed", Err);
251
252    PI.Pid = PID;
253
254    return true;
255  }
256#endif
257
258  // Create a child process.
259  int child = fork();
260  switch (child) {
261    // An error occurred:  Return to the caller.
262    case -1:
263      MakeErrMsg(ErrMsg, "Couldn't fork");
264      return false;
265
266    // Child process: Execute the program.
267    case 0: {
268      // Redirect file descriptors...
269      if (redirects) {
270        // Redirect stdin
271        if (RedirectIO(redirects[0], 0, ErrMsg)) { return false; }
272        // Redirect stdout
273        if (RedirectIO(redirects[1], 1, ErrMsg)) { return false; }
274        if (redirects[1] && redirects[2] &&
275            *(redirects[1]) == *(redirects[2])) {
276          // If stdout and stderr should go to the same place, redirect stderr
277          // to the FD already open for stdout.
278          if (-1 == dup2(1,2)) {
279            MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
280            return false;
281          }
282        } else {
283          // Just redirect stderr
284          if (RedirectIO(redirects[2], 2, ErrMsg)) { return false; }
285        }
286      }
287
288      // Set memory limits
289      if (memoryLimit!=0) {
290        SetMemoryLimits(memoryLimit);
291      }
292
293      // Execute!
294      std::string PathStr = Program;
295      if (envp != nullptr)
296        execve(PathStr.c_str(),
297               const_cast<char **>(args),
298               const_cast<char **>(envp));
299      else
300        execv(PathStr.c_str(),
301              const_cast<char **>(args));
302      // If the execve() failed, we should exit. Follow Unix protocol and
303      // return 127 if the executable was not found, and 126 otherwise.
304      // Use _exit rather than exit so that atexit functions and static
305      // object destructors cloned from the parent process aren't
306      // redundantly run, and so that any data buffered in stdio buffers
307      // cloned from the parent aren't redundantly written out.
308      _exit(errno == ENOENT ? 127 : 126);
309    }
310
311    // Parent process: Break out of the switch to do our processing.
312    default:
313      break;
314  }
315
316  PI.Pid = child;
317
318  return true;
319}
320
321namespace llvm {
322
323ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
324                      bool WaitUntilTerminates, std::string *ErrMsg) {
325#ifdef HAVE_SYS_WAIT_H
326  struct sigaction Act, Old;
327  assert(PI.Pid && "invalid pid to wait on, process not started?");
328
329  int WaitPidOptions = 0;
330  pid_t ChildPid = PI.Pid;
331  if (WaitUntilTerminates) {
332    SecondsToWait = 0;
333  } else if (SecondsToWait) {
334    // Install a timeout handler.  The handler itself does nothing, but the
335    // simple fact of having a handler at all causes the wait below to return
336    // with EINTR, unlike if we used SIG_IGN.
337    memset(&Act, 0, sizeof(Act));
338    Act.sa_handler = TimeOutHandler;
339    sigemptyset(&Act.sa_mask);
340    sigaction(SIGALRM, &Act, &Old);
341    alarm(SecondsToWait);
342  } else if (SecondsToWait == 0)
343    WaitPidOptions = WNOHANG;
344
345  // Parent process: Wait for the child process to terminate.
346  int status;
347  ProcessInfo WaitResult;
348
349  do {
350    WaitResult.Pid = waitpid(ChildPid, &status, WaitPidOptions);
351  } while (WaitUntilTerminates && WaitResult.Pid == -1 && errno == EINTR);
352
353  if (WaitResult.Pid != PI.Pid) {
354    if (WaitResult.Pid == 0) {
355      // Non-blocking wait.
356      return WaitResult;
357    } else {
358      if (SecondsToWait && errno == EINTR) {
359        // Kill the child.
360        kill(PI.Pid, SIGKILL);
361
362        // Turn off the alarm and restore the signal handler
363        alarm(0);
364        sigaction(SIGALRM, &Old, nullptr);
365
366        // Wait for child to die
367        if (wait(&status) != ChildPid)
368          MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
369        else
370          MakeErrMsg(ErrMsg, "Child timed out", 0);
371
372        WaitResult.ReturnCode = -2; // Timeout detected
373        return WaitResult;
374      } else if (errno != EINTR) {
375        MakeErrMsg(ErrMsg, "Error waiting for child process");
376        WaitResult.ReturnCode = -1;
377        return WaitResult;
378      }
379    }
380  }
381
382  // We exited normally without timeout, so turn off the timer.
383  if (SecondsToWait && !WaitUntilTerminates) {
384    alarm(0);
385    sigaction(SIGALRM, &Old, nullptr);
386  }
387
388  // Return the proper exit status. Detect error conditions
389  // so we can return -1 for them and set ErrMsg informatively.
390  int result = 0;
391  if (WIFEXITED(status)) {
392    result = WEXITSTATUS(status);
393    WaitResult.ReturnCode = result;
394
395    if (result == 127) {
396      if (ErrMsg)
397        *ErrMsg = llvm::sys::StrError(ENOENT);
398      WaitResult.ReturnCode = -1;
399      return WaitResult;
400    }
401    if (result == 126) {
402      if (ErrMsg)
403        *ErrMsg = "Program could not be executed";
404      WaitResult.ReturnCode = -1;
405      return WaitResult;
406    }
407  } else if (WIFSIGNALED(status)) {
408    if (ErrMsg) {
409      *ErrMsg = strsignal(WTERMSIG(status));
410#ifdef WCOREDUMP
411      if (WCOREDUMP(status))
412        *ErrMsg += " (core dumped)";
413#endif
414    }
415    // Return a special value to indicate that the process received an unhandled
416    // signal during execution as opposed to failing to execute.
417    WaitResult.ReturnCode = -2;
418  }
419#else
420  if (ErrMsg)
421    *ErrMsg = "Program::Wait is not implemented on this platform yet!";
422  ProcessInfo WaitResult;
423  WaitResult.ReturnCode = -2;
424#endif
425  return WaitResult;
426}
427
428  std::error_code sys::ChangeStdinToBinary(){
429  // Do nothing, as Unix doesn't differentiate between text and binary.
430    return std::error_code();
431}
432
433  std::error_code sys::ChangeStdoutToBinary(){
434  // Do nothing, as Unix doesn't differentiate between text and binary.
435    return std::error_code();
436}
437
438std::error_code
439llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
440                                 WindowsEncodingMethod Encoding /*unused*/) {
441  std::error_code EC;
442  llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::F_Text);
443
444  if (EC)
445    return EC;
446
447  OS << Contents;
448
449  if (OS.has_error())
450    return std::make_error_code(std::errc::io_error);
451
452  return EC;
453}
454
455bool llvm::sys::argumentsFitWithinSystemLimits(ArrayRef<const char*> Args) {
456  static long ArgMax = sysconf(_SC_ARG_MAX);
457
458  // System says no practical limit.
459  if (ArgMax == -1)
460    return true;
461
462  // Conservatively account for space required by environment variables.
463  long HalfArgMax = ArgMax / 2;
464
465  size_t ArgLength = 0;
466  for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
467       I != E; ++I) {
468    ArgLength += strlen(*I) + 1;
469    if (ArgLength > size_t(HalfArgMax)) {
470      return false;
471    }
472  }
473  return true;
474}
475}
476