/*
* Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
- * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Your File System, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
- * notice,
- * this list of conditions and the following disclaimer in the
- * documentation
- * and/or other materials provided with the distribution.
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
* - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
* nor the names of their contributors may be used to endorse or promote
* products derived from this software without specific prior written
#include "AFSCommon.h"
+static
+VOID
+AFSPostedDeferredWrite( IN PVOID Context1,
+ IN PVOID Context2);
+
//
// Function: AFSInitializeWorkerPool
//
// Initialize the worker threads.
//
- pDevExt->Specific.Library.WorkerCount = 0;
-
- KeInitializeEvent( &pDevExt->Specific.Library.WorkerQueueHasItems,
- SynchronizationEvent,
- FALSE);
-
- //
- // Initialize the queue resource
- //
-
- ExInitializeResourceLite( &pDevExt->Specific.Library.QueueLock);
-
while( pDevExt->Specific.Library.WorkerCount < AFS_WORKER_COUNT)
{
if( pCurrentWorker == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSInitializeWorkerPool Failed to allocate worker context\n");
+ "AFSInitializeWorkerPool Failed to allocate worker context\n"));
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSInitializeWorkerPool Failed to initialize worker thread Status %08lX\n", ntStatus);
+ "AFSInitializeWorkerPool Failed to initialize worker thread Status %08lX\n",
+ ntStatus));
ExFreePool( pCurrentWorker);
// Now our IO Worker queue
//
- pDevExt->Specific.Library.IOWorkerCount = 0;
-
- KeInitializeEvent( &pDevExt->Specific.Library.IOWorkerQueueHasItems,
- SynchronizationEvent,
- FALSE);
-
- //
- // Initialize the queue resource
- //
-
- ExInitializeResourceLite( &pDevExt->Specific.Library.IOQueueLock);
-
while( pDevExt->Specific.Library.IOWorkerCount < AFS_IO_WORKER_COUNT)
{
if( pCurrentWorker == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSInitializeWorkerPool Failed to allocate IO worker context\n");
+ "AFSInitializeWorkerPool Failed to allocate IO worker context\n"));
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSInitializeWorkerPool Failed to initialize IO worker thread Status %08lX\n", ntStatus);
+ "AFSInitializeWorkerPool Failed to initialize IO worker thread Status %08lX\n",
+ ntStatus));
ExFreePool( pCurrentWorker);
pDevExt->Specific.Library.PoolHead = NULL;
- ExDeleteResourceLite( &pDevExt->Specific.Library.QueueLock);
-
//
// Loop through the IO workers shutting them down in two stages.
// First, clear AFS_WORKER_PROCESS_REQUESTS so that workers
pDevExt->Specific.Library.IOPoolHead = NULL;
- ExDeleteResourceLite( &pDevExt->Specific.Library.IOQueueLock);
-
return ntStatus;
}
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
if( PoolContext->WorkerThreadObject != NULL)
{
// Wake up the thread if it is a sleep
//
- KeSetEvent( &pDeviceExt->Specific.Library.WorkerQueueHasItems,
+ KeSetEvent( &pControlDeviceExt->Specific.Control.WorkerQueueHasItems,
0,
FALSE);
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
if( PoolContext->WorkerThreadObject != NULL)
{
// Wake up the thread if it is a sleep
//
- KeSetEvent( &pDeviceExt->Specific.Library.IOWorkerQueueHasItems,
+ KeSetEvent( &pControlDeviceExt->Specific.Control.IOWorkerQueueHasItems,
0,
FALSE);
AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)Context;
AFSWorkItem *pWorkItem;
BOOLEAN freeWorkItem = TRUE;
- AFSDeviceExt *pLibraryDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL;
LONG lCount;
- pLibraryDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
//
// Indicate that we are initialized and ready
SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
- ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
+ ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.WorkerQueueHasItems,
Executive,
KernelMode,
FALSE,
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
+ "AFSWorkerThread Wait for queue items failed Status %08lX\n",
+ ntStatus));
ntStatus = STATUS_SUCCESS;
}
if( pWorkItem == NULL)
{
- ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
+ ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.WorkerQueueHasItems,
Executive,
KernelMode,
FALSE,
default:
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSWorkerThread Unknown request type %d\n", pWorkItem->RequestType);
+ "AFSWorkerThread Unknown request type %d\n",
+ pWorkItem->RequestType));
break;
}
// Wake up another worker so they too can exit
- KeSetEvent( &pLibraryDevExt->Specific.Library.WorkerQueueHasItems,
+ KeSetEvent( &pControlDevExt->Specific.Control.WorkerQueueHasItems,
0,
FALSE);
AFSWorkQueueContext *pPoolContext = (AFSWorkQueueContext *)Context;
AFSWorkItem *pWorkItem;
BOOLEAN freeWorkItem = TRUE;
- AFSDeviceExt *pLibraryDevExt = NULL, *pRdrDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL, *pRdrDevExt = NULL;
- pLibraryDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
//
// Indicate that we are initialized and ready
SetFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
- ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
+ ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.IOWorkerQueueHasItems,
Executive,
KernelMode,
FALSE,
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSIOWorkerThread Wait for queue items failed Status %08lX\n", ntStatus);
+ "AFSIOWorkerThread Wait for queue items failed Status %08lX\n",
+ ntStatus));
ntStatus = STATUS_SUCCESS;
}
if( pWorkItem == NULL)
{
- ntStatus = KeWaitForSingleObject( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
+ ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.IOWorkerQueueHasItems,
Executive,
KernelMode,
FALSE,
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,
+ AFSDbgTrace(( 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;
}
// Wake up another IOWorker so they too can exit
- KeSetEvent( &pLibraryDevExt->Specific.Library.IOWorkerQueueHasItems,
+ KeSetEvent( &pControlDevExt->Specific.Control.IOWorkerQueueHasItems,
0,
FALSE);
return;
}
-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;
-
- pCurrentChildObject = pCurrentDirEntry->ObjectInformation;
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineDirectory Deleting DE %wZ Object %p\n",
- &pCurrentDirEntry->NameInformation.FileName,
- pCurrentChildObject);
-
- AFSDeleteDirEntry( pCurrentObject,
- pCurrentDirEntry);
-
- //
- // Acquire ObjectInfoLock shared here so as not to deadlock
- // with an invalidation call from the service during AFSCleanupFcb
- //
-
- lCount = AFSObjectInfoIncrement( pCurrentChildObject,
- AFS_OBJECT_REFERENCE_WORKER);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineDirectory Increment count on object %p Cnt %d\n",
- pCurrentChildObject,
- lCount);
-
- if( lCount == 1 &&
- pCurrentChildObject->Fcb != NULL &&
- pCurrentChildObject->FileType == 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);
-
- //
- // 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
- //
-
- ntStatus = AFSCleanupFcb( pCurrentChildObject->Fcb,
- TRUE);
-
- if ( ntStatus == STATUS_RETRY)
- {
-
- bFcbBusy = TRUE;
- }
-
- AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
- }
-
- AFSAcquireExcl( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock,
- TRUE);
-
- lCount = AFSObjectInfoDecrement( pCurrentChildObject,
- AFS_OBJECT_REFERENCE_WORKER);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineDirectory Decrement1 count on object %p Cnt %d\n",
- pCurrentChildObject,
- lCount);
-
- if( lCount == 0 &&
- pCurrentChildObject->Fcb != NULL &&
- pCurrentChildObject->Fcb->OpenReferenceCount == 0)
- {
-
- AFSRemoveFcb( &pCurrentChildObject->Fcb);
-
- if( pCurrentChildObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
- pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
- {
-
- AFSAcquireExcl( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
- TRUE);
-
- AFSRemoveFcb( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
-
- AFSReleaseResource( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
-
- AFSDeleteObjectInfo( &pCurrentChildObject->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,
- "AFSExamineDirectory (pioctl) AFS_DIR_ENTRY_TAG deallocating %p\n",
- pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB);
-
- AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
- }
-
- AFSReleaseResource( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineDirectory Deleting object %p\n",
- pCurrentChildObject);
-
- AFSDeleteObjectInfo( &pCurrentChildObject);
- }
- else
- {
-
- AFSReleaseResource( &pCurrentChildObject->NonPagedInfo->ObjectInfoLock);
- }
-
- return bFcbBusy;
-}
-
//
-// Called with VolumeCB->ObjectInfoTree.TreeLock held shared.
-// The TreeLock will be released unless *pbReleaseVolumeLock is set to FALSE.
+// Called with VolumeCB->ObjectInfoTree.TreeLock held exclusive.
+// pCurrentObject->ObjectReferenceCount is incremented by the caller.
+//
+// The *pbReleaseVolumeLock is set to FALSE if the TreeLock is dropped
+// before returning.
+//
+// pCurrentObject must either be destroyed or the reference count
+// decremented before returning.
//
-static BOOLEAN
+static void
AFSExamineObjectInfo( IN AFSObjectInfoCB * pCurrentObject,
IN BOOLEAN bVolumeObject,
IN OUT BOOLEAN * pbReleaseVolumeLock)
AFSObjectInfoCB *pCurrentChildObject = NULL;
AFSVolumeCB * pVolumeCB = pCurrentObject->VolumeCB;
LARGE_INTEGER liCurrentTime;
- BOOLEAN bFcbBusy = FALSE;
LONG lCount;
BOOLEAN bTemp;
- switch ( pCurrentObject->FileType) {
+ __Enter
+ {
+
+ ASSERT( ExIsResourceAcquiredExclusiveLite( pVolumeCB->ObjectInfoTree.TreeLock));
+
+ switch ( pCurrentObject->FileType)
+ {
- case AFS_FILE_TYPE_DIRECTORY:
+ case AFS_FILE_TYPE_DIRECTORY:
{
if ( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
{
- return FALSE;
+ try_return( ntStatus);
}
//
// If this object is deleted then remove it from the parent, if we can
//
- 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)
+ if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DELETED))
{
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
-
- //
- // Dropping the TreeLock permits the
- // pCurrentObject->ObjectReferenceCount to change
- //
-
- if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
+ if ( pCurrentObject->ObjectReferenceCount == 1 &&
+ ( pCurrentObject->Fcb == NULL ||
+ pCurrentObject->Fcb->OpenReferenceCount == 0) &&
+ pCurrentObject->Specific.Directory.DirectoryNodeListHead == NULL &&
+ pCurrentObject->Specific.Directory.ChildOpenReferenceCount == 0)
{
AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
TRUE);
- if ( pCurrentObject->ObjectReferenceCount <= 0)
+ if ( pCurrentObject->Fcb != NULL)
{
AFSRemoveFcb( &pCurrentObject->Fcb);
+ }
- if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
- {
+ if( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB != NULL)
+ {
- AFSAcquireExcl( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
- TRUE);
+ AFSAcquireExcl( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- AFSRemoveFcb( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
+ AFSRemoveFcb( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->Fcb);
- AFSReleaseResource( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
+ AFSReleaseResource( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation->NonPagedInfo->ObjectInfoLock);
- AFSDeleteObjectInfo( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
+ lCount = AFSObjectInfoDecrement( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation,
+ AFS_OBJECT_REFERENCE_PIOCTL);
- ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement count on object %p Cnt %d\n",
+ pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation,
+ lCount));
- AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged, AFS_DIR_ENTRY_NP_TAG);
+ ASSERT( lCount == 0);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineObjectInfo (pioctl) AFS_DIR_ENTRY_TAG deallocating %p\n",
- pCurrentObject->Specific.Directory.PIOCtlDirectoryCB);
+ if ( lCount == 0)
+ {
- AFSExFreePoolWithTag( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
+ AFSDeleteObjectInfo( &pCurrentObject->Specific.Directory.PIOCtlDirectoryCB->ObjectInformation);
}
- AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ ExDeleteResourceLite( &pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged->Lock);
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFSExFreePoolWithTag( pCurrentChildObject->Specific.Directory.PIOCtlDirectoryCB->NonPaged, AFS_DIR_ENTRY_NP_TAG);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineObjectInfo Deleting deleted object %p\n",
- pCurrentObject);
+ "AFSExamineObjectInfo (pioctl) AFS_DIR_ENTRY_TAG deallocating %p\n",
+ pCurrentObject->Specific.Directory.PIOCtlDirectoryCB));
- AFSDeleteObjectInfo( &pCurrentObject);
- }
- else
- {
+ AFSExFreePoolWithTag( pCurrentObject->Specific.Directory.PIOCtlDirectoryCB, AFS_DIR_ENTRY_TAG);
- AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ pCurrentObject->Specific.Directory.PIOCtlDirectoryCB = NULL;
}
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
- }
- else
- {
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
- *pbReleaseVolumeLock = FALSE;
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement1 count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Deleting deleted object %p\n",
+ pCurrentObject));
+
+ //
+ // The CurrentReferenceCount must be zero or we would not
+ // have gotten this far. It is safe to delete the ObjectInfoCB.
+ //
+
+ AFSDeleteObjectInfo( &pCurrentObject);
}
- return bFcbBusy;
+ //
+ // Finished processing the AFS_OBJECT_FLAGS_DELETED case.
+ //
+
+ try_return( ntStatus);
}
+ //
+ // pCurrentObject not marked Deleted.
+ //
+
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);
- }
- }
-
- return bFcbBusy;
+ try_return( ntStatus);
}
if( pCurrentObject->Specific.Directory.ChildOpenReferenceCount > 0 ||
pCurrentObject->Fcb->OpenReferenceCount > 0))
{
- return bFcbBusy;
+ try_return( ntStatus);
}
- if ( pCurrentObject->FileType != AFS_FILE_TYPE_DIRECTORY ||
+ if ( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
pCurrentObject->Specific.Directory.DirectoryNodeListHead != NULL)
{
+ //
+ // Directory Entry Processing
+ //
+ // First pass is performed with the TreeLock held shared.
+ // If we detect any objects in use, we give up quickly without
+ // making any changes and without blocking other threads.
+ // The second pass is performed with the TreeLock held exclusive
+ // so deletions can take place.
+ //
+
if( !AFSAcquireShared( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
FALSE))
{
- return bFcbBusy;
+ try_return( ntStatus);
}
- pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
-
- //
- // Directory Entry Processing
- //
-
KeQueryTickCount( &liCurrentTime);
+ pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
+
while( pCurrentDirEntry != NULL)
{
- if( pCurrentDirEntry->DirOpenReferenceCount > 0)
+ if( pCurrentDirEntry->DirOpenReferenceCount > 0 ||
+ pCurrentDirEntry->NameArrayReferenceCount > 0)
{
- break;
- }
-
- if ( pCurrentDirEntry->NameArrayReferenceCount > 0)
- {
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- break;
+ try_return( ntStatus);
}
- if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0)
+ if ( pCurrentDirEntry->ObjectInformation != NULL)
{
- break;
- }
-
- if ( liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
- liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
- pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
- {
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0)
+ {
- break;
- }
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
+ try_return( ntStatus);
+ }
- if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
+ if ( liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
+ liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
{
- break;
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ try_return( ntStatus);
}
- if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
{
- break;
- }
- }
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
+ {
- if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE)
- {
+ break;
+ }
- if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0)
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
+ {
+
+ break;
+ }
+ }
+
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE)
{
- break;
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0)
+ {
+
+ break;
+ }
}
}
pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
}
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
if( pCurrentDirEntry != NULL)
{
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
-
- return bFcbBusy;
+ try_return( ntStatus);
}
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
-
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
-
//
- // Now acquire the locks excl without deadlocking
+ // Attempt the second pass with the TreeLock held exclusive.
+ // The the TreeLock cannot be obtained without blocking it means that
+ // the directory is in active use, so do nothing.
//
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;
+ try_return( ntStatus);
}
KeQueryTickCount( &liCurrentTime);
break;
}
- if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0)
- {
-
- break;
- }
-
- if ( liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
- liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
- pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
+ if ( pCurrentDirEntry->ObjectInformation != NULL)
{
- break;
- }
-
- if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
-
- if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->OpenReferenceCount > 0)
{
break;
}
- if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
+ if ( liCurrentTime.QuadPart <= pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart ||
+ liCurrentTime.QuadPart - pCurrentDirEntry->ObjectInformation->LastAccessCount.QuadPart <
+ pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
{
break;
}
- }
- if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE)
- {
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
- if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
- pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0)
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeListHead != NULL)
+ {
+
+ break;
+ }
+
+ if ( pCurrentDirEntry->ObjectInformation->Specific.Directory.ChildOpenReferenceCount > 0)
+ {
+
+ break;
+ }
+ }
+
+ if ( pCurrentDirEntry->ObjectInformation->FileType == AFS_FILE_TYPE_FILE)
{
- break;
+ if ( pCurrentDirEntry->ObjectInformation->Fcb != NULL &&
+ pCurrentDirEntry->ObjectInformation->Fcb->Specific.File.ExtentsDirtyCount > 0)
+ {
+
+ break;
+ }
}
}
if( pCurrentDirEntry != NULL)
{
- AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ //
+ // At least one entry in the directory is actively in use.
+ // Drop the lock and exit without removing anything.
+ //
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- return bFcbBusy;
+ try_return( ntStatus);
}
+ //
+ // Third pass, process each directory entry and remove what we can.
+ // The VolumeCB TreeLock and the ObjectInfo TreeLock are still held exclusive.
+ //
+
pCurrentDirEntry = pCurrentObject->Specific.Directory.DirectoryNodeListHead;
while( pCurrentDirEntry != NULL)
pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
- AFSExamineDirectory( pCurrentObject,
- pCurrentDirEntry);
+ //
+ // Delete the DirectoryCB which in turn removes the DIRENTRY reference
+ // count from the associated ObjectInfoCB. The reference count held above
+ // may now be the only one left.
+ //
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Deleting DE %wZ Object %p\n",
+ &pCurrentDirEntry->NameInformation.FileName,
+ pCurrentDirEntry->ObjectInformation));
+
+ AFSDeleteDirEntry( pCurrentObject,
+ &pCurrentDirEntry);
pCurrentDirEntry = pNextDirEntry;
}
ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
-
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
- }
- else
- {
-
- //
- // Try to grab the volume lock again ... no problem if we don't
- //
-
- if( !AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
- {
-
- *pbReleaseVolumeLock = FALSE;
-
- return bFcbBusy;
- }
}
}
else if ( bVolumeObject == FALSE)
// No children
//
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
-
- if ( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
+ if( pCurrentObject->ObjectReferenceCount > 1 ||
+ pCurrentObject->Fcb != NULL &&
+ pCurrentObject->Fcb->OpenReferenceCount > 0)
{
- *pbReleaseVolumeLock = FALSE;
-
- return bFcbBusy;
+ try_return( ntStatus);
}
AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
KeQueryTickCount( &liCurrentTime);
- if( pCurrentObject->ObjectReferenceCount <= 0 &&
+ if( pCurrentObject->ObjectReferenceCount == 1 &&
( pCurrentObject->Fcb == NULL ||
- pCurrentObject->Fcb->OpenReferenceCount <= 0) &&
+ pCurrentObject->Fcb->OpenReferenceCount == 0) &&
liCurrentTime.QuadPart > pCurrentObject->LastAccessCount.QuadPart &&
liCurrentTime.QuadPart - pCurrentObject->LastAccessCount.QuadPart >
pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement4 count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
+
+ //
+ // The Volume TreeLock is held exclusive. Therefore, the ObjectReferenceCount
+ // cannot change. It is therefore safe to delete the ObjectInfoCB
+ //
+
AFSDeleteObjectInfo( &pCurrentObject);
}
else
AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
}
-
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
}
+
+ break;
}
- break;
- case AFS_FILE_TYPE_FILE:
+ case AFS_FILE_TYPE_FILE:
{
- lCount = AFSObjectInfoIncrement( pCurrentObject,
- AFS_OBJECT_REFERENCE_WORKER);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineObjectInfo Increment3 count on object %p Cnt %d\n",
- pCurrentObject,
- lCount);
+ if( pCurrentObject->ObjectReferenceCount > 1 ||
+ pCurrentObject->Fcb != NULL &&
+ pCurrentObject->Fcb->OpenReferenceCount > 0)
+ {
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ try_return( ntStatus);
+ }
if( pCurrentObject->Fcb != NULL)
{
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+
//
- // Dropping the TreeLock permits the
- // pCurrentObject->ObjectReferenceCount to change
+ // Dropping the VolumeCB TreeLock permits the
+ // pCurrentObject->ObjectReferenceCount to change.
+ // But it cannot be held across the AFSCleanupFcb
+ // call.
//
ntStatus = AFSCleanupFcb( pCurrentObject->Fcb,
FALSE);
- if ( ntStatus == STATUS_RETRY)
+ if (!AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ FALSE))
{
- bFcbBusy = TRUE;
+ *pbReleaseVolumeLock = FALSE;
}
- }
-
- bTemp = AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE);
- lCount = AFSObjectInfoDecrement( pCurrentObject,
- AFS_OBJECT_REFERENCE_WORKER);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineObjectInfo Decrement3 count on object %p Cnt %d\n",
- pCurrentObject,
- lCount);
-
-
- if ( bTemp == FALSE)
- {
+ if ( ntStatus == STATUS_RETRY ||
+ *pbReleaseVolumeLock == FALSE)
+ {
- *pbReleaseVolumeLock = FALSE;
+ //
+ // The Fcb is in use.
+ //
- return bFcbBusy;
+ try_return( ntStatus);
+ }
}
+ //
+ // VolumeCB is held exclusive
+ //
+
AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
TRUE);
KeQueryTickCount( &liCurrentTime);
- if( pCurrentObject->ObjectReferenceCount <= 0 &&
+ if( pCurrentObject->ObjectReferenceCount == 1 &&
( pCurrentObject->Fcb == NULL ||
- ( pCurrentObject->Fcb->OpenReferenceCount <= 0 &&
- pCurrentObject->Fcb->Specific.File.ExtentsDirtyCount <= 0)) &&
+ ( 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)
AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement5 count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
+
+ //
+ // The VolumeCB TreeLock is held exclusive so the
+ // ObjectReferenceCount cannot change.
+ //
+
AFSDeleteObjectInfo( &pCurrentObject);
}
else
AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
}
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ break;
}
- break;
- default:
+ default:
{
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
-
- if ( !AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
- {
-
- *pbReleaseVolumeLock = FALSE;
-
- return bFcbBusy;
- }
-
AFSAcquireExcl( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
TRUE);
KeQueryTickCount( &liCurrentTime);
- if( pCurrentObject->ObjectReferenceCount <= 0 &&
+ if( pCurrentObject->ObjectReferenceCount == 1 &&
( pCurrentObject->Fcb == NULL ||
- pCurrentObject->Fcb->OpenReferenceCount <= 0) &&
+ pCurrentObject->Fcb->OpenReferenceCount == 0) &&
liCurrentTime.QuadPart > pCurrentObject->LastAccessCount.QuadPart &&
liCurrentTime.QuadPart - pCurrentObject->LastAccessCount.QuadPart >
pControlDeviceExt->Specific.Control.ObjectLifeTimeCount.QuadPart)
AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement6 count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
+
+ //
+ // The VolumeCB TreeLock is held exclusive so the
+ // ObjectReferenceCount cannot change.
+ //
+
AFSDeleteObjectInfo( &pCurrentObject);
}
else
AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
}
+ }
+ }
+
+ try_exit:
- AFSConvertToShared( pVolumeCB->ObjectInfoTree.TreeLock);
+ if ( pCurrentObject != NULL)
+ {
+
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineObjectInfo Decrement count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
}
}
-
- return bFcbBusy;
}
+//
+// Called with VolumeCB->VolumeLock held shared.
+//
-static BOOLEAN
+static void
AFSExamineVolume( IN AFSVolumeCB *pVolumeCB)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSObjectInfoCB *pCurrentObject = NULL, *pNextObject = NULL;
- BOOLEAN bReleaseVolumeLock = FALSE;
+ BOOLEAN bReleaseVolumeTreeLock = FALSE;
BOOLEAN bVolumeObject = FALSE;
- BOOLEAN bFcbBusy = FALSE;
LONG lCount;
- if( AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
- FALSE))
+ //
+ // The Volume ObjectInfoTree TreeLock must be held exclusive to
+ // prevent other threads from obtaining a reference to an ObjectInfoCB
+ // via AFSFindObjectInfo() while it is being deleted. This is
+ // annoying but the alternative is to hold the TreeLock shared during
+ // garbage collection and exclusive during find operations.
+ //
+
+ if( AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE))
{
- bReleaseVolumeLock = TRUE;
+ bReleaseVolumeTreeLock = TRUE;
pCurrentObject = pVolumeCB->ObjectInfoListHead;
+ lCount = AFSObjectInfoIncrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineVolume Increment count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
+
pNextObject = NULL;
- while( pCurrentObject != NULL)
+ while( pCurrentObject != NULL &&
+ bReleaseVolumeTreeLock == TRUE)
{
if( pCurrentObject != &pVolumeCB->ObjectInformation)
lCount = AFSObjectInfoIncrement( pNextObject,
AFS_OBJECT_REFERENCE_WORKER);
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSExamineVolume Increment count on object %p Cnt %d\n",
pNextObject,
- lCount);
+ lCount));
}
}
else
bVolumeObject = TRUE;
}
- bFcbBusy = AFSExamineObjectInfo( pCurrentObject, bVolumeObject, &bReleaseVolumeLock);
-
- if ( pNextObject)
- {
-
- lCount = AFSObjectInfoDecrement( pNextObject,
- AFS_OBJECT_REFERENCE_WORKER);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExamineVolume Decrement count on object %p Cnt %d\n",
- pNextObject,
- lCount);
- }
+ AFSExamineObjectInfo( pCurrentObject, bVolumeObject, &bReleaseVolumeTreeLock);
//
- // If AFSExamineObjectInfo drops the VolumeLock before returning
- // we must halt processing of the Volume's ObjectInfo list.
+ // The CurrentObject is either destroyed or the reference count has been
+ // dropped by AFSExamineObjectInfo().
//
- if ( bReleaseVolumeLock == FALSE)
+ if ( bReleaseVolumeTreeLock == FALSE)
{
- break;
+ //
+ // Try to obtain the Volume's ObjectInfoTree.TreeLock after dropping
+ // other locks and continue.
+ //
+
+ bReleaseVolumeTreeLock = AFSAcquireExcl( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
}
pCurrentObject = pNextObject;
+
+ pNextObject = NULL;
+ }
+
+ if ( pCurrentObject != NULL)
+ {
+
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_WORKER);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSExamineVolume Decrement count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount));
}
- if( bReleaseVolumeLock)
+ if( bReleaseVolumeTreeLock)
{
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
}
}
-
- return bFcbBusy;
}
void
LONG TimeOut;
KTIMER Timer;
AFSVolumeCB *pVolumeCB = NULL, *pNextVolume = NULL;
- BOOLEAN bFcbBusy = FALSE;
LONG lCount;
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryVolumeWorkerThread Initialized\n");
+ "AFSPrimaryVolumeWorkerThread Initialized\n"));
//
// Initialize the timer for the worker thread
while( BooleanFlagOn( pPoolContext->State, AFS_WORKER_PROCESS_REQUESTS))
{
- if ( bFcbBusy == FALSE)
- {
-
- KeWaitForSingleObject( &Timer,
- Executive,
- KernelMode,
- FALSE,
- NULL);
- }
- else
- {
-
- bFcbBusy = FALSE;
- }
+ KeWaitForSingleObject( &Timer,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
//
// This is the primary volume worker so it will traverse the volume list
pNextVolume = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
- AFSAcquireShared( &pVolumeCB->ObjectInformation.NonPagedInfo->ObjectInfoLock,
- TRUE);
+ AFSAcquireExcl( &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 == 1 &&
+ pVolumeCB->VolumeReferenceCount == 0 &&
( pVolumeCB->RootFcb == NULL ||
pVolumeCB->RootFcb->OpenReferenceCount == 0) &&
pVolumeCB->ObjectInformation.ObjectReferenceCount <= 0)
ClearFlag( pPoolContext->State, AFS_WORKER_INITIALIZED);
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPrimaryVolumeWorkerThread Exiting\n");
+ "AFSPrimaryVolumeWorkerThread Exiting\n"));
lCount = InterlockedDecrement( &pControlDeviceExt->Specific.Control.VolumeWorkerThreadCount);
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL;
LONG lCount;
- pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitem Acquiring Control QueueLock lock %p EXCL %08lX\n",
- &pDevExt->Specific.Library.QueueLock,
- PsGetCurrentThread());
+ &pControlDevExt->Specific.Control.QueueLock,
+ PsGetCurrentThread()));
- AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
+ AFSAcquireExcl( &pControlDevExt->Specific.Control.QueueLock,
TRUE);
- lCount = InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount);
+ lCount = InterlockedIncrement( &pControlDevExt->Specific.Control.QueueItemCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitem Inserting work item %p Count %d\n",
WorkItem,
- lCount);
+ lCount));
- if( pDevExt->Specific.Library.QueueTail != NULL) // queue already has nodes
+ if( pControlDevExt->Specific.Control.QueueTail != NULL) // queue already has nodes
{
- pDevExt->Specific.Library.QueueTail->next = WorkItem;
+ pControlDevExt->Specific.Control.QueueTail->next = WorkItem;
}
else // first node
{
- pDevExt->Specific.Library.QueueHead = WorkItem;
+ pControlDevExt->Specific.Control.QueueHead = WorkItem;
}
WorkItem->next = NULL;
- pDevExt->Specific.Library.QueueTail = WorkItem;
+ pControlDevExt->Specific.Control.QueueTail = WorkItem;
// indicate that the queue has nodes
- KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
+ KeSetEvent( &(pControlDevExt->Specific.Control.WorkerQueueHasItems),
0,
FALSE);
- AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
+ AFSReleaseResource( &pControlDevExt->Specific.Control.QueueLock);
return ntStatus;
}
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL;
LONG lCount;
- pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertIOWorkitem Acquiring Control QueueLock lock %p EXCL %08lX\n",
- &pDevExt->Specific.Library.IOQueueLock,
- PsGetCurrentThread());
+ &pControlDevExt->Specific.Control.IOQueueLock,
+ PsGetCurrentThread()));
- AFSAcquireExcl( &pDevExt->Specific.Library.IOQueueLock,
+ AFSAcquireExcl( &pControlDevExt->Specific.Control.IOQueueLock,
TRUE);
- lCount = InterlockedIncrement( &pDevExt->Specific.Library.IOQueueItemCount);
+ lCount = InterlockedIncrement( &pControlDevExt->Specific.Control.IOQueueItemCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitem Inserting IO work item %p Count %d\n",
WorkItem,
- lCount);
+ lCount));
- if( pDevExt->Specific.Library.IOQueueTail != NULL) // queue already has nodes
+ if( pControlDevExt->Specific.Control.IOQueueTail != NULL) // queue already has nodes
{
- pDevExt->Specific.Library.IOQueueTail->next = WorkItem;
+ pControlDevExt->Specific.Control.IOQueueTail->next = WorkItem;
}
else // first node
{
- pDevExt->Specific.Library.IOQueueHead = WorkItem;
+ pControlDevExt->Specific.Control.IOQueueHead = WorkItem;
}
WorkItem->next = NULL;
- pDevExt->Specific.Library.IOQueueTail = WorkItem;
+ pControlDevExt->Specific.Control.IOQueueTail = WorkItem;
// indicate that the queue has nodes
- KeSetEvent( &(pDevExt->Specific.Library.IOWorkerQueueHasItems),
+ KeSetEvent( &(pControlDevExt->Specific.Control.IOWorkerQueueHasItems),
0,
FALSE);
- AFSReleaseResource( &pDevExt->Specific.Library.IOQueueLock);
+ AFSReleaseResource( &pControlDevExt->Specific.Control.IOQueueLock);
return ntStatus;
}
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL;
LONG lCount;
- pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitemAtHead Acquiring Control QueueLock lock %p EXCL %08lX\n",
- &pDevExt->Specific.Library.QueueLock,
- PsGetCurrentThread());
+ &pControlDevExt->Specific.Control.QueueLock,
+ PsGetCurrentThread()));
- AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
+ AFSAcquireExcl( &pControlDevExt->Specific.Control.QueueLock,
TRUE);
- WorkItem->next = pDevExt->Specific.Library.QueueHead;
+ WorkItem->next = pControlDevExt->Specific.Control.QueueHead;
- pDevExt->Specific.Library.QueueHead = WorkItem;
+ pControlDevExt->Specific.Control.QueueHead = WorkItem;
- lCount = InterlockedIncrement( &pDevExt->Specific.Library.QueueItemCount);
+ lCount = InterlockedIncrement( &pControlDevExt->Specific.Control.QueueItemCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertWorkitemAtHead Inserting work item %p Count %d\n",
WorkItem,
- lCount);
+ lCount));
//
// indicate that the queue has nodes
//
- KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
+ KeSetEvent( &(pControlDevExt->Specific.Control.WorkerQueueHasItems),
0,
FALSE);
- AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
+ AFSReleaseResource( &pControlDevExt->Specific.Control.QueueLock);
return ntStatus;
}
{
AFSWorkItem *pWorkItem = NULL;
- AFSDeviceExt *pDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL;
LONG lCount;
- pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveWorkItem Acquiring Control QueueLock lock %p EXCL %08lX\n",
- &pDevExt->Specific.Library.QueueLock,
- PsGetCurrentThread());
+ &pControlDevExt->Specific.Control.QueueLock,
+ PsGetCurrentThread()));
- AFSAcquireExcl( &pDevExt->Specific.Library.QueueLock,
+ AFSAcquireExcl( &pControlDevExt->Specific.Control.QueueLock,
TRUE);
- if( pDevExt->Specific.Library.QueueHead != NULL) // queue has nodes
+ if( pControlDevExt->Specific.Control.QueueHead != NULL) // queue has nodes
{
- pWorkItem = pDevExt->Specific.Library.QueueHead;
+ pWorkItem = pControlDevExt->Specific.Control.QueueHead;
- lCount = InterlockedDecrement( &pDevExt->Specific.Library.QueueItemCount);
+ lCount = InterlockedDecrement( &pControlDevExt->Specific.Control.QueueItemCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveWorkItem Removing work item %p Count %d Thread %08lX\n",
pWorkItem,
lCount,
- PsGetCurrentThreadId());
+ PsGetCurrentThreadId()));
- pDevExt->Specific.Library.QueueHead = pDevExt->Specific.Library.QueueHead->next;
+ pControlDevExt->Specific.Control.QueueHead = pControlDevExt->Specific.Control.QueueHead->next;
- if( pDevExt->Specific.Library.QueueHead == NULL) // if queue just became empty
+ if( pControlDevExt->Specific.Control.QueueHead == NULL) // if queue just became empty
{
- pDevExt->Specific.Library.QueueTail = NULL;
+ pControlDevExt->Specific.Control.QueueTail = NULL;
}
else
{
// Wake up another worker
//
- KeSetEvent( &(pDevExt->Specific.Library.WorkerQueueHasItems),
+ KeSetEvent( &(pControlDevExt->Specific.Control.WorkerQueueHasItems),
0,
FALSE);
}
}
- AFSReleaseResource( &pDevExt->Specific.Library.QueueLock);
+ AFSReleaseResource( &pControlDevExt->Specific.Control.QueueLock);
return pWorkItem;
}
{
AFSWorkItem *pWorkItem = NULL;
- AFSDeviceExt *pDevExt = NULL;
+ AFSDeviceExt *pControlDevExt = NULL;
LONG lCount;
- pDevExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
+ pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveIOWorkItem Acquiring Control QueueLock lock %p EXCL %08lX\n",
- &pDevExt->Specific.Library.IOQueueLock,
- PsGetCurrentThread());
+ &pControlDevExt->Specific.Control.IOQueueLock,
+ PsGetCurrentThread()));
- AFSAcquireExcl( &pDevExt->Specific.Library.IOQueueLock,
+ AFSAcquireExcl( &pControlDevExt->Specific.Control.IOQueueLock,
TRUE);
- if( pDevExt->Specific.Library.IOQueueHead != NULL) // queue has nodes
+ if( pControlDevExt->Specific.Control.IOQueueHead != NULL) // queue has nodes
{
- pWorkItem = pDevExt->Specific.Library.IOQueueHead;
+ pWorkItem = pControlDevExt->Specific.Control.IOQueueHead;
- lCount = InterlockedDecrement( &pDevExt->Specific.Library.IOQueueItemCount);
+ lCount = InterlockedDecrement( &pControlDevExt->Specific.Control.IOQueueItemCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveWorkItem Removing work item %p Count %d Thread %08lX\n",
pWorkItem,
lCount,
- PsGetCurrentThreadId());
+ PsGetCurrentThreadId()));
- pDevExt->Specific.Library.IOQueueHead = pDevExt->Specific.Library.IOQueueHead->next;
+ pControlDevExt->Specific.Control.IOQueueHead = pControlDevExt->Specific.Control.IOQueueHead->next;
- if( pDevExt->Specific.Library.IOQueueHead == NULL) // if queue just became empty
+ if( pControlDevExt->Specific.Control.IOQueueHead == NULL) // if queue just became empty
{
- pDevExt->Specific.Library.IOQueueTail = NULL;
+ pControlDevExt->Specific.Control.IOQueueTail = NULL;
}
else
{
// Wake up another worker
//
- KeSetEvent( &(pDevExt->Specific.Library.IOWorkerQueueHasItems),
+ KeSetEvent( &(pControlDevExt->Specific.Control.IOWorkerQueueHasItems),
0,
FALSE);
}
}
- AFSReleaseResource( &pDevExt->Specific.Library.IOQueueLock);
+ AFSReleaseResource( &pControlDevExt->Specific.Control.IOQueueLock);
return pWorkItem;
}
__try
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueFlushExtents Queuing request for FID %08lX-%08lX-%08lX-%08lX\n",
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
Fcb->ObjectInformation->FileId.Vnode,
- Fcb->ObjectInformation->FileId.Unique);
+ Fcb->ObjectInformation->FileId.Unique));
//
// Increment our flush count here just to keep the number of items in the
if( lCount > 3)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueFlushExtents Max queued items for FID %08lX-%08lX-%08lX-%08lX\n",
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
Fcb->ObjectInformation->FileId.Vnode,
- Fcb->ObjectInformation->FileId.Unique);
+ Fcb->ObjectInformation->FileId.Unique));
try_return( ntStatus);
}
if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueFlushExtents Failing request, in shutdown\n");
+ "AFSQueueFlushExtents 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);
+ pWorkItem = (AFSWorkItem *)AFSExAllocatePoolWithTag( NonPagedPool,
+ sizeof( AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
if( pWorkItem == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueFlushExtents Failed to allocate work item\n");
+ "AFSQueueFlushExtents Failed to allocate work item\n"));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
lCount = InterlockedIncrement( &Fcb->OpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FCB_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FCB_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueFlushExtents Increment count on Fcb %p Cnt %d\n",
Fcb,
- lCount);
+ lCount));
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueFlushExtents Workitem %p for FID %08lX-%08lX-%08lX-%08lX\n",
pWorkItem,
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
Fcb->ObjectInformation->FileId.Vnode,
- Fcb->ObjectInformation->FileId.Unique);
+ Fcb->ObjectInformation->FileId.Unique));
ntStatus = AFSQueueWorkerRequest( pWorkItem);
try_exit:
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueFlushExtents Request complete Status %08lX FID %08lX-%08lX-%08lX-%08lX\n",
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
Fcb->ObjectInformation->FileId.Vnode,
Fcb->ObjectInformation->FileId.Unique,
- ntStatus);
+ ntStatus));
//
// Remove the count we added above
ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueFlushExtents Failed to queue request Status %08lX\n", ntStatus);
+ "AFSQueueFlushExtents Failed to queue request Status %08lX\n",
+ ntStatus));
}
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
- AFSDbgLogMsg( 0,
+ AFSDbgTrace(( 0,
0,
- "EXCEPTION - AFSQueueFlushExtents\n");
+ "EXCEPTION - AFSQueueFlushExtents\n"));
AFSDumpTraceFilesFnc();
}
__try
{
- pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
- sizeof(AFSWorkItem),
- AFS_WORK_ITEM_TAG);
+ pWorkItem = (AFSWorkItem *) AFSExAllocatePoolWithTag( NonPagedPool,
+ sizeof(AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
if (NULL == pWorkItem)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueGlobalRootEnumeration Failed to allocate work item\n");
+ "AFSQueueGlobalRootEnumeration Failed to allocate work item\n"));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
pWorkItem->RequestType = AFS_WORK_ENUMERATE_GLOBAL_ROOT;
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueGlobalRootEnumeration Workitem %p\n",
- pWorkItem);
+ pWorkItem));
ntStatus = AFSQueueWorkerRequest( pWorkItem);
try_exit:
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueGlobalRootEnumeration Request complete Status %08lX\n",
- ntStatus);
+ ntStatus));
if( !NT_SUCCESS( ntStatus))
{
ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSQueueGlobalRootEnumeration Failed to queue request Status %08lX\n",
- ntStatus);
+ ntStatus));
}
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
- AFSDbgLogMsg( 0,
+ AFSDbgTrace(( 0,
0,
- "EXCEPTION - AFSQueueGlobalRootEnumeration\n");
+ "EXCEPTION - AFSQueueGlobalRootEnumeration\n"));
AFSDumpTraceFilesFnc();
}
if( BooleanFlagOn( pRDRDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueStartIos Failing request, in shutdown\n");
+ "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);
+ pWorkItem = (AFSWorkItem *)AFSExAllocatePoolWithTag( NonPagedPool,
+ sizeof( AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
if( pWorkItem == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueStartIos Failed to allocate work item\n");
+ "AFSQueueStartIos Failed to allocate work item\n"));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
pWorkItem->Specific.CacheAccess.GatherIo = GatherIo;
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueStartIos Queuing IO Workitem %p\n",
- pWorkItem);
+ pWorkItem));
ntStatus = AFSQueueIOWorkerRequest( pWorkItem);
try_exit:
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueStartIos Request complete Status %08lX\n",
- ntStatus);
+ ntStatus));
if( !NT_SUCCESS( ntStatus))
{
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
- AFSDbgLogMsg( 0,
+ AFSDbgTrace(( 0,
0,
- "EXCEPTION - AFSQueueStartIos\n");
+ "EXCEPTION - AFSQueueStartIos\n"));
AFSDumpTraceFilesFnc();
}
__try
{
- pWorkItem = (AFSWorkItem *) AFSLibExAllocatePoolWithTag( NonPagedPool,
- sizeof(AFSWorkItem),
- AFS_WORK_ITEM_TAG);
+ pWorkItem = (AFSWorkItem *) AFSExAllocatePoolWithTag( NonPagedPool,
+ sizeof(AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
if (NULL == pWorkItem)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSQueueInvalidateObject Failed to allocate work item\n");
+ "AFSQueueInvalidateObject Failed to allocate work item\n"));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
pWorkItem->Specific.Invalidate.InvalidateReason = InvalidateReason;
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueInvalidateObject Workitem %p\n",
- pWorkItem);
+ pWorkItem));
ntStatus = AFSQueueWorkerRequest( pWorkItem);
try_exit:
- AFSDbgLogMsg( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSQueueInvalidateObject Request complete Status %08lX\n",
- ntStatus);
+ ntStatus));
if( !NT_SUCCESS( ntStatus))
{
ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSQueueInvalidateObject Failed to queue request Status %08lX\n",
- ntStatus);
+ ntStatus));
}
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
- AFSDbgLogMsg( 0,
+ AFSDbgTrace(( 0,
0,
- "EXCEPTION - AFSQueueInvalidateObject\n");
+ "EXCEPTION - AFSQueueInvalidateObject\n"));
AFSDumpTraceFilesFnc();
}
return ntStatus;
}
+
+NTSTATUS
+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;
+ AFSWorkItem *pWorkItem = NULL;
+
+ __try
+ {
+
+ //
+ // Pin the user buffer (first time round only - AFSLockSystemBuffer is
+ // idempotent)
+ //
+
+ if ( NULL == AFSLockSystemBuffer( Irp, BytesToWrite ))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "%s Could not pin user memory item\n",
+ __FUNCTION__));
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
+ }
+
+ pWorkItem = (AFSWorkItem *) AFSExAllocatePoolWithTag( NonPagedPool,
+ sizeof(AFSWorkItem),
+ AFS_WORK_ITEM_TAG);
+
+ if (NULL == pWorkItem)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "%s Failed to allocate work item\n",
+ __FUNCTION__));
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
+ }
+
+ RtlZeroMemory( pWorkItem,
+ sizeof(AFSWorkItem));
+
+ pWorkItem->Size = sizeof( AFSWorkItem);
+
+ pWorkItem->RequestType = AFS_WORK_DEFERRED_WRITE;
+
+ pWorkItem->Specific.AsynchIo.CallingProcess = CallingUser;
+
+ pWorkItem->Specific.AsynchIo.Device = DeviceObject;
+
+ pWorkItem->Specific.AsynchIo.Irp = Irp;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING | AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "%s Workitem %p\n",
+ __FUNCTION__,
+ pWorkItem));
+
+ CcDeferWrite( FileObject, AFSPostedDeferredWrite, pWorkItem, NULL, BytesToWrite, bRetrying);
+
+ IoMarkIrpPending(Irp);
+
+ ntStatus = STATUS_PENDING;
+ }
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
+ {
+
+ AFSDbgTrace(( 0,
+ 0,
+ "EXCEPTION - %s \n",
+ __FUNCTION__));
+
+ ntStatus = GetExceptionCode();
+ }
+
+try_exit:
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_WORKER_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "%s complete Status %08lX\n",
+ __FUNCTION__,
+ ntStatus));
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ if( pWorkItem != NULL)
+ {
+
+ ExFreePoolWithTag( pWorkItem, AFS_WORK_ITEM_TAG);
+ }
+
+ AFSDbgTrace(( 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;
+
+ AFSDbgTrace(( 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);
+
+ AFSDbgTrace(( 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));
+ }
+}