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/Support/Compiler.h"
21#include "llvm/Support/FileSystem.h"
22#include <llvm/Config/config.h>
23#if HAVE_SYS_STAT_H
24#include <sys/stat.h>
25#endif
26#if HAVE_SYS_RESOURCE_H
27#include <sys/resource.h>
28#endif
29#if HAVE_SIGNAL_H
30#include <signal.h>
31#endif
32#if HAVE_FCNTL_H
33#include <fcntl.h>
34#endif
35#if HAVE_UNISTD_H
36#include <unistd.h>
37#endif
38#ifdef HAVE_POSIX_SPAWN
39#include <spawn.h>
40#if !defined(__APPLE__)
41  extern char **environ;
42#else
43#include <crt_externs.h> // _NSGetEnviron
44#endif
45#endif
46
47namespace llvm {
48using namespace sys;
49
50// This function just uses the PATH environment variable to find the program.
51std::string
52sys::FindProgramByName(const std::string& progName) {
53
54  // Check some degenerate cases
55  if (progName.length() == 0) // no program
56    return "";
57  std::string temp = progName;
58  // Use the given path verbatim if it contains any slashes; this matches
59  // the behavior of sh(1) and friends.
60  if (progName.find('/') != std::string::npos)
61    return temp;
62
63  // At this point, the file name is valid and does not contain slashes. Search
64  // for it through the directories specified in the PATH environment variable.
65
66  // Get the path. If its empty, we can't do anything to find it.
67  const char *PathStr = getenv("PATH");
68  if (PathStr == 0)
69    return "";
70
71  // Now we have a colon separated list of directories to search; try them.
72  size_t PathLen = strlen(PathStr);
73  while (PathLen) {
74    // Find the first colon...
75    const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
76
77    // Check to see if this first directory contains the executable...
78    SmallString<128> FilePath(PathStr,Colon);
79    sys::path::append(FilePath, progName);
80    if (sys::fs::can_execute(Twine(FilePath)))
81      return FilePath.str();                    // Found the executable!
82
83    // Nope it wasn't in this directory, check the next path in the list!
84    PathLen -= Colon-PathStr;
85    PathStr = Colon;
86
87    // Advance past duplicate colons
88    while (*PathStr == ':') {
89      PathStr++;
90      PathLen--;
91    }
92  }
93  return "";
94}
95
96static bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) {
97  if (Path == 0) // Noop
98    return false;
99  std::string File;
100  if (Path->empty())
101    // Redirect empty paths to /dev/null
102    File = "/dev/null";
103  else
104    File = *Path;
105
106  // Open the file
107  int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
108  if (InFD == -1) {
109    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
110              + (FD == 0 ? "input" : "output"));
111    return true;
112  }
113
114  // Install it as the requested FD
115  if (dup2(InFD, FD) == -1) {
116    MakeErrMsg(ErrMsg, "Cannot dup2");
117    close(InFD);
118    return true;
119  }
120  close(InFD);      // Close the original FD
121  return false;
122}
123
124#ifdef HAVE_POSIX_SPAWN
125static bool RedirectIO_PS(const StringRef *Path, int FD, std::string *ErrMsg,
126                          posix_spawn_file_actions_t *FileActions) {
127  if (Path == 0) // Noop
128    return false;
129  std::string File;
130  if (Path->empty())
131    // Redirect empty paths to /dev/null
132    File = "/dev/null";
133  else
134    File = *Path;
135
136  if (int Err = posix_spawn_file_actions_addopen(
137          FileActions, FD, File.c_str(),
138          FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
139    return MakeErrMsg(ErrMsg, "Cannot dup2", Err);
140  return false;
141}
142#endif
143
144static void TimeOutHandler(int Sig) {
145}
146
147static void SetMemoryLimits (unsigned size)
148{
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#ifdef RLIMIT_AS  // e.g. NetBSD doesn't have it.
164  // Don't set virtual memory limit if built with any Sanitizer. They need 80Tb
165  // of virtual memory for shadow memory mapping.
166#if !LLVM_MEMORY_SANITIZER_BUILD && !LLVM_ADDRESS_SANITIZER_BUILD
167  // Virtual memory.
168  getrlimit (RLIMIT_AS, &r);
169  r.rlim_cur = limit;
170  setrlimit (RLIMIT_AS, &r);
171#endif
172#endif
173#endif
174}
175
176}
177
178static bool Execute(void **Data, StringRef Program, const char **args,
179                    const char **envp, const StringRef **redirects,
180                    unsigned memoryLimit, std::string *ErrMsg) {
181  // If this OS has posix_spawn and there is no memory limit being implied, use
182  // posix_spawn.  It is more efficient than fork/exec.
183#ifdef HAVE_POSIX_SPAWN
184  if (memoryLimit == 0) {
185    posix_spawn_file_actions_t FileActionsStore;
186    posix_spawn_file_actions_t *FileActions = 0;
187
188    if (redirects) {
189      FileActions = &FileActionsStore;
190      posix_spawn_file_actions_init(FileActions);
191
192      // Redirect stdin/stdout.
193      if (RedirectIO_PS(redirects[0], 0, ErrMsg, FileActions) ||
194          RedirectIO_PS(redirects[1], 1, ErrMsg, FileActions))
195        return false;
196      if (redirects[1] == 0 || redirects[2] == 0 ||
197          *redirects[1] != *redirects[2]) {
198        // Just redirect stderr
199        if (RedirectIO_PS(redirects[2], 2, ErrMsg, FileActions)) return false;
200      } else {
201        // If stdout and stderr should go to the same place, redirect stderr
202        // to the FD already open for stdout.
203        if (int Err = posix_spawn_file_actions_adddup2(FileActions, 1, 2))
204          return !MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout", Err);
205      }
206    }
207
208    if (!envp)
209#if !defined(__APPLE__)
210      envp = const_cast<const char **>(environ);
211#else
212      // environ is missing in dylibs.
213      envp = const_cast<const char **>(*_NSGetEnviron());
214#endif
215
216    // Explicitly initialized to prevent what appears to be a valgrind false
217    // positive.
218    pid_t PID = 0;
219    int Err = posix_spawn(&PID, Program.str().c_str(), FileActions, /*attrp*/0,
220                          const_cast<char **>(args), const_cast<char **>(envp));
221
222    if (FileActions)
223      posix_spawn_file_actions_destroy(FileActions);
224
225    if (Err)
226     return !MakeErrMsg(ErrMsg, "posix_spawn failed", Err);
227
228    if (Data)
229      *Data = reinterpret_cast<void*>(PID);
230    return true;
231  }
232#endif
233
234  // Create a child process.
235  int child = fork();
236  switch (child) {
237    // An error occurred:  Return to the caller.
238    case -1:
239      MakeErrMsg(ErrMsg, "Couldn't fork");
240      return false;
241
242    // Child process: Execute the program.
243    case 0: {
244      // Redirect file descriptors...
245      if (redirects) {
246        // Redirect stdin
247        if (RedirectIO(redirects[0], 0, ErrMsg)) { return false; }
248        // Redirect stdout
249        if (RedirectIO(redirects[1], 1, ErrMsg)) { return false; }
250        if (redirects[1] && redirects[2] &&
251            *(redirects[1]) == *(redirects[2])) {
252          // If stdout and stderr should go to the same place, redirect stderr
253          // to the FD already open for stdout.
254          if (-1 == dup2(1,2)) {
255            MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
256            return false;
257          }
258        } else {
259          // Just redirect stderr
260          if (RedirectIO(redirects[2], 2, ErrMsg)) { return false; }
261        }
262      }
263
264      // Set memory limits
265      if (memoryLimit!=0) {
266        SetMemoryLimits(memoryLimit);
267      }
268
269      // Execute!
270      std::string PathStr = Program;
271      if (envp != 0)
272        execve(PathStr.c_str(),
273               const_cast<char **>(args),
274               const_cast<char **>(envp));
275      else
276        execv(PathStr.c_str(),
277              const_cast<char **>(args));
278      // If the execve() failed, we should exit. Follow Unix protocol and
279      // return 127 if the executable was not found, and 126 otherwise.
280      // Use _exit rather than exit so that atexit functions and static
281      // object destructors cloned from the parent process aren't
282      // redundantly run, and so that any data buffered in stdio buffers
283      // cloned from the parent aren't redundantly written out.
284      _exit(errno == ENOENT ? 127 : 126);
285    }
286
287    // Parent process: Break out of the switch to do our processing.
288    default:
289      break;
290  }
291
292  if (Data)
293    *Data = reinterpret_cast<void*>(child);
294
295  return true;
296}
297
298static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
299                std::string *ErrMsg) {
300#ifdef HAVE_SYS_WAIT_H
301  struct sigaction Act, Old;
302  assert(Data && "invalid pid to wait on, process not started?");
303
304  // Install a timeout handler.  The handler itself does nothing, but the simple
305  // fact of having a handler at all causes the wait below to return with EINTR,
306  // unlike if we used SIG_IGN.
307  if (secondsToWait) {
308    memset(&Act, 0, sizeof(Act));
309    Act.sa_handler = TimeOutHandler;
310    sigemptyset(&Act.sa_mask);
311    sigaction(SIGALRM, &Act, &Old);
312    alarm(secondsToWait);
313  }
314
315  // Parent process: Wait for the child process to terminate.
316  int status;
317  uint64_t pid = reinterpret_cast<uint64_t>(Data);
318  pid_t child = static_cast<pid_t>(pid);
319  while (waitpid(pid, &status, 0) != child)
320    if (secondsToWait && errno == EINTR) {
321      // Kill the child.
322      kill(child, SIGKILL);
323
324      // Turn off the alarm and restore the signal handler
325      alarm(0);
326      sigaction(SIGALRM, &Old, 0);
327
328      // Wait for child to die
329      if (wait(&status) != child)
330        MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
331      else
332        MakeErrMsg(ErrMsg, "Child timed out", 0);
333
334      return -2;   // Timeout detected
335    } else if (errno != EINTR) {
336      MakeErrMsg(ErrMsg, "Error waiting for child process");
337      return -1;
338    }
339
340  // We exited normally without timeout, so turn off the timer.
341  if (secondsToWait) {
342    alarm(0);
343    sigaction(SIGALRM, &Old, 0);
344  }
345
346  // Return the proper exit status. Detect error conditions
347  // so we can return -1 for them and set ErrMsg informatively.
348  int result = 0;
349  if (WIFEXITED(status)) {
350    result = WEXITSTATUS(status);
351#ifdef HAVE_POSIX_SPAWN
352    // The posix_spawn child process returns 127 on any kind of error.
353    // Following the POSIX convention for command-line tools (which posix_spawn
354    // itself apparently does not), check to see if the failure was due to some
355    // reason other than the file not existing, and return 126 in this case.
356    bool Exists;
357    if (result == 127 && !llvm::sys::fs::exists(Program, Exists) && Exists)
358      result = 126;
359#endif
360    if (result == 127) {
361      if (ErrMsg)
362        *ErrMsg = llvm::sys::StrError(ENOENT);
363      return -1;
364    }
365    if (result == 126) {
366      if (ErrMsg)
367        *ErrMsg = "Program could not be executed";
368      return -1;
369    }
370  } else if (WIFSIGNALED(status)) {
371    if (ErrMsg) {
372      *ErrMsg = strsignal(WTERMSIG(status));
373#ifdef WCOREDUMP
374      if (WCOREDUMP(status))
375        *ErrMsg += " (core dumped)";
376#endif
377    }
378    // Return a special value to indicate that the process received an unhandled
379    // signal during execution as opposed to failing to execute.
380    return -2;
381  }
382  return result;
383#else
384  if (ErrMsg)
385    *ErrMsg = "Program::Wait is not implemented on this platform yet!";
386  return -1;
387#endif
388}
389
390namespace llvm {
391
392error_code sys::ChangeStdinToBinary(){
393  // Do nothing, as Unix doesn't differentiate between text and binary.
394  return make_error_code(errc::success);
395}
396
397error_code sys::ChangeStdoutToBinary(){
398  // Do nothing, as Unix doesn't differentiate between text and binary.
399  return make_error_code(errc::success);
400}
401
402error_code sys::ChangeStderrToBinary(){
403  // Do nothing, as Unix doesn't differentiate between text and binary.
404  return make_error_code(errc::success);
405}
406
407bool llvm::sys::argumentsFitWithinSystemLimits(ArrayRef<const char*> Args) {
408  static long ArgMax = sysconf(_SC_ARG_MAX);
409
410  // System says no practical limit.
411  if (ArgMax == -1)
412    return true;
413
414  // Conservatively account for space required by environment variables.
415  ArgMax /= 2;
416
417  size_t ArgLength = 0;
418  for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
419       I != E; ++I) {
420    ArgLength += strlen(*I) + 1;
421    if (ArgLength > size_t(ArgMax)) {
422      return false;
423    }
424  }
425  return true;
426}
427
428}
429