able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/nw/rdr/workque.c

1168 lines
25 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
Workque.c
Abstract:
This module implements the queue of work from the FSD to the
FSP threads (system worker threads) for the NetWare redirector.
Author:
Colin Watson [ColinW] 19-Dec-1992
Revision History:
--*/
#include "Procs.h"
LIST_ENTRY IrpContextList;
KSPIN_LOCK IrpContextInterlock;
KSPIN_LOCK ContextInterlock;
LONG FreeContextCount = 4; // Allow up to 4 free contexts
LIST_ENTRY MiniIrpContextList;
LONG FreeMiniContextCount = 20; // Allow up to 20 free mini contexts
LONG MiniContextCount = 0; // Allow up to 20 free mini contexts
HANDLE WorkerThreadHandle;
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_WORKQUE)
#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, InitializeIrpContext )
#pragma alloc_text( PAGE, UninitializeIrpContext )
#pragma alloc_text( PAGE, NwAppendToQueueAndWait )
#pragma alloc_text( PAGE, WorkerThread )
#ifndef QFE_BUILD
//
//#pragma alloc_text( PAGE1, NwDequeueIrpContext )
//We hold a spinlock coming in or we acquire one inside the function
//So, this should be non-paged.
//
#pragma alloc_text( PAGE1, AllocateMiniIrpContext )
#pragma alloc_text( PAGE1, FreeMiniIrpContext )
#endif
#endif
#if 0 // Not pageable
AllocateIrpContext
FreeIrpContext
NwCompleteRequest
SpawnWorkerThread
// see ifndef QFE_BUILD above
#endif
PIRP_CONTEXT
AllocateIrpContext (
PIRP pIrp
)
/*++
Routine Description:
Initialize a work queue structure, allocating all structures used for it.
Arguments:
pIrp - Supplies the Irp for the applications request
Return Value:
PIRP_CONTEXT - Newly allocated Irp Context.
--*/
{
PIRP_CONTEXT IrpContext;
if ((IrpContext = (PIRP_CONTEXT )ExInterlockedRemoveHeadList(&IrpContextList, &IrpContextInterlock)) == NULL) {
try {
//
// If there are no IRP contexts in the "zone", allocate a new
// Irp context from non paged pool.
//
IrpContext = ALLOCATE_POOL_EX(NonPagedPool, sizeof(IRP_CONTEXT));
RtlFillMemory( IrpContext, sizeof(IRP_CONTEXT), 0 );
IrpContext->TxMdl = NULL;
IrpContext->RxMdl = NULL;
KeInitializeEvent( &IrpContext->Event, SynchronizationEvent, FALSE );
IrpContext->NodeTypeCode = NW_NTC_IRP_CONTEXT;
IrpContext->NodeByteSize = sizeof(IRP_CONTEXT);
IrpContext->TxMdl = ALLOCATE_MDL( &IrpContext->req, MAX_SEND_DATA, FALSE, FALSE, NULL );
if ( IrpContext->TxMdl == NULL) {
InternalError(("Could not allocate TxMdl for IRP context\n"));
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
IrpContext->RxMdl = ALLOCATE_MDL( &IrpContext->rsp, MAX_RECV_DATA, FALSE, FALSE, NULL );
if ( IrpContext->RxMdl == NULL) {
InternalError(("Could not allocate RxMdl for IRP context\n"));
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
} finally {
if ( AbnormalTermination() ) {
if ( IrpContext != NULL ) {
if (IrpContext->TxMdl != NULL ) {
FREE_MDL( IrpContext->TxMdl );
}
FREE_POOL( IrpContext );
} else {
InternalError(("Could not allocate pool for IRP context\n"));
}
}
}
MmBuildMdlForNonPagedPool(IrpContext->TxMdl);
MmBuildMdlForNonPagedPool(IrpContext->RxMdl);
#ifdef NWDBG
// Make it easy to find fields in the context
IrpContext->Signature1 = 0xfeedf00d;
IrpContext->Signature2 = 0xfeedf00d;
IrpContext->Signature3 = 0xfeedf00d;
#endif
// IrpContext is allocated. Finish off initialization.
} else {
// Record that we have removed an entry from the free list
InterlockedIncrement(&FreeContextCount);
ASSERT( IrpContext != NULL );
//
// The free list uses the start of the structure for the list entry
// so restore corrupted fields.
//
IrpContext->NodeTypeCode = NW_NTC_IRP_CONTEXT;
IrpContext->NodeByteSize = sizeof(IRP_CONTEXT);
// Ensure mdl's are clean
IrpContext->TxMdl->Next = NULL;
IrpContext->RxMdl->Next = NULL;
IrpContext->RxMdl->ByteCount = MAX_RECV_DATA;
//
// Clean "used" fields
//
IrpContext->Flags = 0;
IrpContext->Icb = NULL;
IrpContext->pEx = NULL;
IrpContext->TimeoutRoutine = NULL;
IrpContext->CompletionSendRoutine = NULL;
IrpContext->ReceiveDataRoutine = NULL;
IrpContext->pTdiStruct = NULL;
//
// Clean the specific data zone.
//
RtlZeroMemory( &(IrpContext->Specific), sizeof( IrpContext->Specific ) );
// 8/13/96 cjc Fix problem with apps not being able to save
// files to NDS drives. This was never reset so
// ExchangeWithWait ret'd an error to WriteNCP.
IrpContext->ResponseParameters.Error = 0;
}
InterlockedIncrement(&ContextCount);
//
// Save away the fields in the Irp that might be tromped by
// building the Irp for the exchange with the server.
//
IrpContext->pOriginalIrp = pIrp;
if ( pIrp != NULL) {
IrpContext->pOriginalSystemBuffer = pIrp->AssociatedIrp.SystemBuffer;
IrpContext->pOriginalUserBuffer = pIrp->UserBuffer;
IrpContext->pOriginalMdlAddress = pIrp->MdlAddress;
}
#ifdef NWDBG
IrpContext->pNpScb = NULL;
#endif
ASSERT( !BooleanFlagOn( IrpContext->Flags, IRP_FLAG_ON_SCB_QUEUE ) );
return IrpContext;
}
VOID
FreeIrpContext (
PIRP_CONTEXT IrpContext
)
/*++
Routine Description:
Initialize a work queue structure, allocating all structures used for it.
Arguments:
PIRP_CONTEXT IrpContext - Irp Context to free.
None
Return Value:
--*/
{
ASSERT( IrpContext->NodeTypeCode == NW_NTC_IRP_CONTEXT );
ASSERT( !BooleanFlagOn( IrpContext->Flags, IRP_FLAG_ON_SCB_QUEUE ) );
ASSERT( IrpContext->PostProcessRoutine == NULL );
FreeReceiveIrp( IrpContext );
#ifdef NWDBG
IrpContext->DebugValue = 0;
#endif
IrpContext->Flags = 0;
//
// Cleanup the Irp needs to be restored to its original settings.
//
if ( IrpContext->pOriginalIrp != NULL ) {
PIRP pIrp = IrpContext->pOriginalIrp;
pIrp->AssociatedIrp.SystemBuffer = IrpContext->pOriginalSystemBuffer;
pIrp->UserBuffer = IrpContext->pOriginalUserBuffer;
pIrp->MdlAddress = IrpContext->pOriginalMdlAddress;
#ifdef NWDBG
IrpContext->pOriginalIrp = NULL;
#endif
}
#ifdef NWDBG
RtlZeroMemory( &IrpContext->WorkQueueItem, sizeof( WORK_QUEUE_ITEM ) );
#endif
InterlockedDecrement(&ContextCount);
if ( InterlockedDecrement(&FreeContextCount) >= 0 ) {
//
// We use the first two longwords of the IRP context as a list entry
// when we free it to the list.
//
ExInterlockedInsertTailList(&IrpContextList,
(PLIST_ENTRY )IrpContext,
&IrpContextInterlock);
} else {
//
// We already have as many free context as we allow so destroy
// this context. Restore FreeContextCount to its original value.
//
InterlockedIncrement( &FreeContextCount );
FREE_MDL( IrpContext->TxMdl );
FREE_MDL( IrpContext->RxMdl );
FREE_POOL(IrpContext);
#ifdef NWDBG
ContextCount --;
#endif
}
}
VOID
InitializeIrpContext (
VOID
)
/*++
Routine Description:
Initialize the Irp Context system
Arguments:
None.
Return Value:
None.
--*/
{
PAGED_CODE();
KeInitializeSpinLock(&IrpContextInterlock);
KeInitializeSpinLock(&ContextInterlock);
InitializeListHead(&IrpContextList);
InitializeListHead(&MiniIrpContextList);
}
VOID
UninitializeIrpContext (
VOID
)
/*++
Routine Description:
Initialize the Irp Context system
Arguments:
None.
Return Value:
None.
--*/
{
PIRP_CONTEXT IrpContext;
PLIST_ENTRY ListEntry;
PMINI_IRP_CONTEXT MiniIrpContext;
PAGED_CODE();
//
// Free all the IRP contexts.
//
while ( !IsListEmpty( &IrpContextList ) ) {
IrpContext = (PIRP_CONTEXT)RemoveHeadList( &IrpContextList );
FREE_MDL( IrpContext->TxMdl );
FREE_MDL( IrpContext->RxMdl );
FREE_POOL(IrpContext);
}
while ( !IsListEmpty( &MiniIrpContextList ) ) {
ListEntry = RemoveHeadList( &MiniIrpContextList );
MiniIrpContext = CONTAINING_RECORD( ListEntry, MINI_IRP_CONTEXT, Next );
FREE_POOL( MiniIrpContext->Buffer );
FREE_MDL( MiniIrpContext->Mdl2 );
FREE_MDL( MiniIrpContext->Mdl1 );
FREE_IRP( MiniIrpContext->Irp );
FREE_POOL( MiniIrpContext );
}
}
VOID
NwCompleteRequest (
PIRP_CONTEXT IrpContext,
NTSTATUS Status
)
/*++
Routine Description:
The following procedure is used by the FSP and FSD routines to complete
an IRP.
Arguments:
IrpContext - A pointer to the IRP context information.
Status - The status to use to complete the IRP.
Return Value:
None.
--*/
{
PIRP Irp;
if ( IrpContext == NULL ) {
return;
}
if ( Status == STATUS_PENDING ) {
return;
}
if ( Status == STATUS_INSUFFICIENT_RESOURCES ) {
Error( EVENT_NWRDR_RESOURCE_SHORTAGE, Status, NULL, 0, 0 );
}
Irp = IrpContext->pOriginalIrp;
Irp->IoStatus.Status = Status;
DebugTrace(0, Dbg, "Completing Irp with status %X\n", Status );
// Restore the Irp to its original state
if ((Irp->CurrentLocation) > (CCHAR) (Irp->StackCount +1)) {
DbgPrint("Irp is already completed.\n", Irp);
DbgBreakPoint();
}
FreeIrpContext( IrpContext );
IoCompleteRequest ( Irp, IO_NETWORK_INCREMENT );
return;
}
VOID
NwAppendToQueueAndWait(
PIRP_CONTEXT IrpContext
)
/*++
Routine Description:
This routine appends an IrpContext to the SCB queue, and waits the
the queue to be ready to process the Irp.
Arguments:
IrpContext - A pointer to the IRP context information.
Return Value:
None.
--*/
{
BOOLEAN AtFront;
PAGED_CODE();
DebugTrace(+1, Dbg, "NwAppendToQueueAndWait\n", 0);
IrpContext->RunRoutine = SetEvent;
#ifdef MSWDBG
ASSERT( IrpContext->Event.Header.SignalState == 0 );
#endif
AtFront = AppendToScbQueue( IrpContext, IrpContext->pNpScb );
if ( AtFront ) {
KickQueue( IrpContext->pNpScb );
}
//
// Wait until we get to the front of the queue.
//
KeWaitForSingleObject(
&IrpContext->Event,
UserRequest,
KernelMode,
FALSE,
NULL );
ASSERT( IrpContext->pNpScb->Requests.Flink == &IrpContext->NextRequest );
DebugTrace(-1, Dbg, "NwAppendToQueueAndWait\n", 0);
return;
}
VOID
NwDequeueIrpContext(
IN PIRP_CONTEXT pIrpContext,
IN BOOLEAN OwnSpinLock
)
/*++
Routine Description:
This routine removes an IRP Context from the front the SCB queue.
Arguments:
IrpContext - A pointer to the IRP context information.
OwnSpinLock - If TRUE, the caller owns the SCB spin lock.
Return Value:
None.
--*/
{
PLIST_ENTRY pListEntry;
KIRQL OldIrql;
PNONPAGED_SCB pNpScb;
DebugTrace(+1, Dbg, "NwDequeueIrpContext\n", 0);
if (!BooleanFlagOn( pIrpContext->Flags, IRP_FLAG_ON_SCB_QUEUE ) ) {
DebugTrace(-1, Dbg, "NwDequeueIrpContext\n", 0);
return;
}
pNpScb = pIrpContext->pNpScb;
if ( !OwnSpinLock ) {
KeAcquireSpinLock( &pNpScb->NpScbSpinLock, &OldIrql );
}
//
// Disable timer from looking at this queue.
//
pNpScb->OkToReceive = FALSE;
pListEntry = RemoveHeadList( &pNpScb->Requests );
if ( !OwnSpinLock ) {
KeReleaseSpinLock( &pNpScb->NpScbSpinLock, OldIrql );
}
#ifdef NWDBG
ASSERT ( CONTAINING_RECORD( pListEntry, IRP_CONTEXT, NextRequest ) == pIrpContext );
{
PIRP_CONTEXT RemovedContext = CONTAINING_RECORD( pListEntry, IRP_CONTEXT, NextRequest );
if ( RemovedContext != pIrpContext ) {
DbgBreakPoint();
}
}
DebugTrace(
0,
Dbg,
"Dequeued IRP Context %08lx\n",
CONTAINING_RECORD( pListEntry, IRP_CONTEXT, NextRequest ) );
#ifdef MSWDBG
pNpScb->RequestDequeued = TRUE;
#endif
#endif
ClearFlag( pIrpContext->Flags, IRP_FLAG_ON_SCB_QUEUE );
//
// Give the next IRP context on the SCB queue a chance to run.
//
KickQueue( pNpScb );
DebugTrace(-1, Dbg, "NwDequeueIrpContext\n", 0);
return;
}
VOID
NwCancelIrp (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine implements the cancel function for an IRP being processed
by the redirector.
Arguments:
DeviceObject - ignored
Irp - Supplies the Irp being cancelled.
Return Value:
None.
--*/
{
PLIST_ENTRY listEntry, nextListEntry;
KIRQL OldIrql;
PIRP_CONTEXT pTestIrpContext;
PIRP pTestIrp;
UNREFERENCED_PARAMETER( DeviceObject );
//
// We now need to void the cancel routine and release the io cancel
// spin-lock.
//
IoSetCancelRoutine( Irp, NULL );
IoReleaseCancelSpinLock( Irp->CancelIrql );
//
// Now we have to search for the IRP to cancel everywhere. So just
// look for cancelled IRPs and process them all.
//
//
// Process the Get Message queue.
//
KeAcquireSpinLock( &NwMessageSpinLock, &OldIrql );
for ( listEntry = NwGetMessageList.Flink;
listEntry != &NwGetMessageList;
listEntry = nextListEntry ) {
nextListEntry = listEntry->Flink;
//
// If the file object of the queued request, matches the file object
// that is being closed, remove the IRP from the queue, and
// complete it with an error.
//
pTestIrpContext = CONTAINING_RECORD( listEntry, IRP_CONTEXT, NextRequest );
pTestIrp = pTestIrpContext->pOriginalIrp;
if ( pTestIrp->Cancel ) {
RemoveEntryList( listEntry );
NwCompleteRequest( pTestIrpContext, STATUS_CANCELLED );
}
}
KeReleaseSpinLock( &NwMessageSpinLock, OldIrql );
//
// Process the set of SCB IRP queues.
//
//
// And return to our caller
//
return;
}
PMINI_IRP_CONTEXT
AllocateMiniIrpContext (
PIRP_CONTEXT IrpContext
)
/*++
Routine Description:
This routine allocates an IRP, a buffer, and an MDL for sending
a burst write fragment.
Arguments:
None.
Return Value:
Irp - The allocated and initialized IRP.
NULL - The IRP allocation failed.
--*/
{
PMINI_IRP_CONTEXT MiniIrpContext;
PIRP Irp = NULL;
PMDL Mdl1 = NULL, Mdl2 = NULL;
PVOID Buffer = NULL;
PLIST_ENTRY ListEntry;
ListEntry = ExInterlockedRemoveHeadList(
&MiniIrpContextList,
&IrpContextInterlock);
if ( ListEntry == NULL) {
try {
MiniIrpContext = ALLOCATE_POOL_EX( NonPagedPool, sizeof( *MiniIrpContext ) );
MiniIrpContext->NodeTypeCode = NW_NTC_MINI_IRP_CONTEXT;
MiniIrpContext->NodeByteSize = sizeof( *MiniIrpContext );
Irp = ALLOCATE_IRP(
IrpContext->pNpScb->Server.pDeviceObject->StackSize,
FALSE );
if ( Irp == NULL ) {
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
Buffer = ALLOCATE_POOL_EX( NonPagedPool, sizeof( NCP_BURST_HEADER ) );
Mdl1 = ALLOCATE_MDL( Buffer, sizeof( NCP_BURST_HEADER ), FALSE, FALSE, NULL );
if ( Mdl1 == NULL ) {
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
MmBuildMdlForNonPagedPool( Mdl1 );
//
// Since this MDL can be used to send a packet on any server,
// allocate an MDL large enough for any packet size.
//
Mdl2 = ALLOCATE_MDL( 0, 65535 + PAGE_SIZE - 1, FALSE, FALSE, NULL );
if ( Mdl2 == NULL ) {
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
Mdl1->Next = Mdl2;
MiniIrpContext->Irp = Irp;
MiniIrpContext->Buffer = Buffer;
MiniIrpContext->Mdl1 = Mdl1;
MiniIrpContext->Mdl2 = Mdl2;
InterlockedIncrement( &MiniContextCount );
} except( EXCEPTION_EXECUTE_HANDLER ) {
if ( Buffer != NULL ) {
FREE_POOL( Buffer );
}
if ( Irp != NULL ) {
FREE_IRP( Irp );
}
if ( Mdl1 != NULL ) {
FREE_MDL( Mdl1 );
}
return( NULL );
}
} else {
//
// Record that we have removed an entry from the free list.
//
InterlockedIncrement( &FreeMiniContextCount );
MiniIrpContext = CONTAINING_RECORD( ListEntry, MINI_IRP_CONTEXT, Next );
}
MiniIrpContext->IrpContext = IrpContext;
return( MiniIrpContext );
}
VOID
FreeMiniIrpContext (
PMINI_IRP_CONTEXT MiniIrpContext
)
/*++
Routine Description:
This routine frees a mini IRP Context.
Arguments:
MiniIrpContext - The mini IRP context to free.
Return Value:
None.
--*/
{
InterlockedDecrement( &MiniContextCount );
if ( InterlockedDecrement( &FreeMiniContextCount ) >= 0 ) {
//
// Ok to keep this mini irp context. Just queue it to the free list.
//
MmPrepareMdlForReuse( MiniIrpContext->Mdl2 );
ExInterlockedInsertTailList(
&MiniIrpContextList,
&MiniIrpContext->Next,
&IrpContextInterlock );
} else {
//
// We already have as many free context as we allow so destroy
// this context. Restore FreeContextCount to its original value.
//
InterlockedIncrement( &FreeContextCount );
FREE_POOL( MiniIrpContext->Buffer );
FREE_MDL( MiniIrpContext->Mdl2 );
FREE_MDL( MiniIrpContext->Mdl1 );
FREE_IRP( MiniIrpContext->Irp );
FREE_POOL( MiniIrpContext );
}
}
PWORK_CONTEXT
AllocateWorkContext (
VOID
)
/*++
Routine Description:
Allocates a work queue structure, and initializes it.
Arguments:
None.
Return Value:
PWORK_CONTEXT - Newly allocated Work Context.
--*/
{
PWORK_CONTEXT pWorkContext;
try {
pWorkContext = ALLOCATE_POOL_EX(NonPagedPool, sizeof(WORK_CONTEXT));
RtlFillMemory( pWorkContext, sizeof(WORK_CONTEXT), 0 );
pWorkContext->NodeTypeCode = NW_NTC_WORK_CONTEXT;
pWorkContext->NodeByteSize = sizeof(WORK_CONTEXT);
return pWorkContext;
} except( EXCEPTION_EXECUTE_HANDLER ) {
DebugTrace( 0, Dbg, "Failed to allocate work context\n", 0 );
return NULL;
}
}
VOID
FreeWorkContext (
PWORK_CONTEXT WorkContext
)
/*++
Routine Description:
Free the supplied work context.
Arguments:
PWORK_CONTEXT IrpContext - Work Context to free.
Return Value:
None
--*/
{
ASSERT( WorkContext->NodeTypeCode == NW_NTC_WORK_CONTEXT );
FREE_POOL(WorkContext);
}
VOID
SpawnWorkerThread (
VOID
)
/*++
Routine Description:
Create our own worker thread which will service reroute and reconnect
attempts.
Arguments:
None.
Return Value:
None.
--*/
{
NTSTATUS status;
status = PsCreateSystemThread(
&WorkerThreadHandle,
PROCESS_ALL_ACCESS, // Access mask
NULL, // object attributes
NULL, // Process handle
NULL, // client id
(PKSTART_ROUTINE) WorkerThread, // Start routine
NULL // Startcontext
);
if ( !NT_SUCCESS(status) ) {
//
// If we can't create the worker thread, it means that we
// cannot service reconnect or reroute attempts. It is a
// non-critical error.
//
DebugTrace( 0, Dbg, "SpawnWorkerThread: Can't create worker thread", 0 );
WorkerThreadRunning = FALSE;
} else {
DebugTrace( 0, Dbg, "SpawnWorkerThread: created worker thread", 0 );
WorkerThreadRunning = TRUE;
}
}
VOID
WorkerThread (
VOID
)
{
PLIST_ENTRY listentry;
PWORK_CONTEXT workContext;
PIRP_CONTEXT pIrpContext;
NODE_WORK_CODE workCode;
PNONPAGED_SCB OriginalNpScb = NULL;
PAGED_CODE();
DebugTrace( 0, Dbg, "Worker thread \n", 0 );
IoSetThreadHardErrorMode( FALSE );
while (TRUE) {
//
// Check to see if we have any work to do.
//
listentry = KeRemoveQueue (
&KernelQueue, // Kernel queue object
KernelMode, // Processor wait mode
NULL // No timeout
);
ASSERT( listentry != (PVOID) STATUS_TIMEOUT);
//
// We have atleast one reroute attempt to look into. Get the address of the
// work item.
//
workContext = CONTAINING_RECORD (
listentry,
WORK_CONTEXT,
Next
);
pIrpContext = workContext->pIrpC;
workCode = workContext->NodeWorkCode;
if (pIrpContext) {
OriginalNpScb = pIrpContext->pNpScb;
}
//
// We don't need the work context anymore
//
FreeWorkContext( workContext );
//
// The work which this thread does can be one of the following:
//
// - Attempt a reroute
// - Attempt a reconnect
// - Terminate itself
//
switch (workCode) {
case NWC_NWC_REROUTE:
{
ASSERT(BooleanFlagOn( pIrpContext->Flags, IRP_FLAG_REROUTE_IN_PROGRESS ));
DebugTrace( 0, Dbg, "worker got reroute work for scb 0x%x.\n", OriginalNpScb );
if ( BooleanFlagOn( pIrpContext->Flags,
IRP_FLAG_BURST_PACKET ) ) {
NewRouteBurstRetry( pIrpContext );
} else {
NewRouteRetry( pIrpContext );
}
NwDereferenceScb( OriginalNpScb );
ClearFlag( pIrpContext->Flags, IRP_FLAG_REROUTE_IN_PROGRESS );
break;
}
case NWC_NWC_RECONNECT:
{
DebugTrace( 0, Dbg, "worker got reconnect work.\n", 0 );
ReconnectRetry( pIrpContext );
break;
}
case NWC_NWC_TERMINATE:
{
DebugTrace( 0, Dbg, "Terminated worker thread.\n", 0 );
//
// Flush any remaining work items out of the work queue...
//
while (listentry != NULL) {
listentry = KeRundownQueue( &KernelQueue );
DebugTrace( 0, Dbg, "Residual workitem in q %X.\n",listentry );
}
//
// and terminate yourself.
//
WorkerThreadRunning = FALSE;
PsTerminateSystemThread( STATUS_SUCCESS );
break;
}
default:
{
//
// There is something wrong here.
//
DebugTrace( 0, Dbg, "Unknown work code...ignoring\n", 0 );
}
}
}
}
VOID
TerminateWorkerThread (
VOID
)
{
PWORK_CONTEXT workContext = NULL;
LARGE_INTEGER timeout;
NTSTATUS status;
if (WorkerThreadRunning == TRUE) {
//
// set a 5 second timeout for retrying allocation failures
//
timeout.QuadPart = (LONGLONG) ( NwOneSecond * 5 * (-1) );
//
// Prepare the work context
//
workContext = AllocateWorkContext();
while ( workContext == NULL) {
KeDelayExecutionThread( KernelMode,
FALSE,
&timeout
);
workContext = AllocateWorkContext();
}
workContext->NodeWorkCode = NWC_NWC_TERMINATE;
workContext->pIrpC = NULL;
//
// and queue it.
//
KeInsertQueue( &KernelQueue,
&workContext->Next
);
//
// We now have to wait until the thread terminates itself.
//
DebugTrace( 0, Dbg, "TerminateWorkerThread: Waiting for thread termination.\n", 0 );
do {
status = ZwWaitForSingleObject( WorkerThreadHandle,
FALSE,
NULL // No timeout
);
} while ( !NT_SUCCESS( status ) );
DebugTrace( 0, Dbg, "TerminateWorkerThread: Wait returned with 0x%x\n", status );
status = ZwClose( WorkerThreadHandle );
}
}
Reference in a new issue Copy permalink