caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1bf05fbc987dddebe94de7b33d810d8221eda1a5
clang-p2996/compiler-rt/lib/tsan/rtl/tsan_interface_java.cpp
Dmitry Vyukov db2f870fe3 tsan: reset destination range in Java heap move 
Switch Java heap move to the new scheme required for the new tsan runtime.
Instead of copying the shadow we reset the destination range.
The new v3 trace contains addresses of accesses, so we cannot simply copy the shadow.
This can lead to false negatives, but cannot lead to false positives.

Depends on D110159.

Reviewed By: vitalybuka

Differential Revision: https://reviews.llvm.org/D110190
2021-09-22 07:23:21 +02:00

259 lines
8.0 KiB
C++
Raw Blame History

//===-- 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);
}
Reference in New Issue View Git Blame Copy Permalink