94 lines · c
1//===-- tsd.h ---------------------------------------------------*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef SCUDO_TSD_H_10#define SCUDO_TSD_H_11 12#include "atomic_helpers.h"13#include "common.h"14#include "mutex.h"15#include "thread_annotations.h"16 17#include <limits.h> // for PTHREAD_DESTRUCTOR_ITERATIONS18#include <pthread.h>19 20// With some build setups, this might still not be defined.21#ifndef PTHREAD_DESTRUCTOR_ITERATIONS22#define PTHREAD_DESTRUCTOR_ITERATIONS 423#endif24 25namespace scudo {26 27template <class Allocator> struct alignas(SCUDO_CACHE_LINE_SIZE) TSD {28 using ThisT = TSD<Allocator>;29 u8 DestructorIterations = 0;30 31 void init(Allocator *Instance) NO_THREAD_SAFETY_ANALYSIS {32 DCHECK_EQ(DestructorIterations, 0U);33 DCHECK(isAligned(reinterpret_cast<uptr>(this), alignof(ThisT)));34 Instance->initAllocator(&SizeClassAllocator);35 DestructorIterations = PTHREAD_DESTRUCTOR_ITERATIONS;36 }37 38 inline bool tryLock() NO_THREAD_SAFETY_ANALYSIS {39 if (Mutex.tryLock()) {40 atomic_store_relaxed(&Precedence, 0);41 return true;42 }43 if (atomic_load_relaxed(&Precedence) == 0)44 atomic_store_relaxed(45 &Precedence,46 static_cast<uptr>(getMonotonicTime() >> FIRST_32_SECOND_64(16, 0)));47 return false;48 }49 inline void lock() NO_THREAD_SAFETY_ANALYSIS {50 atomic_store_relaxed(&Precedence, 0);51 Mutex.lock();52 }53 inline void unlock() NO_THREAD_SAFETY_ANALYSIS { Mutex.unlock(); }54 inline uptr getPrecedence() { return atomic_load_relaxed(&Precedence); }55 56 void commitBack(Allocator *Instance) { Instance->commitBack(this); }57 58 // As the comments attached to `getCache()`, the TSD doesn't always need to be59 // locked. In that case, we would only skip the check before we have all TSDs60 // locked in all paths.61 void assertLocked(bool BypassCheck) ASSERT_CAPABILITY(Mutex) {62 if (SCUDO_DEBUG && !BypassCheck)63 Mutex.assertHeld();64 }65 66 // Ideally, we may want to assert that all the operations on67 // Cache/QuarantineCache always have the `Mutex` acquired. However, the68 // current architecture of accessing TSD is not easy to cooperate with the69 // thread-safety analysis because of pointer aliasing. So now we just add the70 // assertion on the getters of Cache/QuarantineCache.71 //72 // TODO(chiahungduan): Ideally, we want to do `Mutex.assertHeld` but acquiring73 // TSD doesn't always require holding the lock. Add this assertion while the74 // lock is always acquired.75 typename Allocator::SizeClassAllocatorT &getSizeClassAllocator()76 REQUIRES(Mutex) {77 return SizeClassAllocator;78 }79 typename Allocator::QuarantineCacheT &getQuarantineCache() REQUIRES(Mutex) {80 return QuarantineCache;81 }82 83private:84 HybridMutex Mutex;85 atomic_uptr Precedence = {};86 87 typename Allocator::SizeClassAllocatorT SizeClassAllocator GUARDED_BY(Mutex);88 typename Allocator::QuarantineCacheT QuarantineCache GUARDED_BY(Mutex);89};90 91} // namespace scudo92 93#endif // SCUDO_TSD_H_94