1//===- Unix/Process.cpp - Unix Process Implementation --------- -*- 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 provides the generic Unix implementation of the Process class.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Unix.h"
15#include "llvm/ADT/Hashing.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/Support/ManagedStatic.h"
18#include "llvm/Support/Mutex.h"
19#include "llvm/Support/MutexGuard.h"
20#include "llvm/Support/TimeValue.h"
21#if HAVE_FCNTL_H
22#include <fcntl.h>
23#endif
24#ifdef HAVE_SYS_TIME_H
25#include <sys/time.h>
26#endif
27#ifdef HAVE_SYS_RESOURCE_H
28#include <sys/resource.h>
29#endif
30#ifdef HAVE_SYS_STAT_H
31#include <sys/stat.h>
32#endif
33#if HAVE_SIGNAL_H
34#include <signal.h>
35#endif
36// DragonFlyBSD, OpenBSD, and Bitrig have deprecated <malloc.h> for
37// <stdlib.h> instead. Unix.h includes this for us already.
38#if defined(HAVE_MALLOC_H) && !defined(__DragonFly__) && \
39    !defined(__OpenBSD__) && !defined(__Bitrig__)
40#include <malloc.h>
41#endif
42#ifdef HAVE_MALLOC_MALLOC_H
43#include <malloc/malloc.h>
44#endif
45#ifdef HAVE_SYS_IOCTL_H
46#  include <sys/ioctl.h>
47#endif
48#ifdef HAVE_TERMIOS_H
49#  include <termios.h>
50#endif
51
52//===----------------------------------------------------------------------===//
53//=== WARNING: Implementation here must contain only generic UNIX code that
54//===          is guaranteed to work on *all* UNIX variants.
55//===----------------------------------------------------------------------===//
56
57using namespace llvm;
58using namespace sys;
59
60process::id_type self_process::get_id() {
61  return getpid();
62}
63
64static std::pair<TimeValue, TimeValue> getRUsageTimes() {
65#if defined(HAVE_GETRUSAGE)
66  struct rusage RU;
67  ::getrusage(RUSAGE_SELF, &RU);
68  return std::make_pair(
69      TimeValue(
70          static_cast<TimeValue::SecondsType>(RU.ru_utime.tv_sec),
71          static_cast<TimeValue::NanoSecondsType>(
72              RU.ru_utime.tv_usec * TimeValue::NANOSECONDS_PER_MICROSECOND)),
73      TimeValue(
74          static_cast<TimeValue::SecondsType>(RU.ru_stime.tv_sec),
75          static_cast<TimeValue::NanoSecondsType>(
76              RU.ru_stime.tv_usec * TimeValue::NANOSECONDS_PER_MICROSECOND)));
77#else
78#warning Cannot get usage times on this platform
79  return std::make_pair(TimeValue(), TimeValue());
80#endif
81}
82
83TimeValue self_process::get_user_time() const {
84#if _POSIX_TIMERS > 0 && _POSIX_CPUTIME > 0
85  // Try to get a high resolution CPU timer.
86  struct timespec TS;
87  if (::clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &TS) == 0)
88    return TimeValue(static_cast<TimeValue::SecondsType>(TS.tv_sec),
89                     static_cast<TimeValue::NanoSecondsType>(TS.tv_nsec));
90#endif
91
92  // Otherwise fall back to rusage based timing.
93  return getRUsageTimes().first;
94}
95
96TimeValue self_process::get_system_time() const {
97  // We can only collect system time by inspecting the results of getrusage.
98  return getRUsageTimes().second;
99}
100
101// On Cygwin, getpagesize() returns 64k(AllocationGranularity) and
102// offset in mmap(3) should be aligned to the AllocationGranularity.
103static unsigned getPageSize() {
104#if defined(HAVE_GETPAGESIZE)
105  const int page_size = ::getpagesize();
106#elif defined(HAVE_SYSCONF)
107  long page_size = ::sysconf(_SC_PAGE_SIZE);
108#else
109#warning Cannot get the page size on this machine
110#endif
111  return static_cast<unsigned>(page_size);
112}
113
114// This constructor guaranteed to be run exactly once on a single thread, and
115// sets up various process invariants that can be queried cheaply from then on.
116self_process::self_process() : PageSize(getPageSize()) {
117}
118
119
120size_t Process::GetMallocUsage() {
121#if defined(HAVE_MALLINFO)
122  struct mallinfo mi;
123  mi = ::mallinfo();
124  return mi.uordblks;
125#elif defined(HAVE_MALLOC_ZONE_STATISTICS) && defined(HAVE_MALLOC_MALLOC_H)
126  malloc_statistics_t Stats;
127  malloc_zone_statistics(malloc_default_zone(), &Stats);
128  return Stats.size_in_use;   // darwin
129#elif defined(HAVE_SBRK)
130  // Note this is only an approximation and more closely resembles
131  // the value returned by mallinfo in the arena field.
132  static char *StartOfMemory = reinterpret_cast<char*>(::sbrk(0));
133  char *EndOfMemory = (char*)sbrk(0);
134  if (EndOfMemory != ((char*)-1) && StartOfMemory != ((char*)-1))
135    return EndOfMemory - StartOfMemory;
136  else
137    return 0;
138#else
139#warning Cannot get malloc info on this platform
140  return 0;
141#endif
142}
143
144void Process::GetTimeUsage(TimeValue &elapsed, TimeValue &user_time,
145                           TimeValue &sys_time) {
146  elapsed = TimeValue::now();
147  std::tie(user_time, sys_time) = getRUsageTimes();
148}
149
150#if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
151#include <mach/mach.h>
152#endif
153
154// Some LLVM programs such as bugpoint produce core files as a normal part of
155// their operation. To prevent the disk from filling up, this function
156// does what's necessary to prevent their generation.
157void Process::PreventCoreFiles() {
158#if HAVE_SETRLIMIT
159  struct rlimit rlim;
160  rlim.rlim_cur = rlim.rlim_max = 0;
161  setrlimit(RLIMIT_CORE, &rlim);
162#endif
163
164#if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
165  // Disable crash reporting on Mac OS X 10.0-10.4
166
167  // get information about the original set of exception ports for the task
168  mach_msg_type_number_t Count = 0;
169  exception_mask_t OriginalMasks[EXC_TYPES_COUNT];
170  exception_port_t OriginalPorts[EXC_TYPES_COUNT];
171  exception_behavior_t OriginalBehaviors[EXC_TYPES_COUNT];
172  thread_state_flavor_t OriginalFlavors[EXC_TYPES_COUNT];
173  kern_return_t err =
174    task_get_exception_ports(mach_task_self(), EXC_MASK_ALL, OriginalMasks,
175                             &Count, OriginalPorts, OriginalBehaviors,
176                             OriginalFlavors);
177  if (err == KERN_SUCCESS) {
178    // replace each with MACH_PORT_NULL.
179    for (unsigned i = 0; i != Count; ++i)
180      task_set_exception_ports(mach_task_self(), OriginalMasks[i],
181                               MACH_PORT_NULL, OriginalBehaviors[i],
182                               OriginalFlavors[i]);
183  }
184
185  // Disable crash reporting on Mac OS X 10.5
186  signal(SIGABRT, _exit);
187  signal(SIGILL,  _exit);
188  signal(SIGFPE,  _exit);
189  signal(SIGSEGV, _exit);
190  signal(SIGBUS,  _exit);
191#endif
192}
193
194Optional<std::string> Process::GetEnv(StringRef Name) {
195  std::string NameStr = Name.str();
196  const char *Val = ::getenv(NameStr.c_str());
197  if (!Val)
198    return None;
199  return std::string(Val);
200}
201
202std::error_code
203Process::GetArgumentVector(SmallVectorImpl<const char *> &ArgsOut,
204                           ArrayRef<const char *> ArgsIn,
205                           SpecificBumpPtrAllocator<char> &) {
206  ArgsOut.append(ArgsIn.begin(), ArgsIn.end());
207
208  return std::error_code();
209}
210
211namespace {
212class FDCloser {
213public:
214  FDCloser(int &FD) : FD(FD), KeepOpen(false) {}
215  void keepOpen() { KeepOpen = true; }
216  ~FDCloser() {
217    if (!KeepOpen && FD >= 0)
218      ::close(FD);
219  }
220
221private:
222  FDCloser(const FDCloser &) LLVM_DELETED_FUNCTION;
223  void operator=(const FDCloser &) LLVM_DELETED_FUNCTION;
224
225  int &FD;
226  bool KeepOpen;
227};
228}
229
230std::error_code Process::FixupStandardFileDescriptors() {
231  int NullFD = -1;
232  FDCloser FDC(NullFD);
233  const int StandardFDs[] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
234  for (int StandardFD : StandardFDs) {
235    struct stat st;
236    errno = 0;
237    while (fstat(StandardFD, &st) < 0) {
238      assert(errno && "expected errno to be set if fstat failed!");
239      // fstat should return EBADF if the file descriptor is closed.
240      if (errno == EBADF)
241        break;
242      // retry fstat if we got EINTR, otherwise bubble up the failure.
243      if (errno != EINTR)
244        return std::error_code(errno, std::generic_category());
245    }
246    // if fstat succeeds, move on to the next FD.
247    if (!errno)
248      continue;
249    assert(errno == EBADF && "expected errno to have EBADF at this point!");
250
251    if (NullFD < 0) {
252      while ((NullFD = open("/dev/null", O_RDWR)) < 0) {
253        if (errno == EINTR)
254          continue;
255        return std::error_code(errno, std::generic_category());
256      }
257    }
258
259    if (NullFD == StandardFD)
260      FDC.keepOpen();
261    else if (dup2(NullFD, StandardFD) < 0)
262      return std::error_code(errno, std::generic_category());
263  }
264  return std::error_code();
265}
266
267std::error_code Process::SafelyCloseFileDescriptor(int FD) {
268  // Create a signal set filled with *all* signals.
269  sigset_t FullSet;
270  if (sigfillset(&FullSet) < 0)
271    return std::error_code(errno, std::generic_category());
272  // Atomically swap our current signal mask with a full mask.
273  sigset_t SavedSet;
274#if LLVM_ENABLE_THREADS
275  if (int EC = pthread_sigmask(SIG_SETMASK, &FullSet, &SavedSet))
276    return std::error_code(EC, std::generic_category());
277#else
278  if (sigprocmask(SIG_SETMASK, &FullSet, &SavedSet) < 0)
279    return std::error_code(errno, std::generic_category());
280#endif
281  // Attempt to close the file descriptor.
282  // We need to save the error, if one occurs, because our subsequent call to
283  // pthread_sigmask might tamper with errno.
284  int ErrnoFromClose = 0;
285  if (::close(FD) < 0)
286    ErrnoFromClose = errno;
287  // Restore the signal mask back to what we saved earlier.
288  int EC = 0;
289#if LLVM_ENABLE_THREADS
290  EC = pthread_sigmask(SIG_SETMASK, &SavedSet, nullptr);
291#else
292  if (sigprocmask(SIG_SETMASK, &SavedSet, nullptr) < 0)
293    EC = errno;
294#endif
295  // The error code from close takes precedence over the one from
296  // pthread_sigmask.
297  if (ErrnoFromClose)
298    return std::error_code(ErrnoFromClose, std::generic_category());
299  return std::error_code(EC, std::generic_category());
300}
301
302bool Process::StandardInIsUserInput() {
303  return FileDescriptorIsDisplayed(STDIN_FILENO);
304}
305
306bool Process::StandardOutIsDisplayed() {
307  return FileDescriptorIsDisplayed(STDOUT_FILENO);
308}
309
310bool Process::StandardErrIsDisplayed() {
311  return FileDescriptorIsDisplayed(STDERR_FILENO);
312}
313
314bool Process::FileDescriptorIsDisplayed(int fd) {
315#if HAVE_ISATTY
316  return isatty(fd);
317#else
318  // If we don't have isatty, just return false.
319  return false;
320#endif
321}
322
323static unsigned getColumns(int FileID) {
324  // If COLUMNS is defined in the environment, wrap to that many columns.
325  if (const char *ColumnsStr = std::getenv("COLUMNS")) {
326    int Columns = std::atoi(ColumnsStr);
327    if (Columns > 0)
328      return Columns;
329  }
330
331  unsigned Columns = 0;
332
333#if defined(HAVE_SYS_IOCTL_H) && defined(HAVE_TERMIOS_H)
334  // Try to determine the width of the terminal.
335  struct winsize ws;
336  if (ioctl(FileID, TIOCGWINSZ, &ws) == 0)
337    Columns = ws.ws_col;
338#endif
339
340  return Columns;
341}
342
343unsigned Process::StandardOutColumns() {
344  if (!StandardOutIsDisplayed())
345    return 0;
346
347  return getColumns(1);
348}
349
350unsigned Process::StandardErrColumns() {
351  if (!StandardErrIsDisplayed())
352    return 0;
353
354  return getColumns(2);
355}
356
357#ifdef HAVE_TERMINFO
358// We manually declare these extern functions because finding the correct
359// headers from various terminfo, curses, or other sources is harder than
360// writing their specs down.
361extern "C" int setupterm(char *term, int filedes, int *errret);
362extern "C" struct term *set_curterm(struct term *termp);
363extern "C" int del_curterm(struct term *termp);
364extern "C" int tigetnum(char *capname);
365#endif
366
367#ifdef HAVE_TERMINFO
368static ManagedStatic<sys::Mutex> TermColorMutex;
369#endif
370
371static bool terminalHasColors(int fd) {
372#ifdef HAVE_TERMINFO
373  // First, acquire a global lock because these C routines are thread hostile.
374  MutexGuard G(*TermColorMutex);
375
376  int errret = 0;
377  if (setupterm((char *)nullptr, fd, &errret) != 0)
378    // Regardless of why, if we can't get terminfo, we shouldn't try to print
379    // colors.
380    return false;
381
382  // Test whether the terminal as set up supports color output. How to do this
383  // isn't entirely obvious. We can use the curses routine 'has_colors' but it
384  // would be nice to avoid a dependency on curses proper when we can make do
385  // with a minimal terminfo parsing library. Also, we don't really care whether
386  // the terminal supports the curses-specific color changing routines, merely
387  // if it will interpret ANSI color escape codes in a reasonable way. Thus, the
388  // strategy here is just to query the baseline colors capability and if it
389  // supports colors at all to assume it will translate the escape codes into
390  // whatever range of colors it does support. We can add more detailed tests
391  // here if users report them as necessary.
392  //
393  // The 'tigetnum' routine returns -2 or -1 on errors, and might return 0 if
394  // the terminfo says that no colors are supported.
395  bool HasColors = tigetnum(const_cast<char *>("colors")) > 0;
396
397  // Now extract the structure allocated by setupterm and free its memory
398  // through a really silly dance.
399  struct term *termp = set_curterm((struct term *)nullptr);
400  (void)del_curterm(termp); // Drop any errors here.
401
402  // Return true if we found a color capabilities for the current terminal.
403  if (HasColors)
404    return true;
405#endif
406
407  // Otherwise, be conservative.
408  return false;
409}
410
411bool Process::FileDescriptorHasColors(int fd) {
412  // A file descriptor has colors if it is displayed and the terminal has
413  // colors.
414  return FileDescriptorIsDisplayed(fd) && terminalHasColors(fd);
415}
416
417bool Process::StandardOutHasColors() {
418  return FileDescriptorHasColors(STDOUT_FILENO);
419}
420
421bool Process::StandardErrHasColors() {
422  return FileDescriptorHasColors(STDERR_FILENO);
423}
424
425void Process::UseANSIEscapeCodes(bool /*enable*/) {
426  // No effect.
427}
428
429bool Process::ColorNeedsFlush() {
430  // No, we use ANSI escape sequences.
431  return false;
432}
433
434const char *Process::OutputColor(char code, bool bold, bool bg) {
435  return colorcodes[bg?1:0][bold?1:0][code&7];
436}
437
438const char *Process::OutputBold(bool bg) {
439  return "\033[1m";
440}
441
442const char *Process::OutputReverse() {
443  return "\033[7m";
444}
445
446const char *Process::ResetColor() {
447  return "\033[0m";
448}
449
450#if !defined(HAVE_DECL_ARC4RANDOM) || !HAVE_DECL_ARC4RANDOM
451static unsigned GetRandomNumberSeed() {
452  // Attempt to get the initial seed from /dev/urandom, if possible.
453  if (FILE *RandomSource = ::fopen("/dev/urandom", "r")) {
454    unsigned seed;
455    int count = ::fread((void *)&seed, sizeof(seed), 1, RandomSource);
456    ::fclose(RandomSource);
457
458    // Return the seed if the read was successful.
459    if (count == 1)
460      return seed;
461  }
462
463  // Otherwise, swizzle the current time and the process ID to form a reasonable
464  // seed.
465  TimeValue Now = TimeValue::now();
466  return hash_combine(Now.seconds(), Now.nanoseconds(), ::getpid());
467}
468#endif
469
470unsigned llvm::sys::Process::GetRandomNumber() {
471#if defined(HAVE_DECL_ARC4RANDOM) && HAVE_DECL_ARC4RANDOM
472  return arc4random();
473#else
474  static int x = (::srand(GetRandomNumberSeed()), 0);
475  (void)x;
476  return ::rand();
477#endif
478}
479