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-exception 6 // 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_ITERATIONS 18 #include <pthread.h> 19 20 // With some build setups, this might still not be defined. 21 #ifndef PTHREAD_DESTRUCTOR_ITERATIONS 22 #define PTHREAD_DESTRUCTOR_ITERATIONS 4 23 #endif 24 25 namespace scudo { 26 27 template <class Allocator> struct alignas(SCUDO_CACHE_LINE_SIZE) TSD { 28 using ThisT = TSD<Allocator>; 29 u8 DestructorIterations = 0; 30 initTSD31 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 tryLockTSD38 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 } lockTSD49 inline void lock() NO_THREAD_SAFETY_ANALYSIS { 50 atomic_store_relaxed(&Precedence, 0); 51 Mutex.lock(); 52 } unlockTSD53 inline void unlock() NO_THREAD_SAFETY_ANALYSIS { Mutex.unlock(); } getPrecedenceTSD54 inline uptr getPrecedence() { return atomic_load_relaxed(&Precedence); } 55 commitBackTSD56 void commitBack(Allocator *Instance) { Instance->commitBack(this); } 57 58 // As the comments attached to `getCache()`, the TSD doesn't always need to be 59 // locked. In that case, we would only skip the check before we have all TSDs 60 // locked in all paths. assertLockedTSD61 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 on 67 // Cache/QuarantineCache always have the `Mutex` acquired. However, the 68 // current architecture of accessing TSD is not easy to cooperate with the 69 // thread-safety analysis because of pointer aliasing. So now we just add the 70 // assertion on the getters of Cache/QuarantineCache. 71 // 72 // TODO(chiahungduan): Ideally, we want to do `Mutex.assertHeld` but acquiring 73 // TSD doesn't always require holding the lock. Add this assertion while the 74 // lock is always acquired. getSizeClassAllocatorTSD75 typename Allocator::SizeClassAllocatorT &getSizeClassAllocator() 76 REQUIRES(Mutex) { 77 return SizeClassAllocator; 78 } getQuarantineCacheTSD79 typename Allocator::QuarantineCacheT &getQuarantineCache() REQUIRES(Mutex) { 80 return QuarantineCache; 81 } 82 83 private: 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 scudo 92 93 #endif // SCUDO_TSD_H_ 94