pDevExt->Specific.Library.WorkerCount = 0;
KeInitializeEvent( &pDevExt->Specific.Library.WorkerQueueHasItems,
- NotificationEvent,
+ SynchronizationEvent,
FALSE);
//
pDevExt->Specific.Library.IOWorkerCount = 0;
KeInitializeEvent( &pDevExt->Specific.Library.IOWorkerQueueHasItems,
- NotificationEvent,
+ SynchronizationEvent,
FALSE);
//
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
//
- // Loop through the workers shutting them down
+ // Loop through the workers shutting them down in two stages.
+ // First, clear AFS_WORKER_PROCESS_REQUESTS so that workers
+ // stop processing requests. Second, call AFSShutdownWorkerThread()
+ // to wake the workers and wait for them to exit.
//
pCurrentWorker = pDevExt->Specific.Library.PoolHead;
while( index < pDevExt->Specific.Library.WorkerCount)
{
+ ClearFlag( pCurrentWorker->State, AFS_WORKER_PROCESS_REQUESTS);
+
+ pCurrentWorker = pCurrentWorker->fLink;
+
+ if ( pCurrentWorker == NULL)
+ {
+
+ break;
+ }
+
+ index++;
+ }
+
+ pCurrentWorker = pDevExt->Specific.Library.PoolHead;
+
+ index = 0;
+
+ while( index < pDevExt->Specific.Library.WorkerCount)
+ {
+
ntStatus = AFSShutdownWorkerThread( pCurrentWorker);
pNextWorker = pCurrentWorker->fLink;
ExDeleteResourceLite( &pDevExt->Specific.Library.QueueLock);
//
- // Loop through the IO workers shutting them down
+ // Loop through the IO workers shutting them down in two stages.
+ // First, clear AFS_WORKER_PROCESS_REQUESTS so that workers
+ // stop processing requests. Second, call AFSShutdownWorkerThread()
+ // to wake the workers and wait for them to exit.
//
pCurrentWorker = pDevExt->Specific.Library.IOPoolHead;
while( index < pDevExt->Specific.Library.IOWorkerCount)
{
+ ClearFlag( pCurrentWorker->State, AFS_WORKER_PROCESS_REQUESTS);
+
+ pCurrentWorker = pCurrentWorker->fLink;
+
+ if ( pCurrentWorker == NULL)
+ {
+
+ break;
+ }
+
+ index++;
+ }
+
+ pCurrentWorker = pDevExt->Specific.Library.IOPoolHead;
+
+ index = 0;
+
+ while( index < pDevExt->Specific.Library.IOWorkerCount)
+ {
+
ntStatus = AFSShutdownIOWorkerThread( pCurrentWorker);
pNextWorker = pCurrentWorker->fLink;
HANDLE hThread;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
PKSTART_ROUTINE pStartRoutine = NULL;
+ LONG lCount;
__Enter
{
FALSE,
NULL);
- if( InterlockedIncrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount) > 0)
+ lCount = InterlockedIncrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
+
+ if( lCount > 0)
{
KeClearEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent);
//
// Description:
//
-// This function shusdown a worker thread in the pool
+// This function shutsdown a worker thread in the pool
//
// Return:
//
{
//
- // Clear the 'keep processing' flag
- //
-
- ClearFlag( PoolContext->State, AFS_WORKER_PROCESS_REQUESTS);
-
- //
// Wake up the thread if it is a sleep
//
{
//
- // Clear the 'keep processing' flag
- //
-
- ClearFlag( PoolContext->State, AFS_WORKER_PROCESS_REQUESTS);
-
- //
// Wake up the thread if it is a sleep
//
AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)Context;
AFSWorkItem *pWorkItem;
BOOLEAN freeWorkItem = TRUE;
- BOOLEAN exitThread = FALSE;
AFSDeviceExt *pLibraryDevExt = NULL;
+ LONG lCount;
pLibraryDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
0,
FALSE);
-
//
// Indicate we are initialized
//
SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
+ ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+
while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
{
- ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
- Executive,
- KernelMode,
- FALSE,
- NULL);
-
if( !NT_SUCCESS( ntStatus))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
+
+ ntStatus = STATUS_SUCCESS;
}
else
{
pWorkItem = AFSRemoveWorkItem();
- if( pWorkItem != NULL)
+ if( pWorkItem == NULL)
+ {
+
+ ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ }
+ else
{
freeWorkItem = TRUE;
case AFS_WORK_FLUSH_FCB:
{
- ntStatus = AFSFlushExtents( pWorkItem->Specific.Fcb.Fcb);
+ ntStatus = AFSFlushExtents( pWorkItem->Specific.Fcb.Fcb,
+ &pWorkItem->AuthGroup);
if( !NT_SUCCESS( ntStatus))
{
- AFSReleaseExtentsWithFlush( pWorkItem->Specific.Fcb.Fcb);
+ AFSReleaseExtentsWithFlush( pWorkItem->Specific.Fcb.Fcb,
+ &pWorkItem->AuthGroup);
}
ASSERT( pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount != 0);
- InterlockedDecrement( &pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount);
break;
}
break;
}
+ case AFS_WORK_INVALIDATE_OBJECT:
+ {
+
+ AFSPerformObjectInvalidate( pWorkItem->Specific.Invalidate.ObjectInfo,
+ pWorkItem->Specific.Invalidate.InvalidateReason);
+
+ freeWorkItem = TRUE;
+
+ break;
+ }
+
case AFS_WORK_START_IOS:
{
ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
+
+ ntStatus = STATUS_SUCCESS;
}
}
} // worker thread loop
+ ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
+
+ // Wake up another worker so they too can exit
+
+ KeSetEvent( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
+ 0,
+ FALSE);
+
PsTerminateSystemThread( 0);
return;
AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)Context;
AFSWorkItem *pWorkItem;
BOOLEAN freeWorkItem = TRUE;
- BOOLEAN exitThread = FALSE;
AFSDeviceExt *pLibraryDevExt = NULL, *pRdrDevExt = NULL;
pLibraryDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
+ ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+
while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
{
- ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
- Executive,
- KernelMode,
- FALSE,
- NULL);
-
if( !NT_SUCCESS( ntStatus))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSIOWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
+
+ ntStatus = STATUS_SUCCESS;
}
else
{
pWorkItem = AFSRemoveIOWorkItem();
- if( pWorkItem != NULL)
+ if( pWorkItem == NULL)
+ {
+
+ ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ }
+ else
{
freeWorkItem = TRUE;
ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
+
+ ntStatus = STATUS_SUCCESS;
}
}
} // worker thread loop
+ ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
+
+ // Wake up another IOWorker so they too can exit
+
+ KeSetEvent( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
+ 0,
+ FALSE);
+
PsTerminateSystemThread( 0);
return;
AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)&AFSGlobalRoot->VolumeWorkerContext;
AFSDeviceExt *pControlDeviceExt = NULL;
AFSDeviceExt *pRDRDeviceExt = NULL;
- BOOLEAN exitThread = FALSE;
LARGE_INTEGER DueTime;
LONG TimeOut;
KTIMER Timer;
AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
BOOLEAN bReleaseVolumeLock = FALSE;
AFSVolumeCB *pVolumeCB = NULL, *pNextVolume = NULL;
+ AFSFcb *pFcb = NULL;
+ LONG lFileType;
LARGE_INTEGER liCurrentTime;
BOOLEAN bVolumeObject = FALSE;
+ LONG lCount;
pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
continue;
}
- if( pVolumeCB->ObjectInfoListHead == NULL &&
- pVolumeCB != AFSGlobalRoot)
+ if( pVolumeCB->ObjectInfoListHead == NULL)
{
AFSReleaseResource( pVolumeCB->VolumeLock);
pVolumeCB->VolumeReferenceCount == 1 &&
( pVolumeCB->RootFcb == NULL ||
pVolumeCB->RootFcb->OpenReferenceCount == 0) &&
- pVolumeCB->ObjectInformation.ObjectReferenceCount == 0)
+ pVolumeCB->ObjectInformation.ObjectReferenceCount <= 0)
{
if( pVolumeCB->RootFcb != NULL)
//
if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
- pCurrentObject->ObjectReferenceCount == 0 &&
+ pCurrentObject->ObjectReferenceCount <= 0 &&
( pCurrentObject->Fcb == NULL ||
pCurrentObject->Fcb->OpenReferenceCount == 0) &&
pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL &&
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
+
if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
FALSE))
{
- if( pCurrentObject->Fcb != NULL)
+ if ( pCurrentObject->ObjectReferenceCount <= 0)
{
- AFSRemoveFcb( pCurrentObject->Fcb);
- }
+ if( pCurrentObject->Fcb != NULL)
+ {
- if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
- {
+ AFSRemoveFcb( &pCurrentObject->Fcb);
+ }
- if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb != NULL)
+ if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
{
- AFSRemoveFcb( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
- }
+ if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb != NULL)
+ {
- AFSDeleteObjectInfo( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
+ AFSRemoveFcb( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
+ }
- ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
+ AFSDeleteObjectInfo( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
- AFSExFreePool( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged);
+ ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
- AFSExFreePool( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB);
- }
+ AFSExFreePool( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged);
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Deleting deleted object %08lX\n",
- pCurrentObject);
+ AFSExFreePool( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB);
+ }
- AFSDeleteObjectInfo( pCurrentObject);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPrimaryVolumeWorkerThread Deleting deleted object %08lX\n",
+ pCurrentObject);
+
+ AFSDeleteObjectInfo( pCurrentObject);
+ }
AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
pCurrentChildObject = pCurrentDirEntry->ObjectInformation;
+ pFcb = NULL;
+
AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Deleting DE %wZ Object %08lX\n",
+ "AFSPrimaryVolumeWorkerThread Deleting DE %wZ Object %08lX\n",
&pCurrentDirEntry->NameInformation.FileName,
pCurrentChildObject);
AFSDeleteDirEntry( pCurrentObject,
pCurrentDirEntry);
- if( pCurrentChildObject->ObjectReferenceCount == 0)
+ if( pCurrentChildObject->ObjectReferenceCount <= 0)
{
if( pCurrentChildObject->Fcb != NULL)
{
- if( pCurrentChildObject->FileType == AFS_FILE_TYPE_FILE)
- {
-
- AFSCleanupFcb( pCurrentChildObject->Fcb,
- TRUE);
- }
+ pFcb = (AFSFcb *) InterlockedCompareExchangePointer( (PVOID *)&pCurrentChildObject->Fcb, NULL, (PVOID)pCurrentChildObject->Fcb);
- AFSRemoveFcb( pCurrentChildObject->Fcb);
+ lFileType = pCurrentChildObject->FileType;
}
if( pCurrentChildObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
if( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb != NULL)
{
- AFSRemoveFcb( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
+ AFSRemoveFcb( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
}
AFSDeleteObjectInfo( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Deleting object %08lX\n",
+ "AFSPrimaryVolumeWorkerThread Deleting object %08lX\n",
pCurrentChildObject);
AFSDeleteObjectInfo( pCurrentChildObject);
}
pCurrentDirEntry = pNextDirEntry;
+
+ if ( pFcb != NULL)
+ {
+
+ if( lFileType == AFS_FILE_TYPE_FILE)
+ {
+ //
+ // We must not hold pVolumeCB->ObjectInfoTree.TreeLock exclusive
+ // across an AFSCleanupFcb call since it can deadlock with an
+ // invalidation call from the service.
+ //
+
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
+
+ AFSCleanupFcb( pFcb,
+ TRUE);
+
+ AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+ }
+
+ AFSRemoveFcb( &pFcb);
+ }
}
pCurrentObject->Specific.Directory.DirectoryNodeListHead = NULL;
AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Reset count to 0 on parent FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSPrimaryVolumeWorkerThread Reset count to 0 on parent FID %08lX-%08lX-%08lX-%08lX\n",
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique);
-
//
// Clear our enumerated flag on this object so we retrieve info again on next access
//
ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
}
else
{
break;
}
-
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
}
else
{
{
if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
- pCurrentObject->ObjectReferenceCount == 0 &&
+ pCurrentObject->ObjectReferenceCount <= 0 &&
( pCurrentObject->Fcb == NULL ||
pCurrentObject->Fcb->OpenReferenceCount == 0))
{
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ pFcb = (AFSFcb *) InterlockedCompareExchangePointer( (PVOID *)&pCurrentObject->Fcb, NULL, (PVOID)pCurrentObject->Fcb);
- if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
+ if( pFcb != NULL)
{
- if( pCurrentObject->Fcb != NULL)
- {
-
- AFSCleanupFcb( pCurrentObject->Fcb,
- TRUE);
-
- AFSRemoveFcb( pCurrentObject->Fcb);
- }
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- AFSDeleteObjectInfo( pCurrentObject);
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ AFSCleanupFcb( pFcb,
+ TRUE);
- pCurrentObject = pNextObject;
+ AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
- continue;
+ AFSRemoveFcb( &pFcb);
}
- else
- {
-
- bReleaseVolumeLock = FALSE;
-
- break;
- }
- }
- else if( pCurrentObject->Fcb != NULL)
- {
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
FALSE))
{
- AFSCleanupFcb( pCurrentObject->Fcb,
- FALSE);
+ AFSDeleteObjectInfo( pCurrentObject);
AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
break;
}
}
+ else if( pCurrentObject->Fcb != NULL)
+ {
+
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
+
+ AFSCleanupFcb( pCurrentObject->Fcb,
+ FALSE);
+
+ AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+ }
}
pCurrentObject = pNextObject;
AFS_TRACE_LEVEL_VERBOSE,
"AFSPrimaryVolumeWorkerThread Exiting\n");
- if( InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount) == 0)
+ lCount = InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
+
+ if( lCount == 0)
{
KeSetEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent,
LARGE_INTEGER DueTime;
LONG TimeOut;
KTIMER Timer;
+ LONG lCount;
pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
KeCancelTimer( &Timer);
- if( InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount) == 0)
+ lCount = InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
+
+ if( lCount == 0)
{
KeSetEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent,
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
TRUE);
+ lCount = InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitem Inserting work item %08lX Count %08lX\n",
WorkItem,
- InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount));
+ lCount);
if( pDevExt->Specific.Library.QueueTail != NULL) // queue already has nodes
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
AFSAcquireExcl( &pDevExt->Specific.Library.IOQueueLock,
TRUE);
+ lCount = InterlockedIncrement( &pDevExt->Specific.Library.IOQueueItemCount);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitem Inserting IO work item %08lX Count %08lX\n",
WorkItem,
- InterlockedIncrement( &pDevExt->Specific.Library.IOQueueItemCount));
+ lCount);
if( pDevExt->Specific.Library.IOQueueTail != NULL) // queue already has nodes
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
pDevExt->Specific.Library.QueueHead = WorkItem;
+ lCount = InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitemAtHead Inserting work item %08lX Count %08lX\n",
WorkItem,
- InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount));
+ lCount);
//
// indicate that the queue has nodes
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSWorkItem *pWorkItem = NULL;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
pWorkItem = pDevExt->Specific.Library.QueueHead;
+ lCount = InterlockedDecrement( &pDevExt->Specific.Library.QueueItemCount);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveWorkItem Removing work item %08lX Count %08lX Thread %08lX\n",
pWorkItem,
- InterlockedDecrement( &pDevExt->Specific.Library.QueueItemCount),
+ lCount,
PsGetCurrentThreadId());
pDevExt->Specific.Library.QueueHead = pDevExt->Specific.Library.QueueHead->next;
{
pDevExt->Specific.Library.QueueTail = NULL;
+ }
+ else
+ {
- KeResetEvent(&(pDevExt->Specific.Library.WorkerQueueHasItems));
+ //
+ // Wake up another worker
+ //
+
+ KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
+ 0,
+ FALSE);
}
}
- else
- {
- KeResetEvent(&(pDevExt->Specific.Library.WorkerQueueHasItems));
- }
AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSWorkItem *pWorkItem = NULL;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
pWorkItem = pDevExt->Specific.Library.IOQueueHead;
+ lCount = InterlockedDecrement( &pDevExt->Specific.Library.IOQueueItemCount);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveWorkItem Removing work item %08lX Count %08lX Thread %08lX\n",
pWorkItem,
- InterlockedDecrement( &pDevExt->Specific.Library.IOQueueItemCount),
+ lCount,
PsGetCurrentThreadId());
pDevExt->Specific.Library.IOQueueHead = pDevExt->Specific.Library.IOQueueHead->next;
{
pDevExt->Specific.Library.IOQueueTail = NULL;
+ }
+ else
+ {
+
+ //
+ // Wake up another worker
+ //
- KeResetEvent(&(pDevExt->Specific.Library.IOWorkerQueueHasItems));
+ KeSetEvent( &(pDevExt->Specific.Library.IOWorkerQueueHasItems),
+ 0,
+ FALSE);
}
}
- else
- {
- KeResetEvent(&(pDevExt->Specific.Library.IOWorkerQueueHasItems));
- }
AFSReleaseResource( &pDevExt->Specific.Library.IOQueueLock);
}
NTSTATUS
-AFSQueueFlushExtents( IN AFSFcb *Fcb)
+AFSQueueFlushExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSWorkItem *pWorkItem = NULL;
+ LONG lCount;
__try
{
// queue down. We'll decrement it just below.
//
- if( InterlockedIncrement( &Fcb->Specific.File.QueuedFlushCount) > 3)
+ lCount = InterlockedIncrement( &Fcb->Specific.File.QueuedFlushCount);
+
+ if( lCount > 3)
{
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
pWorkItem->RequestType = AFS_WORK_FLUSH_FCB;
+ RtlCopyMemory( &pWorkItem->AuthGroup,
+ AuthGroup,
+ sizeof( GUID));
+
pWorkItem->Specific.Fcb.Fcb = Fcb;
- InterlockedIncrement( &Fcb->OpenReferenceCount);
+ lCount = InterlockedIncrement( &Fcb->OpenReferenceCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueFlushExtents Increment count on Fcb %08lX Cnt %d\n",
- Fcb,
- Fcb->OpenReferenceCount);
+ Fcb,
+ lCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
// Remove the count we added above
//
- if( InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount) == 0)
+ lCount = InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount);
+
+ if( lCount == 0)
{
KeSetEvent( &Fcb->NPFcb->Specific.File.QueuedFlushEvent,
if( pWorkItem != NULL)
{
- InterlockedDecrement( &Fcb->OpenReferenceCount);
+ lCount = InterlockedDecrement( &Fcb->OpenReferenceCount);
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
if( pWorkItem != NULL)
{
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
if( pWorkItem != NULL)
{
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
if( pWorkItem != NULL)
{
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
if( pWorkItem != NULL)
{
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
}
}
return ntStatus;
}
+
+NTSTATUS
+AFSQueueInvalidateObject( IN AFSObjectInfoCB *ObjectInfo,
+ IN ULONG InvalidateReason)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSWorkItem *pWorkItem = NULL;
+
+ __try
+ {
+
+ pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
+ sizeof(AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
+ if (NULL == pWorkItem)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSQueueInvalidateObject Failed to allocate work item\n");
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
+ }
+
+ RtlZeroMemory( pWorkItem,
+ sizeof(AFSWorkItem));
+
+ pWorkItem->Size = sizeof( AFSWorkItem);
+
+ pWorkItem->RequestType = AFS_WORK_INVALIDATE_OBJECT;
+
+ pWorkItem->Specific.Invalidate.ObjectInfo = ObjectInfo;
+
+ pWorkItem->Specific.Invalidate.InvalidateReason = InvalidateReason;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSQueueInvalidateObject Workitem %08lX\n",
+ pWorkItem);
+
+ ntStatus = AFSQueueWorkerRequest( pWorkItem);
+
+try_exit:
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSQueueInvalidateObject Request complete Status %08lX\n",
+ ntStatus);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ if( pWorkItem != NULL)
+ {
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSQueueInvalidateObject Failed to queue request Status %08lX\n",
+ ntStatus);
+ }
+ }
+ __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ {
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSQueueInvalidateObject\n");
+ }
+
+ return ntStatus;
+}