Program.inc revision dce4a407a24b04eebc6a376f8e62b41aaa7b071f
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#ifdef __sun__ 40#define _RESTRICT_KYWD 41#endif 42#include <spawn.h> 43#if !defined(__APPLE__) 44 extern char **environ; 45#else 46#include <crt_externs.h> // _NSGetEnviron 47#endif 48#endif 49 50namespace llvm { 51using namespace sys; 52 53ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {} 54 55// This function just uses the PATH environment variable to find the program. 56std::string 57sys::FindProgramByName(const std::string& progName) { 58 59 // Check some degenerate cases 60 if (progName.length() == 0) // no program 61 return ""; 62 std::string temp = progName; 63 // Use the given path verbatim if it contains any slashes; this matches 64 // the behavior of sh(1) and friends. 65 if (progName.find('/') != std::string::npos) 66 return temp; 67 68 // At this point, the file name is valid and does not contain slashes. Search 69 // for it through the directories specified in the PATH environment variable. 70 71 // Get the path. If its empty, we can't do anything to find it. 72 const char *PathStr = getenv("PATH"); 73 if (!PathStr) 74 return ""; 75 76 // Now we have a colon separated list of directories to search; try them. 77 size_t PathLen = strlen(PathStr); 78 while (PathLen) { 79 // Find the first colon... 80 const char *Colon = std::find(PathStr, PathStr+PathLen, ':'); 81 82 // Check to see if this first directory contains the executable... 83 SmallString<128> FilePath(PathStr,Colon); 84 sys::path::append(FilePath, progName); 85 if (sys::fs::can_execute(Twine(FilePath))) 86 return FilePath.str(); // Found the executable! 87 88 // Nope it wasn't in this directory, check the next path in the list! 89 PathLen -= Colon-PathStr; 90 PathStr = Colon; 91 92 // Advance past duplicate colons 93 while (*PathStr == ':') { 94 PathStr++; 95 PathLen--; 96 } 97 } 98 return ""; 99} 100 101static bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) { 102 if (!Path) // Noop 103 return false; 104 std::string File; 105 if (Path->empty()) 106 // Redirect empty paths to /dev/null 107 File = "/dev/null"; 108 else 109 File = *Path; 110 111 // Open the file 112 int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666); 113 if (InFD == -1) { 114 MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for " 115 + (FD == 0 ? "input" : "output")); 116 return true; 117 } 118 119 // Install it as the requested FD 120 if (dup2(InFD, FD) == -1) { 121 MakeErrMsg(ErrMsg, "Cannot dup2"); 122 close(InFD); 123 return true; 124 } 125 close(InFD); // Close the original FD 126 return false; 127} 128 129#ifdef HAVE_POSIX_SPAWN 130static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg, 131 posix_spawn_file_actions_t *FileActions) { 132 if (!Path) // Noop 133 return false; 134 const char *File; 135 if (Path->empty()) 136 // Redirect empty paths to /dev/null 137 File = "/dev/null"; 138 else 139 File = Path->c_str(); 140 141 if (int Err = posix_spawn_file_actions_addopen( 142 FileActions, FD, File, 143 FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666)) 144 return MakeErrMsg(ErrMsg, "Cannot dup2", Err); 145 return false; 146} 147#endif 148 149static void TimeOutHandler(int Sig) { 150} 151 152static void SetMemoryLimits (unsigned size) 153{ 154#if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT 155 struct rlimit r; 156 __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576; 157 158 // Heap size 159 getrlimit (RLIMIT_DATA, &r); 160 r.rlim_cur = limit; 161 setrlimit (RLIMIT_DATA, &r); 162#ifdef RLIMIT_RSS 163 // Resident set size. 164 getrlimit (RLIMIT_RSS, &r); 165 r.rlim_cur = limit; 166 setrlimit (RLIMIT_RSS, &r); 167#endif 168#ifdef RLIMIT_AS // e.g. NetBSD doesn't have it. 169 // Don't set virtual memory limit if built with any Sanitizer. They need 80Tb 170 // of virtual memory for shadow memory mapping. 171#if !LLVM_MEMORY_SANITIZER_BUILD && !LLVM_ADDRESS_SANITIZER_BUILD 172 // Virtual memory. 173 getrlimit (RLIMIT_AS, &r); 174 r.rlim_cur = limit; 175 setrlimit (RLIMIT_AS, &r); 176#endif 177#endif 178#endif 179} 180 181} 182 183static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, 184 const char **envp, const StringRef **redirects, 185 unsigned memoryLimit, std::string *ErrMsg) { 186 if (!llvm::sys::fs::exists(Program)) { 187 if (ErrMsg) 188 *ErrMsg = std::string("Executable \"") + Program.str() + 189 std::string("\" doesn't exist!"); 190 return false; 191 } 192 193 // If this OS has posix_spawn and there is no memory limit being implied, use 194 // posix_spawn. It is more efficient than fork/exec. 195#ifdef HAVE_POSIX_SPAWN 196 if (memoryLimit == 0) { 197 posix_spawn_file_actions_t FileActionsStore; 198 posix_spawn_file_actions_t *FileActions = nullptr; 199 200 // If we call posix_spawn_file_actions_addopen we have to make sure the 201 // c strings we pass to it stay alive until the call to posix_spawn, 202 // so we copy any StringRefs into this variable. 203 std::string RedirectsStorage[3]; 204 205 if (redirects) { 206 std::string *RedirectsStr[3] = {nullptr, nullptr, nullptr}; 207 for (int I = 0; I < 3; ++I) { 208 if (redirects[I]) { 209 RedirectsStorage[I] = *redirects[I]; 210 RedirectsStr[I] = &RedirectsStorage[I]; 211 } 212 } 213 214 FileActions = &FileActionsStore; 215 posix_spawn_file_actions_init(FileActions); 216 217 // Redirect stdin/stdout. 218 if (RedirectIO_PS(RedirectsStr[0], 0, ErrMsg, FileActions) || 219 RedirectIO_PS(RedirectsStr[1], 1, ErrMsg, FileActions)) 220 return false; 221 if (redirects[1] == nullptr || redirects[2] == nullptr || 222 *redirects[1] != *redirects[2]) { 223 // Just redirect stderr 224 if (RedirectIO_PS(RedirectsStr[2], 2, ErrMsg, FileActions)) 225 return false; 226 } else { 227 // If stdout and stderr should go to the same place, redirect stderr 228 // to the FD already open for stdout. 229 if (int Err = posix_spawn_file_actions_adddup2(FileActions, 1, 2)) 230 return !MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout", Err); 231 } 232 } 233 234 if (!envp) 235#if !defined(__APPLE__) 236 envp = const_cast<const char **>(environ); 237#else 238 // environ is missing in dylibs. 239 envp = const_cast<const char **>(*_NSGetEnviron()); 240#endif 241 242 // Explicitly initialized to prevent what appears to be a valgrind false 243 // positive. 244 pid_t PID = 0; 245 int Err = posix_spawn(&PID, Program.str().c_str(), FileActions, 246 /*attrp*/nullptr, const_cast<char **>(args), 247 const_cast<char **>(envp)); 248 249 if (FileActions) 250 posix_spawn_file_actions_destroy(FileActions); 251 252 if (Err) 253 return !MakeErrMsg(ErrMsg, "posix_spawn failed", Err); 254 255 PI.Pid = PID; 256 257 return true; 258 } 259#endif 260 261 // Create a child process. 262 int child = fork(); 263 switch (child) { 264 // An error occurred: Return to the caller. 265 case -1: 266 MakeErrMsg(ErrMsg, "Couldn't fork"); 267 return false; 268 269 // Child process: Execute the program. 270 case 0: { 271 // Redirect file descriptors... 272 if (redirects) { 273 // Redirect stdin 274 if (RedirectIO(redirects[0], 0, ErrMsg)) { return false; } 275 // Redirect stdout 276 if (RedirectIO(redirects[1], 1, ErrMsg)) { return false; } 277 if (redirects[1] && redirects[2] && 278 *(redirects[1]) == *(redirects[2])) { 279 // If stdout and stderr should go to the same place, redirect stderr 280 // to the FD already open for stdout. 281 if (-1 == dup2(1,2)) { 282 MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout"); 283 return false; 284 } 285 } else { 286 // Just redirect stderr 287 if (RedirectIO(redirects[2], 2, ErrMsg)) { return false; } 288 } 289 } 290 291 // Set memory limits 292 if (memoryLimit!=0) { 293 SetMemoryLimits(memoryLimit); 294 } 295 296 // Execute! 297 std::string PathStr = Program; 298 if (envp != nullptr) 299 execve(PathStr.c_str(), 300 const_cast<char **>(args), 301 const_cast<char **>(envp)); 302 else 303 execv(PathStr.c_str(), 304 const_cast<char **>(args)); 305 // If the execve() failed, we should exit. Follow Unix protocol and 306 // return 127 if the executable was not found, and 126 otherwise. 307 // Use _exit rather than exit so that atexit functions and static 308 // object destructors cloned from the parent process aren't 309 // redundantly run, and so that any data buffered in stdio buffers 310 // cloned from the parent aren't redundantly written out. 311 _exit(errno == ENOENT ? 127 : 126); 312 } 313 314 // Parent process: Break out of the switch to do our processing. 315 default: 316 break; 317 } 318 319 PI.Pid = child; 320 321 return true; 322} 323 324namespace llvm { 325 326ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait, 327 bool WaitUntilTerminates, std::string *ErrMsg) { 328#ifdef HAVE_SYS_WAIT_H 329 struct sigaction Act, Old; 330 assert(PI.Pid && "invalid pid to wait on, process not started?"); 331 332 int WaitPidOptions = 0; 333 pid_t ChildPid = PI.Pid; 334 if (WaitUntilTerminates) { 335 SecondsToWait = 0; 336 ChildPid = -1; // mimic a wait() using waitpid() 337 } else if (SecondsToWait) { 338 // Install a timeout handler. The handler itself does nothing, but the 339 // simple fact of having a handler at all causes the wait below to return 340 // with EINTR, unlike if we used SIG_IGN. 341 memset(&Act, 0, sizeof(Act)); 342 Act.sa_handler = TimeOutHandler; 343 sigemptyset(&Act.sa_mask); 344 sigaction(SIGALRM, &Act, &Old); 345 alarm(SecondsToWait); 346 } else if (SecondsToWait == 0) 347 WaitPidOptions = WNOHANG; 348 349 // Parent process: Wait for the child process to terminate. 350 int status; 351 ProcessInfo WaitResult; 352 WaitResult.Pid = waitpid(ChildPid, &status, WaitPidOptions); 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 428error_code sys::ChangeStdinToBinary(){ 429 // Do nothing, as Unix doesn't differentiate between text and binary. 430 return make_error_code(errc::success); 431} 432 433error_code sys::ChangeStdoutToBinary(){ 434 // Do nothing, as Unix doesn't differentiate between text and binary. 435 return make_error_code(errc::success); 436} 437 438bool llvm::sys::argumentsFitWithinSystemLimits(ArrayRef<const char*> Args) { 439 static long ArgMax = sysconf(_SC_ARG_MAX); 440 441 // System says no practical limit. 442 if (ArgMax == -1) 443 return true; 444 445 // Conservatively account for space required by environment variables. 446 ArgMax /= 2; 447 448 size_t ArgLength = 0; 449 for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end(); 450 I != E; ++I) { 451 ArgLength += strlen(*I) + 1; 452 if (ArgLength > size_t(ArgMax)) { 453 return false; 454 } 455 } 456 return true; 457} 458} 459