threads.h File Reference

Go to the source code of this file.

Classes
struct	_RTLP_GENERIC_TIMER
struct	_RTLP_WAIT
struct	_RTLP_WAIT_THREAD_CONTROL_BLOCK
struct	_RTLP_IOWORKER_TCB
struct	_RTLP_WAITWORKER
struct	_RTLP_WORK
struct	_RTLP_EVENT
Defines
#define	DBG1   1
#define	RTLP_TIMER   RTLP_GENERIC_TIMER
#define	PRTLP_TIMER   PRTLP_GENERIC_TIMER
#define	RTLP_TIMER_QUEUE   RTLP_GENERIC_TIMER
#define	PRTLP_TIMER_QUEUE   PRTLP_GENERIC_TIMER
#define	THREAD_CREATION_DAMPING_TIME1   1000
#define	THREAD_CREATION_DAMPING_TIME2   5000
#define	THREAD_TERMINATION_DAMPING_TIME   10000
#define	NEW_THREAD_THRESHOLD   7
#define	MAX_WORKER_THREADS   1000
#define	INFINITE_TIME   (ULONG)~0
#define	RTLP_MAX_TIMERS   0x00080000
#define	MAX_UNUSED_EVENTS   40
#define	ONE_MILLISECOND_TIMEOUT(TimeOut)
#define	HUNDRED_MILLISECOND_TIMEOUT(TimeOut)
#define	ONE_SECOND_TIMEOUT(TimeOut)
#define	USE_PROCESS_HEAP   1
#define	RtlpFreeTPHeap(Ptr)   RtlFreeHeap( RtlProcessHeap(), 0, (Ptr) )
#define	RtlpAllocateTPHeap(Size, Flags)   RtlAllocateHeap( RtlProcessHeap(), (Flags), (Size) )
#define	ACQUIRE_GLOBAL_WAIT_LOCK()   RtlEnterCriticalSection (&WaitCriticalSection)
#define	RELEASE_GLOBAL_WAIT_LOCK()   RtlLeaveCriticalSection(&WaitCriticalSection)
#define	ACQUIRE_GLOBAL_TIMER_LOCK()   RtlEnterCriticalSection (&TimerCriticalSection)
#define	RELEASE_GLOBAL_TIMER_LOCK()   RtlLeaveCriticalSection(&TimerCriticalSection)
#define	IS_COMPONENT_INITIALIZED(StartedVariable, CompletedVariable, Flag)
#define	DBG_SET_FUNCTION(Fn, Context)
#define	RtlpShiftWaitArray(ThreadCB, SrcIndex, DstIndex, Count)
#define	RtlpGetResync64BitTickCount()   Resync64BitTickCount.QuadPart
#define	RtlpSetFiring64BitTickCount(Timeout)   Firing64BitTickCount.QuadPart = (Timeout)
#define	SET_SIGNATURE(ptr)   (ptr)->State |= 0xfedc0000
#define	CHECK_SIGNATURE(ptr)   ASSERT( ((ptr)->State & 0xffff0000) == 0xfedc0000 )
#define	SET_DEL_SIGNATURE(ptr)   ((ptr)->State |= 0xfedcb000)
#define	CHECK_DEL_SIGNATURE(ptr)
#define	CLEAR_SIGNATURE(ptr)   ((ptr)->State = ((ptr)->State & 0x0000ffff) | 0xcdef0000)
#define	SET_DEL_TIMERQ_SIGNATURE(ptr)   ((ptr)->State |= 0x00000a00)
#define	DPRN0   (DPRN & 0x1)
#define	DPRN1   (DPRN & 0x2)
#define	DPRN2   (DPRN & 0x4)
#define	DPRN3   (DPRN & 0x8)
#define	DPRN4   (DPRN & 0x10)
#define	THREAD_TYPE_WORKER   1
#define	THREAD_TYPE_IO_WORKER   2
#define	STATE_REGISTERED   0x0001
#define	STATE_ACTIVE   0x0002
#define	STATE_DELETE   0x0004
#define	STATE_DONTFIRE   0x0008
#define	STATE_ONE_SHOT_FIRED   0x0010
Typedefs
typedef _RTLP_GENERIC_TIMER	RTLP_GENERIC_TIMER
typedef _RTLP_GENERIC_TIMER *	PRTLP_GENERIC_TIMER
typedef _RTLP_WAIT	RTLP_WAIT
typedef _RTLP_WAIT *	PRTLP_WAIT
typedef _RTLP_WAIT_THREAD_CONTROL_BLOCK	RTLP_WAIT_THREAD_CONTROL_BLOCK
typedef _RTLP_WAIT_THREAD_CONTROL_BLOCK *	PRTLP_WAIT_THREAD_CONTROL_BLOCK
typedef _RTLP_IOWORKER_TCB	RTLP_IOWORKER_TCB
typedef _RTLP_IOWORKER_TCB *	PRTLP_IOWORKER_TCB
typedef _RTLP_WAITWORKER	RTLP_ASYNC_CALLBACK
typedef _RTLP_WAITWORKER *	PRTLP_ASYNC_CALLBACK
typedef _RTLP_WORK	RTLP_WORK
typedef _RTLP_WORK *	PRTLP_WORK
typedef _RTLP_EVENT	RTLP_EVENT
typedef _RTLP_EVENT *	PRTLP_EVENT
Functions
NTSTATUS	RtlpInitializeWorkerThreadPool ()
NTSTATUS	RtlpInitializeWaitThreadPool ()
NTSTATUS	RtlpInitializeTimerThreadPool ()
NTSTATUS	RtlpStartThread (IN PUSER_THREAD_START_ROUTINE Function, OUT HANDLE *ThreadHandle)
LONG	RtlpWaitThread (IN PVOID WaitHandle)
LONG	RtlpWorkerThread (PVOID NotUsed)
LONG	RtlpIOWorkerThread (PVOID NotUsed)
LONG	RtlpTimerThread (PVOID NotUsed)
VOID	RtlpAddTimerQueue (PVOID Queue)
VOID	RtlpAddTimer (PRTLP_TIMER Timer)
VOID	RtlpResetTimer (HANDLE TimerHandle, ULONG DueTime, PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB)
VOID	RtlpFireTimersAndReorder (PRTLP_TIMER_QUEUE Queue, ULONG *NewFiringTime, PLIST_ENTRY TimersToFireList)
VOID	RtlpFireTimers (PLIST_ENTRY TimersToFireList)
VOID	RtlpInsertTimersIntoDeltaList (PLIST_ENTRY NewTimerList, PLIST_ENTRY DeltaTimerList, ULONG TimeRemaining, ULONG *NewFiringTime)
BOOLEAN	RtlpInsertInDeltaList (PLIST_ENTRY DeltaList, PRTLP_GENERIC_TIMER NewTimer, ULONG TimeRemaining, ULONG *NewFiringTime)
BOOLEAN	RtlpRemoveFromDeltaList (PLIST_ENTRY DeltaList, PRTLP_GENERIC_TIMER Timer, ULONG TimeRemaining, ULONG *NewFiringTime)
BOOLEAN	RtlpReOrderDeltaList (PLIST_ENTRY DeltaList, PRTLP_GENERIC_TIMER Timer, ULONG TimeRemaining, ULONG *NewFiringTime, ULONG ChangedFiringTime)
VOID	RtlpAddWait (PRTLP_WAIT Wait)
NTSTATUS	RtlpDeregisterWait (PRTLP_WAIT Wait, HANDLE PartialCompletionEvent, PULONG StatusPtr)
NTSTATUS	RtlpDeactivateWait (PRTLP_WAIT Wait)
VOID	RtlpDeleteWait (PRTLP_WAIT Wait)
VOID	RtlpProcessWaitCompletion (PRTLP_WAIT Wait, ULONG ArrayIndex)
VOID	RtlpProcessTimeouts (PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB)
ULONG	RtlpGetTimeRemaining (HANDLE TimerHandle)
VOID	RtlpServiceTimer (PVOID NotUsedArg, ULONG NotUsedLowTimer, LONG NotUsedHighTimer)
ULONG	RtlpGetQueueRelativeTime (PRTLP_TIMER_QUEUE Queue)
VOID	RtlpCancelTimer (PRTLP_TIMER TimerToCancel)
VOID	RtlpCancelTimerEx (PRTLP_TIMER Timer, BOOLEAN DeletingQueue)
VOID	RtlpDeactivateTimer (PRTLP_TIMER_QUEUE Queue, PRTLP_TIMER Timer)
NTSTATUS	RtlpDeleteTimerQueue (PRTLP_TIMER_QUEUE Queue)
VOID	RtlpDeleteTimerQueueComplete (PRTLP_TIMER_QUEUE Queue)
LONGLONG	Rtlp64BitTickCount ()
NTSTATUS	RtlpFindWaitThread (PRTLP_WAIT_THREAD_CONTROL_BLOCK *ThreadCB)
VOID	RtlpExecuteIOWorkItem (PVOID Function, PVOID Context, PVOID NotUsed)
VOID	RtlpExecuteLongIOWorkItem (PVOID Function, PVOID Context, PVOID NotUsed)
NTSTATUS	RtlpQueueIOWorkerRequest (WORKERCALLBACKFUNC Function, PVOID Context, ULONG Flags)
NTSTATUS	RtlpStartWorkerThread ()
NTSTATUS	RtlpStartIOWorkerThread ()
VOID	RtlpWorkerThreadTimerCallback (PVOID Context, BOOLEAN NotUsed)
NTSTATUS	RtlpQueueWorkerRequest (WORKERCALLBACKFUNC Function, PVOID Context, ULONG Flags)
BOOLEAN	RtlpDoWeNeedNewWorkerThread (ULONG ThreadType)
VOID	RtlpUpdateTimer (PRTLP_TIMER Timer, PRTLP_TIMER UpdatedTimer)
VOID	RtlpDeleteTimer (PRTLP_TIMER Timer)
VOID	RtlpFreeWaitEvent (PRTLP_EVENT Event)
VOID	RtlpInitializeEventCache (VOID)
PRTLP_EVENT	RtlpGetWaitEvent (VOID)
VOID	RtlpDeleteWaitAPC (PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB, PRTLP_WAIT Wait, HANDLE Handle)
VOID	RtlpDoNothing (PVOID NotUsed1, PVOID NotUsed2, PVOID NotUsed3)
VOID	RtlpExecuteWorkerRequest (NTSTATUS Status, PVOID Context, PVOID ActualFunction)
NTSTATUS	RtlpInitializeTPHeap ()
NTSTATUS	RtlpWaitForEvent (HANDLE Event, HANDLE ThreadHandle)
VOID	RtlpThreadCleanup ()
VOID	RtlpWorkerThreadCleanup (NTSTATUS Status, PVOID NotUsed, PVOID NotUsed2)
PVOID	RtlpForceAllocateTPHeap (ULONG dwSize, ULONG dwFlags)
VOID	RtlpWorkerThreadInitializeTimers (PVOID Context)
NTSYSAPI NTSTATUS NTAPI	RtlThreadPoolCleanup (ULONG Flags)
Variables
ULONG	NextTimerDbgId
ULONG	NextWaitDbgId
ULONG	StartedTPInitialization
ULONG	CompletedTPInitialization
ULONG	StartedWorkerInitialization
ULONG	CompletedWorkerInitialization
ULONG	StartedWaitInitialization
ULONG	CompletedWaitInitialization
ULONG	StartedTimerInitialization
ULONG	CompletedTimerInitialization
ULONG	StartedEventCacheInitialization
ULONG	CompletedEventCacheInitialization
HANDLE	TimerThreadHandle
ULONG	TimerThreadId
ULONG	NumIOWorkerThreads
ULONG	NumWorkerThreads
ULONG	NumMinWorkerThreads
ULONG	NumIOWorkRequests
ULONG	NumLongIOWorkRequests
ULONG	NumWorkRequests
ULONG	NumLongWorkRequests
ULONG	NumExecutingWorkerThreads
ULONG	TotalExecutedWorkRequests
ULONG	OldTotalExecutedWorkRequests
HANDLE	WorkerThreadTimerQueue
ULONG	WorkerThreadTimerQueueInit
HANDLE	WorkerThreadTimer
ULONG	NumUnusedEvents
ULONG	LastThreadCreationTickCount
LIST_ENTRY	IOWorkerThreads
PRTLP_IOWORKER_TCB	PersistentIOTCB
HANDLE	WorkerCompletionPort
LIST_ENTRY	WaitThreads
LIST_ENTRY	EventCache
LIST_ENTRY	TimerQueues
HANDLE	TimerHandle
ULONG	NumTimerQueues
RTL_CRITICAL_SECTION	WorkerCriticalSection
RTL_CRITICAL_SECTION	WaitCriticalSection
RTL_CRITICAL_SECTION	TimerCriticalSection
RTL_CRITICAL_SECTION	EventCacheCriticalSection
RTLP_START_THREAD	RtlpStartThread
PRTLP_START_THREAD	RtlpStartThreadFunc = RtlpStartThread
RTLP_EXIT_THREAD	RtlpExitThread
PRTLP_EXIT_THREAD	RtlpExitThreadFunc = RtlpExitThread
PVOID	CallbackFn1
PVOID	CallbackFn2
PVOID	Context1
PVOID	Context2
LARGE_INTEGER	Last64BitTickCount
LARGE_INTEGER	Resync64BitTickCount
LARGE_INTEGER	Firing64BitTickCount
PRTLP_EVENT	RtlpGetWaitEvent (VOID)

---

Define Documentation

#define ACQUIRE_GLOBAL_TIMER_LOCK (   )     RtlEnterCriticalSection (&TimerCriticalSection)

Definition at line 320 of file threads.h. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlpServiceTimer(), and RtlThreadPoolCleanup().

#define ACQUIRE_GLOBAL_WAIT_LOCK (   )     RtlEnterCriticalSection (&WaitCriticalSection)

Definition at line 310 of file threads.h. Referenced by RtlpFindWaitThread(), RtlpWaitThread(), and RtlThreadPoolCleanup().

#define CHECK_DEL_SIGNATURE (  ptr   )

Value: ASSERT( (((ptr)->State & 0xffff0000) == 0xfedc0000) \ && ( ! ((ptr)->State & 0x0000f000)) ) Definition at line 398 of file threads.h. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlDeregisterWaitEx(), and RtlUpdateTimer().

#define CHECK_SIGNATURE (  ptr   )     ASSERT( ((ptr)->State & 0xffff0000) == 0xfedc0000 )

Definition at line 396 of file threads.h. Referenced by RtlpCancelTimerEx(), RtlpDeleteTimer(), RtlpDeleteWait(), RtlpDeregisterWait(), and RtlpUpdateTimer().

#define CLEAR_SIGNATURE (  ptr   )     ((ptr)->State = ((ptr)->State & 0x0000ffff) | 0xcdef0000)

Definition at line 400 of file threads.h. Referenced by RtlpDeleteTimer(), and RtlpDeleteWait().

#define DBG1   1

Definition at line 31 of file threads.h.

#define DBG_SET_FUNCTION (  Fn, Context   )

Value: { \ CallbackFn1 = CallbackFn2 ; \ CallbackFn2 = (Fn) ; \ Context1 = Context2 ; \ Context2 = (Context ) ; \ } Definition at line 354 of file threads.h. Referenced by RtlpAsyncCallbackCompletion(), RtlpExecuteIOWorkItem(), RtlpExecuteLongIOWorkItem(), RtlpExecuteWorkerRequest(), RtlpFireTimers(), and RtlpProcessWaitCompletion().

#define DPRN0   (DPRN & 0x1)

Definition at line 406 of file threads.h. Referenced by RtlCreateTimerQueue(), RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlDeregisterWaitEx(), and RtlRegisterWait().

#define DPRN1   (DPRN & 0x2)

Definition at line 407 of file threads.h. Referenced by RtlCreateTimer(), RtlpDeleteTimer(), RtlpDeleteTimerQueueComplete(), RtlpDeleteWait(), and RtlUpdateTimer().

#define DPRN2   (DPRN & 0x4)

Definition at line 408 of file threads.h. Referenced by RtlpServiceTimer().

#define DPRN3   (DPRN & 0x8)

Definition at line 409 of file threads.h. Referenced by RtlpServiceTimer().

#define DPRN4   (DPRN & 0x10)

Definition at line 410 of file threads.h. Referenced by RtlpAsyncCallbackCompletion(), RtlpFireTimers(), and RtlpProcessWaitCompletion().

#define HUNDRED_MILLISECOND_TIMEOUT (  TimeOut   )

Value: { \ TimeOut.LowPart = 0xfff0bdc0 ; \ TimeOut.HighPart = 0xffffffff ; \ } Definition at line 290 of file threads.h.

#define INFINITE_TIME   (ULONG)~0

Definition at line 277 of file threads.h. Referenced by RtlpAddWait(), RtlpFireTimersAndReorder(), RtlpRemoveFromDeltaList(), RtlpResetTimer(), and RtlpServiceTimer().

#define IS_COMPONENT_INITIALIZED (  StartedVariable, CompletedVariable, Flag   )

Value: {\ LARGE_INTEGER TimeOut ; \ Flag = FALSE ; \ \ if ( StartedVariable ) { \ \ if ( !CompletedVariable ) { \ \ ONE_MILLISECOND_TIMEOUT(TimeOut) ; \ \ while (!(volatile ULONG) CompletedVariable) \ NtDelayExecution (FALSE, &TimeOut) ; \ \ if (CompletedVariable == 1) \ Flag = TRUE ; \ \ } else { \ Flag = TRUE ; \ } \ } \ } Definition at line 328 of file threads.h. Referenced by RtlThreadPoolCleanup().

#define MAX_UNUSED_EVENTS   40

Definition at line 279 of file threads.h. Referenced by RtlpFreeWaitEvent().

#define MAX_WORKER_THREADS   1000

Definition at line 276 of file threads.h. Referenced by RtlpWorkerThreadTimerCallback(), and RtlQueueWorkItem().

#define NEW_THREAD_THRESHOLD   7

