forked from OSchip/llvm-project
259 lines
8.0 KiB
C++
259 lines
8.0 KiB
C++
//===-- tsan_interface_java.cpp -------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file is a part of ThreadSanitizer (TSan), a race detector.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "tsan_interface_java.h"
|
|
#include "tsan_rtl.h"
|
|
#include "sanitizer_common/sanitizer_internal_defs.h"
|
|
#include "sanitizer_common/sanitizer_common.h"
|
|
#include "sanitizer_common/sanitizer_placement_new.h"
|
|
#include "sanitizer_common/sanitizer_stacktrace.h"
|
|
#include "sanitizer_common/sanitizer_procmaps.h"
|
|
|
|
using namespace __tsan;
|
|
|
|
const jptr kHeapAlignment = 8;
|
|
|
|
namespace __tsan {
|
|
|
|
struct JavaContext {
|
|
const uptr heap_begin;
|
|
const uptr heap_size;
|
|
|
|
JavaContext(jptr heap_begin, jptr heap_size)
|
|
: heap_begin(heap_begin)
|
|
, heap_size(heap_size) {
|
|
}
|
|
};
|
|
|
|
static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1];
|
|
static JavaContext *jctx;
|
|
|
|
MBlock *JavaHeapBlock(uptr addr, uptr *start) {
|
|
if (!jctx || addr < jctx->heap_begin ||
|
|
addr >= jctx->heap_begin + jctx->heap_size)
|
|
return nullptr;
|
|
for (uptr p = RoundDown(addr, kMetaShadowCell); p >= jctx->heap_begin;
|
|
p -= kMetaShadowCell) {
|
|
MBlock *b = ctx->metamap.GetBlock(p);
|
|
if (!b)
|
|
continue;
|
|
if (p + b->siz <= addr)
|
|
return nullptr;
|
|
*start = p;
|
|
return b;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace __tsan
|
|
|
|
#define JAVA_FUNC_ENTER(func) \
|
|
ThreadState *thr = cur_thread(); \
|
|
(void)thr;
|
|
|
|
void __tsan_java_init(jptr heap_begin, jptr heap_size) {
|
|
JAVA_FUNC_ENTER(__tsan_java_init);
|
|
Initialize(thr);
|
|
DPrintf("#%d: java_init(0x%zx, 0x%zx)\n", thr->tid, heap_begin, heap_size);
|
|
DCHECK_EQ(jctx, 0);
|
|
DCHECK_GT(heap_begin, 0);
|
|
DCHECK_GT(heap_size, 0);
|
|
DCHECK_EQ(heap_begin % kHeapAlignment, 0);
|
|
DCHECK_EQ(heap_size % kHeapAlignment, 0);
|
|
DCHECK_LT(heap_begin, heap_begin + heap_size);
|
|
jctx = new(jctx_buf) JavaContext(heap_begin, heap_size);
|
|
}
|
|
|
|
int __tsan_java_fini() {
|
|
JAVA_FUNC_ENTER(__tsan_java_fini);
|
|
DPrintf("#%d: java_fini()\n", thr->tid);
|
|
DCHECK_NE(jctx, 0);
|
|
// FIXME(dvyukov): this does not call atexit() callbacks.
|
|
int status = Finalize(thr);
|
|
DPrintf("#%d: java_fini() = %d\n", thr->tid, status);
|
|
return status;
|
|
}
|
|
|
|
void __tsan_java_alloc(jptr ptr, jptr size) {
|
|
JAVA_FUNC_ENTER(__tsan_java_alloc);
|
|
DPrintf("#%d: java_alloc(0x%zx, 0x%zx)\n", thr->tid, ptr, size);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_NE(size, 0);
|
|
DCHECK_EQ(ptr % kHeapAlignment, 0);
|
|
DCHECK_EQ(size % kHeapAlignment, 0);
|
|
DCHECK_GE(ptr, jctx->heap_begin);
|
|
DCHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
|
|
|
|
OnUserAlloc(thr, 0, ptr, size, false);
|
|
}
|
|
|
|
void __tsan_java_free(jptr ptr, jptr size) {
|
|
JAVA_FUNC_ENTER(__tsan_java_free);
|
|
DPrintf("#%d: java_free(0x%zx, 0x%zx)\n", thr->tid, ptr, size);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_NE(size, 0);
|
|
DCHECK_EQ(ptr % kHeapAlignment, 0);
|
|
DCHECK_EQ(size % kHeapAlignment, 0);
|
|
DCHECK_GE(ptr, jctx->heap_begin);
|
|
DCHECK_LE(ptr + size, jctx->heap_begin + jctx->heap_size);
|
|
|
|
ctx->metamap.FreeRange(thr->proc(), ptr, size);
|
|
}
|
|
|
|
void __tsan_java_move(jptr src, jptr dst, jptr size) {
|
|
JAVA_FUNC_ENTER(__tsan_java_move);
|
|
DPrintf("#%d: java_move(0x%zx, 0x%zx, 0x%zx)\n", thr->tid, src, dst, size);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_NE(size, 0);
|
|
DCHECK_EQ(src % kHeapAlignment, 0);
|
|
DCHECK_EQ(dst % kHeapAlignment, 0);
|
|
DCHECK_EQ(size % kHeapAlignment, 0);
|
|
DCHECK_GE(src, jctx->heap_begin);
|
|
DCHECK_LE(src + size, jctx->heap_begin + jctx->heap_size);
|
|
DCHECK_GE(dst, jctx->heap_begin);
|
|
DCHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);
|
|
DCHECK_NE(dst, src);
|
|
DCHECK_NE(size, 0);
|
|
|
|
// Assuming it's not running concurrently with threads that do
|
|
// memory accesses and mutex operations (stop-the-world phase).
|
|
ctx->metamap.MoveMemory(src, dst, size);
|
|
|
|
// Clear the destination shadow range.
|
|
// We used to move shadow from src to dst, but the trace format does not
|
|
// support that anymore as it contains addresses of accesses.
|
|
RawShadow *d = MemToShadow(dst);
|
|
RawShadow *dend = MemToShadow(dst + size);
|
|
internal_memset(d, 0, (dend - d) * sizeof(*d));
|
|
}
|
|
|
|
jptr __tsan_java_find(jptr *from_ptr, jptr to) {
|
|
JAVA_FUNC_ENTER(__tsan_java_find);
|
|
DPrintf("#%d: java_find(&0x%zx, 0x%zx)\n", thr->tid, *from_ptr, to);
|
|
DCHECK_EQ((*from_ptr) % kHeapAlignment, 0);
|
|
DCHECK_EQ(to % kHeapAlignment, 0);
|
|
DCHECK_GE(*from_ptr, jctx->heap_begin);
|
|
DCHECK_LE(to, jctx->heap_begin + jctx->heap_size);
|
|
for (uptr from = *from_ptr; from < to; from += kHeapAlignment) {
|
|
MBlock *b = ctx->metamap.GetBlock(from);
|
|
if (b) {
|
|
*from_ptr = from;
|
|
return b->siz;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void __tsan_java_finalize() {
|
|
JAVA_FUNC_ENTER(__tsan_java_finalize);
|
|
DPrintf("#%d: java_finalize()\n", thr->tid);
|
|
AcquireGlobal(thr);
|
|
}
|
|
|
|
void __tsan_java_mutex_lock(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_mutex_lock);
|
|
DPrintf("#%d: java_mutex_lock(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
MutexPostLock(thr, 0, addr,
|
|
MutexFlagLinkerInit | MutexFlagWriteReentrant |
|
|
MutexFlagDoPreLockOnPostLock);
|
|
}
|
|
|
|
void __tsan_java_mutex_unlock(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_mutex_unlock);
|
|
DPrintf("#%d: java_mutex_unlock(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
MutexUnlock(thr, 0, addr);
|
|
}
|
|
|
|
void __tsan_java_mutex_read_lock(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_mutex_read_lock);
|
|
DPrintf("#%d: java_mutex_read_lock(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
MutexPostReadLock(thr, 0, addr,
|
|
MutexFlagLinkerInit | MutexFlagWriteReentrant |
|
|
MutexFlagDoPreLockOnPostLock);
|
|
}
|
|
|
|
void __tsan_java_mutex_read_unlock(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_mutex_read_unlock);
|
|
DPrintf("#%d: java_mutex_read_unlock(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
MutexReadUnlock(thr, 0, addr);
|
|
}
|
|
|
|
void __tsan_java_mutex_lock_rec(jptr addr, int rec) {
|
|
JAVA_FUNC_ENTER(__tsan_java_mutex_lock_rec);
|
|
DPrintf("#%d: java_mutex_lock_rec(0x%zx, %d)\n", thr->tid, addr, rec);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
DCHECK_GT(rec, 0);
|
|
|
|
MutexPostLock(thr, 0, addr,
|
|
MutexFlagLinkerInit | MutexFlagWriteReentrant |
|
|
MutexFlagDoPreLockOnPostLock | MutexFlagRecursiveLock,
|
|
rec);
|
|
}
|
|
|
|
int __tsan_java_mutex_unlock_rec(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_mutex_unlock_rec);
|
|
DPrintf("#%d: java_mutex_unlock_rec(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
return MutexUnlock(thr, 0, addr, MutexFlagRecursiveUnlock);
|
|
}
|
|
|
|
void __tsan_java_acquire(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_acquire);
|
|
DPrintf("#%d: java_acquire(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
Acquire(thr, 0, addr);
|
|
}
|
|
|
|
void __tsan_java_release(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_release);
|
|
DPrintf("#%d: java_release(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
Release(thr, 0, addr);
|
|
}
|
|
|
|
void __tsan_java_release_store(jptr addr) {
|
|
JAVA_FUNC_ENTER(__tsan_java_release);
|
|
DPrintf("#%d: java_release_store(0x%zx)\n", thr->tid, addr);
|
|
DCHECK_NE(jctx, 0);
|
|
DCHECK_GE(addr, jctx->heap_begin);
|
|
DCHECK_LT(addr, jctx->heap_begin + jctx->heap_size);
|
|
|
|
ReleaseStore(thr, 0, addr);
|
|
}
|