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.
OnDead()71   virtual void OnDead() {}
OnJoined(void * arg)72   virtual void OnJoined(void *arg) {}
OnFinished()73   virtual void OnFinished() {}
OnStarted(void * arg)74   virtual void OnStarted(void *arg) {}
OnCreated(void * arg)75   virtual void OnCreated(void *arg) {}
OnReset()76   virtual void OnReset() {}
OnDetached(void * arg)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 
Lock()92   void Lock() { mtx_.Lock(); }
CheckLocked()93   void CheckLocked() { mtx_.CheckLocked(); }
Unlock()94   void Unlock() { mtx_.Unlock(); }
95 
96   // Should be guarded by ThreadRegistryLock.
GetThreadLocked(u32 tid)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