forked from dotnet/runtime
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy paththreads.h
5737 lines (4826 loc) · 198 KB
/
threads.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// THREADS.H -
//
//
//
// Currently represents a logical and physical CLR thread. Later, these concepts will be separated.
//
//
// #SuspendingTheRuntime
//
// One of the primary differences between runtime code (managed code), and traditional (unmanaged code) is
// the existence of the GC heap (see file:gc.cpp#Overview). For the GC to do its job, it must be able to
// traverse all references to the GC heap, including ones on the stack of every thread, as well as any in
// hardware registers. While it is simple to state this requirement, it has long reaching effects, because
// properly accounting for all GC heap references ALL the time turns out to be quite hard. When we make a
// bookkeeping mistake, a GC reference is not reported at GC time, which means it will not be updated when the
// GC happens. Since memory in the GC heap can move, this can cause the pointer to point at 'random' places
// in the GC heap, causing data corruption. This is a 'GC Hole', and is very bad. We have special modes (see
// code:EEConfig.GetGCStressLevel) called GCStress to help find such issues.
//
// In order to find all GC references on the stacks, we need to ensure that no thread is manipulating a GC
// reference at the time of the scan. This is the job of code:Thread.SuspendRuntime. Logically, it suspends
// every thread in the process. Unfortunately, it can not literally simply call the OS SuspendThread API on
// all threads. The reason is that the other threads MIGHT hold important locks (for example, there is a lock
// that is taken when unmanaged heap memory is requested, or when a DLL is loaded). In general, process
// global structures in the OS will be protected by locks, and if you suspend a thread it might hold that
// lock. If you happen to need that OS service (eg you might need to allocate unmanaged memory), then
// deadlock will occur (as you wait on the suspended thread, that never wakes up).
//
// Luckily, we don't need to actually suspend the threads, we just need to ensure that all GC references on
// the stack are stable. This is where the concept of cooperative mode and preemptive mode (a bad name) come
// from.
//
// #CooperativeMode
//
// The runtime keeps a table of all threads that have ever run managed code in the code:ThreadStore table.
// The ThreadStore table holds a list of Thread objects (see code:#ThreadClass). This object holds all
// information about managed threads. Cooperative mode is defined as the mode the thread is in when the field
// code:Thread.m_fPreemptiveGCDisabled is non-zero. When this field is zero, the thread is said to be in
// Preemptive mode (named because if you preempt the thread in this mode, it is guaranteed to be in a place
// where a GC can occur).
//
// When a thread is in cooperative mode, it is basically saying that it is potentially modifying GC
// references, and so the runtime must Cooperate with it to get to a 'GC Safe' location where the GC
// references can be enumerated. This is the mode that a thread is in MOST times when it is running managed
// code (in fact, if the EIP is in JIT compiled code, there is only one place where you are NOT in cooperative
// mode (Inlined PINVOKE transition code)). Conversely, any time non-runtime unmanaged code is running, the
// thread MUST NOT be in cooperative mode (you risk deadlock otherwise). Only code in mscorwks.dll might be
// running in either cooperative or preemptive mode.
//
// It is easier to describe the invariant associated with being in Preemptive mode. When the thread is in
// preemptive mode (when code:Thread.m_fPreemptiveGCDisabled is zero), the thread guarantees two things
//
// * That it is not currently running code that manipulates GC references.
// * That it has set the code:Thread.m_pFrame pointer in the code:Thread to be a subclass of the class
// code:Frame which marks the location on the stack where the last managed method frame is. This
// allows the GC to start crawling the stack from there (essentially skip over the unmanaged frames).
// * That the thread will not reenter managed code if the global variable code:g_TrapReturningThreads is
// set (it will call code:Thread.RareDisablePreemptiveGC first which will block if a suspension is
// in progress)
//
// The basic idea is that the suspension logic in code:Thread.SuspendRuntime first sets the global variable
// code:g_TrapReturningThreads and then checks if each thread in the ThreadStore is in Cooperative mode. If a
// thread is NOT in cooperative mode, the logic simply skips the thread, because it knows that the thread
// will stop itself before reentering managed code (because code:g_TrapReturningThreads is set). This avoids
// the deadlock problem mentioned earlier, because threads that are running unmanaged code are allowed to
// run. Enumeration of GC references starts at the first managed frame (pointed at by code:Thread.m_pFrame).
//
// When a thread is in cooperative mode, it means that GC references might be in the process of being
// manipulated. There are two important possibilities
//
// * The CPU is running JIT compiled code
// * The CPU is running code elsewhere (which should only be in mscorwks.dll, because everywhere else a
// transition to preemptive mode should have happened first)
//
// * #PartiallyInterruptibleCode
// * #FullyInterruptibleCode
//
// If the Instruction pointer (x86/x64: EIP, ARM: R15/PC) is in JIT compiled code, we can detect this because we have tables that
// map the ranges of every method back to their code:MethodDesc (this the code:ICodeManager interface). In
// addition to knowing the method, these tables also point at 'GCInfo' that tell for that method which stack
// locations and which registers hold GC references at any particular instruction pointer. If the method is
// what is called FullyInterruptible, then we have information for any possible instruction pointer in the
// method and we can simply stop the thread (however we have to do this carefully TODO explain).
//
// However for most methods, we only keep GC information for particular EIPs, in particular we keep track of
// GC reference liveness only at call sites. Thus, not every location is 'GC Safe' (that is, we can enumerate
// all references, but must be 'driven' to a GC safe location).
//
// We drive threads to GC safe locations by hijacking. This is a term for updating the return address on the
// stack so that we gain control when a method returns. If we find that we are in JITTed code but NOT at a GC
// safe location, then we find the return address for the method and modify it to cause the runtime to stop.
// We then let the method run. Hopefully the method quickly returns, and hits our hijack, and we are now at a
// GC-safe location (all call sites are GC-safe). If not, we repeat the procedure (possibly moving the
// hijack). At some point, a method returns, and we get control. For methods that have loops that don't make
// calls, we are forced to make the method FullyInterruptible, so we can be sure to stop the method.
//
// This leaves only the case where we are in cooperative modes, but not in JIT compiled code (we should be in
// clr.dll). In this case, we simply let the thread run. The idea is that code in clr.dll makes the
// promise that it will not do ANYTHING that will block (which includes taking a lock), while in cooperative
// mode, or do anything that might take a long time without polling to see if a GC is needed. Thus, this code
// 'cooperates' to ensure that GCs can happen in a timely fashion.
//
// If you need to switch the GC mode of the current thread, look for the GCX_COOP() and GCX_PREEMP() macros.
//
#ifndef __threads_h__
#define __threads_h__
#include "vars.hpp"
#include "util.hpp"
#include "eventstore.hpp"
#include "argslot.h"
#include "regdisp.h"
#include "mscoree.h"
#include "gcheaputilities.h"
#include "gchandleutilities.h"
#include "gcinfotypes.h"
#include <clrhost.h>
#include "cdacdata.h"
class Thread;
class ThreadStore;
class MethodDesc;
struct PendingSync;
class AppDomain;
class NDirect;
class Frame;
class ThreadBaseObject;
class AppDomainStack;
class DomainAssembly;
class DeadlockAwareLock;
struct HelperMethodFrameCallerList;
class EECodeInfo;
class DebuggerPatchSkip;
class FaultingExceptionFrame;
enum BinderMethodID : int;
class PrepareCodeConfig;
class NativeCodeVersion;
typedef void(*ADCallBackFcnType)(LPVOID);
#include "stackwalktypes.h"
#include "log.h"
#include "excep.h"
#include "synch.h"
#include "exstate.h"
#include "threaddebugblockinginfo.h"
#include "interoputil.h"
#include "eventtrace.h"
#ifdef FEATURE_PERFTRACING
#include "eventpipeadaptertypes.h"
#endif // FEATURE_PERFTRACING
#include "threadstatics.h"
class Module;
// TailCallArgBuffer states
#define TAILCALLARGBUFFER_ACTIVE 0
#define TAILCALLARGBUFFER_INSTARG_ONLY 1
#define TAILCALLARGBUFFER_ABANDONED 2
struct TailCallArgBuffer
{
int State;
int Size;
void* GCDesc;
BYTE Args[1];
};
#if (defined(TARGET_ARM) && defined(FEATURE_EMULATE_SINGLESTEP))
#include "armsinglestepper.h"
#endif
#if (defined(TARGET_ARM64) && defined(FEATURE_EMULATE_SINGLESTEP))
#include "arm64singlestepper.h"
#endif
#if (defined(TARGET_RISCV64) && defined(FEATURE_EMULATE_SINGLESTEP))
#include "riscv64singlestepper.h"
#endif
#if (defined(TARGET_LOONGARCH64) && defined(FEATURE_EMULATE_SINGLESTEP))
#include "loongarch64singlestepper.h"
#endif
#if !defined(PLATFORM_SUPPORTS_SAFE_THREADSUSPEND)
// DISABLE_THREADSUSPEND controls whether Thread::SuspendThread will be used at all.
// This API is dangerous on non-Windows platforms, as it can lead to deadlocks,
// due to low level OS resources that the PAL is not aware of, or due to the fact that
// PAL-unaware code in the process may hold onto some OS resources.
#define DISABLE_THREADSUSPEND
#endif
#if defined(FEATURE_HIJACK) && (defined(TARGET_UNIX) || defined(FEATURE_SPECIAL_USER_MODE_APC))
#define FEATURE_THREAD_ACTIVATION
#endif
// NT thread priorities range from -15 to +15.
#define INVALID_THREAD_PRIORITY ((DWORD)0x80000000)
// For a fiber which switched out, we set its OSID to a special number
// Note: there's a copy of this macro in strike.cpp
#define SWITCHED_OUT_FIBER_OSID 0xbaadf00d;
#ifdef _DEBUG
// A thread doesn't receive its id until fully constructed.
#define UNINITIALIZED_THREADID 0xbaadf00d
#endif //_DEBUG
// Capture all the synchronization requests, for debugging purposes
#if defined(_DEBUG) && defined(TRACK_SYNC)
// Each thread has a stack that tracks all enter and leave requests
struct Dbg_TrackSync
{
virtual ~Dbg_TrackSync() = default;
virtual void EnterSync (UINT_PTR caller, void *pAwareLock) = 0;
virtual void LeaveSync (UINT_PTR caller, void *pAwareLock) = 0;
};
#endif // TRACK_SYNC
//***************************************************************************
#ifdef FEATURE_HIJACK
// Used to capture information about the state of execution of a *SUSPENDED* thread.
struct ExecutionState;
#ifndef TARGET_UNIX
// This is the type of the start function of a redirected thread pulled from
// a HandledJITCase during runtime suspension
typedef void (__stdcall *PFN_REDIRECTTARGET)();
// Describes the weird argument sets during hijacking
struct HijackArgs;
#endif // !TARGET_UNIX
#endif // FEATURE_HIJACK
// manifest constant for waiting in the exposed classlibs
const INT32 INFINITE_TIMEOUT = -1;
/***************************************************************************/
#ifdef FEATURE_SPECIAL_USER_MODE_APC
// These declarations are for a new special user-mode APC feature introduced in Windows. These are not yet available in Windows
// SDK headers, so some names below are prefixed with "CLONE_" to avoid conflicts in the future. Once the prefixed declarations
// become available in the Windows SDK headers, the prefixed declarations below can be removed in favor of the SDK ones.
enum CLONE_QUEUE_USER_APC_FLAGS
{
CLONE_QUEUE_USER_APC_FLAGS_NONE = 0x0,
CLONE_QUEUE_USER_APC_FLAGS_SPECIAL_USER_APC = 0x1,
CLONE_QUEUE_USER_APC_CALLBACK_DATA_CONTEXT = 0x10000
};
struct CLONE_APC_CALLBACK_DATA
{
ULONG_PTR Parameter;
PCONTEXT ContextRecord;
ULONG_PTR Reserved0;
ULONG_PTR Reserved1;
};
typedef CLONE_APC_CALLBACK_DATA *CLONE_PAPC_CALLBACK_DATA;
typedef BOOL (WINAPI *QueueUserAPC2Proc)(PAPCFUNC ApcRoutine, HANDLE Thread, ULONG_PTR Data, CLONE_QUEUE_USER_APC_FLAGS Flags);
const CLONE_QUEUE_USER_APC_FLAGS SpecialUserModeApcWithContextFlags =
(CLONE_QUEUE_USER_APC_FLAGS)
(
CLONE_QUEUE_USER_APC_FLAGS_SPECIAL_USER_APC | // this will be a special user-mode APC
CLONE_QUEUE_USER_APC_CALLBACK_DATA_CONTEXT // the callback's parameter will be a PAPC_CALLBACK_DATA
);
#endif // FEATURE_SPECIAL_USER_MODE_APC
//***************************************************************************
// Public functions
//
// Thread* GetThread() - returns current Thread.
// Thread* SetupThread() - creates a new Thread.
// Thread* SetupThreadNoThrow() - creates a new Thread without throwing.
// Thread* SetupUnstartedThread() - creates new unstarted Thread which
// (obviously) isn't in a TLS.
// void DestroyThread() - the underlying logical thread is going
// away.
// void DetachThread() - the underlying logical thread is going
// away but we don't want to destroy it yet.
//
// Public functions for one-time init/cleanup
//
// void InitThreadManager() - onetime init
// void TerminateThreadManager() - onetime cleanup
//
// Public functions for taking control of a thread at a safe point
//
// VOID OnHijackTripThread() - we've hijacked a JIT method
// VOID OnHijackFPTripThread() - we've hijacked a JIT method,
// and need to save the x87 FP stack.
//
//***************************************************************************
//***************************************************************************
// Public functions
//***************************************************************************
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
Thread* SetupThread();
Thread* SetupThreadNoThrow(HRESULT *phresult = NULL);
enum SetupUnstartedThreadFlags
{
SUTF_None = 0,
// The ThreadStoreLock is being held during Thread startup.
SUTF_ThreadStoreLockAlreadyTaken = 1,
// The default flags for the majority of threads.
SUTF_Default = SUTF_None,
};
Thread* SetupUnstartedThread(SetupUnstartedThreadFlags flags = SUTF_Default);
void DestroyThread(Thread *th);
DWORD GetRuntimeId();
#define CREATETHREAD_IF_NULL_FAILFAST(__thread, __msg) \
{ \
HRESULT __ctinffhr; \
__thread = SetupThreadNoThrow(&__ctinffhr); \
if (__thread == NULL) \
{ \
EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(__ctinffhr, __msg); \
UNREACHABLE(); \
} \
}
//---------------------------------------------------------------------------
// One-time initialization. Called during Dll initialization.
//---------------------------------------------------------------------------
void InitThreadManager();
// When we want to take control of a thread at a safe point, the thread will
// eventually come back to us in one of the following trip functions:
#ifdef FEATURE_HIJACK
EXTERN_C void WINAPI OnHijackTripThread();
#ifdef TARGET_X86
EXTERN_C void WINAPI OnHijackFPTripThread(); // hijacked JIT code is returning an FP value
#endif // TARGET_X86
#endif // FEATURE_HIJACK
void CommonTripThread();
void SetupTLSForThread();
// When we resume a thread at a new location, to get an exception thrown, we have to
// pretend the exception originated elsewhere.
EXTERN_C void ThrowControlForThread(
#ifdef FEATURE_EH_FUNCLETS
FaultingExceptionFrame *pfef
#endif // FEATURE_EH_FUNCLETS
#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS)
, TADDR ssp
#endif // TARGET_AMD64 && TARGET_WINDOWS
);
#if defined(_DEBUG)
BOOL MatchThreadHandleToOsId ( HANDLE h, DWORD osId );
#endif
typedef DWORD (*AppropriateWaitFunc) (void *args, DWORD timeout, DWORD option);
// The Thread class represents a managed thread. This thread could be internal
// or external (i.e. it wandered in from outside the runtime). For internal
// threads, it could correspond to an exposed System.Thread object or it
// could correspond to an internal worker thread of the runtime.
//
// If there's a physical Win32 thread underneath this object (i.e. it isn't an
// unstarted System.Thread), then this instance can be found in the TLS
// of that physical thread.
// FEATURE_MULTIREG_RETURN is set for platforms where a struct return value
// can be returned in multiple registers
// ex: Windows/Unix ARM/ARM64, Unix-AMD64.
//
//
// UNIX_AMD64_ABI is a specific kind of FEATURE_MULTIREG_RETURN
// specified by SystemV ABI for AMD64
//
#ifdef FEATURE_HIJACK // Hijack function returning
EXTERN_C void STDCALL OnHijackWorker(HijackArgs * pArgs);
#endif // FEATURE_HIJACK
// This is the code we pass around for Thread.Interrupt, mainly for assertions
#define APC_Code 0xEECEECEE
#ifdef DACCESS_COMPILE
class BaseStackGuard;
#endif
struct PortableTailCallFrame
{
void* TailCallAwareReturnAddress;
void* NextCall;
};
class TailCallTls
{
friend class CoreLibBinder;
PortableTailCallFrame* m_frame;
TailCallArgBuffer* m_argBuffer;
public:
TailCallTls();
TailCallArgBuffer* AllocArgBuffer(int size, void* gcDesc);
void FreeArgBuffer() { delete[] (BYTE*)m_argBuffer; m_argBuffer = NULL; }
TailCallArgBuffer* GetArgBuffer()
{
return m_argBuffer;
}
const PortableTailCallFrame* GetFrame() { return m_frame; }
};
// This struct contains data that lives as long as the current OS thread.
struct RuntimeThreadLocals
{
// on MP systems, each thread has its own allocation chunk so we can avoid
// lock prefixes and expensive MP cache snooping stuff
ee_alloc_context alloc_context;
};
#ifdef _MSC_VER
// use selectany to avoid initialization de-optimization issues in the compiler
__declspec(selectany)
#else
extern
#endif
thread_local RuntimeThreadLocals t_runtime_thread_locals;
typedef DPTR(struct RuntimeThreadLocals) PTR_RuntimeThreadLocals;
typedef DPTR(struct gc_alloc_context) PTR_gc_alloc_context;
// #ThreadClass
//
// A code:Thread contains all the per-thread information needed by the runtime. We can get this
// structure through the OS TLS slot see code:#RuntimeThreadLocals for more information.
class Thread
{
friend class ThreadStore;
friend class ThreadSuspend;
friend class SyncBlock;
friend struct PendingSync;
#ifdef _DEBUG
friend class EEContract;
#endif
#ifdef DACCESS_COMPILE
friend class ClrDataAccess;
friend class ClrDataTask;
#endif
friend BOOL NTGetThreadContext(Thread *pThread, T_CONTEXT *pContext);
friend BOOL NTSetThreadContext(Thread *pThread, const T_CONTEXT *pContext);
#ifdef FEATURE_HIJACK
// MapWin32FaultToCOMPlusException needs access to Thread::IsAddrOfRedirectFunc()
friend DWORD MapWin32FaultToCOMPlusException(EXCEPTION_RECORD *pExceptionRecord);
friend void STDCALL OnHijackWorker(HijackArgs * pArgs);
#ifdef FEATURE_THREAD_ACTIVATION
friend void HandleSuspensionForInterruptedThread(CONTEXT *interruptedContext);
friend BOOL CheckActivationSafePoint(SIZE_T ip);
#endif // FEATURE_THREAD_ACTIVATION
#endif // FEATURE_HIJACK
friend void InitThreadManager();
// Debug and Profiler caches ThreadHandle.
friend class Debugger; // void Debugger::ThreadStarted(Thread* pRuntimeThread, BOOL fAttaching);
#if defined(DACCESS_COMPILE)
friend class DacDbiInterfaceImpl; // DacDbiInterfaceImpl::GetThreadHandle(HANDLE * phThread);
#endif // DACCESS_COMPILE
friend class ProfToEEInterfaceImpl; // HRESULT ProfToEEInterfaceImpl::GetHandleFromThread(ThreadID threadId, HANDLE *phThread);
friend class ExceptionTracker;
friend class ThreadExceptionState;
friend class StackFrameIterator;
public:
enum SetThreadStackGuaranteeScope { STSGuarantee_Force, STSGuarantee_OnlyIfEnabled };
static BOOL IsSetThreadStackGuaranteeInUse(SetThreadStackGuaranteeScope fScope = STSGuarantee_OnlyIfEnabled)
{
WRAPPER_NO_CONTRACT;
if(STSGuarantee_Force == fScope)
return TRUE;
#ifdef DEBUG
// For debug, always enable setting thread stack guarantee so that we can print the stack trace
return TRUE;
#else
return FALSE;
#endif
}
public:
// If we are trying to suspend a thread, we set the appropriate pending bit to
// indicate why we want to suspend it (TS_AbortRequested or TS_DebugSuspendPending).
//
// If instead the thread has blocked itself, via WaitSuspendEvent, we indicate
// this with TS_SyncSuspended. However, we need to know whether the synchronous
// suspension is for a user request, or for an internal one (GC & Debug). That's
// because a user request is not allowed to resume a thread suspended for
// debugging or GC. -- That's not stricly true. It is allowed to resume such a
// thread so long as it was ALSO suspended by the user. In other words, this
// ensures that user resumptions aren't unbalanced from user suspensions.
//
enum ThreadState
{
TS_Unknown = 0x00000000, // threads are initialized this way
TS_AbortRequested = 0x00000001, // Abort the thread
// unused = 0x00000002,
TS_GCSuspendRedirected = 0x00000004, // ThreadSuspend::SuspendRuntime has redirected the thread to suspention routine.
TS_DebugSuspendPending = 0x00000008, // Is the debugger suspending threads?
TS_GCOnTransitions = 0x00000010, // Force a GC on stub transitions (GCStress only)
TS_LegalToJoin = 0x00000020, // Is it now legal to attempt a Join()
TS_ExecutingOnAltStack = 0x00000040, // Runtime is executing on an alternate stack located anywhere in the memory
#ifdef FEATURE_HIJACK
TS_Hijacked = 0x00000080, // Return address has been hijacked
#endif // FEATURE_HIJACK
// unused = 0x00000100,
TS_Background = 0x00000200, // Thread is a background thread
TS_Unstarted = 0x00000400, // Thread has never been started
TS_Dead = 0x00000800, // Thread is dead
TS_WeOwn = 0x00001000, // Exposed object initiated this thread
#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT
TS_CoInitialized = 0x00002000, // CoInitialize has been called for this thread
TS_InSTA = 0x00004000, // Thread hosts an STA
TS_InMTA = 0x00008000, // Thread is part of the MTA
#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
// Some bits that only have meaning for reporting the state to clients.
TS_ReportDead = 0x00010000, // in WaitForOtherThreads()
TS_FullyInitialized = 0x00020000, // Thread is fully initialized and we are ready to broadcast its existence to external clients
// unused = 0x00040000,
TS_SyncSuspended = 0x00080000, // Suspended via WaitSuspendEvent
TS_DebugWillSync = 0x00100000, // Debugger will wait for this thread to sync
TS_StackCrawlNeeded = 0x00200000, // A stackcrawl is needed on this thread, such as for thread abort
// See comment for s_pWaitForStackCrawlEvent for reason.
// unused = 0x00400000,
// unused = 0x00800000,
TS_TPWorkerThread = 0x01000000, // is this a threadpool worker thread?
TS_Interruptible = 0x02000000, // sitting in a Sleep(), Wait(), Join()
TS_Interrupted = 0x04000000, // was awakened by an interrupt APC. !!! This can be moved to TSNC
// unused
TS_AbortInitiated = 0x10000000, // set when abort is begun
TS_Finalized = 0x20000000, // The associated managed Thread object has been finalized.
// We can clean up the unmanaged part now.
TS_FailStarted = 0x40000000, // The thread fails during startup.
TS_Detached = 0x80000000, // Thread was detached by DllMain
// <TODO> @TODO: We need to reclaim the bits that have no concurrency issues (i.e. they are only
// manipulated by the owning thread) and move them off to a different DWORD. Note if this
// enum is changed, we also need to update SOS to reflect this.</TODO>
// We require (and assert) that the following bits are less than 0x100.
TS_CatchAtSafePoint = (TS_AbortRequested | TS_DebugSuspendPending | TS_GCOnTransitions),
};
// Thread flags that aren't really states in themselves but rather things the thread
// has to do.
enum ThreadTasks
{
TT_CleanupSyncBlock = 0x00000001, // The synch block needs to be cleaned up.
#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT
TT_CallCoInitialize = 0x00000002, // CoInitialize needs to be called.
#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
};
// Thread flags that have no concurrency issues (i.e., they are only manipulated by the owning thread). Use these
// state flags when you have a new thread state that doesn't belong in the ThreadState enum above.
//
// <TODO>@TODO: its possible that the ThreadTasks from above and these flags should be merged.</TODO>
enum ThreadStateNoConcurrency
{
TSNC_Unknown = 0x00000000, // threads are initialized this way
TSNC_DebuggerUserSuspend = 0x00000001, // marked "suspended" by the debugger
// unused = 0x00000002,
TSNC_DebuggerIsStepping = 0x00000004, // debugger is stepping this thread
TSNC_DebuggerIsManagedException = 0x00000008, // EH is re-raising a managed exception.
// unused = 0x00000010,
TSNC_BlockedForShutdown = 0x00000020, // Thread is blocked in WaitForEndOfShutdown. We should not hit WaitForEndOfShutdown again.
// unused = 0x00000040,
// unused = 0x00000080,
TSNC_ExistInThreadStore = 0x00000100, // For dtor to know if it needs to be removed from ThreadStore
// unused = 0x00000200,
TSNC_OwnsSpinLock = 0x00000400, // The thread owns a spinlock.
TSNC_PreparingAbort = 0x00000800, // Preparing abort. This avoids recursive HandleThreadAbort call.
TSNC_OSAlertableWait = 0x00001000, // Preparing abort. This avoids recursive HandleThreadAbort call.
// unused = 0x00002000,
TSNC_CreatingTypeInitException = 0x00004000, // Thread is trying to create a TypeInitException
// unused = 0x00008000,
// unused = 0x00010000,
TSNC_InRestoringSyncBlock = 0x00020000, // The thread is restoring its SyncBlock for Object.Wait.
// After the thread is interrupted once, we turn off interruption
// at the beginning of wait.
// unused = 0x00040000,
// unused = 0x00080000,
// unused = 0x00100000,
// unused = 0x00200000,
// unused = 0x00400000,
// unused = 0x00800000,
TSNC_ProcessedUnhandledException = 0x01000000,// Set on a thread on which we have done unhandled exception processing so that
// we dont perform it again when OS invokes our UEF. Currently, applicable threads include:
// 1) entry point thread of a managed app
// 2) new managed thread created in default domain
//
// For such threads, we will return to the OS after our UE processing is done
// and the OS will start invoking the UEFs. If our UEF gets invoked, it will try to
// perform the UE processing again. We will use this flag to prevent the duplicated
// effort.
//
// Once we are completely independent of the OS UEF, we could remove this.
// unused = 0x02000000,
TSNC_DebuggerSleepWaitJoin = 0x04000000, // Indicates to the debugger that this thread is in a sleep wait or join state
// This almost mirrors the TS_Interruptible state however that flag can change
// during GC-preemptive mode whereas this one cannot.
#ifdef FEATURE_COMINTEROP
TSNC_WinRTInitialized = 0x08000000, // the thread has initialized WinRT
#endif // FEATURE_COMINTEROP
TSNC_TSLTakenForStartup = 0x10000000, // The ThreadStoreLock (TSL) is held by another mechanism during
// thread startup so can be skipped.
TSNC_CallingManagedCodeDisabled = 0x20000000, // Use by multicore JIT feature to asert on calling managed code/loading module in background thread
// Exception, system module is allowed, security demand is allowed
TSNC_LoadsTypeViolation = 0x40000000, // Use by type loader to break deadlocks caused by type load level ordering violations
TSNC_EtwStackWalkInProgress = 0x80000000, // Set on the thread so that ETW can know that stackwalking is in progress
// and does not proceed with a stackwalk on the same thread
// There are cases during managed debugging when we can run into this situation
};
public:
HRESULT DetachThread(BOOL fDLLThreadDetach);
void SetThreadState(ThreadState ts)
{
LIMITED_METHOD_CONTRACT;
InterlockedOr((LONG*)&m_State, ts);
}
void ResetThreadState(ThreadState ts)
{
LIMITED_METHOD_CONTRACT;
InterlockedAnd((LONG*)&m_State, ~ts);
}
BOOL HasThreadState(ThreadState ts)
{
LIMITED_METHOD_CONTRACT;
return ((DWORD)m_State & ts);
}
//
// This is meant to be used for quick opportunistic checks for thread abort and similar conditions. This method
// does not erect memory barrier and so it may return wrong result sometime that the caller has to handle.
//
BOOL HasThreadStateOpportunistic(ThreadState ts)
{
LIMITED_METHOD_CONTRACT;
return m_State.LoadWithoutBarrier() & ts;
}
void SetThreadStateNC(ThreadStateNoConcurrency tsnc)
{
LIMITED_METHOD_CONTRACT;
m_StateNC = (ThreadStateNoConcurrency)((DWORD)m_StateNC | tsnc);
}
void ResetThreadStateNC(ThreadStateNoConcurrency tsnc)
{
LIMITED_METHOD_CONTRACT;
m_StateNC = (ThreadStateNoConcurrency)((DWORD)m_StateNC & ~tsnc);
}
BOOL HasThreadStateNC(ThreadStateNoConcurrency tsnc)
{
LIMITED_METHOD_DAC_CONTRACT;
return ((DWORD)m_StateNC & tsnc);
}
void MarkEtwStackWalkInProgress()
{
WRAPPER_NO_CONTRACT;
SetThreadStateNC(Thread::TSNC_EtwStackWalkInProgress);
}
void MarkEtwStackWalkCompleted()
{
WRAPPER_NO_CONTRACT;
ResetThreadStateNC(Thread::TSNC_EtwStackWalkInProgress);
}
BOOL IsEtwStackWalkInProgress()
{
WRAPPER_NO_CONTRACT;
return HasThreadStateNC(Thread::TSNC_EtwStackWalkInProgress);
}
DWORD RequireSyncBlockCleanup()
{
LIMITED_METHOD_CONTRACT;
return (m_ThreadTasks & TT_CleanupSyncBlock);
}
void SetSyncBlockCleanup()
{
LIMITED_METHOD_CONTRACT;
InterlockedOr((LONG*)&m_ThreadTasks, TT_CleanupSyncBlock);
}
void ResetSyncBlockCleanup()
{
LIMITED_METHOD_CONTRACT;
InterlockedAnd((LONG*)&m_ThreadTasks, ~TT_CleanupSyncBlock);
}
#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT
DWORD IsCoInitialized()
{
LIMITED_METHOD_CONTRACT;
return (m_State & TS_CoInitialized);
}
void SetCoInitialized()
{
LIMITED_METHOD_CONTRACT;
InterlockedOr((LONG*)&m_State, TS_CoInitialized);
InterlockedAnd((LONG*)&m_ThreadTasks, ~TT_CallCoInitialize);
}
void ResetCoInitialized()
{
LIMITED_METHOD_CONTRACT;
ResetThreadState(TS_CoInitialized);
}
#ifdef FEATURE_COMINTEROP
BOOL IsWinRTInitialized()
{
LIMITED_METHOD_CONTRACT;
return HasThreadStateNC(TSNC_WinRTInitialized);
}
void ResetWinRTInitialized()
{
LIMITED_METHOD_CONTRACT;
ResetThreadStateNC(TSNC_WinRTInitialized);
}
#endif // FEATURE_COMINTEROP
DWORD RequiresCoInitialize()
{
LIMITED_METHOD_CONTRACT;
return (m_ThreadTasks & TT_CallCoInitialize);
}
void SetRequiresCoInitialize()
{
LIMITED_METHOD_CONTRACT;
InterlockedOr((LONG*)&m_ThreadTasks, TT_CallCoInitialize);
}
void ResetRequiresCoInitialize()
{
LIMITED_METHOD_CONTRACT;
InterlockedAnd((LONG*)&m_ThreadTasks,~TT_CallCoInitialize);
}
void CleanupCOMState();
#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
void PrepareApartmentAndContext();
#ifdef FEATURE_COMINTEROP
bool IsDisableComObjectEagerCleanup()
{
LIMITED_METHOD_CONTRACT;
return m_fDisableComObjectEagerCleanup;
}
void SetDisableComObjectEagerCleanup()
{
LIMITED_METHOD_CONTRACT;
m_fDisableComObjectEagerCleanup = true;
}
#endif //FEATURE_COMINTEROP
#ifndef DACCESS_COMPILE
bool HasDeadThreadBeenConsideredForGCTrigger()
{
LIMITED_METHOD_CONTRACT;
_ASSERTE(IsDead());
return m_fHasDeadThreadBeenConsideredForGCTrigger;
}
void SetHasDeadThreadBeenConsideredForGCTrigger()
{
LIMITED_METHOD_CONTRACT;
_ASSERTE(IsDead());
m_fHasDeadThreadBeenConsideredForGCTrigger = true;
}
#endif // !DACCESS_COMPILE
// returns if there is some extra work for the finalizer thread.
BOOL HaveExtraWorkForFinalizer();
// do the extra finalizer work.
void DoExtraWorkForFinalizer();
#ifndef DACCESS_COMPILE
DWORD CatchAtSafePoint()
{
CONTRACTL
{
NOTHROW;
GC_NOTRIGGER;
MODE_COOPERATIVE;
}
CONTRACTL_END;
return g_TrapReturningThreads & 1 ||
HasThreadStateOpportunistic(TS_CatchAtSafePoint);
}
#endif // DACCESS_COMPILE
DWORD IsExecutingOnAltStack()
{
LIMITED_METHOD_CONTRACT;
return (m_State & TS_ExecutingOnAltStack);
}
void SetExecutingOnAltStack()
{
LIMITED_METHOD_CONTRACT;
SetThreadState(TS_ExecutingOnAltStack);
}
DWORD IsBackground()
{
LIMITED_METHOD_CONTRACT;
return (m_State & TS_Background);
}
DWORD IsUnstarted()
{
LIMITED_METHOD_CONTRACT;
SUPPORTS_DAC;
return (m_State & TS_Unstarted);
}
DWORD IsDead()
{
LIMITED_METHOD_CONTRACT;
return (m_State & TS_Dead);
}
DWORD DoWeOwn()
{
LIMITED_METHOD_CONTRACT;
return (m_State & TS_WeOwn);
}
// For reporting purposes, grab a consistent snapshot of the thread's state
ThreadState GetSnapshotState();
// For delayed destruction of threads
DWORD IsDetached()
{
LIMITED_METHOD_CONTRACT;
return (m_State & TS_Detached);
}
static LONG m_DetachCount;
static LONG m_ActiveDetachCount; // Count how many non-background detached
// Offsets for the following variables need to fit in 1 byte, so keep near
// the top of the object. Also, we want cache line filling to work for us
// so the critical stuff is ordered based on frequency of use.
Volatile<ThreadState> m_State; // Bits for the state of the thread
// If TRUE, GC is scheduled cooperatively with this thread.
// NOTE: This "byte" is actually a boolean - we don't allow
// recursive disables.
Volatile<ULONG> m_fPreemptiveGCDisabled;
PTR_Frame m_pFrame; // The Current Frame
// Unique thread id used for thin locks - kept as small as possible, as we have limited space
// in the object header to store it.
DWORD m_ThreadId;
#ifndef DACCESS_COMPILE
Frame* NotifyFrameChainOfExceptionUnwind(Frame* pStartFrame, LPVOID pvLimitSP);
#endif // DACCESS_COMPILE
// Lock thread is trying to acquire
VolatilePtr<DeadlockAwareLock> m_pBlockingLock;
// We store a pointer to the runtime thread locals here for easier introspection
// from other threads and diagnostic tools
PTR_RuntimeThreadLocals m_pRuntimeThreadLocals;
public:
inline void InitRuntimeThreadLocals() { LIMITED_METHOD_CONTRACT; m_pRuntimeThreadLocals = PTR_RuntimeThreadLocals(&t_runtime_thread_locals); }
inline ee_alloc_context* GetEEAllocContext()
{
LIMITED_METHOD_CONTRACT;
if (m_pRuntimeThreadLocals == nullptr)
{
return nullptr;
}
return &m_pRuntimeThreadLocals->alloc_context;
}
inline gc_alloc_context* GetAllocContext()
{
LIMITED_METHOD_CONTRACT;
if (m_pRuntimeThreadLocals == nullptr)
{
return nullptr;
}
return &m_pRuntimeThreadLocals->alloc_context.m_GCAllocContext;
}
// This is the type handle of the first object in the alloc context at the time
// we fire the AllocationTick event. It's only for tooling purpose.
TypeHandle m_thAllocContextObj;
#ifndef TARGET_UNIX
private:
_NT_TIB *m_pTEB;
public:
_NT_TIB *GetTEB() {
LIMITED_METHOD_CONTRACT;
return m_pTEB;
}
PEXCEPTION_REGISTRATION_RECORD *GetExceptionListPtr() {
WRAPPER_NO_CONTRACT;
return &GetTEB()->ExceptionList;
}
#endif // !TARGET_UNIX
inline void SetTHAllocContextObj(TypeHandle th) {LIMITED_METHOD_CONTRACT; m_thAllocContextObj = th; }
inline TypeHandle GetTHAllocContextObj() {LIMITED_METHOD_CONTRACT; return m_thAllocContextObj; }
// Flags used to indicate tasks the thread has to do.
ThreadTasks m_ThreadTasks;