dfd9808b6c
Currently ThreadRegistry is overcomplicated because of tsan, it needs tid quarantine and reuse counters. Other sanitizers don't need that. It also seems that no other sanitizer now needs max number of threads. Asan used to need 2^24 limit, but it does not seem to be needed now. Other sanitizers blindly copy-pasted that without reasons. Lsan also uses quarantine, but I don't see why that may be potentially needed. Add a ThreadRegistry ctor that does not require any sizes and use it in all sanitizers except for tsan. In preparation for new tsan runtime, which won't need any of these parameters as well. Reviewed By: vitalybuka Differential Revision: https://reviews.llvm.org/D105713
113 lines
3.2 KiB
C++
113 lines
3.2 KiB
C++
//=-- lsan_thread.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 LeakSanitizer.
|
|
// See lsan_thread.h for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lsan_thread.h"
|
|
|
|
#include "lsan.h"
|
|
#include "lsan_allocator.h"
|
|
#include "lsan_common.h"
|
|
#include "sanitizer_common/sanitizer_common.h"
|
|
#include "sanitizer_common/sanitizer_placement_new.h"
|
|
#include "sanitizer_common/sanitizer_thread_registry.h"
|
|
#include "sanitizer_common/sanitizer_tls_get_addr.h"
|
|
|
|
namespace __lsan {
|
|
|
|
static ThreadRegistry *thread_registry;
|
|
|
|
static ThreadContextBase *CreateThreadContext(u32 tid) {
|
|
void *mem = MmapOrDie(sizeof(ThreadContext), "ThreadContext");
|
|
return new (mem) ThreadContext(tid);
|
|
}
|
|
|
|
void InitializeThreadRegistry() {
|
|
static ALIGNED(64) char thread_registry_placeholder[sizeof(ThreadRegistry)];
|
|
thread_registry =
|
|
new (thread_registry_placeholder) ThreadRegistry(CreateThreadContext);
|
|
}
|
|
|
|
ThreadContextLsanBase::ThreadContextLsanBase(int tid)
|
|
: ThreadContextBase(tid) {}
|
|
|
|
void ThreadContextLsanBase::OnFinished() {
|
|
AllocatorThreadFinish();
|
|
DTLS_Destroy();
|
|
}
|
|
|
|
u32 ThreadCreate(u32 parent_tid, uptr user_id, bool detached, void *arg) {
|
|
return thread_registry->CreateThread(user_id, detached, parent_tid, arg);
|
|
}
|
|
|
|
void ThreadContextLsanBase::ThreadStart(u32 tid, tid_t os_id,
|
|
ThreadType thread_type, void *arg) {
|
|
thread_registry->StartThread(tid, os_id, thread_type, arg);
|
|
SetCurrentThread(tid);
|
|
}
|
|
|
|
void ThreadFinish() {
|
|
thread_registry->FinishThread(GetCurrentThread());
|
|
SetCurrentThread(kInvalidTid);
|
|
}
|
|
|
|
ThreadContext *CurrentThreadContext() {
|
|
if (!thread_registry)
|
|
return nullptr;
|
|
if (GetCurrentThread() == kInvalidTid)
|
|
return nullptr;
|
|
// No lock needed when getting current thread.
|
|
return (ThreadContext *)thread_registry->GetThreadLocked(GetCurrentThread());
|
|
}
|
|
|
|
static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) {
|
|
uptr uid = (uptr)arg;
|
|
if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
u32 ThreadTid(uptr uid) {
|
|
return thread_registry->FindThread(FindThreadByUid, (void *)uid);
|
|
}
|
|
|
|
void ThreadDetach(u32 tid) {
|
|
CHECK_NE(tid, kInvalidTid);
|
|
thread_registry->DetachThread(tid, /* arg */ nullptr);
|
|
}
|
|
|
|
void ThreadJoin(u32 tid) {
|
|
CHECK_NE(tid, kInvalidTid);
|
|
thread_registry->JoinThread(tid, /* arg */ nullptr);
|
|
}
|
|
|
|
void EnsureMainThreadIDIsCorrect() {
|
|
if (GetCurrentThread() == kMainTid)
|
|
CurrentThreadContext()->os_id = GetTid();
|
|
}
|
|
|
|
///// Interface to the common LSan module. /////
|
|
|
|
void ForEachExtraStackRange(tid_t os_id, RangeIteratorCallback callback,
|
|
void *arg) {}
|
|
|
|
void LockThreadRegistry() { thread_registry->Lock(); }
|
|
|
|
void UnlockThreadRegistry() { thread_registry->Unlock(); }
|
|
|
|
ThreadRegistry *GetThreadRegistryLocked() {
|
|
thread_registry->CheckLocked();
|
|
return thread_registry;
|
|
}
|
|
|
|
} // namespace __lsan
|