lib/Support/SystemUtils.cpp

   1 //===- SystemUtils.h - Utilities to do low-level system stuff --*- C++ -*--===//
   2 //
   3 // This file contains functions used to do a variety of low-level, often
   4 // system-specific, tasks.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "Support/SystemUtils.h"
   9 #include <algorithm>
  10 #include <fstream>
  11 #include <iostream>
  12 #include <cstdlib>
  13 #include "Config/sys/types.h"
  14 #include "Config/sys/stat.h"
  15 #include "Config/fcntl.h"
  16 #include "Config/sys/wait.h"
  17 #include "Config/unistd.h"
  18 #include "Config/errno.h"
  19
  20 /// isExecutableFile - This function returns true if the filename specified
  21 /// exists and is executable.
  22 ///
  23 bool isExecutableFile(const std::string &ExeFileName) {
  24   struct stat Buf;
  25   if (stat(ExeFileName.c_str(), &Buf))
  26     return false;  // Must not be executable!
  27
  28   if (!(Buf.st_mode & S_IFREG))
  29     return false;                    // Not a regular file?
  30
  31   if (Buf.st_uid == getuid())        // Owner of file?
  32     return Buf.st_mode & S_IXUSR;
  33   else if (Buf.st_gid == getgid())   // In group of file?
  34     return Buf.st_mode & S_IXGRP;
  35   else                               // Unrelated to file?
  36     return Buf.st_mode & S_IXOTH;
  37 }
  38
  39
  40 /// FindExecutable - Find a named executable, giving the argv[0] of program
  41 /// being executed. This allows us to find another LLVM tool if it is built into
  42 /// the same directory, but that directory is neither the current directory, nor
  43 /// in the PATH.  If the executable cannot be found, return an empty string.
  44 ///
  45 std::string FindExecutable(const std::string &ExeName,
  46                            const std::string &ProgramPath) {
  47   // First check the directory that bugpoint is in.  We can do this if
  48   // BugPointPath contains at least one / character, indicating that it is a
  49   // relative path to bugpoint itself.
  50   //
  51   std::string Result = ProgramPath;
  52   while (!Result.empty() && Result[Result.size()-1] != '/')
  53     Result.erase(Result.size()-1, 1);
  54
  55   if (!Result.empty()) {
  56     Result += ExeName;
  57     if (isExecutableFile(Result)) return Result; // Found it?
  58   }
  59
  60   // Okay, if the path to the program didn't tell us anything, try using the
  61   // PATH environment variable.
  62   const char *PathStr = getenv("PATH");
  63   if (PathStr == 0) return "";
  64
  65   // Now we have a colon separated list of directories to search... try them...
  66   unsigned PathLen = strlen(PathStr);
  67   while (PathLen) {
  68     // Find the first colon...
  69     const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
  70
  71     // Check to see if this first directory contains the executable...
  72     std::string FilePath = std::string(PathStr, Colon) + '/' + ExeName;
  73     if (isExecutableFile(FilePath))
  74       return FilePath;                    // Found the executable!
  75
  76     // Nope it wasn't in this directory, check the next range!
  77     PathLen -= Colon-PathStr;
  78     PathStr = Colon;
  79     while (*PathStr == ':') {   // Advance past colons
  80       PathStr++;
  81       PathLen--;
  82     }
  83   }
  84
  85   // If we fell out, we ran out of directories in PATH to search, return failure
  86   return "";
  87 }
  88
  89 static void RedirectFD(const std::string &File, int FD) {
  90   if (File.empty()) return;  // Noop
  91
  92   // Open the file
  93   int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
  94   if (InFD == -1) {
  95     std::cerr << "Error opening file '" << File << "' for "
  96               << (FD == 0 ? "input" : "output") << "!\n";
  97     exit(1);
  98   }
  99
 100   dup2(InFD, FD);   // Install it as the requested FD
 101   close(InFD);      // Close the original FD
 102 }
 103
 104 /// RunProgramWithTimeout - This function executes the specified program, with
 105 /// the specified null-terminated argument array, with the stdin/out/err fd's
 106 /// redirected, with a timeout specified on the command line.  This terminates
 107 /// the calling program if there is an error executing the specified program.
 108 /// It returns the return value of the program, or -1 if a timeout is detected.
 109 ///
 110 int RunProgramWithTimeout(const std::string &ProgramPath, const char **Args,
 111                           const std::string &StdInFile,
 112                           const std::string &StdOutFile,
 113                           const std::string &StdErrFile) {
 114
 115   // FIXME: install sigalarm handler here for timeout...
 116
 117   int Child = fork();
 118   switch (Child) {
 119   case -1:
 120     std::cerr << "ERROR forking!\n";
 121     exit(1);
 122   case 0:               // Child
 123     RedirectFD(StdInFile, 0);      // Redirect file descriptors...
 124     RedirectFD(StdOutFile, 1);
 125     RedirectFD(StdErrFile, 2);
 126
 127     execv(ProgramPath.c_str(), (char *const *)Args);
 128     std::cerr << "Error executing program '" << ProgramPath;
 129     for (; *Args; ++Args)
 130       std::cerr << " " << *Args;
 131     exit(1);
 132
 133   default: break;
 134   }
 135
 136   // Make sure all output has been written while waiting
 137   std::cout << std::flush;
 138
 139   int Status;
 140   if (wait(&Status) != Child) {
 141     if (errno == EINTR) {
 142       static bool FirstTimeout = true;
 143       if (FirstTimeout) {
 144         std::cout <<
 145  "*** Program execution timed out!  This mechanism is designed to handle\n"
 146  "    programs stuck in infinite loops gracefully.  The -timeout option\n"
 147  "    can be used to change the timeout threshold or disable it completely\n"
 148  "    (with -timeout=0).  This message is only displayed once.\n";
 149         FirstTimeout = false;
 150       }
 151       return -1;   // Timeout detected
 152     }
 153
 154     std::cerr << "Error waiting for child process!\n";
 155     exit(1);
 156   }
 157   return Status;
 158 }
 159
 160
 161 //
 162 // Function: ExecWait ()
 163 //
 164 // Description:
 165 //  This function executes a program with the specified arguments and
 166 //  environment.  It then waits for the progarm to termiante and then returns
 167 //  to the caller.
 168 //
 169 // Inputs:
 170 //  argv - The arguments to the program as an array of C strings.  The first
 171 //         argument should be the name of the program to execute, and the
 172 //         last argument should be a pointer to NULL.
 173 //
 174 //  envp - The environment passes to the program as an array of C strings in
 175 //         the form of "name=value" pairs.  The last element should be a
 176 //         pointer to NULL.
 177 //
 178 // Outputs:
 179 //  None.
 180 //
 181 // Return value:
 182 //  0 - No errors.
 183 //  1 - The program could not be executed.
 184 //  1 - The program returned a non-zero exit status.
 185 //  1 - The program terminated abnormally.
 186 //
 187 // Notes:
 188 //  The program will inherit the stdin, stdout, and stderr file descriptors
 189 //  as well as other various configuration settings (umask).
 190 //
 191 //  This function should not print anything to stdout/stderr on its own.  It is
 192 //  a generic library function.  The caller or executed program should report
 193 //  errors in the way it sees fit.
 194 //
 195 int
 196 ExecWait (char ** argv, char **envp)
 197 {
 198   // Child process ID
 199   register int child;
 200
 201   // Status from child process when it exits
 202   int status;
 203
 204   //
 205   // Because UNIX is sometimes less than convenient, we need to use
 206   // FindExecutable() to find the full pathname to the file to execute.
 207   //
 208   // This is becausse execvp() doesn't use PATH, and we want to look for
 209   // programs in the LLVM binary directory first anyway.
 210   //
 211   std::string Program = FindExecutable (argv[0], "");
 212   if (Program.empty())
 213   {
 214     return 1;
 215   }
 216
 217   //
 218   // Create a child process.
 219   //
 220   switch (child=fork())
 221   {
 222     case -1:
 223       return 1;
 224       break;
 225
 226     case 0:
 227       execve (Program.c_str(), argv, envp);
 228       return 1;
 229       break;
 230
 231     default:
 232       break;
 233   }
 234
 235   //
 236   // Parent process: Wait for the child process to termiante.
 237   //
 238   if ((wait (&status)) == -1)
 239   {
 240     return 1;
 241   }
 242
 243   //
 244   // If the program exited normally with a zero exit status, return success!
 245   //
 246   if (WIFEXITED (status) && (WEXITSTATUS(status) == 0))
 247   {
 248     return 0;
 249   }
 250
 251   //
 252   // Otherwise, return failure.
 253   //
 254   return 1;
 255 }
 256