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