able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/srv/worker.c

831 lines
20 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
worker.c
Abstract:
This module implements the LAN Manager server FSP worker thread
function. It also implements routines for managing (i.e., starting
and stopping) worker threads, and balancing load.
Author:
Chuck Lenzmeier (chuckl) 01-Oct-1989
David Treadwell (davidtr)
Environment:
Kernel mode
Revision History:
--*/
#include "precomp.h"
#include "worker.tmh"
#pragma hdrstop
#define BugCheckFileId SRV_FILE_WORKER
//
// Local declarations
//
NTSTATUS
CreateQueueThread (
IN PWORK_QUEUE Queue
);
VOID
InitializeWorkerThread (
IN PWORK_QUEUE WorkQueue,
IN KPRIORITY ThreadPriority
);
VOID
WorkerThread (
IN PWORK_QUEUE WorkQueue
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, SrvCreateWorkerThreads )
#pragma alloc_text( PAGE, CreateQueueThread )
#pragma alloc_text( PAGE, InitializeWorkerThread )
#pragma alloc_text( PAGE, WorkerThread )
#endif
#if 0
NOT PAGEABLE -- SrvQueueWorkToBlockingThread
NOT PAGEABLE -- SrvQueueWorkToFsp
NOT PAGEABLE -- SrvQueueWorkToFspAtSendCompletion
NOT PAGEABLE -- SrvBalanceLoad
#endif
NTSTATUS
SrvCreateWorkerThreads (
VOID
)
/*++
Routine Description:
This function creates the worker threads for the LAN Manager server
FSP.
Arguments:
None.
Return Value:
NTSTATUS - Status of thread creation
--*/
{
NTSTATUS status;
PWORK_QUEUE queue;
PAGED_CODE( );
//
// Create the nonblocking worker threads.
//
for( queue = SrvWorkQueues; queue < eSrvWorkQueues; queue++ ) {
status = CreateQueueThread( queue );
if( !NT_SUCCESS( status ) ) {
return status;
}
}
//
// Create the blocking worker threads
//
return CreateQueueThread( &SrvBlockingWorkQueue );
} // SrvCreateWorkerThreads
NTSTATUS
CreateQueueThread (
IN PWORK_QUEUE Queue
)
/*++
Routine Description:
This function creates a worker thread to service a queue.
NOTE: The scavenger occasionally kills off threads on a queue. If logic
here is modified, you may need to look there too.
Arguments:
Queue - the queue to service
Return Value:
NTSTATUS - Status of thread creation
--*/
{
HANDLE threadHandle;
LARGE_INTEGER interval;
NTSTATUS status;
PAGED_CODE();
//
// Another thread is coming into being. Keep the counts up to date
//
InterlockedIncrement( &Queue->Threads );
InterlockedIncrement( &Queue->AvailableThreads );
status = PsCreateSystemThread(
&threadHandle,
PROCESS_ALL_ACCESS,
NULL,
NtCurrentProcess(),
NULL,
WorkerThread,
Queue
);
if ( !NT_SUCCESS(status) ) {
INTERNAL_ERROR(
ERROR_LEVEL_EXPECTED,
"CreateQueueThread: PsCreateSystemThread for "
"queue %X returned %X",
Queue,
status
);
InterlockedDecrement( &Queue->Threads );
InterlockedDecrement( &Queue->AvailableThreads );
SrvLogServiceFailure( SRV_SVC_PS_CREATE_SYSTEM_THREAD, status );
return status;
}
//
// Close the handle so the thread can die when needed
//
SrvNtClose( threadHandle, FALSE );
//
// If we just created the first queue thread, wait for it
// to store its thread pointer in IrpThread. This pointer is
// stored in all IRPs issued for this queue by the server.
//
while ( Queue->IrpThread == NULL ) {
interval.QuadPart = -1*10*1000*10; // .01 second
KeDelayExecutionThread( KernelMode, FALSE, &interval );
}
return STATUS_SUCCESS;
} // CreateQueueThread
VOID
InitializeWorkerThread (
IN PWORK_QUEUE WorkQueue,
IN KPRIORITY ThreadPriority
)
{
NTSTATUS status;
KPRIORITY basePriority;
PAGED_CODE( );
#if SRVDBG_LOCK
{
//
// Create a special system thread TEB. The size of this TEB is just
// large enough to accommodate the first three user-reserved
// longwords. These three locations are used for lock debugging. If
// the allocation fails, then no lock debugging will be performed
// for this thread.
//
//
PETHREAD Thread = PsGetCurrentThread( );
ULONG TebSize = FIELD_OFFSET( TEB, UserReserved[0] ) + SRV_TEB_USER_SIZE;
Thread->Tcb.Teb = ExAllocatePoolWithTag( NonPagedPool, TebSize, BlockTypeMisc );
if ( Thread->Tcb.Teb != NULL ) {
RtlZeroMemory( Thread->Tcb.Teb, TebSize );
}
}
#endif // SRVDBG_LOCK
//
// Set this thread's priority.
//
basePriority = ThreadPriority;
status = NtSetInformationThread (
NtCurrentThread( ),
ThreadBasePriority,
&basePriority,
sizeof(basePriority)
);
if ( !NT_SUCCESS(status) ) {
INTERNAL_ERROR(
ERROR_LEVEL_UNEXPECTED,
"InitializeWorkerThread: NtSetInformationThread failed: %X\n",
status,
NULL
);
SrvLogServiceFailure( SRV_SVC_NT_SET_INFO_THREAD, status );
}
#if MULTIPROCESSOR
//
// If this is a nonblocking worker thread, set its ideal processor affinity. Setting
// ideal affinity informs ntos that the thread would rather run on its ideal
// processor if reasonable, but if ntos can't schedule it on that processor then it is
// ok to schedule it on a different processor.
//
if( SrvNumberOfProcessors > 1 && WorkQueue >= SrvWorkQueues && WorkQueue < eSrvWorkQueues ) {
KeSetIdealProcessorThread( KeGetCurrentThread(), (CCHAR)(WorkQueue - SrvWorkQueues) );
}
#endif
//
// Disable hard error popups for this thread.
//
IoSetThreadHardErrorMode( FALSE );
return;
} // InitializeWorkerThread
VOID
WorkerThread (
IN PWORK_QUEUE WorkQueue
)
{
PLIST_ENTRY listEntry;
PWORK_CONTEXT workContext;
ULONG timeDifference;
ULONG updateSmbCount = 0;
ULONG updateTime = 0;
ULONG iAmBlockingThread = (WorkQueue == &SrvBlockingWorkQueue);
PLARGE_INTEGER Timeout = NULL;
PAGED_CODE();
//
// If this is the first worker thread, save the thread pointer.
//
if( WorkQueue->IrpThread == NULL ) {
WorkQueue->IrpThread = PsGetCurrentThread( );
}
InitializeWorkerThread( WorkQueue, SrvThreadPriority );
//
// If we are the IrpThread, we don't want to die
//
if( WorkQueue->IrpThread != PsGetCurrentThread( ) ) {
Timeout = &WorkQueue->IdleTimeOut;
}
//
// Loop infinitely dequeueing and processing work items.
//
while ( TRUE ) {
listEntry = KeRemoveQueue(
&WorkQueue->Queue,
WorkQueue->WaitMode,
Timeout
);
if( (ULONG_PTR)listEntry == STATUS_TIMEOUT ) {
//
// We have a non critical thread that hasn't gotten any work for
// awhile. Time to die.
//
InterlockedDecrement( &WorkQueue->AvailableThreads );
InterlockedDecrement( &WorkQueue->Threads );
SrvTerminateWorkerThread( NULL );
}
if( InterlockedDecrement( &WorkQueue->AvailableThreads ) == 0 &&
!SrvFspTransitioning &&
WorkQueue->Threads < WorkQueue->MaxThreads ) {
//
// We are running low on threads for this queue. Spin up
// another one before handling this request
//
CreateQueueThread( WorkQueue );
}
//
// Get the address of the work item.
//
workContext = CONTAINING_RECORD(
listEntry,
WORK_CONTEXT,
ListEntry
);
ASSERT( KeGetCurrentIrql() == 0 );
//
// There is work available. It may be a work contect block or
// an RFCB. (Blocking threads won't get RFCBs.)
//
ASSERT( (GET_BLOCK_TYPE(workContext) == BlockTypeWorkContextInitial) ||
(GET_BLOCK_TYPE(workContext) == BlockTypeWorkContextNormal) ||
(GET_BLOCK_TYPE(workContext) == BlockTypeWorkContextRaw) ||
(GET_BLOCK_TYPE(workContext) == BlockTypeWorkContextSpecial) ||
(GET_BLOCK_TYPE(workContext) == BlockTypeRfcb) );
#if DBG
if ( GET_BLOCK_TYPE( workContext ) == BlockTypeRfcb ) {
((PRFCB)workContext)->ListEntry.Flink =
((PRFCB)workContext)->ListEntry.Blink = NULL;
}
#endif
IF_DEBUG(WORKER1) {
KdPrint(( "WorkerThread working on work context %p", workContext ));
}
//
// Make sure we have a resaonable idea of the system time
//
if( ++updateTime == TIME_SMB_INTERVAL ) {
updateTime = 0;
SET_SERVER_TIME( WorkQueue );
}
//
// Update statistics.
//
if ( ++updateSmbCount == STATISTICS_SMB_INTERVAL ) {
updateSmbCount = 0;
GET_SERVER_TIME( WorkQueue, &timeDifference );
timeDifference = timeDifference - workContext->Timestamp;
++(WorkQueue->stats.WorkItemsQueued.Count);
WorkQueue->stats.WorkItemsQueued.Time.QuadPart += timeDifference;
}
{
//
// Put the workContext out relative to bp so we can find it later if we need
// to debug. The block of memory we're writing to is likely already in cache,
// so this should be relatively cheap.
//
PWORK_CONTEXT volatile savedWorkContext;
savedWorkContext = workContext;
}
//
// Make sure the WorkContext knows if it is on the blocking work queue
//
workContext->UsingBlockingThread = iAmBlockingThread;
//
// Call the restart routine for the work item.
//
IF_SMB_DEBUG( TRACE ) {
KdPrint(( "Blocking %d, Count %d -> %p( %p )\n",
iAmBlockingThread,
workContext->ProcessingCount,
workContext->FspRestartRoutine,
workContext
));
}
workContext->FspRestartRoutine( workContext );
//
// Make sure we are still at normal level.
//
ASSERT( KeGetCurrentIrql() == 0 );
//
// We're getting ready to be available (i.e. waiting on the queue)
//
InterlockedIncrement( &WorkQueue->AvailableThreads );
}
} // WorkerThread
VOID SRVFASTCALL
SrvQueueWorkToBlockingThread (
IN OUT PWORK_CONTEXT WorkContext
)
/*++
Routine Description:
This routine queues a work item to a blocking thread. These threads
are used to service requests that may block for a long time, so we
don't want to tie up our normal worker threads.
Arguments:
WorkContext - Supplies a pointer to the work context block
representing the work item
Return Value:
None.
--*/
{
//
// Increment the processing count.
//
WorkContext->ProcessingCount++;
//
// Insert the work item at the tail of the blocking work queue.
//
SrvInsertWorkQueueTail(
&SrvBlockingWorkQueue,
(PQUEUEABLE_BLOCK_HEADER)WorkContext
);
return;
} // SrvQueueWorkToBlockingThread
VOID SRVFASTCALL
SrvQueueWorkToFsp (
IN OUT PWORK_CONTEXT WorkContext
)
/*++
Routine Description:
This is the restart routine for work items that are to be queued to
a nonblocking worker thread in the FSP. This function is also
called from elsewhere in the server to transfer work to the FSP.
This function should not be called at dispatch level -- use
SrvQueueWorkToFspAtDpcLevel instead.
Arguments:
WorkContext - Supplies a pointer to the work context block
representing the work item
Return Value:
None.
--*/
{
//
// Increment the processing count.
//
WorkContext->ProcessingCount++;
//
// Insert the work item at the tail of the nonblocking work queue.
//
if( WorkContext->QueueToHead ) {
SrvInsertWorkQueueHead(
WorkContext->CurrentWorkQueue,
(PQUEUEABLE_BLOCK_HEADER)WorkContext
);
} else {
SrvInsertWorkQueueTail(
WorkContext->CurrentWorkQueue,
(PQUEUEABLE_BLOCK_HEADER)WorkContext
);
}
} // SrvQueueWorkToFsp
NTSTATUS
SrvQueueWorkToFspAtSendCompletion (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PWORK_CONTEXT WorkContext
)
/*++
Routine Description:
Send completion handler for work items that are to be queued to
a nonblocking worker thread in the FSP. This function is also
called from elsewhere in the server to transfer work to the FSP.
This function should not be called at dispatch level -- use
SrvQueueWorkToFspAtDpcLevel instead.
Arguments:
DeviceObject - Pointer to target device object for the request.
Irp - Pointer to I/O request packet
WorkContext - Caller-specified context parameter associated with IRP.
This is actually a pointer to a Work Context block.
Return Value:
STATUS_MORE_PROCESSING_REQUIRED.
--*/
{
//
// Check the status of the send completion.
//
CHECK_SEND_COMPLETION_STATUS( Irp->IoStatus.Status );
//
// Reset the IRP cancelled bit.
//
Irp->Cancel = FALSE;
//
// Increment the processing count.
//
WorkContext->ProcessingCount++;
//
// Insert the work item on the nonblocking work queue.
//
if( WorkContext->QueueToHead ) {
SrvInsertWorkQueueHead(
WorkContext->CurrentWorkQueue,
(PQUEUEABLE_BLOCK_HEADER)WorkContext
);
} else {
SrvInsertWorkQueueTail(
WorkContext->CurrentWorkQueue,
(PQUEUEABLE_BLOCK_HEADER)WorkContext
);
}
return STATUS_MORE_PROCESSING_REQUIRED;
} // SrvQueueWorkToFspAtSendCompletion
VOID SRVFASTCALL
SrvTerminateWorkerThread (
IN OUT PWORK_CONTEXT WorkItem OPTIONAL
)
/*++
Routine Description:
This routine is called when a thread is being requested to terminate. There
are two cases when this happens. One is at server shutdown -- in this
case we need to keep requeueing the termination request until all the
threads on the queue have terminated. The other time is if a thread has
not received work for some amount of time.
--*/
{
LONG priority = 16;
//
// Raise our priority to ensure that this thread has a chance to get completely
// done before the main thread causes the driver to unload or something
//
NtSetInformationThread (
NtCurrentThread( ),
ThreadBasePriority,
&priority,
sizeof(priority)
);
if( ARGUMENT_PRESENT( WorkItem ) &&
InterlockedDecrement( &WorkItem->CurrentWorkQueue->Threads ) != 0 ) {
//
// We are being asked to terminate all of the worker threads on this queue.
// So, if we're not the last thread, we should requeue the workitem so
// the other threads will terminate
//
//
// There are still other threads servicing this queue, so requeue
// the workitem
//
SrvInsertWorkQueueTail( WorkItem->CurrentWorkQueue,
(PQUEUEABLE_BLOCK_HEADER)WorkItem );
}
PsTerminateSystemThread( STATUS_SUCCESS ); // no return;
}
#if MULTIPROCESSOR
VOID
SrvBalanceLoad(
IN PCONNECTION connection
)
/*++
Routine Description:
Ensure that the processor handling 'connection' is the best one
for the job. This routine is called periodically per connection from
DPC level. It can not be paged.
Arguments:
connection - the connection to inspect
Return Value:
none.
--*/
{
ULONG MyQueueLength, OtherQueueLength;
ULONG i;
PWORK_QUEUE tmpqueue;
PWORK_QUEUE queue = connection->CurrentWorkQueue;
ASSERT( queue >= SrvWorkQueues );
ASSERT( queue < eSrvWorkQueues );
//
// Reset the countdown. After the client performs BalanceCount
// more operations, we'll call this routine again.
//
connection->BalanceCount = SrvBalanceCount;
//
// Figure out the load on the current work queue. The load is
// the sum of the average work queue depth and the current work
// queue depth. This gives us some history mixed in with the
// load *right now*
//
MyQueueLength = queue->AvgQueueDepthSum >> LOG2_QUEUE_SAMPLES;
MyQueueLength += KeReadStateQueue( &queue->Queue );
//
// If we are not on our preferred queue, look to see if we want to
// go back to it. The preferred queue is the queue for the processor
// handling this client's network card DPCs. We prefer to run on that
// processor to avoid sloshing data between CPUs in an MP system.
//
tmpqueue = connection->PreferredWorkQueue;
ASSERT( tmpqueue >= SrvWorkQueues );
ASSERT( tmpqueue < eSrvWorkQueues );
if( tmpqueue != queue ) {
//
// We are not queueing to our preferred queue. See if we
// should go back to our preferred queue
//
ULONG PreferredQueueLength;
PreferredQueueLength = tmpqueue->AvgQueueDepthSum >> LOG2_QUEUE_SAMPLES;
PreferredQueueLength += KeReadStateQueue( &tmpqueue->Queue );
if( PreferredQueueLength <= MyQueueLength + SrvPreferredAffinity ) {
//
// We want to switch back to our preferred processor!
//
IF_DEBUG( REBALANCE ) {
KdPrint(( "%p C%d(%p) > P%p(%d)\n",
connection,
MyQueueLength,
(PVOID)(connection->CurrentWorkQueue - SrvWorkQueues),
(PVOID)(tmpqueue - SrvWorkQueues),
PreferredQueueLength ));
}
InterlockedDecrement( &queue->CurrentClients );
InterlockedExchangePointer( &connection->CurrentWorkQueue, tmpqueue );
InterlockedIncrement( &tmpqueue->CurrentClients );
SrvReBalanced++;
return;
}
}
//
// We didn't hop to the preferred processor, so let's see if
// another processor looks more lightly loaded than we are.
//
//
// SrvNextBalanceProcessor is the next processor we should consider
// moving to. It is a global to ensure everybody doesn't pick the
// the same processor as the next candidate.
//
tmpqueue = &SrvWorkQueues[ SrvNextBalanceProcessor ];
//
// Advance SrvNextBalanceProcessor to the next processor in the system
//
i = SrvNextBalanceProcessor + 1;
if( i >= SrvNumberOfProcessors )
i = 0;
SrvNextBalanceProcessor = i;
//
// Look at the other processors, and pick the next one which is doing
// enough less work than we are to make the jump worthwhile
//
for( i = SrvNumberOfProcessors; i > 1; --i ) {
ASSERT( tmpqueue >= SrvWorkQueues );
ASSERT( tmpqueue < eSrvWorkQueues );
OtherQueueLength = tmpqueue->AvgQueueDepthSum >> LOG2_QUEUE_SAMPLES;
OtherQueueLength += KeReadStateQueue( &tmpqueue->Queue );
if( OtherQueueLength + SrvOtherQueueAffinity < MyQueueLength ) {
//
// This processor looks promising. Switch to it
//
IF_DEBUG( REBALANCE ) {
KdPrint(( "%p %c%p(%d) > %c%p(%d)\n",
connection,
queue == connection->PreferredWorkQueue ? 'P' : 'C',
(PVOID)(queue - SrvWorkQueues),
MyQueueLength,
tmpqueue == connection->PreferredWorkQueue ? 'P' : 'C',
(PVOID)(tmpqueue - SrvWorkQueues),
OtherQueueLength ));
}
InterlockedDecrement( &queue->CurrentClients );
InterlockedExchangePointer( &connection->CurrentWorkQueue, tmpqueue );
InterlockedIncrement( &tmpqueue->CurrentClients );
SrvReBalanced++;
return;
}
if( ++tmpqueue == eSrvWorkQueues )
tmpqueue = SrvWorkQueues;
}
//
// No rebalancing necessary
//
return;
}
#endif
Reference in a new issue Copy permalink