libsanitizer/tsan/tsan_report.cpp

   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:
  24   Decorator() : SanitizerCommonDecorator() { }
  25   const char *Access()     { return Blue(); }
  26   const char *ThreadDescription()    { return Cyan(); }
  27   const char *Location()   { return Green(); }
  28   const char *Sleep()   { return Yellow(); }
  29   const char *Mutex()   { return Magenta(); }
  30 };
  31
  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
  44 ReportMop::ReportMop()
  45     : mset() {
  46 }
  47
  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;
  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
  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     // No default case so compiler warns us if we miss one
  97   }
  98   UNREACHABLE("missing case");
  99 }
 100
 101 #if SANITIZER_MAC
 102 static const char *const kInterposedFunctionPrefix = "wrap_";
 103 #else
 104 static const char *const kInterposedFunctionPrefix = "__interceptor_";
 105 #endif
 106
 107 void PrintStack(const ReportStack *ent) {
 108   if (ent == 0 || ent->frames == 0) {
 109     Printf("    [failed to restore the stack]\n\n");
 110     return;
 111   }
 112   SymbolizedStack *frame = ent->frames;
 113   for (int i = 0; frame && frame->info.address; frame = frame->next, i++) {
 114     InternalScopedString res;
 115     RenderFrame(&res, common_flags()->stack_trace_format, i,
 116                 frame->info.address, &frame->info,
 117                 common_flags()->symbolize_vs_style,
 118                 common_flags()->strip_path_prefix, kInterposedFunctionPrefix);
 119     Printf("%s\n", res.data());
 120   }
 121   Printf("\n");
 122 }
 123
 124 static void PrintMutexSet(Vector<ReportMopMutex> const& mset) {
 125   for (uptr i = 0; i < mset.Size(); i++) {
 126     if (i == 0)
 127       Printf(" (mutexes:");
 128     const ReportMopMutex m = mset[i];
 129     Printf(" %s M%llu", m.write ? "write" : "read", m.id);
 130     Printf(i == mset.Size() - 1 ? ")" : ",");
 131   }
 132 }
 133
 134 static const char *MopDesc(bool first, bool write, bool atomic) {
 135   return atomic ? (first ? (write ? "Atomic write" : "Atomic read")
 136                 : (write ? "Previous atomic write" : "Previous atomic read"))
 137                 : (first ? (write ? "Write" : "Read")
 138                 : (write ? "Previous write" : "Previous read"));
 139 }
 140
 141 static const char *ExternalMopDesc(bool first, bool write) {
 142   return first ? (write ? "Modifying" : "Read-only")
 143                : (write ? "Previous modifying" : "Previous read-only");
 144 }
 145
 146 static void PrintMop(const ReportMop *mop, bool first) {
 147   Decorator d;
 148   char thrbuf[kThreadBufSize];
 149   Printf("%s", d.Access());
 150   if (mop->external_tag == kExternalTagNone) {
 151     Printf("  %s of size %d at %p by %s",
 152            MopDesc(first, mop->write, mop->atomic), mop->size,
 153            (void *)mop->addr, thread_name(thrbuf, mop->tid));
 154   } else {
 155     const char *object_type = GetObjectTypeFromTag(mop->external_tag);
 156     if (object_type == nullptr)
 157         object_type = "external object";
 158     Printf("  %s access of %s at %p by %s",
 159            ExternalMopDesc(first, mop->write), object_type,
 160            (void *)mop->addr, thread_name(thrbuf, mop->tid));
 161   }
 162   PrintMutexSet(mop->mset);
 163   Printf(":\n");
 164   Printf("%s", d.Default());
 165   PrintStack(mop->stack);
 166 }
 167
 168 static void PrintLocation(const ReportLocation *loc) {
 169   Decorator d;
 170   char thrbuf[kThreadBufSize];
 171   bool print_stack = false;
 172   Printf("%s", d.Location());
 173   if (loc->type == ReportLocationGlobal) {
 174     const DataInfo &global = loc->global;
 175     if (global.size != 0)
 176       Printf("  Location is global '%s' of size %zu at %p (%s+0x%zx)\n\n",
 177              global.name, global.size, reinterpret_cast<void *>(global.start),
 178              StripModuleName(global.module), global.module_offset);
 179     else
 180       Printf("  Location is global '%s' at %p (%s+0x%zx)\n\n", global.name,
 181              reinterpret_cast<void *>(global.start),
 182              StripModuleName(global.module), global.module_offset);
 183   } else if (loc->type == ReportLocationHeap) {
 184     char thrbuf[kThreadBufSize];
 185     const char *object_type = GetObjectTypeFromTag(loc->external_tag);
 186     if (!object_type) {
 187       Printf("  Location is heap block of size %zu at %p allocated by %s:\n",
 188              loc->heap_chunk_size,
 189              reinterpret_cast<void *>(loc->heap_chunk_start),
 190              thread_name(thrbuf, loc->tid));
 191     } else {
 192       Printf("  Location is %s of size %zu at %p allocated by %s:\n",
 193              object_type, loc->heap_chunk_size,
 194              reinterpret_cast<void *>(loc->heap_chunk_start),
 195              thread_name(thrbuf, loc->tid));
 196     }
 197     print_stack = true;
 198   } else if (loc->type == ReportLocationStack) {
 199     Printf("  Location is stack of %s.\n\n", thread_name(thrbuf, loc->tid));
 200   } else if (loc->type == ReportLocationTLS) {
 201     Printf("  Location is TLS of %s.\n\n", thread_name(thrbuf, loc->tid));
 202   } else if (loc->type == ReportLocationFD) {
 203     Printf("  Location is file descriptor %d created by %s at:\n",
 204         loc->fd, thread_name(thrbuf, loc->tid));
 205     print_stack = true;
 206   }
 207   Printf("%s", d.Default());
 208   if (print_stack)
 209     PrintStack(loc->stack);
 210 }
 211
 212 static void PrintMutexShort(const ReportMutex *rm, const char *after) {
 213   Decorator d;
 214   Printf("%sM%lld%s%s", d.Mutex(), rm->id, d.Default(), after);
 215 }
 216
 217 static void PrintMutexShortWithAddress(const ReportMutex *rm,
 218                                        const char *after) {
 219   Decorator d;
 220   Printf("%sM%lld (%p)%s%s", d.Mutex(), rm->id,
 221          reinterpret_cast<void *>(rm->addr), d.Default(), after);
 222 }
 223
 224 static void PrintMutex(const ReportMutex *rm) {
 225   Decorator d;
 226   if (rm->destroyed) {
 227     Printf("%s", d.Mutex());
 228     Printf("  Mutex M%llu is already destroyed.\n\n", rm->id);
 229     Printf("%s", d.Default());
 230   } else {
 231     Printf("%s", d.Mutex());
 232     Printf("  Mutex M%llu (%p) created at:\n", rm->id,
 233            reinterpret_cast<void *>(rm->addr));
 234     Printf("%s", d.Default());
 235     PrintStack(rm->stack);
 236   }
 237 }
 238
 239 static void PrintThread(const ReportThread *rt) {
 240   Decorator d;
 241   if (rt->id == kMainTid)  // Little sense in describing the main thread.
 242     return;
 243   Printf("%s", d.ThreadDescription());
 244   Printf("  Thread T%d", rt->id);
 245   if (rt->name && rt->name[0] != '\0')
 246     Printf(" '%s'", rt->name);
 247   char thrbuf[kThreadBufSize];
 248   const char *thread_status = rt->running ? "running" : "finished";
 249   if (rt->thread_type == ThreadType::Worker) {
 250     Printf(" (tid=%llu, %s) is a GCD worker thread\n", rt->os_id,
 251            thread_status);
 252     Printf("\n");
 253     Printf("%s", d.Default());
 254     return;
 255   }
 256   Printf(" (tid=%llu, %s) created by %s", rt->os_id, thread_status,
 257          thread_name(thrbuf, rt->parent_tid));
 258   if (rt->stack)
 259     Printf(" at:");
 260   Printf("\n");
 261   Printf("%s", d.Default());
 262   PrintStack(rt->stack);
 263 }
 264
 265 static void PrintSleep(const ReportStack *s) {
 266   Decorator d;
 267   Printf("%s", d.Sleep());
 268   Printf("  As if synchronized via sleep:\n");
 269   Printf("%s", d.Default());
 270   PrintStack(s);
 271 }
 272
 273 static ReportStack *ChooseSummaryStack(const ReportDesc *rep) {
 274   if (rep->mops.Size())
 275     return rep->mops[0]->stack;
 276   if (rep->stacks.Size())
 277     return rep->stacks[0];
 278   if (rep->mutexes.Size())
 279     return rep->mutexes[0]->stack;
 280   if (rep->threads.Size())
 281     return rep->threads[0]->stack;
 282   return 0;
 283 }
 284
 285 static bool FrameIsInternal(const SymbolizedStack *frame) {
 286   if (frame == 0)
 287     return false;
 288   const char *file = frame->info.file;
 289   const char *module = frame->info.module;
 290   if (file != 0 &&
 291       (internal_strstr(file, "tsan_interceptors_posix.cpp") ||
 292        internal_strstr(file, "sanitizer_common_interceptors.inc") ||
 293        internal_strstr(file, "tsan_interface_")))
 294     return true;
 295   if (module != 0 && (internal_strstr(module, "libclang_rt.tsan_")))
 296     return true;
 297   return false;
 298 }
 299
 300 static SymbolizedStack *SkipTsanInternalFrames(SymbolizedStack *frames) {
 301   while (FrameIsInternal(frames) && frames->next)
 302     frames = frames->next;
 303   return frames;
 304 }
 305
 306 void PrintReport(const ReportDesc *rep) {
 307   Decorator d;
 308   Printf("==================\n");
 309   const char *rep_typ_str = ReportTypeString(rep->typ, rep->tag);
 310   Printf("%s", d.Warning());
 311   Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str,
 312          (int)internal_getpid());
 313   Printf("%s", d.Default());
 314
 315   if (rep->typ == ReportTypeDeadlock) {
 316     char thrbuf[kThreadBufSize];
 317     Printf("  Cycle in lock order graph: ");
 318     for (uptr i = 0; i < rep->mutexes.Size(); i++)
 319       PrintMutexShortWithAddress(rep->mutexes[i], " => ");
 320     PrintMutexShort(rep->mutexes[0], "\n\n");
 321     CHECK_GT(rep->mutexes.Size(), 0U);
 322     CHECK_EQ(rep->mutexes.Size() * (flags()->second_deadlock_stack ? 2 : 1),
 323              rep->stacks.Size());
 324     for (uptr i = 0; i < rep->mutexes.Size(); i++) {
 325       Printf("  Mutex ");
 326       PrintMutexShort(rep->mutexes[(i + 1) % rep->mutexes.Size()],
 327                       " acquired here while holding mutex ");
 328       PrintMutexShort(rep->mutexes[i], " in ");
 329       Printf("%s", d.ThreadDescription());
 330       Printf("%s:\n", thread_name(thrbuf, rep->unique_tids[i]));
 331       Printf("%s", d.Default());
 332       if (flags()->second_deadlock_stack) {
 333         PrintStack(rep->stacks[2*i]);
 334         Printf("  Mutex ");
 335         PrintMutexShort(rep->mutexes[i],
 336                         " previously acquired by the same thread here:\n");
 337         PrintStack(rep->stacks[2*i+1]);
 338       } else {
 339         PrintStack(rep->stacks[i]);
 340         if (i == 0)
 341           Printf("    Hint: use TSAN_OPTIONS=second_deadlock_stack=1 "
 342                  "to get more informative warning message\n\n");
 343       }
 344     }
 345   } else {
 346     for (uptr i = 0; i < rep->stacks.Size(); i++) {
 347       if (i)
 348         Printf("  and:\n");
 349       PrintStack(rep->stacks[i]);
 350     }
 351   }
 352
 353   for (uptr i = 0; i < rep->mops.Size(); i++)
 354     PrintMop(rep->mops[i], i == 0);
 355
 356   if (rep->sleep)
 357     PrintSleep(rep->sleep);
 358
 359   for (uptr i = 0; i < rep->locs.Size(); i++)
 360     PrintLocation(rep->locs[i]);
 361
 362   if (rep->typ != ReportTypeDeadlock) {
 363     for (uptr i = 0; i < rep->mutexes.Size(); i++)
 364       PrintMutex(rep->mutexes[i]);
 365   }
 366
 367   for (uptr i = 0; i < rep->threads.Size(); i++)
 368     PrintThread(rep->threads[i]);
 369
 370   if (rep->typ == ReportTypeThreadLeak && rep->count > 1)
 371     Printf("  And %d more similar thread leaks.\n\n", rep->count - 1);
 372
 373   if (ReportStack *stack = ChooseSummaryStack(rep)) {
 374     if (SymbolizedStack *frame = SkipTsanInternalFrames(stack->frames))
 375       ReportErrorSummary(rep_typ_str, frame->info);
 376   }
 377
 378   if (common_flags()->print_module_map == 2)
 379     DumpProcessMap();
 380
 381   Printf("==================\n");
 382 }
 383
 384 #else  // #if !SANITIZER_GO
 385
 386 const Tid kMainGoroutineId = 1;
 387
 388 void PrintStack(const ReportStack *ent) {
 389   if (ent == 0 || ent->frames == 0) {
 390     Printf("  [failed to restore the stack]\n");
 391     return;
 392   }
 393   SymbolizedStack *frame = ent->frames;
 394   for (int i = 0; frame; frame = frame->next, i++) {
 395     const AddressInfo &info = frame->info;
 396     Printf("  %s()\n      %s:%d +0x%zx\n", info.function,
 397            StripPathPrefix(info.file, common_flags()->strip_path_prefix),
 398            info.line, info.module_offset);
 399   }
 400 }
 401
 402 static void PrintMop(const ReportMop *mop, bool first) {
 403   Printf("\n");
 404   Printf("%s at %p by ",
 405          (first ? (mop->write ? "Write" : "Read")
 406                 : (mop->write ? "Previous write" : "Previous read")),
 407          reinterpret_cast<void *>(mop->addr));
 408   if (mop->tid == kMainGoroutineId)
 409     Printf("main goroutine:\n");
 410   else
 411     Printf("goroutine %d:\n", mop->tid);
 412   PrintStack(mop->stack);
 413 }
 414
 415 static void PrintLocation(const ReportLocation *loc) {
 416   switch (loc->type) {
 417   case ReportLocationHeap: {
 418     Printf("\n");
 419     Printf("Heap block of size %zu at %p allocated by ", loc->heap_chunk_size,
 420            reinterpret_cast<void *>(loc->heap_chunk_start));
 421     if (loc->tid == kMainGoroutineId)
 422       Printf("main goroutine:\n");
 423     else
 424       Printf("goroutine %d:\n", loc->tid);
 425     PrintStack(loc->stack);
 426     break;
 427   }
 428   case ReportLocationGlobal: {
 429     Printf("\n");
 430     Printf("Global var %s of size %zu at %p declared at %s:%zu\n",
 431            loc->global.name, loc->global.size,
 432            reinterpret_cast<void *>(loc->global.start), loc->global.file,
 433            loc->global.line);
 434     break;
 435   }
 436   default:
 437     break;
 438   }
 439 }
 440
 441 static void PrintThread(const ReportThread *rt) {
 442   if (rt->id == kMainGoroutineId)
 443     return;
 444   Printf("\n");
 445   Printf("Goroutine %d (%s) created at:\n",
 446     rt->id, rt->running ? "running" : "finished");
 447   PrintStack(rt->stack);
 448 }
 449
 450 void PrintReport(const ReportDesc *rep) {
 451   Printf("==================\n");
 452   if (rep->typ == ReportTypeRace) {
 453     Printf("WARNING: DATA RACE");
 454     for (uptr i = 0; i < rep->mops.Size(); i++)
 455       PrintMop(rep->mops[i], i == 0);
 456     for (uptr i = 0; i < rep->locs.Size(); i++)
 457       PrintLocation(rep->locs[i]);
 458     for (uptr i = 0; i < rep->threads.Size(); i++)
 459       PrintThread(rep->threads[i]);
 460   } else if (rep->typ == ReportTypeDeadlock) {
 461     Printf("WARNING: DEADLOCK\n");
 462     for (uptr i = 0; i < rep->mutexes.Size(); i++) {
 463       Printf("Goroutine %d lock mutex %llu while holding mutex %llu:\n", 999,
 464              rep->mutexes[i]->id,
 465              rep->mutexes[(i + 1) % rep->mutexes.Size()]->id);
 466       PrintStack(rep->stacks[2*i]);
 467       Printf("\n");
 468       Printf("Mutex %llu was previously locked here:\n",
 469              rep->mutexes[(i + 1) % rep->mutexes.Size()]->id);
 470       PrintStack(rep->stacks[2*i + 1]);
 471       Printf("\n");
 472     }
 473   }
 474   Printf("==================\n");
 475 }
 476
 477 #endif
 478
 479 }  // namespace __tsan