| //===-- tsan_trace_test.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_trace.h" |
| |
| #include <pthread.h> |
| |
| #include "gtest/gtest.h" |
| #include "tsan_rtl.h" |
| |
| #if SANITIZER_MAC || !defined(__x86_64__) |
| // These tests are currently crashing on Mac: |
| // https://reviews.llvm.org/D107911 |
| // and on ppc64: https://reviews.llvm.org/D110546#3025422 |
| // due to the way we create thread contexts |
| // (but they crashed on Mac with normal pthread_create as well). |
| // There must be some difference in thread initialization |
| // between normal execution and unit tests. |
| # define TRACE_TEST(SUITE, NAME) TEST(SUITE, DISABLED_##NAME) |
| #else |
| # define TRACE_TEST(SUITE, NAME) TEST(SUITE, NAME) |
| #endif |
| |
| namespace __tsan { |
| |
| using namespace v3; |
| |
| // We need to run all trace tests in a new thread, |
| // so that the thread trace is empty initially. |
| template <uptr N> |
| struct ThreadArray { |
| ThreadArray() { |
| for (auto *&thr : threads) { |
| thr = static_cast<ThreadState *>( |
| MmapOrDie(sizeof(ThreadState), "ThreadState")); |
| Tid tid = ThreadCreate(cur_thread(), 0, 0, true); |
| Processor *proc = ProcCreate(); |
| ProcWire(proc, thr); |
| ThreadStart(thr, tid, 0, ThreadType::Fiber); |
| } |
| } |
| |
| ~ThreadArray() { |
| for (uptr i = 0; i < N; i++) { |
| if (threads[i]) |
| Finish(i); |
| } |
| } |
| |
| void Finish(uptr i) { |
| auto *thr = threads[i]; |
| threads[i] = nullptr; |
| Processor *proc = thr->proc(); |
| ThreadFinish(thr); |
| ProcUnwire(proc, thr); |
| ProcDestroy(proc); |
| UnmapOrDie(thr, sizeof(ThreadState)); |
| } |
| |
| ThreadState *threads[N]; |
| ThreadState *operator[](uptr i) { return threads[i]; } |
| ThreadState *operator->() { return threads[0]; } |
| operator ThreadState *() { return threads[0]; } |
| }; |
| |
| TRACE_TEST(Trace, RestoreAccess) { |
| // A basic test with some function entry/exit events, |
| // some mutex lock/unlock events and some other distracting |
| // memory events. |
| ThreadArray<1> thr; |
| TraceFunc(thr, 0x1000); |
| TraceFunc(thr, 0x1001); |
| TraceMutexLock(thr, v3::EventType::kLock, 0x4000, 0x5000, 0x6000); |
| TraceMutexLock(thr, v3::EventType::kLock, 0x4001, 0x5001, 0x6001); |
| TraceMutexUnlock(thr, 0x5000); |
| TraceFunc(thr); |
| CHECK(TryTraceMemoryAccess(thr, 0x2001, 0x3001, 8, kAccessRead)); |
| TraceMutexLock(thr, v3::EventType::kRLock, 0x4002, 0x5002, 0x6002); |
| TraceFunc(thr, 0x1002); |
| CHECK(TryTraceMemoryAccess(thr, 0x2000, 0x3000, 8, kAccessRead)); |
| // This is the access we want to find. |
| // The previous one is equivalent, but RestoreStack must prefer |
| // the last of the matchig accesses. |
| CHECK(TryTraceMemoryAccess(thr, 0x2002, 0x3000, 8, kAccessRead)); |
| Lock lock1(&ctx->slot_mtx); |
| ThreadRegistryLock lock2(&ctx->thread_registry); |
| VarSizeStackTrace stk; |
| MutexSet mset; |
| uptr tag = kExternalTagNone; |
| bool res = |
| RestoreStack(thr->tid, v3::EventType::kAccessExt, thr->sid, thr->epoch, |
| 0x3000, 8, kAccessRead, &stk, &mset, &tag); |
| CHECK(res); |
| CHECK_EQ(stk.size, 3); |
| CHECK_EQ(stk.trace[0], 0x1000); |
| CHECK_EQ(stk.trace[1], 0x1002); |
| CHECK_EQ(stk.trace[2], 0x2002); |
| CHECK_EQ(mset.Size(), 2); |
| CHECK_EQ(mset.Get(0).addr, 0x5001); |
| CHECK_EQ(mset.Get(0).stack_id, 0x6001); |
| CHECK_EQ(mset.Get(0).write, true); |
| CHECK_EQ(mset.Get(1).addr, 0x5002); |
| CHECK_EQ(mset.Get(1).stack_id, 0x6002); |
| CHECK_EQ(mset.Get(1).write, false); |
| CHECK_EQ(tag, kExternalTagNone); |
| } |
| |
| TRACE_TEST(Trace, MemoryAccessSize) { |
| // Test tracing and matching of accesses of different sizes. |
| struct Params { |
| uptr access_size, offset, size; |
| bool res; |
| }; |
| Params tests[] = { |
| {1, 0, 1, true}, {4, 0, 2, true}, |
| {4, 2, 2, true}, {8, 3, 1, true}, |
| {2, 1, 1, true}, {1, 1, 1, false}, |
| {8, 5, 4, false}, {4, static_cast<uptr>(-1l), 4, false}, |
| }; |
| for (auto params : tests) { |
| for (int type = 0; type < 3; type++) { |
| ThreadArray<1> thr; |
| Printf("access_size=%zu, offset=%zu, size=%zu, res=%d, type=%d\n", |
| params.access_size, params.offset, params.size, params.res, type); |
| TraceFunc(thr, 0x1000); |
| switch (type) { |
| case 0: |
| // This should emit compressed event. |
| CHECK(TryTraceMemoryAccess(thr, 0x2000, 0x3000, params.access_size, |
| kAccessRead)); |
| break; |
| case 1: |
| // This should emit full event. |
| CHECK(TryTraceMemoryAccess(thr, 0x2000000, 0x3000, params.access_size, |
| kAccessRead)); |
| break; |
| case 2: |
| TraceMemoryAccessRange(thr, 0x2000000, 0x3000, params.access_size, |
| kAccessRead); |
| break; |
| } |
| Lock lock1(&ctx->slot_mtx); |
| ThreadRegistryLock lock2(&ctx->thread_registry); |
| VarSizeStackTrace stk; |
| MutexSet mset; |
| uptr tag = kExternalTagNone; |
| bool res = RestoreStack(thr->tid, v3::EventType::kAccessExt, thr->sid, |
| thr->epoch, 0x3000 + params.offset, params.size, |
| kAccessRead, &stk, &mset, &tag); |
| CHECK_EQ(res, params.res); |
| if (params.res) { |
| CHECK_EQ(stk.size, 2); |
| CHECK_EQ(stk.trace[0], 0x1000); |
| CHECK_EQ(stk.trace[1], type ? 0x2000000 : 0x2000); |
| } |
| } |
| } |
| } |
| |
| TRACE_TEST(Trace, RestoreMutexLock) { |
| // Check of restoration of a mutex lock event. |
| ThreadArray<1> thr; |
| TraceFunc(thr, 0x1000); |
| TraceMutexLock(thr, v3::EventType::kLock, 0x4000, 0x5000, 0x6000); |
| TraceMutexLock(thr, v3::EventType::kRLock, 0x4001, 0x5001, 0x6001); |
| TraceMutexLock(thr, v3::EventType::kRLock, 0x4002, 0x5001, 0x6002); |
| Lock lock1(&ctx->slot_mtx); |
| ThreadRegistryLock lock2(&ctx->thread_registry); |
| VarSizeStackTrace stk; |
| MutexSet mset; |
| uptr tag = kExternalTagNone; |
| bool res = RestoreStack(thr->tid, v3::EventType::kLock, thr->sid, thr->epoch, |
| 0x5001, 0, 0, &stk, &mset, &tag); |
| CHECK(res); |
| CHECK_EQ(stk.size, 2); |
| CHECK_EQ(stk.trace[0], 0x1000); |
| CHECK_EQ(stk.trace[1], 0x4002); |
| CHECK_EQ(mset.Size(), 2); |
| CHECK_EQ(mset.Get(0).addr, 0x5000); |
| CHECK_EQ(mset.Get(0).stack_id, 0x6000); |
| CHECK_EQ(mset.Get(0).write, true); |
| CHECK_EQ(mset.Get(1).addr, 0x5001); |
| CHECK_EQ(mset.Get(1).stack_id, 0x6001); |
| CHECK_EQ(mset.Get(1).write, false); |
| } |
| |
| TRACE_TEST(Trace, MultiPart) { |
| // Check replay of a trace with multiple parts. |
| ThreadArray<1> thr; |
| TraceFunc(thr, 0x1000); |
| TraceFunc(thr, 0x2000); |
| TraceMutexLock(thr, v3::EventType::kLock, 0x4000, 0x5000, 0x6000); |
| const uptr kEvents = 3 * sizeof(TracePart) / sizeof(v3::Event); |
| for (uptr i = 0; i < kEvents; i++) { |
| TraceFunc(thr, 0x3000); |
| TraceMutexLock(thr, v3::EventType::kLock, 0x4002, 0x5002, 0x6002); |
| TraceMutexUnlock(thr, 0x5002); |
| TraceFunc(thr); |
| } |
| TraceFunc(thr, 0x4000); |
| TraceMutexLock(thr, v3::EventType::kRLock, 0x4001, 0x5001, 0x6001); |
| CHECK(TryTraceMemoryAccess(thr, 0x2002, 0x3000, 8, kAccessRead)); |
| Lock lock1(&ctx->slot_mtx); |
| ThreadRegistryLock lock2(&ctx->thread_registry); |
| VarSizeStackTrace stk; |
| MutexSet mset; |
| uptr tag = kExternalTagNone; |
| bool res = |
| RestoreStack(thr->tid, v3::EventType::kAccessExt, thr->sid, thr->epoch, |
| 0x3000, 8, kAccessRead, &stk, &mset, &tag); |
| CHECK(res); |
| CHECK_EQ(stk.size, 4); |
| CHECK_EQ(stk.trace[0], 0x1000); |
| CHECK_EQ(stk.trace[1], 0x2000); |
| CHECK_EQ(stk.trace[2], 0x4000); |
| CHECK_EQ(stk.trace[3], 0x2002); |
| CHECK_EQ(mset.Size(), 2); |
| CHECK_EQ(mset.Get(0).addr, 0x5000); |
| CHECK_EQ(mset.Get(0).stack_id, 0x6000); |
| CHECK_EQ(mset.Get(0).write, true); |
| CHECK_EQ(mset.Get(1).addr, 0x5001); |
| CHECK_EQ(mset.Get(1).stack_id, 0x6001); |
| CHECK_EQ(mset.Get(1).write, false); |
| } |
| |
| } // namespace __tsan |