xref: /freebsd/contrib/llvm-project/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp (revision 9f23cbd6cae82fd77edfad7173432fa8dccd0a95)
1 //===-- tsan_rtl_thread.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 
13 #include "sanitizer_common/sanitizer_placement_new.h"
14 #include "tsan_rtl.h"
15 #include "tsan_mman.h"
16 #include "tsan_platform.h"
17 #include "tsan_report.h"
18 #include "tsan_sync.h"
19 
20 namespace __tsan {
21 
22 // ThreadContext implementation.
23 
24 ThreadContext::ThreadContext(Tid tid) : ThreadContextBase(tid), thr(), sync() {}
25 
26 #if !SANITIZER_GO
27 ThreadContext::~ThreadContext() {
28 }
29 #endif
30 
31 void ThreadContext::OnReset() { CHECK(!sync); }
32 
33 #if !SANITIZER_GO
34 struct ThreadLeak {
35   ThreadContext *tctx;
36   int count;
37 };
38 
39 static void CollectThreadLeaks(ThreadContextBase *tctx_base, void *arg) {
40   auto &leaks = *static_cast<Vector<ThreadLeak> *>(arg);
41   auto *tctx = static_cast<ThreadContext *>(tctx_base);
42   if (tctx->detached || tctx->status != ThreadStatusFinished)
43     return;
44   for (uptr i = 0; i < leaks.Size(); i++) {
45     if (leaks[i].tctx->creation_stack_id == tctx->creation_stack_id) {
46       leaks[i].count++;
47       return;
48     }
49   }
50   leaks.PushBack({tctx, 1});
51 }
52 #endif
53 
54 // Disabled on Mac because lldb test TestTsanBasic fails:
55 // https://reviews.llvm.org/D112603#3163158
56 #if !SANITIZER_GO && !SANITIZER_APPLE
57 static void ReportIgnoresEnabled(ThreadContext *tctx, IgnoreSet *set) {
58   if (tctx->tid == kMainTid) {
59     Printf("ThreadSanitizer: main thread finished with ignores enabled\n");
60   } else {
61     Printf("ThreadSanitizer: thread T%d %s finished with ignores enabled,"
62       " created at:\n", tctx->tid, tctx->name);
63     PrintStack(SymbolizeStackId(tctx->creation_stack_id));
64   }
65   Printf("  One of the following ignores was not ended"
66       " (in order of probability)\n");
67   for (uptr i = 0; i < set->Size(); i++) {
68     Printf("  Ignore was enabled at:\n");
69     PrintStack(SymbolizeStackId(set->At(i)));
70   }
71   Die();
72 }
73 
74 static void ThreadCheckIgnore(ThreadState *thr) {
75   if (ctx->after_multithreaded_fork)
76     return;
77   if (thr->ignore_reads_and_writes)
78     ReportIgnoresEnabled(thr->tctx, &thr->mop_ignore_set);
79   if (thr->ignore_sync)
80     ReportIgnoresEnabled(thr->tctx, &thr->sync_ignore_set);
81 }
82 #else
83 static void ThreadCheckIgnore(ThreadState *thr) {}
84 #endif
85 
86 void ThreadFinalize(ThreadState *thr) {
87   ThreadCheckIgnore(thr);
88 #if !SANITIZER_GO
89   if (!ShouldReport(thr, ReportTypeThreadLeak))
90     return;
91   ThreadRegistryLock l(&ctx->thread_registry);
92   Vector<ThreadLeak> leaks;
93   ctx->thread_registry.RunCallbackForEachThreadLocked(CollectThreadLeaks,
94                                                       &leaks);
95   for (uptr i = 0; i < leaks.Size(); i++) {
96     ScopedReport rep(ReportTypeThreadLeak);
97     rep.AddThread(leaks[i].tctx, true);
98     rep.SetCount(leaks[i].count);
99     OutputReport(thr, rep);
100   }
101 #endif
102 }
103 
104 int ThreadCount(ThreadState *thr) {
105   uptr result;
106   ctx->thread_registry.GetNumberOfThreads(0, 0, &result);
107   return (int)result;
108 }
109 
110 struct OnCreatedArgs {
111   VectorClock *sync;
112   uptr sync_epoch;
113   StackID stack;
114 };
115 
116 Tid ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) {
117   // The main thread and GCD workers don't have a parent thread.
118   Tid parent = kInvalidTid;
119   OnCreatedArgs arg = {nullptr, 0, kInvalidStackID};
120   if (thr) {
121     parent = thr->tid;
122     arg.stack = CurrentStackId(thr, pc);
123     if (!thr->ignore_sync) {
124       SlotLocker locker(thr);
125       thr->clock.ReleaseStore(&arg.sync);
126       arg.sync_epoch = ctx->global_epoch;
127       IncrementEpoch(thr);
128     }
129   }
130   Tid tid = ctx->thread_registry.CreateThread(uid, detached, parent, &arg);
131   DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", parent, tid, uid);
132   return tid;
133 }
134 
135 void ThreadContext::OnCreated(void *arg) {
136   OnCreatedArgs *args = static_cast<OnCreatedArgs *>(arg);
137   sync = args->sync;
138   sync_epoch = args->sync_epoch;
139   creation_stack_id = args->stack;
140 }
141 
142 extern "C" void __tsan_stack_initialization() {}
143 
144 struct OnStartedArgs {
145   ThreadState *thr;
146   uptr stk_addr;
147   uptr stk_size;
148   uptr tls_addr;
149   uptr tls_size;
150 };
151 
152 void ThreadStart(ThreadState *thr, Tid tid, tid_t os_id,
153                  ThreadType thread_type) {
154   ctx->thread_registry.StartThread(tid, os_id, thread_type, thr);
155   if (!thr->ignore_sync) {
156     SlotAttachAndLock(thr);
157     if (thr->tctx->sync_epoch == ctx->global_epoch)
158       thr->clock.Acquire(thr->tctx->sync);
159     SlotUnlock(thr);
160   }
161   Free(thr->tctx->sync);
162 
163   uptr stk_addr = 0;
164   uptr stk_size = 0;
165   uptr tls_addr = 0;
166   uptr tls_size = 0;
167 #if !SANITIZER_GO
168   if (thread_type != ThreadType::Fiber)
169     GetThreadStackAndTls(tid == kMainTid, &stk_addr, &stk_size, &tls_addr,
170                          &tls_size);
171 #endif
172   thr->stk_addr = stk_addr;
173   thr->stk_size = stk_size;
174   thr->tls_addr = tls_addr;
175   thr->tls_size = tls_size;
176 
177 #if !SANITIZER_GO
178   if (ctx->after_multithreaded_fork) {
179     thr->ignore_interceptors++;
180     ThreadIgnoreBegin(thr, 0);
181     ThreadIgnoreSyncBegin(thr, 0);
182   }
183 #endif
184 
185 #if !SANITIZER_GO
186   // Don't imitate stack/TLS writes for the main thread,
187   // because its initialization is synchronized with all
188   // subsequent threads anyway.
189   if (tid != kMainTid) {
190     if (stk_addr && stk_size) {
191       const uptr pc = StackTrace::GetNextInstructionPc(
192           reinterpret_cast<uptr>(__tsan_stack_initialization));
193       MemoryRangeImitateWrite(thr, pc, stk_addr, stk_size);
194     }
195 
196     if (tls_addr && tls_size)
197       ImitateTlsWrite(thr, tls_addr, tls_size);
198   }
199 #endif
200 }
201 
202 void ThreadContext::OnStarted(void *arg) {
203   thr = static_cast<ThreadState *>(arg);
204   DPrintf("#%d: ThreadStart\n", tid);
205   new (thr) ThreadState(tid);
206   if (common_flags()->detect_deadlocks)
207     thr->dd_lt = ctx->dd->CreateLogicalThread(tid);
208   thr->tctx = this;
209 #if !SANITIZER_GO
210   thr->is_inited = true;
211 #endif
212 }
213 
214 void ThreadFinish(ThreadState *thr) {
215   DPrintf("#%d: ThreadFinish\n", thr->tid);
216   ThreadCheckIgnore(thr);
217   if (thr->stk_addr && thr->stk_size)
218     DontNeedShadowFor(thr->stk_addr, thr->stk_size);
219   if (thr->tls_addr && thr->tls_size)
220     DontNeedShadowFor(thr->tls_addr, thr->tls_size);
221   thr->is_dead = true;
222 #if !SANITIZER_GO
223   thr->is_inited = false;
224   thr->ignore_interceptors++;
225   PlatformCleanUpThreadState(thr);
226 #endif
227   if (!thr->ignore_sync) {
228     SlotLocker locker(thr);
229     ThreadRegistryLock lock(&ctx->thread_registry);
230     // Note: detached is protected by the thread registry mutex,
231     // the thread may be detaching concurrently in another thread.
232     if (!thr->tctx->detached) {
233       thr->clock.ReleaseStore(&thr->tctx->sync);
234       thr->tctx->sync_epoch = ctx->global_epoch;
235       IncrementEpoch(thr);
236     }
237   }
238 #if !SANITIZER_GO
239   UnmapOrDie(thr->shadow_stack, kShadowStackSize * sizeof(uptr));
240 #else
241   Free(thr->shadow_stack);
242 #endif
243   thr->shadow_stack = nullptr;
244   thr->shadow_stack_pos = nullptr;
245   thr->shadow_stack_end = nullptr;
246   if (common_flags()->detect_deadlocks)
247     ctx->dd->DestroyLogicalThread(thr->dd_lt);
248   SlotDetach(thr);
249   ctx->thread_registry.FinishThread(thr->tid);
250   thr->~ThreadState();
251 }
252 
253 void ThreadContext::OnFinished() {
254   Lock lock(&ctx->slot_mtx);
255   Lock lock1(&trace.mtx);
256   // Queue all trace parts into the global recycle queue.
257   auto parts = &trace.parts;
258   while (trace.local_head) {
259     CHECK(parts->Queued(trace.local_head));
260     ctx->trace_part_recycle.PushBack(trace.local_head);
261     trace.local_head = parts->Next(trace.local_head);
262   }
263   ctx->trace_part_recycle_finished += parts->Size();
264   if (ctx->trace_part_recycle_finished > Trace::kFinishedThreadHi) {
265     ctx->trace_part_finished_excess += parts->Size();
266     trace.parts_allocated = 0;
267   } else if (ctx->trace_part_recycle_finished > Trace::kFinishedThreadLo &&
268              parts->Size() > 1) {
269     ctx->trace_part_finished_excess += parts->Size() - 1;
270     trace.parts_allocated = 1;
271   }
272   // From now on replay will use trace->final_pos.
273   trace.final_pos = (Event *)atomic_load_relaxed(&thr->trace_pos);
274   atomic_store_relaxed(&thr->trace_pos, 0);
275   thr->tctx = nullptr;
276   thr = nullptr;
277 }
278 
279 struct ConsumeThreadContext {
280   uptr uid;
281   ThreadContextBase *tctx;
282 };
283 
284 Tid ThreadConsumeTid(ThreadState *thr, uptr pc, uptr uid) {
285   return ctx->thread_registry.ConsumeThreadUserId(uid);
286 }
287 
288 struct JoinArg {
289   VectorClock *sync;
290   uptr sync_epoch;
291 };
292 
293 void ThreadJoin(ThreadState *thr, uptr pc, Tid tid) {
294   CHECK_GT(tid, 0);
295   DPrintf("#%d: ThreadJoin tid=%d\n", thr->tid, tid);
296   JoinArg arg = {};
297   ctx->thread_registry.JoinThread(tid, &arg);
298   if (!thr->ignore_sync) {
299     SlotLocker locker(thr);
300     if (arg.sync_epoch == ctx->global_epoch)
301       thr->clock.Acquire(arg.sync);
302   }
303   Free(arg.sync);
304 }
305 
306 void ThreadContext::OnJoined(void *ptr) {
307   auto arg = static_cast<JoinArg *>(ptr);
308   arg->sync = sync;
309   arg->sync_epoch = sync_epoch;
310   sync = nullptr;
311   sync_epoch = 0;
312 }
313 
314 void ThreadContext::OnDead() { CHECK_EQ(sync, nullptr); }
315 
316 void ThreadDetach(ThreadState *thr, uptr pc, Tid tid) {
317   CHECK_GT(tid, 0);
318   ctx->thread_registry.DetachThread(tid, thr);
319 }
320 
321 void ThreadContext::OnDetached(void *arg) { Free(sync); }
322 
323 void ThreadNotJoined(ThreadState *thr, uptr pc, Tid tid, uptr uid) {
324   CHECK_GT(tid, 0);
325   ctx->thread_registry.SetThreadUserId(tid, uid);
326 }
327 
328 void ThreadSetName(ThreadState *thr, const char *name) {
329   ctx->thread_registry.SetThreadName(thr->tid, name);
330 }
331 
332 #if !SANITIZER_GO
333 void FiberSwitchImpl(ThreadState *from, ThreadState *to) {
334   Processor *proc = from->proc();
335   ProcUnwire(proc, from);
336   ProcWire(proc, to);
337   set_cur_thread(to);
338 }
339 
340 ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags) {
341   void *mem = Alloc(sizeof(ThreadState));
342   ThreadState *fiber = static_cast<ThreadState *>(mem);
343   internal_memset(fiber, 0, sizeof(*fiber));
344   Tid tid = ThreadCreate(thr, pc, 0, true);
345   FiberSwitchImpl(thr, fiber);
346   ThreadStart(fiber, tid, 0, ThreadType::Fiber);
347   FiberSwitchImpl(fiber, thr);
348   return fiber;
349 }
350 
351 void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber) {
352   FiberSwitchImpl(thr, fiber);
353   ThreadFinish(fiber);
354   FiberSwitchImpl(fiber, thr);
355   Free(fiber);
356 }
357 
358 void FiberSwitch(ThreadState *thr, uptr pc,
359                  ThreadState *fiber, unsigned flags) {
360   if (!(flags & FiberSwitchFlagNoSync))
361     Release(thr, pc, (uptr)fiber);
362   FiberSwitchImpl(thr, fiber);
363   if (!(flags & FiberSwitchFlagNoSync))
364     Acquire(fiber, pc, (uptr)fiber);
365 }
366 #endif
367 
368 }  // namespace __tsan
369