1 //===-- sanitizer_deadlock_detector_interface.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 a part of Sanitizer runtime.
10 // Abstract deadlock detector interface.
11 // FIXME: this is work in progress, nothing really works yet.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef SANITIZER_DEADLOCK_DETECTOR_INTERFACE_H
16 #define SANITIZER_DEADLOCK_DETECTOR_INTERFACE_H
17 
18 #ifndef SANITIZER_DEADLOCK_DETECTOR_VERSION
19 # define SANITIZER_DEADLOCK_DETECTOR_VERSION 1
20 #endif
21 
22 #include "sanitizer_internal_defs.h"
23 #include "sanitizer_atomic.h"
24 
25 namespace __sanitizer {
26 
27 // dd - deadlock detector.
28 // lt - logical (user) thread.
29 // pt - physical (OS) thread.
30 
31 struct DDPhysicalThread;
32 struct DDLogicalThread;
33 
34 struct DDMutex {
35 #if SANITIZER_DEADLOCK_DETECTOR_VERSION == 1
36   uptr id;
37   u32  stk;  // creation stack
38 #elif SANITIZER_DEADLOCK_DETECTOR_VERSION == 2
39   u32              id;
40   u32              recursion;
41   atomic_uintptr_t owner;
42 #else
43 # error "BAD SANITIZER_DEADLOCK_DETECTOR_VERSION"
44 #endif
45   u64  ctx;
46 };
47 
48 struct DDFlags {
49   bool second_deadlock_stack;
50 };
51 
52 struct DDReport {
53   enum { kMaxLoopSize = 20 };
54   int n;  // number of entries in loop
55   struct {
56     u64 thr_ctx;   // user thread context
57     u64 mtx_ctx0;  // user mutex context, start of the edge
58     u64 mtx_ctx1;  // user mutex context, end of the edge
59     u32 stk[2];  // stack ids for the edge
60   } loop[kMaxLoopSize];
61 };
62 
63 struct DDCallback {
64   DDPhysicalThread *pt;
65   DDLogicalThread  *lt;
66 
67   virtual u32 Unwind() { return 0; }
68   virtual int UniqueTid() { return 0; }
69 
70  protected:
71   ~DDCallback() {}
72 };
73 
74 struct DDetector {
75   static DDetector *Create(const DDFlags *flags);
76 
77   virtual DDPhysicalThread* CreatePhysicalThread() { return nullptr; }
78   virtual void DestroyPhysicalThread(DDPhysicalThread *pt) {}
79 
80   virtual DDLogicalThread* CreateLogicalThread(u64 ctx) { return nullptr; }
81   virtual void DestroyLogicalThread(DDLogicalThread *lt) {}
82 
83   virtual void MutexInit(DDCallback *cb, DDMutex *m) {}
84   virtual void MutexBeforeLock(DDCallback *cb, DDMutex *m, bool wlock) {}
85   virtual void MutexAfterLock(DDCallback *cb, DDMutex *m, bool wlock,
86       bool trylock) {}
87   virtual void MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock) {}
88   virtual void MutexDestroy(DDCallback *cb, DDMutex *m) {}
89 
90   virtual DDReport *GetReport(DDCallback *cb) { return nullptr; }
91 
92  protected:
93   ~DDetector() {}
94 };
95 
96 } // namespace __sanitizer
97 
98 #endif // SANITIZER_DEADLOCK_DETECTOR_INTERFACE_H
99