1 //===-- tsan_debugging.cc -------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is a part of ThreadSanitizer (TSan), a race detector.
12 // TSan debugging API implementation.
13 //===----------------------------------------------------------------------===//
14 #include "tsan_interface.h"
15 #include "tsan_report.h"
18 #include "sanitizer_common/sanitizer_stackdepot.h"
20 using namespace __tsan;
22 static const char *ReportTypeDescription(ReportType typ) {
24 case ReportTypeRace: return "data-race";
25 case ReportTypeVptrRace: return "data-race-vptr";
26 case ReportTypeUseAfterFree: return "heap-use-after-free";
27 case ReportTypeVptrUseAfterFree: return "heap-use-after-free-vptr";
28 case ReportTypeExternalRace: return "external-race";
29 case ReportTypeThreadLeak: return "thread-leak";
30 case ReportTypeMutexDestroyLocked: return "locked-mutex-destroy";
31 case ReportTypeMutexDoubleLock: return "mutex-double-lock";
32 case ReportTypeMutexInvalidAccess: return "mutex-invalid-access";
33 case ReportTypeMutexBadUnlock: return "mutex-bad-unlock";
34 case ReportTypeMutexBadReadLock: return "mutex-bad-read-lock";
35 case ReportTypeMutexBadReadUnlock: return "mutex-bad-read-unlock";
36 case ReportTypeSignalUnsafe: return "signal-unsafe-call";
37 case ReportTypeErrnoInSignal: return "errno-in-signal-handler";
38 case ReportTypeDeadlock: return "lock-order-inversion";
39 // No default case so compiler warns us if we miss one
41 UNREACHABLE("missing case");
44 static const char *ReportLocationTypeDescription(ReportLocationType typ) {
46 case ReportLocationGlobal: return "global";
47 case ReportLocationHeap: return "heap";
48 case ReportLocationStack: return "stack";
49 case ReportLocationTLS: return "tls";
50 case ReportLocationFD: return "fd";
51 // No default case so compiler warns us if we miss one
53 UNREACHABLE("missing case");
56 static void CopyTrace(SymbolizedStack *first_frame, void **trace,
59 for (SymbolizedStack *frame = first_frame; frame != nullptr;
60 frame = frame->next) {
61 trace[i++] = (void *)frame->info.address;
62 if (i >= trace_size) break;
66 // Meant to be called by the debugger.
67 SANITIZER_INTERFACE_ATTRIBUTE
68 void *__tsan_get_current_report() {
69 return const_cast<ReportDesc*>(cur_thread()->current_report);
72 SANITIZER_INTERFACE_ATTRIBUTE
73 int __tsan_get_report_data(void *report, const char **description, int *count,
74 int *stack_count, int *mop_count, int *loc_count,
75 int *mutex_count, int *thread_count,
76 int *unique_tid_count, void **sleep_trace,
78 const ReportDesc *rep = (ReportDesc *)report;
79 *description = ReportTypeDescription(rep->typ);
81 *stack_count = rep->stacks.Size();
82 *mop_count = rep->mops.Size();
83 *loc_count = rep->locs.Size();
84 *mutex_count = rep->mutexes.Size();
85 *thread_count = rep->threads.Size();
86 *unique_tid_count = rep->unique_tids.Size();
87 if (rep->sleep) CopyTrace(rep->sleep->frames, sleep_trace, trace_size);
91 SANITIZER_INTERFACE_ATTRIBUTE
92 int __tsan_get_report_tag(void *report, uptr *tag) {
93 const ReportDesc *rep = (ReportDesc *)report;
98 SANITIZER_INTERFACE_ATTRIBUTE
99 int __tsan_get_report_stack(void *report, uptr idx, void **trace,
101 const ReportDesc *rep = (ReportDesc *)report;
102 CHECK_LT(idx, rep->stacks.Size());
103 ReportStack *stack = rep->stacks[idx];
104 if (stack) CopyTrace(stack->frames, trace, trace_size);
105 return stack ? 1 : 0;
108 SANITIZER_INTERFACE_ATTRIBUTE
109 int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr,
110 int *size, int *write, int *atomic, void **trace,
112 const ReportDesc *rep = (ReportDesc *)report;
113 CHECK_LT(idx, rep->mops.Size());
114 ReportMop *mop = rep->mops[idx];
116 *addr = (void *)mop->addr;
118 *write = mop->write ? 1 : 0;
119 *atomic = mop->atomic ? 1 : 0;
120 if (mop->stack) CopyTrace(mop->stack->frames, trace, trace_size);
124 SANITIZER_INTERFACE_ATTRIBUTE
125 int __tsan_get_report_loc(void *report, uptr idx, const char **type,
126 void **addr, uptr *start, uptr *size, int *tid,
127 int *fd, int *suppressable, void **trace,
129 const ReportDesc *rep = (ReportDesc *)report;
130 CHECK_LT(idx, rep->locs.Size());
131 ReportLocation *loc = rep->locs[idx];
132 *type = ReportLocationTypeDescription(loc->type);
133 *addr = (void *)loc->global.start;
134 *start = loc->heap_chunk_start;
135 *size = loc->heap_chunk_size;
138 *suppressable = loc->suppressable;
139 if (loc->stack) CopyTrace(loc->stack->frames, trace, trace_size);
143 SANITIZER_INTERFACE_ATTRIBUTE
144 int __tsan_get_report_loc_object_type(void *report, uptr idx,
145 const char **object_type) {
146 const ReportDesc *rep = (ReportDesc *)report;
147 CHECK_LT(idx, rep->locs.Size());
148 ReportLocation *loc = rep->locs[idx];
149 *object_type = GetObjectTypeFromTag(loc->external_tag);
153 SANITIZER_INTERFACE_ATTRIBUTE
154 int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr,
155 int *destroyed, void **trace, uptr trace_size) {
156 const ReportDesc *rep = (ReportDesc *)report;
157 CHECK_LT(idx, rep->mutexes.Size());
158 ReportMutex *mutex = rep->mutexes[idx];
159 *mutex_id = mutex->id;
160 *addr = (void *)mutex->addr;
161 *destroyed = mutex->destroyed;
162 if (mutex->stack) CopyTrace(mutex->stack->frames, trace, trace_size);
166 SANITIZER_INTERFACE_ATTRIBUTE
167 int __tsan_get_report_thread(void *report, uptr idx, int *tid, tid_t *os_id,
168 int *running, const char **name, int *parent_tid,
169 void **trace, uptr trace_size) {
170 const ReportDesc *rep = (ReportDesc *)report;
171 CHECK_LT(idx, rep->threads.Size());
172 ReportThread *thread = rep->threads[idx];
174 *os_id = thread->os_id;
175 *running = thread->running;
176 *name = thread->name;
177 *parent_tid = thread->parent_tid;
178 if (thread->stack) CopyTrace(thread->stack->frames, trace, trace_size);
182 SANITIZER_INTERFACE_ATTRIBUTE
183 int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid) {
184 const ReportDesc *rep = (ReportDesc *)report;
185 CHECK_LT(idx, rep->unique_tids.Size());
186 *tid = rep->unique_tids[idx];
190 SANITIZER_INTERFACE_ATTRIBUTE
191 const char *__tsan_locate_address(uptr addr, char *name, uptr name_size,
192 uptr *region_address_ptr,
193 uptr *region_size_ptr) {
194 uptr region_address = 0;
195 uptr region_size = 0;
196 const char *region_kind = nullptr;
197 if (name && name_size > 0) name[0] = 0;
199 if (IsMetaMem(addr)) {
200 region_kind = "meta shadow";
201 } else if (IsShadowMem(addr)) {
202 region_kind = "shadow";
204 bool is_stack = false;
206 Allocator *a = allocator();
207 if (a->PointerIsMine((void *)addr)) {
208 void *block_begin = a->GetBlockBegin((void *)addr);
209 if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin);
213 region_address = (uptr)allocator()->GetBlockBegin((void *)addr);
214 region_size = b->siz;
215 region_kind = "heap";
217 // TODO(kuba.brecka): We should not lock. This is supposed to be called
218 // from within the debugger when other threads are stopped.
219 ctx->thread_registry->Lock();
220 ThreadContext *tctx = IsThreadStackOrTls(addr, &is_stack);
221 ctx->thread_registry->Unlock();
223 region_kind = is_stack ? "stack" : "tls";
225 region_kind = "global";
227 if (Symbolizer::GetOrInit()->SymbolizeData(addr, &info)) {
228 internal_strncpy(name, info.name, name_size);
229 region_address = info.start;
230 region_size = info.size;
237 if (region_address_ptr) *region_address_ptr = region_address;
238 if (region_size_ptr) *region_size_ptr = region_size;
242 SANITIZER_INTERFACE_ATTRIBUTE
243 int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id,
246 Allocator *a = allocator();
247 if (a->PointerIsMine((void *)addr)) {
248 void *block_begin = a->GetBlockBegin((void *)addr);
249 if (block_begin) b = ctx->metamap.GetBlock((uptr)block_begin);
251 if (b == 0) return 0;
254 // No locking. This is supposed to be called from within the debugger when
255 // other threads are stopped.
256 ThreadContextBase *tctx = ctx->thread_registry->GetThreadLocked(b->tid);
257 *os_id = tctx->os_id;
259 StackTrace stack = StackDepotGet(b->stk);
260 size = Min(size, (uptr)stack.size);
261 for (uptr i = 0; i < size; i++) trace[i] = stack.trace[stack.size - i - 1];