libsanitizer/tsan/tsan_platform_linux.cc

   1 //===-- tsan_platform_linux.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 a part of ThreadSanitizer (TSan), a race detector.
   9 //
  10 // Linux-specific code.
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifdef __linux__
  14
  15 #include "sanitizer_common/sanitizer_common.h"
  16 #include "sanitizer_common/sanitizer_libc.h"
  17 #include "sanitizer_common/sanitizer_procmaps.h"
  18 #include "tsan_platform.h"
  19 #include "tsan_rtl.h"
  20 #include "tsan_flags.h"
  21
  22 #include <asm/prctl.h>
  23 #include <fcntl.h>
  24 #include <pthread.h>
  25 #include <signal.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <stdarg.h>
  30 #include <sys/mman.h>
  31 #include <sys/prctl.h>
  32 #include <sys/syscall.h>
  33 #include <sys/time.h>
  34 #include <sys/types.h>
  35 #include <sys/resource.h>
  36 #include <sys/stat.h>
  37 #include <unistd.h>
  38 #include <errno.h>
  39 #include <sched.h>
  40 #include <dlfcn.h>
  41
  42 extern "C" int arch_prctl(int code, __sanitizer::uptr *addr);
  43
  44 namespace __tsan {
  45
  46 #ifndef TSAN_GO
  47 ScopedInRtl::ScopedInRtl()
  48     : thr_(cur_thread()) {
  49   in_rtl_ = thr_->in_rtl;
  50   thr_->in_rtl++;
  51   errno_ = errno;
  52 }
  53
  54 ScopedInRtl::~ScopedInRtl() {
  55   thr_->in_rtl--;
  56   errno = errno_;
  57   CHECK_EQ(in_rtl_, thr_->in_rtl);
  58 }
  59 #else
  60 ScopedInRtl::ScopedInRtl() {
  61 }
  62
  63 ScopedInRtl::~ScopedInRtl() {
  64 }
  65 #endif
  66
  67 uptr GetShadowMemoryConsumption() {
  68   return 0;
  69 }
  70
  71 void FlushShadowMemory() {
  72   madvise((void*)kLinuxShadowBeg,
  73           kLinuxShadowEnd - kLinuxShadowBeg,
  74           MADV_DONTNEED);
  75 }
  76
  77 #ifndef TSAN_GO
  78 static void ProtectRange(uptr beg, uptr end) {
  79   ScopedInRtl in_rtl;
  80   CHECK_LE(beg, end);
  81   if (beg == end)
  82     return;
  83   if (beg != (uptr)Mprotect(beg, end - beg)) {
  84     Printf("FATAL: ThreadSanitizer can not protect [%zx,%zx]\n", beg, end);
  85     Printf("FATAL: Make sure you are not using unlimited stack\n");
  86     Die();
  87   }
  88 }
  89 #endif
  90
  91 #ifndef TSAN_GO
  92 void InitializeShadowMemory() {
  93   uptr shadow = (uptr)MmapFixedNoReserve(kLinuxShadowBeg,
  94     kLinuxShadowEnd - kLinuxShadowBeg);
  95   if (shadow != kLinuxShadowBeg) {
  96     Printf("FATAL: ThreadSanitizer can not mmap the shadow memory\n");
  97     Printf("FATAL: Make sure to compile with -fPIE and "
  98                "to link with -pie (%p, %p).\n", shadow, kLinuxShadowBeg);
  99     Die();
 100   }
 101   const uptr kClosedLowBeg  = 0x200000;
 102   const uptr kClosedLowEnd  = kLinuxShadowBeg - 1;
 103   const uptr kClosedMidBeg = kLinuxShadowEnd + 1;
 104   const uptr kClosedMidEnd = kLinuxAppMemBeg - 1;
 105   ProtectRange(kClosedLowBeg, kClosedLowEnd);
 106   ProtectRange(kClosedMidBeg, kClosedMidEnd);
 107   DPrintf("kClosedLow   %zx-%zx (%zuGB)\n",
 108       kClosedLowBeg, kClosedLowEnd, (kClosedLowEnd - kClosedLowBeg) >> 30);
 109   DPrintf("kLinuxShadow %zx-%zx (%zuGB)\n",
 110       kLinuxShadowBeg, kLinuxShadowEnd,
 111       (kLinuxShadowEnd - kLinuxShadowBeg) >> 30);
 112   DPrintf("kClosedMid   %zx-%zx (%zuGB)\n",
 113       kClosedMidBeg, kClosedMidEnd, (kClosedMidEnd - kClosedMidBeg) >> 30);
 114   DPrintf("kLinuxAppMem %zx-%zx (%zuGB)\n",
 115       kLinuxAppMemBeg, kLinuxAppMemEnd,
 116       (kLinuxAppMemEnd - kLinuxAppMemBeg) >> 30);
 117   DPrintf("stack        %zx\n", (uptr)&shadow);
 118 }
 119 #endif
 120
 121 static uptr g_data_start;
 122 static uptr g_data_end;
 123
 124 #ifndef TSAN_GO
 125 static void CheckPIE() {
 126   // Ensure that the binary is indeed compiled with -pie.
 127   MemoryMappingLayout proc_maps;
 128   uptr start, end;
 129   if (proc_maps.Next(&start, &end,
 130                      /*offset*/0, /*filename*/0, /*filename_size*/0)) {
 131     if ((u64)start < kLinuxAppMemBeg) {
 132       Printf("FATAL: ThreadSanitizer can not mmap the shadow memory ("
 133              "something is mapped at 0x%zx < 0x%zx)\n",
 134              start, kLinuxAppMemBeg);
 135       Printf("FATAL: Make sure to compile with -fPIE"
 136              " and to link with -pie.\n");
 137       Die();
 138     }
 139   }
 140 }
 141
 142 static void InitDataSeg() {
 143   MemoryMappingLayout proc_maps;
 144   uptr start, end, offset;
 145   char name[128];
 146   bool prev_is_data = false;
 147   while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name))) {
 148     DPrintf("%p-%p %p %s\n", start, end, offset, name);
 149     bool is_data = offset != 0 && name[0] != 0;
 150     // BSS may get merged with [heap] in /proc/self/maps. This is not very
 151     // reliable.
 152     bool is_bss = offset == 0 &&
 153       (name[0] == 0 || internal_strcmp(name, "[heap]") == 0) && prev_is_data;
 154     if (g_data_start == 0 && is_data)
 155       g_data_start = start;
 156     if (is_bss)
 157       g_data_end = end;
 158     prev_is_data = is_data;
 159   }
 160   DPrintf("guessed data_start=%p data_end=%p\n",  g_data_start, g_data_end);
 161   CHECK_LT(g_data_start, g_data_end);
 162   CHECK_GE((uptr)&g_data_start, g_data_start);
 163   CHECK_LT((uptr)&g_data_start, g_data_end);
 164 }
 165
 166 static uptr g_tls_size;
 167
 168 #ifdef __i386__
 169 # define INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
 170 #else
 171 # define INTERNAL_FUNCTION
 172 #endif
 173 extern "C" void _dl_get_tls_static_info(size_t*, size_t*)
 174     __attribute__((weak)) INTERNAL_FUNCTION;
 175
 176 static int InitTlsSize() {
 177   typedef void (*get_tls_func)(size_t*, size_t*) INTERNAL_FUNCTION;
 178   get_tls_func get_tls = &_dl_get_tls_static_info;
 179   if (get_tls == 0) {
 180     void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
 181     CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr));
 182     internal_memcpy(&get_tls, &get_tls_static_info_ptr,
 183                     sizeof(get_tls_static_info_ptr));
 184   }
 185   CHECK_NE(get_tls, 0);
 186   size_t tls_size = 0;
 187   size_t tls_align = 0;
 188   get_tls(&tls_size, &tls_align);
 189   return tls_size;
 190 }
 191 #endif  // #ifndef TSAN_GO
 192
 193 const char *InitializePlatform() {
 194   void *p = 0;
 195   if (sizeof(p) == 8) {
 196     // Disable core dumps, dumping of 16TB usually takes a bit long.
 197     // The following magic is to prevent clang from replacing it with memset.
 198     volatile rlimit lim;
 199     lim.rlim_cur = 0;
 200     lim.rlim_max = 0;
 201     setrlimit(RLIMIT_CORE, (rlimit*)&lim);
 202   }
 203   // TSan doesn't play well with unlimited stack size (as stack
 204   // overlaps with shadow memory). If we detect unlimited stack size,
 205   // we re-exec the program with limited stack size as a best effort.
 206   if (StackSizeIsUnlimited()) {
 207     const uptr kMaxStackSize = 32 * 1024 * 1024;  // 32 Mb
 208     Report("WARNING: Program is run with unlimited stack size, which "
 209            "wouldn't work with ThreadSanitizer.\n");
 210     Report("Re-execing with stack size limited to %zd bytes.\n", kMaxStackSize);
 211     SetStackSizeLimitInBytes(kMaxStackSize);
 212     ReExec();
 213   }
 214
 215 #ifndef TSAN_GO
 216   CheckPIE();
 217   g_tls_size = (uptr)InitTlsSize();
 218   InitDataSeg();
 219 #endif
 220   return getenv(kTsanOptionsEnv);
 221 }
 222
 223 void FinalizePlatform() {
 224   fflush(0);
 225 }
 226
 227 uptr GetTlsSize() {
 228 #ifndef TSAN_GO
 229   return g_tls_size;
 230 #else
 231   return 0;
 232 #endif
 233 }
 234
 235 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
 236                           uptr *tls_addr, uptr *tls_size) {
 237 #ifndef TSAN_GO
 238   arch_prctl(ARCH_GET_FS, tls_addr);
 239   *tls_addr -= g_tls_size;
 240   *tls_size = g_tls_size;
 241
 242   uptr stack_top, stack_bottom;
 243   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
 244   *stk_addr = stack_bottom;
 245   *stk_size = stack_top - stack_bottom;
 246
 247   if (!main) {
 248     // If stack and tls intersect, make them non-intersecting.
 249     if (*tls_addr > *stk_addr && *tls_addr < *stk_addr + *stk_size) {
 250       CHECK_GT(*tls_addr + *tls_size, *stk_addr);
 251       CHECK_LE(*tls_addr + *tls_size, *stk_addr + *stk_size);
 252       *stk_size -= *tls_size;
 253       *tls_addr = *stk_addr + *stk_size;
 254     }
 255   }
 256 #else
 257   *stk_addr = 0;
 258   *stk_size = 0;
 259   *tls_addr = 0;
 260   *tls_size = 0;
 261 #endif
 262 }
 263
 264 bool IsGlobalVar(uptr addr) {
 265   return g_data_start && addr >= g_data_start && addr < g_data_end;
 266 }
 267
 268 }  // namespace __tsan
 269
 270 #endif  // #ifdef __linux__