1 //===-- tsan_rtl_thread.cc ------------------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is a part of ThreadSanitizer (TSan), a race detector.
10 //===----------------------------------------------------------------------===//
12 #include "sanitizer_common/sanitizer_placement_new.h"
14 #include "tsan_mman.h"
15 #include "tsan_platform.h"
16 #include "tsan_report.h"
17 #include "tsan_sync.h"
21 // ThreadContext implementation.
23 ThreadContext::ThreadContext(int tid
)
24 : ThreadContextBase(tid
)
32 ThreadContext::~ThreadContext() {
36 void ThreadContext::OnDead() {
37 CHECK_EQ(sync
.size(), 0);
40 void ThreadContext::OnJoined(void *arg
) {
41 ThreadState
*caller_thr
= static_cast<ThreadState
*>(arg
);
42 AcquireImpl(caller_thr
, 0, &sync
);
43 sync
.Reset(&caller_thr
->clock_cache
);
46 struct OnCreatedArgs
{
51 void ThreadContext::OnCreated(void *arg
) {
55 OnCreatedArgs
*args
= static_cast<OnCreatedArgs
*>(arg
);
56 args
->thr
->fast_state
.IncrementEpoch();
57 // Can't increment epoch w/o writing to the trace as well.
58 TraceAddEvent(args
->thr
, args
->thr
->fast_state
, EventTypeMop
, 0);
59 ReleaseImpl(args
->thr
, 0, &sync
);
60 creation_stack_id
= CurrentStackId(args
->thr
, args
->pc
);
62 StatInc(args
->thr
, StatThreadMaxTid
);
65 void ThreadContext::OnReset() {
66 CHECK_EQ(sync
.size(), 0);
67 FlushUnneededShadowMemory(GetThreadTrace(tid
), TraceSize() * sizeof(Event
));
68 //!!! FlushUnneededShadowMemory(GetThreadTraceHeader(tid), sizeof(Trace));
71 void ThreadContext::OnDetached(void *arg
) {
72 ThreadState
*thr1
= static_cast<ThreadState
*>(arg
);
73 sync
.Reset(&thr1
->clock_cache
);
76 struct OnStartedArgs
{
84 void ThreadContext::OnStarted(void *arg
) {
85 OnStartedArgs
*args
= static_cast<OnStartedArgs
*>(arg
);
87 // RoundUp so that one trace part does not contain events
88 // from different threads.
89 epoch0
= RoundUp(epoch1
+ 1, kTracePartSize
);
91 new(thr
) ThreadState(ctx
, tid
, unique_id
, epoch0
, reuse_count
,
92 args
->stk_addr
, args
->stk_size
, args
->tls_addr
, args
->tls_size
);
94 thr
->shadow_stack
= &ThreadTrace(thr
->tid
)->shadow_stack
[0];
95 thr
->shadow_stack_pos
= thr
->shadow_stack
;
96 thr
->shadow_stack_end
= thr
->shadow_stack
+ kShadowStackSize
;
98 // Setup dynamic shadow stack.
99 const int kInitStackSize
= 8;
100 thr
->shadow_stack
= (uptr
*)internal_alloc(MBlockShadowStack
,
101 kInitStackSize
* sizeof(uptr
));
102 thr
->shadow_stack_pos
= thr
->shadow_stack
;
103 thr
->shadow_stack_end
= thr
->shadow_stack
+ kInitStackSize
;
106 AllocatorThreadStart(thr
);
108 if (common_flags()->detect_deadlocks
) {
109 thr
->dd_pt
= ctx
->dd
->CreatePhysicalThread();
110 thr
->dd_lt
= ctx
->dd
->CreateLogicalThread(unique_id
);
112 thr
->fast_synch_epoch
= epoch0
;
113 AcquireImpl(thr
, 0, &sync
);
114 thr
->fast_state
.SetHistorySize(flags()->history_size
);
115 const uptr trace
= (epoch0
/ kTracePartSize
) % TraceParts();
116 Trace
*thr_trace
= ThreadTrace(thr
->tid
);
117 thr_trace
->headers
[trace
].epoch0
= epoch0
;
118 StatInc(thr
, StatSyncAcquire
);
119 sync
.Reset(&thr
->clock_cache
);
120 DPrintf("#%d: ThreadStart epoch=%zu stk_addr=%zx stk_size=%zx "
121 "tls_addr=%zx tls_size=%zx\n",
122 tid
, (uptr
)epoch0
, args
->stk_addr
, args
->stk_size
,
123 args
->tls_addr
, args
->tls_size
);
126 void ThreadContext::OnFinished() {
128 thr
->fast_state
.IncrementEpoch();
129 // Can't increment epoch w/o writing to the trace as well.
130 TraceAddEvent(thr
, thr
->fast_state
, EventTypeMop
, 0);
131 ReleaseImpl(thr
, 0, &sync
);
133 epoch1
= thr
->fast_state
.epoch();
135 if (common_flags()->detect_deadlocks
) {
136 ctx
->dd
->DestroyPhysicalThread(thr
->dd_pt
);
137 ctx
->dd
->DestroyLogicalThread(thr
->dd_lt
);
139 ctx
->clock_alloc
.FlushCache(&thr
->clock_cache
);
140 ctx
->metamap
.OnThreadIdle(thr
);
142 AllocatorThreadFinish(thr
);
145 StatAggregate(ctx
->stat
, thr
->stat
);
155 static void MaybeReportThreadLeak(ThreadContextBase
*tctx_base
, void *arg
) {
156 Vector
<ThreadLeak
> &leaks
= *(Vector
<ThreadLeak
>*)arg
;
157 ThreadContext
*tctx
= static_cast<ThreadContext
*>(tctx_base
);
158 if (tctx
->detached
|| tctx
->status
!= ThreadStatusFinished
)
160 for (uptr i
= 0; i
< leaks
.Size(); i
++) {
161 if (leaks
[i
].tctx
->creation_stack_id
== tctx
->creation_stack_id
) {
166 ThreadLeak leak
= {tctx
, 1};
167 leaks
.PushBack(leak
);
172 static void ReportIgnoresEnabled(ThreadContext
*tctx
, IgnoreSet
*set
) {
173 if (tctx
->tid
== 0) {
174 Printf("ThreadSanitizer: main thread finished with ignores enabled\n");
176 Printf("ThreadSanitizer: thread T%d %s finished with ignores enabled,"
177 " created at:\n", tctx
->tid
, tctx
->name
);
178 PrintStack(SymbolizeStackId(tctx
->creation_stack_id
));
180 Printf(" One of the following ignores was not ended"
181 " (in order of probability)\n");
182 for (uptr i
= 0; i
< set
->Size(); i
++) {
183 Printf(" Ignore was enabled at:\n");
184 PrintStack(SymbolizeStackId(set
->At(i
)));
189 static void ThreadCheckIgnore(ThreadState
*thr
) {
190 if (ctx
->after_multithreaded_fork
)
192 if (thr
->ignore_reads_and_writes
)
193 ReportIgnoresEnabled(thr
->tctx
, &thr
->mop_ignore_set
);
194 if (thr
->ignore_sync
)
195 ReportIgnoresEnabled(thr
->tctx
, &thr
->sync_ignore_set
);
198 static void ThreadCheckIgnore(ThreadState
*thr
) {}
201 void ThreadFinalize(ThreadState
*thr
) {
202 ThreadCheckIgnore(thr
);
204 if (!flags()->report_thread_leaks
)
206 ThreadRegistryLock
l(ctx
->thread_registry
);
207 Vector
<ThreadLeak
> leaks(MBlockScopedBuf
);
208 ctx
->thread_registry
->RunCallbackForEachThreadLocked(
209 MaybeReportThreadLeak
, &leaks
);
210 for (uptr i
= 0; i
< leaks
.Size(); i
++) {
211 ScopedReport
rep(ReportTypeThreadLeak
);
212 rep
.AddThread(leaks
[i
].tctx
, true);
213 rep
.SetCount(leaks
[i
].count
);
214 OutputReport(thr
, rep
);
219 int ThreadCount(ThreadState
*thr
) {
221 ctx
->thread_registry
->GetNumberOfThreads(0, 0, &result
);
225 int ThreadCreate(ThreadState
*thr
, uptr pc
, uptr uid
, bool detached
) {
226 StatInc(thr
, StatThreadCreate
);
227 OnCreatedArgs args
= { thr
, pc
};
228 int tid
= ctx
->thread_registry
->CreateThread(uid
, detached
, thr
->tid
, &args
);
229 DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", thr
->tid
, tid
, uid
);
230 StatSet(thr
, StatThreadMaxAlive
, ctx
->thread_registry
->GetMaxAliveThreads());
234 void ThreadStart(ThreadState
*thr
, int tid
, uptr os_id
) {
239 GetThreadStackAndTls(tid
== 0, &stk_addr
, &stk_size
, &tls_addr
, &tls_size
);
242 if (stk_addr
&& stk_size
)
243 MemoryRangeImitateWrite(thr
, /*pc=*/ 1, stk_addr
, stk_size
);
245 if (tls_addr
&& tls_size
) {
246 // Check that the thr object is in tls;
247 const uptr thr_beg
= (uptr
)thr
;
248 const uptr thr_end
= (uptr
)thr
+ sizeof(*thr
);
249 CHECK_GE(thr_beg
, tls_addr
);
250 CHECK_LE(thr_beg
, tls_addr
+ tls_size
);
251 CHECK_GE(thr_end
, tls_addr
);
252 CHECK_LE(thr_end
, tls_addr
+ tls_size
);
253 // Since the thr object is huge, skip it.
254 MemoryRangeImitateWrite(thr
, /*pc=*/ 2, tls_addr
, thr_beg
- tls_addr
);
255 MemoryRangeImitateWrite(thr
, /*pc=*/ 2,
256 thr_end
, tls_addr
+ tls_size
- thr_end
);
260 ThreadRegistry
*tr
= ctx
->thread_registry
;
261 OnStartedArgs args
= { thr
, stk_addr
, stk_size
, tls_addr
, tls_size
};
262 tr
->StartThread(tid
, os_id
, &args
);
265 thr
->tctx
= (ThreadContext
*)tr
->GetThreadLocked(tid
);
269 if (ctx
->after_multithreaded_fork
) {
270 thr
->ignore_interceptors
++;
271 ThreadIgnoreBegin(thr
, 0);
272 ThreadIgnoreSyncBegin(thr
, 0);
277 void ThreadFinish(ThreadState
*thr
) {
278 ThreadCheckIgnore(thr
);
279 StatInc(thr
, StatThreadFinish
);
280 if (thr
->stk_addr
&& thr
->stk_size
)
281 DontNeedShadowFor(thr
->stk_addr
, thr
->stk_size
);
282 if (thr
->tls_addr
&& thr
->tls_size
)
283 DontNeedShadowFor(thr
->tls_addr
, thr
->tls_size
);
285 ctx
->thread_registry
->FinishThread(thr
->tid
);
288 static bool FindThreadByUid(ThreadContextBase
*tctx
, void *arg
) {
289 uptr uid
= (uptr
)arg
;
290 if (tctx
->user_id
== uid
&& tctx
->status
!= ThreadStatusInvalid
) {
297 int ThreadTid(ThreadState
*thr
, uptr pc
, uptr uid
) {
298 int res
= ctx
->thread_registry
->FindThread(FindThreadByUid
, (void*)uid
);
299 DPrintf("#%d: ThreadTid uid=%zu tid=%d\n", thr
->tid
, uid
, res
);
303 void ThreadJoin(ThreadState
*thr
, uptr pc
, int tid
) {
305 CHECK_LT(tid
, kMaxTid
);
306 DPrintf("#%d: ThreadJoin tid=%d\n", thr
->tid
, tid
);
307 ctx
->thread_registry
->JoinThread(tid
, thr
);
310 void ThreadDetach(ThreadState
*thr
, uptr pc
, int tid
) {
312 CHECK_LT(tid
, kMaxTid
);
313 ctx
->thread_registry
->DetachThread(tid
, thr
);
316 void ThreadSetName(ThreadState
*thr
, const char *name
) {
317 ctx
->thread_registry
->SetThreadName(thr
->tid
, name
);
320 void MemoryAccessRange(ThreadState
*thr
, uptr pc
, uptr addr
,
321 uptr size
, bool is_write
) {
325 u64
*shadow_mem
= (u64
*)MemToShadow(addr
);
326 DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_write=%d\n",
327 thr
->tid
, (void*)pc
, (void*)addr
,
328 (int)size
, is_write
);
331 if (!IsAppMem(addr
)) {
332 Printf("Access to non app mem %zx\n", addr
);
333 DCHECK(IsAppMem(addr
));
335 if (!IsAppMem(addr
+ size
- 1)) {
336 Printf("Access to non app mem %zx\n", addr
+ size
- 1);
337 DCHECK(IsAppMem(addr
+ size
- 1));
339 if (!IsShadowMem((uptr
)shadow_mem
)) {
340 Printf("Bad shadow addr %p (%zx)\n", shadow_mem
, addr
);
341 DCHECK(IsShadowMem((uptr
)shadow_mem
));
343 if (!IsShadowMem((uptr
)(shadow_mem
+ size
* kShadowCnt
/ 8 - 1))) {
344 Printf("Bad shadow addr %p (%zx)\n",
345 shadow_mem
+ size
* kShadowCnt
/ 8 - 1, addr
+ size
- 1);
346 DCHECK(IsShadowMem((uptr
)(shadow_mem
+ size
* kShadowCnt
/ 8 - 1)));
350 StatInc(thr
, StatMopRange
);
352 if (*shadow_mem
== kShadowRodata
) {
353 // Access to .rodata section, no races here.
354 // Measurements show that it can be 10-20% of all memory accesses.
355 StatInc(thr
, StatMopRangeRodata
);
359 FastState fast_state
= thr
->fast_state
;
360 if (fast_state
.GetIgnoreBit())
363 fast_state
.IncrementEpoch();
364 thr
->fast_state
= fast_state
;
365 TraceAddEvent(thr
, fast_state
, EventTypeMop
, pc
);
367 bool unaligned
= (addr
% kShadowCell
) != 0;
369 // Handle unaligned beginning, if any.
370 for (; addr
% kShadowCell
&& size
; addr
++, size
--) {
371 int const kAccessSizeLog
= 0;
372 Shadow
cur(fast_state
);
373 cur
.SetWrite(is_write
);
374 cur
.SetAddr0AndSizeLog(addr
& (kShadowCell
- 1), kAccessSizeLog
);
375 MemoryAccessImpl(thr
, addr
, kAccessSizeLog
, is_write
, false,
379 shadow_mem
+= kShadowCnt
;
380 // Handle middle part, if any.
381 for (; size
>= kShadowCell
; addr
+= kShadowCell
, size
-= kShadowCell
) {
382 int const kAccessSizeLog
= 3;
383 Shadow
cur(fast_state
);
384 cur
.SetWrite(is_write
);
385 cur
.SetAddr0AndSizeLog(0, kAccessSizeLog
);
386 MemoryAccessImpl(thr
, addr
, kAccessSizeLog
, is_write
, false,
388 shadow_mem
+= kShadowCnt
;
390 // Handle ending, if any.
391 for (; size
; addr
++, size
--) {
392 int const kAccessSizeLog
= 0;
393 Shadow
cur(fast_state
);
394 cur
.SetWrite(is_write
);
395 cur
.SetAddr0AndSizeLog(addr
& (kShadowCell
- 1), kAccessSizeLog
);
396 MemoryAccessImpl(thr
, addr
, kAccessSizeLog
, is_write
, false,
401 } // namespace __tsan