1 //===-- tsan_report.cpp ---------------------------------------------------===//
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 ThreadSanitizer (TSan), a race detector.
10 //
11 //===----------------------------------------------------------------------===//
12 #include "tsan_report.h"
13 #include "tsan_platform.h"
14 #include "tsan_rtl.h"
15 #include "sanitizer_common/sanitizer_file.h"
16 #include "sanitizer_common/sanitizer_placement_new.h"
17 #include "sanitizer_common/sanitizer_report_decorator.h"
18 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
19
20 namespace __tsan {
21
22 class Decorator: public __sanitizer::SanitizerCommonDecorator {
23 public:
Decorator()24 Decorator() : SanitizerCommonDecorator() { }
Access()25 const char *Access() { return Blue(); }
ThreadDescription()26 const char *ThreadDescription() { return Cyan(); }
Location()27 const char *Location() { return Green(); }
Sleep()28 const char *Sleep() { return Yellow(); }
Mutex()29 const char *Mutex() { return Magenta(); }
30 };
31
ReportDesc()32 ReportDesc::ReportDesc()
33 : tag(kExternalTagNone)
34 , stacks()
35 , mops()
36 , locs()
37 , mutexes()
38 , threads()
39 , unique_tids()
40 , sleep()
41 , count() {
42 }
43
ReportMop()44 ReportMop::ReportMop()
45 : mset() {
46 }
47
~ReportDesc()48 ReportDesc::~ReportDesc() {
49 // FIXME(dvyukov): it must be leaking a lot of memory.
50 }
51
52 #if !SANITIZER_GO
53
54 const int kThreadBufSize = 32;
thread_name(char * buf,Tid tid)55 const char *thread_name(char *buf, Tid tid) {
56 if (tid == kMainTid)
57 return "main thread";
58 internal_snprintf(buf, kThreadBufSize, "thread T%d", tid);
59 return buf;
60 }
61
ReportTypeString(ReportType typ,uptr tag)62 static const char *ReportTypeString(ReportType typ, uptr tag) {
63 switch (typ) {
64 case ReportTypeRace:
65 return "data race";
66 case ReportTypeVptrRace:
67 return "data race on vptr (ctor/dtor vs virtual call)";
68 case ReportTypeUseAfterFree:
69 return "heap-use-after-free";
70 case ReportTypeVptrUseAfterFree:
71 return "heap-use-after-free (virtual call vs free)";
72 case ReportTypeExternalRace: {
73 const char *str = GetReportHeaderFromTag(tag);
74 return str ? str : "race on external object";
75 }
76 case ReportTypeThreadLeak:
77 return "thread leak";
78 case ReportTypeMutexDestroyLocked:
79 return "destroy of a locked mutex";
80 case ReportTypeMutexDoubleLock:
81 return "double lock of a mutex";
82 case ReportTypeMutexInvalidAccess:
83 return "use of an invalid mutex (e.g. uninitialized or destroyed)";
84 case ReportTypeMutexBadUnlock:
85 return "unlock of an unlocked mutex (or by a wrong thread)";
86 case ReportTypeMutexBadReadLock:
87 return "read lock of a write locked mutex";
88 case ReportTypeMutexBadReadUnlock:
89 return "read unlock of a write locked mutex";
90 case ReportTypeSignalUnsafe:
91 return "signal-unsafe call inside of a signal";
92 case ReportTypeErrnoInSignal:
93 return "signal handler spoils errno";
94 case ReportTypeDeadlock:
95 return "lock-order-inversion (potential deadlock)";
96 case ReportTypeMutexHeldWrongContext:
97 return "mutex held in the wrong context";
98 // No default case so compiler warns us if we miss one
99 }
100 UNREACHABLE("missing case");
101 }
102
PrintStack(const ReportStack * ent)103 void PrintStack(const ReportStack *ent) {
104 if (ent == 0 || ent->frames == 0) {
105 Printf(" [failed to restore the stack]\n\n");
106 return;
107 }
108 SymbolizedStack *frame = ent->frames;
109 for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
110 InternalScopedString res;
111 StackTracePrinter::GetOrInit()->RenderFrame(
112 &res, common_flags()->stack_trace_format, i, frame->info.address,
113 &frame->info, common_flags()->symbolize_vs_style,
114 common_flags()->strip_path_prefix);
115 Printf("%s\n", res.data());
116 }
117 Printf("\n");
118 }
119
PrintMutexSet(Vector<ReportMopMutex> const & mset)120 static void PrintMutexSet(Vector<ReportMopMutex> const& mset) {
121 for (uptr i = 0; i < mset.Size(); i++) {
122 if (i == 0)
123 Printf(" (mutexes:");
124 const ReportMopMutex m = mset[i];
125 Printf(" %s M%u", m.write ? "write" : "read", m.id);
126 Printf(i == mset.Size() - 1 ? ")" : ",");
127 }
128 }
129
MopDesc(bool first,bool write,bool atomic)130 static const char *MopDesc(bool first, bool write, bool atomic) {
131 return atomic ? (first ? (write ? "Atomic write" : "Atomic read")
132 : (write ? "Previous atomic write" : "Previous atomic read"))
133 : (first ? (write ? "Write" : "Read")
134 : (write ? "Previous write" : "Previous read"));
135 }
136
ExternalMopDesc(bool first,bool write)137 static const char *ExternalMopDesc(bool first, bool write) {
138 return first ? (write ? "Modifying" : "Read-only")
139 : (write ? "Previous modifying" : "Previous read-only");
140 }
141
PrintMop(const ReportMop * mop,bool first)142 static void PrintMop(const ReportMop *mop, bool first) {
143 Decorator d;
144 char thrbuf[kThreadBufSize];
145 Printf("%s", d.Access());
146 if (mop->external_tag == kExternalTagNone) {
147 Printf(" %s of size %d at %p by %s",
148 MopDesc(first, mop->write, mop->atomic), mop->size,
149 (void *)mop->addr, thread_name(thrbuf, mop->tid));
150 } else {
151 const char *object_type = GetObjectTypeFromTag(mop->external_tag);
152 if (object_type == nullptr)
153 object_type = "external object";
154 Printf(" %s access of %s at %p by %s",
155 ExternalMopDesc(first, mop->write), object_type,
156 (void *)mop->addr, thread_name(thrbuf, mop->tid));
157 }
158 PrintMutexSet(mop->mset);
159 Printf(":\n");
160 Printf("%s", d.Default());
161 PrintStack(mop->stack);
162 }
163
PrintLocation(const ReportLocation * loc)164 static void PrintLocation(const ReportLocation *loc) {
165 Decorator d;
166 char thrbuf[kThreadBufSize];
167 bool print_stack = false;
168 Printf("%s", d.Location());
169 if (loc->type == ReportLocationGlobal) {
170 const DataInfo &global = loc->global;
171 if (global.size != 0)
172 Printf(" Location is global '%s' of size %zu at %p (%s+0x%zx)\n\n",
173 global.name, global.size, reinterpret_cast<void *>(global.start),
174 StripModuleName(global.module), global.module_offset);
175 else
176 Printf(" Location is global '%s' at %p (%s+0x%zx)\n\n", global.name,
177 reinterpret_cast<void *>(global.start),
178 StripModuleName(global.module), global.module_offset);
179 } else if (loc->type == ReportLocationHeap) {
180 char thrbuf[kThreadBufSize];
181 const char *object_type = GetObjectTypeFromTag(loc->external_tag);
182 if (!object_type) {
183 Printf(" Location is heap block of size %zu at %p allocated by %s:\n",
184 loc->heap_chunk_size,
185 reinterpret_cast<void *>(loc->heap_chunk_start),
186 thread_name(thrbuf, loc->tid));
187 } else {
188 Printf(" Location is %s of size %zu at %p allocated by %s:\n",
189 object_type, loc->heap_chunk_size,
190 reinterpret_cast<void *>(loc->heap_chunk_start),
191 thread_name(thrbuf, loc->tid));
192 }
193 print_stack = true;
194 } else if (loc->type == ReportLocationStack) {
195 Printf(" Location is stack of %s.\n\n", thread_name(thrbuf, loc->tid));
196 } else if (loc->type == ReportLocationTLS) {
197 Printf(" Location is TLS of %s.\n\n", thread_name(thrbuf, loc->tid));
198 } else if (loc->type == ReportLocationFD) {
199 Printf(" Location is file descriptor %d %s by %s at:\n", loc->fd,
200 loc->fd_closed ? "destroyed" : "created",
201 thread_name(thrbuf, loc->tid));
202 print_stack = true;
203 }
204 Printf("%s", d.Default());
205 if (print_stack)
206 PrintStack(loc->stack);
207 }
208
PrintMutexShort(const ReportMutex * rm,const char * after)209 static void PrintMutexShort(const ReportMutex *rm, const char *after) {
210 Decorator d;
211 Printf("%sM%d%s%s", d.Mutex(), rm->id, d.Default(), after);
212 }
213
PrintMutexShortWithAddress(const ReportMutex * rm,const char * after)214 static void PrintMutexShortWithAddress(const ReportMutex *rm,
215 const char *after) {
216 Decorator d;
217 Printf("%sM%d (%p)%s%s", d.Mutex(), rm->id,
218 reinterpret_cast<void *>(rm->addr), d.Default(), after);
219 }
220
PrintMutex(const ReportMutex * rm)221 static void PrintMutex(const ReportMutex *rm) {
222 Decorator d;
223 Printf("%s", d.Mutex());
224 Printf(" Mutex M%u (%p) created at:\n", rm->id,
225 reinterpret_cast<void *>(rm->addr));
226 Printf("%s", d.Default());
227 PrintStack(rm->stack);
228 }
229
PrintThread(const ReportThread * rt)230 static void PrintThread(const ReportThread *rt) {
231 Decorator d;
232 if (rt->id == kMainTid) // Little sense in describing the main thread.
233 return;
234 Printf("%s", d.ThreadDescription());
235 Printf(" Thread T%d", rt->id);
236 if (rt->name && rt->name[0] != '\0')
237 Printf(" '%s'", rt->name);
238 char thrbuf[kThreadBufSize];
239 const char *thread_status = rt->running ? "running" : "finished";
240 if (rt->thread_type == ThreadType::Worker) {
241 Printf(" (tid=%llu, %s) is a GCD worker thread\n", rt->os_id,
242 thread_status);
243 Printf("\n");
244 Printf("%s", d.Default());
245 return;
246 }
247 Printf(" (tid=%llu, %s) created by %s", rt->os_id, thread_status,
248 thread_name(thrbuf, rt->parent_tid));
249 if (rt->stack)
250 Printf(" at:");
251 Printf("\n");
252 Printf("%s", d.Default());
253 PrintStack(rt->stack);
254 }
255
PrintSleep(const ReportStack * s)256 static void PrintSleep(const ReportStack *s) {
257 Decorator d;
258 Printf("%s", d.Sleep());
259 Printf(" As if synchronized via sleep:\n");
260 Printf("%s", d.Default());
261 PrintStack(s);
262 }
263
ChooseSummaryStack(const ReportDesc * rep)264 static ReportStack *ChooseSummaryStack(const ReportDesc *rep) {
265 if (rep->mops.Size())
266 return rep->mops[0]->stack;
267 if (rep->stacks.Size())
268 return rep->stacks[0];
269 if (rep->mutexes.Size())
270 return rep->mutexes[0]->stack;
271 if (rep->threads.Size())
272 return rep->threads[0]->stack;
273 return 0;
274 }
275
SkipTsanInternalFrames(SymbolizedStack * frames)276 static const SymbolizedStack *SkipTsanInternalFrames(SymbolizedStack *frames) {
277 if (const SymbolizedStack *f = SkipInternalFrames(frames))
278 return f;
279 return frames; // Fallback to the top frame.
280 }
281
PrintReport(const ReportDesc * rep)282 void PrintReport(const ReportDesc *rep) {
283 Decorator d;
284 Printf("==================\n");
285 const char *rep_typ_str = ReportTypeString(rep->typ, rep->tag);
286 Printf("%s", d.Warning());
287 Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str,
288 (int)internal_getpid());
289 Printf("%s", d.Default());
290
291 if (rep->typ == ReportTypeErrnoInSignal)
292 Printf(" Signal %u handler invoked at:\n", rep->signum);
293
294 if (rep->typ == ReportTypeDeadlock) {
295 char thrbuf[kThreadBufSize];
296 Printf(" Cycle in lock order graph: ");
297 for (uptr i = 0; i < rep->mutexes.Size(); i++)
298 PrintMutexShortWithAddress(rep->mutexes[i], " => ");
299 PrintMutexShort(rep->mutexes[0], "\n\n");
300 CHECK_GT(rep->mutexes.Size(), 0U);
301 CHECK_EQ(rep->mutexes.Size() * (flags()->second_deadlock_stack ? 2 : 1),
302 rep->stacks.Size());
303 for (uptr i = 0; i < rep->mutexes.Size(); i++) {
304 Printf(" Mutex ");
305 PrintMutexShort(rep->mutexes[(i + 1) % rep->mutexes.Size()],
306 " acquired here while holding mutex ");
307 PrintMutexShort(rep->mutexes[i], " in ");
308 Printf("%s", d.ThreadDescription());
309 Printf("%s:\n", thread_name(thrbuf, rep->unique_tids[i]));
310 Printf("%s", d.Default());
311 if (flags()->second_deadlock_stack) {
312 PrintStack(rep->stacks[2*i]);
313 Printf(" Mutex ");
314 PrintMutexShort(rep->mutexes[i],
315 " previously acquired by the same thread here:\n");
316 PrintStack(rep->stacks[2*i+1]);
317 } else {
318 PrintStack(rep->stacks[i]);
319 if (i == 0)
320 Printf(" Hint: use TSAN_OPTIONS=second_deadlock_stack=1 "
321 "to get more informative warning message\n\n");
322 }
323 }
324 } else {
325 for (uptr i = 0; i < rep->stacks.Size(); i++) {
326 if (i)
327 Printf(" and:\n");
328 PrintStack(rep->stacks[i]);
329 }
330 }
331
332 for (uptr i = 0; i < rep->mops.Size(); i++)
333 PrintMop(rep->mops[i], i == 0);
334
335 if (rep->sleep)
336 PrintSleep(rep->sleep);
337
338 for (uptr i = 0; i < rep->locs.Size(); i++)
339 PrintLocation(rep->locs[i]);
340
341 if (rep->typ != ReportTypeDeadlock) {
342 for (uptr i = 0; i < rep->mutexes.Size(); i++)
343 PrintMutex(rep->mutexes[i]);
344 }
345
346 for (uptr i = 0; i < rep->threads.Size(); i++)
347 PrintThread(rep->threads[i]);
348
349 if (rep->typ == ReportTypeThreadLeak && rep->count > 1)
350 Printf(" And %d more similar thread leaks.\n\n", rep->count - 1);
351
352 if (ReportStack *stack = ChooseSummaryStack(rep)) {
353 if (const SymbolizedStack *frame = SkipTsanInternalFrames(stack->frames))
354 ReportErrorSummary(rep_typ_str, frame->info);
355 }
356
357 if (common_flags()->print_module_map == 2)
358 DumpProcessMap();
359
360 Printf("==================\n");
361 }
362
363 #else // #if !SANITIZER_GO
364
365 const Tid kMainGoroutineId = 1;
366
PrintStack(const ReportStack * ent)367 void PrintStack(const ReportStack *ent) {
368 if (ent == 0 || ent->frames == 0) {
369 Printf(" [failed to restore the stack]\n");
370 return;
371 }
372 SymbolizedStack *frame = ent->frames;
373 for (int i = 0; frame; frame = frame->next, i++) {
374 const AddressInfo &info = frame->info;
375 Printf(" %s()\n %s:%d +0x%zx\n", info.function,
376 StripPathPrefix(info.file, common_flags()->strip_path_prefix),
377 info.line, info.module_offset);
378 }
379 }
380
PrintMop(const ReportMop * mop,bool first)381 static void PrintMop(const ReportMop *mop, bool first) {
382 Printf("\n");
383 Printf("%s at %p by ",
384 (first ? (mop->write ? "Write" : "Read")
385 : (mop->write ? "Previous write" : "Previous read")),
386 reinterpret_cast<void *>(mop->addr));
387 if (mop->tid == kMainGoroutineId)
388 Printf("main goroutine:\n");
389 else
390 Printf("goroutine %d:\n", mop->tid);
391 PrintStack(mop->stack);
392 }
393
PrintLocation(const ReportLocation * loc)394 static void PrintLocation(const ReportLocation *loc) {
395 switch (loc->type) {
396 case ReportLocationHeap: {
397 Printf("\n");
398 Printf("Heap block of size %zu at %p allocated by ", loc->heap_chunk_size,
399 reinterpret_cast<void *>(loc->heap_chunk_start));
400 if (loc->tid == kMainGoroutineId)
401 Printf("main goroutine:\n");
402 else
403 Printf("goroutine %d:\n", loc->tid);
404 PrintStack(loc->stack);
405 break;
406 }
407 case ReportLocationGlobal: {
408 Printf("\n");
409 Printf("Global var %s of size %zu at %p declared at %s:%zu\n",
410 loc->global.name, loc->global.size,
411 reinterpret_cast<void *>(loc->global.start), loc->global.file,
412 loc->global.line);
413 break;
414 }
415 default:
416 break;
417 }
418 }
419
PrintThread(const ReportThread * rt)420 static void PrintThread(const ReportThread *rt) {
421 if (rt->id == kMainGoroutineId)
422 return;
423 Printf("\n");
424 Printf("Goroutine %d (%s) created at:\n",
425 rt->id, rt->running ? "running" : "finished");
426 PrintStack(rt->stack);
427 }
428
PrintReport(const ReportDesc * rep)429 void PrintReport(const ReportDesc *rep) {
430 Printf("==================\n");
431 if (rep->typ == ReportTypeRace) {
432 Printf("WARNING: DATA RACE");
433 for (uptr i = 0; i < rep->mops.Size(); i++)
434 PrintMop(rep->mops[i], i == 0);
435 for (uptr i = 0; i < rep->locs.Size(); i++)
436 PrintLocation(rep->locs[i]);
437 for (uptr i = 0; i < rep->threads.Size(); i++)
438 PrintThread(rep->threads[i]);
439 } else if (rep->typ == ReportTypeDeadlock) {
440 Printf("WARNING: DEADLOCK\n");
441 for (uptr i = 0; i < rep->mutexes.Size(); i++) {
442 Printf("Goroutine %d lock mutex %u while holding mutex %u:\n", 999,
443 rep->mutexes[i]->id,
444 rep->mutexes[(i + 1) % rep->mutexes.Size()]->id);
445 PrintStack(rep->stacks[2*i]);
446 Printf("\n");
447 Printf("Mutex %u was previously locked here:\n",
448 rep->mutexes[(i + 1) % rep->mutexes.Size()]->id);
449 PrintStack(rep->stacks[2*i + 1]);
450 Printf("\n");
451 }
452 }
453 Printf("==================\n");
454 }
455
456 #endif
457
458 } // namespace __tsan
459