#include "AFSCommon.h"
+static
+VOID
+AFSPostedDeferredWrite( IN PVOID Context1,
+ IN PVOID Context2);
+
//
// Function: AFSInitializeWorkerPool
//
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 AFSShutdownIOWorkerThread()
+ // 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;
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSWorkQueueContext *pWorker = &VolumeCB->VolumeWorkerContext;
+ AFSWorkQueueContext *pWorker = &VolumeCB->NonPagedVcb->VolumeWorkerContext;
HANDLE hThread;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
PKSTART_ROUTINE pStartRoutine = NULL;
+ LONG lCount;
__Enter
{
- if( VolumeCB == AFSGlobalRoot)
+ if ( VolumeCB != AFSGlobalRoot)
{
- pStartRoutine = AFSPrimaryVolumeWorkerThread;
+ return STATUS_INVALID_PARAMETER;
}
- else
- {
- pStartRoutine = AFSVolumeWorkerThread;
- }
+ pStartRoutine = AFSPrimaryVolumeWorkerThread;
//
// Initialize the worker thread
FALSE,
NULL);
- if( InterlockedIncrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount) > 0)
+ lCount = InterlockedIncrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
+
+ if( lCount > 0)
{
KeClearEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent);
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSWorkQueueContext *pWorker = &VolumeCB->VolumeWorkerContext;
+ AFSWorkQueueContext *pWorker = &VolumeCB->NonPagedVcb->VolumeWorkerContext;
- if( pWorker->WorkerThreadObject != NULL &&
- BooleanFlagOn( pWorker->State, AFS_WORKER_INITIALIZED))
- {
+ //
+ // Clear the 'keep processing' flag
+ //
- //
- // Clear the 'keep processing' flag
- //
+ ClearFlag( pWorker->State, AFS_WORKER_PROCESS_REQUESTS);
- ClearFlag( pWorker->State, AFS_WORKER_PROCESS_REQUESTS);
+ if( pWorker->WorkerThreadObject != NULL)
+ {
+ while ( BooleanFlagOn( pWorker->State, AFS_WORKER_INITIALIZED) )
+ {
- ntStatus = KeWaitForSingleObject( pWorker->WorkerThreadObject,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ ntStatus = KeWaitForSingleObject( pWorker->WorkerThreadObject,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ }
ObDereferenceObject( pWorker->WorkerThreadObject);
//
// Description:
//
-// This function shusdown a worker thread in the pool
+// This function shutsdown a worker thread in the pool
//
// Return:
//
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
- if( PoolContext->WorkerThreadObject != NULL &&
- BooleanFlagOn( PoolContext->State, AFS_WORKER_INITIALIZED))
+ if( PoolContext->WorkerThreadObject != NULL)
{
- //
- // Clear the 'keep processing' flag
- //
-
- ClearFlag( PoolContext->State, AFS_WORKER_PROCESS_REQUESTS);
+ while ( BooleanFlagOn( PoolContext->State, AFS_WORKER_INITIALIZED) )
+ {
- //
- // Wake up the thread if it is a sleep
- //
+ //
+ // Wake up the thread if it is a sleep
+ //
- KeSetEvent( &pDeviceExt->Specific.Library.WorkerQueueHasItems,
- 0,
- FALSE);
+ KeSetEvent( &pDeviceExt->Specific.Library.WorkerQueueHasItems,
+ 0,
+ FALSE);
- ntStatus = KeWaitForSingleObject( PoolContext->WorkerThreadObject,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ ntStatus = KeWaitForSingleObject( PoolContext->WorkerThreadObject,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ }
ObDereferenceObject( PoolContext->WorkerThreadObject);
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
- if( PoolContext->WorkerThreadObject != NULL &&
- BooleanFlagOn( PoolContext->State, AFS_WORKER_INITIALIZED))
+ if( PoolContext->WorkerThreadObject != NULL)
{
- //
- // Clear the 'keep processing' flag
- //
-
- ClearFlag( PoolContext->State, AFS_WORKER_PROCESS_REQUESTS);
+ while ( BooleanFlagOn( PoolContext->State, AFS_WORKER_INITIALIZED) )
+ {
- //
- // Wake up the thread if it is a sleep
- //
+ //
+ // Wake up the thread if it is a sleep
+ //
- KeSetEvent( &pDeviceExt->Specific.Library.IOWorkerQueueHasItems,
- 0,
- FALSE);
+ KeSetEvent( &pDeviceExt->Specific.Library.IOWorkerQueueHasItems,
+ 0,
+ FALSE);
- ntStatus = KeWaitForSingleObject( PoolContext->WorkerThreadObject,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ ntStatus = KeWaitForSingleObject( PoolContext->WorkerThreadObject,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ }
ObDereferenceObject( PoolContext->WorkerThreadObject);
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,
+ FALSE);
}
ASSERT( pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount != 0);
- InterlockedDecrement( &pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount);
break;
}
- case AFS_WORK_ASYNCH_READ:
+ case AFS_WORK_ENUMERATE_GLOBAL_ROOT:
{
- ASSERT( pWorkItem->Specific.AsynchIo.CallingProcess != NULL);
-
- (VOID) AFSCommonRead( pWorkItem->Specific.AsynchIo.Device,
- pWorkItem->Specific.AsynchIo.Irp,
- pWorkItem->Specific.AsynchIo.CallingProcess);
+ AFSEnumerateGlobalRoot( NULL);
break;
}
- case AFS_WORK_ASYNCH_WRITE:
+ case AFS_WORK_INVALIDATE_OBJECT:
{
- ASSERT( pWorkItem->Specific.AsynchIo.CallingProcess != NULL);
-
- (VOID) AFSCommonWrite( pWorkItem->Specific.AsynchIo.Device,
- pWorkItem->Specific.AsynchIo.Irp,
- pWorkItem->Specific.AsynchIo.CallingProcess);
- break;
- }
-
- case AFS_WORK_ENUMERATE_GLOBAL_ROOT:
- {
+ AFSPerformObjectInvalidate( pWorkItem->Specific.Invalidate.ObjectInfo,
+ pWorkItem->Specific.Invalidate.InvalidateReason);
- AFSEnumerateGlobalRoot( NULL);
+ freeWorkItem = TRUE;
break;
}
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;
break;
}
+ case AFS_WORK_DEFERRED_WRITE:
+ {
+
+ ntStatus = AFSCommonWrite( pWorkItem->Specific.AsynchIo.Device,
+ pWorkItem->Specific.AsynchIo.Irp,
+ pWorkItem->Specific.AsynchIo.CallingProcess,
+ TRUE);
+
+ freeWorkItem = TRUE;
+
+ break;
+ }
+
default:
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSWorkerThread Unknown request type %d\n", pWorkItem->RequestType);
+ "AFSIOWorkerThread Unknown request type %d\n", pWorkItem->RequestType);
break;
}
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;
}
-void
-AFSPrimaryVolumeWorkerThread( IN PVOID Context)
+static BOOLEAN
+AFSExamineDirectory( IN AFSObjectInfoCB * pCurrentObject,
+ IN AFSDirectoryCB * pCurrentDirEntry)
{
+ NTSTATUS ntStatus;
+ AFSFcb *pFcb = NULL;
+ AFSObjectInfoCB *pCurrentChildObject = NULL;
+ AFSVolumeCB * pVolumeCB = pCurrentObject->VolumeCB;
+ BOOLEAN bFcbBusy = FALSE;
+ LONG lCount;
- NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)&AFSGlobalRoot->VolumeWorkerContext;
- AFSDeviceExt *pControlDeviceExt = NULL;
- AFSDeviceExt *pRDRDeviceExt = NULL;
- BOOLEAN exitThread = FALSE;
- LARGE_INTEGER DueTime;
- LONG TimeOut;
- KTIMER Timer;
- BOOLEAN bFoundOpenEntry = FALSE;
- AFSObjectInfoCB *pCurrentObject = NULL, *pNextObject = NULL, *pCurrentChildObject = NULL;
- AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
- BOOLEAN bReleaseVolumeLock = FALSE;
- AFSVolumeCB *pVolumeCB = NULL, *pNextVolume = NULL;
- LARGE_INTEGER liCurrentTime;
- BOOLEAN bVolumeObject = FALSE;
-
- pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
-
- pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
+ pCurrentChildObject = pCurrentDirEntry->ObjectInformation;
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryVolumeWorkerThread Initialized\n");
-
- //
- // Initialize the timer for the worker thread
- //
+ "AFSExamineDirectory Deleting DE %wZ Object %p\n",
+ &pCurrentDirEntry->NameInformation.FileName,
+ pCurrentChildObject);
- DueTime.QuadPart = -(5000);
-
- TimeOut = 5000;
-
- KeInitializeTimerEx( &Timer,
- SynchronizationTimer);
-
- KeSetTimerEx( &Timer,
- DueTime,
- TimeOut,
- NULL);
+ AFSDeleteDirEntry( pCurrentObject,
+ pCurrentDirEntry);
//
- // Indicate that we are initialized and ready
+ // Acquire ObjectInfoLock shared here so as not to deadlock
+ // with an invalidation call from the service during AFSCleanupFcb
//
- KeSetEvent( &pPoolContext->WorkerThreadReady,
- 0,
- FALSE);
-
- //
- // Indicate we are initialized
- //
+ lCount = AFSObjectInfoIncrement( pCurrentChildObject,
+ AFS_OBJECT_REFERENCE_WORKER);
- SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineDirectory Increment count on object %p Cnt %d\n",
+ pCurrentChildObject,
+ lCount);
- while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
+ if( lCount == 1 &&
+ pCurrentChildObject->Fcb != NULL &&
+ pCurrentChildObject->FileType == AFS_FILE_TYPE_FILE)
{
- KeWaitForSingleObject( &Timer,
- Executive,
- KernelMode,
- FALSE,
- NULL);
-
//
- // This is the primary volume worker so it will traverse the volume list
- // looking for cleanup or volumes requiring private workers
+ // We must not hold pVolumeCB->ObjectInfoTree.TreeLock exclusive
+ // across an AFSCleanupFcb call since it can deadlock with an
+ // invalidation call from the service.
//
- AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
- TRUE);
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- pVolumeCB = pRDRDeviceExt->Specific.RDR.VolumeListHead;
+ //
+ // Cannot hold a TreeLock across an AFSCleanupFcb call
+ // as it can deadlock with an invalidation ioctl initiated
+ // from the service.
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
- while( pVolumeCB != NULL)
+ ntStatus = AFSCleanupFcb( pCurrentChildObject->Fcb,
+ TRUE);
+
+ if ( ntStatus == STATUS_RETRY)
{
- if( pVolumeCB == AFSGlobalRoot ||
- !AFSAcquireExcl( pVolumeCB->VolumeLock,
- FALSE))
- {
+ bFcbBusy = TRUE;
+ }
- pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
+ AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+ }
- continue;
- }
+ AFSAcquireExcl( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- if( pVolumeCB->ObjectInfoListHead == NULL &&
- pVolumeCB != AFSGlobalRoot)
- {
+ lCount = AFSObjectInfoDecrement( pCurrentChildObject,
+ AFS_OBJECT_REFERENCE_WORKER);
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineDirectory Decrement1 count on object %p Cnt %d\n",
+ pCurrentChildObject,
+ lCount);
- AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+ if( lCount == 0 &&
+ pCurrentChildObject->Fcb != NULL &&
+ pCurrentChildObject->Fcb->OpenReferenceCount == 0)
+ {
- AFSAcquireExcl( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock,
- TRUE);
+ AFSRemoveFcb( &pCurrentChildObject->Fcb);
- AFSAcquireExcl( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
- TRUE);
+ if( pCurrentChildObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
+ pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
+ {
- if( !AFSAcquireExcl( pVolumeCB->VolumeLock,
- FALSE))
- {
+ AFSAcquireExcl( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- AFSConvertToShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+ AFSRemoveFcb( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
- AFSReleaseResource( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock);
+ AFSReleaseResource( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
- pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
+ AFSDeleteObjectInfo( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
- continue;
- }
+ ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
- KeQueryTickCount( &liCurrentTime);
+ AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged, AFS_DIR_ENTRY_NP_TAG);
- pNextVolume = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineDirectory (pioctl) AFS_DIR_ENTRY_TAG deallocating %p\n",
+ pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB);
- if( pVolumeCB->ObjectInfoListHead == NULL &&
- pVolumeCB->DirectoryCB->OpenReferenceCount == 0 &&
- pVolumeCB->VolumeReferenceCount == 1 &&
- ( pVolumeCB->RootFcb == NULL ||
- pVolumeCB->RootFcb->OpenReferenceCount == 0) &&
- pVolumeCB->ObjectInformation.ObjectReferenceCount == 0)
- {
+ AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
+ }
- if( pVolumeCB->RootFcb != NULL)
- {
+ AFSReleaseResource( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock);
- AFSRemoveRootFcb( pVolumeCB->RootFcb);
- }
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineDirectory Deleting object %p\n",
+ pCurrentChildObject);
- AFSRemoveVolume( pVolumeCB);
- }
- else
- {
+ AFSDeleteObjectInfo( &pCurrentChildObject);
+ }
+ else
+ {
- AFSReleaseResource( pVolumeCB->VolumeLock);
- }
+ AFSReleaseResource( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock);
+ }
- AFSConvertToShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+ return bFcbBusy;
+}
- AFSReleaseResource( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock);
+//
+// Called with VolumeCB->ObjectInfoTree.TreeLock held shared.
+// The TreeLock will be released unless *pbReleaseVolumeLock is set to FALSE.
+//
- pVolumeCB = pNextVolume;
+static BOOLEAN
+AFSExamineObjectInfo( IN AFSObjectInfoCB * pCurrentObject,
+ IN BOOLEAN bVolumeObject,
+ IN OUT BOOLEAN * pbReleaseVolumeLock)
+{
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
+ AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
+ AFSObjectInfoCB *pCurrentChildObject = NULL;
+ AFSVolumeCB * pVolumeCB = pCurrentObject->VolumeCB;
+ LARGE_INTEGER liCurrentTime;
+ BOOLEAN bFcbBusy = FALSE;
+ LONG lCount;
+ BOOLEAN bTemp;
- continue;
- }
+ switch ( pCurrentObject->FileType) {
- //
- // Don't need this lock anymore now that we have a volume cb to work with
- //
+ case AFS_FILE_TYPE_DIRECTORY:
+ {
- AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+ if ( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
+ {
+
+ return FALSE;
+ }
//
- // For now we only need the volume lock shared
+ // If this object is deleted then remove it from the parent, if we can
//
- AFSConvertToShared( pVolumeCB->VolumeLock);
-
- if( AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
+ if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
+ pCurrentObject->ObjectReferenceCount <= 0 &&
+ ( pCurrentObject->Fcb == NULL ||
+ pCurrentObject->Fcb->OpenReferenceCount == 0) &&
+ pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL &&
+ pCurrentObject->Specific.Directory.ChildOpenReferenceCount == 0)
{
- pCurrentObject = pVolumeCB->ObjectInfoListHead;
-
- pNextObject = NULL;
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- bReleaseVolumeLock = TRUE;
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
- while( pCurrentObject != NULL)
+ if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
{
- if( pCurrentObject != &pVolumeCB->ObjectInformation)
+ AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ if ( pCurrentObject->ObjectReferenceCount <= 0)
{
- pNextObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
+ AFSRemoveFcb( &pCurrentObject->Fcb);
- if( pNextObject == NULL &&
- pVolumeCB != AFSGlobalRoot) // Don't free up the root of the global
+ if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
{
- pNextObject = &pVolumeCB->ObjectInformation;
+ AFSAcquireExcl( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ AFSRemoveFcb( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
+
+ AFSReleaseResource( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
+
+ AFSDeleteObjectInfo( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
+
+ ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
+
+ AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged, AFS_DIR_ENTRY_NP_TAG);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo (pioctl) AFS_DIR_ENTRY_TAG deallocating %p\n",
+ pCurrentObject->Specific.Directory.PIOCtlDirectoryCB);
+
+ AFSExFreePoolWithTag( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
}
- bVolumeObject = FALSE;
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Deleting deleted object %p\n",
+ pCurrentObject);
+
+ AFSDeleteObjectInfo( &pCurrentObject);
}
else
{
- pNextObject = NULL;
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ }
+
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ }
+ else
+ {
+
+ *pbReleaseVolumeLock = FALSE;
+ }
+
+ return bFcbBusy;
+ }
- bVolumeObject = TRUE;
+ if ( pCurrentObject->Fcb != NULL &&
+ pCurrentObject->Fcb->CcbListHead != NULL)
+ {
+
+ AFSCcb *pCcb;
+
+ for ( pCcb = pCurrentObject->Fcb->CcbListHead;
+ pCcb;
+ pCcb = (AFSCcb *)pCcb->ListEntry.fLink)
+ {
+
+ if ( pCcb->NameArray) {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Found Object %p Fcb %p Ccb %p\n",
+ pCurrentObject,
+ pCurrentObject->Fcb,
+ pCcb);
}
+ }
- if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
- !BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN)) // If we are in shutdown mode skip directories
- {
+ return bFcbBusy;
+ }
- //
- // If this object is deleted then remove it from the parent, if we can
- //
+ if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0 ||
+ ( pCurrentObject->Fcb != NULL &&
+ pCurrentObject->Fcb->OpenReferenceCount > 0))
+ {
- if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
- pCurrentObject->ObjectReferenceCount == 0 &&
- ( pCurrentObject->Fcb == NULL ||
- pCurrentObject->Fcb->OpenReferenceCount == 0) &&
- pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL &&
- pCurrentObject->Specific.Directory.ChildOpenReferenceCount == 0)
- {
+ return bFcbBusy;
+ }
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ if ( pCurrentObject->FileType != AFS_FILE_TYPE_DIRECTORY ||
+ pCurrentObject->Specific.Directory.DirectoryNodeListHead != NULL)
+ {
- if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
- {
+ if( !AFSAcquireShared( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ FALSE))
+ {
+
+ return bFcbBusy;
+ }
- if( pCurrentObject->Fcb != NULL)
- {
+ pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
- AFSRemoveFcb( pCurrentObject->Fcb);
- }
+ //
+ // Directory Entry Processing
+ //
+
+ KeQueryTickCount( &liCurrentTime);
- if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
- {
+ while( pCurrentDirEntry != NULL)
+ {
- if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb != NULL)
- {
+ if( pCurrentDirEntry->DirOpenReferenceCount > 0)
+ {
- AFSRemoveFcb( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
- }
+ break;
+ }
- AFSDeleteObjectInfo( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
+ if ( pCurrentDirEntry->NameArrayReferenceCount > 0)
+ {
- ExFreePool( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB);
- }
+ break;
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Deleting deleted object %08lX\n",
- pCurrentObject);
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0)
+ {
- AFSDeleteObjectInfo( pCurrentObject);
+ break;
+ }
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ if ( liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
+ liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
+ {
- pCurrentObject = pNextObject;
+ break;
+ }
- continue;
- }
- else
- {
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
- bReleaseVolumeLock = FALSE;
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
+ {
- break;
- }
+ break;
}
- if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0 ||
- ( pCurrentObject->Fcb != NULL &&
- pCurrentObject->Fcb->OpenReferenceCount > 0) ||
- pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL)
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
{
- pCurrentObject = pNextObject;
-
- continue;
+ break;
}
+ }
- if( !AFSAcquireShared( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
- FALSE))
- {
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE)
+ {
- pCurrentObject = pNextObject;
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0)
+ {
- continue;
+ break;
}
+ }
+
+ pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+ }
- KeQueryTickCount( &liCurrentTime);
+ if( pCurrentDirEntry != NULL)
+ {
- pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- while( pCurrentDirEntry != NULL)
- {
+ return bFcbBusy;
+ }
- if( pCurrentDirEntry->OpenReferenceCount > 0 ||
- ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0) ||
- liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
- liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
- pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart ||
- ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
- ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL ||
- pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)) ||
- ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
- pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0))
- {
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- break;
- }
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
- }
+ //
+ // Now acquire the locks excl without deadlocking
+ //
+
+ if( AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ FALSE))
+ {
+
+ if( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
+ {
+
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ *pbReleaseVolumeLock = FALSE;
+
+ return bFcbBusy;
+ }
+
+ if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0)
+ {
+
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+
+ return bFcbBusy;
+ }
+
+ KeQueryTickCount( &liCurrentTime);
- if( pCurrentDirEntry != NULL)
+ pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
+
+ while( pCurrentDirEntry != NULL)
+ {
+
+ if( pCurrentDirEntry->DirOpenReferenceCount > 0)
{
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ break;
+ }
- pCurrentObject = pNextObject;
+ if ( pCurrentDirEntry->NameArrayReferenceCount > 0)
+ {
- continue;
+ break;
}
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0)
+ {
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ break;
+ }
- //
- // Now acquire the locks excl
- //
+ if ( liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
+ liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
+ {
+
+ break;
+ }
- if( AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
- FALSE))
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
{
- if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
{
- if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0)
- {
+ break;
+ }
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
+ {
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ break;
+ }
+ }
- pCurrentObject = pNextObject;
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE)
+ {
- continue;
- }
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0)
+ {
- KeQueryTickCount( &liCurrentTime);
+ break;
+ }
+ }
- pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
+ pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+ }
- while( pCurrentDirEntry != NULL)
- {
+ if( pCurrentDirEntry != NULL)
+ {
- if( pCurrentDirEntry->OpenReferenceCount > 0 ||
- ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0) ||
- liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
- liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
- pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart ||
- ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY &&
- ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL ||
- pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)) ||
- ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE &&
- pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0))
- {
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- break;
- }
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
- pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
- }
+ return bFcbBusy;
+ }
- if( pCurrentDirEntry != NULL)
- {
+ pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ while( pCurrentDirEntry != NULL)
+ {
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
- pCurrentObject = pNextObject;
+ AFSExamineDirectory( pCurrentObject,
+ pCurrentDirEntry);
- continue;
- }
+ pCurrentDirEntry = pNextDirEntry;
+ }
- pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
+ //
+ // Clear our enumerated flag on this object so we retrieve info again on next access
+ //
- while( pCurrentDirEntry != NULL)
- {
+ ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
- pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- pCurrentChildObject = pCurrentDirEntry->ObjectInformation;
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ }
+ else
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Deleting DE %wZ Object %08lX\n",
- &pCurrentDirEntry->NameInformation.FileName,
- pCurrentChildObject);
+ //
+ // Try to grab the volume lock again ... no problem if we don't
+ //
- AFSDeleteDirEntry( pCurrentObject,
- pCurrentDirEntry);
+ if( !AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
+ {
- if( pCurrentChildObject->ObjectReferenceCount == 0)
- {
+ *pbReleaseVolumeLock = FALSE;
- if( pCurrentChildObject->Fcb != NULL)
- {
+ return bFcbBusy;
+ }
+ }
+ }
+ else if ( bVolumeObject == FALSE)
+ {
+ //
+ // No children
+ //
+
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- if( pCurrentChildObject->FileType == AFS_FILE_TYPE_FILE)
- {
+ if ( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
+ {
- AFSCleanupFcb( pCurrentChildObject->Fcb,
- TRUE);
- }
+ *pbReleaseVolumeLock = FALSE;
- AFSRemoveFcb( pCurrentChildObject->Fcb);
- }
+ return bFcbBusy;
+ }
- if( pCurrentChildObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
- pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
- {
+ AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- if( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb != NULL)
- {
+ KeQueryTickCount( &liCurrentTime);
- AFSRemoveFcb( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
- }
+ if( pCurrentObject->ObjectReferenceCount <= 0 &&
+ ( pCurrentObject->Fcb == NULL ||
+ pCurrentObject->Fcb->OpenReferenceCount <= 0) &&
+ liCurrentTime.QuadPart > pCurrentObject->LastAccessCount.QuadPart &&
+ liCurrentTime.QuadPart - pCurrentObject->LastAccessCount.QuadPart >
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
+ {
- AFSDeleteObjectInfo( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
+ AFSRemoveFcb( &pCurrentObject->Fcb);
- ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
- ExFreePool( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged);
+ AFSDeleteObjectInfo( &pCurrentObject);
+ }
+ else
+ {
- ExFreePool( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB);
- }
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Deleting object %08lX\n",
- pCurrentChildObject);
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ }
+ }
+ break;
- AFSDeleteObjectInfo( pCurrentChildObject);
- }
+ case AFS_FILE_TYPE_FILE:
+ {
- pCurrentDirEntry = pNextDirEntry;
- }
+ lCount = AFSObjectInfoIncrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
- pCurrentObject->Specific.Directory.DirectoryNodeListHead = NULL;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Increment3 count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount);
- pCurrentObject->Specific.Directory.DirectoryNodeListTail = NULL;
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- pCurrentObject->Specific.Directory.ShortNameTree = NULL;
+ if( pCurrentObject->Fcb != NULL)
+ {
- pCurrentObject->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = NULL;
+ //
+ // Dropping the TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change
+ //
- pCurrentObject->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = NULL;
+ ntStatus = AFSCleanupFcb( pCurrentObject->Fcb,
+ FALSE);
- pCurrentObject->Specific.Directory.DirectoryNodeCount = 0;
+ if ( ntStatus == STATUS_RETRY)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryWorker Reset count to 0 on parent FID %08lX-%08lX-%08lX-%08lX\n",
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ bFcbBusy = TRUE;
+ }
+ }
+ bTemp = AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE);
- //
- // Clear our enumerated flag on this object so we retrieve info again on next access
- //
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
- ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement3 count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount);
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- }
- else
- {
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ if ( bTemp == FALSE)
+ {
- bReleaseVolumeLock = FALSE;
+ *pbReleaseVolumeLock = FALSE;
- break;
- }
+ return bFcbBusy;
+ }
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
- }
- else
- {
+ AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- //
- // Try to grab the volume lock again ... no problem if we don't
- //
+ KeQueryTickCount( &liCurrentTime);
- if( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
- {
+ if( pCurrentObject->ObjectReferenceCount <= 0 &&
+ ( pCurrentObject->Fcb == NULL ||
+ ( pCurrentObject->Fcb->OpenReferenceCount <= 0 &&
+ pCurrentObject->Fcb->Specific.File.ExtentsDirtyCount <= 0)) &&
+ liCurrentTime.QuadPart > pCurrentObject->LastAccessCount.QuadPart &&
+ liCurrentTime.QuadPart - pCurrentObject->LastAccessCount.QuadPart >
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
+ {
- bReleaseVolumeLock = FALSE;
+ AFSRemoveFcb( &pCurrentObject->Fcb);
- break;
- }
- }
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
- if( pCurrentObject != &pVolumeCB->ObjectInformation)
- {
+ AFSDeleteObjectInfo( &pCurrentObject);
+ }
+ else
+ {
- pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ }
- if( pCurrentObject == NULL &&
- pVolumeCB != AFSGlobalRoot)
- {
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ }
+ break;
- pCurrentObject = &pVolumeCB->ObjectInformation;
- }
- }
- else
- {
+ default:
+ {
- pCurrentObject = NULL;
- }
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
- continue;
- }
- else if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
- {
+ if ( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
+ {
- if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED) &&
- pCurrentObject->ObjectReferenceCount == 0 &&
- ( pCurrentObject->Fcb == NULL ||
- pCurrentObject->Fcb->OpenReferenceCount == 0))
- {
+ *pbReleaseVolumeLock = FALSE;
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ return bFcbBusy;
+ }
- if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
- {
+ AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- if( pCurrentObject->Fcb != NULL)
- {
+ KeQueryTickCount( &liCurrentTime);
- AFSCleanupFcb( pCurrentObject->Fcb,
- TRUE);
+ if( pCurrentObject->ObjectReferenceCount <= 0 &&
+ ( pCurrentObject->Fcb == NULL ||
+ pCurrentObject->Fcb->OpenReferenceCount <= 0) &&
+ liCurrentTime.QuadPart > pCurrentObject->LastAccessCount.QuadPart &&
+ liCurrentTime.QuadPart - pCurrentObject->LastAccessCount.QuadPart >
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
+ {
- AFSRemoveFcb( pCurrentObject->Fcb);
- }
+ AFSRemoveFcb( &pCurrentObject->Fcb);
- AFSDeleteObjectInfo( pCurrentObject);
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ AFSDeleteObjectInfo( &pCurrentObject);
+ }
+ else
+ {
- pCurrentObject = pNextObject;
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ }
- continue;
- }
- else
- {
+ AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ }
+ }
- bReleaseVolumeLock = FALSE;
+ return bFcbBusy;
+}
- break;
- }
- }
- else if( pCurrentObject->Fcb != NULL)
- {
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+static BOOLEAN
+AFSExamineVolume( IN AFSVolumeCB *pVolumeCB)
+{
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSObjectInfoCB *pCurrentObject = NULL, *pNextObject = NULL;
+ BOOLEAN bReleaseVolumeLock = FALSE;
+ BOOLEAN bVolumeObject = FALSE;
+ BOOLEAN bFcbBusy = FALSE;
+ LONG lCount;
- if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
- {
+ if( AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
+ {
- AFSCleanupFcb( pCurrentObject->Fcb,
- FALSE);
+ bReleaseVolumeLock = TRUE;
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ pCurrentObject = pVolumeCB->ObjectInfoListHead;
- pCurrentObject = pNextObject;
+ pNextObject = NULL;
- continue;
- }
- else
- {
+ while( pCurrentObject != NULL)
+ {
- bReleaseVolumeLock = FALSE;
+ if( pCurrentObject != &pVolumeCB->ObjectInformation)
+ {
- break;
- }
- }
- }
+ pNextObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
+
+ //
+ // If the end of the VolumeCB ObjectInfo List is reached, then
+ // the next ObjectInformationCB to examine is the one embedded within
+ // the VolumeCB itself except when the VolumeCB is the AFSGlobalRoot.
+ //
+ // bVolumeObject is used to indicate whether the embedded ObjectInfoCB
+ // is being examined.
+ //
- pCurrentObject = pNextObject;
+ if( pNextObject == NULL &&
+ pVolumeCB != AFSGlobalRoot) // Don't free up the root of the global
+ {
+
+ pNextObject = &pVolumeCB->ObjectInformation;
}
- if( bReleaseVolumeLock)
+ bVolumeObject = FALSE;
+
+ if ( pNextObject)
{
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ lCount = AFSObjectInfoIncrement( pNextObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineVolume Increment count on object %p Cnt %d\n",
+ pNextObject,
+ lCount);
}
}
+ else
+ {
- //
- // Next volume cb
- //
+ pNextObject = NULL;
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ bVolumeObject = TRUE;
+ }
- AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
- TRUE);
+ bFcbBusy = AFSExamineObjectInfo( pCurrentObject, bVolumeObject, &bReleaseVolumeLock);
- pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
- }
+ if ( pNextObject)
+ {
- AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+ lCount = AFSObjectInfoDecrement( pNextObject,
+ AFS_OBJECT_REFERENCE_WORKER);
- } // worker thread loop
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineVolume Decrement count on object %p Cnt %d\n",
+ pNextObject,
+ lCount);
+ }
- KeCancelTimer( &Timer);
+ //
+ // If AFSExamineObjectInfo drops the VolumeLock before returning
+ // we must halt processing of the Volume's ObjectInfo list.
+ //
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryVolumeWorkerThread Exiting\n");
+ if ( bReleaseVolumeLock == FALSE)
+ {
- if( InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount) == 0)
- {
+ break;
+ }
- KeSetEvent( &pControlDeviceExt->Specific.Control.VolumeWorkerCloseEvent,
- 0,
- FALSE);
- }
+ pCurrentObject = pNextObject;
+ }
- PsTerminateSystemThread( 0);
+ if( bReleaseVolumeLock)
+ {
- return;
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ }
+ }
+
+ return bFcbBusy;
}
void
-AFSVolumeWorkerThread( IN PVOID Context)
+AFSPrimaryVolumeWorkerThread( IN PVOID Context)
{
- NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSVolumeCB *pVolumeCB = (AFSVolumeCB * )Context;
- AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)&pVolumeCB->VolumeWorkerContext;
- AFSDeviceExt *pControlDeviceExt = NULL;
- AFSDeviceExt *pRDRDeviceExt = NULL;
- BOOLEAN exitThread = FALSE;
+ UNREFERENCED_PARAMETER(Context);
+ AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)&AFSGlobalRoot->NonPagedVcb->VolumeWorkerContext;
+ AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
LARGE_INTEGER DueTime;
LONG TimeOut;
KTIMER Timer;
+ AFSVolumeCB *pVolumeCB = NULL, *pNextVolume = NULL;
+ BOOLEAN bFcbBusy = FALSE;
+ LONG lCount;
- pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
-
- pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPrimaryVolumeWorkerThread Initialized\n");
//
// Initialize the timer for the worker thread
while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
{
- ntStatus = KeWaitForSingleObject( &Timer,
- Executive,
- KernelMode,
- FALSE,
- NULL);
+ if ( bFcbBusy == FALSE)
+ {
- if( !NT_SUCCESS( ntStatus))
+ KeWaitForSingleObject( &Timer,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ }
+ else
+ {
+
+ bFcbBusy = FALSE;
+ }
+
+ //
+ // This is the primary volume worker so it will traverse the volume list
+ // looking for cleanup or volumes requiring private workers
+ //
+
+ AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
+ TRUE);
+
+ pVolumeCB = pRDRDeviceExt->Specific.RDR.VolumeListHead;
+
+ while( pVolumeCB != NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSVolumeWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
- }
- else
- {
+ if( pVolumeCB == AFSGlobalRoot ||
+ !AFSAcquireExcl( pVolumeCB->VolumeLock,
+ FALSE))
+ {
+
+ pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
+
+ continue;
+ }
+
+ if( pVolumeCB->ObjectInfoListHead == NULL)
+ {
+
+ AFSReleaseResource( pVolumeCB->VolumeLock);
+
+ AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+
+ AFSAcquireExcl( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock,
+ TRUE);
+
+ AFSAcquireExcl( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
+ TRUE);
+
+ if( !AFSAcquireExcl( pVolumeCB->VolumeLock,
+ FALSE))
+ {
+
+ AFSConvertToShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+
+ AFSReleaseResource( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock);
+
+ pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
+
+ continue;
+ }
+
+ pNextVolume = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
+
+ AFSAcquireShared( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ //
+ // If VolumeCB is idle, the Volume can be garbage collected
+ //
+
+ if( pVolumeCB->ObjectInfoListHead == NULL &&
+ pVolumeCB->DirectoryCB->DirOpenReferenceCount <= 0 &&
+ pVolumeCB->DirectoryCB->NameArrayReferenceCount <= 0 &&
+ pVolumeCB->VolumeReferenceCount == 0 &&
+ ( pVolumeCB->RootFcb == NULL ||
+ pVolumeCB->RootFcb->OpenReferenceCount == 0) &&
+ pVolumeCB->ObjectInformation.ObjectReferenceCount <= 0)
+ {
+
+ AFSRemoveRootFcb( pVolumeCB);
+
+ AFSReleaseResource( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock);
+
+ AFSRemoveVolume( pVolumeCB);
+ }
+ else
+ {
+
+ AFSReleaseResource( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock);
+
+ AFSReleaseResource( pVolumeCB->VolumeLock);
+ }
+
+ AFSConvertToShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+
+ AFSReleaseResource( pRDRDeviceExt->Specific.RDR.VolumeTree.TreeLock);
+
+ pVolumeCB = pNextVolume;
+
+ continue;
+ }
+
+ //
+ // Don't need this lock anymore now that we have a volume cb to work with
+ //
+
+ AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+
+ //
+ // For now we only need the volume lock shared
+ //
+
+ AFSConvertToShared( pVolumeCB->VolumeLock);
+
+ AFSExamineVolume( pVolumeCB);
//
- // If we are in shutdown mode and the dirty flag is clear then get out now
+ // Next volume cb
//
- if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
- {
+ AFSReleaseResource( pVolumeCB->VolumeLock);
- break;
- }
+ AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
+ TRUE);
+
+ pVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
}
+
+ AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
+
} // worker thread loop
KeCancelTimer( &Timer);
- if( InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount) == 0)
+ ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPrimaryVolumeWorkerThread Exiting\n");
+
+ 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;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInsertWorkitem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
+ "AFSInsertWorkitem Acquiring Control QueueLock lock %p EXCL %08lX\n",
&pDevExt->Specific.Library.QueueLock,
PsGetCurrentThread());
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",
+ "AFSInsertWorkitem Inserting work item %p Count %d\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;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInsertIOWorkitem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
+ "AFSInsertIOWorkitem Acquiring Control QueueLock lock %p EXCL %08lX\n",
&pDevExt->Specific.Library.IOQueueLock,
PsGetCurrentThread());
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",
+ "AFSInsertWorkitem Inserting IO work item %p Count %d\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;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInsertWorkitemAtHead Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
+ "AFSInsertWorkitemAtHead Acquiring Control QueueLock lock %p EXCL %08lX\n",
&pDevExt->Specific.Library.QueueLock,
PsGetCurrentThread());
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",
+ "AFSInsertWorkitemAtHead Inserting work item %p Count %d\n",
WorkItem,
- InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount));
+ lCount);
//
// indicate that the queue has nodes
AFSRemoveWorkItem()
{
- NTSTATUS ntStatus = STATUS_SUCCESS;
AFSWorkItem *pWorkItem = NULL;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSRemoveWorkItem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
+ "AFSRemoveWorkItem Acquiring Control QueueLock lock %p EXCL %08lX\n",
&pDevExt->Specific.Library.QueueLock,
PsGetCurrentThread());
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",
+ "AFSRemoveWorkItem Removing work item %p Count %d 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
+ {
+
+ //
+ // Wake up another worker
+ //
- KeResetEvent(&(pDevExt->Specific.Library.WorkerQueueHasItems));
+ KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
+ 0,
+ FALSE);
}
}
- else
- {
- KeResetEvent(&(pDevExt->Specific.Library.WorkerQueueHasItems));
- }
AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
AFSRemoveIOWorkItem()
{
- NTSTATUS ntStatus = STATUS_SUCCESS;
AFSWorkItem *pWorkItem = NULL;
AFSDeviceExt *pDevExt = NULL;
+ LONG lCount;
pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSRemoveIOWorkItem Acquiring Control QueueLock lock %08lX EXCL %08lX\n",
+ "AFSRemoveIOWorkItem Acquiring Control QueueLock lock %p EXCL %08lX\n",
&pDevExt->Specific.Library.IOQueueLock,
PsGetCurrentThread());
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",
+ "AFSRemoveWorkItem Removing work item %p Count %d 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 ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = NULL;
BOOLEAN bWait = BooleanFlagOn( WorkItem->RequestFlags, AFS_SYNCHRONOUS_REQUEST);
//
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = NULL;
BOOLEAN bWait = BooleanFlagOn( WorkItem->RequestFlags, AFS_SYNCHRONOUS_REQUEST);
//
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = NULL;
BOOLEAN bWait = BooleanFlagOn( WorkItem->RequestFlags, AFS_SYNCHRONOUS_REQUEST);
//
}
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;
+ if ( AuthGroup == NULL)
+ {
+
+ RtlZeroMemory( &pWorkItem->AuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &pWorkItem->AuthGroup);
+ }
+ else
+ {
+ 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);
+ "AFSQueueFlushExtents Increment count on Fcb %p Cnt %d\n",
+ Fcb,
+ lCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueFlushExtents Workitem %08lX for FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSQueueFlushExtents Workitem %p for FID %08lX-%08lX-%08lX-%08lX\n",
pWorkItem,
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
// Remove the count we added above
//
- if( InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount) == 0)
+ lCount = InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount);
+
+ ASSERT( lCount >= 0);
+
+ 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,
"AFSQueueFlushExtents Failed to queue request Status %08lX\n", ntStatus);
}
}
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
AFSDbgLogMsg( 0,
0,
"EXCEPTION - AFSQueueFlushExtents\n");
+
+ AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
-AFSQueueAsyncRead( IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN HANDLE CallerProcess)
+AFSQueueGlobalRootEnumeration()
{
NTSTATUS ntStatus = STATUS_SUCCESS;
__try
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueAsyncRead Queuing request for Irp %08lX\n",
- Irp);
-
pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
sizeof(AFSWorkItem),
AFS_WORK_ITEM_TAG);
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueAsyncRead Failed to allocate work item\n");
+ "AFSQueueGlobalRootEnumeration Failed to allocate work item\n");
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
pWorkItem->Size = sizeof( AFSWorkItem);
- pWorkItem->RequestType = AFS_WORK_ASYNCH_READ;
-
- pWorkItem->Specific.AsynchIo.Device = DeviceObject;
-
- pWorkItem->Specific.AsynchIo.Irp = Irp;
-
- pWorkItem->Specific.AsynchIo.CallingProcess = CallerProcess;
+ pWorkItem->RequestType = AFS_WORK_ENUMERATE_GLOBAL_ROOT;
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueAsyncRead Workitem %08lX for Irp %08lX\n",
- pWorkItem,
- Irp);
+ "AFSQueueGlobalRootEnumeration Workitem %p\n",
+ pWorkItem);
ntStatus = AFSQueueWorkerRequest( pWorkItem);
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueAsyncRead Request for Irp %08lX complete Status %08lX\n",
- Irp,
+ "AFSQueueGlobalRootEnumeration Request complete Status %08lX\n",
ntStatus);
if( !NT_SUCCESS( ntStatus))
if( pWorkItem != NULL)
{
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueAsyncRead Failed to queue request Status %08lX\n", ntStatus);
+ "AFSQueueGlobalRootEnumeration Failed to queue request Status %08lX\n",
+ ntStatus);
}
}
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
AFSDbgLogMsg( 0,
0,
- "EXCEPTION - AFSQueueAsyncRead\n");
+ "EXCEPTION - AFSQueueGlobalRootEnumeration\n");
+
+ AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
-AFSQueueAsyncWrite( IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN HANDLE CallerProcess)
+AFSQueueStartIos( IN PFILE_OBJECT CacheFileObject,
+ IN UCHAR FunctionCode,
+ IN ULONG RequestFlags,
+ IN AFSIoRun *IoRuns,
+ IN ULONG RunCount,
+ IN AFSGatherIo *GatherIo)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSWorkItem *pWorkItem = NULL;
__try
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueAsyncWrite Queuing request for Irp %08lX\n",
- Irp);
+ if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
+ {
- pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
- sizeof(AFSWorkItem),
- AFS_WORK_ITEM_TAG);
- if (NULL == pWorkItem)
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSQueueStartIos Failing request, in shutdown\n");
+
+ try_return( ntStatus = STATUS_TOO_LATE);
+ }
+
+ //
+ // Allocate our request structure and send it to the worker
+ //
+
+ pWorkItem = (AFSWorkItem *)AFSLibExAllocatePoolWithTag( NonPagedPool,
+ sizeof( AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
+
+ if( pWorkItem == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueAsyncWrite Failed to allocate work item\n");
+ "AFSQueueStartIos Failed to allocate work item\n");
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
RtlZeroMemory( pWorkItem,
- sizeof(AFSWorkItem));
+ sizeof( AFSWorkItem));
+
+ KeInitializeEvent( &pWorkItem->Event,
+ NotificationEvent,
+ FALSE);
pWorkItem->Size = sizeof( AFSWorkItem);
- pWorkItem->RequestType = AFS_WORK_ASYNCH_WRITE;
+ pWorkItem->ProcessID = (ULONGLONG)PsGetCurrentProcessId();
- pWorkItem->Specific.AsynchIo.Device = DeviceObject;
+ pWorkItem->RequestType = AFS_WORK_START_IOS;
- pWorkItem->Specific.AsynchIo.Irp = Irp;
+ pWorkItem->Specific.CacheAccess.CacheFileObject = CacheFileObject;
+
+ pWorkItem->Specific.CacheAccess.FunctionCode = FunctionCode;
- pWorkItem->Specific.AsynchIo.CallingProcess = CallerProcess;
+ pWorkItem->Specific.CacheAccess.RequestFlags = RequestFlags;
+
+ pWorkItem->Specific.CacheAccess.IoRuns = IoRuns;
+
+ pWorkItem->Specific.CacheAccess.RunCount = RunCount;
+
+ pWorkItem->Specific.CacheAccess.GatherIo = GatherIo;
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueAsyncWrite Workitem %08lX for Irp %08lX\n",
- pWorkItem,
- Irp);
+ "AFSQueueStartIos Queuing IO Workitem %p\n",
+ pWorkItem);
- ntStatus = AFSQueueWorkerRequest( pWorkItem);
+ ntStatus = AFSQueueIOWorkerRequest( pWorkItem);
try_exit:
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueAsyncWrite Request for Irp %08lX complete Status %08lX\n",
- Irp,
+ "AFSQueueStartIos Request complete Status %08lX\n",
ntStatus);
if( !NT_SUCCESS( ntStatus))
if( pWorkItem != NULL)
{
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSQueueAsyncWrite Failed to queue request Status %08lX\n", ntStatus);
}
}
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
AFSDbgLogMsg( 0,
0,
- "EXCEPTION - AFSQueueAsyncWrite\n");
+ "EXCEPTION - AFSQueueStartIos\n");
+
+ AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
-AFSQueueGlobalRootEnumeration()
+AFSQueueInvalidateObject( IN AFSObjectInfoCB *ObjectInfo,
+ IN ULONG InvalidateReason)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueGlobalRootEnumeration Failed to allocate work item\n");
+ "AFSQueueInvalidateObject Failed to allocate work item\n");
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
pWorkItem->Size = sizeof( AFSWorkItem);
- pWorkItem->RequestType = AFS_WORK_ENUMERATE_GLOBAL_ROOT;
+ 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,
- "AFSQueueGlobalRootEnumeration Workitem %08lX\n",
+ "AFSQueueInvalidateObject Workitem %p\n",
pWorkItem);
ntStatus = AFSQueueWorkerRequest( pWorkItem);
AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueGlobalRootEnumeration Request complete Status %08lX\n",
+ "AFSQueueInvalidateObject Request complete Status %08lX\n",
ntStatus);
if( !NT_SUCCESS( ntStatus))
if( pWorkItem != NULL)
{
-
- ExFreePool( pWorkItem);
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueGlobalRootEnumeration Failed to queue request Status %08lX\n",
+ "AFSQueueInvalidateObject Failed to queue request Status %08lX\n",
ntStatus);
}
}
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
AFSDbgLogMsg( 0,
0,
- "EXCEPTION - AFSQueueGlobalRootEnumeration\n");
+ "EXCEPTION - AFSQueueInvalidateObject\n");
+
+ AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
-AFSQueueStartIos( IN PFILE_OBJECT CacheFileObject,
- IN UCHAR FunctionCode,
- IN ULONG RequestFlags,
- IN AFSIoRun *IoRuns,
- IN ULONG RunCount,
- IN AFSGatherIo *GatherIo)
+AFSDeferWrite( IN PDEVICE_OBJECT DeviceObject,
+ IN PFILE_OBJECT FileObject,
+ IN HANDLE CallingUser,
+ IN PIRP Irp,
+ IN ULONG BytesToWrite,
+ IN BOOLEAN bRetrying)
{
-
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSWorkItem *pWorkItem = NULL;
__try
{
- if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
+ //
+ // Pin the user buffer (first time round only - AFSLockSystemBuffer is
+ // idempotent)
+ //
+
+ if ( NULL == AFSLockSystemBuffer( Irp, BytesToWrite ))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueStartIos Failing request, in shutdown\n");
+ "%s Could not pin user memory item\n",
+ __FUNCTION__);
- try_return( ntStatus = STATUS_TOO_LATE);
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
- //
- // Allocate our request structure and send it to the worker
- //
-
- pWorkItem = (AFSWorkItem *)AFSLibExAllocatePoolWithTag( NonPagedPool,
- sizeof( AFSWorkItem),
- AFS_WORK_ITEM_TAG);
+ pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
+ sizeof(AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
- if( pWorkItem == NULL)
+ if (NULL == pWorkItem)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueStartIos Failed to allocate work item\n");
+ "%s Failed to allocate work item\n",
+ __FUNCTION__);
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
RtlZeroMemory( pWorkItem,
- sizeof( AFSWorkItem));
-
- KeInitializeEvent( &pWorkItem->Event,
- NotificationEvent,
- FALSE);
+ sizeof(AFSWorkItem));
pWorkItem->Size = sizeof( AFSWorkItem);
- pWorkItem->ProcessID = (ULONGLONG)PsGetCurrentProcessId();
+ pWorkItem->RequestType = AFS_WORK_DEFERRED_WRITE;
- pWorkItem->RequestType = AFS_WORK_START_IOS;
+ pWorkItem->Specific.AsynchIo.CallingProcess = CallingUser;
- pWorkItem->Specific.CacheAccess.CacheFileObject = CacheFileObject;
+ pWorkItem->Specific.AsynchIo.Device = DeviceObject;
- pWorkItem->Specific.CacheAccess.FunctionCode = FunctionCode;
+ pWorkItem->Specific.AsynchIo.Irp = Irp;
- pWorkItem->Specific.CacheAccess.RequestFlags = RequestFlags;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING | AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "%s Workitem %p\n",
+ __FUNCTION__,
+ pWorkItem);
- pWorkItem->Specific.CacheAccess.IoRuns = IoRuns;
+ CcDeferWrite( FileObject, AFSPostedDeferredWrite, pWorkItem, NULL, BytesToWrite, bRetrying);
- pWorkItem->Specific.CacheAccess.RunCount = RunCount;
+ IoMarkIrpPending(Irp);
- pWorkItem->Specific.CacheAccess.GatherIo = GatherIo;
+ ntStatus = STATUS_PENDING;
+ }
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueStartIos Queuing IO Workitem %08lX\n",
- pWorkItem);
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - %s \n",
+ __FUNCTION__);
- ntStatus = AFSQueueIOWorkerRequest( pWorkItem);
+ ntStatus = GetExceptionCode();
+ }
try_exit:
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSQueueStartIos Request complete Status %08lX\n",
- ntStatus);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "%s complete Status %08lX\n",
+ __FUNCTION__,
+ ntStatus);
- if( !NT_SUCCESS( ntStatus))
- {
+ if( !NT_SUCCESS( ntStatus))
+ {
- if( pWorkItem != NULL)
- {
+ if( pWorkItem != NULL)
+ {
- ExFreePool( pWorkItem);
- }
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
- }
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
- {
- AFSDbgLogMsg( 0,
- 0,
- "EXCEPTION - AFSQueueStartIos\n");
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "%s Failed to queue request Status %08lX\n",
+ __FUNCTION__,
+ ntStatus);
}
return ntStatus;
}
+
+static
+VOID
+AFSPostedDeferredWrite( IN PVOID Context1,
+ IN PVOID Context2)
+{
+ UNREFERENCED_PARAMETER( Context2);
+ NTSTATUS ntStatus;
+
+ AFSWorkItem *pWorkItem = (AFSWorkItem *) Context1;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING | AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "%s Workitem %p\n",
+ __FUNCTION__,
+ pWorkItem);
+
+ ntStatus = AFSQueueIOWorkerRequest( pWorkItem);
+
+ if (!NT_SUCCESS( ntStatus))
+ {
+
+ AFSCompleteRequest( pWorkItem->Specific.AsynchIo.Irp, ntStatus);
+
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING | AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "%s (%p) Failed to queue request Status %08lX\n",
+ __FUNCTION__,
+ pWorkItem->Specific.AsynchIo.Irp,
+ ntStatus);
+ }
+}
git://git.openafs.org / openafs.git / blobdiff