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
22namespace __sanitizer {
23
24enum 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.
34class 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  uptr 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
49  u32 parent_tid;
50  ThreadContextBase *next;  // For storing thread contexts in a list.
51
52  void SetName(const char *new_name);
53
54  void SetDead();
55  void SetJoined(void *arg);
56  void SetFinished();
57  void SetStarted(uptr _os_id, void *arg);
58  void SetCreated(uptr _user_id, u64 _unique_id, bool _detached,
59                  u32 _parent_tid, void *arg);
60  void Reset();
61
62  // The following methods may be overriden by subclasses.
63  // Some of them take opaque arg that may be optionally be used
64  // by subclasses.
65  virtual void OnDead() {}
66  virtual void OnJoined(void *arg) {}
67  virtual void OnFinished() {}
68  virtual void OnStarted(void *arg) {}
69  virtual void OnCreated(void *arg) {}
70  virtual void OnReset() {}
71  virtual void OnDetached(void *arg) {}
72};
73
74typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
75
76class ThreadRegistry {
77 public:
78  static const u32 kUnknownTid;
79
80  ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
81                 u32 thread_quarantine_size, u32 max_reuse = 0);
82  void GetNumberOfThreads(uptr *total = nullptr, uptr *running = nullptr,
83                          uptr *alive = nullptr);
84  uptr GetMaxAliveThreads();
85
86  void Lock() { mtx_.Lock(); }
87  void CheckLocked() { mtx_.CheckLocked(); }
88  void Unlock() { mtx_.Unlock(); }
89
90  // Should be guarded by ThreadRegistryLock.
91  ThreadContextBase *GetThreadLocked(u32 tid) {
92    DCHECK_LT(tid, n_contexts_);
93    return threads_[tid];
94  }
95
96  u32 CreateThread(uptr user_id, bool detached, u32 parent_tid, void *arg);
97
98  typedef void (*ThreadCallback)(ThreadContextBase *tctx, void *arg);
99  // Invokes callback with a specified arg for each thread context.
100  // Should be guarded by ThreadRegistryLock.
101  void RunCallbackForEachThreadLocked(ThreadCallback cb, void *arg);
102
103  typedef bool (*FindThreadCallback)(ThreadContextBase *tctx, void *arg);
104  // Finds a thread using the provided callback. Returns kUnknownTid if no
105  // thread is found.
106  u32 FindThread(FindThreadCallback cb, void *arg);
107  // Should be guarded by ThreadRegistryLock. Return 0 if no thread
108  // is found.
109  ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb,
110                                             void *arg);
111  ThreadContextBase *FindThreadContextByOsIDLocked(uptr os_id);
112
113  void SetThreadName(u32 tid, const char *name);
114  void SetThreadNameByUserId(uptr user_id, const char *name);
115  void DetachThread(u32 tid, void *arg);
116  void JoinThread(u32 tid, void *arg);
117  void FinishThread(u32 tid);
118  void StartThread(u32 tid, uptr os_id, void *arg);
119
120 private:
121  const ThreadContextFactory context_factory_;
122  const u32 max_threads_;
123  const u32 thread_quarantine_size_;
124  const u32 max_reuse_;
125
126  BlockingMutex mtx_;
127
128  u32 n_contexts_;      // Number of created thread contexts,
129                        // at most max_threads_.
130  u64 total_threads_;   // Total number of created threads. May be greater than
131                        // max_threads_ if contexts were reused.
132  uptr alive_threads_;  // Created or running.
133  uptr max_alive_threads_;
134  uptr running_threads_;
135
136  ThreadContextBase **threads_;  // Array of thread contexts is leaked.
137  IntrusiveList<ThreadContextBase> dead_threads_;
138  IntrusiveList<ThreadContextBase> invalid_threads_;
139
140  void QuarantinePush(ThreadContextBase *tctx);
141  ThreadContextBase *QuarantinePop();
142};
143
144typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock;
145
146} // namespace __sanitizer
147
148#endif // SANITIZER_THREAD_REGISTRY_H
149