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
