|
111
|
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
|
|
|
20 namespace __sanitizer {
|
|
|
21
|
|
|
22 enum 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.
|
|
|
32 class 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
|
|
|
73 typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
|
|
|
74
|
|
|
75 class 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
|
|
|
143 typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock;
|
|
|
144
|
|
|
145 } // namespace __sanitizer
|
|
|
146
|
|
|
147 #endif // SANITIZER_THREAD_REGISTRY_H
|
