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 = min(kLinuxAppMemBeg, kTraceMemBegin);
 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 void MapThreadTrace(uptr addr, uptr size) {
 122   DPrintf("Mapping trace at %p-%p(0x%zx)\n", addr, addr + size, size);
 123   CHECK_GE(addr, kTraceMemBegin);
 124   CHECK_LE(addr + size, kTraceMemBegin + kTraceMemSize);
 125   if (addr != (uptr)MmapFixedNoReserve(addr, size)) {
 126     Printf("FATAL: ThreadSanitizer can not mmap thread trace\n");
 127     Die();
 128   }
 129 }
 130
 131 static uptr g_data_start;
 132 static uptr g_data_end;
 133
 134 #ifndef TSAN_GO
 135 static void CheckPIE() {
 136   // Ensure that the binary is indeed compiled with -pie.
 137   MemoryMappingLayout proc_maps;
 138   uptr start, end;
 139   if (proc_maps.Next(&start, &end,
 140                      /*offset*/0, /*filename*/0, /*filename_size*/0)) {
 141     if ((u64)start < kLinuxAppMemBeg) {
 142       Printf("FATAL: ThreadSanitizer can not mmap the shadow memory ("
 143              "something is mapped at 0x%zx < 0x%zx)\n",
 144              start, kLinuxAppMemBeg);
 145       Printf("FATAL: Make sure to compile with -fPIE"
 146              " and to link with -pie.\n");
 147       Die();
 148     }
 149   }
 150 }
 151
 152 static void InitDataSeg() {
 153   MemoryMappingLayout proc_maps;
 154   uptr start, end, offset;
 155   char name[128];
 156   bool prev_is_data = false;
 157   while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name))) {
 158     DPrintf("%p-%p %p %s\n", start, end, offset, name);
 159     bool is_data = offset != 0 && name[0] != 0;
 160     // BSS may get merged with [heap] in /proc/self/maps. This is not very
 161     // reliable.
 162     bool is_bss = offset == 0 &&
 163       (name[0] == 0 || internal_strcmp(name, "[heap]") == 0) && prev_is_data;
 164     if (g_data_start == 0 && is_data)
 165       g_data_start = start;
 166     if (is_bss)
 167       g_data_end = end;
 168     prev_is_data = is_data;
 169   }
 170   DPrintf("guessed data_start=%p data_end=%p\n",  g_data_start, g_data_end);
 171   CHECK_LT(g_data_start, g_data_end);
 172   CHECK_GE((uptr)&g_data_start, g_data_start);
 173   CHECK_LT((uptr)&g_data_start, g_data_end);
 174 }
 175
 176 static uptr g_tls_size;
 177
 178 #ifdef __i386__
 179 # define INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
 180 #else
 181 # define INTERNAL_FUNCTION
 182 #endif
 183 extern "C" void _dl_get_tls_static_info(size_t*, size_t*)
 184     __attribute__((weak)) INTERNAL_FUNCTION;
 185
 186 static int InitTlsSize() {
 187   typedef void (*get_tls_func)(size_t*, size_t*) INTERNAL_FUNCTION;
 188   get_tls_func get_tls = &_dl_get_tls_static_info;
 189   if (get_tls == 0) {
 190     void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
 191     CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr));
 192     internal_memcpy(&get_tls, &get_tls_static_info_ptr,
 193                     sizeof(get_tls_static_info_ptr));
 194   }
 195   CHECK_NE(get_tls, 0);
 196   size_t tls_size = 0;
 197   size_t tls_align = 0;
 198   get_tls(&tls_size, &tls_align);
 199   return tls_size;
 200 }
 201 #endif  // #ifndef TSAN_GO
 202
 203 static rlim_t getlim(int res) {
 204   rlimit rlim;
 205   CHECK_EQ(0, getrlimit(res, &rlim));
 206   return rlim.rlim_cur;
 207 }
 208
 209 static void setlim(int res, rlim_t lim) {
 210   // The following magic is to prevent clang from replacing it with memset.
 211   volatile rlimit rlim;
 212   rlim.rlim_cur = lim;
 213   rlim.rlim_max = lim;
 214   setrlimit(res, (rlimit*)&rlim);
 215 }
 216
 217 const char *InitializePlatform() {
 218   void *p = 0;
 219   if (sizeof(p) == 8) {
 220     // Disable core dumps, dumping of 16TB usually takes a bit long.
 221     setlim(RLIMIT_CORE, 0);
 222   }
 223   bool reexec = false;
 224   // TSan doesn't play well with unlimited stack size (as stack
 225   // overlaps with shadow memory). If we detect unlimited stack size,
 226   // we re-exec the program with limited stack size as a best effort.
 227   if (getlim(RLIMIT_STACK) == (rlim_t)-1) {
 228     const uptr kMaxStackSize = 32 * 1024 * 1024;
 229     Report("WARNING: Program is run with unlimited stack size, which "
 230            "wouldn't work with ThreadSanitizer.\n");
 231     Report("Re-execing with stack size limited to %zd bytes.\n", kMaxStackSize);
 232     SetStackSizeLimitInBytes(kMaxStackSize);
 233     reexec = true;
 234   }
 235
 236   if (getlim(RLIMIT_AS) != (rlim_t)-1) {
 237     Report("WARNING: Program is run with limited virtual address space, which "
 238            "wouldn't work with ThreadSanitizer.\n");
 239     Report("Re-execing with unlimited virtual address space.\n");
 240     setlim(RLIMIT_AS, -1);
 241     reexec = true;
 242   }
 243
 244   if (reexec)
 245     ReExec();
 246
 247 #ifndef TSAN_GO
 248   CheckPIE();
 249   g_tls_size = (uptr)InitTlsSize();
 250   InitDataSeg();
 251 #endif
 252   return getenv(kTsanOptionsEnv);
 253 }
 254
 255 void FinalizePlatform() {
 256   fflush(0);
 257 }
 258
 259 uptr GetTlsSize() {
 260 #ifndef TSAN_GO
 261   return g_tls_size;
 262 #else
 263   return 0;
 264 #endif
 265 }
 266
 267 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
 268                           uptr *tls_addr, uptr *tls_size) {
 269 #ifndef TSAN_GO
 270   arch_prctl(ARCH_GET_FS, tls_addr);
 271   *tls_addr -= g_tls_size;
 272   *tls_size = g_tls_size;
 273
 274   uptr stack_top, stack_bottom;
 275   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
 276   *stk_addr = stack_bottom;
 277   *stk_size = stack_top - stack_bottom;
 278
 279   if (!main) {
 280     // If stack and tls intersect, make them non-intersecting.
 281     if (*tls_addr > *stk_addr && *tls_addr < *stk_addr + *stk_size) {
 282       CHECK_GT(*tls_addr + *tls_size, *stk_addr);
 283       CHECK_LE(*tls_addr + *tls_size, *stk_addr + *stk_size);
 284       *stk_size -= *tls_size;
 285       *tls_addr = *stk_addr + *stk_size;
 286     }
 287   }
 288 #else
 289   *stk_addr = 0;
 290   *stk_size = 0;
 291   *tls_addr = 0;
 292   *tls_size = 0;
 293 #endif
 294 }
 295
 296 bool IsGlobalVar(uptr addr) {
 297   return g_data_start && addr >= g_data_start && addr < g_data_end;
 298 }
 299
 300 }  // namespace __tsan
 301
 302 #endif  // #ifdef __linux__