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