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