Home | History | Annotate | Download | only in sanitizer_common 
      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 #ifndef SANITIZER_GO  // Go does not have libstdc++
     38   virtual
     39 #endif
     40   ~ThreadContextBase();
     41 
     42   const u32 tid;  // Thread ID. Main thread should have tid = 0.
     43   u64 unique_id;  // Unique thread ID.
     44   uptr os_id;     // PID (used for reporting).
     45   uptr user_id;   // Some opaque user thread id (e.g. pthread_t).
     46   char name[64];  // As annotated by user.
     47 
     48   ThreadStatus status;
     49   bool detached;
     50   int reuse_count;
     51 
     52   u32 parent_tid;
     53   ThreadContextBase *next;  // For storing thread contexts in a list.
     54 
     55   void SetName(const char *new_name);
     56 
     57   void SetDead();
     58   void SetJoined(void *arg);
     59   void SetFinished();
     60   void SetStarted(uptr _os_id, void *arg);
     61   void SetCreated(uptr _user_id, u64 _unique_id, bool _detached,
     62                   u32 _parent_tid, void *arg);
     63   void Reset(void *arg);
     64 
     65   // The following methods may be overriden by subclasses.
     66   // Some of them take opaque arg that may be optionally be used
     67   // by subclasses.
     68   virtual void OnDead() {}
     69   virtual void OnJoined(void *arg) {}
     70   virtual void OnFinished() {}
     71   virtual void OnStarted(void *arg) {}
     72   virtual void OnCreated(void *arg) {}
     73   virtual void OnReset(void *arg) {}
     74 };
     75 
     76 typedef ThreadContextBase* (*ThreadContextFactory)(u32 tid);
     77 
     78 class ThreadRegistry {
     79  public:
     80   static const u32 kUnknownTid;
     81 
     82   ThreadRegistry(ThreadContextFactory factory, u32 max_threads,
     83                  u32 thread_quarantine_size);
     84   void GetNumberOfThreads(uptr *total = 0, uptr *running = 0, uptr *alive = 0);
     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. Returns 0 if no thread
    109   // is found.
    110   ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb,
    111                                              void *arg);
    112 
    113   void SetThreadName(u32 tid, const char *name);
    114   void DetachThread(u32 tid);
    115   void JoinThread(u32 tid, void *arg);
    116   void FinishThread(u32 tid);
    117   void StartThread(u32 tid, uptr os_id, void *arg);
    118 
    119  private:
    120   const ThreadContextFactory context_factory_;
    121   const u32 max_threads_;
    122   const u32 thread_quarantine_size_;
    123 
    124   BlockingMutex mtx_;
    125 
    126   u32 n_contexts_;      // Number of created thread contexts,
    127                         // at most max_threads_.
    128   u64 total_threads_;   // Total number of created threads. May be greater than
    129                         // max_threads_ if contexts were reused.
    130   uptr alive_threads_;  // Created or running.
    131   uptr max_alive_threads_;
    132   uptr running_threads_;
    133 
    134   ThreadContextBase **threads_;  // Array of thread contexts is leaked.
    135   IntrusiveList<ThreadContextBase> dead_threads_;
    136 };
    137 
    138 typedef GenericScopedLock<ThreadRegistry> ThreadRegistryLock;
    139 
    140 }  // namespace __sanitizer
    141 
    142 #endif  // SANITIZER_THREAD_REGISTRY_H
    143 
    144