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
60extern char **environ;
61#else
62#include <crt_externs.h> // _NSGetEnviron
63#endif
64#endif
65
66using namespace llvm;
67using namespace sys;
68
69ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {}
70
71ErrorOr<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(C: '/'))
77 return std::string(Name);
78
79 SmallVector<StringRef, 16> EnvironmentPaths;
80 if (Paths.empty())
81 if (const char *PathEnv = std::getenv(name: "PATH")) {
82 SplitString(Source: PathEnv, OutFragments&: EnvironmentPaths, Delimiters: ":");
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(path&: FilePath, a: Name);
93 if (sys::fs::can_execute(Path: FilePath.c_str()))
94 return std::string(FilePath); // Found the executable!
95 }
96 return errc::no_such_file_or_directory;
97}
98
99static 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: File.c_str(), oflag: FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666);
111 if (InFD == -1) {
112 MakeErrMsg(ErrMsg, prefix: "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(fd: InFD, fd2: FD) == -1) {
119 MakeErrMsg(ErrMsg, prefix: "Cannot dup2");
120 close(fd: InFD);
121 return true;
122 }
123 close(fd: InFD); // Close the original FD
124 return false;
125}
126
127#ifdef HAVE_POSIX_SPAWN
128static 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 file_actions: FileActions, fd: FD, path: File, oflag: FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, mode: 0666))
141 return MakeErrMsg(ErrMsg, prefix: "Cannot posix_spawn_file_actions_addopen", errnum: Err);
142 return false;
143}
144#endif
145
146static void TimeOutHandler(int Sig) {}
147
148static 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, rlimits: &r);
155 r.rlim_cur = limit;
156 setrlimit(RLIMIT_DATA, rlimits: &r);
157#ifdef RLIMIT_RSS
158 // Resident set size.
159 getrlimit(RLIMIT_RSS, rlimits: &r);
160 r.rlim_cur = limit;
161 setrlimit(RLIMIT_RSS, rlimits: &r);
162#endif
163#endif
164}
165
166static std::vector<const char *>
167toNullTerminatedCStringArray(ArrayRef<StringRef> Strings, StringSaver &Saver) {
168 std::vector<const char *> Result;
169 for (StringRef S : Strings)
170 Result.push_back(x: Saver.save(S).data());
171 Result.push_back(x: nullptr);
172 return Result;
173}
174
175static 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(Path: 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(Strings: Args, Saver);
197 Argv = ArgVector.data();
198 if (Env) {
199 EnvVector = toNullTerminatedCStringArray(Strings: *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(file_actions: FileActions);
228
229 // Redirect stdin/stdout.
230 if (RedirectIO_PS(Path: RedirectsStr[0], FD: 0, ErrMsg, FileActions) ||
231 RedirectIO_PS(Path: RedirectsStr[1], FD: 1, ErrMsg, FileActions))
232 return false;
233 if (!Redirects[1] || !Redirects[2] || *Redirects[1] != *Redirects[2]) {
234 // Just redirect stderr
235 if (RedirectIO_PS(Path: RedirectsStr[2], FD: 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(file_actions: FileActions, fd: 1, newfd: 2))
241 return !MakeErrMsg(ErrMsg, prefix: "Can't redirect stderr to stdout", errnum: 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: &PID, path: Program.str().c_str(), file_actions: FileActions,
260 /*attrp*/ attrp: nullptr, argv: const_cast<char **>(Argv),
261 envp: const_cast<char **>(Envp));
262 } while (Err == EINTR && ++retries < maxRetries);
263
264 if (FileActions)
265 posix_spawn_file_actions_destroy(file_actions: FileActions);
266
267 if (Err)
268 return !MakeErrMsg(ErrMsg, prefix: "posix_spawn failed", errnum: 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, prefix: "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(Path: Redirects[0], FD: 0, ErrMsg)) {
291 return false;
292 }
293 // Redirect stdout
294 if (RedirectIO(Path: Redirects[1], FD: 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(fd: 1, fd2: 2)) {
301 MakeErrMsg(ErrMsg, prefix: "Can't redirect stderr to stdout");
302 return false;
303 }
304 } else {
305 // Just redirect stderr
306 if (RedirectIO(Path: Redirects[2], FD: 2, ErrMsg)) {
307 return false;
308 }
309 }
310 }
311
312 if (DetachProcess) {
313 // Detach from controlling terminal
314 if (::setsid() == -1) {
315 MakeErrMsg(ErrMsg, prefix: "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(path: PathStr.c_str(), argv: const_cast<char **>(Argv),
329 envp: const_cast<char **>(Envp));
330 else
331 execv(path: PathStr.c_str(), argv: 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
352namespace llvm {
353namespace sys {
354
355#if defined(_AIX)
356static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage);
357#elif !defined(__Fuchsia__)
358using ::wait4;
359#endif
360
361} // namespace sys
362} // namespace llvm
363
364#ifdef _AIX
365#ifndef _ALL_SOURCE
366extern "C" pid_t(wait4)(pid_t pid, int *status, int options,
367 struct rusage *usage);
368#endif
369pid_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
398ProcessInfo 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(s: &Act, c: 0, n: sizeof(Act));
419 Act.sa_handler = TimeOutHandler;
420 sigemptyset(set: &Act.sa_mask);
421 sigaction(SIGALRM, act: &Act, oact: &Old);
422 // FIXME The alarm signal may be delivered to another thread.
423 alarm(seconds: *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(pid: ChildPid, stat_loc: &status, options: WaitPidOptions, usage: &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(pid: PI.Pid, SIGKILL);
447
448 // Turn off the alarm and restore the signal handler
449 alarm(seconds: 0);
450 sigaction(SIGALRM, act: &Old, oact: 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(stat_loc: &status) != ChildPid)
456 MakeErrMsg(ErrMsg, prefix: "Child timed out but wouldn't die");
457 else
458 MakeErrMsg(ErrMsg, prefix: "Child timed out", errnum: 0);
459
460 WaitResult.ReturnCode = -2; // Timeout detected
461 return WaitResult;
462 } else if (errno != EINTR) {
463 MakeErrMsg(ErrMsg, prefix: "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(seconds: 0);
473 sigaction(SIGALRM, act: &Old, oact: nullptr);
474 }
475
476#ifndef __Fuchsia__
477 if (ProcStat) {
478 std::chrono::microseconds UserT = toDuration(TV: Info.ru_utime);
479 std::chrono::microseconds KernelT = toDuration(TV: 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{.TotalTime: UserT + KernelT, .UserTime: UserT, .PeakMemory: 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
522std::error_code llvm::sys::ChangeStdinMode(fs::OpenFlags Flags) {
523 if (!(Flags & fs::OF_Text))
524 return ChangeStdinToBinary();
525 return std::error_code();
526}
527
528std::error_code llvm::sys::ChangeStdoutMode(fs::OpenFlags Flags) {
529 if (!(Flags & fs::OF_Text))
530 return ChangeStdoutToBinary();
531 return std::error_code();
532}
533
534std::error_code llvm::sys::ChangeStdinToBinary() {
535#ifdef __MVS__
536 return disableAutoConversion(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
543std::error_code llvm::sys::ChangeStdoutToBinary() {
544 // Do nothing, as Unix doesn't differentiate between text and binary.
545 return std::error_code();
546}
547
548std::error_code
549llvm::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(E: errc::io_error);
562
563 return EC;
564}
565
566bool 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}
606

source code of llvm/lib/Support/Unix/Program.inc