1 //===-- sanitizer_thread_registry.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 // This file is shared between sanitizer tools.
10 //
11 // General thread bookkeeping functionality.
12 //===----------------------------------------------------------------------===//
13
14 #ifndef SANITIZER_THREAD_REGISTRY_H
15 #define SANITIZER_THREAD_REGISTRY_H
16
17 #include "sanitizer_common.h"
18 #include "sanitizer_dense_map.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 enum class ThreadType {
33 Regular, // Normal thread
34 Worker, // macOS Grand Central Dispatch (GCD) worker thread
35 Fiber, // Fiber
36 };
37
38 // Generic thread context. Specific sanitizer tools may inherit from it.
39 // If thread is dead, context may optionally be reused for a new thread.
40 class ThreadContextBase {
41 public:
42 explicit ThreadContextBase(u32 tid);
43 const u32 tid; // Thread ID. Main thread should have tid = 0.
44 u64 unique_id; // Unique thread ID.
45 u32 reuse_count; // Number of times this tid was reused.
46 tid_t os_id; // PID (used for reporting).
47 uptr user_id; // Some opaque user thread id (e.g. pthread_t).
48 char name[64]; // As annotated by user.
49
50 ThreadStatus status;
51 bool detached;
52 ThreadType thread_type;
53
54 u32 parent_tid;
55 ThreadContextBase *next; // For storing thread contexts in a list.
56
57 atomic_uint32_t thread_destroyed; // To address race of Joined vs Finished
58
59 void SetName(const char *new_name);
60
61 void SetDead();
62 void SetJoined(void *arg);
63 void SetFinished();
64 void SetStarted(tid_t _os_id, ThreadType _thread_type, void *arg);
65 void SetCreated(uptr _user_id, u64 _unique_id, bool _detached,
66 u32 _parent_tid, void *arg);
67 void Reset();
68
69 void SetDestroyed();
70 bool GetDestroyed();
71
72 // The following methods may be overriden by subclasses.
73 // Some of them take opaque arg that may be optionally be used
74 // by subclasses.
75 virtual void OnDead() {}
76 virtual void OnJoined(void *arg) {}
77 virtual void OnFinished() {}
78 virtual void OnStarted(void *arg) {}
79 virtual void OnCreated(void *arg) {}
80 virtual void OnReset() {}
81 virtual void OnDetached(void *arg) {}
82
83 protected:
84 ~ThreadContextBase();
85 };
86
87 typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
88
89 class SANITIZER_MUTEX ThreadRegistry {
90 public:
91 ThreadRegistry(ThreadContextFactory factory);
92 ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
93 u32 thread_quarantine_size, u32 max_reuse);
94 void GetNumberOfThreads(uptr *total = nullptr, uptr *running = nullptr,
95 uptr *alive = nullptr);
96 uptr GetMaxAliveThreads();
97
98 void Lock() SANITIZER_ACQUIRE() { mtx_.Lock(); }
99 void CheckLocked() const SANITIZER_CHECK_LOCKED() { mtx_.CheckLocked(); }
100 void Unlock() SANITIZER_RELEASE() { mtx_.Unlock(); }
101
102 // Should be guarded by ThreadRegistryLock.
103 ThreadContextBase *GetThreadLocked(u32 tid) {
104 return threads_.empty() ? nullptr : threads_[tid];
105 }
106
107 u32 NumThreadsLocked() const { return threads_.size(); }
108
109 u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg);
110
111 typedef void (*ThreadCallback)(ThreadContextBase *tctx, void *arg);
112 // Invokes callback with a specified arg for each thread context.
113 // Should be guarded by ThreadRegistryLock.
114 void RunCallbackForEachThreadLocked(ThreadCallback cb, void *arg);
115
116 typedef bool (*FindThreadCallback)(ThreadContextBase *tctx, void *arg);
117 // Finds a thread using the provided callback. Returns kInvalidTid if no
118 // thread is found.
119 u32 FindThread(FindThreadCallback cb, void *arg);
120 // Should be guarded by ThreadRegistryLock. Return 0 if no thread
121 // is found.
122 ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb,
123 void *arg);
124 ThreadContextBase *FindThreadContextByOsIDLocked(tid_t os_id);
125
126 void SetThreadName(u32 tid, const char *name);
127 void SetThreadNameByUserId(uptr user_id, const char *name);
128 void DetachThread(u32 tid, void *arg);
129 void JoinThread(u32 tid, void *arg);
130 // Finishes thread and returns previous status.
131 ThreadStatus FinishThread(u32 tid);
132 void StartThread(u32 tid, tid_t os_id, ThreadType thread_type, void *arg);
133 u32 ConsumeThreadUserId(uptr user_id);
134 void SetThreadUserId(u32 tid, uptr user_id);
135
136 // OnFork must be called in the child process after fork to purge old
137 // threads that don't exist anymore (except for the current thread tid).
138 // Returns number of alive threads before fork.
139 u32 OnFork(u32 tid);
140
141 private:
142 const ThreadContextFactory context_factory_;
143 const u32 max_threads_;
144 const u32 thread_quarantine_size_;
145 const u32 max_reuse_;
146
147 Mutex mtx_;
148
149 u64 total_threads_; // Total number of created threads. May be greater than
150 // max_threads_ if contexts were reused.
151 uptr alive_threads_; // Created or running.
152 uptr max_alive_threads_;
153 uptr running_threads_;
154
155 InternalMmapVector<ThreadContextBase *> threads_;
156 IntrusiveList<ThreadContextBase> dead_threads_;
157 IntrusiveList<ThreadContextBase> invalid_threads_;
158 DenseMap<uptr, Tid> live_;
159
160 void QuarantinePush(ThreadContextBase *tctx);
161 ThreadContextBase *QuarantinePop();
162 };
163
164 typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock;
165
166 } // namespace __sanitizer
167
168 #endif // SANITIZER_THREAD_REGISTRY_H