Definition at line 275 of file threads.h. Referenced by RtlpIOWorkerThread(), RtlpWorkerThread(), RtlpWorkerThreadTimerCallback(), and RtlQueueWorkItem().

#define ONE_MILLISECOND_TIMEOUT (  TimeOut   )

Value: { \ TimeOut.LowPart = 0xffffd8f0 ; \ TimeOut.HighPart = 0xffffffff ; \ } Definition at line 285 of file threads.h. Referenced by RtlpInitializeEventCache(), RtlpInitializeTimerThreadPool(), RtlpInitializeWaitThreadPool(), RtlpInitializeWorkerThreadPool(), and RtlpStartThread().

#define ONE_SECOND_TIMEOUT (  TimeOut   )

Value: { \ TimeOut.LowPart = 0xff676980 ; \ TimeOut.HighPart = 0xffffffff ; \ } Definition at line 295 of file threads.h. Referenced by RtlpForceAllocateTPHeap(), and RtlpWaitForEvent().

#define PRTLP_TIMER   PRTLP_GENERIC_TIMER

Definition at line 45 of file threads.h. Referenced by PrintTimerQueue(), RtlCreateTimer(), RtlDeleteTimer(), RtlpAddWait(), RtlpAsyncCallbackCompletion(), RtlpDeleteTimerQueue(), RtlpFireTimers(), RtlpFireTimersAndReorder(), RtlpServiceTimer(), and RtlUpdateTimer().

#define PRTLP_TIMER_QUEUE   PRTLP_GENERIC_TIMER

Definition at line 48 of file threads.h. Referenced by PrintTimerQueue(), RtlCreateTimer(), RtlCreateTimerQueue(), RtlDebugPrintTimes(), RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlpAddTimer(), RtlpCancelTimerEx(), RtlpDeleteTimer(), RtlpGetQueueRelativeTime(), RtlpServiceTimer(), and RtlpUpdateTimer().

#define RELEASE_GLOBAL_TIMER_LOCK (   )     RtlLeaveCriticalSection(&TimerCriticalSection)

Definition at line 323 of file threads.h. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlpServiceTimer(), and RtlThreadPoolCleanup().

#define RELEASE_GLOBAL_WAIT_LOCK (   )     RtlLeaveCriticalSection(&WaitCriticalSection)

Definition at line 313 of file threads.h. Referenced by RtlpFindWaitThread(), RtlpWaitThread(), and RtlThreadPoolCleanup().

#define RTLP_MAX_TIMERS   0x00080000

Definition at line 278 of file threads.h.

#define RTLP_TIMER   RTLP_GENERIC_TIMER

Definition at line 44 of file threads.h. Referenced by PrintTimerQueue(), RtlCreateTimer(), RtlpDeleteTimerQueue(), RtlpFireTimers(), RtlpFireTimersAndReorder(), RtlpWaitThread(), and RtlUpdateTimer().

#define RTLP_TIMER_QUEUE   RTLP_GENERIC_TIMER

Definition at line 47 of file threads.h. Referenced by PrintTimerQueue(), RtlCreateTimerQueue(), RtlDebugPrintTimes(), RtlpGetQueueRelativeTime(), and RtlpServiceTimer().

#define RtlpAllocateTPHeap (  Size, Flags   )     RtlAllocateHeap( RtlProcessHeap(), (Flags), (Size) )

Definition at line 305 of file threads.h. Referenced by RtlCreateTimer(), RtlCreateTimerQueue(), RtlpForceAllocateTPHeap(), RtlRegisterWait(), and RtlUpdateTimer().

#define RtlpFreeTPHeap (  Ptr   )     RtlFreeHeap( RtlProcessHeap(), 0, (Ptr) )

Definition at line 302 of file threads.h. Referenced by RtlpAsyncCallbackCompletion(), RtlpDeleteTimer(), RtlpDeleteTimerQueueComplete(), RtlpDeleteWait(), RtlpExecuteWorkerRequest(), RtlpFireTimers(), RtlpFreeWaitEvent(), RtlpGetWaitEvent(), RtlpProcessWaitCompletion(), RtlpQueueWorkerRequest(), RtlpUpdateTimer(), and RtlRegisterWait().

#define RtlpGetResync64BitTickCount (   )     Resync64BitTickCount.QuadPart

Definition at line 387 of file threads.h. Referenced by RtlpResetTimer().

#define RtlpSetFiring64BitTickCount (  Timeout   )     Firing64BitTickCount.QuadPart = (Timeout)

Definition at line 388 of file threads.h. Referenced by RtlpResetTimer().

#define RtlpShiftWaitArray (  ThreadCB, SrcIndex, DstIndex, Count   )

Value: { \ \ RtlCopyMemory (&(ThreadCB)->ActiveWaitArray[DstIndex], \ &(ThreadCB)->ActiveWaitArray[SrcIndex], \ sizeof (HANDLE) * (Count)) ; \ \ RtlCopyMemory (&(ThreadCB)->ActiveWaitPointers[DstIndex],\ &(ThreadCB)->ActiveWaitPointers[SrcIndex],\ sizeof (HANDLE) * (Count)) ; \ } Definition at line 372 of file threads.h. Referenced by RtlpDeactivateWait(), and RtlpProcessWaitCompletion().

#define SET_DEL_SIGNATURE (  ptr   )     ((ptr)->State |= 0xfedcb000)

Definition at line 397 of file threads.h. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), and RtlDeregisterWaitEx().

#define SET_DEL_TIMERQ_SIGNATURE (  ptr   )     ((ptr)->State |= 0x00000a00)

Definition at line 401 of file threads.h. Referenced by RtlpDeleteTimerQueue().

#define SET_SIGNATURE (  ptr   )     (ptr)->State |= 0xfedc0000

Definition at line 395 of file threads.h. Referenced by RtlCreateTimer(), RtlCreateTimerQueue(), and RtlRegisterWait().

#define STATE_ACTIVE   0x0002

Definition at line 760 of file threads.h. Referenced by RtlpAddTimer(), RtlpAddWait(), RtlpCancelTimerEx(), RtlpDeactivateWait(), RtlpDeregisterWait(), RtlpFireTimersAndReorder(), and RtlpUpdateTimer().

#define STATE_DELETE   0x0004

Definition at line 763 of file threads.h. Referenced by RtlpAddTimer(), RtlpAddWait(), RtlpCancelTimerEx(), and RtlpDeregisterWait().

#define STATE_DONTFIRE   0x0008

Definition at line 766 of file threads.h. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlpFireTimers(), and RtlpFireTimersAndReorder().

#define STATE_ONE_SHOT_FIRED   0x0010

Definition at line 769 of file threads.h. Referenced by RtlpFireTimersAndReorder().

#define STATE_REGISTERED   0x0001

Definition at line 755 of file threads.h. Referenced by RtlpAddTimer(), RtlpAddWait(), and RtlpDeregisterWait().

#define THREAD_CREATION_DAMPING_TIME1   1000

Definition at line 272 of file threads.h. Referenced by RtlQueueWorkItem().

#define THREAD_CREATION_DAMPING_TIME2   5000

Definition at line 273 of file threads.h. Referenced by RtlQueueWorkItem().

#define THREAD_TERMINATION_DAMPING_TIME   10000

Definition at line 274 of file threads.h.

#define THREAD_TYPE_IO_WORKER   2

Definition at line 650 of file threads.h.

#define THREAD_TYPE_WORKER   1

Definition at line 649 of file threads.h.

#define USE_PROCESS_HEAP   1

Definition at line 300 of file threads.h.

---

Typedef Documentation

typedef struct _RTLP_WAITWORKER * PRTLP_ASYNC_CALLBACK

Referenced by RtlpAsyncCallbackCompletion().

typedef struct _RTLP_EVENT * PRTLP_EVENT

Referenced by RtlRegisterWait().

typedef struct _RTLP_GENERIC_TIMER * PRTLP_GENERIC_TIMER

Referenced by RtlpInsertInDeltaList().

typedef struct _RTLP_IOWORKER_TCB * PRTLP_IOWORKER_TCB

typedef struct _RTLP_WAIT * PRTLP_WAIT

Referenced by RtlRegisterWait().

typedef struct _RTLP_WAIT_THREAD_CONTROL_BLOCK * PRTLP_WAIT_THREAD_CONTROL_BLOCK

Referenced by RtlRegisterWait().

typedef struct _RTLP_WORK * PRTLP_WORK

Referenced by RtlpQueueWorkerRequest().

typedef struct _RTLP_WAITWORKER RTLP_ASYNC_CALLBACK

Referenced by RtlpProcessWaitCompletion().

typedef struct _RTLP_EVENT RTLP_EVENT

Referenced by RtlpGetWaitEvent().

typedef struct _RTLP_GENERIC_TIMER RTLP_GENERIC_TIMER

Referenced by RtlpInsertInDeltaList().

typedef struct _RTLP_IOWORKER_TCB RTLP_IOWORKER_TCB

Referenced by RtlThreadPoolCleanup().

typedef struct _RTLP_WAIT RTLP_WAIT

Referenced by RtlRegisterWait().

typedef struct _RTLP_WAIT_THREAD_CONTROL_BLOCK RTLP_WAIT_THREAD_CONTROL_BLOCK

Referenced by RtlThreadPoolCleanup().

typedef struct _RTLP_WORK RTLP_WORK

Referenced by RtlpQueueWorkerRequest().

---

Function Documentation

LONGLONG Rtlp64BitTickCount (   )

VOID RtlpAddTimer (  PRTLP_TIMER  Timer  )

