libsanitizer/sanitizer_common/sanitizer_posix_libcdep.cc

   1 //===-- sanitizer_posix_libcdep.cc ----------------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is shared between AddressSanitizer and ThreadSanitizer
   9 // run-time libraries and implements libc-dependent POSIX-specific functions
  10 // from sanitizer_libc.h.
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "sanitizer_platform.h"
  14
  15 #if SANITIZER_POSIX
  16
  17 #include "sanitizer_common.h"
  18 #include "sanitizer_flags.h"
  19 #include "sanitizer_platform_limits_posix.h"
  20 #include "sanitizer_posix.h"
  21 #include "sanitizer_procmaps.h"
  22 #include "sanitizer_stacktrace.h"
  23 #include "sanitizer_symbolizer.h"
  24
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <pthread.h>
  28 #include <signal.h>
  29 #include <stdlib.h>
  30 #include <sys/mman.h>
  31 #include <sys/resource.h>
  32 #include <sys/stat.h>
  33 #include <sys/time.h>
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36 #include <unistd.h>
  37
  38 #if SANITIZER_FREEBSD
  39 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
  40 // that, it was never implemented.  So just define it to zero.
  41 #undef  MAP_NORESERVE
  42 #define MAP_NORESERVE 0
  43 #endif
  44
  45 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
  46
  47 namespace __sanitizer {
  48
  49 u32 GetUid() {
  50   return getuid();
  51 }
  52
  53 uptr GetThreadSelf() {
  54   return (uptr)pthread_self();
  55 }
  56
  57 void ReleaseMemoryToOS(uptr addr, uptr size) {
  58   madvise((void*)addr, size, MADV_DONTNEED);
  59 }
  60
  61 void NoHugePagesInRegion(uptr addr, uptr size) {
  62 #ifdef MADV_NOHUGEPAGE  // May not be defined on old systems.
  63   madvise((void *)addr, size, MADV_NOHUGEPAGE);
  64 #endif  // MADV_NOHUGEPAGE
  65 }
  66
  67 void DontDumpShadowMemory(uptr addr, uptr length) {
  68 #ifdef MADV_DONTDUMP
  69   madvise((void *)addr, length, MADV_DONTDUMP);
  70 #endif
  71 }
  72
  73 static rlim_t getlim(int res) {
  74   rlimit rlim;
  75   CHECK_EQ(0, getrlimit(res, &rlim));
  76   return rlim.rlim_cur;
  77 }
  78
  79 static void setlim(int res, rlim_t lim) {
  80   // The following magic is to prevent clang from replacing it with memset.
  81   volatile struct rlimit rlim;
  82   rlim.rlim_cur = lim;
  83   rlim.rlim_max = lim;
  84   if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) {
  85     Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno);
  86     Die();
  87   }
  88 }
  89
  90 void DisableCoreDumperIfNecessary() {
  91   if (common_flags()->disable_coredump) {
  92     setlim(RLIMIT_CORE, 0);
  93   }
  94 }
  95
  96 bool StackSizeIsUnlimited() {
  97   rlim_t stack_size = getlim(RLIMIT_STACK);
  98   return (stack_size == RLIM_INFINITY);
  99 }
 100
 101 uptr GetStackSizeLimitInBytes() {
 102   return (uptr)getlim(RLIMIT_STACK);
 103 }
 104
 105 void SetStackSizeLimitInBytes(uptr limit) {
 106   setlim(RLIMIT_STACK, (rlim_t)limit);
 107   CHECK(!StackSizeIsUnlimited());
 108 }
 109
 110 bool AddressSpaceIsUnlimited() {
 111   rlim_t as_size = getlim(RLIMIT_AS);
 112   return (as_size == RLIM_INFINITY);
 113 }
 114
 115 void SetAddressSpaceUnlimited() {
 116   setlim(RLIMIT_AS, RLIM_INFINITY);
 117   CHECK(AddressSpaceIsUnlimited());
 118 }
 119
 120 void SleepForSeconds(int seconds) {
 121   sleep(seconds);
 122 }
 123
 124 void SleepForMillis(int millis) {
 125   usleep(millis * 1000);
 126 }
 127
 128 void Abort() {
 129 #if !SANITIZER_GO
 130   // If we are handling SIGABRT, unhandle it first.
 131   if (IsHandledDeadlySignal(SIGABRT)) {
 132     struct sigaction sigact;
 133     internal_memset(&sigact, 0, sizeof(sigact));
 134     sigact.sa_sigaction = (sa_sigaction_t)SIG_DFL;
 135     internal_sigaction(SIGABRT, &sigact, nullptr);
 136   }
 137 #endif
 138
 139   abort();
 140 }
 141
 142 int Atexit(void (*function)(void)) {
 143 #if !SANITIZER_GO
 144   return atexit(function);
 145 #else
 146   return 0;
 147 #endif
 148 }
 149
 150 bool SupportsColoredOutput(fd_t fd) {
 151   return isatty(fd) != 0;
 152 }
 153
 154 #if !SANITIZER_GO
 155 // TODO(glider): different tools may require different altstack size.
 156 static const uptr kAltStackSize = SIGSTKSZ * 4;  // SIGSTKSZ is not enough.
 157
 158 void SetAlternateSignalStack() {
 159   stack_t altstack, oldstack;
 160   CHECK_EQ(0, sigaltstack(nullptr, &oldstack));
 161   // If the alternate stack is already in place, do nothing.
 162   // Android always sets an alternate stack, but it's too small for us.
 163   if (!SANITIZER_ANDROID && !(oldstack.ss_flags & SS_DISABLE)) return;
 164   // TODO(glider): the mapped stack should have the MAP_STACK flag in the
 165   // future. It is not required by man 2 sigaltstack now (they're using
 166   // malloc()).
 167   void* base = MmapOrDie(kAltStackSize, __func__);
 168   altstack.ss_sp = (char*) base;
 169   altstack.ss_flags = 0;
 170   altstack.ss_size = kAltStackSize;
 171   CHECK_EQ(0, sigaltstack(&altstack, nullptr));
 172 }
 173
 174 void UnsetAlternateSignalStack() {
 175   stack_t altstack, oldstack;
 176   altstack.ss_sp = nullptr;
 177   altstack.ss_flags = SS_DISABLE;
 178   altstack.ss_size = kAltStackSize;  // Some sane value required on Darwin.
 179   CHECK_EQ(0, sigaltstack(&altstack, &oldstack));
 180   UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);
 181 }
 182
 183 static void MaybeInstallSigaction(int signum,
 184                                   SignalHandlerType handler) {
 185   if (!IsHandledDeadlySignal(signum))
 186     return;
 187   struct sigaction sigact;
 188   internal_memset(&sigact, 0, sizeof(sigact));
 189   sigact.sa_sigaction = (sa_sigaction_t)handler;
 190   // Do not block the signal from being received in that signal's handler.
 191   // Clients are responsible for handling this correctly.
 192   sigact.sa_flags = SA_SIGINFO | SA_NODEFER;
 193   if (common_flags()->use_sigaltstack) sigact.sa_flags |= SA_ONSTACK;
 194   CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));
 195   VReport(1, "Installed the sigaction for signal %d\n", signum);
 196 }
 197
 198 void InstallDeadlySignalHandlers(SignalHandlerType handler) {
 199   // Set the alternate signal stack for the main thread.
 200   // This will cause SetAlternateSignalStack to be called twice, but the stack
 201   // will be actually set only once.
 202   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
 203   MaybeInstallSigaction(SIGSEGV, handler);
 204   MaybeInstallSigaction(SIGBUS, handler);
 205   MaybeInstallSigaction(SIGABRT, handler);
 206   MaybeInstallSigaction(SIGFPE, handler);
 207   MaybeInstallSigaction(SIGILL, handler);
 208 }
 209 #endif  // SANITIZER_GO
 210
 211 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
 212   uptr page_size = GetPageSizeCached();
 213   // Checking too large memory ranges is slow.
 214   CHECK_LT(size, page_size * 10);
 215   int sock_pair[2];
 216   if (pipe(sock_pair))
 217     return false;
 218   uptr bytes_written =
 219       internal_write(sock_pair[1], reinterpret_cast<void *>(beg), size);
 220   int write_errno;
 221   bool result;
 222   if (internal_iserror(bytes_written, &write_errno)) {
 223     CHECK_EQ(EFAULT, write_errno);
 224     result = false;
 225   } else {
 226     result = (bytes_written == size);
 227   }
 228   internal_close(sock_pair[0]);
 229   internal_close(sock_pair[1]);
 230   return result;
 231 }
 232
 233 void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
 234   // Some kinds of sandboxes may forbid filesystem access, so we won't be able
 235   // to read the file mappings from /proc/self/maps. Luckily, neither the
 236   // process will be able to load additional libraries, so it's fine to use the
 237   // cached mappings.
 238   MemoryMappingLayout::CacheMemoryMappings();
 239   // Same for /proc/self/exe in the symbolizer.
 240 #if !SANITIZER_GO
 241   Symbolizer::GetOrInit()->PrepareForSandboxing();
 242   CovPrepareForSandboxing(args);
 243 #endif
 244 }
 245
 246 #if SANITIZER_ANDROID || SANITIZER_GO
 247 int GetNamedMappingFd(const char *name, uptr size) {
 248   return -1;
 249 }
 250 #else
 251 int GetNamedMappingFd(const char *name, uptr size) {
 252   if (!common_flags()->decorate_proc_maps)
 253     return -1;
 254   char shmname[200];
 255   CHECK(internal_strlen(name) < sizeof(shmname) - 10);
 256   internal_snprintf(shmname, sizeof(shmname), "%zu [%s]", internal_getpid(),
 257                     name);
 258   int fd = shm_open(shmname, O_RDWR | O_CREAT | O_TRUNC, S_IRWXU);
 259   CHECK_GE(fd, 0);
 260   int res = internal_ftruncate(fd, size);
 261   CHECK_EQ(0, res);
 262   res = shm_unlink(shmname);
 263   CHECK_EQ(0, res);
 264   return fd;
 265 }
 266 #endif
 267
 268 void *MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) {
 269   int fd = name ? GetNamedMappingFd(name, size) : -1;
 270   unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE;
 271   if (fd == -1) flags |= MAP_ANON;
 272
 273   uptr PageSize = GetPageSizeCached();
 274   uptr p = internal_mmap((void *)(fixed_addr & ~(PageSize - 1)),
 275                          RoundUpTo(size, PageSize), PROT_READ | PROT_WRITE,
 276                          flags, fd, 0);
 277   int reserrno;
 278   if (internal_iserror(p, &reserrno))
 279     Report("ERROR: %s failed to "
 280            "allocate 0x%zx (%zd) bytes at address %zx (errno: %d)\n",
 281            SanitizerToolName, size, size, fixed_addr, reserrno);
 282   IncreaseTotalMmap(size);
 283   return (void *)p;
 284 }
 285
 286 void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) {
 287   int fd = name ? GetNamedMappingFd(name, size) : -1;
 288   unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE;
 289   if (fd == -1) flags |= MAP_ANON;
 290
 291   return (void *)internal_mmap((void *)fixed_addr, size, PROT_NONE, flags, fd,
 292                                0);
 293 }
 294
 295 void *MmapNoAccess(uptr size) {
 296   unsigned flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE;
 297   return (void *)internal_mmap(nullptr, size, PROT_NONE, flags, -1, 0);
 298 }
 299
 300 // This function is defined elsewhere if we intercepted pthread_attr_getstack.
 301 extern "C" {
 302 SANITIZER_WEAK_ATTRIBUTE int
 303 real_pthread_attr_getstack(void *attr, void **addr, size_t *size);
 304 } // extern "C"
 305
 306 int my_pthread_attr_getstack(void *attr, void **addr, uptr *size) {
 307 #if !SANITIZER_GO && !SANITIZER_MAC
 308   if (&real_pthread_attr_getstack)
 309     return real_pthread_attr_getstack((pthread_attr_t *)attr, addr,
 310                                       (size_t *)size);
 311 #endif
 312   return pthread_attr_getstack((pthread_attr_t *)attr, addr, (size_t *)size);
 313 }
 314
 315 #if !SANITIZER_GO
 316 void AdjustStackSize(void *attr_) {
 317   pthread_attr_t *attr = (pthread_attr_t *)attr_;
 318   uptr stackaddr = 0;
 319   uptr stacksize = 0;
 320   my_pthread_attr_getstack(attr, (void**)&stackaddr, &stacksize);
 321   // GLibC will return (0 - stacksize) as the stack address in the case when
 322   // stacksize is set, but stackaddr is not.
 323   bool stack_set = (stackaddr != 0) && (stackaddr + stacksize != 0);
 324   // We place a lot of tool data into TLS, account for that.
 325   const uptr minstacksize = GetTlsSize() + 128*1024;
 326   if (stacksize < minstacksize) {
 327     if (!stack_set) {
 328       if (stacksize != 0) {
 329         VPrintf(1, "Sanitizer: increasing stacksize %zu->%zu\n", stacksize,
 330                 minstacksize);
 331         pthread_attr_setstacksize(attr, minstacksize);
 332       }
 333     } else {
 334       Printf("Sanitizer: pre-allocated stack size is insufficient: "
 335              "%zu < %zu\n", stacksize, minstacksize);
 336       Printf("Sanitizer: pthread_create is likely to fail.\n");
 337     }
 338   }
 339 }
 340 #endif // !SANITIZER_GO
 341
 342 pid_t StartSubprocess(const char *program, const char *const argv[],
 343                       fd_t stdin_fd, fd_t stdout_fd, fd_t stderr_fd) {
 344   auto file_closer = at_scope_exit([&] {
 345     if (stdin_fd != kInvalidFd) {
 346       internal_close(stdin_fd);
 347     }
 348     if (stdout_fd != kInvalidFd) {
 349       internal_close(stdout_fd);
 350     }
 351     if (stderr_fd != kInvalidFd) {
 352       internal_close(stderr_fd);
 353     }
 354   });
 355
 356   int pid = internal_fork();
 357
 358   if (pid < 0) {
 359     int rverrno;
 360     if (internal_iserror(pid, &rverrno)) {
 361       Report("WARNING: failed to fork (errno %d)\n", rverrno);
 362     }
 363     return pid;
 364   }
 365
 366   if (pid == 0) {
 367     // Child subprocess
 368     if (stdin_fd != kInvalidFd) {
 369       internal_close(STDIN_FILENO);
 370       internal_dup2(stdin_fd, STDIN_FILENO);
 371       internal_close(stdin_fd);
 372     }
 373     if (stdout_fd != kInvalidFd) {
 374       internal_close(STDOUT_FILENO);
 375       internal_dup2(stdout_fd, STDOUT_FILENO);
 376       internal_close(stdout_fd);
 377     }
 378     if (stderr_fd != kInvalidFd) {
 379       internal_close(STDERR_FILENO);
 380       internal_dup2(stderr_fd, STDERR_FILENO);
 381       internal_close(stderr_fd);
 382     }
 383
 384     for (int fd = sysconf(_SC_OPEN_MAX); fd > 2; fd--) internal_close(fd);
 385
 386     execv(program, const_cast<char **>(&argv[0]));
 387     internal__exit(1);
 388   }
 389
 390   return pid;
 391 }
 392
 393 bool IsProcessRunning(pid_t pid) {
 394   int process_status;
 395   uptr waitpid_status = internal_waitpid(pid, &process_status, WNOHANG);
 396   int local_errno;
 397   if (internal_iserror(waitpid_status, &local_errno)) {
 398     VReport(1, "Waiting on the process failed (errno %d).\n", local_errno);
 399     return false;
 400   }
 401   return waitpid_status == 0;
 402 }
 403
 404 int WaitForProcess(pid_t pid) {
 405   int process_status;
 406   uptr waitpid_status = internal_waitpid(pid, &process_status, 0);
 407   int local_errno;
 408   if (internal_iserror(waitpid_status, &local_errno)) {
 409     VReport(1, "Waiting on the process failed (errno %d).\n", local_errno);
 410     return -1;
 411   }
 412   return process_status;
 413 }
 414
 415 } // namespace __sanitizer
 416
 417 #endif // SANITIZER_POSIX