contrib/compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.h

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