Definition at line 3954 of file threads.c. References NULL, PRTLP_TIMER_QUEUE, RtlpDeleteTimer(), RtlpGetQueueRelativeTime(), RtlpGetTimeRemaining(), RtlpInsertInDeltaList(), RtlpReOrderDeltaList(), RtlpResetTimer(), RtlpResync64BitTickCount(), STATE_ACTIVE, STATE_DELETE, STATE_REGISTERED, TimerHandle, and TimerQueues. Referenced by RtlCreateTimer(). : This routine runs as an APC into the Timer thread. It adds a new timer to the specified queue. Arguments: Timer - Pointer to the timer to add Return Value: --*/ { PRTLP_TIMER_QUEUE Queue ; ULONG TimeRemaining, QueueRelTimeRemaining ; ULONG NewFiringTime ; RtlpResync64BitTickCount() ; // the timer was set to be deleted in a callback function. if (Timer->State & STATE_DELETE ) { RtlpDeleteTimer( Timer ) ; return ; } Queue = Timer->Queue ; // TimeRemaining is the time left in the current timer + the relative time of // the queue it is being inserted into TimeRemaining = RtlpGetTimeRemaining (TimerHandle) ; QueueRelTimeRemaining = TimeRemaining + RtlpGetQueueRelativeTime (Queue) ; if (RtlpInsertInDeltaList (&Queue->TimerList, Timer, QueueRelTimeRemaining, &NewFiringTime)) { // If the Queue is not attached to TimerQueues since it had no timers // previously then insert the queue into the TimerQueues list, else just // reorder its existing position. if (IsListEmpty (&Queue->List)) { Queue->DeltaFiringTime = NewFiringTime ; if (RtlpInsertInDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime)) { // There is a new element at the head of the queue we need to reset the NT // timer to fire sooner. RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; } } else { // If we insert at the head of the timer delta list we will need to // make sure the queue delta list is readjusted if (RtlpReOrderDeltaList(&TimerQueues, Queue, TimeRemaining, &NewFiringTime, NewFiringTime)){ // There is a new element at the head of the queue we need to reset the NT // timer to fire sooner. RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; } } } Timer->State |= ( STATE_REGISTERED | STATE_ACTIVE ) ; }

VOID RtlpAddTimerQueue (  PVOID  Queue  )

Definition at line 4794 of file threads.c. : This routine runs as an APC into the Timer thread. It does whatever necessary to create a new timer queue Arguments: Queue - Pointer to the queue to add Return Value: --*/ { // We do nothing here. The newly created queue is free floating until a timer is // queued onto it. }

VOID RtlpAddWait (  PRTLP_WAIT  Wait  )

Definition at line 3302 of file threads.c. References _RTLP_WAIT_THREAD_CONTROL_BLOCK::ActiveWaitArray, _RTLP_WAIT_THREAD_CONTROL_BLOCK::ActiveWaitPointers, ASSERT, _RTLP_WAIT::Context, _RTLP_GENERIC_TIMER::Context, _RTLP_GENERIC_TIMER::DeltaFiringTime, FALSE, _RTLP_WAIT::Flags, _RTLP_GENERIC_TIMER::Flags, _RTLP_WAIT_THREAD_CONTROL_BLOCK::FreeTimerBlocks, _RTLP_WAIT::Function, _RTLP_GENERIC_TIMER::Function, INFINITE_TIME, NULL, _RTLP_WAIT_THREAD_CONTROL_BLOCK::NumActiveWaits, _RTLP_WAIT_THREAD_CONTROL_BLOCK::NumWaits, _RTLP_GENERIC_TIMER::Period, PRTLP_TIMER, _RTLP_GENERIC_TIMER::Queue, _RTLP_WAIT::RefCount, _RTLP_GENERIC_TIMER::RefCountPtr, RtlpDeleteWait(), RtlpGetTimeRemaining(), RtlpInsertInDeltaList(), RtlpResetTimer(), _RTLP_GENERIC_TIMER::State, _RTLP_WAIT::State, STATE_ACTIVE, STATE_DELETE, STATE_REGISTERED, _RTLP_WAIT::ThreadCB, _RTLP_WAIT::Timeout, _RTLP_WAIT::Timer, _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerHandle, _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerQueue, _RTLP_GENERIC_TIMER::Wait, and _RTLP_WAIT::WaitHandle. Referenced by RtlRegisterWait(). : This routine is used for adding waits to the wait thread. It is executed in an APC. Arguments: Wait - The wait to add Return Value: --*/ { PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB = Wait->ThreadCB; // if the state is deleted, it implies that RtlDeregister was called in a // WaitThreadCallback for a Wait other than that which was fired. This is // an application bug. I Assert, but also handle it. if ( Wait->State & STATE_DELETE ) { ASSERT(FALSE) ; InterlockedDecrement( &ThreadCB->NumWaits ) ; RtlpDeleteWait (Wait) ; return ; } // activate Wait ThreadCB->ActiveWaitArray [ThreadCB->NumActiveWaits] = Wait->WaitHandle ; ThreadCB->ActiveWaitPointers[ThreadCB->NumActiveWaits] = Wait ; ThreadCB->NumActiveWaits ++ ; Wait->State |= (STATE_REGISTERED | STATE_ACTIVE) ; Wait->RefCount = 1 ; // Fill in the wait timer if (Wait->Timeout != INFINITE_TIME) { ULONG TimeRemaining ; ULONG NewFiringTime ; // Initialize timer related fields and insert the timer in the timer queue for // this wait thread Wait->Timer = (PRTLP_TIMER) RemoveHeadList(&ThreadCB->FreeTimerBlocks); Wait->Timer->Function = Wait->Function ; Wait->Timer->Context = Wait->Context ; Wait->Timer->Flags = Wait->Flags ; Wait->Timer->DeltaFiringTime = Wait->Timeout ; Wait->Timer->Period = ( Wait->Flags & WT_EXECUTEONLYONCE ) ? 0 : Wait->Timeout == INFINITE_TIME ? 0 : Wait->Timeout ; Wait->Timer->State = ( STATE_REGISTERED | STATE_ACTIVE ) ; ; Wait->Timer->Wait = Wait ; Wait->Timer->RefCountPtr = &Wait->RefCount ; Wait->Timer->Queue = &ThreadCB->TimerQueue ; TimeRemaining = RtlpGetTimeRemaining (ThreadCB->TimerHandle) ; if (RtlpInsertInDeltaList (&ThreadCB->TimerQueue.TimerList, Wait->Timer, TimeRemaining, &NewFiringTime)) { // If the element was inserted at head of list then reset the timers RtlpResetTimer (ThreadCB->TimerHandle, NewFiringTime, ThreadCB) ; } } else { // No timer with this wait Wait->Timer = NULL ; } return ; }

VOID RtlpCancelTimer (  PRTLP_TIMER  TimerToCancel  )

Definition at line 4120 of file threads.c. References FALSE, and RtlpCancelTimerEx(). Referenced by RtlDeleteTimer(). : This routine executes in an APC and cancels the specified timer if it exists Arguments: Timer - Specifies pointer to a timer structure that contains Queue and Timer information Return Value: --*/ { RtlpCancelTimerEx( Timer, FALSE ) ; // queue not being deleted }

VOID RtlpCancelTimerEx (  PRTLP_TIMER  Timer, BOOLEAN  DeletingQueue )

Definition at line 4142 of file threads.c. References CHECK_SIGNATURE, PRTLP_TIMER_QUEUE, RtlpDeactivateTimer(), RtlpDeleteTimer(), RtlpResync64BitTickCount(), STATE_ACTIVE, and STATE_DELETE. Referenced by RtlpCancelTimer(), and RtlpDeleteTimerQueue(). : This routine cancels the specified timer. Arguments: Timer - Specifies pointer to a timer structure that contains Queue and Timer information DeletingQueue - FALSE: routine executing in an APC. Delete timer only. TRUE : routine called by timer queue which is being deleted. So dont reset the queue's position Return Value: --*/ { PRTLP_TIMER_QUEUE Queue ; RtlpResync64BitTickCount() ; CHECK_SIGNATURE( Timer ) ; Queue = Timer->Queue ; if ( Timer->State & STATE_ACTIVE ) { // if queue is being deleted, then the timer should not be reset if ( ! DeletingQueue ) RtlpDeactivateTimer( Queue, Timer ) ; } else { // remove one shot Inactive timer from Queue->UncancelledTimerList // called only when the time queue is being deleted RemoveEntryList( &Timer->List ) ; } // Set the State to deleted Timer->State |= STATE_DELETE ; // delete timer if refcount == 0 if ( InterlockedDecrement( &Timer->RefCount ) == 0 ) { RtlpDeleteTimer( Timer ) ; } }

VOID RtlpDeactivateTimer (  PRTLP_TIMER_QUEUE  Queue, PRTLP_TIMER  Timer )

Definition at line 4202 of file threads.c. References NULL, RtlpGetQueueRelativeTime(), RtlpGetTimeRemaining(), RtlpRemoveFromDeltaList(), RtlpReOrderDeltaList(), RtlpResetTimer(), TimerHandle, and TimerQueues. Referenced by RtlpCancelTimerEx(). : This routine executes in an APC and cancels the specified timer if it exists Arguments: Timer - Specifies pointer to a timer structure that contains Queue and Timer information Return Value: --*/ { ULONG TimeRemaining, QueueRelTimeRemaining ; ULONG NewFiringTime ; // Remove the timer from the appropriate queue TimeRemaining = RtlpGetTimeRemaining (TimerHandle) ; QueueRelTimeRemaining = TimeRemaining + RtlpGetQueueRelativeTime (Queue) ; if (RtlpRemoveFromDeltaList (&Queue->TimerList, Timer, QueueRelTimeRemaining, &NewFiringTime)) { // If we removed the last timer from the queue then we should remove the queue // from TimerQueues, else we should readjust its position based on the delta time change if (IsListEmpty (&Queue->TimerList)) { // Remove the queue from TimerQueues if (RtlpRemoveFromDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime)) { // There is a new element at the head of the queue we need to reset the NT // timer to fire later RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; } InitializeListHead (&Queue->List) ; } else { // If we remove from the head of the timer delta list we will need to // make sure the queue delta list is readjusted if (RtlpReOrderDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime, NewFiringTime)) { // There is a new element at the head of the queue we need to reset the NT // timer to fire later RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; } } } }

NTSTATUS RtlpDeactivateWait (  PRTLP_WAIT  Wait  )

Definition at line 3483 of file threads.c. References _RTLP_WAIT_THREAD_CONTROL_BLOCK::ActiveWaitPointers, ASSERT, FALSE, _RTLP_WAIT_THREAD_CONTROL_BLOCK::FreeTimerBlocks, _RTLP_GENERIC_TIMER::List, NULL, _RTLP_WAIT_THREAD_CONTROL_BLOCK::NumActiveWaits, _RTLP_WAIT_THREAD_CONTROL_BLOCK::NumWaits, RtlpGetTimeRemaining(), RtlpRemoveFromDeltaList(), RtlpResetTimer(), RtlpShiftWaitArray, _RTLP_WAIT::State, _RTLP_GENERIC_TIMER::State, STATE_ACTIVE, _RTLP_WAIT::ThreadCB, _RTLP_WAIT::Timer, _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerHandle, and _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerQueue. Referenced by RtlpDeregisterWait(), RtlpFireTimersAndReorder(), and RtlpProcessWaitCompletion(). : This routine is used for deactivating the specified wait. It is executed in a APC. Arguments: Wait - The wait to deactivate Return Value: --*/ { PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB = Wait->ThreadCB ; ULONG ArrayIndex ; //Index in ActiveWaitArray where the Wait object is placed ULONG EndIndex = ThreadCB->NumActiveWaits -1; // get the index in ActiveWaitArray for (ArrayIndex = 0; ArrayIndex <= EndIndex; ArrayIndex++) { if (ThreadCB->ActiveWaitPointers[ArrayIndex] == Wait) break ; } if ( ArrayIndex > EndIndex ) { ASSERT (FALSE) ; return STATUS_NOT_FOUND; } // Move the remaining ActiveWaitArray left. RtlpShiftWaitArray( ThreadCB, ArrayIndex+1, ArrayIndex, EndIndex - ArrayIndex ) ; // // delete timer if associated with this wait // // Though timer is being "freed" here, if it is in the timersToBeFired // list, some of its fields will be used later // if ( Wait->Timer ) { ULONG TimeRemaining ; ULONG NewFiringTime ; if (! (Wait->Timer->State & STATE_ACTIVE) ) { RemoveEntryList( &Wait->Timer->List ) ; } else { TimeRemaining = RtlpGetTimeRemaining (ThreadCB->TimerHandle) ; if (RtlpRemoveFromDeltaList (&ThreadCB->TimerQueue.TimerList, Wait->Timer, TimeRemaining, &NewFiringTime)) { RtlpResetTimer (ThreadCB->TimerHandle, NewFiringTime, ThreadCB) ; } } InsertTailList (&ThreadCB->FreeTimerBlocks, &Wait->Timer->List) ; Wait->Timer = NULL ; } // Decrement the (active) wait count ThreadCB->NumActiveWaits-- ; InterlockedDecrement( &ThreadCB->NumWaits ) ; Wait->State &= ~STATE_ACTIVE ; return STATUS_SUCCESS; }

VOID RtlpDeleteTimer (  PRTLP_TIMER  Timer  )

Definition at line 4271 of file threads.c. References CHECK_SIGNATURE, CLEAR_SIGNATURE, DbgPrint, DPRN1, NtSetEvent(), NULL, PRTLP_TIMER_QUEUE, RtlpDeleteTimerQueueComplete(), and RtlpFreeTPHeap. Referenced by RtlpAddTimer(), RtlpAsyncCallbackCompletion(), and RtlpCancelTimerEx(). : This routine executes in worker or timer thread and deletes the timer whose RefCount == 0. The function can be called outside timer thread, so no structure outside Timer can be touched (no list etc). Arguments: Timer - Specifies pointer to a timer structure that contains Queue and Timer information Return Value: --*/ { PRTLP_TIMER_QUEUE Queue = Timer->Queue ; CHECK_SIGNATURE( Timer ) ; CLEAR_SIGNATURE( Timer ) ; #if DBG1 if (DPRN1) DbgPrint("<%d> Timer: %x: deleted\n\n", Timer->Queue->DbgId, (ULONG_PTR)Timer) ; #endif // safe to call this. Either the timer is in the TimersToFireList and // the function is being called in time context or else it is not in the // list RemoveEntryList( &Timer->TimersToFireList ) ; if ( Timer->CompletionEvent ) NtSetEvent( Timer->CompletionEvent, NULL ) ; // decrement the total number of timers in the queue if ( InterlockedDecrement( &Queue->RefCount ) == 0 ) RtlpDeleteTimerQueueComplete( Queue ) ; RtlpFreeTPHeap( Timer ) ; }

NTSTATUS RtlpDeleteTimerQueue (  PRTLP_TIMER_QUEUE  Queue  )

Definition at line 5354 of file threads.c. References List, NULL, PRTLP_TIMER, RTLP_TIMER, RtlpCancelTimerEx(), RtlpDeleteTimerQueueComplete(), RtlpGetQueueRelativeTime(), RtlpGetTimeRemaining(), RtlpRemoveFromDeltaList(), RtlpResetTimer(), RtlpResync64BitTickCount(), SET_DEL_TIMERQ_SIGNATURE, TimerHandle, TimerQueues, and TRUE. Referenced by RtlDeleteTimerQueueEx(). : This routine deletes the queue specified in the Request and frees all timers Arguments: Queue - queue to delete Event - Event Handle used for signalling completion of request Return Value: --*/ { ULONG TimeRemaining ; ULONG NewFiringTime ; PLIST_ENTRY Node ; PRTLP_TIMER Timer ; RtlpResync64BitTickCount() ; SET_DEL_TIMERQ_SIGNATURE( Queue ) ; // If there are no timers in the queue then it is not attached to TimerQueues // In this case simply free the memory and return. Otherwise we have to first // remove the queue from the TimerQueues List, update the firing time if this // was the first queue in the list and then walk all the timers and free them // before freeing the Timer Queue. if (!IsListEmpty (&Queue->List)) { TimeRemaining = RtlpGetTimeRemaining (TimerHandle) + RtlpGetQueueRelativeTime (Queue) ; if (RtlpRemoveFromDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime)) { // If removed from head of queue list, reset the timer RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; } // Free all the timers associated with this queue for (Node = Queue->TimerList.Flink ; Node != &Queue->TimerList ; ) { Timer = CONTAINING_RECORD (Node, RTLP_TIMER, List) ; Node = Node->Flink ; RtlpCancelTimerEx( Timer ,TRUE ) ; // Queue being deleted } } // Free all the uncancelled one shot timers in this queue for (Node = Queue->UncancelledTimerList.Flink ; Node != &Queue->UncancelledTimerList ; ) { Timer = CONTAINING_RECORD (Node, RTLP_TIMER, List) ; Node = Node->Flink ; RtlpCancelTimerEx( Timer ,TRUE ) ; // Queue being deleted } // delete the queue completely if the RefCount is 0 if ( InterlockedDecrement( &Queue->RefCount ) == 0 ) { RtlpDeleteTimerQueueComplete( Queue ) ; return STATUS_SUCCESS ; } else { return STATUS_PENDING ; } }

VOID RtlpDeleteTimerQueueComplete (  PRTLP_TIMER_QUEUE  Queue  )

Definition at line 5462 of file threads.c. References DbgPrint, DPRN1, NtSetEvent(), NULL, NumTimerQueues, and RtlpFreeTPHeap. Referenced by RtlpDeleteTimer(), and RtlpDeleteTimerQueue(). { #if DBG1 if (DPRN1) DbgPrint("<%d> Queue: %x: deleted\n\n", Queue->DbgId, (ULONG_PTR)Queue) ; #endif InterlockedDecrement( &NumTimerQueues ) ; // Notify the thread issuing the cancel that the request is completed if ( Queue->CompletionEvent ) NtSetEvent (Queue->CompletionEvent, NULL) ; RtlpFreeTPHeap( Queue ) ; }

VOID RtlpDeleteWait (  PRTLP_WAIT  Wait  )

Definition at line 3573 of file threads.c. References CHECK_SIGNATURE, CLEAR_SIGNATURE, _RTLP_WAIT::DbgId, DbgPrint, DPRN1, NtSetEvent(), NULL, and RtlpFreeTPHeap. Referenced by RtlpAddWait(), RtlpAsyncCallbackCompletion(), RtlpDeregisterWait(), and RtlpProcessWaitCompletion(). : This routine is used for deleting the specified wait. It can be executed outside the context of the wait thread. So structure except the WaitEntry can be changed. It also sets the event. Arguments: Wait - The wait to delete Return Value: --*/ { CHECK_SIGNATURE( Wait ) ; CLEAR_SIGNATURE( Wait ) ; #if DBG1 if (DPRN1) DbgPrint("<%d> Wait %x deleted in thread:%d\n\n", Wait->DbgId, (ULONG_PTR)Wait, HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread)) ; #endif if ( Wait->CompletionEvent ) { NtSetEvent( Wait->CompletionEvent, NULL ) ; } RtlpFreeTPHeap( Wait) ; return ; }

VOID RtlpDeleteWaitAPC (  PRTLP_WAIT_THREAD_CONTROL_BLOCK  ThreadCB, PRTLP_WAIT  Wait, HANDLE  Handle )

NTSTATUS RtlpDeregisterWait (  PRTLP_WAIT  Wait, HANDLE  PartialCompletionEvent, PULONG  StatusPtr )

Definition at line 3397 of file threads.c. References CHECK_SIGNATURE, NT_SUCCESS, NtSetEvent(), NULL, _RTLP_WAIT::RefCount, RtlpDeactivateWait(), RtlpDeleteWait(), _RTLP_WAIT::State, STATE_ACTIVE, STATE_DELETE, STATE_REGISTERED, and Status. Referenced by RtlDeregisterWaitEx(). : This routine is used for deregistering the specified wait. Arguments: Wait - The wait to deregister Return Value: --*/ { ULONG Status = STATUS_SUCCESS ; ULONG DontUse ; PULONG RetStatus = RetStatusPtr ? RetStatusPtr : &DontUse; CHECK_SIGNATURE(Wait) ; // RtlpDeregisterWait can be called on a wait that has not yet been // registered. This indicates that someone calls a RtlDeregisterWait // inside a WaitThreadCallback for a Wait other than that was fired. // Application bug!! I assert but handle it if ( ! (Wait->State & STATE_REGISTERED) ) { // set state to deleted, so that it does not get registered Wait->State |= STATE_DELETE ; InterlockedDecrement( &Wait->RefCount ) ; if ( PartialCompletionEvent ) { NtSetEvent( PartialCompletionEvent, NULL ) ; } *RetStatus = STATUS_SUCCESS ; return STATUS_SUCCESS ; } // deactivate wait. if ( Wait->State & STATE_ACTIVE ) { if ( ! NT_SUCCESS( RtlpDeactivateWait ( Wait ) ) ) { *RetStatus = STATUS_NOT_FOUND ; return STATUS_NOT_FOUND ; } } // delete wait if RefCount == 0 Wait->State |= STATE_DELETE ; if ( InterlockedDecrement (&Wait->RefCount) == 0 ) { RtlpDeleteWait ( Wait ) ; Status = *RetStatus = STATUS_SUCCESS ; } else { Status = *RetStatus = STATUS_PENDING ; } if ( PartialCompletionEvent ) { NtSetEvent( PartialCompletionEvent, NULL ) ; } return Status ; }

VOID RtlpDoNothing (  PVOID  NotUsed1, PVOID  NotUsed2, PVOID  NotUsed3 )

Definition at line 3617 of file threads.c. Referenced by RtlpWaitForEvent(). : This routine is used to see if the thread is alive Arguments: NotUsed1, NotUsed2 and NotUsed 3 - not used Return Value: None --*/ { }

BOOLEAN RtlpDoWeNeedNewWorkerThread (  ULONG  ThreadType  )

VOID RtlpExecuteIOWorkItem (  PVOID  Function, PVOID  Context, PVOID  NotUsed )

Definition at line 2632 of file threads.c. References ASSERT, DBG_SET_FUNCTION, EXCEPTION_EXECUTE_HANDLER, FALSE, and NumIOWorkRequests. Referenced by RtlpQueueIOWorkerRequest(). : Executes an IO Work function. RUNs in a APC in the IO Worker thread. Arguments: Function - Worker function to call Context - Argument for the worker function. NotUsed - Argument is not used in this function. Return Value: --*/ { #if (DBG1) DBG_SET_FUNCTION( Function, Context ) ; #endif // Invoke the function try { ((WORKERCALLBACKFUNC) Function)((PVOID)Context) ; } except (EXCEPTION_EXECUTE_HANDLER) { ASSERT(FALSE); } // Decrement pending IO requests count InterlockedDecrement (&NumIOWorkRequests) ; }

VOID RtlpExecuteLongIOWorkItem (  PVOID  Function, PVOID  Context, PVOID  NotUsed )

Definition at line 2583 of file threads.c. References ASSERT, DBG_SET_FUNCTION, EXCEPTION_EXECUTE_HANDLER, FALSE, NumIOWorkRequests, and NumLongIOWorkRequests. : Executes an IO Work function. RUNs in a APC in the IO Worker thread. Arguments: Function - Worker function to call Context - Argument for the worker function. NotUsed - Argument is not used in this function. Return Value: --*/ { #if (DBG1) DBG_SET_FUNCTION( Function, Context ) ; #endif // Invoke the function try { ((WORKERCALLBACKFUNC) Function)((PVOID)Context) ; } except (EXCEPTION_EXECUTE_HANDLER) { ASSERT(FALSE); } ((PRTLP_IOWORKER_TCB)ThreadCB)->LongFunctionFlag = FALSE ; // Decrement pending IO requests count InterlockedDecrement (&NumIOWorkRequests) ; // decrement pending long funcitons InterlockedDecrement (&NumLongIOWorkRequests ) ; }

VOID RtlpExecuteWorkerRequest (  NTSTATUS  Status, PVOID  Context, PVOID  ActualFunction )

Definition at line 1589 of file threads.c. References DBG_SET_FUNCTION, EXCEPTION_EXECUTE_HANDLER, _RTLP_WORK::Flags, _RTLP_WORK::Function, NumLongWorkRequests, NumWorkRequests, and RtlpFreeTPHeap. Referenced by RtlpQueueWorkerRequest(). : This routine executes a work item. Arguments: Context - contains context to be passed to the callback function. WorkContext - contains callback function ptr and flags Return Value: Notes: This function executes in a worker thread or a timer thread if WT_EXECUTEINTIMERTHREAD flag is set. --*/ { PRTLP_WORK WorkEntry = (PRTLP_WORK) WorkContext; #if (DBG1) DBG_SET_FUNCTION( WorkEntry->Function, Context ) ; #endif try { ((WORKERCALLBACKFUNC) WorkEntry->Function) ( Context ) ; } except (EXCEPTION_EXECUTE_HANDLER) { // ASSERT(FALSE); } InterlockedDecrement( &NumWorkRequests ) ; if (WorkEntry->Flags & WT_EXECUTELONGFUNCTION) { InterlockedDecrement( &NumLongWorkRequests ) ; } RtlpFreeTPHeap( WorkEntry ) ; }

NTSTATUS RtlpFindWaitThread (  PRTLP_WAIT_THREAD_CONTROL_BLOCK *  ThreadCB  )

Definition at line 3851 of file threads.c. References ACQUIRE_GLOBAL_WAIT_LOCK, DbgPrint, NtClose(), NTSTATUS(), RELEASE_GLOBAL_WAIT_LOCK, RtlpStartThreadFunc, RtlpWaitThread(), Status, ThreadHandle, TRUE, and WaitThreads. Referenced by RtlRegisterWait(). : Walks thru the list of wait threads and finds one which can accomodate another wait. If one is not found then a new thread is created. This routine assumes that the caller has the GlobalWaitLock. Arguments: ThreadCB: returns the ThreadCB of the wait thread that will service the wait request. Return Value: STATUS_SUCCESS if a wait thread was allocated, --*/ { NTSTATUS Status = STATUS_SUCCESS; PLIST_ENTRY Node ; HANDLE ThreadHandle ; PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCBTmp; ACQUIRE_GLOBAL_WAIT_LOCK() ; do { // Walk thru the list of Wait Threads and find a Wait thread that can accomodate a // new wait request. // *Consider* finding a wait thread with least # of waits to facilitate better // load balancing of waits. for (Node = WaitThreads.Flink ; Node != &WaitThreads ; Node = Node->Flink) { ThreadCBTmp = CONTAINING_RECORD (Node, RTLP_WAIT_THREAD_CONTROL_BLOCK, WaitThreadsList) ; // Wait Threads can accomodate upto 64 waits (NtWaitForMultipleObject limit) if ((ThreadCBTmp)->NumWaits < 64) { // Found a thread with some wait slots available. InterlockedIncrement ( &(ThreadCBTmp)->NumWaits) ; *ThreadCB = ThreadCBTmp; RELEASE_GLOBAL_WAIT_LOCK() ; return STATUS_SUCCESS ; } } // If we reach here, we dont have any more wait threads. so create a new wait thread. Status = RtlpStartThreadFunc (RtlpWaitThread, &ThreadHandle) ; // If thread creation fails then return the failure to caller if (Status != STATUS_SUCCESS ) { #if DBG DbgPrint("ERROR!! ThreadPool: could not create wait thread\n"); #endif RELEASE_GLOBAL_WAIT_LOCK() ; return Status ; } else { // Close Thread handle, we dont need it. NtClose (ThreadHandle) ; } // Loop back now that we have created another thread } while (TRUE) ; // Loop back to top and put new wait request in the newly created thread RELEASE_GLOBAL_WAIT_LOCK() ; return Status ; }

VOID RtlpFireTimers (  PLIST_ENTRY  TimersToFireList  )

Definition at line 3747 of file threads.c. References DBG_SET_FUNCTION, DbgPrint, DPRN4, FALSE, NT_SUCCESS, NTSTATUS(), NULL, PRTLP_TIMER, RTLP_TIMER, RtlpAsyncCallbackCompletion(), RtlpForceAllocateTPHeap(), RtlpFreeTPHeap, RtlQueueWorkItem(), STATE_DONTFIRE, Status, _RTLP_WAITWORKER::Timer, _RTLP_WAITWORKER::TimerCondition, TRUE, _RTLP_WAITWORKER::Wait, and _RTLP_WAITWORKER::WaitThreadCallback. Referenced by RtlpProcessTimeouts(), and RtlpServiceTimer(). : Finally all the timers are fired here. Arguments: TimersToFireList: List of timers to fire --*/ { PLIST_ENTRY Node ; PRTLP_TIMER Timer ; NTSTATUS Status; for (Node = TimersToFireList->Flink; Node != TimersToFireList; Node = TimersToFireList->Flink) { Timer = CONTAINING_RECORD (Node, RTLP_TIMER, TimersToFireList) ; RemoveEntryList( Node ) ; InitializeListHead( Node ) ; if ( (Timer->State & STATE_DONTFIRE) || (Timer->Queue->State & STATE_DONTFIRE) ) { ; } else if ( Timer->Flags & (WT_EXECUTEINTIMERTHREAD | WT_EXECUTEINWAITTHREAD ) ) { //DPRN5 if (DPRN4) DbgPrint("Calling WaitOrTimer(Timer): fn:%x context:%x bool:%d Thread<%d:%d>\n", (ULONG_PTR)Timer->Function, (ULONG_PTR)Timer->Context, TRUE, HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread), HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess) ) ; #if (DBG1) DBG_SET_FUNCTION( Timer->Function, Timer->Context ) ; #endif ((WAITORTIMERCALLBACKFUNC) Timer->Function) (Timer->Context, TRUE) ; } else { // create context for Callback and queue it appropriately PRTLP_ASYNC_CALLBACK AsyncCallback ; AsyncCallback = RtlpForceAllocateTPHeap( sizeof( RTLP_ASYNC_CALLBACK ), 0 ); AsyncCallback->TimerCondition = TRUE ; // timer associated with WaitEvents should be treated differently if ( Timer->Wait != NULL ) { AsyncCallback->Wait = Timer->Wait ; AsyncCallback->WaitThreadCallback = TRUE ; InterlockedIncrement( Timer->RefCountPtr ) ; } else { AsyncCallback->Timer = Timer ; AsyncCallback->WaitThreadCallback = FALSE ; InterlockedIncrement( &Timer->RefCount ) ; } // queue work item Status = RtlQueueWorkItem( RtlpAsyncCallbackCompletion, AsyncCallback, Timer->Flags ); if (!NT_SUCCESS(Status)) { RtlpFreeTPHeap( AsyncCallback ); if ( Timer->Wait != NULL ) { InterlockedDecrement( Timer->RefCountPtr ) ; } else { InterlockedDecrement( &Timer->RefCount ) ; } } } } }

VOID RtlpFireTimersAndReorder (  PRTLP_TIMER_QUEUE  Queue, ULONG *  NewFiringTime, PLIST_ENTRY  TimersToFireList )

Definition at line 5010 of file threads.c. References INFINITE_TIME, List, PRTLP_TIMER, RTLP_TIMER, RtlpDeactivateWait(), RtlpInsertInDeltaList(), STATE_ACTIVE, STATE_DONTFIRE, and STATE_ONE_SHOT_FIRED. Referenced by RtlpProcessTimeouts(), and RtlpServiceTimer(). : Fires all timers in TimerList that have DeltaFiringTime == 0. After firing the timers it reorders the timers based on their periodic times OR frees the fired one shot timers. Arguments: TimerList - Timer list to work thru. NewFiringTime - Location where the new firing time for the first timer in the delta list is returned. Return Value: --*/ { PLIST_ENTRY TNode ; PRTLP_TIMER Timer ; LIST_ENTRY ReinsertTimerList ; PLIST_ENTRY TimerList = &Queue->TimerList ; InitializeListHead (&ReinsertTimerList) ; *NewFiringTime = 0 ; for (TNode = TimerList->Flink ; (TNode != TimerList) && (*NewFiringTime == 0); TNode = TimerList->Flink) { Timer = CONTAINING_RECORD (TNode, RTLP_TIMER, List) ; // Fire all timers with delta time of 0 if (Timer->DeltaFiringTime == 0) { // detach this timer from the list RemoveEntryList (TNode) ; // get next firing time if (!IsListEmpty(TimerList)) { PRTLP_TIMER TmpTimer ; TmpTimer = CONTAINING_RECORD (TimerList->Flink, RTLP_TIMER, List) ; *NewFiringTime = TmpTimer->DeltaFiringTime ; TmpTimer->DeltaFiringTime = 0 ; } else { *NewFiringTime = INFINITE_TIME ; } // if timer is not periodic then remove active state. Timer will be deleted // when cancel timer is called. if (Timer->Period == 0) { InsertHeadList( &Queue->UncancelledTimerList, &Timer->List ) ; // if one shot wait was timed out then, deactivate the wait if ( Timer->Wait ) { // // though timer is being "freed" in this call, it can still be // used after this call // RtlpDeactivateWait( Timer->Wait ) ; } else { // should be set at the end Timer->State &= ~STATE_ACTIVE ; } Timer->State |= STATE_ONE_SHOT_FIRED ; } else { // Set the DeltaFiringTime to be the next period Timer->DeltaFiringTime = Timer->Period ; // reinsert the timer in the list. RtlpInsertInDeltaList (TimerList, Timer, *NewFiringTime, NewFiringTime) ; } // Call the function associated with this timer. call it in the end // so that RtlTimer calls can be made in the timer function if ( (Timer->State & STATE_DONTFIRE) || (Timer->Queue->State & STATE_DONTFIRE) ) { ; } else { InsertTailList( TimersToFireList, &Timer->TimersToFireList ) ; } } else { // No more Timers with DeltaFiringTime == 0 break ; } } if ( *NewFiringTime == 0 ) { *NewFiringTime = INFINITE_TIME ; } }

PVOID RtlpForceAllocateTPHeap (  ULONG  dwSize, ULONG  dwFlags )

Definition at line 5847 of file threads.c. References dwFlags, FALSE, NtDelayExecution(), ONE_SECOND_TIMEOUT, RtlpAllocateTPHeap, and TRUE. Referenced by RtlpFireTimers(), RtlpGetWaitEvent(), RtlpProcessWaitCompletion(), and RtlpQueueWorkerRequest(). : This routine goes into an infinite loop trying to allocate the memory. Arguments: dwSize - size of memory to be allocated dwFlags - Flags for memory allocation Return Value: ptr to memory --*/ { PVOID ptr; ptr = RtlpAllocateTPHeap(dwSize, dwFlags); if (ptr) return ptr; { LARGE_INTEGER TimeOut ; do { ONE_SECOND_TIMEOUT(TimeOut) ; NtDelayExecution (FALSE, &TimeOut) ; ptr = RtlpAllocateTPHeap(dwSize, dwFlags); if (ptr) break; } while (TRUE) ; } return ptr; }

VOID RtlpFreeWaitEvent (  PRTLP_EVENT  Event  )

Definition at line 5648 of file threads.c. References Event(), EventCache, EventCacheCriticalSection, MAX_UNUSED_EVENTS, NtClose(), NULL, NumUnusedEvents, and RtlpFreeTPHeap. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), and RtlDeregisterWaitEx(). : Frees the event to the event cache Arguments: Event - the event struct to put back into the cache Return Value: Nothing --*/ { if ( Event == NULL ) return ; InitializeListHead (&Event->List) ; RtlEnterCriticalSection (&EventCacheCriticalSection) ; if ( NumUnusedEvents > MAX_UNUSED_EVENTS ) { NtClose( Event->Handle ) ; RtlpFreeTPHeap( Event ) ; } else { InsertHeadList (&EventCache, &Event->List) ; NumUnusedEvents++ ; } RtlLeaveCriticalSection (&EventCacheCriticalSection) ; }

ULONG RtlpGetQueueRelativeTime (  PRTLP_TIMER_QUEUE  Queue  )

Definition at line 4326 of file threads.c. References List, PRTLP_TIMER_QUEUE, RTLP_TIMER_QUEUE, and TimerQueues. Referenced by RtlpAddTimer(), RtlpDeactivateTimer(), RtlpDeleteTimerQueue(), and RtlpUpdateTimer(). : Walks the list of queues and returns the relative firing time by adding all the DeltaFiringTimes for all queues before it. Arguments: Queue - Queue for which to find the relative firing time Return Value: Time in milliseconds --*/ { PLIST_ENTRY Node ; ULONG RelativeTime ; PRTLP_TIMER_QUEUE CurrentQueue ; RelativeTime = 0 ; // It the Queue is not attached to TimerQueues List because it has no timer // associated with it simply returns 0 as the relative time. Else run thru // all queues before it in the list and compute the relative firing time if (!IsListEmpty (&Queue->List)) { for (Node = TimerQueues.Flink; Node != &Queue->List; Node=Node->Flink) { CurrentQueue = CONTAINING_RECORD (Node, RTLP_TIMER_QUEUE, List) ; RelativeTime += CurrentQueue->DeltaFiringTime ; } // Add the queue's delta firing time as well RelativeTime += Queue->DeltaFiringTime ; } return RelativeTime ; }

ULONG RtlpGetTimeRemaining (  HANDLE  TimerHandle  )

Definition at line 4378 of file threads.c. References ASSERT, NtQueryTimer(), NTSTATUS(), Status, and TimerHandle. Referenced by RtlDebugPrintTimes(), RtlpAddTimer(), RtlpAddWait(), RtlpDeactivateTimer(), RtlpDeactivateWait(), RtlpDeleteTimerQueue(), RtlpProcessTimeouts(), RtlpProcessWaitCompletion(), RtlpServiceTimer(), and RtlpUpdateTimer(). : Gets the time remaining on the specified NT timer Arguments: TimerHandle - Handle to the NT timer Return Value: Time remaining on the timer --*/ { ULONG InfoLen ; TIMER_BASIC_INFORMATION Info ; NTSTATUS Status ; Status = NtQueryTimer (TimerHandle, TimerBasicInformation, &Info, sizeof(Info), &InfoLen) ; ASSERT (Status == STATUS_SUCCESS) ; // Return 0 if // // - the timer has already fired then return // OR // - the timer is has more than 0x7f0000000 in its high part // (which indicates that the timer was (probably) programmed for -1) if (Info.TimerState || ((ULONG)Info.RemainingTime.HighPart > 0x7f000000) ) { return 0 ; } else { return (ULONG) (Info.RemainingTime.QuadPart / 10000) ; } }

PRTLP_EVENT RtlpGetWaitEvent (  VOID   )

Definition at line 5575 of file threads.c. References CompletedEventCacheInitialization, Event(), EventCache, EventCacheCriticalSection, FALSE, NT_SUCCESS, NtCreateEvent(), NTSTATUS(), NULL, RTLP_EVENT, RtlpForceAllocateTPHeap(), RtlpFreeTPHeap, RtlpInitializeEventCache(), and Status. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), and RtlDeregisterWaitEx(). : Returns an event from the event cache. Arguments: None Return Value: Pointer to event structure --*/ { NTSTATUS Status; PRTLP_EVENT Event ; if (!CompletedEventCacheInitialization) { RtlpInitializeEventCache () ; } RtlEnterCriticalSection (&EventCacheCriticalSection) ; if (!IsListEmpty (&EventCache)) { Event = (PRTLP_EVENT) RemoveHeadList (&EventCache) ; } else { Event = RtlpForceAllocateTPHeap( sizeof( RTLP_EVENT ), 0 ); if (!Event) { RtlLeaveCriticalSection (&EventCacheCriticalSection) ; return NULL ; } Status = NtCreateEvent( &Event->Handle, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if (!NT_SUCCESS(Status) ) { RtlpFreeTPHeap( Event ) ; RtlLeaveCriticalSection (&EventCacheCriticalSection) ; return NULL ; } } RtlLeaveCriticalSection (&EventCacheCriticalSection) ; return Event ; }

VOID RtlpInitializeEventCache (  VOID   )

Definition at line 5694 of file threads.c. References ASSERT, CompletedEventCacheInitialization, EventCache, EventCacheCriticalSection, FALSE, L, NtDelayExecution(), NTSTATUS(), NumUnusedEvents, ONE_MILLISECOND_TIMEOUT, RtlInitializeCriticalSection(), StartedEventCacheInitialization, and Status. Referenced by RtlpGetWaitEvent(). : Initializes the event cache Arguments: None Return Value: Nothing --*/ { NTSTATUS Status; LARGE_INTEGER TimeOut ; if (!InterlockedExchange(&StartedEventCacheInitialization, 1L)) { InitializeListHead (&EventCache) ; Status = RtlInitializeCriticalSection(&EventCacheCriticalSection) ; ASSERT (Status == STATUS_SUCCESS) ; NumUnusedEvents = 0 ; InterlockedExchange (&CompletedEventCacheInitialization, 1L) ; } else { // sleep for 1 milliseconds and see if the initialization is complete ONE_MILLISECOND_TIMEOUT(TimeOut) ; while (!(volatile ULONG) CompletedEventCacheInitialization) { NtDelayExecution (FALSE, &TimeOut) ; } } }

NTSTATUS RtlpInitializeTimerThreadPool (   )

Definition at line 5256 of file threads.c. References ASSERT, CompletedTimerInitialization, FALSE, Firing64BitTickCount, L, NT_SUCCESS, NtCreateTimer(), NtDelayExecution(), NtGetTickCount(), NTSTATUS(), NULL, ONE_MILLISECOND_TIMEOUT, Resync64BitTickCount, RtlInitializeCriticalSection(), RtlpStartThreadFunc, RtlpTimerThread(), StartedTimerInitialization, Status, TimerCriticalSection, TimerHandle, TimerQueues, and TimerThreadHandle. Referenced by RtlCreateTimerQueue(), and RtlpInitializeWorkerThreadPool(). : This routine is used to initialize structures used for Timer Thread Arguments: Return Value: --*/ { NTSTATUS Status = STATUS_SUCCESS; LARGE_INTEGER TimeOut ; // In order to avoid an explicit RtlInitialize() function to initialize the wait thread pool // we use StartedTimerInitialization and CompletedTimerInitialization to provide us the // necessary synchronization to avoid multiple threads from initializing the thread pool. // This scheme does not work if RtlInitializeCriticalSection() or NtCreateEvent fails - but in this case the // caller has not choices left. if (!InterlockedExchange(&StartedTimerInitialization, 1L)) { if (CompletedTimerInitialization) InterlockedExchange(&CompletedTimerInitialization, 0 ) ; do { // Initialize global timer lock Status = RtlInitializeCriticalSection( &TimerCriticalSection ) ; if (! NT_SUCCESS( Status )) { break ; } Status = NtCreateTimer( &TimerHandle, TIMER_ALL_ACCESS, NULL, NotificationTimer ) ; if (!NT_SUCCESS(Status) ) break ; InitializeListHead (&TimerQueues) ; // Initialize Timer Queue Structures // initialize tick count Resync64BitTickCount.QuadPart = NtGetTickCount() ; Firing64BitTickCount.QuadPart = 0 ; Status = RtlpStartThreadFunc (RtlpTimerThread, &TimerThreadHandle) ; if (!NT_SUCCESS(Status) ) break ; } while(FALSE ) ; if (!NT_SUCCESS(Status) ) { ASSERT (Status == STATUS_SUCCESS) ; StartedTimerInitialization = 0 ; InterlockedExchange (&CompletedTimerInitialization, ~0) ; return Status ; } InterlockedExchange (&CompletedTimerInitialization, 1L) ; } else { // Sleep 1 ms and see if the other thread has completed initialization ONE_MILLISECOND_TIMEOUT(TimeOut) ; while (!(volatile ULONG) CompletedTimerInitialization) { NtDelayExecution (FALSE, &TimeOut) ; } if (CompletedTimerInitialization != 1) Status = STATUS_NO_MEMORY ; } return NT_SUCCESS(Status) ? STATUS_SUCCESS : Status ; }

NTSTATUS RtlpInitializeTPHeap (   )

NTSTATUS RtlpInitializeWaitThreadPool (   )

Definition at line 2751 of file threads.c. References ASSERT, CompletedWaitInitialization, FALSE, L, NT_SUCCESS, NtDelayExecution(), NTSTATUS(), ONE_MILLISECOND_TIMEOUT, RtlInitializeCriticalSection(), StartedWaitInitialization, Status, WaitCriticalSection, and WaitThreads. Referenced by RtlRegisterWait(). : This routine initializes all aspects of the thread pool. Arguments: None Return Value: None --*/ { NTSTATUS Status = STATUS_SUCCESS; LARGE_INTEGER TimeOut ; // In order to avoid an explicit RtlInitialize() function to initialize the wait thread pool // we use StartedWaitInitialization and CompletedWait Initialization to provide us the // necessary synchronization to avoid multiple threads from initializing the thread pool. // This scheme does not work if RtlInitializeCriticalSection() or NtCreateEvent fails - but in this case the // caller has not choices left. if (!InterlockedExchange(&StartedWaitInitialization, 1L)) { if (CompletedWaitInitialization) InterlockedExchange (&CompletedWaitInitialization, 0L) ; // Initialize Critical Section Status = RtlInitializeCriticalSection( &WaitCriticalSection ) ; if (! NT_SUCCESS( Status ) ) { ASSERT ( NT_SUCCESS( Status ) ) ; StartedWaitInitialization = 0 ; InterlockedExchange (&CompletedWaitInitialization, ~0) ; return Status ; } InitializeListHead (&WaitThreads); // Initialize global wait threads list InterlockedExchange (&CompletedWaitInitialization, 1L) ; } else { // Sleep 1 ms and see if the other thread has completed initialization ONE_MILLISECOND_TIMEOUT(TimeOut) ; while (!(volatile ULONG) CompletedWaitInitialization) { NtDelayExecution (FALSE, &TimeOut) ; } if (CompletedWaitInitialization != 1) { Status = STATUS_NO_MEMORY ; } } return Status ; }

NTSTATUS RtlpInitializeWorkerThreadPool (   )

Definition at line 1965 of file threads.c. References ASSERT, CompletedTimerInitialization, CompletedWorkerInitialization, FALSE, IOWorkerThreads, L, NT_SUCCESS, NtCreateIoCompletion(), NtDelayExecution(), NtQuerySystemInformation(), NTSTATUS(), NULL, ONE_MILLISECOND_TIMEOUT, RtlInitializeCriticalSection(), RtlpInitializeTimerThreadPool(), RtlpWorkerThreadInitializeTimers(), RtlQueueWorkItem(), StartedWorkerInitialization, Status, WorkerCompletionPort, WorkerCriticalSection, and WorkerThreadTimerQueueInit. Referenced by RtlQueueWorkItem(), and RtlSetIoCompletionCallback(). : This routine initializes all aspects of the thread pool. Arguments: None Return Value: None --*/ { NTSTATUS Status = STATUS_SUCCESS ; LARGE_INTEGER TimeOut ; // Initialize the timer component if it hasnt been done already if (CompletedTimerInitialization != 1) { Status = RtlpInitializeTimerThreadPool () ; if ( !NT_SUCCESS(Status) ) return Status ; } // In order to avoid an explicit RtlInitialize() function to initialize the thread pool // we use StartedInitialization and CompletedInitialization to provide us the necessary // synchronization to avoid multiple threads from initializing the thread pool. // This scheme does not work if RtlInitializeCriticalSection() fails - but in this case the // caller has no choices left. if (!InterlockedExchange(&StartedWorkerInitialization, 1L)) { if (CompletedWorkerInitialization) InterlockedExchange( &CompletedWorkerInitialization, 0 ) ; do { // Initialize Critical Sections Status = RtlInitializeCriticalSection( &WorkerCriticalSection ); if (!NT_SUCCESS(Status)) break ; InitializeListHead (&IOWorkerThreads) ; { SYSTEM_BASIC_INFORMATION BasicInfo; // get number of processors Status = NtQuerySystemInformation ( SystemBasicInformation, &BasicInfo, sizeof(BasicInfo), NULL ) ; if ( !NT_SUCCESS(Status) ) { BasicInfo.NumberOfProcessors = 1 ; } // Create completion port used by worker threads Status = NtCreateIoCompletion ( &WorkerCompletionPort, IO_COMPLETION_ALL_ACCESS, NULL, BasicInfo.NumberOfProcessors ); if (!NT_SUCCESS(Status)) break ; } } while ( FALSE ) ; if (!NT_SUCCESS(Status) ) { ASSERT ( Status == STATUS_SUCCESS ) ; StartedWorkerInitialization = 0 ; InterlockedExchange( &CompletedWorkerInitialization, ~0 ) ; return Status ; } // Signal that initialization has completed InterlockedExchange (&CompletedWorkerInitialization, 1L) ; } else { LARGE_INTEGER Timeout ; // Sleep 1 ms and see if the other thread has completed initialization ONE_MILLISECOND_TIMEOUT(TimeOut) ; while (!(volatile ULONG) CompletedWorkerInitialization) { NtDelayExecution (FALSE, &TimeOut) ; } if (CompletedWorkerInitialization != 1) return STATUS_NO_MEMORY ; } // // create timer for worker thread. it should be created outside any worker // lock and the above wait loop. It should not make the RtlpInitializeWorkerThread // call blocking on a timer thread. so queue a work item. // if (NT_SUCCESS(Status) && (InterlockedIncrement(&WorkerThreadTimerQueueInit) == 1) ) { RtlQueueWorkItem(RtlpWorkerThreadInitializeTimers, NULL, 0); } return NT_SUCCESS(Status) ? STATUS_SUCCESS : Status ; }

BOOLEAN RtlpInsertInDeltaList (  PLIST_ENTRY  DeltaList, PRTLP_GENERIC_TIMER  NewTimer, ULONG  TimeRemaining, ULONG *  NewFiringTime )

Definition at line 4507 of file threads.c. References _RTLP_GENERIC_TIMER::DeltaFiringTime, FALSE, List, _RTLP_GENERIC_TIMER::List, PRTLP_GENERIC_TIMER, RTLP_GENERIC_TIMER, and TRUE. Referenced by RtlpAddTimer(), RtlpAddWait(), RtlpFireTimersAndReorder(), RtlpInsertTimersIntoDeltaList(), and RtlpReOrderDeltaList(). : Inserts the timer element in the appropriate place in the delta list. Arguments: DeltaList - Delta list to insert into NewTimer - Timer element to insert into list TimeRemaining - This time must be added to the head of the list to get "real" relative time. NewFiringTime - If the new element was inserted at the head of the list - this will contain the new firing time in milliseconds. The caller can use this time to re-program the NT timer. This MUST NOT be changed if the function returns FALSE. Return Value: TRUE - If the timer was inserted at head of delta list FALSE - otherwise --*/ { PLIST_ENTRY Node ; PRTLP_GENERIC_TIMER Temp ; PRTLP_GENERIC_TIMER Head ; if (IsListEmpty (DeltaList)) { InsertHeadList (DeltaList, &NewTimer->List) ; *NewFiringTime = NewTimer->DeltaFiringTime ; NewTimer->DeltaFiringTime = 0 ; return TRUE ; } // Adjust the head of the list to reflect the time remaining on the NT timer Head = CONTAINING_RECORD (DeltaList->Flink, RTLP_GENERIC_TIMER, List) ; Head->DeltaFiringTime += TimeRemaining ; // Find the appropriate location to insert this element in for (Node = DeltaList->Flink ; Node != DeltaList ; Node = Node->Flink) { Temp = CONTAINING_RECORD (Node, RTLP_GENERIC_TIMER, List) ; if (Temp->DeltaFiringTime <= NewTimer->DeltaFiringTime) { NewTimer->DeltaFiringTime -= Temp->DeltaFiringTime ; } else { // found appropriate place to insert this timer break ; } } // Either we have found the appopriate node to insert before in terms of deltas. // OR we have come to the end of the list. Insert this timer here. InsertHeadList (Node->Blink, &NewTimer->List) ; // If this isnt the last element in the list - adjust the delta of the // next element if (Node != DeltaList) { Temp->DeltaFiringTime -= NewTimer->DeltaFiringTime ; } // Check if element was inserted at head of list if (DeltaList->Flink == &NewTimer->List) { // Set NewFiringTime to the time in milliseconds when the new head of list // should be serviced. *NewFiringTime = NewTimer->DeltaFiringTime ; // This means the timer must be programmed to service this request NewTimer->DeltaFiringTime = 0 ; return TRUE ; } else { // No change to the head of the list, set the delta time back Head->DeltaFiringTime -= TimeRemaining ; return FALSE ; } }

VOID RtlpInsertTimersIntoDeltaList (  PLIST_ENTRY  NewTimerList, PLIST_ENTRY  DeltaTimerList, ULONG  TimeRemaining, ULONG *  NewFiringTime )

Referenced by RtlpServiceTimer().

LONG RtlpIOWorkerThread (  PVOID  NotUsed  )

Definition at line 2370 of file threads.c. References ASSERT, FALSE, _RTLP_IOWORKER_TCB::Flags, Initialized, IOWORKER_IDLE_TIMEOUT, IOWorkerThreads, L, _RTLP_IOWORKER_TCB::List, _RTLP_IOWORKER_TCB::LongFunctionFlag, NEW_THREAD_THRESHOLD, NT_SUCCESS, NtClose(), NtDelayExecution(), NtDuplicateObject(), NtQueryInformationThread(), NTSTATUS(), NULL, NumIOWorkerThreads, NumIOWorkRequests, NumLongIOWorkRequests, RtlpExitThreadFunc, Status, _RTLP_IOWORKER_TCB::ThreadHandle, TRUE, and WorkerCriticalSection. Referenced by RtlpStartIOWorkerThread(). : All I/O worker threads execute in this routine. All the work requests execute as APCs in this thread. Arguments: Initialized - set to 1 when the initialization has completed Return Value: --*/ { #define IOWORKER_IDLE_TIMEOUT 40000 // In Milliseconds LARGE_INTEGER TimeOut ; ULONG SleepTime = IOWORKER_IDLE_TIMEOUT ; RTLP_IOWORKER_TCB ThreadCB ; // Control Block allocated on the stack NTSTATUS Status ; BOOLEAN Terminate ; // // Initialize thread control block // and insert it into list of IOWorker Threads // Status = NtDuplicateObject( NtCurrentProcess(), NtCurrentThread(), NtCurrentProcess(), &ThreadCB.ThreadHandle, 0, FALSE, DUPLICATE_SAME_ACCESS ) ; if (!NT_SUCCESS(Status)) { ASSERT (FALSE) ; InterlockedExchange ((ULONG *)Initialized, (ULONG)~0) ; return STATUS_NO_MEMORY; } InsertHeadList (&IOWorkerThreads, &ThreadCB.List) ; ThreadCB.Flags = 0 ; ThreadCB.LongFunctionFlag = FALSE ; InterlockedIncrement(&NumIOWorkerThreads) ; // We are all initialized now. Notify the starter to queue the task. InterlockedExchange ((ULONG *)Initialized, 1L) ; // Sleep alertably so that all the activity can take place // in APCs for ( ; ; ) { // Set timeout for IdleTimeout TimeOut.QuadPart = Int32x32To64( SleepTime, -10000 ) ; Status = NtDelayExecution (TRUE, &TimeOut) ; // Status is STATUS_SUCCESS only when it has timed out if (Status != STATUS_SUCCESS) { continue ; } // // idle timeout. check if you can terminate the thread // Terminate = FALSE ; RtlEnterCriticalSection (&WorkerCriticalSection) ; // dont terminate if it is a persistent thread if (ThreadCB.Flags & WT_EXECUTEINPERSISTENTIOTHREAD) { TimeOut.LowPart = 0x0; TimeOut.HighPart = 0x80000000; RtlLeaveCriticalSection (&WorkerCriticalSection) ; continue ; } // The thread terminates if there are > 1 threads and the queue is small // OR if there is only 1 thread and there is no request pending if (NumIOWorkerThreads > 1) { ULONG NumEffIOWorkerThreads = NumIOWorkerThreads - NumLongIOWorkRequests ; ULONG Threshold ; if (NumEffIOWorkerThreads == 0) { Terminate = FALSE ; } else { // Check if we need to shrink worker thread pool Threshold = NEW_THREAD_THRESHOLD * (NumEffIOWorkerThreads-1); if (NumIOWorkRequests-NumLongIOWorkRequests < Threshold) { Terminate = TRUE ; } else { Terminate = FALSE ; SleepTime <<= 1 ; } } } else { if (NumIOWorkRequests == 0) { // delay termination of last thread if (SleepTime < 4*IOWORKER_IDLE_TIMEOUT) { SleepTime <<= 1 ; Terminate = FALSE ; } else { Terminate = TRUE ; } } else { Terminate = FALSE ; } } // // terminate only if no io is pending // if (Terminate) { NTSTATUS Status; THREAD_BASIC_INFORMATION ThreadInfo; ULONG IsIoPending ; Terminate = FALSE ; Status = NtQueryInformationThread( ThreadCB.ThreadHandle, ThreadIsIoPending, &IsIoPending, sizeof( IsIoPending ), NULL ); if (NT_SUCCESS( Status )) { if (! IsIoPending ) Terminate = TRUE ; } } if (Terminate) { InterlockedDecrement (&NumIOWorkerThreads) ; RemoveEntryList (&ThreadCB.List) ; NtClose( ThreadCB.ThreadHandle ) ; RtlLeaveCriticalSection (&WorkerCriticalSection) ; RtlpExitThreadFunc( 0 ); } else { // This is the condition where a request was queued *after* the // thread woke up - ready to terminate because of inactivity. In // this case dont terminate - service the completion port. RtlLeaveCriticalSection (&WorkerCriticalSection) ; } } return 0 ; // Keep compiler happy }

VOID RtlpProcessTimeouts (  PRTLP_WAIT_THREAD_CONTROL_BLOCK  ThreadCB  )

Definition at line 3697 of file threads.c. References _RTLP_WAIT_THREAD_CONTROL_BLOCK::Current64BitTickCount, _RTLP_WAIT_THREAD_CONTROL_BLOCK::Firing64BitTickCount, RtlpFireTimers(), RtlpFireTimersAndReorder(), RtlpGet64BitTickCount(), RtlpGetTimeRemaining(), RtlpResetTimer(), _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerHandle, and _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerQueue. Referenced by RtlpWaitThread(). : This routine processes timeouts for the wait thread Arguments: ThreadCB - The wait thread to add the wait to Return Value: --*/ { ULONG NewFiringTime, TimeRemaining ; LIST_ENTRY TimersToFireList ; // // check if incorrect timer fired // if (ThreadCB->Firing64BitTickCount > RtlpGet64BitTickCount(&ThreadCB->Current64BitTickCount) + 200 ) { RtlpResetTimer (ThreadCB->TimerHandle, RtlpGetTimeRemaining (ThreadCB->TimerHandle), ThreadCB) ; return ; } InitializeListHead( &TimersToFireList ) ; // Walk thru the timer list and fire all waits with DeltaFiringTime == 0 RtlpFireTimersAndReorder (&ThreadCB->TimerQueue, &NewFiringTime, &TimersToFireList) ; // Reset the NT timer RtlpResetTimer (ThreadCB->TimerHandle, NewFiringTime, ThreadCB) ; RtlpFireTimers( &TimersToFireList ) ; }

VOID RtlpProcessWaitCompletion (  PRTLP_WAIT  Wait, ULONG  ArrayIndex )

Definition at line 3172 of file threads.c. References _RTLP_WAIT_THREAD_CONTROL_BLOCK::ActiveWaitArray, _RTLP_WAIT_THREAD_CONTROL_BLOCK::ActiveWaitPointers, _RTLP_WAIT::Context, DBG_SET_FUNCTION, DbgPrint, DPRN4, FALSE, _RTLP_WAIT::Flags, _RTLP_WAIT::Function, NT_SUCCESS, NTSTATUS(), _RTLP_WAIT_THREAD_CONTROL_BLOCK::NumActiveWaits, _RTLP_GENERIC_TIMER::Period, _RTLP_WAIT::RefCount, RTLP_ASYNC_CALLBACK, RtlpAsyncCallbackCompletion(), RtlpDeactivateWait(), RtlpDeleteWait(), RtlpForceAllocateTPHeap(), RtlpFreeTPHeap, RtlpGetTimeRemaining(), RtlpReOrderDeltaList(), RtlpResetTimer(), RtlpShiftWaitArray, RtlQueueWorkItem(), Status, _RTLP_WAIT::ThreadCB, _RTLP_WAIT::Timer, _RTLP_WAITWORKER::TimerCondition, _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerHandle, _RTLP_WAIT_THREAD_CONTROL_BLOCK::TimerQueue, TRUE, _RTLP_WAITWORKER::Wait, and _RTLP_WAITWORKER::WaitThreadCallback. Referenced by RtlpWaitThread(). : This routine is used for processing a completed wait Arguments: Wait - Wait that completed Return Value: --*/ { ULONG TimeRemaining ; ULONG NewFiringTime ; LARGE_INTEGER DueTime ; PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB ; PRTLP_ASYNC_CALLBACK AsyncCallback ; ThreadCB = Wait->ThreadCB ; // deactivate wait if it is meant for single execution if ( Wait->Flags & WT_EXECUTEONLYONCE ) { RtlpDeactivateWait (Wait) ; } else { // if wait being reactivated, then reset the timer now itself as // it can be deleted in the callback function if ( Wait->Timer ) { TimeRemaining = RtlpGetTimeRemaining (ThreadCB->TimerHandle) ; if (RtlpReOrderDeltaList ( &ThreadCB->TimerQueue.TimerList, Wait->Timer, TimeRemaining, &NewFiringTime, Wait->Timer->Period)) { // There is a new element at the head of the queue we need to reset the NT // timer to fire later RtlpResetTimer (ThreadCB->TimerHandle, NewFiringTime, ThreadCB) ; } } // move the wait entry to the end, and shift elements to its right one pos towards left { HANDLE HandlePtr = ThreadCB->ActiveWaitArray[ArrayIndex]; PRTLP_WAIT WaitPtr = ThreadCB->ActiveWaitPointers[ArrayIndex]; RtlpShiftWaitArray(ThreadCB, ArrayIndex+1, ArrayIndex, ThreadCB->NumActiveWaits -1 - ArrayIndex) ThreadCB->ActiveWaitArray[ThreadCB->NumActiveWaits-1] = HandlePtr ; ThreadCB->ActiveWaitPointers[ThreadCB->NumActiveWaits-1] = WaitPtr ; } } // call callback function (FALSE since this isnt a timeout related callback) if ( Wait->Flags & WT_EXECUTEINWAITTHREAD ) { // executing callback after RtlpDeactivateWait allows the Callback to call // RtlDeregisterWait Wait->RefCount is not incremented so that RtlDeregisterWait // will work on this Wait. Though Wait->RefCount is not incremented, others cannot // deregister this Wait as it has to be queued as an APC. if (DPRN4) DbgPrint("Calling WaitOrTimer(wait): fn:%x context:%x bool:%d Thread<%d:%d>\n", (ULONG_PTR)Wait->Function, (ULONG_PTR)Wait->Context, FALSE, HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread), HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess) ) ; #if (DBG1) DBG_SET_FUNCTION( Wait->Function, Wait->Context ) ; #endif ((WAITORTIMERCALLBACKFUNC)(Wait->Function))(Wait->Context, FALSE) ; // Wait object could have been deleted in the above callback return ; } else { AsyncCallback = RtlpForceAllocateTPHeap( sizeof( RTLP_ASYNC_CALLBACK ), 0 ); if ( AsyncCallback ) { NTSTATUS Status; AsyncCallback->Wait = Wait ; AsyncCallback->WaitThreadCallback = TRUE ; AsyncCallback->TimerCondition = FALSE ; InterlockedIncrement( &Wait->RefCount ) ; Status = RtlQueueWorkItem( RtlpAsyncCallbackCompletion, AsyncCallback, Wait->Flags ); if (!NT_SUCCESS(Status)) { RtlpFreeTPHeap( AsyncCallback ); if ( InterlockedDecrement( &Wait->RefCount ) == 0 ) { RtlpDeleteWait( Wait ) ; } } } } }

NTSTATUS RtlpQueueIOWorkerRequest (  WORKERCALLBACKFUNC  Function, PVOID  Context, ULONG  Flags )

Definition at line 1638 of file threads.c. References DbgPrint, FALSE, _RTLP_IOWORKER_TCB::Flags, IOWorkerThreads, _RTLP_IOWORKER_TCB::List, List, _RTLP_IOWORKER_TCB::LongFunctionFlag, NT_SUCCESS, NtQueueApcThread(), NTSTATUS(), NumIOWorkerThreads, NumIOWorkRequests, NumLongIOWorkRequests, PersistentIOTCB, RtlpExecuteIOWorkItem(), Status, _RTLP_IOWORKER_TCB::ThreadHandle, and TRUE. Referenced by RtlQueueWorkItem(). : This routine queues up the request to be executed in an IO worker thread. Arguments: Function - Routine that is called by the worker thread Context - Opaque pointer passed in as an argument to WorkerProc Return Value: --*/ { NTSTATUS Status ; PRTLP_IOWORKER_TCB TCB ; BOOLEAN LongFunction = (Flags & WT_EXECUTELONGFUNCTION) ? TRUE : FALSE ; PLIST_ENTRY ple ; if (Flags & WT_EXECUTEINPERSISTENTIOTHREAD) { if (!PersistentIOTCB) { for (ple=IOWorkerThreads.Flink; ple!=&IOWorkerThreads; ple=ple->Flink) { TCB = CONTAINING_RECORD (ple, RTLP_IOWORKER_TCB, List) ; if (! TCB->LongFunctionFlag) break; } if (ple == &IOWorkerThreads) { // ASSERT(FALSE); return STATUS_NO_MEMORY; } PersistentIOTCB = TCB ; TCB->Flags |= WT_EXECUTEINPERSISTENTIOTHREAD ; } else { TCB = PersistentIOTCB ; } } else { for (ple=IOWorkerThreads.Flink; ple!=&IOWorkerThreads; ple=ple->Flink) { TCB = CONTAINING_RECORD (ple, RTLP_IOWORKER_TCB, List) ; // do not queue to the thread if it is executing a long function, or // if you are queueing a long function and the thread is a persistent thread if (! TCB->LongFunctionFlag && (! ((TCB->Flags&WT_EXECUTEINPERSISTENTIOTHREAD) && (Flags&WT_EXECUTELONGFUNCTION)))) { break ; } } if ((ple == &IOWorkerThreads) && (NumIOWorkerThreads<1)) { #if DBG DbgPrint("ThreadPool:ntdll.dll: Out of memory. " "Could not execute IOWorkItem(%x)\n", (ULONG_PTR)Function); #endif return STATUS_NO_MEMORY; } else { ple = IOWorkerThreads.Flink; TCB = CONTAINING_RECORD (ple, RTLP_IOWORKER_TCB, List) ; // treat it as a short function so that counters work fine. LongFunction = FALSE; } // In order to implement "fair" assignment of work items between IO worker threads // each time remove the entry and reinsert at back. RemoveEntryList (&TCB->List) ; InsertTailList (&IOWorkerThreads, &TCB->List) ; } // Increment the outstanding work request counter InterlockedIncrement (&NumIOWorkRequests) ; if (LongFunction) { InterlockedIncrement( &NumLongIOWorkRequests ) ; TCB->LongFunctionFlag = TRUE ; } // Queue an APC to the IoWorker Thread Status = NtQueueApcThread( TCB->ThreadHandle, LongFunction? (PPS_APC_ROUTINE)RtlpExecuteLongIOWorkItem: (PPS_APC_ROUTINE)RtlpExecuteIOWorkItem, (PVOID)Function, Context, TCB ); if (! NT_SUCCESS( Status ) ) { InterlockedDecrement( &NumIOWorkRequests ) ; if (LongFunction) InterlockedDecrement( &NumLongIOWorkRequests ) ; } return Status ; }

NTSTATUS RtlpQueueWorkerRequest (  WORKERCALLBACKFUNC  Function, PVOID  Context, ULONG  Flags )

Definition at line 1506 of file threads.c. References ASSERT, DbgPrint, FALSE, _RTLP_WORK::Flags, _RTLP_WORK::Function, NT_SUCCESS, NtQueueApcThread(), NtSetIoCompletion(), NTSTATUS(), NumLongWorkRequests, NumWorkRequests, PRTLP_WORK, RTLP_WORK, RtlpExecuteWorkerRequest(), RtlpForceAllocateTPHeap(), RtlpFreeTPHeap, Status, TimerThreadHandle, and WorkerCompletionPort. Referenced by RtlQueueWorkItem(). : This routine queues up the request to be executed in a worker thread. Arguments: Function - Routine that is called by the worker thread Context - Opaque pointer passed in as an argument to WorkerProc Flags - flags passed to RtlQueueWorkItem Return Value: --*/ { NTSTATUS Status ; PRTLP_WORK WorkEntry ; // Increment the outstanding work request counter InterlockedIncrement (&NumWorkRequests) ; if (Flags & WT_EXECUTELONGFUNCTION) { InterlockedIncrement( & NumLongWorkRequests ) ; } WorkEntry = (PRTLP_WORK) RtlpForceAllocateTPHeap ( sizeof (RTLP_WORK), HEAP_ZERO_MEMORY) ; WorkEntry->Function = Function ; WorkEntry->Flags = Flags ; if (Flags & WT_EXECUTEINPERSISTENTTHREAD) { // Queue APC to timer thread Status = NtQueueApcThread( TimerThreadHandle, (PPS_APC_ROUTINE)RtlpExecuteWorkerRequest, (PVOID) STATUS_SUCCESS, (PVOID) Context, (PVOID) WorkEntry ) ; } else { Status = NtSetIoCompletion ( WorkerCompletionPort, RtlpExecuteWorkerRequest, (PVOID) WorkEntry, STATUS_SUCCESS, (ULONG_PTR)Context ); } if ( ! NT_SUCCESS(Status) ) { InterlockedDecrement (&NumWorkRequests) ; if (Flags && WT_EXECUTELONGFUNCTION) { InterlockedDecrement( &NumLongWorkRequests ) ; } RtlpFreeTPHeap( WorkEntry ) ; ASSERT(FALSE) ; #if DBG DbgPrint("ERROR!! Thread Pool (RtlQeueuWorkItem): could not queue work item\n"); #endif } return Status ; }

BOOLEAN RtlpRemoveFromDeltaList (  PLIST_ENTRY  DeltaList, PRTLP_GENERIC_TIMER  Timer, ULONG  TimeRemaining, ULONG *  NewFiringTime )

Definition at line 4631 of file threads.c. References _RTLP_GENERIC_TIMER::DeltaFiringTime, FALSE, INFINITE_TIME, List, _RTLP_GENERIC_TIMER::List, and TRUE. Referenced by RtlpDeactivateTimer(), RtlpDeactivateWait(), RtlpDeleteTimerQueue(), and RtlpReOrderDeltaList(). : Removes the specified timer from the delta list Arguments: DeltaList - Delta list to insert into Timer - Timer element to insert into list TimerHandle - Handle of the NT Timer object TimeRemaining - This time must be added to the head of the list to get "real" relative time. Return Value: TRUE if the timer was removed from head of timer list FALSE otherwise --*/ { PLIST_ENTRY Next ; PRTLP_GENERIC_TIMER Temp ; Next = Timer->List.Flink ; RemoveEntryList (&Timer->List) ; if (IsListEmpty (DeltaList)) { *NewFiringTime = INFINITE_TIME ; return TRUE ; } if (Next == DeltaList) { // If we removed the last element in the list nothing to do either return FALSE ; } else { Temp = CONTAINING_RECORD ( Next, RTLP_GENERIC_TIMER, List) ; Temp->DeltaFiringTime += Timer->DeltaFiringTime ; // Check if element was removed from head of list if (DeltaList->Flink == Next) { *NewFiringTime = Temp->DeltaFiringTime + TimeRemaining ; Temp->DeltaFiringTime = 0 ; return TRUE ; } else { return FALSE ; } } }

BOOLEAN RtlpReOrderDeltaList (  PLIST_ENTRY  DeltaList, PRTLP_GENERIC_TIMER  Timer, ULONG  TimeRemaining, ULONG *  NewFiringTime, ULONG  ChangedFiringTime )

Definition at line 4711 of file threads.c. References _RTLP_GENERIC_TIMER::DeltaFiringTime, RtlpInsertInDeltaList(), RtlpRemoveFromDeltaList(), and TRUE. Referenced by RtlpAddTimer(), RtlpDeactivateTimer(), RtlpProcessWaitCompletion(), and RtlpUpdateTimer(). : Called when a timer in the delta list needs to be re-inserted because the firing time has changed. Arguments: DeltaList - List in which to re-insert Timer - Timer for which the firing time has changed TimeRemaining - Time before the head of the delta list is fired NewFiringTime - If the new element was inserted at the head of the list - this will contain the new firing time in milliseconds. The caller can use this time to re-program the NT timer. ChangedFiringTime - Changed Time for the specified timer. Return Value: TRUE if the timer was removed from head of timer list FALSE otherwise --*/ { ULONG NewTimeRemaining ; PRTLP_GENERIC_TIMER Temp ; // Remove the timer from the list if (RtlpRemoveFromDeltaList (DeltaList, Timer, TimeRemaining, NewFiringTime)) { // If element was removed from the head of the list we should record that NewTimeRemaining = *NewFiringTime ; } else { // Element was not removed from head of delta list, the current TimeRemaining is valid NewTimeRemaining = TimeRemaining ; } // Before inserting Timer, set its delta time to the ChangedFiringTime Timer->DeltaFiringTime = ChangedFiringTime ; // Reinsert this element back in the list if (!RtlpInsertInDeltaList (DeltaList, Timer, NewTimeRemaining, NewFiringTime)) { // If we did not add at the head of the list, then we should return TRUE if // RtlpRemoveFromDeltaList() had returned TRUE. We also update the NewFiringTime to // the reflect the new firing time returned by RtlpRemoveFromDeltaList() *NewFiringTime = NewTimeRemaining ; return (NewTimeRemaining != TimeRemaining) ; } else { // NewFiringTime contains the time the NT timer must be programmed for return TRUE ; } }

VOID RtlpResetTimer (  HANDLE  TimerHandle, ULONG  DueTime, PRTLP_WAIT_THREAD_CONTROL_BLOCK  ThreadCB )

Definition at line 4429 of file threads.c. References _RTLP_WAIT_THREAD_CONTROL_BLOCK::Current64BitTickCount, FALSE, _RTLP_WAIT_THREAD_CONTROL_BLOCK::Firing64BitTickCount, INFINITE_TIME, Last64BitTickCount, NtCancelTimer(), NtSetTimer(), NULL, RtlpGet64BitTickCount(), RtlpGetResync64BitTickCount, RtlpServiceTimer(), RtlpSetFiring64BitTickCount, and TimerHandle. Referenced by RtlpAddTimer(), RtlpAddWait(), RtlpDeactivateTimer(), RtlpDeactivateWait(), RtlpDeleteTimerQueue(), RtlpProcessTimeouts(), RtlpProcessWaitCompletion(), RtlpServiceTimer(), RtlpTimerThread(), RtlpUpdateTimer(), and RtlpWaitThread(). : This routine resets the timer object with the new due time. Arguments: TimerHandle - Handle to the timer object DueTime - Relative timer due time in Milliseconds Return Value: --*/ { LARGE_INTEGER LongDueTime ; NtCancelTimer (TimerHandle, NULL) ; // If the DueTime is INFINITE_TIME then set the timer to the largest integer possible if (DueTime == INFINITE_TIME) { LongDueTime.LowPart = 0x0 ; LongDueTime.HighPart = 0x80000000 ; } else { // // set the absolute time when timer is to be fired // if (ThreadCB) { ThreadCB->Firing64BitTickCount = DueTime + RtlpGet64BitTickCount(&ThreadCB->Current64BitTickCount) ; } else { // // adjust for drift only if it is a global timer // ULONG Drift ; LONGLONG llCurrentTick ; llCurrentTick = RtlpGet64BitTickCount(&Last64BitTickCount) ; Drift = (ULONG) (llCurrentTick - RtlpGetResync64BitTickCount()) ; DueTime = (DueTime > Drift) ? DueTime-Drift : 1 ; RtlpSetFiring64BitTickCount(llCurrentTick + DueTime) ; } LongDueTime.QuadPart = Int32x32To64( DueTime, -10000 ); } NtSetTimer ( TimerHandle, &LongDueTime, ThreadCB ? NULL : RtlpServiceTimer, NULL, FALSE, 0, NULL ) ; }

VOID RtlpServiceTimer (  PVOID  NotUsedArg, ULONG  NotUsedLowTimer, LONG  NotUsedHighTimer )

Definition at line 4821 of file threads.c. References ACQUIRE_GLOBAL_TIMER_LOCK, DbgPrint, DPRN2, DPRN3, Firing64BitTickCount, INFINITE_TIME, Last64BitTickCount, List, NULL, PRTLP_TIMER, PRTLP_TIMER_QUEUE, RELEASE_GLOBAL_TIMER_LOCK, RtlDebugPrintTimes(), RTLP_TIMER_QUEUE, RtlpFireTimers(), RtlpFireTimersAndReorder(), RtlpGet64BitTickCount(), RtlpGetTimeRemaining(), RtlpInsertTimersIntoDeltaList(), RtlpResetTimer(), RtlpResync64BitTickCount(), TimerHandle, and TimerQueues. Referenced by RtlpResetTimer(). : Services the timer. Runs in an APC. Arguments: NotUsedArg - Argument is not used in this function. NotUsedLowTimer - Argument is not used in this function. NotUsedHighTimer - Argument is not used in this function. Return Value: Remarks: This APC is called only for timeouts of timer threads. --*/ { PRTLP_TIMER Timer ; PRTLP_TIMER_QUEUE Queue ; PLIST_ENTRY TNode ; PLIST_ENTRY QNode ; PLIST_ENTRY Temp ; ULONG NewFiringTime ; LIST_ENTRY ReinsertTimerQueueList ; LIST_ENTRY TimersToFireList ; RtlpResync64BitTickCount() ; if (DPRN2) { DbgPrint("Before service timer ThreadId<%x:%x>\n", HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread), HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)); RtlDebugPrintTimes (); } ACQUIRE_GLOBAL_TIMER_LOCK(); // fire it if it even 200ms ahead. else reset the timer if (Firing64BitTickCount.QuadPart > RtlpGet64BitTickCount(&Last64BitTickCount) + 200) { RtlpResetTimer (TimerHandle, RtlpGetTimeRemaining (TimerHandle), NULL) ; RELEASE_GLOBAL_TIMER_LOCK() ; return ; } InitializeListHead (&ReinsertTimerQueueList) ; InitializeListHead (&TimersToFireList) ; // We run thru all queues with DeltaFiringTime == 0 and fire all timers that // have DeltaFiringTime == 0. We remove the fired timers and either free them // (for one shot timers) or put them in aside list (for periodic timers). // After we have finished firing all timers in a queue we reinsert the timers // in the aside list back into the queue based on their new firing times. // // Similarly, we remove each fired Queue and put it in a aside list. After firing // all queues with DeltaFiringTime == 0, we reinsert the Queues in the aside list // and reprogram the NT timer to be the firing time of the first queue in the list for (QNode = TimerQueues.Flink ; QNode != &TimerQueues ; QNode = QNode->Flink) { Queue = CONTAINING_RECORD (QNode, RTLP_TIMER_QUEUE, List) ; // If the delta time in the timer queue is 0 - then this queue // has timers that are ready to fire. Walk the list and fire all timers with // Delta time of 0 if (Queue->DeltaFiringTime == 0) { // Walk all timers with DeltaFiringTime == 0 and fire them. After that // reinsert the periodic timers in the appropriate place. RtlpFireTimersAndReorder (Queue, &NewFiringTime, &TimersToFireList) ; // detach this Queue from the list QNode = QNode->Blink ; RemoveEntryList (QNode->Flink) ; // If there are timers in the queue then prepare to reinsert the queue in // TimerQueues. if (NewFiringTime != INFINITE_TIME) { Queue->DeltaFiringTime = NewFiringTime ; // put the timer in list that we will process after we have // fired all elements in this queue InsertHeadList (&ReinsertTimerQueueList, &Queue->List) ; } else { // Queue has no more timers in it. Let the Queue float. InitializeListHead (&Queue->List) ; } } else { // No more Queues with DeltaFiringTime == 0 break ; } } // At this point we have fired all the ready timers. We have two lists that need to be // merged - TimerQueues and ReinsertTimerQueueList. The following steps do this - at the // end of this we will reprogram the NT Timer. if (!IsListEmpty(&TimerQueues)) { Queue = CONTAINING_RECORD (TimerQueues.Flink, RTLP_TIMER_QUEUE, List) ; NewFiringTime = Queue->DeltaFiringTime ; Queue->DeltaFiringTime = 0 ; if (!IsListEmpty (&ReinsertTimerQueueList)) { // TimerQueues and ReinsertTimerQueueList are both non-empty. Merge them. RtlpInsertTimersIntoDeltaList (&ReinsertTimerQueueList, &TimerQueues, NewFiringTime, &NewFiringTime) ; } // NewFiringTime contains the time the NT Timer should be programmed to. } else { if (!IsListEmpty (&ReinsertTimerQueueList)) { // TimerQueues is empty. ReinsertTimerQueueList is not. RtlpInsertTimersIntoDeltaList (&ReinsertTimerQueueList, &TimerQueues, 0, &NewFiringTime) ; } else { NewFiringTime = INFINITE_TIME ; } // NewFiringTime contains the time the NT Timer should be programmed to. } // Reset the timer to reflect the Delta time associated with the first Queue RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; if (DPRN3) { DbgPrint("After service timer:ThreadId<%x:%x>\n", HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread), HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess)); RtlDebugPrintTimes (); } // finally fire all the timers RtlpFireTimers( &TimersToFireList ) ; RELEASE_GLOBAL_TIMER_LOCK(); }

NTSTATUS RtlpStartIOWorkerThread (   )

Definition at line 1820 of file threads.c. References LastThreadCreationTickCount, NtClose(), NtGetTickCount(), NTSTATUS(), NumIOWorkerThreads, RtlpIOWorkerThread(), RtlpStartThreadFunc, Status, and ThreadHandle. Referenced by RtlQueueWorkItem(). : This routine starts an I/O worker thread Arguments: Return Value: NTSTATUS error codes resulting from attempts to create a thread STATUS_SUCCESS --*/ { HANDLE ThreadHandle ; ULONG CurrentTickCount ; NTSTATUS Status ; // Create worker thread Status = RtlpStartThreadFunc (RtlpIOWorkerThread, &ThreadHandle) ; if (Status == STATUS_SUCCESS ) { NtClose( ThreadHandle ) ; // Update the time at which the current thread was created LastThreadCreationTickCount = NtGetTickCount() ; } else { // Thread creation failed. If there is even one thread present do not return // failure since we can still service the work request. if (NumIOWorkerThreads == 0) { return Status ; } } return STATUS_SUCCESS ; }

NTSTATUS RtlpStartThread (  IN PUSER_THREAD_START_ROUTINE  Function, OUT HANDLE *  ThreadHandle )

NTSTATUS RtlpStartWorkerThread (   )

Definition at line 1763 of file threads.c. References LastThreadCreationTickCount, NtClose(), NtGetTickCount(), NTSTATUS(), NumWorkerThreads, RtlpStartThreadFunc, RtlpWorkerThread(), Status, and ThreadHandle. Referenced by RtlpWorkerThreadTimerCallback(), RtlQueueWorkItem(), and RtlSetIoCompletionCallback(). : This routine starts a regular worker thread Arguments: Return Value: NTSTATUS error codes resulting from attempts to create a thread STATUS_SUCCESS --*/ { HANDLE ThreadHandle ; ULONG CurrentTickCount ; NTSTATUS Status ; // Create worker thread Status = RtlpStartThreadFunc (RtlpWorkerThread, &ThreadHandle) ; if (Status == STATUS_SUCCESS ) { // Update the time at which the current thread was created LastThreadCreationTickCount = NtGetTickCount() ; // Increment the count of the thread type created InterlockedIncrement(&NumWorkerThreads) ; // Close Thread handle, we dont need it. NtClose (ThreadHandle) ; } else { // Thread creation failed. If there is even one thread present do not return // failure - else queue the request anyway. if (NumWorkerThreads == 0) { return Status ; } } return STATUS_SUCCESS ; }

VOID RtlpThreadCleanup (   )

Definition at line 5484 of file threads.c. References NtTerminateThread(). Referenced by RtlThreadPoolCleanup(). : This routine is used for exiting timer, wait and IOworker threads. Arguments: Return Value: --*/ { NtTerminateThread( NtCurrentThread(), 0) ; }

LONG RtlpTimerThread (  PVOID  NotUsed  )

Definition at line 5201 of file threads.c. References Initialized, NtDelayExecution(), NULL, RtlpResetTimer(), TimerHandle, TimerThreadId, and TRUE. Referenced by RtlpInitializeTimerThreadPool(). : All the timer activity takes place in APCs. Arguments: Initialized - Used to notify the starter of the thread that thread initialization has completed Return Value: --*/ { LARGE_INTEGER TimeOut ; // no structure initializations should be done here as new timer thread // may be created after threadPoolCleanup TimerThreadId = HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread) ; // Reset the NT Timer to never fire initially RtlpResetTimer (TimerHandle, -1, NULL) ; // Notify starter of this thread that it has initialized InterlockedExchange ((ULONG *) Initialized, 1) ; // Sleep alertably so that all the activity can take place // in APCs for ( ; ; ) { // Set timeout for the largest timeout possible TimeOut.LowPart = 0 ; TimeOut.HighPart = 0x80000000 ; NtDelayExecution (TRUE, &TimeOut) ; } return 0 ; // Keep compiler happy }

VOID RtlpUpdateTimer (  PRTLP_TIMER  Timer, PRTLP_TIMER  UpdatedTimer )

Definition at line 4044 of file threads.c. References CHECK_SIGNATURE, NULL, PRTLP_TIMER_QUEUE, RtlpFreeTPHeap, RtlpGetQueueRelativeTime(), RtlpGetTimeRemaining(), RtlpReOrderDeltaList(), RtlpResetTimer(), RtlpResync64BitTickCount(), STATE_ACTIVE, TimerHandle, and TimerQueues. Referenced by RtlUpdateTimer(). : This routine executes in an APC and updates the specified timer if it exists Arguments: Timer - Timer that is actually updated UpdatedTimer - Specifies pointer to a timer structure that contains Queue and Timer information Return Value: --*/ { PRTLP_TIMER_QUEUE Queue ; ULONG TimeRemaining, QueueRelTimeRemaining ; ULONG NewFiringTime ; RtlpResync64BitTickCount( ) ; CHECK_SIGNATURE(Timer) ; Queue = Timer->Queue ; // Update the periodic time on the timer Timer->Period = UpdatedTimer->Period ; // if timer is not in active state, then dont update it if ( ! ( Timer->State & STATE_ACTIVE ) ) { return ; } // Get the time remaining on the NT timer TimeRemaining = RtlpGetTimeRemaining (TimerHandle) ; QueueRelTimeRemaining = TimeRemaining + RtlpGetQueueRelativeTime (Queue) ; // Update the timer based on the due time if (RtlpReOrderDeltaList (&Queue->TimerList, Timer, QueueRelTimeRemaining, &NewFiringTime, UpdatedTimer->DeltaFiringTime)) { // If this update caused the timer at the head of the queue to change, then reinsert // this queue in the list of queues. if (RtlpReOrderDeltaList (&TimerQueues, Queue, TimeRemaining, &NewFiringTime, NewFiringTime)) { // NT timer needs to be updated since the change caused the queue at the head of // the TimerQueues to change. RtlpResetTimer (TimerHandle, NewFiringTime, NULL) ; } } RtlpFreeTPHeap( UpdatedTimer ) ; }

NTSTATUS RtlpWaitForEvent (  HANDLE  Event, HANDLE  ThreadHandle )

Definition at line 5503 of file threads.c. References DbgPrint, Event(), FALSE, NT_SUCCESS, NtQueueApcThread(), NTSTATUS(), NtWaitForSingleObject(), NULL, ONE_SECOND_TIMEOUT, RtlpDoNothing(), Status, and ThreadHandle. Referenced by RtlDeleteTimer(), RtlDeleteTimerQueueEx(), and RtlDeregisterWaitEx(). : Waits for the event to be signalled. If the event is not signalled within one second, then checks to see that the thread is alive Arguments: Event : Event handle used for signalling completion of request ThreadHandle: Thread to check whether still alive Return Value: STATUS_SUCCESS if event was signalled else return NTSTATUS --*/ { NTSTATUS Status ; LARGE_INTEGER TimeOut ; // Timeout of 1 second for request to complete ONE_SECOND_TIMEOUT(TimeOut) ; Wait: Status = NtWaitForSingleObject (Event, FALSE, &TimeOut) ; if (Status == STATUS_TIMEOUT) { // The wait timed out. Check to see if the wait thread is still alive. // This is done by trying to queue a dummy APC to it. There is no better // way known to determine if the thread has died unexpectedly. // If so then go back to waiting. Status = NtQueueApcThread( ThreadHandle, (PPS_APC_ROUTINE)RtlpDoNothing, NULL, NULL, NULL ); if (NT_SUCCESS(Status) ) { // Wait thread is still alive. Go back to waiting. goto Wait ; } else { // The wait thread died between the time the APC was queued and the // the time we started waiting on NtQueryInformationThread() DbgPrint ("Thread died before event could be signalled") ; } } return NT_SUCCESS(Status) ? STATUS_SUCCESS : Status ; }

LONG RtlpWaitThread (  IN PVOID  WaitHandle  )

LONG RtlpWorkerThread (  PVOID  NotUsed  )

Definition at line 2137 of file threads.c. References ASSERT, EXCEPTION_EXECUTE_HANDLER, FALSE, Initialized, L, MAX_WORKER_SLEEP_TIME_EXPONENT, NEW_THREAD_THRESHOLD, NT_SUCCESS, NtClose(), NtDuplicateObject(), NtQueryInformationThread(), NtRemoveIoCompletion(), NTSTATUS(), NULL, NumExecutingWorkerThreads, NumLongWorkRequests, NumMinWorkerThreads, NumWorkerThreads, NumWorkRequests, RtlpExitThreadFunc, Status, TotalExecutedWorkRequests, TRUE, WORKER_IDLE_TIMEOUT, WorkerCompletionPort, and WorkerCriticalSection. Referenced by RtlpStartWorkerThread(). : All non I/O worker threads execute in this routine. Worker thread will try to terminate when it has not serviced a request for STARTING_WORKER_SLEEP_TIME + STARTING_WORKER_SLEEP_TIME << 1 + ... STARTING_WORKER_SLEEP_TIME << MAX_WORKER_SLEEP_TIME_EXPONENT Arguments: Initialized - Set to 1 when we are initialized Return Value: --*/ { NTSTATUS Status ; PVOID WorkerProc ; PVOID Context ; IO_STATUS_BLOCK IoSb ; ULONG SleepTime ; LARGE_INTEGER TimeOut ; ULONG Terminate ; PVOID Overlapped ; // We are all initialized now. Notify the starter to queue the task. InterlockedExchange ((ULONG *)Initialized, 1L) ; // Set default sleep time for 40 seconds. This time is doubled each time a timeout // occurs after which the thread terminates #define WORKER_IDLE_TIMEOUT 40000 // In Milliseconds #define MAX_WORKER_SLEEP_TIME_EXPONENT 4 SleepTime = WORKER_IDLE_TIMEOUT ; // Loop servicing I/O completion requests for ( ; ; ) { TimeOut.QuadPart = Int32x32To64( SleepTime, -10000 ) ; Status = NtRemoveIoCompletion( WorkerCompletionPort, (PVOID) &WorkerProc, &Overlapped, &IoSb, &TimeOut ) ; if (Status == STATUS_SUCCESS) { TotalExecutedWorkRequests ++ ;//interlocked op not req InterlockedIncrement(&NumExecutingWorkerThreads) ; // Call the work item. // If IO APC, context1 contains number of IO bytes transferred, and context2 // contains the overlapped structure. // If (IO)WorkerFunction, context1 contains the actual WorkerFunction to be // executed and context2 contains the actual context Context = (PVOID) IoSb.Information ; try { ((APC_CALLBACK_FUNCTION)WorkerProc) ( IoSb.Status, Context, // Number of IO bytes transferred Overlapped // Overlapped structure ) ; } except (EXCEPTION_EXECUTE_HANDLER) { ASSERT(FALSE); } SleepTime = WORKER_IDLE_TIMEOUT ; InterlockedDecrement(&NumExecutingWorkerThreads) ; } else if (Status == STATUS_TIMEOUT) { // NtRemoveIoCompletion timed out. Check to see if have hit our limit // on waiting. If so terminate. Terminate = FALSE ; RtlEnterCriticalSection (&WorkerCriticalSection) ; // The thread terminates if there are > 1 threads and the queue is small // OR if there is only 1 thread and there is no request pending if (NumWorkerThreads > 1) { ULONG NumEffWorkerThreads = (NumWorkerThreads - NumLongWorkRequests) ; if (NumEffWorkerThreads == 0) { Terminate = FALSE ; } else if (SleepTime >= (WORKER_IDLE_TIMEOUT << MAX_WORKER_SLEEP_TIME_EXPONENT)) { // // have been idle for very long time. terminate irrespective of number of // work items. (This is useful when the set of runnable threads is taking // care of all the work items being queued). dont terminate if // (NumEffWorkerThreads == 1) // if (NumEffWorkerThreads > 1) Terminate = TRUE ; } else { ULONG Threshold ; // Check if we need to shrink worker thread pool Threshold = NumEffWorkerThreads < 7 ? NumEffWorkerThreads*(NumEffWorkerThreads-1) : NEW_THREAD_THRESHOLD * (NumEffWorkerThreads-1); if (NumWorkRequests-NumLongWorkRequests < Threshold) { Terminate = TRUE ; } else { Terminate = FALSE ; SleepTime <<= 1 ; } } } else { if ( (NumMinWorkerThreads == 0) && (NumWorkRequests == 0) ) { // delay termination of last thread if (SleepTime < (WORKER_IDLE_TIMEOUT << MAX_WORKER_SLEEP_TIME_EXPONENT)) { SleepTime <<= 1 ; Terminate = FALSE ; } else { Terminate = TRUE ; } } else { Terminate = FALSE ; } } if (Terminate) { THREAD_BASIC_INFORMATION ThreadInfo; ULONG IsIoPending ; HANDLE CurThreadHandle ; Status = NtDuplicateObject( NtCurrentProcess(), NtCurrentThread(), NtCurrentProcess(), &CurThreadHandle, 0, FALSE, DUPLICATE_SAME_ACCESS ) ; ASSERT (Status == STATUS_SUCCESS) ; Terminate = FALSE ; Status = NtQueryInformationThread( CurThreadHandle, ThreadIsIoPending, &IsIoPending, sizeof( IsIoPending ), NULL ); if (NT_SUCCESS( Status )) { if (! IsIoPending ) Terminate = TRUE ; } NtClose( CurThreadHandle ) ; } if (Terminate) { InterlockedDecrement (&NumWorkerThreads) ; RtlLeaveCriticalSection (&WorkerCriticalSection) ; RtlpExitThreadFunc( 0 ); } else { // This is the condition where a request was queued *after* the // thread woke up - ready to terminate because of inactivity. In // this case dont terminate - service the completion port. RtlLeaveCriticalSection (&WorkerCriticalSection) ; } } else { ASSERT (FALSE) ; } } return 1 ; }

VOID RtlpWorkerThreadCleanup (  NTSTATUS  Status, PVOID  NotUsed, PVOID  NotUsed2 )

VOID RtlpWorkerThreadInitializeTimers (  PVOID  Context  )

Definition at line 2104 of file threads.c. References NT_SUCCESS, NTSTATUS(), NULL, RtlCreateTimer(), RtlCreateTimerQueue(), RtlpWorkerThreadTimerCallback(), Status, WorkerThreadTimer, and WorkerThreadTimerQueue. Referenced by RtlpInitializeWorkerThreadPool(). { NTSTATUS Status; // create a timer that will fire every 30 sec and check if new thread // should be created Status = RtlCreateTimerQueue(&WorkerThreadTimerQueue) ; if (!NT_SUCCESS(Status)) return ; Status = RtlCreateTimer( WorkerThreadTimerQueue, &WorkerThreadTimer, RtlpWorkerThreadTimerCallback, NULL, 30000, 30000, WT_EXECUTEINTIMERTHREAD ) ; return; }

VOID RtlpWorkerThreadTimerCallback (  PVOID  Context, BOOLEAN  NotUsed )

Definition at line 1872 of file threads.c. References FALSE, MAX_WORKER_THREADS, NEW_THREAD_THRESHOLD, NT_SUCCESS, NtQueryIoCompletion(), NTSTATUS(), NULL, NumExecutingWorkerThreads, NumLongWorkRequests, NumWorkerThreads, OldTotalExecutedWorkRequests, RtlpStartWorkerThread(), Status, TotalExecutedWorkRequests, TRUE, WorkerCompletionPort, and WorkerCriticalSection. Referenced by RtlpWorkerThreadInitializeTimers(). : This routine checks if new worker thread has to be created Arguments: None Return Value: None --*/ { IO_COMPLETION_BASIC_INFORMATION Info ; BOOLEAN bCreateThread = FALSE ; NTSTATUS Status ; ULONG QueueLength, Threshold, ShortWorkRequests ; Status = NtQueryIoCompletion( WorkerCompletionPort, IoCompletionBasicInformation, &Info, sizeof(Info), NULL ) ; if (!NT_SUCCESS(Status)) return ; QueueLength = Info.Depth ; if (!QueueLength) { OldTotalExecutedWorkRequests = TotalExecutedWorkRequests ; return ; } RtlEnterCriticalSection (&WorkerCriticalSection) ; // if there are queued work items and no new work items have been scheduled // in the last 30 seconds then create a new thread. // this will take care of deadlocks. // this will create a problem only if some thread is running for a long time if (TotalExecutedWorkRequests == OldTotalExecutedWorkRequests) { bCreateThread = TRUE ; } // if there are a lot of queued work items, then create a new thread { ULONG NumEffWorkerThreads = (NumWorkerThreads - NumLongWorkRequests) ; ULONG ShortWorkRequests ; Threshold = (NumWorkerThreads < MAX_WORKER_THREADS ? (NumEffWorkerThreads < 7 ? NumEffWorkerThreads*NumEffWorkerThreads : NEW_THREAD_THRESHOLD * NumEffWorkerThreads ) : 0xffffffff) ; ShortWorkRequests = QueueLength + NumExecutingWorkerThreads - NumLongWorkRequests ; if (ShortWorkRequests > Threshold) { bCreateThread = TRUE ; } } if (bCreateThread) { RtlpStartWorkerThread () ; } OldTotalExecutedWorkRequests = TotalExecutedWorkRequests ; RtlLeaveCriticalSection (&WorkerCriticalSection) ; }

NTSYSAPI NTSTATUS NTAPI RtlThreadPoolCleanup (  ULONG  Flags  )

Definition at line 1320 of file threads.c. References ACQUIRE_GLOBAL_TIMER_LOCK, ACQUIRE_GLOBAL_WAIT_LOCK, ASSERTMSG, CompletedTimerInitialization, CompletedWaitInitialization, CompletedWorkerInitialization, FALSE, IOWorkerThreads, IS_COMPONENT_INITIALIZED, _RTLP_IOWORKER_TCB::List, List, NtClose(), NtQueueApcThread(), NtSetIoCompletion(), NULL, NumIOWorkerThreads, NumIOWorkRequests, NumTimerQueues, _RTLP_WAIT_THREAD_CONTROL_BLOCK::NumWaits, NumWorkerThreads, NumWorkRequests, RELEASE_GLOBAL_TIMER_LOCK, RELEASE_GLOBAL_WAIT_LOCK, RTLP_IOWORKER_TCB, RTLP_WAIT_THREAD_CONTROL_BLOCK, RtlpThreadCleanup(), StartedTimerInitialization, StartedWaitInitialization, StartedWorkerInitialization, _RTLP_IOWORKER_TCB::ThreadHandle, _RTLP_WAIT_THREAD_CONTROL_BLOCK::ThreadHandle, TimerThreadHandle, WaitThreads, _RTLP_WAIT_THREAD_CONTROL_BLOCK::WaitThreadsList, WorkerCompletionPort, and WorkerCriticalSection. : This routine cleans up the thread pool. Arguments: None Return Value: STATUS_SUCCESS : if none of the components are in use. STATUS_UNSUCCESSFUL : if some components are still in use. --*/ { BOOLEAN Cleanup ; PLIST_ENTRY Node ; ULONG i ; HANDLE TmpHandle ; return STATUS_UNSUCCESSFUL; // cleanup timer thread IS_COMPONENT_INITIALIZED(StartedTimerInitialization, CompletedTimerInitialization, Cleanup ) ; if ( Cleanup ) { ACQUIRE_GLOBAL_TIMER_LOCK() ; if (NumTimerQueues != 0 ) { ASSERTMSG( FALSE, "Trying to deinitialize ThreadPool when timers exist\n" ) ; RELEASE_GLOBAL_TIMER_LOCK() ; return STATUS_UNSUCCESSFUL ; } NtQueueApcThread( TimerThreadHandle, (PPS_APC_ROUTINE)RtlpThreadCleanup, NULL, NULL, NULL ); NtClose( TimerThreadHandle ) ; TimerThreadHandle = NULL ; RELEASE_GLOBAL_TIMER_LOCK() ; } // // cleanup wait threads // IS_COMPONENT_INITIALIZED(StartedWaitInitialization, CompletedWaitInitialization, Cleanup ) ; if ( Cleanup ) { PRTLP_WAIT_THREAD_CONTROL_BLOCK ThreadCB ; ACQUIRE_GLOBAL_WAIT_LOCK() ; // Queue an APC to all Wait Threads for (Node = WaitThreads.Flink ; Node != &WaitThreads ; Node = Node->Flink) { ThreadCB = CONTAINING_RECORD(Node, RTLP_WAIT_THREAD_CONTROL_BLOCK, WaitThreadsList) ; if ( ThreadCB->NumWaits != 0 ) { ASSERTMSG( FALSE, "Cannot cleanup ThreadPool. Registered Wait events exist." ) ; RELEASE_GLOBAL_WAIT_LOCK( ) ; return STATUS_UNSUCCESSFUL ; } RemoveEntryList( &ThreadCB->WaitThreadsList ) ; TmpHandle = ThreadCB->ThreadHandle ; NtQueueApcThread( ThreadCB->ThreadHandle, (PPS_APC_ROUTINE)RtlpThreadCleanup, NULL, NULL, NULL ); NtClose( TmpHandle ) ; } RELEASE_GLOBAL_WAIT_LOCK( ) ; } // cleanup worker threads IS_COMPONENT_INITIALIZED( StartedWorkerInitialization, CompletedWorkerInitialization, Cleanup ) ; if ( Cleanup ) { RtlEnterCriticalSection (&WorkerCriticalSection) ; if ( (NumWorkRequests != 0) || (NumIOWorkRequests != 0) ) { ASSERTMSG( FALSE, "Cannot cleanup ThreadPool. Work requests pending." ) ; RtlLeaveCriticalSection (&WorkerCriticalSection) ; return STATUS_UNSUCCESSFUL ; } // queue a cleanup for each worker thread for (i = 0 ; i < NumWorkerThreads ; i ++ ) { NtSetIoCompletion ( WorkerCompletionPort, RtlpThreadCleanup, NULL, STATUS_SUCCESS, 0 ); } // queue an apc to cleanup all IO worker threads for (Node = IOWorkerThreads.Flink ; Node != &IOWorkerThreads ; Node = Node->Flink ) { PRTLP_IOWORKER_TCB ThreadCB ; ThreadCB = CONTAINING_RECORD (Node, RTLP_IOWORKER_TCB, List) ; RemoveEntryList( &ThreadCB->List) ; TmpHandle = ThreadCB->ThreadHandle ; NtQueueApcThread( ThreadCB->ThreadHandle, (PPS_APC_ROUTINE)RtlpThreadCleanup, NULL, NULL, NULL ); NtClose( TmpHandle ) ; } NumWorkerThreads = NumIOWorkerThreads = 0 ; RtlLeaveCriticalSection (&WorkerCriticalSection) ; } return STATUS_SUCCESS ; }

---

Variable Documentation

PVOID CallbackFn1

Definition at line 266 of file threads.h.

PVOID CallbackFn2

Definition at line 266 of file threads.h.

ULONG CompletedEventCacheInitialization

Definition at line 219 of file threads.h. Referenced by RtlpGetWaitEvent(), and RtlpInitializeEventCache().

ULONG CompletedTimerInitialization

Definition at line 216 of file threads.h. Referenced by RtlCreateTimerQueue(), RtlDebugPrintTimes(), RtlpInitializeTimerThreadPool(), RtlpInitializeWorkerThreadPool(), and RtlThreadPoolCleanup().

ULONG CompletedTPInitialization

Definition at line 207 of file threads.h.

ULONG CompletedWaitInitialization

Definition at line 213 of file threads.h. Referenced by RtlpInitializeWaitThreadPool(), RtlRegisterWait(), and RtlThreadPoolCleanup().

ULONG CompletedWorkerInitialization

Definition at line 210 of file threads.h. Referenced by RtlpInitializeWorkerThreadPool(), RtlQueueWorkItem(), RtlSetIoCompletionCallback(), and RtlThreadPoolCleanup().

PVOID Context1

Definition at line 266 of file threads.h. Referenced by CcDeferWrite(), CcGetDirtyPages(), CmpRefreshWorkerRoutine(), and CmpSearchKeyControlBlockTree().

PVOID Context2

Definition at line 266 of file threads.h. Referenced by CcDeferWrite(), CcGetDirtyPages(), CmpSearchKeyControlBlockTree(), and KiInitializeContextThread().

LIST_ENTRY EventCache

Definition at line 248 of file threads.h. Referenced by RtlpFreeWaitEvent(), RtlpGetWaitEvent(), and RtlpInitializeEventCache().

RTL_CRITICAL_SECTION EventCacheCriticalSection

Definition at line 258 of file threads.h. Referenced by RtlpFreeWaitEvent(), RtlpGetWaitEvent(), and RtlpInitializeEventCache().

LARGE_INTEGER Firing64BitTickCount

Definition at line 385 of file threads.h. Referenced by RtlpInitializeTimerThreadPool(), and RtlpServiceTimer().

LIST_ENTRY IOWorkerThreads

Definition at line 243 of file threads.h. Referenced by RtlpInitializeWorkerThreadPool(), RtlpIOWorkerThread(), RtlpQueueIOWorkerRequest(), and RtlThreadPoolCleanup().

LARGE_INTEGER Last64BitTickCount

Definition at line 383 of file threads.h. Referenced by RtlpGet64BitTickCount(), RtlpResetTimer(), RtlpResync64BitTickCount(), and RtlpServiceTimer().

ULONG LastThreadCreationTickCount

Definition at line 241 of file threads.h. Referenced by RtlpStartIOWorkerThread(), RtlpStartWorkerThread(), and RtlQueueWorkItem().

ULONG NextTimerDbgId

Definition at line 103 of file threads.h. Referenced by RtlCreateTimerQueue().

ULONG NextWaitDbgId

Definition at line 104 of file threads.h. Referenced by RtlRegisterWait().

ULONG NumExecutingWorkerThreads

Definition at line 231 of file threads.h. Referenced by RtlpWorkerThread(), and RtlpWorkerThreadTimerCallback().

ULONG NumIOWorkerThreads

Definition at line 224 of file threads.h. Referenced by RtlpIOWorkerThread(), RtlpQueueIOWorkerRequest(), RtlpStartIOWorkerThread(), RtlQueueWorkItem(), and RtlThreadPoolCleanup().

ULONG NumIOWorkRequests

Definition at line 227 of file threads.h. Referenced by RtlpExecuteIOWorkItem(), RtlpExecuteLongIOWorkItem(), RtlpIOWorkerThread(), RtlpQueueIOWorkerRequest(), RtlQueueWorkItem(), and RtlThreadPoolCleanup().

ULONG NumLongIOWorkRequests

Definition at line 228 of file threads.h. Referenced by RtlpExecuteLongIOWorkItem(), RtlpIOWorkerThread(), RtlpQueueIOWorkerRequest(), and RtlQueueWorkItem().

ULONG NumLongWorkRequests

Definition at line 230 of file threads.h. Referenced by RtlpExecuteWorkerRequest(), RtlpQueueWorkerRequest(), RtlpWorkerThread(), RtlpWorkerThreadTimerCallback(), and RtlQueueWorkItem().

ULONG NumMinWorkerThreads

Definition at line 226 of file threads.h. Referenced by RtlpWorkerThread(), RtlQueueWorkItem(), and RtlSetIoCompletionCallback().

ULONG NumTimerQueues

Definition at line 253 of file threads.h. Referenced by RtlCreateTimerQueue(), RtlpDeleteTimerQueueComplete(), and RtlThreadPoolCleanup().

ULONG NumUnusedEvents

Definition at line 239 of file threads.h. Referenced by RtlpFreeWaitEvent(), and RtlpInitializeEventCache().

ULONG NumWorkerThreads

Definition at line 225 of file threads.h. Referenced by RtlpStartWorkerThread(), RtlpWorkerThread(), RtlpWorkerThreadTimerCallback(), RtlQueueWorkItem(), RtlSetIoCompletionCallback(), and RtlThreadPoolCleanup().

ULONG NumWorkRequests

Definition at line 229 of file threads.h. Referenced by RtlpExecuteWorkerRequest(), RtlpQueueWorkerRequest(), RtlpWorkerThread(), RtlQueueWorkItem(), and RtlThreadPoolCleanup().

ULONG OldTotalExecutedWorkRequests

Definition at line 233 of file threads.h. Referenced by RtlpWorkerThreadTimerCallback().

PRTLP_IOWORKER_TCB PersistentIOTCB

Definition at line 244 of file threads.h. Referenced by RtlpQueueIOWorkerRequest(), and RtlQueueWorkItem().

LARGE_INTEGER Resync64BitTickCount

Definition at line 384 of file threads.h. Referenced by RtlpInitializeTimerThreadPool(), and RtlpResync64BitTickCount().

RTLP_EXIT_THREAD RtlpExitThread

Definition at line 262 of file threads.h.

PRTLP_EXIT_THREAD RtlpExitThreadFunc = RtlpExitThread

Definition at line 263 of file threads.h. Referenced by RtlpIOWorkerThread(), RtlpWaitThread(), RtlpWorkerThread(), and RtlSetThreadPoolStartFunc().

PRTLP_EVENT RtlpGetWaitEvent(VOID)

RTLP_START_THREAD RtlpStartThread

Definition at line 260 of file threads.h.

PRTLP_START_THREAD RtlpStartThreadFunc = RtlpStartThread

Definition at line 261 of file threads.h. Referenced by RtlpFindWaitThread(), RtlpInitializeTimerThreadPool(), RtlpStartIOWorkerThread(), RtlpStartWorkerThread(), and RtlSetThreadPoolStartFunc().

ULONG StartedEventCacheInitialization

Definition at line 218 of file threads.h. Referenced by RtlpInitializeEventCache().

ULONG StartedTimerInitialization

Definition at line 215 of file threads.h. Referenced by RtlpInitializeTimerThreadPool(), and RtlThreadPoolCleanup().

ULONG StartedTPInitialization

Definition at line 206 of file threads.h.

ULONG StartedWaitInitialization

Definition at line 212 of file threads.h. Referenced by RtlpInitializeWaitThreadPool(), and RtlThreadPoolCleanup().

ULONG StartedWorkerInitialization

Definition at line 209 of file threads.h. Referenced by RtlpInitializeWorkerThreadPool(), and RtlThreadPoolCleanup().

RTL_CRITICAL_SECTION TimerCriticalSection

Definition at line 257 of file threads.h. Referenced by RtlpInitializeTimerThreadPool().

HANDLE TimerHandle

Definition at line 252 of file threads.h. Referenced by NtCancelTimer(), NtCreateTimer(), NtOpenTimer(), NtQueryTimer(), NtSetTimer(), RtlDebugPrintTimes(), RtlpAddTimer(), RtlpDeactivateTimer(), RtlpDeleteTimerQueue(), RtlpGetTimeRemaining(), RtlpInitializeTimerThreadPool(), RtlpResetTimer(), RtlpServiceTimer(), RtlpTimerThread(), and RtlpUpdateTimer().

LIST_ENTRY TimerQueues

Definition at line 251 of file threads.h. Referenced by RtlDebugPrintTimes(), RtlpAddTimer(), RtlpDeactivateTimer(), RtlpDeleteTimerQueue(), RtlpGetQueueRelativeTime(), RtlpInitializeTimerThreadPool(), RtlpServiceTimer(), and RtlpUpdateTimer().

HANDLE TimerThreadHandle

Definition at line 221 of file threads.h. Referenced by RtlCreateTimer(), RtlDebugPrintTimes(), RtlDeleteTimer(), RtlDeleteTimerQueueEx(), RtlpInitializeTimerThreadPool(), RtlpQueueWorkerRequest(), RtlThreadPoolCleanup(), and RtlUpdateTimer().

ULONG TimerThreadId

Definition at line 222 of file threads.h. Referenced by RtlDebugPrintTimes(), and RtlpTimerThread().

ULONG TotalExecutedWorkRequests

Definition at line 232 of file threads.h. Referenced by RtlpWorkerThread(), and RtlpWorkerThreadTimerCallback().

RTL_CRITICAL_SECTION WaitCriticalSection

Definition at line 256 of file threads.h. Referenced by RtlpInitializeWaitThreadPool().

LIST_ENTRY WaitThreads

Definition at line 247 of file threads.h. Referenced by RtlpFindWaitThread(), RtlpInitializeWaitThreadPool(), RtlpWaitThread(), and RtlThreadPoolCleanup().

HANDLE WorkerCompletionPort

Definition at line 245 of file threads.h. Referenced by RtlpInitializeWorkerThreadPool(), RtlpQueueWorkerRequest(), RtlpWorkerThread(), RtlpWorkerThreadTimerCallback(), RtlSetIoCompletionCallback(), and RtlThreadPoolCleanup().

RTL_CRITICAL_SECTION WorkerCriticalSection

Definition at line 255 of file threads.h. Referenced by RtlpInitializeWorkerThreadPool(), RtlpIOWorkerThread(), RtlpWorkerThread(), RtlpWorkerThreadTimerCallback(), RtlQueueWorkItem(), RtlSetIoCompletionCallback(), and RtlThreadPoolCleanup().

HANDLE WorkerThreadTimer

Definition at line 237 of file threads.h. Referenced by RtlpWorkerThreadInitializeTimers().

HANDLE WorkerThreadTimerQueue

Definition at line 234 of file threads.h. Referenced by RtlpWorkerThreadInitializeTimers().

ULONG WorkerThreadTimerQueueInit

Definition at line 235 of file threads.h. Referenced by RtlpInitializeWorkerThreadPool().

---