]>
git.proxmox.com Git - rustc.git/blob - src/libcompiler_builtins/compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cc
1 //===-- tsan_rtl_thread.cc ------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is a part of ThreadSanitizer (TSan), a race detector.
12 //===----------------------------------------------------------------------===//
14 #include "sanitizer_common/sanitizer_placement_new.h"
16 #include "tsan_mman.h"
17 #include "tsan_platform.h"
18 #include "tsan_report.h"
19 #include "tsan_sync.h"
23 // ThreadContext implementation.
25 ThreadContext::ThreadContext(int tid
)
26 : ThreadContextBase(tid
)
34 ThreadContext::~ThreadContext() {
38 void ThreadContext::OnDead() {
39 CHECK_EQ(sync
.size(), 0);
42 void ThreadContext::OnJoined(void *arg
) {
43 ThreadState
*caller_thr
= static_cast<ThreadState
*>(arg
);
44 AcquireImpl(caller_thr
, 0, &sync
);
45 sync
.Reset(&caller_thr
->proc()->clock_cache
);
48 struct OnCreatedArgs
{
53 void ThreadContext::OnCreated(void *arg
) {
57 OnCreatedArgs
*args
= static_cast<OnCreatedArgs
*>(arg
);
58 if (!args
->thr
) // GCD workers don't have a parent thread.
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);
63 ReleaseImpl(args
->thr
, 0, &sync
);
64 creation_stack_id
= CurrentStackId(args
->thr
, args
->pc
);
66 StatInc(args
->thr
, StatThreadMaxTid
);
69 void ThreadContext::OnReset() {
70 CHECK_EQ(sync
.size(), 0);
71 uptr trace_p
= GetThreadTrace(tid
);
72 ReleaseMemoryPagesToOS(trace_p
, trace_p
+ TraceSize() * sizeof(Event
));
73 //!!! ReleaseMemoryToOS(GetThreadTraceHeader(tid), sizeof(Trace));
76 void ThreadContext::OnDetached(void *arg
) {
77 ThreadState
*thr1
= static_cast<ThreadState
*>(arg
);
78 sync
.Reset(&thr1
->proc()->clock_cache
);
81 struct OnStartedArgs
{
89 void ThreadContext::OnStarted(void *arg
) {
90 OnStartedArgs
*args
= static_cast<OnStartedArgs
*>(arg
);
92 // RoundUp so that one trace part does not contain events
93 // from different threads.
94 epoch0
= RoundUp(epoch1
+ 1, kTracePartSize
);
96 new(thr
) ThreadState(ctx
, tid
, unique_id
, epoch0
, reuse_count
,
97 args
->stk_addr
, args
->stk_size
, args
->tls_addr
, args
->tls_size
);
99 thr
->shadow_stack
= &ThreadTrace(thr
->tid
)->shadow_stack
[0];
100 thr
->shadow_stack_pos
= thr
->shadow_stack
;
101 thr
->shadow_stack_end
= thr
->shadow_stack
+ kShadowStackSize
;
103 // Setup dynamic shadow stack.
104 const int kInitStackSize
= 8;
105 thr
->shadow_stack
= (uptr
*)internal_alloc(MBlockShadowStack
,
106 kInitStackSize
* sizeof(uptr
));
107 thr
->shadow_stack_pos
= thr
->shadow_stack
;
108 thr
->shadow_stack_end
= thr
->shadow_stack
+ kInitStackSize
;
110 if (common_flags()->detect_deadlocks
)
111 thr
->dd_lt
= ctx
->dd
->CreateLogicalThread(unique_id
);
112 thr
->fast_state
.SetHistorySize(flags()->history_size
);
113 // Commit switch to the new part of the trace.
114 // TraceAddEvent will reset stack0/mset0 in the new part for us.
115 TraceAddEvent(thr
, thr
->fast_state
, EventTypeMop
, 0);
117 thr
->fast_synch_epoch
= epoch0
;
118 AcquireImpl(thr
, 0, &sync
);
119 StatInc(thr
, StatSyncAcquire
);
120 sync
.Reset(&thr
->proc()->clock_cache
);
121 thr
->is_inited
= true;
122 DPrintf("#%d: ThreadStart epoch=%zu stk_addr=%zx stk_size=%zx "
123 "tls_addr=%zx tls_size=%zx\n",
124 tid
, (uptr
)epoch0
, args
->stk_addr
, args
->stk_size
,
125 args
->tls_addr
, args
->tls_size
);
128 void ThreadContext::OnFinished() {
130 internal_free(thr
->shadow_stack
);
131 thr
->shadow_stack
= nullptr;
132 thr
->shadow_stack_pos
= nullptr;
133 thr
->shadow_stack_end
= nullptr;
136 thr
->fast_state
.IncrementEpoch();
137 // Can't increment epoch w/o writing to the trace as well.
138 TraceAddEvent(thr
, thr
->fast_state
, EventTypeMop
, 0);
139 ReleaseImpl(thr
, 0, &sync
);
141 epoch1
= thr
->fast_state
.epoch();
143 if (common_flags()->detect_deadlocks
)
144 ctx
->dd
->DestroyLogicalThread(thr
->dd_lt
);
146 #if TSAN_COLLECT_STATS
147 StatAggregate(ctx
->stat
, thr
->stat
);
158 static void MaybeReportThreadLeak(ThreadContextBase
*tctx_base
, void *arg
) {
159 Vector
<ThreadLeak
> &leaks
= *(Vector
<ThreadLeak
>*)arg
;
160 ThreadContext
*tctx
= static_cast<ThreadContext
*>(tctx_base
);
161 if (tctx
->detached
|| tctx
->status
!= ThreadStatusFinished
)
163 for (uptr i
= 0; i
< leaks
.Size(); i
++) {
164 if (leaks
[i
].tctx
->creation_stack_id
== tctx
->creation_stack_id
) {
169 ThreadLeak leak
= {tctx
, 1};
170 leaks
.PushBack(leak
);
175 static void ReportIgnoresEnabled(ThreadContext
*tctx
, IgnoreSet
*set
) {
176 if (tctx
->tid
== 0) {
177 Printf("ThreadSanitizer: main thread finished with ignores enabled\n");
179 Printf("ThreadSanitizer: thread T%d %s finished with ignores enabled,"
180 " created at:\n", tctx
->tid
, tctx
->name
);
181 PrintStack(SymbolizeStackId(tctx
->creation_stack_id
));
183 Printf(" One of the following ignores was not ended"
184 " (in order of probability)\n");
185 for (uptr i
= 0; i
< set
->Size(); i
++) {
186 Printf(" Ignore was enabled at:\n");
187 PrintStack(SymbolizeStackId(set
->At(i
)));
192 static void ThreadCheckIgnore(ThreadState
*thr
) {
193 if (ctx
->after_multithreaded_fork
)
195 if (thr
->ignore_reads_and_writes
)
196 ReportIgnoresEnabled(thr
->tctx
, &thr
->mop_ignore_set
);
197 if (thr
->ignore_sync
)
198 ReportIgnoresEnabled(thr
->tctx
, &thr
->sync_ignore_set
);
201 static void ThreadCheckIgnore(ThreadState
*thr
) {}
204 void ThreadFinalize(ThreadState
*thr
) {
205 ThreadCheckIgnore(thr
);
207 if (!flags()->report_thread_leaks
)
209 ThreadRegistryLock
l(ctx
->thread_registry
);
210 Vector
<ThreadLeak
> leaks(MBlockScopedBuf
);
211 ctx
->thread_registry
->RunCallbackForEachThreadLocked(
212 MaybeReportThreadLeak
, &leaks
);
213 for (uptr i
= 0; i
< leaks
.Size(); i
++) {
214 ScopedReport
rep(ReportTypeThreadLeak
);
215 rep
.AddThread(leaks
[i
].tctx
, true);
216 rep
.SetCount(leaks
[i
].count
);
217 OutputReport(thr
, rep
);
222 int ThreadCount(ThreadState
*thr
) {
224 ctx
->thread_registry
->GetNumberOfThreads(0, 0, &result
);
228 int ThreadCreate(ThreadState
*thr
, uptr pc
, uptr uid
, bool detached
) {
229 StatInc(thr
, StatThreadCreate
);
230 OnCreatedArgs args
= { thr
, pc
};
231 u32 parent_tid
= thr
? thr
->tid
: kInvalidTid
; // No parent for GCD workers.
233 ctx
->thread_registry
->CreateThread(uid
, detached
, parent_tid
, &args
);
234 DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", parent_tid
, tid
, uid
);
235 StatSet(thr
, StatThreadMaxAlive
, ctx
->thread_registry
->GetMaxAliveThreads());
239 void ThreadStart(ThreadState
*thr
, int tid
, uptr os_id
) {
245 GetThreadStackAndTls(tid
== 0, &stk_addr
, &stk_size
, &tls_addr
, &tls_size
);
248 if (stk_addr
&& stk_size
)
249 MemoryRangeImitateWrite(thr
, /*pc=*/ 1, stk_addr
, stk_size
);
251 if (tls_addr
&& tls_size
) {
252 // Check that the thr object is in tls;
253 const uptr thr_beg
= (uptr
)thr
;
254 const uptr thr_end
= (uptr
)thr
+ sizeof(*thr
);
255 CHECK_GE(thr_beg
, tls_addr
);
256 CHECK_LE(thr_beg
, tls_addr
+ tls_size
);
257 CHECK_GE(thr_end
, tls_addr
);
258 CHECK_LE(thr_end
, tls_addr
+ tls_size
);
259 // Since the thr object is huge, skip it.
260 MemoryRangeImitateWrite(thr
, /*pc=*/ 2, tls_addr
, thr_beg
- tls_addr
);
261 MemoryRangeImitateWrite(thr
, /*pc=*/ 2,
262 thr_end
, tls_addr
+ tls_size
- thr_end
);
267 ThreadRegistry
*tr
= ctx
->thread_registry
;
268 OnStartedArgs args
= { thr
, stk_addr
, stk_size
, tls_addr
, tls_size
};
269 tr
->StartThread(tid
, os_id
, &args
);
272 thr
->tctx
= (ThreadContext
*)tr
->GetThreadLocked(tid
);
276 if (ctx
->after_multithreaded_fork
) {
277 thr
->ignore_interceptors
++;
278 ThreadIgnoreBegin(thr
, 0);
279 ThreadIgnoreSyncBegin(thr
, 0);
284 void ThreadFinish(ThreadState
*thr
) {
285 ThreadCheckIgnore(thr
);
286 StatInc(thr
, StatThreadFinish
);
287 if (thr
->stk_addr
&& thr
->stk_size
)
288 DontNeedShadowFor(thr
->stk_addr
, thr
->stk_size
);
289 if (thr
->tls_addr
&& thr
->tls_size
)
290 DontNeedShadowFor(thr
->tls_addr
, thr
->tls_size
);
292 ctx
->thread_registry
->FinishThread(thr
->tid
);
295 static bool FindThreadByUid(ThreadContextBase
*tctx
, void *arg
) {
296 uptr uid
= (uptr
)arg
;
297 if (tctx
->user_id
== uid
&& tctx
->status
!= ThreadStatusInvalid
) {
304 int ThreadTid(ThreadState
*thr
, uptr pc
, uptr uid
) {
305 int res
= ctx
->thread_registry
->FindThread(FindThreadByUid
, (void*)uid
);
306 DPrintf("#%d: ThreadTid uid=%zu tid=%d\n", thr
->tid
, uid
, res
);
310 void ThreadJoin(ThreadState
*thr
, uptr pc
, int tid
) {
312 CHECK_LT(tid
, kMaxTid
);
313 DPrintf("#%d: ThreadJoin tid=%d\n", thr
->tid
, tid
);
314 ctx
->thread_registry
->JoinThread(tid
, thr
);
317 void ThreadDetach(ThreadState
*thr
, uptr pc
, int tid
) {
319 CHECK_LT(tid
, kMaxTid
);
320 ctx
->thread_registry
->DetachThread(tid
, thr
);
323 void ThreadSetName(ThreadState
*thr
, const char *name
) {
324 ctx
->thread_registry
->SetThreadName(thr
->tid
, name
);
327 void MemoryAccessRange(ThreadState
*thr
, uptr pc
, uptr addr
,
328 uptr size
, bool is_write
) {
332 u64
*shadow_mem
= (u64
*)MemToShadow(addr
);
333 DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_write=%d\n",
334 thr
->tid
, (void*)pc
, (void*)addr
,
335 (int)size
, is_write
);
338 if (!IsAppMem(addr
)) {
339 Printf("Access to non app mem %zx\n", addr
);
340 DCHECK(IsAppMem(addr
));
342 if (!IsAppMem(addr
+ size
- 1)) {
343 Printf("Access to non app mem %zx\n", addr
+ size
- 1);
344 DCHECK(IsAppMem(addr
+ size
- 1));
346 if (!IsShadowMem((uptr
)shadow_mem
)) {
347 Printf("Bad shadow addr %p (%zx)\n", shadow_mem
, addr
);
348 DCHECK(IsShadowMem((uptr
)shadow_mem
));
350 if (!IsShadowMem((uptr
)(shadow_mem
+ size
* kShadowCnt
/ 8 - 1))) {
351 Printf("Bad shadow addr %p (%zx)\n",
352 shadow_mem
+ size
* kShadowCnt
/ 8 - 1, addr
+ size
- 1);
353 DCHECK(IsShadowMem((uptr
)(shadow_mem
+ size
* kShadowCnt
/ 8 - 1)));
357 StatInc(thr
, StatMopRange
);
359 if (*shadow_mem
== kShadowRodata
) {
360 // Access to .rodata section, no races here.
361 // Measurements show that it can be 10-20% of all memory accesses.
362 StatInc(thr
, StatMopRangeRodata
);
366 FastState fast_state
= thr
->fast_state
;
367 if (fast_state
.GetIgnoreBit())
370 fast_state
.IncrementEpoch();
371 thr
->fast_state
= fast_state
;
372 TraceAddEvent(thr
, fast_state
, EventTypeMop
, pc
);
374 bool unaligned
= (addr
% kShadowCell
) != 0;
376 // Handle unaligned beginning, if any.
377 for (; addr
% kShadowCell
&& size
; addr
++, size
--) {
378 int const kAccessSizeLog
= 0;
379 Shadow
cur(fast_state
);
380 cur
.SetWrite(is_write
);
381 cur
.SetAddr0AndSizeLog(addr
& (kShadowCell
- 1), kAccessSizeLog
);
382 MemoryAccessImpl(thr
, addr
, kAccessSizeLog
, is_write
, false,
386 shadow_mem
+= kShadowCnt
;
387 // Handle middle part, if any.
388 for (; size
>= kShadowCell
; addr
+= kShadowCell
, size
-= kShadowCell
) {
389 int const kAccessSizeLog
= 3;
390 Shadow
cur(fast_state
);
391 cur
.SetWrite(is_write
);
392 cur
.SetAddr0AndSizeLog(0, kAccessSizeLog
);
393 MemoryAccessImpl(thr
, addr
, kAccessSizeLog
, is_write
, false,
395 shadow_mem
+= kShadowCnt
;
397 // Handle ending, if any.
398 for (; size
; addr
++, size
--) {
399 int const kAccessSizeLog
= 0;
400 Shadow
cur(fast_state
);
401 cur
.SetWrite(is_write
);
402 cur
.SetAddr0AndSizeLog(addr
& (kShadowCell
- 1), kAccessSizeLog
);
403 MemoryAccessImpl(thr
, addr
, kAccessSizeLog
, is_write
, false,
408 } // namespace __tsan