Alexey Samsonov | 603c4be | 2012-06-04 13:55:19 +0000 | [diff] [blame] | 1 | //===-- tsan_rtl_thread.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 | |
Alexey Samsonov | 47b1634 | 2012-06-07 09:50:16 +0000 | [diff] [blame] | 14 | #include "sanitizer_common/sanitizer_placement_new.h" |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 15 | #include "tsan_rtl.h" |
| 16 | #include "tsan_mman.h" |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 17 | #include "tsan_platform.h" |
| 18 | #include "tsan_report.h" |
| 19 | #include "tsan_sync.h" |
| 20 | |
| 21 | namespace __tsan { |
| 22 | |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 23 | // ThreadContext implementation. |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 24 | |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 25 | ThreadContext::ThreadContext(int tid) |
| 26 | : ThreadContextBase(tid) |
| 27 | , thr() |
| 28 | , sync() |
| 29 | , epoch0() |
Dmitry Vyukov | 9743d74 | 2013-03-20 10:31:53 +0000 | [diff] [blame] | 30 | , epoch1() { |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 31 | } |
| 32 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 33 | #ifndef SANITIZER_GO |
Dmitry Vyukov | 6af642e | 2013-03-18 10:10:15 +0000 | [diff] [blame] | 34 | ThreadContext::~ThreadContext() { |
| 35 | } |
| 36 | #endif |
| 37 | |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 38 | void ThreadContext::OnDead() { |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 39 | CHECK_EQ(sync.size(), 0); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 40 | } |
| 41 | |
| 42 | void ThreadContext::OnJoined(void *arg) { |
| 43 | ThreadState *caller_thr = static_cast<ThreadState *>(arg); |
Dmitry Vyukov | e1ddbf9 | 2013-10-10 15:58:12 +0000 | [diff] [blame] | 44 | AcquireImpl(caller_thr, 0, &sync); |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 45 | sync.Reset(&caller_thr->clock_cache); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 46 | } |
| 47 | |
| 48 | struct OnCreatedArgs { |
| 49 | ThreadState *thr; |
| 50 | uptr pc; |
| 51 | }; |
| 52 | |
| 53 | void ThreadContext::OnCreated(void *arg) { |
| 54 | thr = 0; |
Dmitry Vyukov | 491852e | 2013-03-18 08:52:46 +0000 | [diff] [blame] | 55 | if (tid == 0) |
| 56 | return; |
| 57 | OnCreatedArgs *args = static_cast<OnCreatedArgs *>(arg); |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 58 | if (!args->thr) // GCD workers don't have a parent thread. |
| 59 | return; |
Dmitry Vyukov | 491852e | 2013-03-18 08:52:46 +0000 | [diff] [blame] | 60 | args->thr->fast_state.IncrementEpoch(); |
| 61 | // Can't increment epoch w/o writing to the trace as well. |
| 62 | TraceAddEvent(args->thr, args->thr->fast_state, EventTypeMop, 0); |
Dmitry Vyukov | e1ddbf9 | 2013-10-10 15:58:12 +0000 | [diff] [blame] | 63 | ReleaseImpl(args->thr, 0, &sync); |
Dmitry Vyukov | 2c5284e | 2013-03-18 09:02:27 +0000 | [diff] [blame] | 64 | creation_stack_id = CurrentStackId(args->thr, args->pc); |
Dmitry Vyukov | 491852e | 2013-03-18 08:52:46 +0000 | [diff] [blame] | 65 | if (reuse_count == 0) |
| 66 | StatInc(args->thr, StatThreadMaxTid); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 67 | } |
| 68 | |
Dmitry Vyukov | ce85e03 | 2013-03-19 12:25:48 +0000 | [diff] [blame] | 69 | void ThreadContext::OnReset() { |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 70 | CHECK_EQ(sync.size(), 0); |
Dmitry Vyukov | 9743d74 | 2013-03-20 10:31:53 +0000 | [diff] [blame] | 71 | FlushUnneededShadowMemory(GetThreadTrace(tid), TraceSize() * sizeof(Event)); |
| 72 | //!!! FlushUnneededShadowMemory(GetThreadTraceHeader(tid), sizeof(Trace)); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 73 | } |
| 74 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 75 | void ThreadContext::OnDetached(void *arg) { |
| 76 | ThreadState *thr1 = static_cast<ThreadState*>(arg); |
| 77 | sync.Reset(&thr1->clock_cache); |
| 78 | } |
| 79 | |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 80 | struct OnStartedArgs { |
| 81 | ThreadState *thr; |
| 82 | uptr stk_addr; |
| 83 | uptr stk_size; |
| 84 | uptr tls_addr; |
| 85 | uptr tls_size; |
| 86 | }; |
| 87 | |
| 88 | void ThreadContext::OnStarted(void *arg) { |
| 89 | OnStartedArgs *args = static_cast<OnStartedArgs*>(arg); |
Dmitry Vyukov | 491852e | 2013-03-18 08:52:46 +0000 | [diff] [blame] | 90 | thr = args->thr; |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 91 | // RoundUp so that one trace part does not contain events |
| 92 | // from different threads. |
| 93 | epoch0 = RoundUp(epoch1 + 1, kTracePartSize); |
| 94 | epoch1 = (u64)-1; |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 95 | new(thr) ThreadState(ctx, tid, unique_id, epoch0, reuse_count, |
| 96 | args->stk_addr, args->stk_size, args->tls_addr, args->tls_size); |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 97 | #ifndef SANITIZER_GO |
Dmitry Vyukov | 01a7ce8 | 2013-10-16 15:35:12 +0000 | [diff] [blame] | 98 | thr->shadow_stack = &ThreadTrace(thr->tid)->shadow_stack[0]; |
| 99 | thr->shadow_stack_pos = thr->shadow_stack; |
| 100 | thr->shadow_stack_end = thr->shadow_stack + kShadowStackSize; |
| 101 | #else |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 102 | // Setup dynamic shadow stack. |
| 103 | const int kInitStackSize = 8; |
Dmitry Vyukov | 01a7ce8 | 2013-10-16 15:35:12 +0000 | [diff] [blame] | 104 | thr->shadow_stack = (uptr*)internal_alloc(MBlockShadowStack, |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 105 | kInitStackSize * sizeof(uptr)); |
Dmitry Vyukov | 01a7ce8 | 2013-10-16 15:35:12 +0000 | [diff] [blame] | 106 | thr->shadow_stack_pos = thr->shadow_stack; |
| 107 | thr->shadow_stack_end = thr->shadow_stack + kInitStackSize; |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 108 | #endif |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 109 | #ifndef SANITIZER_GO |
Dmitry Vyukov | 01a7ce8 | 2013-10-16 15:35:12 +0000 | [diff] [blame] | 110 | AllocatorThreadStart(thr); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 111 | #endif |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 112 | if (common_flags()->detect_deadlocks) { |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 113 | thr->dd_pt = ctx->dd->CreatePhysicalThread(); |
| 114 | thr->dd_lt = ctx->dd->CreateLogicalThread(unique_id); |
| 115 | } |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 116 | thr->fast_state.SetHistorySize(flags()->history_size); |
| 117 | // Commit switch to the new part of the trace. |
| 118 | // TraceAddEvent will reset stack0/mset0 in the new part for us. |
| 119 | TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0); |
| 120 | |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 121 | thr->fast_synch_epoch = epoch0; |
Dmitry Vyukov | e1ddbf9 | 2013-10-10 15:58:12 +0000 | [diff] [blame] | 122 | AcquireImpl(thr, 0, &sync); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 123 | StatInc(thr, StatSyncAcquire); |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 124 | sync.Reset(&thr->clock_cache); |
Pirama Arumuga Nainar | 7c91505 | 2015-04-08 08:58:29 -0700 | [diff] [blame] | 125 | thr->is_inited = true; |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 126 | DPrintf("#%d: ThreadStart epoch=%zu stk_addr=%zx stk_size=%zx " |
| 127 | "tls_addr=%zx tls_size=%zx\n", |
Alexey Samsonov | 036f933 | 2013-03-18 09:45:22 +0000 | [diff] [blame] | 128 | tid, (uptr)epoch0, args->stk_addr, args->stk_size, |
| 129 | args->tls_addr, args->tls_size); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | void ThreadContext::OnFinished() { |
| 133 | if (!detached) { |
| 134 | thr->fast_state.IncrementEpoch(); |
| 135 | // Can't increment epoch w/o writing to the trace as well. |
| 136 | TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0); |
Dmitry Vyukov | e1ddbf9 | 2013-10-10 15:58:12 +0000 | [diff] [blame] | 137 | ReleaseImpl(thr, 0, &sync); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 138 | } |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 139 | epoch1 = thr->fast_state.epoch(); |
| 140 | |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 141 | if (common_flags()->detect_deadlocks) { |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 142 | ctx->dd->DestroyPhysicalThread(thr->dd_pt); |
| 143 | ctx->dd->DestroyLogicalThread(thr->dd_lt); |
| 144 | } |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 145 | ctx->clock_alloc.FlushCache(&thr->clock_cache); |
Stephen Hines | 6a211c5 | 2014-07-21 00:49:56 -0700 | [diff] [blame] | 146 | ctx->metamap.OnThreadIdle(thr); |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 147 | #ifndef SANITIZER_GO |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 148 | AllocatorThreadFinish(thr); |
| 149 | #endif |
| 150 | thr->~ThreadState(); |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 151 | #if TSAN_COLLECT_STATS |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 152 | StatAggregate(ctx->stat, thr->stat); |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 153 | #endif |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 154 | thr = 0; |
| 155 | } |
| 156 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 157 | #ifndef SANITIZER_GO |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 158 | struct ThreadLeak { |
| 159 | ThreadContext *tctx; |
| 160 | int count; |
| 161 | }; |
| 162 | |
| 163 | static void MaybeReportThreadLeak(ThreadContextBase *tctx_base, void *arg) { |
| 164 | Vector<ThreadLeak> &leaks = *(Vector<ThreadLeak>*)arg; |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 165 | ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base); |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 166 | if (tctx->detached || tctx->status != ThreadStatusFinished) |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 167 | return; |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 168 | for (uptr i = 0; i < leaks.Size(); i++) { |
| 169 | if (leaks[i].tctx->creation_stack_id == tctx->creation_stack_id) { |
| 170 | leaks[i].count++; |
| 171 | return; |
| 172 | } |
| 173 | } |
| 174 | ThreadLeak leak = {tctx, 1}; |
| 175 | leaks.PushBack(leak); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 176 | } |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 177 | #endif |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 178 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 179 | #ifndef SANITIZER_GO |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 180 | static void ReportIgnoresEnabled(ThreadContext *tctx, IgnoreSet *set) { |
| 181 | if (tctx->tid == 0) { |
| 182 | Printf("ThreadSanitizer: main thread finished with ignores enabled\n"); |
| 183 | } else { |
| 184 | Printf("ThreadSanitizer: thread T%d %s finished with ignores enabled," |
| 185 | " created at:\n", tctx->tid, tctx->name); |
| 186 | PrintStack(SymbolizeStackId(tctx->creation_stack_id)); |
Dmitry Vyukov | dc563c0 | 2013-05-21 08:12:35 +0000 | [diff] [blame] | 187 | } |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 188 | Printf(" One of the following ignores was not ended" |
| 189 | " (in order of probability)\n"); |
| 190 | for (uptr i = 0; i < set->Size(); i++) { |
| 191 | Printf(" Ignore was enabled at:\n"); |
| 192 | PrintStack(SymbolizeStackId(set->At(i))); |
Dmitry Vyukov | e1ddbf9 | 2013-10-10 15:58:12 +0000 | [diff] [blame] | 193 | } |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 194 | Die(); |
Dmitry Vyukov | dc563c0 | 2013-05-21 08:12:35 +0000 | [diff] [blame] | 195 | } |
| 196 | |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 197 | static void ThreadCheckIgnore(ThreadState *thr) { |
| 198 | if (ctx->after_multithreaded_fork) |
| 199 | return; |
| 200 | if (thr->ignore_reads_and_writes) |
| 201 | ReportIgnoresEnabled(thr->tctx, &thr->mop_ignore_set); |
| 202 | if (thr->ignore_sync) |
| 203 | ReportIgnoresEnabled(thr->tctx, &thr->sync_ignore_set); |
| 204 | } |
| 205 | #else |
| 206 | static void ThreadCheckIgnore(ThreadState *thr) {} |
| 207 | #endif |
| 208 | |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 209 | void ThreadFinalize(ThreadState *thr) { |
Dmitry Vyukov | dc563c0 | 2013-05-21 08:12:35 +0000 | [diff] [blame] | 210 | ThreadCheckIgnore(thr); |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 211 | #ifndef SANITIZER_GO |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 212 | if (!flags()->report_thread_leaks) |
| 213 | return; |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 214 | ThreadRegistryLock l(ctx->thread_registry); |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 215 | Vector<ThreadLeak> leaks(MBlockScopedBuf); |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 216 | ctx->thread_registry->RunCallbackForEachThreadLocked( |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 217 | MaybeReportThreadLeak, &leaks); |
| 218 | for (uptr i = 0; i < leaks.Size(); i++) { |
| 219 | ScopedReport rep(ReportTypeThreadLeak); |
Stephen Hines | 6a211c5 | 2014-07-21 00:49:56 -0700 | [diff] [blame] | 220 | rep.AddThread(leaks[i].tctx, true); |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 221 | rep.SetCount(leaks[i].count); |
Stephen Hines | 6a211c5 | 2014-07-21 00:49:56 -0700 | [diff] [blame] | 222 | OutputReport(thr, rep); |
Dmitry Vyukov | 4536cb1 | 2013-03-21 16:55:17 +0000 | [diff] [blame] | 223 | } |
| 224 | #endif |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 225 | } |
| 226 | |
Dmitry Vyukov | 54e0a9a | 2012-11-07 16:41:57 +0000 | [diff] [blame] | 227 | int ThreadCount(ThreadState *thr) { |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 228 | uptr result; |
| 229 | ctx->thread_registry->GetNumberOfThreads(0, 0, &result); |
| 230 | return (int)result; |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 231 | } |
| 232 | |
| 233 | int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) { |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 234 | StatInc(thr, StatThreadCreate); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 235 | OnCreatedArgs args = { thr, pc }; |
Pirama Arumuga Nainar | 799172d | 2016-03-03 15:50:30 -0800 | [diff] [blame^] | 236 | u32 parent_tid = thr ? thr->tid : kInvalidTid; // No parent for GCD workers. |
| 237 | int tid = |
| 238 | ctx->thread_registry->CreateThread(uid, detached, parent_tid, &args); |
| 239 | DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", parent_tid, tid, uid); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 240 | StatSet(thr, StatThreadMaxAlive, ctx->thread_registry->GetMaxAliveThreads()); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 241 | return tid; |
| 242 | } |
| 243 | |
Dmitry Vyukov | e0023f7 | 2012-10-02 12:58:14 +0000 | [diff] [blame] | 244 | void ThreadStart(ThreadState *thr, int tid, uptr os_id) { |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 245 | uptr stk_addr = 0; |
| 246 | uptr stk_size = 0; |
| 247 | uptr tls_addr = 0; |
| 248 | uptr tls_size = 0; |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 249 | #ifndef SANITIZER_GO |
Dmitry Vyukov | 789b6c5 | 2012-05-25 11:15:04 +0000 | [diff] [blame] | 250 | GetThreadStackAndTls(tid == 0, &stk_addr, &stk_size, &tls_addr, &tls_size); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 251 | |
Dmitry Vyukov | af154b8 | 2012-05-28 07:44:34 +0000 | [diff] [blame] | 252 | if (tid) { |
Dmitry Vyukov | 7ac33ac | 2013-03-18 15:49:07 +0000 | [diff] [blame] | 253 | if (stk_addr && stk_size) |
Dmitry Vyukov | 74172de | 2013-03-18 16:56:48 +0000 | [diff] [blame] | 254 | MemoryRangeImitateWrite(thr, /*pc=*/ 1, stk_addr, stk_size); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 255 | |
Dmitry Vyukov | b78caa6 | 2012-07-05 16:18:28 +0000 | [diff] [blame] | 256 | if (tls_addr && tls_size) { |
| 257 | // Check that the thr object is in tls; |
| 258 | const uptr thr_beg = (uptr)thr; |
| 259 | const uptr thr_end = (uptr)thr + sizeof(*thr); |
| 260 | CHECK_GE(thr_beg, tls_addr); |
| 261 | CHECK_LE(thr_beg, tls_addr + tls_size); |
| 262 | CHECK_GE(thr_end, tls_addr); |
| 263 | CHECK_LE(thr_end, tls_addr + tls_size); |
| 264 | // Since the thr object is huge, skip it. |
Dmitry Vyukov | 74172de | 2013-03-18 16:56:48 +0000 | [diff] [blame] | 265 | MemoryRangeImitateWrite(thr, /*pc=*/ 2, tls_addr, thr_beg - tls_addr); |
| 266 | MemoryRangeImitateWrite(thr, /*pc=*/ 2, |
| 267 | thr_end, tls_addr + tls_size - thr_end); |
Dmitry Vyukov | b78caa6 | 2012-07-05 16:18:28 +0000 | [diff] [blame] | 268 | } |
Dmitry Vyukov | af154b8 | 2012-05-28 07:44:34 +0000 | [diff] [blame] | 269 | } |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 270 | #endif |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 271 | |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 272 | ThreadRegistry *tr = ctx->thread_registry; |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 273 | OnStartedArgs args = { thr, stk_addr, stk_size, tls_addr, tls_size }; |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 274 | tr->StartThread(tid, os_id, &args); |
| 275 | |
| 276 | tr->Lock(); |
| 277 | thr->tctx = (ThreadContext*)tr->GetThreadLocked(tid); |
| 278 | tr->Unlock(); |
| 279 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 280 | #ifndef SANITIZER_GO |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 281 | if (ctx->after_multithreaded_fork) { |
| 282 | thr->ignore_interceptors++; |
| 283 | ThreadIgnoreBegin(thr, 0); |
| 284 | ThreadIgnoreSyncBegin(thr, 0); |
| 285 | } |
| 286 | #endif |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | void ThreadFinish(ThreadState *thr) { |
Dmitry Vyukov | dc563c0 | 2013-05-21 08:12:35 +0000 | [diff] [blame] | 290 | ThreadCheckIgnore(thr); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 291 | StatInc(thr, StatThreadFinish); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 292 | if (thr->stk_addr && thr->stk_size) |
Dmitry Vyukov | 7ac33ac | 2013-03-18 15:49:07 +0000 | [diff] [blame] | 293 | DontNeedShadowFor(thr->stk_addr, thr->stk_size); |
| 294 | if (thr->tls_addr && thr->tls_size) |
| 295 | DontNeedShadowFor(thr->tls_addr, thr->tls_size); |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 296 | thr->is_dead = true; |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 297 | ctx->thread_registry->FinishThread(thr->tid); |
| 298 | } |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 299 | |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 300 | static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) { |
| 301 | uptr uid = (uptr)arg; |
| 302 | if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) { |
| 303 | tctx->user_id = 0; |
| 304 | return true; |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 305 | } |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 306 | return false; |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 307 | } |
| 308 | |
| 309 | int ThreadTid(ThreadState *thr, uptr pc, uptr uid) { |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 310 | int res = ctx->thread_registry->FindThread(FindThreadByUid, (void*)uid); |
Alexey Samsonov | e954101 | 2012-06-06 13:11:29 +0000 | [diff] [blame] | 311 | DPrintf("#%d: ThreadTid uid=%zu tid=%d\n", thr->tid, uid, res); |
Dmitry Vyukov | 411b2c9 | 2012-05-28 17:32:50 +0000 | [diff] [blame] | 312 | return res; |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 313 | } |
| 314 | |
| 315 | void ThreadJoin(ThreadState *thr, uptr pc, int tid) { |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 316 | CHECK_GT(tid, 0); |
| 317 | CHECK_LT(tid, kMaxTid); |
| 318 | DPrintf("#%d: ThreadJoin tid=%d\n", thr->tid, tid); |
Alexey Samsonov | 2bbd8be | 2013-03-15 13:48:44 +0000 | [diff] [blame] | 319 | ctx->thread_registry->JoinThread(tid, thr); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | void ThreadDetach(ThreadState *thr, uptr pc, int tid) { |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 323 | CHECK_GT(tid, 0); |
| 324 | CHECK_LT(tid, kMaxTid); |
Stephen Hines | 6d18623 | 2014-11-26 17:56:19 -0800 | [diff] [blame] | 325 | ctx->thread_registry->DetachThread(tid, thr); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 326 | } |
| 327 | |
Dmitry Vyukov | aecf2e5 | 2012-12-04 15:46:05 +0000 | [diff] [blame] | 328 | void ThreadSetName(ThreadState *thr, const char *name) { |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame] | 329 | ctx->thread_registry->SetThreadName(thr->tid, name); |
Dmitry Vyukov | aecf2e5 | 2012-12-04 15:46:05 +0000 | [diff] [blame] | 330 | } |
| 331 | |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 332 | void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr, |
| 333 | uptr size, bool is_write) { |
| 334 | if (size == 0) |
| 335 | return; |
| 336 | |
| 337 | u64 *shadow_mem = (u64*)MemToShadow(addr); |
| 338 | DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_write=%d\n", |
| 339 | thr->tid, (void*)pc, (void*)addr, |
| 340 | (int)size, is_write); |
| 341 | |
Stephen Hines | 86277eb | 2015-03-23 12:06:32 -0700 | [diff] [blame] | 342 | #if SANITIZER_DEBUG |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 343 | if (!IsAppMem(addr)) { |
Alexey Samsonov | b1fe302 | 2012-11-02 12:17:51 +0000 | [diff] [blame] | 344 | Printf("Access to non app mem %zx\n", addr); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 345 | DCHECK(IsAppMem(addr)); |
| 346 | } |
| 347 | if (!IsAppMem(addr + size - 1)) { |
Alexey Samsonov | b1fe302 | 2012-11-02 12:17:51 +0000 | [diff] [blame] | 348 | Printf("Access to non app mem %zx\n", addr + size - 1); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 349 | DCHECK(IsAppMem(addr + size - 1)); |
| 350 | } |
| 351 | if (!IsShadowMem((uptr)shadow_mem)) { |
Alexey Samsonov | b1fe302 | 2012-11-02 12:17:51 +0000 | [diff] [blame] | 352 | Printf("Bad shadow addr %p (%zx)\n", shadow_mem, addr); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 353 | DCHECK(IsShadowMem((uptr)shadow_mem)); |
| 354 | } |
| 355 | if (!IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1))) { |
Alexey Samsonov | b1fe302 | 2012-11-02 12:17:51 +0000 | [diff] [blame] | 356 | Printf("Bad shadow addr %p (%zx)\n", |
Alexey Samsonov | e954101 | 2012-06-06 13:11:29 +0000 | [diff] [blame] | 357 | shadow_mem + size * kShadowCnt / 8 - 1, addr + size - 1); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 358 | DCHECK(IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1))); |
| 359 | } |
| 360 | #endif |
| 361 | |
| 362 | StatInc(thr, StatMopRange); |
| 363 | |
Dmitry Vyukov | 82dbc51 | 2013-03-20 13:21:50 +0000 | [diff] [blame] | 364 | if (*shadow_mem == kShadowRodata) { |
| 365 | // Access to .rodata section, no races here. |
| 366 | // Measurements show that it can be 10-20% of all memory accesses. |
| 367 | StatInc(thr, StatMopRangeRodata); |
| 368 | return; |
| 369 | } |
| 370 | |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 371 | FastState fast_state = thr->fast_state; |
| 372 | if (fast_state.GetIgnoreBit()) |
| 373 | return; |
| 374 | |
| 375 | fast_state.IncrementEpoch(); |
| 376 | thr->fast_state = fast_state; |
Dmitry Vyukov | 385542a | 2012-11-28 10:35:31 +0000 | [diff] [blame] | 377 | TraceAddEvent(thr, fast_state, EventTypeMop, pc); |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 378 | |
| 379 | bool unaligned = (addr % kShadowCell) != 0; |
| 380 | |
| 381 | // Handle unaligned beginning, if any. |
| 382 | for (; addr % kShadowCell && size; addr++, size--) { |
| 383 | int const kAccessSizeLog = 0; |
| 384 | Shadow cur(fast_state); |
| 385 | cur.SetWrite(is_write); |
| 386 | cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog); |
Dmitry Vyukov | 334553e | 2013-02-01 09:42:06 +0000 | [diff] [blame] | 387 | MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false, |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 388 | shadow_mem, cur); |
| 389 | } |
| 390 | if (unaligned) |
| 391 | shadow_mem += kShadowCnt; |
| 392 | // Handle middle part, if any. |
| 393 | for (; size >= kShadowCell; addr += kShadowCell, size -= kShadowCell) { |
| 394 | int const kAccessSizeLog = 3; |
| 395 | Shadow cur(fast_state); |
| 396 | cur.SetWrite(is_write); |
| 397 | cur.SetAddr0AndSizeLog(0, kAccessSizeLog); |
Dmitry Vyukov | 334553e | 2013-02-01 09:42:06 +0000 | [diff] [blame] | 398 | MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false, |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 399 | shadow_mem, cur); |
| 400 | shadow_mem += kShadowCnt; |
| 401 | } |
| 402 | // Handle ending, if any. |
| 403 | for (; size; addr++, size--) { |
| 404 | int const kAccessSizeLog = 0; |
| 405 | Shadow cur(fast_state); |
| 406 | cur.SetWrite(is_write); |
| 407 | cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog); |
Dmitry Vyukov | 334553e | 2013-02-01 09:42:06 +0000 | [diff] [blame] | 408 | MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false, |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 409 | shadow_mem, cur); |
| 410 | } |
| 411 | } |
Dmitry Vyukov | eaa0190 | 2013-02-13 13:05:36 +0000 | [diff] [blame] | 412 | |
Kostya Serebryany | 7ac4148 | 2012-05-10 13:48:04 +0000 | [diff] [blame] | 413 | } // namespace __tsan |