1 //===-- sanitizer_thread_registry.h -----------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file is shared between sanitizer tools. 11 // 12 // General thread bookkeeping functionality. 13 //===----------------------------------------------------------------------===// 14 15 #ifndef SANITIZER_THREAD_REGISTRY_H 16 #define SANITIZER_THREAD_REGISTRY_H 17 18 #include "sanitizer_common.h" 19 #include "sanitizer_list.h" 20 #include "sanitizer_mutex.h" 21 22 namespace __sanitizer { 23 24 enum ThreadStatus { 25 ThreadStatusInvalid, // Non-existent thread, data is invalid. 26 ThreadStatusCreated, // Created but not yet running. 27 ThreadStatusRunning, // The thread is currently running. 28 ThreadStatusFinished, // Joinable thread is finished but not yet joined. 29 ThreadStatusDead // Joined, but some info is still available. 30 }; 31 32 // Generic thread context. Specific sanitizer tools may inherit from it. 33 // If thread is dead, context may optionally be reused for a new thread. 34 class ThreadContextBase { 35 public: 36 explicit ThreadContextBase(u32 tid); 37 ~ThreadContextBase(); // Should never be called. 38 39 const u32 tid; // Thread ID. Main thread should have tid = 0. 40 u64 unique_id; // Unique thread ID. 41 u32 reuse_count; // Number of times this tid was reused. 42 tid_t os_id; // PID (used for reporting). 43 uptr user_id; // Some opaque user thread id (e.g. pthread_t). 44 char name[64]; // As annotated by user. 45 46 ThreadStatus status; 47 bool detached; 48 bool workerthread; 49 50 u32 parent_tid; 51 ThreadContextBase *next; // For storing thread contexts in a list. 52 53 atomic_uint32_t thread_destroyed; // To address race of Joined vs Finished 54 55 void SetName(const char *new_name); 56 57 void SetDead(); 58 void SetJoined(void *arg); 59 void SetFinished(); 60 void SetStarted(tid_t _os_id, bool _workerthread, void *arg); 61 void SetCreated(uptr _user_id, u64 _unique_id, bool _detached, 62 u32 _parent_tid, void *arg); 63 void Reset(); 64 65 void SetDestroyed(); 66 bool GetDestroyed(); 67 68 // The following methods may be overriden by subclasses. 69 // Some of them take opaque arg that may be optionally be used 70 // by subclasses. 71 virtual void OnDead() {} 72 virtual void OnJoined(void *arg) {} 73 virtual void OnFinished() {} 74 virtual void OnStarted(void *arg) {} 75 virtual void OnCreated(void *arg) {} 76 virtual void OnReset() {} 77 virtual void OnDetached(void *arg) {} 78 }; 79 80 typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid); 81 82 class ThreadRegistry { 83 public: 84 static const u32 kUnknownTid; 85 86 ThreadRegistry(ThreadContextFactory factory, u32 max_threads, 87 u32 thread_quarantine_size, u32 max_reuse = 0); 88 void GetNumberOfThreads(uptr *total = nullptr, uptr *running = nullptr, 89 uptr *alive = nullptr); 90 uptr GetMaxAliveThreads(); 91 92 void Lock() { mtx_.Lock(); } 93 void CheckLocked() { mtx_.CheckLocked(); } 94 void Unlock() { mtx_.Unlock(); } 95 96 // Should be guarded by ThreadRegistryLock. 97 ThreadContextBase *GetThreadLocked(u32 tid) { 98 DCHECK_LT(tid, n_contexts_); 99 return threads_[tid]; 100 } 101 102 u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg); 103 104 typedef void (*ThreadCallback)(ThreadContextBase *tctx, void *arg); 105 // Invokes callback with a specified arg for each thread context. 106 // Should be guarded by ThreadRegistryLock. 107 void RunCallbackForEachThreadLocked(ThreadCallback cb, void *arg); 108 109 typedef bool (*FindThreadCallback)(ThreadContextBase *tctx, void *arg); 110 // Finds a thread using the provided callback. Returns kUnknownTid if no 111 // thread is found. 112 u32 FindThread(FindThreadCallback cb, void *arg); 113 // Should be guarded by ThreadRegistryLock. Return 0 if no thread 114 // is found. 115 ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb, 116 void *arg); 117 ThreadContextBase *FindThreadContextByOsIDLocked(tid_t os_id); 118 119 void SetThreadName(u32 tid, const char *name); 120 void SetThreadNameByUserId(uptr user_id, const char *name); 121 void DetachThread(u32 tid, void *arg); 122 void JoinThread(u32 tid, void *arg); 123 void FinishThread(u32 tid); 124 void StartThread(u32 tid, tid_t os_id, bool workerthread, void *arg); 125 void SetThreadUserId(u32 tid, uptr user_id); 126 127 private: 128 const ThreadContextFactory context_factory_; 129 const u32 max_threads_; 130 const u32 thread_quarantine_size_; 131 const u32 max_reuse_; 132 133 BlockingMutex mtx_; 134 135 u32 n_contexts_; // Number of created thread contexts, 136 // at most max_threads_. 137 u64 total_threads_; // Total number of created threads. May be greater than 138 // max_threads_ if contexts were reused. 139 uptr alive_threads_; // Created or running. 140 uptr max_alive_threads_; 141 uptr running_threads_; 142 143 ThreadContextBase **threads_; // Array of thread contexts is leaked. 144 IntrusiveList<ThreadContextBase> dead_threads_; 145 IntrusiveList<ThreadContextBase> invalid_threads_; 146 147 void QuarantinePush(ThreadContextBase *tctx); 148 ThreadContextBase *QuarantinePop(); 149 }; 150 151 typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock; 152 153 } // namespace __sanitizer 154 155 #endif // SANITIZER_THREAD_REGISTRY_H 156
Indexes created Sat Sep 20 22:09:52 GMT 2025