contrib/compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

   1 //===-- sanitizer_posix_libcdep.cc ----------------------------------------===//
   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 is shared between AddressSanitizer and ThreadSanitizer
  11 // run-time libraries and implements libc-dependent POSIX-specific functions
  12 // from sanitizer_libc.h.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "sanitizer_platform.h"
  16
  17 #if SANITIZER_POSIX
  18 #include "sanitizer_common.h"
  19 #include "sanitizer_flags.h"
  20 #include "sanitizer_platform_limits_posix.h"
  21 #include "sanitizer_stacktrace.h"
  22
  23 #include <errno.h>
  24 #include <pthread.h>
  25 #include <signal.h>
  26 #include <stdlib.h>
  27 #include <sys/mman.h>
  28 #include <sys/resource.h>
  29 #include <sys/time.h>
  30 #include <sys/types.h>
  31 #include <unistd.h>
  32
  33 namespace __sanitizer {
  34
  35 u32 GetUid() {
  36   return getuid();
  37 }
  38
  39 uptr GetThreadSelf() {
  40   return (uptr)pthread_self();
  41 }
  42
  43 void FlushUnneededShadowMemory(uptr addr, uptr size) {
  44   madvise((void*)addr, size, MADV_DONTNEED);
  45 }
  46
  47 static rlim_t getlim(int res) {
  48   rlimit rlim;
  49   CHECK_EQ(0, getrlimit(res, &rlim));
  50   return rlim.rlim_cur;
  51 }
  52
  53 static void setlim(int res, rlim_t lim) {
  54   // The following magic is to prevent clang from replacing it with memset.
  55   volatile struct rlimit rlim;
  56   rlim.rlim_cur = lim;
  57   rlim.rlim_max = lim;
  58   if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) {
  59     Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno);
  60     Die();
  61   }
  62 }
  63
  64 void DisableCoreDumperIfNecessary() {
  65   if (common_flags()->disable_coredump) {
  66     setlim(RLIMIT_CORE, 0);
  67   }
  68 }
  69
  70 bool StackSizeIsUnlimited() {
  71   rlim_t stack_size = getlim(RLIMIT_STACK);
  72   return (stack_size == RLIM_INFINITY);
  73 }
  74
  75 void SetStackSizeLimitInBytes(uptr limit) {
  76   setlim(RLIMIT_STACK, (rlim_t)limit);
  77   CHECK(!StackSizeIsUnlimited());
  78 }
  79
  80 bool AddressSpaceIsUnlimited() {
  81   rlim_t as_size = getlim(RLIMIT_AS);
  82   return (as_size == RLIM_INFINITY);
  83 }
  84
  85 void SetAddressSpaceUnlimited() {
  86   setlim(RLIMIT_AS, RLIM_INFINITY);
  87   CHECK(AddressSpaceIsUnlimited());
  88 }
  89
  90 void SleepForSeconds(int seconds) {
  91   sleep(seconds);
  92 }
  93
  94 void SleepForMillis(int millis) {
  95   usleep(millis * 1000);
  96 }
  97
  98 void Abort() {
  99   abort();
 100 }
 101
 102 int Atexit(void (*function)(void)) {
 103 #ifndef SANITIZER_GO
 104   return atexit(function);
 105 #else
 106   return 0;
 107 #endif
 108 }
 109
 110 int internal_isatty(fd_t fd) {
 111   return isatty(fd);
 112 }
 113
 114 #ifndef SANITIZER_GO
 115 // TODO(glider): different tools may require different altstack size.
 116 static const uptr kAltStackSize = SIGSTKSZ * 4;  // SIGSTKSZ is not enough.
 117
 118 void SetAlternateSignalStack() {
 119   stack_t altstack, oldstack;
 120   CHECK_EQ(0, sigaltstack(0, &oldstack));
 121   // If the alternate stack is already in place, do nothing.
 122   // Android always sets an alternate stack, but it's too small for us.
 123   if (!SANITIZER_ANDROID && !(oldstack.ss_flags & SS_DISABLE)) return;
 124   // TODO(glider): the mapped stack should have the MAP_STACK flag in the
 125   // future. It is not required by man 2 sigaltstack now (they're using
 126   // malloc()).
 127   void* base = MmapOrDie(kAltStackSize, __func__);
 128   altstack.ss_sp = (char*) base;
 129   altstack.ss_flags = 0;
 130   altstack.ss_size = kAltStackSize;
 131   CHECK_EQ(0, sigaltstack(&altstack, 0));
 132 }
 133
 134 void UnsetAlternateSignalStack() {
 135   stack_t altstack, oldstack;
 136   altstack.ss_sp = 0;
 137   altstack.ss_flags = SS_DISABLE;
 138   altstack.ss_size = kAltStackSize;  // Some sane value required on Darwin.
 139   CHECK_EQ(0, sigaltstack(&altstack, &oldstack));
 140   UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);
 141 }
 142
 143 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
 144 static void MaybeInstallSigaction(int signum,
 145                                   SignalHandlerType handler) {
 146   if (!IsDeadlySignal(signum))
 147     return;
 148   struct sigaction sigact;
 149   internal_memset(&sigact, 0, sizeof(sigact));
 150   sigact.sa_sigaction = (sa_sigaction_t)handler;
 151   // Do not block the signal from being received in that signal's handler.
 152   // Clients are responsible for handling this correctly.
 153   sigact.sa_flags = SA_SIGINFO | SA_NODEFER;
 154   if (common_flags()->use_sigaltstack) sigact.sa_flags |= SA_ONSTACK;
 155   CHECK_EQ(0, internal_sigaction(signum, &sigact, 0));
 156   VReport(1, "Installed the sigaction for signal %d\n", signum);
 157 }
 158
 159 void InstallDeadlySignalHandlers(SignalHandlerType handler) {
 160   // Set the alternate signal stack for the main thread.
 161   // This will cause SetAlternateSignalStack to be called twice, but the stack
 162   // will be actually set only once.
 163   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
 164   MaybeInstallSigaction(SIGSEGV, handler);
 165   MaybeInstallSigaction(SIGBUS, handler);
 166 }
 167 #endif  // SANITIZER_GO
 168
 169 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
 170   uptr page_size = GetPageSizeCached();
 171   // Checking too large memory ranges is slow.
 172   CHECK_LT(size, page_size * 10);
 173   int sock_pair[2];
 174   if (pipe(sock_pair))
 175     return false;
 176   uptr bytes_written =
 177       internal_write(sock_pair[1], reinterpret_cast<void *>(beg), size);
 178   int write_errno;
 179   bool result;
 180   if (internal_iserror(bytes_written, &write_errno)) {
 181     CHECK_EQ(EFAULT, write_errno);
 182     result = false;
 183   } else {
 184     result = (bytes_written == size);
 185   }
 186   internal_close(sock_pair[0]);
 187   internal_close(sock_pair[1]);
 188   return result;
 189 }
 190
 191 }  // namespace __sanitizer
 192
 193 #endif  // SANITIZER_POSIX