1 //===-- tsan_interface_java.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 //===----------------------------------------------------------------------===// 11 12 #include "tsan_interface_java.h" 13 #include "tsan_rtl.h" 14 #include "tsan_mutex.h" 15 #include "sanitizer_common/sanitizer_internal_defs.h" 16 #include "sanitizer_common/sanitizer_common.h" 17 #include "sanitizer_common/sanitizer_placement_new.h" 18 19 using namespace __tsan; // NOLINT 20 21 namespace __tsan { 22 23 const uptr kHeapShadow = 0x300000000000ull; 24 const uptr kHeapAlignment = 8; 25 26 struct BlockDesc { 27 bool begin; 28 Mutex mtx; 29 SyncVar *head; 30 31 BlockDesc() 32 : mtx(MutexTypeJavaMBlock, StatMtxJavaMBlock) 33 , head() { 34 CHECK_EQ(begin, false); 35 begin = true; 36 } 37 38 ~BlockDesc() { 39 CHECK_EQ(begin, true); 40 begin = false; 41 ThreadState *thr = cur_thread(); 42 SyncVar *s = head; 43 while (s) { 44 SyncVar *s1 = s->next; 45 StatInc(thr, StatSyncDestroyed); 46 s->mtx.Lock(); 47 s->mtx.Unlock(); 48 thr->mset.Remove(s->GetId()); 49 DestroyAndFree(s); 50 s = s1; 51 } 52 } 53 }; 54 55 struct JavaContext { 56 const uptr heap_begin; 57 const uptr heap_size; 58 BlockDesc *heap_shadow; 59 60 JavaContext(jptr heap_begin, jptr heap_size) 61 : heap_begin(heap_begin) 62 , heap_size(heap_size) { 63 uptr size = heap_size / kHeapAlignment * sizeof(BlockDesc); 64 heap_shadow = (BlockDesc*)MmapFixedNoReserve(kHeapShadow, size); 65 if ((uptr)heap_shadow != kHeapShadow) { 66 Printf("ThreadSanitizer: failed to mmap Java heap shadow\n"); 67 Die(); 68 } 69 } 70 }; 71 72 class ScopedJavaFunc { 73 public: 74 ScopedJavaFunc(ThreadState *thr, uptr pc) 75 : thr_(thr) { 76 Initialize(thr_); 77 FuncEntry(thr, pc); 78 CHECK_EQ(thr_->in_rtl, 0); 79 thr_->in_rtl++; 80 } 81 82 ~ScopedJavaFunc() { 83 thr_->in_rtl--; 84 CHECK_EQ(thr_->in_rtl, 0); 85 FuncExit(thr_); 86 // FIXME(dvyukov): process pending signals. 87 } 88 89 private: 90 ThreadState *thr_; 91 }; 92 93 static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1]; 94 static JavaContext *jctx; 95 96 static BlockDesc *getblock(uptr addr) { 97 uptr i = (addr - jctx->heap_begin) / kHeapAlignment; 98 return &jctx->heap_shadow[i]; 99 } 100 101 static uptr USED getmem(BlockDesc *b) { 102 uptr i = b - jctx->heap_shadow; 103 uptr p = jctx->heap_begin + i * kHeapAlignment; 104 CHECK_GE(p, jctx->heap_begin); 105 CHECK_LT(p, jctx->heap_begin + jctx->heap_size); 106 return p; 107 } 108 109 static BlockDesc *getblockbegin(uptr addr) { 110 for (BlockDesc *b = getblock(addr);; b--) { 111 CHECK_GE(b, jctx->heap_shadow); 112 if (b->begin) 113 return b; 114 } 115 return 0; 116 } 117 118 SyncVar* GetJavaSync(ThreadState *thr, uptr pc, uptr addr, 119 bool write_lock, bool create) { 120 if (jctx == 0 || addr < jctx->heap_begin 121 || addr >= jctx->heap_begin + jctx->heap_size) 122 return 0; 123 BlockDesc *b = getblockbegin(addr); 124 DPrintf("#%d: GetJavaSync %p->%p\n", thr->tid, addr, b); 125 Lock l(&b->mtx); 126 SyncVar *s = b->head; 127 for (; s; s = s->next) { 128 if (s->addr == addr) { 129 DPrintf("#%d: found existing sync for %p\n", thr->tid, addr); 130 break; 131 } 132 } 133 if (s == 0 && create) { 134 DPrintf("#%d: creating new sync for %p\n", thr->tid, addr); 135 s = CTX()->synctab.Create(thr, pc, addr); 136 s->next = b->head; 137 b->head = s; 138 } 139 if (s) { 140 if (write_lock) 141 s->mtx.Lock(); 142 else 143 s->mtx.ReadLock(); 144 } 145 return s; 146 } 147 148 SyncVar* GetAndRemoveJavaSync(ThreadState *thr, uptr pc, uptr addr) { 149 // We do not destroy Java mutexes other than in __tsan_java_free(). 150 return 0; 151 } 152 153 } // namespace __tsan 154 155 #define SCOPED_JAVA_FUNC(func) \ 156 ThreadState *thr = cur_thread(); \ 157 const uptr caller_pc = GET_CALLER_PC(); \ 158 const uptr pc = (uptr)&func; \ 159 (void)pc; \ 160 ScopedJavaFunc scoped(thr, caller_pc); \ 161 /**/ 162 163 void __tsan_java_init(jptr heap_begin, jptr heap_size) { 164 SCOPED_JAVA_FUNC(__tsan_java_init); 165 DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size); 166 CHECK_EQ(jctx, 0); 167 CHECK_GT(heap_begin, 0); 168 CHECK_GT(heap_size, 0); 169 CHECK_EQ(heap_begin % kHeapAlignment, 0); 170 CHECK_EQ(heap_size % kHeapAlignment, 0); 171 CHECK_LT(heap_begin, heap_begin + heap_size); 172 jctx = new(jctx_buf) JavaContext(heap_begin, heap_size); 173 } 174 175 int __tsan_java_fini() { 176 SCOPED_JAVA_FUNC(__tsan_java_fini); 177 DPrintf("#%d: java_fini()\n", thr->tid); 178 CHECK_NE(jctx, 0); 179 // FIXME(dvyukov): this does not call atexit() callbacks. 180 int status = Finalize(thr); 181 DPrintf("#%d: java_fini() = %d\n", thr->tid, status); 182 return status; 183 } 184 185 void __tsan_java_alloc(jptr ptr, jptr size) { 186 SCOPED_JAVA_FUNC(__tsan_java_alloc); 187 DPrintf("#%d: java_alloc(%p, %p)\n", thr->tid, ptr, size); 188 CHECK_NE(jctx, 0); 189 CHECK_NE(size, 0); 190 CHECK_EQ(ptr % kHeapAlignment, 0); 191 CHECK_EQ(size % kHeapAlignment, 0); 192 CHECK_GE(ptr, jctx->heap_begin); 193 CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size); 194 195 BlockDesc *b = getblock(ptr); 196 new(b) BlockDesc(); 197 } 198 199 void __tsan_java_free(jptr ptr, jptr size) { 200 SCOPED_JAVA_FUNC(__tsan_java_free); 201 DPrintf("#%d: java_free(%p, %p)\n", thr->tid, ptr, size); 202 CHECK_NE(jctx, 0); 203 CHECK_NE(size, 0); 204 CHECK_EQ(ptr % kHeapAlignment, 0); 205 CHECK_EQ(size % kHeapAlignment, 0); 206 CHECK_GE(ptr, jctx->heap_begin); 207 CHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size); 208 209 BlockDesc *beg = getblock(ptr); 210 BlockDesc *end = getblock(ptr + size); 211 for (BlockDesc *b = beg; b != end; b++) { 212 if (b->begin) 213 b->~BlockDesc(); 214 } 215 } 216 217 void __tsan_java_move(jptr src, jptr dst, jptr size) { 218 SCOPED_JAVA_FUNC(__tsan_java_move); 219 DPrintf("#%d: java_move(%p, %p, %p)\n", thr->tid, src, dst, size); 220 CHECK_NE(jctx, 0); 221 CHECK_NE(size, 0); 222 CHECK_EQ(src % kHeapAlignment, 0); 223 CHECK_EQ(dst % kHeapAlignment, 0); 224 CHECK_EQ(size % kHeapAlignment, 0); 225 CHECK_GE(src, jctx->heap_begin); 226 CHECK_LE(src + size, jctx->heap_begin + jctx->heap_size); 227 CHECK_GE(dst, jctx->heap_begin); 228 CHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size); 229 CHECK(dst >= src + size || src >= dst + size); 230 231 // Assuming it's not running concurrently with threads that do 232 // memory accesses and mutex operations (stop-the-world phase). 233 { // NOLINT 234 BlockDesc *s = getblock(src); 235 BlockDesc *d = getblock(dst); 236 BlockDesc *send = getblock(src + size); 237 for (; s != send; s++, d++) { 238 CHECK_EQ(d->begin, false); 239 if (s->begin) { 240 DPrintf("#%d: moving block %p->%p\n", thr->tid, getmem(s), getmem(d)); 241 new(d) BlockDesc; 242 d->head = s->head; 243 for (SyncVar *sync = d->head; sync; sync = sync->next) { 244 uptr newaddr = sync->addr - src + dst; 245 DPrintf("#%d: moving sync %p->%p\n", thr->tid, sync->addr, newaddr); 246 sync->addr = newaddr; 247 } 248 s->head = 0; 249 s->~BlockDesc(); 250 } 251 } 252 } 253 254 { // NOLINT 255 u64 *s = (u64*)MemToShadow(src); 256 u64 *d = (u64*)MemToShadow(dst); 257 u64 *send = (u64*)MemToShadow(src + size); 258 for (; s != send; s++, d++) { 259 *d = *s; 260 *s = 0; 261 } 262 } 263 } 264 265 void __tsan_java_mutex_lock(jptr addr) { 266 SCOPED_JAVA_FUNC(__tsan_java_mutex_lock); 267 DPrintf("#%d: java_mutex_lock(%p)\n", thr->tid, addr); 268 CHECK_NE(jctx, 0); 269 CHECK_GE(addr, jctx->heap_begin); 270 CHECK_LT(addr, jctx->heap_begin + jctx->heap_size); 271 272 MutexLock(thr, pc, addr); 273 } 274 275 void __tsan_java_mutex_unlock(jptr addr) { 276 SCOPED_JAVA_FUNC(__tsan_java_mutex_unlock); 277 DPrintf("#%d: java_mutex_unlock(%p)\n", thr->tid, addr); 278 CHECK_NE(jctx, 0); 279 CHECK_GE(addr, jctx->heap_begin); 280 CHECK_LT(addr, jctx->heap_begin + jctx->heap_size); 281 282 MutexUnlock(thr, pc, addr); 283 } 284 285 void __tsan_java_mutex_read_lock(jptr addr) { 286 SCOPED_JAVA_FUNC(__tsan_java_mutex_read_lock); 287 DPrintf("#%d: java_mutex_read_lock(%p)\n", thr->tid, addr); 288 CHECK_NE(jctx, 0); 289 CHECK_GE(addr, jctx->heap_begin); 290 CHECK_LT(addr, jctx->heap_begin + jctx->heap_size); 291 292 MutexReadLock(thr, pc, addr); 293 } 294 295 void __tsan_java_mutex_read_unlock(jptr addr) { 296 SCOPED_JAVA_FUNC(__tsan_java_mutex_read_unlock); 297 DPrintf("#%d: java_mutex_read_unlock(%p)\n", thr->tid, addr); 298 CHECK_NE(jctx, 0); 299 CHECK_GE(addr, jctx->heap_begin); 300 CHECK_LT(addr, jctx->heap_begin + jctx->heap_size); 301 302 MutexReadUnlock(thr, pc, addr); 303 } 304