Home | History | Annotate | Download | only in rtl
      1 //===-- tsan_interface_java.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 a part of ThreadSanitizer (TSan), a race detector.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "tsan_interface_java.h"
     15 #include "tsan_rtl.h"
     16 #include "tsan_mutex.h"
     17 #include "sanitizer_common/sanitizer_internal_defs.h"
     18 #include "sanitizer_common/sanitizer_common.h"
     19 #include "sanitizer_common/sanitizer_placement_new.h"
     20 #include "sanitizer_common/sanitizer_stacktrace.h"
     21 #include "sanitizer_common/sanitizer_procmaps.h"
     22 
     23 using namespace __tsan;  // NOLINT
     24 
     25 const jptr kHeapAlignment = 8;
     26 
     27 namespace __tsan {
     28 
     29 struct JavaContext {
     30   const uptr heap_begin;
     31   const uptr heap_size;
     32 
     33   JavaContext(jptr heap_begin, jptr heap_size)
     34       : heap_begin(heap_begin)
     35       , heap_size(heap_size) {
     36   }
     37 };
     38 
     39 class ScopedJavaFunc {
     40  public:
     41   ScopedJavaFunc(ThreadState *thr, uptr pc)
     42       : thr_(thr) {
     43     Initialize(thr_);
     44     FuncEntry(thr, pc);
     45   }
     46 
     47   ~ScopedJavaFunc() {
     48     FuncExit(thr_);
     49     // FIXME(dvyukov): process pending signals.
     50   }
     51 
     52  private:
     53   ThreadState *thr_;
     54 };
     55 
     56 static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1];
     57 static JavaContext *jctx;
     58 
     59 }  // namespace __tsan
     60 
     61 #define SCOPED_JAVA_FUNC(func) \
     62   ThreadState *thr = cur_thread(); \
     63   const uptr caller_pc = GET_CALLER_PC(); \
     64   const uptr pc = StackTrace::GetCurrentPc(); \
     65   (void)pc; \
     66   ScopedJavaFunc scoped(thr, caller_pc); \
     67 /**/
     68 
     69 void __tsan_java_init(jptr heap_begin, jptr heap_size) {
     70   SCOPED_JAVA_FUNC(__tsan_java_init);
     71   DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size);
     72   CHECK_EQ(jctx, 0);
     73   CHECK_GT(heap_begin, 0);
     74   CHECK_GT(heap_size, 0);
     75   CHECK_EQ(heap_begin % kHeapAlignment, 0);
     76   CHECK_EQ(heap_size % kHeapAlignment, 0);
     77   CHECK_LT(heap_begin, heap_begin + heap_size);
     78   jctx = new(jctx_buf) JavaContext(heap_begin, heap_size);
     79 }
     80 
     81 int  __tsan_java_fini() {
     82   SCOPED_JAVA_FUNC(__tsan_java_fini);
     83   DPrintf("#%d: java_fini()\n", thr->tid);
     84   CHECK_NE(jctx, 0);
     85   // FIXME(dvyukov): this does not call atexit() callbacks.
     86   int status = Finalize(thr);
     87   DPrintf("#%d: java_fini() = %d\n", thr->tid, status);
     88   return status;
     89 }
     90 
     91 void __tsan_java_alloc(jptr ptr, jptr size) {
     92   SCOPED_JAVA_FUNC(__tsan_java_alloc);
     93   DPrintf("#%d: java_alloc(%p, %p)\n", thr->tid, ptr, size);
     94   CHECK_NE(jctx, 0);
     95   CHECK_NE(size, 0);
     96   CHECK_EQ(ptr % kHeapAlignment, 0);
     97   CHECK_EQ(size % kHeapAlignment, 0);
     98   CHECK_GE(ptr, jctx->heap_begin);
     99   CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
    100 
    101   OnUserAlloc(thr, pc, ptr, size, false);
    102 }
    103 
    104 void __tsan_java_free(jptr ptr, jptr size) {
    105   SCOPED_JAVA_FUNC(__tsan_java_free);
    106   DPrintf("#%d: java_free(%p, %p)\n", thr->tid, ptr, size);
    107   CHECK_NE(jctx, 0);
    108   CHECK_NE(size, 0);
    109   CHECK_EQ(ptr % kHeapAlignment, 0);
    110   CHECK_EQ(size % kHeapAlignment, 0);
    111   CHECK_GE(ptr, jctx->heap_begin);
    112   CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
    113 
    114   ctx->metamap.FreeRange(thr, pc, ptr, size);
    115 }
    116 
    117 void __tsan_java_move(jptr src, jptr dst, jptr size) {
    118   SCOPED_JAVA_FUNC(__tsan_java_move);
    119   DPrintf("#%d: java_move(%p, %p, %p)\n", thr->tid, src, dst, size);
    120   CHECK_NE(jctx, 0);
    121   CHECK_NE(size, 0);
    122   CHECK_EQ(src % kHeapAlignment, 0);
    123   CHECK_EQ(dst % kHeapAlignment, 0);
    124   CHECK_EQ(size % kHeapAlignment, 0);
    125   CHECK_GE(src, jctx->heap_begin);
    126   CHECK_LE(src + size, jctx->heap_begin + jctx->heap_size);
    127   CHECK_GE(dst, jctx->heap_begin);
    128   CHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);
    129   CHECK_NE(dst, src);
    130   CHECK_NE(size, 0);
    131 
    132   // Assuming it's not running concurrently with threads that do
    133   // memory accesses and mutex operations (stop-the-world phase).
    134   ctx->metamap.MoveMemory(src, dst, size);
    135 
    136   // Move shadow.
    137   u64 *s = (u64*)MemToShadow(src);
    138   u64 *d = (u64*)MemToShadow(dst);
    139   u64 *send = (u64*)MemToShadow(src + size);
    140   uptr inc = 1;
    141   if (dst > src) {
    142     s = (u64*)MemToShadow(src + size) - 1;
    143     d = (u64*)MemToShadow(dst + size) - 1;
    144     send = (u64*)MemToShadow(src) - 1;
    145     inc = -1;
    146   }
    147   for (; s != send; s += inc, d += inc) {
    148     *d = *s;
    149     *s = 0;
    150   }
    151 }
    152 
    153 void __tsan_java_finalize() {
    154   SCOPED_JAVA_FUNC(__tsan_java_finalize);
    155   DPrintf("#%d: java_mutex_finalize()\n", thr->tid);
    156   AcquireGlobal(thr, 0);
    157 }
    158 
    159 void __tsan_java_mutex_lock(jptr addr) {
    160   SCOPED_JAVA_FUNC(__tsan_java_mutex_lock);
    161   DPrintf("#%d: java_mutex_lock(%p)\n", thr->tid, addr);
    162   CHECK_NE(jctx, 0);
    163   CHECK_GE(addr, jctx->heap_begin);
    164   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    165 
    166   MutexCreate(thr, pc, addr, true, true, true);
    167   MutexLock(thr, pc, addr);
    168 }
    169 
    170 void __tsan_java_mutex_unlock(jptr addr) {
    171   SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock);
    172   DPrintf("#%d: java_mutex_unlock(%p)\n", thr->tid, addr);
    173   CHECK_NE(jctx, 0);
    174   CHECK_GE(addr, jctx->heap_begin);
    175   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    176 
    177   MutexUnlock(thr, pc, addr);
    178 }
    179 
    180 void __tsan_java_mutex_read_lock(jptr addr) {
    181   SCOPED_JAVA_FUNC(__tsan_java_mutex_read_lock);
    182   DPrintf("#%d: java_mutex_read_lock(%p)\n", thr->tid, addr);
    183   CHECK_NE(jctx, 0);
    184   CHECK_GE(addr, jctx->heap_begin);
    185   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    186 
    187   MutexCreate(thr, pc, addr, true, true, true);
    188   MutexReadLock(thr, pc, addr);
    189 }
    190 
    191 void __tsan_java_mutex_read_unlock(jptr addr) {
    192   SCOPED_JAVA_FUNC(__tsan_java_mutex_read_unlock);
    193   DPrintf("#%d: java_mutex_read_unlock(%p)\n", thr->tid, addr);
    194   CHECK_NE(jctx, 0);
    195   CHECK_GE(addr, jctx->heap_begin);
    196   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    197 
    198   MutexReadUnlock(thr, pc, addr);
    199 }
    200 
    201 void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
    202   SCOPED_JAVA_FUNC(__tsan_java_mutex_lock_rec);
    203   DPrintf("#%d: java_mutex_lock_rec(%p, %d)\n", thr->tid, addr, rec);
    204   CHECK_NE(jctx, 0);
    205   CHECK_GE(addr, jctx->heap_begin);
    206   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    207   CHECK_GT(rec, 0);
    208 
    209   MutexCreate(thr, pc, addr, true, true, true);
    210   MutexLock(thr, pc, addr, rec);
    211 }
    212 
    213 int __tsan_java_mutex_unlock_rec(jptr addr) {
    214   SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock_rec);
    215   DPrintf("#%d: java_mutex_unlock_rec(%p)\n", thr->tid, addr);
    216   CHECK_NE(jctx, 0);
    217   CHECK_GE(addr, jctx->heap_begin);
    218   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    219 
    220   return MutexUnlock(thr, pc, addr, true);
    221 }
    222 
    223 void __tsan_java_acquire(jptr addr) {
    224   SCOPED_JAVA_FUNC(__tsan_java_acquire);
    225   DPrintf("#%d: java_acquire(%p)\n", thr->tid, addr);
    226   CHECK_NE(jctx, 0);
    227   CHECK_GE(addr, jctx->heap_begin);
    228   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    229 
    230   Acquire(thr, caller_pc, addr);
    231 }
    232 
    233 void __tsan_java_release(jptr addr) {
    234   SCOPED_JAVA_FUNC(__tsan_java_release);
    235   DPrintf("#%d: java_release(%p)\n", thr->tid, addr);
    236   CHECK_NE(jctx, 0);
    237   CHECK_GE(addr, jctx->heap_begin);
    238   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    239 
    240   Release(thr, caller_pc, addr);
    241 }
    242 
    243 void __tsan_java_release_store(jptr addr) {
    244   SCOPED_JAVA_FUNC(__tsan_java_release);
    245   DPrintf("#%d: java_release_store(%p)\n", thr->tid, addr);
    246   CHECK_NE(jctx, 0);
    247   CHECK_GE(addr, jctx->heap_begin);
    248   CHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
    249 
    250   ReleaseStore(thr, caller_pc, addr);
    251 }
    252