//
ULONG
-AFSExceptionFilter( IN ULONG Code,
+AFSExceptionFilter( IN CHAR *FunctionString,
+ IN ULONG Code,
IN PEXCEPTION_POINTERS ExceptPtrs)
{
+ UNREFERENCED_PARAMETER(Code);
PEXCEPTION_RECORD ExceptRec;
PCONTEXT Context;
AFSDbgLogMsg( 0,
0,
- "AFSExceptionFilter (Library) - EXR %p CXR %p Code %08lX Address %p Routine %p\n",
+ "AFSExceptionFilter (Library) - EXR %p CXR %p Function %s Code %08lX Address %p Routine %p\n",
ExceptRec,
Context,
+ FunctionString,
ExceptRec->ExceptionCode,
ExceptRec->ExceptionAddress,
(void *)AFSExceptionFilter);
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSReleaseResource Releasing lock %08lX Thread %08lX\n",
+ "AFSReleaseResource Releasing lock %p Thread %08lX\n",
Resource,
PsGetCurrentThread());
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSConvertToShared Converting lock %08lX Thread %08lX\n",
+ "AFSConvertToShared Converting lock %p Thread %08lX\n",
Resource,
PsGetCurrentThread());
}
//
-// Function: AFSBuildCRCTable
-//
-// Description:
-//
-// This function builds the CRC table for mapping filenames to a CRC value.
-//
-// Return:
-//
-// A status is returned for the function
-//
-
-void
-AFSBuildCRCTable()
-{
- ULONG crc;
- int i, j;
-
- for ( i = 0; i <= 255; i++)
- {
- crc = i;
- for ( j = 8; j > 0; j--)
- {
- if (crc & 1)
- {
- crc = ( crc >> 1 ) ^ CRC32_POLYNOMIAL;
- }
- else
- {
- crc >>= 1;
- }
- }
-
- AFSCRCTable[ i ] = crc;
- }
-}
-
-//
// Function: AFSGenerateCRC
//
// Description:
IN BOOLEAN UpperCaseName)
{
- ULONG crc;
- ULONG temp1, temp2;
- UNICODE_STRING UpcaseString;
- WCHAR *lpbuffer;
- USHORT size = 0;
-
- if( !AFSCRCTable[1])
- {
- AFSBuildCRCTable();
- }
-
- crc = 0xFFFFFFFFL;
-
- if( UpperCaseName)
- {
-
- RtlUpcaseUnicodeString( &UpcaseString,
- FileName,
- TRUE);
-
- lpbuffer = UpcaseString.Buffer;
-
- size = (UpcaseString.Length/sizeof( WCHAR));
- }
- else
- {
-
- lpbuffer = FileName->Buffer;
-
- size = (FileName->Length/sizeof( WCHAR));
- }
+ ULONG ulCRC = 0;
+ NTSTATUS ntStatus = STATUS_SUCCESS;
- while (size--)
- {
- temp1 = (crc >> 8) & 0x00FFFFFFL;
- temp2 = AFSCRCTable[((int)crc ^ *lpbuffer++) & 0xff];
- crc = temp1 ^ temp2;
- }
+ ntStatus = RtlHashUnicodeString( FileName,
+ UpperCaseName,
+ HASH_STRING_ALGORITHM_DEFAULT,
+ &ulCRC);
- if( UpperCaseName)
+ if( !NT_SUCCESS( ntStatus))
{
-
- RtlFreeUnicodeString( &UpcaseString);
+ ulCRC = 0;
}
- crc ^= 0xFFFFFFFFL;
-
- return crc;
+ return ulCRC;
}
void *
IN ULONG Length)
{
- NTSTATUS Status = STATUS_SUCCESS;
void *pAddress = NULL;
if( Irp->MdlAddress != NULL)
pAddress = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
}
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
+ AFSDumpTraceFilesFnc();
+
IoFreeMdl( Irp->MdlAddress );
Irp->MdlAddress = NULL;
pAddress = NULL;
void *
AFSLockUserBuffer( IN void *UserBuffer,
IN ULONG BufferLength,
- OUT MDL ** Mdl)
+ OUT MDL ** Mdl)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
void *pAddress = NULL;
- MDL *pMdl = NULL;
+ MDL *pMdl = NULL;
- __Enter
- {
+ __Enter
+ {
pMdl = IoAllocateMdl( UserBuffer,
BufferLength,
FALSE,
NULL);
- if( pMdl == NULL)
- {
+ if( pMdl == NULL)
+ {
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
//
// Lock the new Mdl in memory.
{
MmProbeAndLockPages( pMdl,
- KernelMode,
+ KernelMode,
IoWriteAccess);
pAddress = MmGetSystemAddressForMdlSafe( pMdl,
- NormalPagePriority);
+ NormalPagePriority);
}
- __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
+ AFSDumpTraceFilesFnc();
+
IoFreeMdl( pMdl);
pMdl = NULL;
pAddress = NULL;
}
- if( pMdl != NULL)
- {
+ if( pMdl != NULL)
+ {
- *Mdl = pMdl;
- }
+ *Mdl = pMdl;
+ }
try_exit:
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- void *pMappedBuffer = NULL;
AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
KAPC stApcState;
IN PIRP Irp)
{
+ UNREFERENCED_PARAMETER(DeviceObject);
NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
- PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
AFSCompleteRequest( Irp,
ntStatus);
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDirectoryCB *pDirNode = NULL;
ULONG ulEntryLength = 0;
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSObjectInfoCB *pObjectInfoCB = NULL;
AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
+ LONG lCount;
__Enter
{
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
- InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_GLOBAL);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitializeGlobalDirectoryEntries Increment count on object %08lX Cnt %d\n",
+ "AFSInitializeGlobalDirectoryEntries Increment count on object %p Cnt %d\n",
pObjectInfoCB,
- pObjectInfoCB->ObjectReferenceCount);
+ lCount);
ntStatus = STATUS_SUCCESS;
if( pDirNode == NULL)
{
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
AFS_TRACE_LEVEL_ERROR,
"AFSInitializeGlobalDirectory AFS_DIR_ENTRY_TAG allocation failure\n");
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitializeGlobalDirectory AFS_DIR_ENTRY_TAG allocated %p\n",
+ pDirNode);
+
pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedDirectoryCB),
AFS_DIR_ENTRY_NP_TAG);
ExFreePool( pDirNode);
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
- InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_GLOBAL);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitializeGlobalDirectoryEntries Increment count on object %08lX Cnt %d\n",
+ "AFSInitializeGlobalDirectoryEntries Increment count on object %p Cnt %d\n",
pObjectInfoCB,
- pObjectInfoCB->ObjectReferenceCount);
+ lCount);
ntStatus = STATUS_SUCCESS;
if( pDirNode == NULL)
{
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOAD_LIBRARY | AFS_SUBSYSTEM_INIT_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSInitializeGlobalDirectoryEntries AFS_DIR_ENTRY_TAG allocation failure\n");
+
+ AFSDeleteObjectInfo( &pObjectInfoCB);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitializeGlobalDirectoryEntries AFS_DIR_ENTRY_TAG allocated %p\n",
+ pDirNode);
+
pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedDirectoryCB),
AFS_DIR_ENTRY_NP_TAG);
ExFreePool( pDirNode);
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
if( AFSGlobalDotDirEntry != NULL)
{
- AFSDeleteObjectInfo( AFSGlobalDotDirEntry->ObjectInformation);
+ AFSDeleteObjectInfo( &AFSGlobalDotDirEntry->ObjectInformation);
ExDeleteResourceLite( &AFSGlobalDotDirEntry->NonPaged->Lock);
if( AFSGlobalDotDotDirEntry != NULL)
{
- AFSDeleteObjectInfo( AFSGlobalDotDotDirEntry->ObjectInformation);
+ AFSDeleteObjectInfo( &AFSGlobalDotDotDirEntry->ObjectInformation);
ExDeleteResourceLite( &AFSGlobalDotDotDirEntry->NonPaged->Lock);
AFSDirectoryCB *pDirNode = NULL;
NTSTATUS ntStatus = STATUS_SUCCESS;
ULONG ulEntryLength = 0;
- AFSDirEnumEntry *pDirEnumCB = NULL;
- AFSFileID stTargetFileID;
- AFSFcb *pVcb = NULL;
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSObjectInfoCB *pObjectInfoCB = NULL;
BOOLEAN bAllocatedObjectCB = FALSE;
ULONGLONG ullIndex = 0;
AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
+ LONG lCount;
__Enter
{
bAllocatedObjectCB = TRUE;
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitDirEntry initialized object %08lX Parent Object %08lX for %wZ\n",
+ "AFSInitDirEntry initialized object %p Parent Object %p for %wZ\n",
pObjectInfoCB,
ParentObjectInfo,
FileName);
}
- InterlockedIncrement( &pObjectInfoCB->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_DIRENTRY);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitDirEntry Increment count on object %08lX Cnt %d\n",
+ "AFSInitDirEntry Increment count on object %p Cnt %d\n",
pObjectInfoCB,
- pObjectInfoCB->ObjectReferenceCount);
+ lCount);
AFSReleaseResource( ParentObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitDirEntry AFS_DIR_ENTRY_TAG allocated %p\n",
+ pDirNode);
+
pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedDirectoryCB),
AFS_DIR_ENTRY_NP_TAG);
pDirNode->ObjectInformation = pObjectInfoCB;
//
- // Set valid entry
+ // Set valid entry and NOT_IN_PARENT flag
//
- SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID);
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
pDirNode->FileIndex = FileIndex;
TRUE);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitDirEntry Initialized DE %p for %wZ in parent FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ FileName,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique);
+
if( TargetName != NULL &&
TargetName->Length > 0)
{
pObjectInfoCB->FileAttributes = DirEnumEntry->FileAttributes;
if( pObjectInfoCB->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
- pObjectInfoCB->FileType == AFS_FILE_TYPE_SYMLINK ||
pObjectInfoCB->FileType == AFS_FILE_TYPE_DFSLINK)
{
- pObjectInfoCB->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ pObjectInfoCB->FileAttributes |= (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
}
- pObjectInfoCB->EaSize = DirEnumEntry->EaSize;
+ if (pObjectInfoCB->FileType == AFS_FILE_TYPE_SYMLINK)
+ {
- //
- // Object specific information
- //
+ if ( pObjectInfoCB->FileAttributes == FILE_ATTRIBUTE_NORMAL)
+ {
- pObjectInfoCB->Links = DirEnumEntry->Links;
+ pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
+ }
+ else
+ {
- pObjectInfoCB->Expiration = DirEnumEntry->Expiration;
+ pObjectInfoCB->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ }
+ }
- pObjectInfoCB->DataVersion = DirEnumEntry->DataVersion;
+ pObjectInfoCB->EaSize = DirEnumEntry->EaSize;
//
// Check for the case where we have a filetype of SymLink but both the TargetFid and the
}
}
+ //
+ // Object specific information
+ //
+
+ pObjectInfoCB->Links = DirEnumEntry->Links;
+
+ pObjectInfoCB->Expiration = DirEnumEntry->Expiration;
+
+ pObjectInfoCB->DataVersion = DirEnumEntry->DataVersion;
+
try_exit:
if( !NT_SUCCESS( ntStatus))
ExDeleteResourceLite( &pNonPagedDirEntry->Lock);
- AFSExFreePool( pNonPagedDirEntry);
+ AFSExFreePoolWithTag( pNonPagedDirEntry, AFS_DIR_ENTRY_NP_TAG);
}
if( pDirNode != NULL)
{
- AFSExFreePool( pDirNode);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitDirEntry AFS_DIR_ENTRY_TAG deallocating %p\n",
+ pDirNode);
+
+ AFSExFreePoolWithTag( pDirNode, AFS_DIR_ENTRY_TAG);
pDirNode = NULL;
}
if( pObjectInfoCB != NULL)
{
- InterlockedDecrement( &pObjectInfoCB->ObjectReferenceCount);
+ lCount = AFSObjectInfoDecrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_DIRENTRY);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitDirEntry Decrement count on object %08lX Cnt %d\n",
+ "AFSInitDirEntry Decrement count on object %p Cnt %d\n",
pObjectInfoCB,
- pObjectInfoCB->ObjectReferenceCount);
+ lCount);
if( bAllocatedObjectCB)
{
ASSERT( pObjectInfoCB->ObjectReferenceCount == 0);
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
}
}
}
IN AFSDirectoryCB *DirEntry)
{
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDirEnumEntry *pDirEntry = NULL;
UNICODE_STRING uniTargetName;
DirEntry->ObjectInformation->FileAttributes = pDirEntry->FileAttributes;
if( pDirEntry->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
- pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK ||
pDirEntry->FileType == AFS_FILE_TYPE_DFSLINK)
{
- DirEntry->ObjectInformation->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ DirEntry->ObjectInformation->FileAttributes |= (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+ }
+
+ if( pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK)
+ {
+
+ if ( DirEntry->ObjectInformation->FileAttributes == FILE_ATTRIBUTE_NORMAL)
+ {
+
+ DirEntry->ObjectInformation->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
+ }
+ else
+ {
+
+ DirEntry->ObjectInformation->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ }
}
DirEntry->ObjectInformation->EaSize = pDirEntry->EaSize;
if( pDirEntry != NULL)
{
- AFSExFreePool( pDirEntry);
+ AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
}
}
IN AFSDirectoryCB *DirEntry)
{
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDirEnumEntry *pDirEntry = NULL;
UNICODE_STRING uniTargetName;
pDirEntry->FileType == AFS_FILE_TYPE_INVALID)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSValidateSymLink Invalid type Status %08lX\n",
+ STATUS_OBJECT_NAME_NOT_FOUND);
+
try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
}
DirEntry->ObjectInformation->FileAttributes = pDirEntry->FileAttributes;
if( pDirEntry->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
- pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK ||
pDirEntry->FileType == AFS_FILE_TYPE_DFSLINK)
{
- DirEntry->ObjectInformation->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ DirEntry->ObjectInformation->FileAttributes |= (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+ }
+
+ if( pDirEntry->FileType == AFS_FILE_TYPE_SYMLINK)
+ {
+
+ if ( DirEntry->ObjectInformation->FileAttributes == FILE_ATTRIBUTE_NORMAL)
+ {
+
+ DirEntry->ObjectInformation->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
+ }
+ else
+ {
+
+ DirEntry->ObjectInformation->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ }
}
DirEntry->ObjectInformation->EaSize = pDirEntry->EaSize;
if( pDirEntry != NULL)
{
- AFSExFreePool( pDirEntry);
+ AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
}
}
}
NTSTATUS
-AFSInvalidateCache( IN AFSInvalidateCacheCB *InvalidateCB)
+AFSInvalidateObject( IN OUT AFSObjectInfoCB **ppObjectInfo,
+ IN ULONG Reason)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSFcb *pDcb = NULL, *pFcb = NULL, *pNextFcb = NULL;
- AFSVolumeCB *pVolumeCB = NULL;
- AFSFcb *pTargetDcb = NULL;
- AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
- AFSDirectoryCB *pCurrentDirEntry = NULL;
- BOOLEAN bIsChild = FALSE;
- ULONGLONG ullIndex = 0;
- AFSObjectInfoCB *pObjectInfo = NULL;
IO_STATUS_BLOCK stIoStatus;
ULONG ulFilter = 0;
+ AFSObjectInfoCB * pParentObjectInfo = NULL;
- __Enter
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateObject Invalidation on node type %d for fid %08lX-%08lX-%08lX-%08lX Reason %d\n",
+ (*ppObjectInfo)->FileType,
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique,
+ Reason);
+
+ if ( BooleanFlagOn( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
{
- //
- // Need to locate the Fcb for the directory to purge
- //
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
- &pDevExt->Specific.RDR.VolumeTreeLock,
- PsGetCurrentThread());
+ pParentObjectInfo = AFSFindObjectInfo( (*ppObjectInfo)->VolumeCB,
+ &(*ppObjectInfo)->ParentFileId);
+ }
+ if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_SYMLINK ||
+ (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DFSLINK ||
+ (*ppObjectInfo)->FileType == AFS_FILE_TYPE_MOUNTPOINT)
+ {
//
- // Starve any exclusive waiters on this paticular call
+ // We only act on the mount point itself, not the target. If the
+ // node has been deleted then mark it as such otherwise indicate
+ // it requires verification
//
- AFSAcquireSharedStarveExclusive( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
+ if( Reason == AFS_INVALIDATE_DELETED)
+ {
+ SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
+ }
+ else
+ {
- //
- // Locate the volume node
- //
+ if( Reason == AFS_INVALIDATE_FLUSHED)
+ {
- ullIndex = AFSCreateHighIndex( &InvalidateCB->FileID);
+ (*ppObjectInfo)->DataVersion.QuadPart = (ULONGLONG)-1;
- ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
- ullIndex,
- (AFSBTreeEntry **)&pVolumeCB);
+ SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
+ }
- if( pVolumeCB != NULL)
- {
+ (*ppObjectInfo)->Expiration.QuadPart = 0;
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ (*ppObjectInfo)->TargetFileId.Vnode = 0;
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ (*ppObjectInfo)->TargetFileId.Unique = 0;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Increment count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
- }
+ "AFSInvalidateObject Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique);
- AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
+ SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY);
+ }
- if( !NT_SUCCESS( ntStatus) ||
- pVolumeCB == NULL)
+ if ( pParentObjectInfo != NULL)
{
- try_return( ntStatus = STATUS_SUCCESS);
- }
- //
- // If this is a whole volume invalidation then go do it now
- //
+ ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
- if( InvalidateCB->WholeVolume ||
- AFSIsVolumeFID( &InvalidateCB->FileID))
- {
+ if( Reason == AFS_INVALIDATE_CREDS)
+ {
+ ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
+ }
- ntStatus = AFSInvalidateVolume( pVolumeCB,
- InvalidateCB->Reason);
+ if( Reason == AFS_INVALIDATE_DATA_VERSION ||
+ Reason == AFS_INVALIDATE_FLUSHED)
+ {
+ ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
+ }
+ else
+ {
+ ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
+ }
- AFSFsRtlNotifyFullReportChange( &pVolumeCB->ObjectInformation,
+ AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
NULL,
- FILE_NOTIFY_CHANGE_FILE_NAME |
- FILE_NOTIFY_CHANGE_DIR_NAME |
- FILE_NOTIFY_CHANGE_NAME |
- FILE_NOTIFY_CHANGE_ATTRIBUTES |
- FILE_NOTIFY_CHANGE_SIZE,
+ ulFilter,
FILE_ACTION_MODIFIED);
-
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
-
- try_return( ntStatus);
}
- AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
-
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Decrement count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ try_return( ntStatus);
+ }
- ullIndex = AFSCreateLowIndex( &InvalidateCB->FileID);
+ //
+ // Depending on the reason for invalidation then perform work on the node
+ //
- ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
- ullIndex,
- (AFSBTreeEntry **)&pObjectInfo);
+ switch( Reason)
+ {
- if( pObjectInfo != NULL)
+ case AFS_INVALIDATE_DELETED:
{
//
- // Reference the node so it won't be torn down
+ // Mark this node as invalid
//
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
+ (*ppObjectInfo)->Links = 0;
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Increment count on object %08lX Cnt %d\n",
- pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
- }
+ SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_DELETED);
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateObject Set DELETE flag on fid %08lX-%08lX-%08lX-%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique);
- if( !NT_SUCCESS( ntStatus) ||
- pObjectInfo == NULL)
- {
- try_return( ntStatus = STATUS_SUCCESS);
- }
+ if( pParentObjectInfo != NULL)
+ {
- if( pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK ||
- pObjectInfo->FileType == AFS_FILE_TYPE_DFSLINK ||
- pObjectInfo->FileType == AFS_FILE_TYPE_MOUNTPOINT)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateObject Set VERIFY flag on parent fid %08lX-%08lX-%08lX-%08lX\n",
+ pParentObjectInfo->FileId.Cell,
+ pParentObjectInfo->FileId.Volume,
+ pParentObjectInfo->FileId.Vnode,
+ pParentObjectInfo->FileId.Unique);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Invalidation on node type %d for fid %08lX-%08lX-%08lX-%08lX Reason %d\n",
- pObjectInfo->FileType,
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique,
- InvalidateCB->Reason);
+ SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
- //
- // We only act on the mount point itself, not the target. If the
- // node has been deleted then mark it as such otherwise indicate
- // it requires verification
- //
+ pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
- if( InvalidateCB->Reason == AFS_INVALIDATE_DELETED)
- {
- SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
- }
- else
- {
+ pParentObjectInfo->Expiration.QuadPart = 0;
- if( InvalidateCB->Reason == AFS_INVALIDATE_FLUSHED ||
- InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
+ if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
+ ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
+ }
+ else
{
- pObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
}
- pObjectInfo->Expiration.QuadPart = 0;
+ AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
+ NULL,
+ ulFilter,
+ FILE_ACTION_REMOVED);
+ }
+
+ if( NT_SUCCESS( AFSQueueInvalidateObject( (*ppObjectInfo),
+ Reason)))
+ {
+ (*ppObjectInfo) = NULL; // We'll dec the count in the worker item
+ }
+
+ break;
+ }
- pObjectInfo->TargetFileId.Vnode = 0;
+ case AFS_INVALIDATE_FLUSHED:
+ {
- pObjectInfo->TargetFileId.Unique = 0;
+ if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_FILE &&
+ (*ppObjectInfo)->Fcb != NULL)
+ {
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ "AFSInvalidateObject Flush/purge file fid %08lX-%08lX-%08lX-%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique);
- SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
- }
+ AFSAcquireExcl( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
- ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
+ __try
+ {
+
+ CcFlushCache( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ &stIoStatus);
+
+ if( !NT_SUCCESS( stIoStatus.Status))
+ {
- if( InvalidateCB->Reason == AFS_INVALIDATE_CREDS)
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSInvalidateObject CcFlushCache failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique,
+ stIoStatus.Status,
+ stIoStatus.Information);
+
+ ntStatus = stIoStatus.Status;
+ }
+
+
+ if ( (*ppObjectInfo)->Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
+ {
+
+ if ( !CcPurgeCacheSection( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSInvalidateObject CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique);
+
+ SetFlag( (*ppObjectInfo)->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
+ {
+
+ ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSInvalidateObject Cc FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique,
+ ntStatus);
+
+ SetFlag( (*ppObjectInfo)->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+
+ AFSReleaseResource( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectResource);
+
+ //
+ // Clear out the extents
+ // Get rid of them (note this involves waiting
+ // for any writes or reads to the cache to complete)
+ //
+
+ AFSTearDownFcbExtents( (*ppObjectInfo)->Fcb,
+ NULL);
+ }
+
+ (*ppObjectInfo)->DataVersion.QuadPart = (ULONGLONG)-1;
+
+
+ if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_FILE)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateObject Setting VERIFY_DATA flag on fid %08lX-%08lX-%08lX-%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique);
+
+ SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
+ }
+
+ // Fall through to the default processing
+ }
+
+ default:
+ {
+
+ if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
+ ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
+ }
+ else
+ {
+ ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
+ }
+
+ if( Reason == AFS_INVALIDATE_CREDS)
{
ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
}
- if( InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
+ if( Reason == AFS_INVALIDATE_DATA_VERSION)
{
ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
}
ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
}
- AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
- NULL,
- FILE_NOTIFY_CHANGE_FILE_NAME |
- FILE_NOTIFY_CHANGE_ATTRIBUTES,
- FILE_ACTION_MODIFIED);
+ if( (*ppObjectInfo)->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
- try_return( ntStatus);
- }
+ AFSFsRtlNotifyFullReportChange( (*ppObjectInfo),
+ NULL,
+ ulFilter,
+ FILE_ACTION_MODIFIED);
+ }
+ else if ( pParentObjectInfo != NULL)
+ {
- //
- // Depending on the reason for invalidation then perform work on the node
- //
+ AFSFsRtlNotifyFullReportChange( pParentObjectInfo,
+ NULL,
+ ulFilter,
+ FILE_ACTION_MODIFIED);
+ }
- switch( InvalidateCB->Reason)
- {
+ //
+ // Indicate this node requires re-evaluation for the remaining reasons
+ //
- case AFS_INVALIDATE_DELETED:
+ (*ppObjectInfo)->Expiration.QuadPart = 0;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateObject Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
+ (*ppObjectInfo)->FileId.Cell,
+ (*ppObjectInfo)->FileId.Volume,
+ (*ppObjectInfo)->FileId.Vnode,
+ (*ppObjectInfo)->FileId.Unique);
+
+ SetFlag( (*ppObjectInfo)->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ if( Reason == AFS_INVALIDATE_DATA_VERSION ||
+ (*ppObjectInfo)->FileType == AFS_FILE_TYPE_FILE &&
+ ( Reason == AFS_INVALIDATE_CALLBACK ||
+ Reason == AFS_INVALIDATE_EXPIRED))
{
+ if ( NT_SUCCESS( AFSQueueInvalidateObject( (*ppObjectInfo),
+ AFS_INVALIDATE_DATA_VERSION)))
+ {
- //
- // Mark this node as invalid
- //
+ (*ppObjectInfo) = NULL; // We'll dec the count in the worker item
+ }
+ }
- SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_DELETED);
+ break;
+ }
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Set DELETE flag on fid %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ try_exit:
- if( pObjectInfo->ParentObjectInformation != NULL)
- {
+ if ( pParentObjectInfo != NULL)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Set VERIFY flag on parent fid %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->ParentObjectInformation->FileId.Cell,
- pObjectInfo->ParentObjectInformation->FileId.Volume,
- pObjectInfo->ParentObjectInformation->FileId.Vnode,
- pObjectInfo->ParentObjectInformation->FileId.Unique);
-
- SetFlag( pObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
- pObjectInfo->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
- pObjectInfo->ParentObjectInformation->Expiration.QuadPart = 0;
- }
+ AFSReleaseObjectInfo( &pParentObjectInfo);
+ }
- if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
- ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
- }
- else
- {
- ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
- }
+ return ntStatus;
+}
- AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
- NULL,
- ulFilter,
- FILE_ACTION_REMOVED);
+NTSTATUS
+AFSInvalidateCache( IN AFSInvalidateCacheCB *InvalidateCB)
+{
- break;
- }
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSVolumeCB *pVolumeCB = NULL;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ ULONGLONG ullIndex = 0;
+ AFSObjectInfoCB *pObjectInfo = NULL;
+ LONG lCount;
- case AFS_INVALIDATE_FLUSHED:
- {
+ __Enter
+ {
- if( pObjectInfo->FileType == AFS_FILE_TYPE_FILE &&
- pObjectInfo->Fcb != NULL)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateCache Invalidation FID %08lX-%08lX-%08lX-%08lX Type %d WholeVolume %d Reason %d\n",
+ InvalidateCB->FileID.Cell,
+ InvalidateCB->FileID.Volume,
+ InvalidateCB->FileID.Vnode,
+ InvalidateCB->FileID.Unique,
+ InvalidateCB->FileType,
+ InvalidateCB->WholeVolume,
+ InvalidateCB->Reason);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Flush/purge file fid %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ //
+ // Need to locate the Fcb for the directory to purge
+ //
- AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
- TRUE);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateCache Acquiring RDR VolumeTreeLock lock %p SHARED %08lX\n",
+ &pDevExt->Specific.RDR.VolumeTreeLock,
+ PsGetCurrentThread());
- __try
- {
+ //
+ // Starve any exclusive waiters on this paticular call
+ //
- CcFlushCache( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- &stIoStatus);
+ AFSAcquireSharedStarveExclusive( &pDevExt->Specific.RDR.VolumeTreeLock, TRUE);
- if( !NT_SUCCESS( stIoStatus.Status))
- {
+ //
+ // Locate the volume node
+ //
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSInvalidateCache CcFlushCache failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique,
- stIoStatus.Status,
- stIoStatus.Information);
+ ullIndex = AFSCreateHighIndex( &InvalidateCB->FileID);
- ntStatus = stIoStatus.Status;
- }
+ ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
+ ullIndex,
+ (AFSBTreeEntry **)&pVolumeCB);
- CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- FALSE);
- }
- __except( EXCEPTION_EXECUTE_HANDLER)
- {
+ if( pVolumeCB != NULL)
+ {
- ntStatus = GetExceptionCode();
- }
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_INVALIDATE);
- AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateCache Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount);
+ }
- //
- // Clear out the extents
- // Get rid of them (note this involves waiting
- // for any writes or reads to the cache to complete)
- //
+ AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
- (VOID) AFSTearDownFcbExtents( pObjectInfo->Fcb);
- }
+ if( !NT_SUCCESS( ntStatus) ||
+ pVolumeCB == NULL)
+ {
- // Fall through to the default processing
- }
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSInvalidateCache Invalidation FAILURE Unable to locate volume node FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ InvalidateCB->FileID.Cell,
+ InvalidateCB->FileID.Volume,
+ InvalidateCB->FileID.Vnode,
+ InvalidateCB->FileID.Unique,
+ ntStatus);
- default:
- {
+ try_return( ntStatus = STATUS_SUCCESS);
+ }
- if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
- ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
- }
- else
- {
- ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
- }
+ //
+ // If this is a whole volume invalidation then go do it now
+ //
- if( InvalidateCB->Reason == AFS_INVALIDATE_CREDS)
- {
- ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
- }
+ if( InvalidateCB->WholeVolume)
+ {
- if( InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
- {
- ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
- }
- else
- {
- ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
- }
+ ntStatus = AFSInvalidateVolume( pVolumeCB,
+ InvalidateCB->Reason);
- AFSFsRtlNotifyFullReportChange( pObjectInfo->ParentObjectInformation,
- NULL,
- ulFilter,
- FILE_ACTION_MODIFIED);
+ try_return( ntStatus);
+ }
- //
- // Indicate this node requires re-evaluation for the remaining reasons
- //
+ AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
- pObjectInfo->Expiration.QuadPart = 0;
+ if ( AFSIsVolumeFID( &InvalidateCB->FileID))
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ pObjectInfo = &pVolumeCB->ObjectInformation;
+ }
+ else
+ {
- SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+ ullIndex = AFSCreateLowIndex( &InvalidateCB->FileID);
- if( InvalidateCB->Reason == AFS_INVALIDATE_FLUSHED ||
- InvalidateCB->Reason == AFS_INVALIDATE_DATA_VERSION)
- {
- pObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
+ ullIndex,
+ (AFSBTreeEntry **)&pObjectInfo);
+ }
- if( pObjectInfo->FileType == AFS_FILE_TYPE_FILE)
- {
+ if( pObjectInfo != NULL)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Setting VERIFY_DATA flag on fid %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ //
+ // Reference the node so it won't be torn down
+ //
- SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
- }
- }
+ lCount = AFSObjectInfoIncrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
- break;
- }
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateCache Increment count on object %p Cnt %d\n",
+ pObjectInfo,
+ lCount);
+ }
+
+ AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
+
+ if( !NT_SUCCESS( ntStatus) ||
+ pObjectInfo == NULL)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateCache Invalidation FAILURE Unable to locate object FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ InvalidateCB->FileID.Cell,
+ InvalidateCB->FileID.Volume,
+ InvalidateCB->FileID.Vnode,
+ InvalidateCB->FileID.Unique,
+ ntStatus);
+
+ try_return( ntStatus = STATUS_SUCCESS);
}
+ AFSInvalidateObject( &pObjectInfo,
+ InvalidateCB->Reason);
+
try_exit:
if( pObjectInfo != NULL)
{
- InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoDecrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateCache Decrement count on object %08lX Cnt %d\n",
+ "AFSInvalidateCache Decrement count on object %p Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
+ }
+
+ if ( pVolumeCB != NULL)
+ {
+
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_INVALIDATE);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateCache Decrement count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount);
}
}
BOOLEAN bIsChild = FALSE;
AFSFcb *pCurrentFcb = Fcb;
+ AFSObjectInfoCB * pParentObjectInfo = NULL;
while( pCurrentFcb != NULL)
{
- if( pCurrentFcb->ObjectInformation->ParentObjectInformation == Dcb->ObjectInformation)
+ if( BooleanFlagOn( pCurrentFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_PARENT_FID) &&
+ AFSIsEqualFID( &pCurrentFcb->ObjectInformation->ParentFileId, &Dcb->ObjectInformation->FileId))
{
bIsChild = TRUE;
break;
}
- pCurrentFcb = pCurrentFcb->ObjectInformation->ParentObjectInformation->Fcb;
+ pParentObjectInfo = AFSFindObjectInfo( pCurrentFcb->ObjectInformation->VolumeCB,
+ &pCurrentFcb->ObjectInformation->ParentFileId);
+
+ if ( pParentObjectInfo != NULL)
+ {
+
+ pCurrentFcb = pParentObjectInfo->Fcb;
+
+ AFSReleaseObjectInfo( &pParentObjectInfo);
+ }
+ else
+ {
+
+ pCurrentFcb = NULL;
+ }
}
return bIsChild;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSSubstituteSysName Acquiring SysName lock %08lX SHARED %08lX\n",
+ "AFSSubstituteSysName Acquiring SysName lock %p SHARED %08lX\n",
pSysNameLock,
PsGetCurrentThread());
if( pSysName == NULL)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSSubstituteSysName No sysname %wZ Status %08lX\n",
+ &ComponentName,
+ STATUS_OBJECT_NAME_NOT_FOUND);
+
try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
}
if( FreePathName)
{
- AFSExFreePool( FullPathName->Buffer);
+ AFSExFreePoolWithTag( FullPathName->Buffer, 0);
}
*FullPathName = uniPathName;
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSFcb *pFcb = NULL;
AFSObjectInfoCB *pCurrentObject = NULL;
- ULONG ulFilter = 0;
+ AFSObjectInfoCB *pNextObject = NULL;
+ LONG lCount;
__Enter
{
// Mark this volume as invalid
//
- VolumeCB->ObjectInformation.Expiration.QuadPart = 0;
-
SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
SetFlag( VolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE);
- AFSFsRtlNotifyFullReportChange( &VolumeCB->ObjectInformation,
- NULL,
- FILE_NOTIFY_CHANGE_DIR_NAME,
- FILE_ACTION_REMOVED);
+ break;
+ }
+ }
- AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
+ //
+ // Invalidate the volume root directory
+ //
- pCurrentObject = VolumeCB->ObjectInfoListHead;
+ pCurrentObject = &VolumeCB->ObjectInformation;
- while( pCurrentObject != NULL)
- {
+ if ( pCurrentObject )
+ {
- if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
- ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
- }
- else
- {
- ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
- }
+ lCount = AFSObjectInfoIncrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
- AFSFsRtlNotifyFullReportChange( pCurrentObject,
- NULL,
- ulFilter,
- FILE_ACTION_REMOVED);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateVolumeObjects Increment count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount);
- SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
+ AFSInvalidateObject( &pCurrentObject,
+ Reason);
- pFcb = pCurrentObject->Fcb;
+ if ( pCurrentObject)
+ {
- if( pFcb != NULL &&
- pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
- {
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateVolumeObjects Decrement count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount);
+ }
+ }
- //
- // Clear out the extents
- // And get rid of them (note this involves waiting
- // for any writes or reads to the cache to complete)
- //
+ //
+ // Apply invalidation to all other volume objects
+ //
- (VOID) AFSTearDownFcbExtents( pFcb);
- }
+ AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
- pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
- }
+ pCurrentObject = VolumeCB->ObjectInfoListHead;
- AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
+ if ( pCurrentObject)
+ {
- break;
- }
+ //
+ // Reference the node so it won't be torn down
+ //
- default:
+ lCount = AFSObjectInfoIncrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateVolumeObjects Increment count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount);
+ }
+
+ while( pCurrentObject != NULL)
+ {
+
+ pNextObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
+
+ if ( pNextObject)
{
//
- // Indicate this node requires re-evaluation for the remaining reasons
+ // Reference the node so it won't be torn down
//
- VolumeCB->ObjectInformation.Expiration.QuadPart = 0;
+ lCount = AFSObjectInfoIncrement( pNextObject,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateVolume Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
- VolumeCB->ObjectInformation.FileId.Cell,
- VolumeCB->ObjectInformation.FileId.Volume,
- VolumeCB->ObjectInformation.FileId.Vnode,
- VolumeCB->ObjectInformation.FileId.Unique);
+ "AFSInvalidateVolumeObjects Increment count on object %p Cnt %d\n",
+ pNextObject,
+ lCount);
+ }
- SetFlag( VolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY);
+ AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
- if( Reason == AFS_INVALIDATE_FLUSHED ||
- Reason == AFS_INVALIDATE_DATA_VERSION)
- {
+ AFSInvalidateObject( &pCurrentObject,
+ Reason);
- VolumeCB->ObjectInformation.DataVersion.QuadPart = (ULONGLONG)-1;
- }
+ if ( pCurrentObject )
+ {
- //
- // Notify anyone that cares
- //
+ lCount = AFSObjectInfoDecrement( pCurrentObject,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
- ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateVolumeObjects Decrement count on object %p Cnt %d\n",
+ pCurrentObject,
+ lCount);
+ }
- if( Reason == AFS_INVALIDATE_CREDS)
- {
- ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
- }
+ AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
- if( Reason == AFS_INVALIDATE_DATA_VERSION)
- {
- ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
- }
- else
- {
- ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
- }
+ pCurrentObject = pNextObject;
+ }
- AFSFsRtlNotifyFullReportChange( &VolumeCB->ObjectInformation,
- NULL,
- ulFilter,
- FILE_ACTION_MODIFIED);
+ AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
+ }
- //
- // Volume invalidations require all objects in the volume be re-verified
- //
+ return ntStatus;
+}
- AFSAcquireShared( VolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
+VOID
+AFSInvalidateAllVolumes( VOID)
+{
+ AFSVolumeCB *pVolumeCB = NULL;
+ AFSVolumeCB *pNextVolumeCB = NULL;
+ AFSDeviceExt *pRDRDeviceExt = NULL;
+ LONG lCount;
- pCurrentObject = VolumeCB->ObjectInfoListHead;
+ pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
- while( pCurrentObject != NULL)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateAllVolumes Acquiring RDR VolumeListLock lock %p SHARED %08lX\n",
+ &pRDRDeviceExt->Specific.RDR.VolumeListLock,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
+ TRUE);
- pCurrentObject->Expiration.QuadPart = 0;
+ pVolumeCB = pRDRDeviceExt->Specific.RDR.VolumeListHead;
- pCurrentObject->TargetFileId.Vnode = 0;
+ if ( pVolumeCB)
+ {
- pCurrentObject->TargetFileId.Unique = 0;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateAllVolumes Acquiring VolumeRoot ObjectInfoTree lock %p SHARED %08lX\n",
+ pVolumeCB->ObjectInfoTree.TreeLock,
+ PsGetCurrentThread());
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateVolume Setting VERIFY flag on fid %08lX-%08lX-%08lX-%08lX\n",
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_INVALIDATE);
- SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateAllVolumes Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount);
+ }
- if( Reason == AFS_INVALIDATE_FLUSHED ||
- Reason == AFS_INVALIDATE_DATA_VERSION)
- {
+ while( pVolumeCB != NULL)
+ {
- pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
+ pNextVolumeCB = (AFSVolumeCB *)pVolumeCB->ListEntry.fLink;
- if( pCurrentObject->FileType == AFS_FILE_TYPE_FILE)
- {
+ if ( pNextVolumeCB)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInvalidateVolume Setting VERIFY_DATA flag on fid %08lX-%08lX-%08lX-%08lX\n",
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ lCount = AFSVolumeIncrement( pNextVolumeCB,
+ AFS_VOLUME_REFERENCE_INVALIDATE);
- SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
- }
- }
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateAllVolumes Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount);
+ }
- if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
- ulFilter = FILE_NOTIFY_CHANGE_DIR_NAME;
- }
- else
- {
- ulFilter = FILE_NOTIFY_CHANGE_FILE_NAME;
- }
+ AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
- if( Reason == AFS_INVALIDATE_CREDS)
- {
- ulFilter |= FILE_NOTIFY_CHANGE_SECURITY;
- }
+ // do I need to hold the volume lock here?
- if( Reason == AFS_INVALIDATE_DATA_VERSION)
- {
- ulFilter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
- }
- else
- {
- ulFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
- }
+ AFSInvalidateVolume( pVolumeCB, AFS_INVALIDATE_EXPIRED);
- AFSFsRtlNotifyFullReportChange( pCurrentObject,
- NULL,
- ulFilter,
- FILE_ACTION_MODIFIED);
+ AFSAcquireShared( &pRDRDeviceExt->Specific.RDR.VolumeListLock,
+ TRUE);
- pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
- }
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_INVALIDATE);
- AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInvalidateAllVolumes Decrement count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount);
- break;
- }
- }
+ pVolumeCB = pNextVolumeCB;
}
- return ntStatus;
+ AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
}
NTSTATUS
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSValidateEntry Evaluate Target failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ "AFSVerifyEntry Evaluate Target failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
// Check the data version of the file
//
- if( pObjectInfo->DataVersion.QuadPart == pDirEnumEntry->DataVersion.QuadPart &&
- !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
+ if( pObjectInfo->DataVersion.QuadPart == pDirEnumEntry->DataVersion.QuadPart)
{
+ if ( !BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyEntry No DV change %I64X for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX\n",
- pObjectInfo->DataVersion.QuadPart,
- &DirEntry->NameInformation.FileName,
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry No DV change %I64X for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ pObjectInfo->DataVersion.QuadPart,
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
- //
- // We are ok, just get out
- //
+ //
+ // We are ok, just get out
+ //
- ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+ ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
- try_return( ntStatus = STATUS_SUCCESS);
+ try_return( ntStatus = STATUS_SUCCESS);
+ }
}
//
case AFS_FILE_TYPE_SYMLINK:
{
- ASSERT( pDirEnumEntry->TargetNameLength > 0);
-
//
// Update the metadata for the entry
//
FILE_OBJECT * pCCFileObject = NULL;
BOOLEAN bPurgeExtents = FALSE;
- if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
+ if ( pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart)
{
- bPurgeExtents = TRUE;
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSVerifyEntry DV Change %wZ FID %08lX-%08lX-%08lX-%08lX (%08lX != %08lX)\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ pObjectInfo->FileId.Unique,
+ pObjectInfo->DataVersion.LowPart,
+ pDirEnumEntry->DataVersion.LowPart
+ );
- ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
+ bPurgeExtents = TRUE;
}
- //
- // Update the metadata for the entry
- //
-
- ntStatus = AFSUpdateMetaData( DirEntry,
- pDirEnumEntry);
-
- if( !NT_SUCCESS( ntStatus))
+ if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
{
+ bPurgeExtents = TRUE;
+
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSInvalidateCache Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX ntStatus %08lX\n",
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique,
- ntStatus);
+ pObjectInfo->FileId.Unique);
- break;
+ ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
}
if( pObjectInfo->Fcb != NULL)
pObjectInfo->FileId.Vnode,
pObjectInfo->FileId.Unique);
- AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
TRUE);
__try
ntStatus = stIoStatus.Status;
}
- if ( bPurgeExtents)
+ if ( bPurgeExtents &&
+ pObjectInfo->Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
{
- CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- FALSE);
+ if ( !CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSVerifyEntry CcPurgeCacheSection failure %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
+
+ SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
}
}
__except( EXCEPTION_EXECUTE_HANDLER)
{
ntStatus = GetExceptionCode();
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSVerifyEntry CcFlushCache or CcPurgeCacheSection Exception %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSVerifyEntry CcFlushCache or CcPurgeCacheSection %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
pObjectInfo->FileId.Unique,
ntStatus);
+
+ SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
- AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
if ( bPurgeExtents)
{
- AFSFlushExtents( pObjectInfo->Fcb);
+ AFSFlushExtents( pObjectInfo->Fcb,
+ AuthGroup);
}
//
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
+ "AFSVerifyEntry Acquiring Fcb lock %p EXCL %08lX\n",
&pObjectInfo->Fcb->NPFcb->Resource,
PsGetCurrentThread());
TRUE);
//
+ // Update the metadata for the entry
+ //
+
+ ntStatus = AFSUpdateMetaData( DirEntry,
+ pDirEnumEntry);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSVerifyEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX ntStatus %08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique,
+ ntStatus);
+
+ break;
+ }
+
+ //
// Update file sizes
//
pObjectInfo->Fcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
if ( pCCFileObject != NULL)
(PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
+
AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
}
else
{
+
+ //
+ // Update the metadata for the entry
+ //
+
+ ntStatus = AFSUpdateMetaData( DirEntry,
+ pDirEnumEntry);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSVerifyEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX ntStatus %08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique,
+ ntStatus);
+
+ break;
+ }
+
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_WARNING,
- "AFSValidateEntry Fcb NULL %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSVerifyEntry Fcb NULL %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
case AFS_FILE_TYPE_DIRECTORY:
{
- AFSFcb *pCurrentFcb = NULL;
- AFSDirectoryCB *pCurrentDirEntry = NULL;
-
//
// For a directory or root entry flush the content of
// the directory enumeration.
AFSAcquireExcl( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
TRUE);
- AFSValidateDirectoryCache( pObjectInfo,
- AuthGroup);
+ ntStatus = AFSValidateDirectoryCache( pObjectInfo,
+ AuthGroup);
AFSReleaseResource( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ if ( !NT_SUCCESS( ntStatus))
+ {
+
+ try_return( ntStatus);
+ }
}
//
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_WARNING,
- "AFSVerifyEntry Attempt to verify node of type %d\n",
- pObjectInfo->FileType);
+ "AFSVerifyEntry Attempt to verify node of type %d %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ pObjectInfo->FileType,
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
break;
}
if( pDirEnumEntry != NULL)
{
- AFSExFreePool( pDirEnumEntry);
+ AFSExFreePoolWithTag( pDirEnumEntry, AFS_GENERIC_MEMORY_2_TAG);
}
}
AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
ULONGLONG ullIndex = 0;
AFSVolumeCB *pVolumeCB = NULL;
- AFSFcb *pFcb = NULL;
- AFSObjectInfoCB *pCurrentObject = NULL;
+ LONG lCount;
__Enter
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSSetVolumeState Acquiring RDR VolumeTreeLock lock %08lX SHARED %08lX\n",
+ "AFSSetVolumeState Acquiring RDR VolumeTreeLock lock %p SHARED %08lX\n",
&pDevExt->Specific.RDR.VolumeTreeLock,
PsGetCurrentThread());
if( pVolumeCB != NULL)
{
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_INVALIDATE);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetVolumeState Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount);
AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
InterlockedOr( (LONG *)&(pVolumeCB->Flags), AFS_VOLUME_FLAGS_OFFLINE);
}
-
- AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
-
- pCurrentObject = pVolumeCB->ObjectInfoListHead;;
-
- while( pCurrentObject != NULL)
- {
-
- if( VolumeStatus->Online)
- {
-
- ClearFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
-
- SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
-
- pCurrentObject->DataVersion.QuadPart = (ULONGLONG)-1;
- }
- else
- {
-
- SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID);
- }
-
- pFcb = pCurrentObject->Fcb;
-
- if( pFcb != NULL &&
- !(VolumeStatus->Online) &&
- pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSSetVolumeState Marking volume offline and canceling extents Volume Cell %08lX Volume %08lX\n",
- VolumeStatus->FileID.Cell,
- VolumeStatus->FileID.Volume);
-
- //
- // Clear out the extents
- //
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSSetVolumeState Acquiring Fcb extents lock %08lX EXCL %08lX\n",
- &pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSAcquireExcl( &pFcb->NPFcb->Specific.File.ExtentsResource,
- TRUE);
-
- pFcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_CANCELLED;
-
- KeSetEvent( &pFcb->NPFcb->Specific.File.ExtentsRequestComplete,
- 0,
- FALSE);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSSetVolumeState Releasing Fcb extents lock %08lX EXCL %08lX\n",
- &pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource);
-
- //
- // And get rid of them (note this involves waiting
- // for any writes or reads to the cache to complete)
- //
-
- (VOID) AFSTearDownFcbExtents( pFcb);
- }
-
- pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
- }
-
- AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
-
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
- }
- else
- {
-
- AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
}
}
{
NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
BOOLEAN bAcquiredLock = FALSE;
AFSDirectoryCB *pCurrentDirEntry = NULL, *pNextDirEntry = NULL;
- AFSFcb *pFcb = NULL;
__Enter
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSValidateDirectoryCache Acquiring DirectoryNodeHdr.TreeLock lock %08lX EXCL %08lX\n",
+ "AFSValidateDirectoryCache Acquiring DirectoryNodeHdr.TreeLock lock %p EXCL %08lX\n",
ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
PsGetCurrentThread());
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSValidateDirectoryCache Empty Node List but Non-Zero Node Count %08lX for dir FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSValidateDirectoryCache Empty Node List but Non-Zero Node Count %d for dir FID %08lX-%08lX-%08lX-%08lX\n",
ObjectInfo->Specific.Directory.DirectoryNodeCount,
ObjectInfo->FileId.Cell,
ObjectInfo->FileId.Volume,
while( pCurrentDirEntry != NULL)
{
+ pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+
if( !BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_FAKE))
{
- ClearFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_VALID);
+ //
+ // If this entry has been deleted then process it here
+ //
+
+ if( BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_DELETED) &&
+ pCurrentDirEntry->DirOpenReferenceCount <= 0 &&
+ pCurrentDirEntry->NameArrayReferenceCount <= 0)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Deleting dir entry %p name %wZ\n",
+ pCurrentDirEntry,
+ &pCurrentDirEntry->NameInformation.FileName);
+
+ AFSDeleteDirEntry( ObjectInfo,
+ pCurrentDirEntry);
+ }
+ else
+ {
+
+ ClearFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_VALID);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Clear VALID flag on DE %p Reference count %d\n",
+ pCurrentDirEntry,
+ pCurrentDirEntry->DirOpenReferenceCount);
+
+ //
+ // We pull the short name from the parent tree since it could change below
+ //
+
+ if( BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Removing DE %p (%08lX) from shortname tree for %wZ\n",
+ pCurrentDirEntry,
+ pCurrentDirEntry->Type.Data.ShortNameTreeEntry.HashIndex,
+ &pCurrentDirEntry->NameInformation.FileName);
+
+ AFSRemoveShortNameDirEntry( &ObjectInfo->Specific.Directory.ShortNameTree,
+ pCurrentDirEntry);
+
+ ClearFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
+ }
+ }
}
- pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+ pCurrentDirEntry = pNextDirEntry;
}
//
// Reget the directory contents
//
- AFSVerifyDirectoryContent( ObjectInfo,
- AuthGroup);
+ ntStatus = AFSVerifyDirectoryContent( ObjectInfo,
+ AuthGroup);
+
+ if ( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
//
// Now start again and tear down any entries not valid
pCurrentDirEntry = ObjectInfo->Specific.Directory.DirectoryNodeListHead;
- while( pCurrentDirEntry != NULL)
- {
+ while( pCurrentDirEntry != NULL)
+ {
+
+ pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+
+ if( BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_VALID))
+ {
+
+ if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ !BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME) &&
+ pCurrentDirEntry->Type.Data.ShortNameTreeEntry.HashIndex > 0)
+ {
+
+ if( ObjectInfo->Specific.Directory.ShortNameTree == NULL)
+ {
+
+ ObjectInfo->Specific.Directory.ShortNameTree = pCurrentDirEntry;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Insert DE %p to head of shortname tree for %wZ\n",
+ pCurrentDirEntry,
+ &pCurrentDirEntry->NameInformation.FileName);
+
+ SetFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
+ }
+ else
+ {
- pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
+ if( !NT_SUCCESS( AFSInsertShortNameDirEntry( ObjectInfo->Specific.Directory.ShortNameTree,
+ pCurrentDirEntry)))
+ {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Failed to insert DE %p (%08lX) to shortname tree for %wZ\n",
+ pCurrentDirEntry,
+ pCurrentDirEntry->Type.Data.ShortNameTreeEntry.HashIndex,
+ &pCurrentDirEntry->NameInformation.FileName);
+ }
+ else
+ {
+ SetFlag( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
- if( BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_VALID))
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Insert DE %p to shortname tree for %wZ\n",
+ pCurrentDirEntry,
+ &pCurrentDirEntry->NameInformation.FileName);
+ }
+ }
+ }
pCurrentDirEntry = pNextDirEntry;
continue;
}
- if( pCurrentDirEntry->OpenReferenceCount == 0)
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateDirectoryCache Processing INVALID DE %p Reference count %d\n",
+ pCurrentDirEntry,
+ pCurrentDirEntry->DirOpenReferenceCount);
+
+ if( pCurrentDirEntry->DirOpenReferenceCount <= 0 &&
+ pCurrentDirEntry->NameArrayReferenceCount <= 0)
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
}
#endif
+try_exit:
+
if( bAcquiredLock)
{
pObjectInfo->FileAttributes = DirEnumEntry->FileAttributes;
if( pObjectInfo->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
- pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK ||
pObjectInfo->FileType == AFS_FILE_TYPE_DFSLINK)
{
- pObjectInfo->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ pObjectInfo->FileAttributes |= (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+ }
+
+ if( pObjectInfo->FileType == AFS_FILE_TYPE_SYMLINK)
+ {
+
+ if ( pObjectInfo->FileAttributes == FILE_ATTRIBUTE_NORMAL)
+ {
+
+ pObjectInfo->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
+ }
+ else
+ {
+
+ pObjectInfo->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ }
}
pObjectInfo->EaSize = DirEnumEntry->EaSize;
pObjectInfo->Links = DirEnumEntry->Links;
- if( DirEnumEntry->TargetNameLength > 0)
+ if( DirEnumEntry->TargetNameLength > 0 &&
+ ( DirEntry->NameInformation.TargetName.Length != DirEnumEntry->TargetNameLength ||
+ DirEntry->ObjectInformation->DataVersion.QuadPart != DirEnumEntry->DataVersion.QuadPart))
{
//
AFSReleaseResource( &DirEntry->NonPaged->Lock);
}
- else if( DirEntry->NameInformation.TargetName.Length > 0)
+ else if( DirEntry->NameInformation.TargetName.Length > 0 &&
+ DirEntry->ObjectInformation->DataVersion.QuadPart != DirEnumEntry->DataVersion.QuadPart)
{
AFSAcquireExcl( &DirEntry->NonPaged->Lock,
if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER) &&
DirEntry->NameInformation.TargetName.Buffer != NULL)
{
- AFSExFreePool( DirEntry->NameInformation.TargetName.Buffer);
+ AFSExFreePoolWithTag( DirEntry->NameInformation.TargetName.Buffer, AFS_NAME_BUFFER_FIVE_TAG);
}
ClearFlag( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER);
NTSTATUS
AFSValidateEntry( IN AFSDirectoryCB *DirEntry,
IN GUID *AuthGroup,
- IN BOOLEAN PurgeContent,
- IN BOOLEAN FastCall)
+ IN BOOLEAN FastCall,
+ IN BOOLEAN bSafeToPurge)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSValidateEntry Validating entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSValidateEntry Validating entry %wZ FID %08lX-%08lX-%08lX-%08lX FastCall %u\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ pObjectInfo->FileId.Unique,
+ FastCall);
//
// If this is a fake node then bail since the service knows nothing about it
try_return( ntStatus);
}
- if( PurgeContent &&
- pObjectInfo->Fcb != NULL)
- {
-
- pCurrentFcb = pObjectInfo->Fcb;
-
- if( !ExIsResourceAcquiredLite( &pCurrentFcb->NPFcb->Resource))
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSValidateEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
- &pCurrentFcb->NPFcb->Resource,
- PsGetCurrentThread());
-
- AFSAcquireExcl( &pCurrentFcb->NPFcb->Resource,
- TRUE);
-
- bReleaseFcb = TRUE;
- }
- }
-
//
// This routine ensures that the current entry is valid by:
//
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSValidateEntry Failed to evaluate entry %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSValidateEntry Failed to evaluate entry FastCall %d %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ FastCall,
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSValidateEntry Validating entry %wZ FID %08lX-%08lX-%08lX-%08lX DV %I64X returned DV %I64X FT %d\n",
+ "AFSValidateEntry Validating entry FastCall %d %wZ FID %08lX-%08lX-%08lX-%08lX DV %I64X returned DV %I64X FT %d\n",
+ FastCall,
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
case AFS_FILE_TYPE_FILE:
{
+ BOOLEAN bPurgeExtents = FALSE;
+
//
// For a file where the data version has become invalid we need to
// fail any current extent requests and purge the cache for the file
// Can't hold the Fcb resource while doing this
//
- if( pCurrentFcb != NULL &&
+ if( pObjectInfo->Fcb != NULL &&
(pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart ||
- BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA)))
+ BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA)))
{
- IO_STATUS_BLOCK stIoStatus;
- BOOLEAN bPurgeExtents = FALSE;
+ pCurrentFcb = pObjectInfo->Fcb;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSValidateEntry Flush/purge entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
- &DirEntry->NameInformation.FileName,
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
+ if( !ExIsResourceAcquiredLite( &pCurrentFcb->NPFcb->Resource))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb lock %p EXCL %08lX\n",
+ &pCurrentFcb->NPFcb->Resource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pCurrentFcb->NPFcb->Resource,
+ TRUE);
- if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
+ bReleaseFcb = TRUE;
+ }
+
+ if( pCurrentFcb != NULL)
{
- bPurgeExtents = TRUE;
+
+ IO_STATUS_BLOCK stIoStatus;
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSValidateEntry Flush/purge entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
pObjectInfo->FileId.Unique);
- ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
- }
-
- __try
- {
-
- CcFlushCache( &pCurrentFcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- &stIoStatus);
-
- if( !NT_SUCCESS( stIoStatus.Status))
+ if ( pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSValidateEntry CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry DV Change %wZ FID %08lX-%08lX-%08lX-%08lX (%08lX != %08lX)\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Vnode,
pObjectInfo->FileId.Unique,
- stIoStatus.Status,
- stIoStatus.Information);
+ pObjectInfo->DataVersion.LowPart,
+ pDirEnumEntry->DataVersion.LowPart
+ );
- ntStatus = stIoStatus.Status;
+ bPurgeExtents = TRUE;
}
- if ( bPurgeExtents)
+ if ( bSafeToPurge)
{
- CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- FALSE);
+ if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA))
+ {
+ bPurgeExtents = TRUE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry Clearing VERIFY_DATA flag %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
+
+ ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ //
+ // Release Fcb->Resource to avoid Trend Micro deadlock
+ //
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
+
+ __try
+ {
+
+ CcFlushCache( &pCurrentFcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ &stIoStatus);
+
+ if( !NT_SUCCESS( stIoStatus.Status))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSValidateEntry CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique,
+ stIoStatus.Status,
+ stIoStatus.Information);
+
+ ntStatus = stIoStatus.Status;
+ }
+
+ if ( bPurgeExtents &&
+ pObjectInfo->Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
+ {
+
+ if ( !CcPurgeCacheSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSValidateEntry CcPurgeCacheSection failure %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
+
+ SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
+ {
+ ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSValidateEntry CcFlushCache or CcPurgeCacheSection %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique,
+ ntStatus);
+
+ SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
+ TRUE);
+ }
+ else
+ {
+
+ if ( bPurgeExtents)
+ {
+
+ SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
+ }
+ }
+
+
+ AFSReleaseResource( &pCurrentFcb->NPFcb->Resource);
+
+ bReleaseFcb = FALSE;
+
+ if ( bPurgeExtents &&
+ bSafeToPurge)
+ {
+ AFSFlushExtents( pCurrentFcb,
+ AuthGroup);
}
}
- __except( EXCEPTION_EXECUTE_HANDLER)
+ }
+
+ //
+ // Update the metadata for the entry but only if it is safe to do so.
+ // If it was determined that a data version change has occurred or
+ // that a pending data verification was required, do not update the
+ // ObjectInfo meta data or the FileObject size information. That
+ // way it is consistent for the next time that the data is verified
+ // or validated.
+ //
+
+ if ( !(bPurgeExtents && bSafeToPurge))
+ {
+
+ ntStatus = AFSUpdateMetaData( DirEntry,
+ pDirEnumEntry);
+
+ if( !NT_SUCCESS( ntStatus))
{
- ntStatus = GetExceptionCode();
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSValidateEntry CcFlushCache or CcPurgeCacheSection exception %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ "AFSValidateEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
&DirEntry->NameInformation.FileName,
pObjectInfo->FileId.Cell,
pObjectInfo->FileId.Volume,
pObjectInfo->FileId.Unique,
ntStatus);
+ break;
}
- AFSReleaseResource( &pCurrentFcb->NPFcb->Resource);
-
- if ( bPurgeExtents)
- {
- AFSFlushExtents( pCurrentFcb);
- }
+ ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY | AFS_OBJECT_FLAGS_NOT_EVALUATED);
//
- // Reacquire the Fcb to purge the cache
+ // Update file sizes
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSValidateEntry Acquiring Fcb lock %08lX EXCL %08lX\n",
- &pCurrentFcb->NPFcb->Resource,
- PsGetCurrentThread());
-
- AFSAcquireExcl( &pCurrentFcb->NPFcb->Resource,
- TRUE);
- }
-
- //
- // Update the metadata for the entry
- //
-
- ntStatus = AFSUpdateMetaData( DirEntry,
- pDirEnumEntry);
-
- if( !NT_SUCCESS( ntStatus))
- {
+ if( pObjectInfo->Fcb != NULL)
+ {
+ FILE_OBJECT *pCCFileObject;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSValidateEntry Meta Data Update failed %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
- &DirEntry->NameInformation.FileName,
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique,
- ntStatus);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
- break;
- }
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
- ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY | AFS_OBJECT_FLAGS_NOT_EVALUATED);
+ pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
- //
- // Update file sizes
- //
+ pObjectInfo->Fcb->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
+ pObjectInfo->Fcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
+ pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
- if( pObjectInfo->Fcb != NULL)
- {
- FILE_OBJECT *pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
+ if ( pCCFileObject != NULL)
+ {
+ CcSetFileSizes( pCCFileObject,
+ (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
+ }
- pObjectInfo->Fcb->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
- pObjectInfo->Fcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
- pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
- if ( pCCFileObject != NULL)
- {
- CcSetFileSizes( pCCFileObject,
- (PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
}
}
-
break;
}
case AFS_FILE_TYPE_DIRECTORY:
{
- AFSDirectoryCB *pCurrentDirEntry = NULL;
-
- if( pCurrentFcb != NULL &&
- pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart)
+ if( pObjectInfo->DataVersion.QuadPart != pDirEnumEntry->DataVersion.QuadPart)
{
//
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSValidateEntry Acquiring DirectoryNodeHdr.TreeLock lock %08lX EXCL %08lX\n",
+ "AFSValidateEntry Acquiring DirectoryNodeHdr.TreeLock lock %p EXCL %08lX\n",
pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
PsGetCurrentThread());
AFSAcquireExcl( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
TRUE);
- AFSValidateDirectoryCache( pCurrentFcb->ObjectInformation,
- AuthGroup);
+ ntStatus = AFSValidateDirectoryCache( pObjectInfo,
+ AuthGroup);
AFSReleaseResource( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_WARNING,
- "AFSValidateEntry Attempt to verify node of type %d\n",
- pObjectInfo->FileType);
+ "AFSValidateEntry Attempt to verify node of type %d FastCall %d %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ pObjectInfo->FileType,
+ FastCall,
+ &DirEntry->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
break;
}
if( pDirEnumEntry != NULL)
{
- AFSExFreePool( pDirEnumEntry);
+ AFSExFreePoolWithTag( pDirEnumEntry, AFS_GENERIC_MEMORY_2_TAG);
}
}
UNICODE_STRING uniShareName;
ULONG ulEntryLength = 0;
AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
+ LONG lCount;
__Enter
{
RtlInitUnicodeString( &uniShareName,
- L"PIPE\\srvsvc");
+ L"PIPE");
pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
0);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ lCount = AFSObjectInfoIncrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_GLOBAL);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitializeSpecialShareNameList (srvsvc) Initializing count (1) on object %08lX\n",
- pObjectInfoCB);
-
- pObjectInfoCB->ObjectReferenceCount = 1;
+ "AFSInitializeSpecialShareNameList (srvsvc) Increment count on object %p Cnt %d\n",
+ pObjectInfoCB,
+ lCount);
- pObjectInfoCB->FileType = AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
+ pObjectInfoCB->FileType = (ULONG) AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
ulEntryLength = sizeof( AFSDirectoryCB) +
uniShareName.Length;
if( pDirNode == NULL)
{
- AFSDeleteObjectInfo( pObjectInfoCB);
-
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
-
- pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
- sizeof( AFSNonPagedDirectoryCB),
- AFS_DIR_ENTRY_NP_TAG);
-
- if( pNonPagedDirEntry == NULL)
- {
-
- ExFreePool( pDirNode);
-
- AFSDeleteObjectInfo( pObjectInfoCB);
-
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
-
- RtlZeroMemory( pDirNode,
- ulEntryLength);
-
- RtlZeroMemory( pNonPagedDirEntry,
- sizeof( AFSNonPagedDirectoryCB));
-
- ExInitializeResourceLite( &pNonPagedDirEntry->Lock);
-
- pDirNode->NonPaged = pNonPagedDirEntry;
-
- pDirNode->ObjectInformation = pObjectInfoCB;
-
- //
- // Set valid entry
- //
-
- SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_SERVER_SERVICE);
-
- pDirNode->NameInformation.FileName.Length = uniShareName.Length;
-
- pDirNode->NameInformation.FileName.MaximumLength = uniShareName.Length;
-
- pDirNode->NameInformation.FileName.Buffer = (WCHAR *)((char *)pDirNode + sizeof( AFSDirectoryCB));
-
- RtlCopyMemory( pDirNode->NameInformation.FileName.Buffer,
- uniShareName.Buffer,
- pDirNode->NameInformation.FileName.Length);
-
- pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
- TRUE);
-
- AFSSpecialShareNames = pDirNode;
-
- pLastDirNode = pDirNode;
-
- RtlInitUnicodeString( &uniShareName,
- L"PIPE\\wkssvc");
-
- pObjectInfoCB = AFSAllocateObjectInfo( &AFSGlobalRoot->ObjectInformation,
- 0);
-
- if( pObjectInfoCB == NULL)
- {
+ AFSDeleteObjectInfo( &pObjectInfoCB);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitializeSpecialShareNameList (wkssvc) Initializing count (1) on object %08lX\n",
- pObjectInfoCB);
-
- pObjectInfoCB->ObjectReferenceCount = 1;
-
- pObjectInfoCB->FileType = AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
-
- ulEntryLength = sizeof( AFSDirectoryCB) +
- uniShareName.Length;
-
- pDirNode = (AFSDirectoryCB *)AFSLibExAllocatePoolWithTag( PagedPool,
- ulEntryLength,
- AFS_DIR_ENTRY_TAG);
-
- if( pDirNode == NULL)
- {
-
- AFSDeleteObjectInfo( pObjectInfoCB);
-
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
+ "AFSInitializeSpecialShareNameList (srvsvc) AFS_DIR_ENTRY_TAG allocated %p\n",
+ pDirNode);
pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedDirectoryCB),
ExFreePool( pDirNode);
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
// Set valid entry
//
- SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_WORKSTATION_SERVICE);
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID | AFS_DIR_ENTRY_PIPE_SERVICE);
pDirNode->NameInformation.FileName.Length = uniShareName.Length;
pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
TRUE);
- pLastDirNode->ListEntry.fLink = pDirNode;
-
- pDirNode->ListEntry.bLink = pLastDirNode;
+ AFSSpecialShareNames = pDirNode;
pLastDirNode = pDirNode;
+
RtlInitUnicodeString( &uniShareName,
L"IPC$");
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ lCount = AFSObjectInfoIncrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_GLOBAL);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitializeSpecialShareNameList (ipc$) Initializing count (1) on object %08lX\n",
- pObjectInfoCB);
-
- pObjectInfoCB->ObjectReferenceCount = 1;
+ "AFSInitializeSpecialShareNameList (ipc$) Incrementing count on object %p Cnt %d\n",
+ pObjectInfoCB,
+ lCount);
- pObjectInfoCB->FileType = AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
+ pObjectInfoCB->FileType = (ULONG) AFS_FILE_TYPE_SPECIAL_SHARE_NAME;
ulEntryLength = sizeof( AFSDirectoryCB) +
uniShareName.Length;
if( pDirNode == NULL)
{
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitializeSpecialShareNameList (ipc$) AFS_DIR_ENTRY_TAG allocated %p\n",
+ pDirNode);
+
pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSLibExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedDirectoryCB),
AFS_DIR_ENTRY_NP_TAG);
ExFreePool( pDirNode);
- AFSDeleteObjectInfo( pObjectInfoCB);
+ AFSDeleteObjectInfo( &pObjectInfoCB);
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
pLastDirNode = (AFSDirectoryCB *)pDirNode->ListEntry.fLink;
- AFSDeleteObjectInfo( pDirNode->ObjectInformation);
+ AFSDeleteObjectInfo( &pDirNode->ObjectInformation);
ExDeleteResourceLite( &pDirNode->NonPaged->Lock);
__Enter
{
- //
- // Build up the entire name here. We are guaranteed that if there is a
- // secondary name, it is pointing to a portion of the share name buffer
- //
-
- if( SecondaryName->Length > 0 &&
- SecondaryName->Buffer != NULL)
- {
-
- uniFullShareName = *SecondaryName;
-
- //
- // The calling routine strips off the leading slash so add it back in
- //
-
- uniFullShareName.Buffer--;
- uniFullShareName.Length += sizeof( WCHAR);
- uniFullShareName.MaximumLength += sizeof( WCHAR);
-
- //
- // And the share name
- //
- uniFullShareName.Buffer -= (ShareName->Length/sizeof( WCHAR));
- uniFullShareName.Length += ShareName->Length;
- uniFullShareName.MaximumLength += ShareName->Length;
- }
- else
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSGetSpecialShareNameEntry share name %wZ secondary name %wZ\n",
+ ShareName,
+ SecondaryName);
- uniFullShareName = *ShareName;
- }
+ uniFullShareName = *ShareName;
//
// Generate our hash value
BOOLEAN bIsEqual = FALSE;
- if( FileId1->Unique == FileId2->Unique &&
+ if( FileId1->Hash == FileId2->Hash &&
+ FileId1->Unique == FileId2->Unique &&
FileId1->Vnode == FileId2->Vnode &&
FileId1->Volume == FileId2->Volume &&
FileId1->Cell == FileId2->Cell)
pNextDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
- if( pCurrentDirEntry->OpenReferenceCount == 0)
+ if( pCurrentDirEntry->DirOpenReferenceCount <= 0 &&
+ pCurrentDirEntry->NameArrayReferenceCount <= 0)
{
AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSEnumerateGlobalRoot Acquiring GlobalRoot DirectoryNodeHdr.TreeLock lock %08lX EXCL %08lX\n",
+ "AFSEnumerateGlobalRoot Acquiring GlobalRoot DirectoryNodeHdr.TreeLock lock %p EXCL %08lX\n",
AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock,
PsGetCurrentThread());
pDirGlobalDirNode = AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeListHead;
- //
- // Indicate the node is initialized
- //
-
- SetFlag( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
-
uniFullName.MaximumLength = PAGE_SIZE;
uniFullName.Length = 0;
pDirGlobalDirNode = (AFSDirectoryCB *)pDirGlobalDirNode->ListEntry.fLink;
}
- AFSExFreePool( uniFullName.Buffer);
+ AFSExFreePoolWithTag( uniFullName.Buffer, 0);
try_exit:
BOOLEAN bIsRelative = FALSE;
- if( Name->Buffer[ 0] != L'\\')
+ if( Name->Length > 0 &&
+ Name->Buffer[ 0] != L'\\')
{
bIsRelative = TRUE;
return bIsRelative;
}
+BOOLEAN
+AFSIsAbsoluteAFSName( IN UNICODE_STRING *Name)
+{
+ UNICODE_STRING uniTempName;
+ BOOLEAN bIsAbsolute = FALSE;
+
+ //
+ // An absolute AFS path must begin with \afs\... or equivalent
+ //
+
+ if ( Name->Length == 0 ||
+ Name->Length <= AFSMountRootName.Length + sizeof( WCHAR) ||
+ Name->Buffer[ 0] != L'\\' ||
+ Name->Buffer[ AFSMountRootName.Length/sizeof( WCHAR)] != L'\\')
+ {
+
+ return FALSE;
+ }
+
+ uniTempName.Length = AFSMountRootName.Length;
+ uniTempName.MaximumLength = AFSMountRootName.Length;
+
+ uniTempName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
+ uniTempName.MaximumLength,
+ AFS_NAME_BUFFER_TWO_TAG);
+
+ if( uniTempName.Buffer == NULL)
+ {
+
+ return FALSE;
+ }
+
+ RtlCopyMemory( uniTempName.Buffer,
+ Name->Buffer,
+ AFSMountRootName.Length);
+
+ bIsAbsolute = (0 == RtlCompareUnicodeString( &uniTempName,
+ &AFSMountRootName,
+ TRUE));
+
+ AFSExFreePoolWithTag( uniTempName.Buffer,
+ AFS_NAME_BUFFER_TWO_TAG);
+
+ return bIsAbsolute;
+}
+
+
void
AFSUpdateName( IN UNICODE_STRING *Name)
{
if( BooleanFlagOn( *Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
{
- AFSExFreePool( TargetName->Buffer);
+ AFSExFreePoolWithTag( TargetName->Buffer, AFS_NAME_BUFFER_FIVE_TAG);
}
TargetName->MaximumLength = NameLength;
{
AFSNameArrayHdr *pNameArray = NULL;
+ AFSNameArrayCB *pCurrentElement = NULL;
AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ LONG lCount;
__Enter
{
if( pNameArray == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitNameArray Failed to allocate name array\n");
if( DirectoryCB != NULL)
{
- pNameArray->CurrentEntry = &pNameArray->ElementArray[ 0];
+ pCurrentElement = &pNameArray->ElementArray[ 0];
- InterlockedIncrement( &pNameArray->Count);
+ pNameArray->CurrentEntry = pCurrentElement;
- InterlockedIncrement( &DirectoryCB->OpenReferenceCount);
+ pNameArray->Count = 1;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ pNameArray->LinkCount = 0;
+
+ lCount = InterlockedIncrement( &DirectoryCB->NameArrayReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitNameArray Increment count on %wZ DE %p Cnt %d\n",
+ "AFSInitNameArray [NA:%p] Increment count on %wZ DE %p Cnt %d\n",
+ pNameArray,
&DirectoryCB->NameInformation.FileName,
DirectoryCB,
- DirectoryCB->OpenReferenceCount);
+ lCount);
+
+ pCurrentElement->DirectoryCB = DirectoryCB;
+
+ pCurrentElement->Component = DirectoryCB->NameInformation.FileName;
- pNameArray->CurrentEntry->DirectoryCB = DirectoryCB;
+ pCurrentElement->FileId = DirectoryCB->ObjectInformation->FileId;
- pNameArray->CurrentEntry->Component = DirectoryCB->NameInformation.FileName;
+ if( pCurrentElement->FileId.Vnode == 1)
+ {
+
+ SetFlag( pCurrentElement->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+ }
- pNameArray->CurrentEntry->FileId = DirectoryCB->ObjectInformation->FileId;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitNameArray [NA:%p] Element[0] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ pNameArray,
+ pCurrentElement->DirectoryCB,
+ pCurrentElement->FileId.Cell,
+ pCurrentElement->FileId.Volume,
+ pCurrentElement->FileId.Vnode,
+ pCurrentElement->FileId.Unique,
+ &pCurrentElement->DirectoryCB->NameInformation.FileName,
+ pCurrentElement->DirectoryCB->ObjectInformation->FileType);
}
try_exit:
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSNameArrayCB *pCurrentElement = NULL;
- UNICODE_STRING uniComponentName, uniRemainingPath;
- AFSObjectInfoCB *pCurrentObject = NULL;
- ULONG ulTotalCount = 0;
- ULONG ulIndex = 0;
- USHORT usLength = 0;
+ LONG lCount;
__Enter
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPopulateNameArray [NA:%p] passed Path %wZ DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ &Path,
+ DirectoryCB,
+ DirectoryCB->ObjectInformation->FileId.Cell,
+ DirectoryCB->ObjectInformation->FileId.Volume,
+ DirectoryCB->ObjectInformation->FileId.Vnode,
+ DirectoryCB->ObjectInformation->FileId.Unique,
+ &DirectoryCB->NameInformation.FileName,
+ DirectoryCB->ObjectInformation->FileType);
+
//
// Init some info in the header
//
pCurrentElement->DirectoryCB = DirectoryCB->ObjectInformation->VolumeCB->DirectoryCB;
- InterlockedIncrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pCurrentElement->DirectoryCB->NameArrayReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPopulateNameArray Increment count on volume %wZ DE %p Cnt %d\n",
+ "AFSPopulateNameArray [NA:%p] Increment count on volume %wZ DE %p Cnt %d\n",
+ NameArray,
&pCurrentElement->DirectoryCB->NameInformation.FileName,
pCurrentElement->DirectoryCB,
- pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount);
pCurrentElement->Component = DirectoryCB->ObjectInformation->VolumeCB->DirectoryCB->NameInformation.FileName;
pCurrentElement->FileId = DirectoryCB->ObjectInformation->VolumeCB->ObjectInformation.FileId;
+ pCurrentElement->Flags = 0;
+
+ if( pCurrentElement->FileId.Vnode == 1)
+ {
+
+ SetFlag( pCurrentElement->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+ }
+
NameArray->Count = 1;
NameArray->LinkCount = 0;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPopulateNameArray [NA:%p] Element[0] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ pCurrentElement->DirectoryCB,
+ pCurrentElement->FileId.Cell,
+ pCurrentElement->FileId.Volume,
+ pCurrentElement->FileId.Vnode,
+ pCurrentElement->FileId.Unique,
+ &pCurrentElement->DirectoryCB->NameInformation.FileName,
+ pCurrentElement->DirectoryCB->ObjectInformation->FileType);
+
//
// If the root is the parent then we are done ...
//
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSNameArrayCB *pCurrentElement = NULL, *pCurrentRelatedElement = NULL;
- UNICODE_STRING uniComponentName, uniRemainingPath;
- AFSObjectInfoCB *pObjectInfo = NULL;
- ULONG ulTotalCount = 0;
- ULONG ulIndex = 0;
- USHORT usLength = 0;
+ LONG lCount;
__Enter
{
+ if ( DirectoryCB)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPopulateNameArray [NA:%p] passed RelatedNameArray %p DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ RelatedNameArray,
+ DirectoryCB,
+ DirectoryCB->ObjectInformation->FileId.Cell,
+ DirectoryCB->ObjectInformation->FileId.Volume,
+ DirectoryCB->ObjectInformation->FileId.Vnode,
+ DirectoryCB->ObjectInformation->FileId.Unique,
+ &DirectoryCB->NameInformation.FileName,
+ DirectoryCB->ObjectInformation->FileType);
+ }
+ else
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPopulateNameArray [NA:%p] passed RelatedNameArray %p DE NULL\n",
+ NameArray,
+ RelatedNameArray);
+ }
+
//
// Init some info in the header
//
pCurrentElement->FileId = pCurrentElement->DirectoryCB->ObjectInformation->FileId;
- InterlockedIncrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
+ pCurrentElement->Flags = 0;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ if( pCurrentElement->FileId.Vnode == 1)
+ {
+
+ SetFlag( pCurrentElement->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+ }
+
+ lCount = InterlockedIncrement( &pCurrentElement->DirectoryCB->NameArrayReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSPopulateNameArrayFromRelatedArray Increment count on %wZ DE %p Cnt %d\n",
+ "AFSPopulateNameArrayFromRelatedArray [NA:%p] Increment count on %wZ DE %p Cnt %d\n",
+ NameArray,
&pCurrentElement->DirectoryCB->NameInformation.FileName,
pCurrentElement->DirectoryCB,
- pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount);
- InterlockedIncrement( &NameArray->Count);
+ lCount = InterlockedIncrement( &NameArray->Count);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPopulateNameArrayFromRelatedArray [NA:%p] Element[%d] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ lCount - 1,
+ pCurrentElement->DirectoryCB,
+ pCurrentElement->FileId.Cell,
+ pCurrentElement->FileId.Volume,
+ pCurrentElement->FileId.Vnode,
+ pCurrentElement->FileId.Unique,
+ &pCurrentElement->DirectoryCB->NameInformation.FileName,
+ pCurrentElement->DirectoryCB->ObjectInformation->FileType);
if( pCurrentElement->DirectoryCB == DirectoryCB ||
NameArray->Count == RelatedNameArray->Count)
pCurrentRelatedElement++;
}
- if( NameArray->Count > 0)
- {
- NameArray->CurrentEntry = pCurrentElement;
- }
+ NameArray->CurrentEntry = NameArray->Count > 0 ? pCurrentElement : NULL;
}
return ntStatus;
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSNameArrayCB *pCurrentElement = NULL;
+ LONG lCount, lElement;
__Enter
{
- pCurrentElement = &NameArray->ElementArray[ 0];
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFreeNameArray [NA:%p]\n",
+ NameArray);
- while( TRUE)
+ for ( lElement = 0; lElement < NameArray->Count; lElement++)
{
- if( pCurrentElement->DirectoryCB == NULL)
- {
-
- break;
- }
+ pCurrentElement = &NameArray->ElementArray[ lElement];
- InterlockedDecrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pCurrentElement->DirectoryCB->NameArrayReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSFreeNameArray Decrement count on %wZ DE %p Cnt %d\n",
+ "AFSFreeNameArray [NA:%p] Decrement count on %wZ DE %p Cnt %d\n",
+ NameArray,
&pCurrentElement->DirectoryCB->NameInformation.FileName,
pCurrentElement->DirectoryCB,
- pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount);
- pCurrentElement++;
+ ASSERT( lCount >= 0);
}
- AFSExFreePool( NameArray);
+ AFSExFreePoolWithTag( NameArray, AFS_NAME_ARRAY_TAG);
}
return ntStatus;
NTSTATUS
AFSInsertNextElement( IN AFSNameArrayHdr *NameArray,
- IN AFSDirectoryCB *DirEntry)
+ IN AFSDirectoryCB *DirectoryCB)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ AFSNameArrayCB *pCurrentElement = NULL;
+ LONG lCount;
__Enter
{
- if( NameArray->Count == NameArray->MaxElementCount)
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInsertNextElement [NA:%p] passed DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ DirectoryCB,
+ DirectoryCB->ObjectInformation->FileId.Cell,
+ DirectoryCB->ObjectInformation->FileId.Volume,
+ DirectoryCB->ObjectInformation->FileId.Vnode,
+ DirectoryCB->ObjectInformation->FileId.Unique,
+ &DirectoryCB->NameInformation.FileName,
+ DirectoryCB->ObjectInformation->FileType);
+
+ if( NameArray->Count == (LONG) NameArray->MaxElementCount)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSInsertNextElement [NA:%p] Name has reached Maximum Size\n",
+ NameArray);
+
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
- if( NameArray->CurrentEntry != NULL &&
- NameArray->CurrentEntry->DirectoryCB == DirEntry)
+ for ( lCount = 0; lCount < NameArray->Count; lCount++)
{
- try_return( ntStatus);
+ if ( AFSIsEqualFID( &NameArray->ElementArray[ lCount].FileId,
+ &DirectoryCB->ObjectInformation->FileId) )
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSInsertNextElement [NA:%p] DE %p recursion Status %08X\n",
+ NameArray,
+ DirectoryCB,
+ STATUS_ACCESS_DENIED);
+
+ try_return( ntStatus = STATUS_ACCESS_DENIED);
+ }
}
if( NameArray->Count > 0)
NameArray->CurrentEntry = &NameArray->ElementArray[ 0];
}
- InterlockedIncrement( &NameArray->Count);
-
- InterlockedIncrement( &DirEntry->OpenReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInsertNextElement Increment count on %wZ DE %p Cnt %d\n",
- &DirEntry->NameInformation.FileName,
- DirEntry,
- DirEntry->OpenReferenceCount);
-
- NameArray->CurrentEntry->DirectoryCB = DirEntry;
-
- NameArray->CurrentEntry->Component = DirEntry->NameInformation.FileName;
+ pCurrentElement = NameArray->CurrentEntry;
- NameArray->CurrentEntry->FileId = DirEntry->ObjectInformation->FileId;
-
-try_exit:
-
- NOTHING;
- }
+ lCount = InterlockedIncrement( &NameArray->Count);
- return ntStatus;
-}
+ lCount = InterlockedIncrement( &DirectoryCB->NameArrayReferenceCount);
-void
-AFSReplaceCurrentElement( IN AFSNameArrayHdr *NameArray,
- IN AFSDirectoryCB *DirectoryCB)
-{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInsertNextElement [NA:%p] Increment count on %wZ DE %p Cnt %d\n",
+ NameArray,
+ &DirectoryCB->NameInformation.FileName,
+ DirectoryCB,
+ lCount);
- ASSERT( NameArray->CurrentEntry != NULL);
+ ASSERT( lCount > 0);
- InterlockedDecrement( &NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
+ pCurrentElement->DirectoryCB = DirectoryCB;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSReplaceCurrentElement Decrement count on %wZ DE %p Cnt %d\n",
- &NameArray->CurrentEntry->DirectoryCB->NameInformation.FileName,
- NameArray->CurrentEntry->DirectoryCB,
- NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
+ pCurrentElement->Component = DirectoryCB->NameInformation.FileName;
- InterlockedIncrement( &DirectoryCB->OpenReferenceCount);
+ pCurrentElement->FileId = DirectoryCB->ObjectInformation->FileId;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSReplaceCurrentElement Increment count on %wZ DE %p Cnt %d\n",
- &DirectoryCB->NameInformation.FileName,
- DirectoryCB,
- DirectoryCB->OpenReferenceCount);
+ pCurrentElement->Flags = 0;
- NameArray->CurrentEntry->DirectoryCB = DirectoryCB;
+ if( pCurrentElement->FileId.Vnode == 1)
+ {
- NameArray->CurrentEntry->Component = DirectoryCB->NameInformation.FileName;
+ SetFlag( pCurrentElement->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+ }
- NameArray->CurrentEntry->FileId = DirectoryCB->ObjectInformation->FileId;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInsertNextElement [NA:%p] Element[%d] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ NameArray->Count - 1,
+ pCurrentElement->DirectoryCB,
+ pCurrentElement->FileId.Cell,
+ pCurrentElement->FileId.Volume,
+ pCurrentElement->FileId.Vnode,
+ pCurrentElement->FileId.Unique,
+ &pCurrentElement->DirectoryCB->NameInformation.FileName,
+ pCurrentElement->DirectoryCB->ObjectInformation->FileType);
- if( DirectoryCB->ObjectInformation->ParentObjectInformation == NULL)
- {
+try_exit:
- SetFlag( NameArray->CurrentEntry->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+ NOTHING;
}
- return;
+ return ntStatus;
}
AFSDirectoryCB *
AFSBackupEntry( IN AFSNameArrayHdr *NameArray)
{
- AFSDirectoryCB *pCurrentDirEntry = NULL;
+ AFSDirectoryCB *pDirectoryCB = NULL;
+ AFSNameArrayCB *pCurrentElement = NULL;
+ BOOLEAN bVolumeRoot = FALSE;
+ LONG lCount;
__Enter
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSBackupEntry [NA:%p]\n",
+ NameArray);
+
if( NameArray->Count == 0)
{
- try_return( pCurrentDirEntry);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSBackupEntry [NA:%p] No more entries\n",
+ NameArray);
+
+ try_return( pCurrentElement);
}
- InterlockedDecrement( &NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedDecrement( &NameArray->CurrentEntry->DirectoryCB->NameArrayReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSBackupEntry Decrement count on %wZ DE %p Cnt %d\n",
+ "AFSBackupEntry [NA:%p] Decrement count on %wZ DE %p Cnt %d\n",
+ NameArray,
&NameArray->CurrentEntry->DirectoryCB->NameInformation.FileName,
NameArray->CurrentEntry->DirectoryCB,
- NameArray->CurrentEntry->DirectoryCB->OpenReferenceCount);
+ lCount);
+
+ ASSERT( lCount >= 0);
NameArray->CurrentEntry->DirectoryCB = NULL;
- if( InterlockedDecrement( &NameArray->Count) == 0)
+ lCount = InterlockedDecrement( &NameArray->Count);
+
+ if( lCount == 0)
{
NameArray->CurrentEntry = NULL;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSBackupEntry [NA:%p] No more entries\n",
+ NameArray);
}
else
{
+
+ bVolumeRoot = BooleanFlagOn( NameArray->CurrentEntry->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+
NameArray->CurrentEntry--;
- pCurrentDirEntry = NameArray->CurrentEntry->DirectoryCB;
+
+ pCurrentElement = NameArray->CurrentEntry;
+
+ pDirectoryCB = pCurrentElement->DirectoryCB;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSBackupEntry [NA:%p] Returning Element[%d] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ NameArray->Count - 1,
+ pCurrentElement->DirectoryCB,
+ pCurrentElement->FileId.Cell,
+ pCurrentElement->FileId.Volume,
+ pCurrentElement->FileId.Vnode,
+ pCurrentElement->FileId.Unique,
+ &pCurrentElement->DirectoryCB->NameInformation.FileName,
+ pCurrentElement->DirectoryCB->ObjectInformation->FileType);
+
+ //
+ // If the entry we are removing is a volume root,
+ // we must remove the mount point entry as well.
+ // If the NameArray was constructed by checking the
+ // share name via the service, the name array can
+ // contain two volume roots in sequence without a
+ // mount point separating them.
+ //
+
+ if ( bVolumeRoot &&
+ !BooleanFlagOn( NameArray->CurrentEntry->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT))
+ {
+
+ pDirectoryCB = AFSBackupEntry( NameArray);
+ }
}
+
try_exit:
NOTHING;
}
- return pCurrentDirEntry;
+ return pDirectoryCB;
}
AFSDirectoryCB *
__Enter
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetParentEntry [NA:%p]\n",
+ NameArray);
+
if( NameArray->Count == 0 ||
NameArray->Count == 1)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSGetParentEntry [NA:%p] No more entries\n",
+ NameArray);
+
try_return( pDirEntry = NULL);
}
pDirEntry = pElement->DirectoryCB;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetParentEntry [NA:%p] Returning Element[%d] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ NameArray->Count - 2,
+ pElement->DirectoryCB,
+ pElement->FileId.Cell,
+ pElement->FileId.Volume,
+ pElement->FileId.Vnode,
+ pElement->FileId.Unique,
+ &pElement->DirectoryCB->NameInformation.FileName,
+ pElement->DirectoryCB->ObjectInformation->FileType);
+
try_exit:
NOTHING;
void
AFSResetNameArray( IN AFSNameArrayHdr *NameArray,
- IN AFSDirectoryCB *DirEntry)
+ IN AFSDirectoryCB *DirectoryCB)
{
AFSNameArrayCB *pCurrentElement = NULL;
AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ LONG lCount, lElement;
__Enter
{
- pCurrentElement = &NameArray->ElementArray[ 0];
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSResetNameArray [NA:%p] passed DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ DirectoryCB,
+ DirectoryCB->ObjectInformation->FileId.Cell,
+ DirectoryCB->ObjectInformation->FileId.Volume,
+ DirectoryCB->ObjectInformation->FileId.Vnode,
+ DirectoryCB->ObjectInformation->FileId.Unique,
+ &DirectoryCB->NameInformation.FileName,
+ DirectoryCB->ObjectInformation->FileType);
+ //
+ // Dereference previous name array contents
+ //
- while( TRUE)
+ for ( lElement = 0; lElement < NameArray->Count; lElement++)
{
- if( pCurrentElement->DirectoryCB == NULL)
- {
-
- break;
- }
+ pCurrentElement = &NameArray->ElementArray[ lElement];
- InterlockedDecrement( &pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pCurrentElement->DirectoryCB->NameArrayReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSResetNameArray Decrement count on %wZ DE %p Cnt %d\n",
+ "AFSResetNameArray [NA:%p] Decrement count on %wZ DE %p Cnt %d\n",
+ NameArray,
&pCurrentElement->DirectoryCB->NameInformation.FileName,
pCurrentElement->DirectoryCB,
- pCurrentElement->DirectoryCB->OpenReferenceCount);
+ lCount);
- pCurrentElement++;
+ ASSERT( lCount >= 0);
}
RtlZeroMemory( NameArray,
NameArray->MaxElementCount = pDevExt->Specific.RDR.NameArrayLength;
- if( DirEntry != NULL)
+ if( DirectoryCB != NULL)
{
- NameArray->CurrentEntry = &NameArray->ElementArray[ 0];
+ pCurrentElement = &NameArray->ElementArray[ 0];
- InterlockedIncrement( &NameArray->Count);
+ NameArray->CurrentEntry = pCurrentElement;
- InterlockedIncrement( &DirEntry->OpenReferenceCount);
+ NameArray->Count = 1;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ NameArray->LinkCount = 0;
+
+ lCount = InterlockedIncrement( &DirectoryCB->NameArrayReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSResetNameArray Increment count on %wZ DE %p Cnt %d\n",
- &DirEntry->NameInformation.FileName,
- DirEntry,
- DirEntry->OpenReferenceCount);
+ "AFSResetNameArray [NA:%p] Increment count on %wZ DE %p Cnt %d\n",
+ NameArray,
+ &DirectoryCB->NameInformation.FileName,
+ DirectoryCB,
+ lCount);
+
+ pCurrentElement->DirectoryCB = DirectoryCB;
+
+ pCurrentElement->Component = DirectoryCB->NameInformation.FileName;
- NameArray->CurrentEntry->DirectoryCB = DirEntry;
+ pCurrentElement->FileId = DirectoryCB->ObjectInformation->FileId;
- NameArray->CurrentEntry->Component = DirEntry->NameInformation.FileName;
+ pCurrentElement->Flags = 0;
+
+ if( pCurrentElement->FileId.Vnode == 1)
+ {
+
+ SetFlag( pCurrentElement->Flags, AFS_NAME_ARRAY_FLAG_ROOT_ELEMENT);
+ }
- NameArray->CurrentEntry->FileId = DirEntry->ObjectInformation->FileId;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_NAME_ARRAY_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSResetNameArray [NA:%p] Element[0] DE %p FID %08lX-%08lX-%08lX-%08lX %wZ Type %d\n",
+ NameArray,
+ pCurrentElement->DirectoryCB,
+ pCurrentElement->FileId.Cell,
+ pCurrentElement->FileId.Volume,
+ pCurrentElement->FileId.Vnode,
+ pCurrentElement->FileId.Unique,
+ &pCurrentElement->DirectoryCB->NameInformation.FileName,
+ pCurrentElement->DirectoryCB->ObjectInformation->FileType);
}
}
void
AFSSetEnumerationEvent( IN AFSFcb *Fcb)
{
+ LONG lCount;
//
// Depending on the type of node, set the event
{
case AFS_DIRECTORY_FCB:
- {
-
- KeSetEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
- 0,
- FALSE);
-
- InterlockedIncrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount);
-
- break;
- }
-
case AFS_ROOT_FCB:
case AFS_ROOT_ALL:
{
- KeSetEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent,
- 0,
- FALSE);
-
- InterlockedIncrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount);
+ lCount = InterlockedIncrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount);
break;
}
AFSClearEnumerationEvent( IN AFSFcb *Fcb)
{
+ LONG lCount;
+
//
// Depending on the type of node, set the event
//
{
case AFS_DIRECTORY_FCB:
- {
-
- ASSERT( Fcb->NPFcb->Specific.Directory.DirectoryEnumCount > 0);
-
- if( InterlockedDecrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount) == 0)
- {
-
- KeClearEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent);
- }
-
- break;
- }
-
case AFS_ROOT_FCB:
case AFS_ROOT_ALL:
{
ASSERT( Fcb->NPFcb->Specific.Directory.DirectoryEnumCount > 0);
- if( InterlockedDecrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount) == 0)
- {
-
- KeClearEvent( &Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent);
- }
+ lCount = InterlockedDecrement( &Fcb->NPFcb->Specific.Directory.DirectoryEnumCount);
break;
}
try_return( bIsInProcess);
}
- //
- // Depending on the type of node, set the event
- //
-
switch( ObjectInfo->Fcb->Header.NodeTypeCode)
{
case AFS_DIRECTORY_FCB:
- {
-
- if( KeReadStateEvent( &ObjectInfo->Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent))
- {
-
- bIsInProcess = TRUE;
- }
-
- break;
- }
-
case AFS_ROOT_FCB:
case AFS_ROOT_ALL:
{
- if( KeReadStateEvent( &ObjectInfo->Fcb->NPFcb->Specific.Directory.DirectoryEnumEvent))
+ if( ObjectInfo->Fcb->NPFcb->Specific.Directory.DirectoryEnumCount > 0)
{
bIsInProcess = TRUE;
IN AFSVolumeCB *VolumeCB)
{
+ UNREFERENCED_PARAMETER(ProcessId);
+ UNREFERENCED_PARAMETER(VolumeCB);
NTSTATUS ntStatus = STATUS_SUCCESS;
}
NTSTATUS
-AFSInitPIOCtlDirectoryCB( IN AFSObjectInfoCB *ObjectInfo)
+AFSInitPIOCtlDirectoryCB( IN AFSObjectInfoCB *ParentObjectInfo)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDirectoryCB *pDirNode = NULL;
ULONG ulEntryLength = 0;
AFSNonPagedDirectoryCB *pNonPagedDirEntry = NULL;
+ LONG lCount;
__Enter
{
- pObjectInfoCB = AFSAllocateObjectInfo( ObjectInfo,
+ pObjectInfoCB = AFSAllocateObjectInfo( ParentObjectInfo,
0);
if( pObjectInfoCB == NULL)
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ lCount = AFSObjectInfoIncrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_DIRENTRY);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInitPIOCtlDirectoryCB Initializing count (1) on object %08lX\n",
- pObjectInfoCB);
-
- pObjectInfoCB->ObjectReferenceCount = 1;
+ "AFSInitPIOCtlDirectoryCB Increment count on object %p Cnt %d\n",
+ pObjectInfoCB,
+ lCount);
- pObjectInfoCB->FileType = AFS_FILE_TYPE_PIOCTL;
+ pObjectInfoCB->FileType = (ULONG) AFS_FILE_TYPE_PIOCTL;
pObjectInfoCB->FileAttributes = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
if( pDirNode == NULL)
{
- AFSDeleteObjectInfo( pObjectInfoCB);
-
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitPIOCtlDirectoryCB AFS_DIR_ENTRY_TAG allocated %p\n",
+ pDirNode);
+
pNonPagedDirEntry = (AFSNonPagedDirectoryCB *)AFSExAllocatePoolWithTag( NonPagedPool,
sizeof( AFSNonPagedDirectoryCB),
AFS_DIR_ENTRY_NP_TAG);
pDirNode->CaseInsensitiveTreeEntry.HashIndex = AFSGenerateCRC( &pDirNode->NameInformation.FileName,
TRUE);
- ObjectInfo->Specific.Directory.PIOCtlDirectoryCB = pDirNode;
+ if ( InterlockedCompareExchangePointer( (PVOID *)&ParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB, pDirNode, NULL) != NULL)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSInitPIOCtlDirectoryCB Raced PIOCtlDirectoryCB %p pFcb %p\n",
+ ParentObjectInfo->Specific.Directory.PIOCtlDirectoryCB,
+ pDirNode);
+
+ try_return( ntStatus = STATUS_REPARSE);
+ }
try_exit:
- if ( !NT_SUCCESS( ntStatus))
+ if ( ntStatus != STATUS_SUCCESS)
{
if ( pDirNode != NULL)
{
- AFSExFreePool( pDirNode);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitPIOCtlDirectoryCB AFS_DIR_ENTRY_TAG deallocating %p\n",
+ pDirNode);
+
+ AFSExFreePoolWithTag( pDirNode, AFS_DIR_ENTRY_TAG);
+ }
+
+ if( pNonPagedDirEntry != NULL)
+ {
+
+ ExDeleteResourceLite( &pNonPagedDirEntry->Lock);
+
+ AFSExFreePoolWithTag( pNonPagedDirEntry, AFS_DIR_ENTRY_NP_TAG);
}
if ( pObjectInfoCB != NULL)
{
- AFSDeleteObjectInfo( pObjectInfoCB);
+ lCount = AFSObjectInfoDecrement( pObjectInfoCB,
+ AFS_OBJECT_REFERENCE_DIRENTRY);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitPIOCtlDirectoryCB Decrement count on object %p Cnt %d\n",
+ pObjectInfoCB,
+ lCount);
+
+ AFSDeleteObjectInfo( &pObjectInfoCB);
}
}
}
IN AFSDirectoryCB *DirectoryCB,
IN UNICODE_STRING *ParentPathName,
IN AFSNameArrayHdr *RelatedNameArray,
+ IN GUID *AuthGroup,
OUT AFSFileInfoCB *FileInfo)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDirEnumEntry *pDirEntry = NULL, *pLastDirEntry = NULL;
- UNICODE_STRING uniFullPathName;
+ AFSDirEnumEntry *pDirEntry = NULL;
+ UNICODE_STRING uniFullPathName = {0};
AFSNameArrayHdr *pNameArray = NULL;
AFSVolumeCB *pVolumeCB = NULL;
+ LONG VolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
+ AFSVolumeCB *pNewVolumeCB = NULL;
+ LONG NewVolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
AFSDirectoryCB *pDirectoryEntry = NULL, *pParentDirEntry = NULL;
+ AFSDirectoryCB *pNewParentDirEntry = NULL;
WCHAR *pwchBuffer = NULL;
UNICODE_STRING uniComponentName, uniRemainingPath, uniParsedName;
ULONG ulNameDifference = 0;
- GUID *pAuthGroup = NULL;
+ LONG lCount;
__Enter
{
AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
- if( ParentDirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &ParentDirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
- else if( DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
- pAuthGroup,
+ AuthGroup,
FALSE,
&pDirEntry);
if( pDirEntry != NULL)
{
- ntStatus = STATUS_ACCESS_DENIED;
+ ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
}
try_return( ntStatus);
pVolumeCB = ParentDirectoryCB->ObjectInformation->VolumeCB;
- AFSAcquireShared( pVolumeCB->VolumeLock,
- TRUE);
-
pParentDirEntry = ParentDirectoryCB;
}
else
pVolumeCB = AFSGlobalRoot;
- AFSAcquireShared( pVolumeCB->VolumeLock,
- TRUE);
-
pParentDirEntry = AFSGlobalRoot->DirectoryCB;
}
// Increment the ref count on the volume and dir entry for correct processing below
//
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_FILE_ATTRS;
+
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ VolumeReferenceReason);
AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Increment count on volume %08lX Cnt %d\n",
+ "AFSRetrieveFileAttributes Increment count on volume %p Reason %u Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason,
+ lCount);
- InterlockedIncrement( &pParentDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
&pParentDirEntry->NameInformation.FileName,
pParentDirEntry,
NULL,
- pParentDirEntry->OpenReferenceCount);
+ lCount);
ntStatus = AFSLocateNameEntry( NULL,
NULL,
&uniParsedName,
pNameArray,
AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL,
- &pVolumeCB,
- &pParentDirEntry,
+ pVolumeCB,
+ pParentDirEntry,
+ &pNewVolumeCB,
+ &NewVolumeReferenceReason,
+ &pNewParentDirEntry,
&pDirectoryEntry,
NULL);
- if( !NT_SUCCESS( ntStatus))
+ if ( pNewVolumeCB != NULL)
{
-
//
- // The volume lock was released on failure above
- // Except for STATUS_OBJECT_NAME_NOT_FOUND
+ // AFSLocateNameEntry returns pNewVolumeCB with a reference held
+ // even if pVolumeCB == pNewVolumeCB. It is always safe to release
+ // the reference on pVolumeCB that was held prior to the call.
+ // If pVolumeCB == pNewVolumeCB, the reference from AFSLocateNameEntry
+ // will be released second.
//
- if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
- {
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ VolumeReferenceReason);
- if( pVolumeCB != NULL)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRetrieveFileAttributes Decrement count on volume %p Reason %u Cnt %d\n",
+ pVolumeCB,
+ VolumeReferenceReason,
+ lCount);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ pVolumeCB = pNewVolumeCB;
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Decrement count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ pNewVolumeCB = NULL;
- AFSReleaseResource( pVolumeCB->VolumeLock);
- }
+ VolumeReferenceReason = NewVolumeReferenceReason;
- if( pDirectoryEntry != NULL)
- {
+ NewVolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
+ }
+
+ //
+ // AFSLocateNameEntry does not alter the reference count of
+ // pParentDirectoryCB and it returns pNewParentDirectoryCB with
+ // a reference held.
+ //
- InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirectoryEntry->NameInformation.FileName,
- pDirectoryEntry,
- NULL,
- pDirectoryEntry->OpenReferenceCount);
- }
- else
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRetrieveFileAttributes DecrementX count on %wZ DE %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ lCount);
- InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
+ pParentDirEntry = pNewParentDirEntry;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pParentDirEntry->NameInformation.FileName,
- pParentDirEntry,
- NULL,
- pParentDirEntry->OpenReferenceCount);
- }
- }
+ pNewParentDirEntry = NULL;
- pVolumeCB = NULL;
+ if( !NT_SUCCESS( ntStatus) ||
+ ntStatus == STATUS_REPARSE)
+ {
try_return( ntStatus);
}
// Check for the mount point being returned
//
- if( pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_MOUNTPOINT)
+ if( pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_MOUNTPOINT ||
+ pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DFSLINK)
{
FileInfo->FileAttributes |= (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
}
- else if( pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK ||
- pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_DFSLINK)
+ else if( pDirectoryEntry->ObjectInformation->FileType == AFS_FILE_TYPE_SYMLINK)
{
- FileInfo->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ if ( FileInfo->FileAttributes == FILE_ATTRIBUTE_NORMAL)
+ {
+
+ FileInfo->FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
+ }
+ else
+ {
+
+ FileInfo->FileAttributes |= FILE_ATTRIBUTE_REPARSE_POINT;
+ }
}
FileInfo->AllocationSize = pDirectoryEntry->ObjectInformation->AllocationSize;
FileInfo->ChangeTime = pDirectoryEntry->ObjectInformation->ChangeTime;
- //
- // Remove the reference made above
- //
+try_exit:
- InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
+ if( pDirEntry != NULL)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirectoryEntry->NameInformation.FileName,
- pDirectoryEntry,
- NULL,
- pDirectoryEntry->OpenReferenceCount);
+ AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
+ }
-try_exit:
+ if( pDirectoryEntry != NULL)
+ {
- if( pDirEntry != NULL)
+ lCount = InterlockedDecrement( &pDirectoryEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRetrieveFileAttributes Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirectoryEntry->NameInformation.FileName,
+ pDirectoryEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
+ }
+
+ if ( pParentDirEntry != NULL)
{
- AFSExFreePool( pDirEntry);
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRetrieveFileAttributes Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
}
if( pVolumeCB != NULL)
{
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ VolumeReferenceReason);
AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Decrement2 count on volume %08lX Cnt %d\n",
+ "AFSRetrieveFileAttributes Decrement2 count on volume %p Reason %u Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
-
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ VolumeReferenceReason,
+ lCount);
}
if( pNameArray != NULL)
// offset by the length of the server name
//
- AFSExFreePool( pwchBuffer);
-
if( uniFullPathName.Length > 0 &&
pwchBuffer != (WCHAR *)((char *)uniFullPathName.Buffer - ulNameDifference))
{
- AFSExFreePool( uniFullPathName.Buffer);
+ AFSExFreePoolWithTag( uniFullPathName.Buffer, 0);
}
+
+ AFSExFreePoolWithTag( pwchBuffer, 0);
}
}
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSObjectInfoCB *pObjectInfo = NULL;
+ LONG lCount;
__Enter
{
if( pObjectInfo->NonPagedInfo == NULL)
{
- AFSExFreePool( pObjectInfo);
+ AFSExFreePoolWithTag( pObjectInfo, AFS_OBJECT_INFO_TAG);
try_return( pObjectInfo = NULL);
}
ExInitializeResourceLite( &pObjectInfo->NonPagedInfo->DirectoryNodeHdrLock);
- pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock = &pObjectInfo->NonPagedInfo->DirectoryNodeHdrLock;
-
- pObjectInfo->VolumeCB = ParentObjectInfo->VolumeCB;
+ ExInitializeResourceLite( &pObjectInfo->NonPagedInfo->ObjectInfoLock);
- pObjectInfo->ParentObjectInformation = ParentObjectInfo;
+ pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock = &pObjectInfo->NonPagedInfo->DirectoryNodeHdrLock;
if( ParentObjectInfo != NULL)
{
- InterlockedIncrement( &ParentObjectInfo->ObjectReferenceCount);
+
+ pObjectInfo->VolumeCB = ParentObjectInfo->VolumeCB;
+
+ pObjectInfo->ParentFileId = ParentObjectInfo->FileId;
+
+ SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_PARENT_FID);
+
+ lCount = AFSObjectInfoIncrement( ParentObjectInfo,
+ AFS_OBJECT_REFERENCE_CHILD);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSAllocateObjectInfo Increment count on parent object %p Cnt %d\n",
+ ParentObjectInfo,
+ lCount);
}
//
if( HashIndex != 0)
{
+ ASSERT( ParentObjectInfo);
+
//
// Insert the entry into the object tree and list
//
return pObjectInfo;
}
+LONG
+AFSObjectInfoIncrement( IN AFSObjectInfoCB *ObjectInfo,
+ IN LONG Reason)
+{
+
+ LONG lCount;
+
+ if ( ObjectInfo->ObjectReferenceCount == 0)
+ {
+
+ AFSAcquireExcl( &ObjectInfo->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ lCount = InterlockedIncrement( &ObjectInfo->ObjectReferenceCount);
+ }
+ else
+ {
+
+ AFSAcquireShared( &ObjectInfo->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ lCount = InterlockedIncrement( &ObjectInfo->ObjectReferenceCount);
+
+ if ( lCount == 1)
+ {
+
+ AFSReleaseResource( &ObjectInfo->NonPagedInfo->ObjectInfoLock);
+
+ AFSAcquireExcl( &ObjectInfo->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+ }
+ }
+
+ InterlockedIncrement( &ObjectInfo->ObjectReferences[ Reason]);
+
+ AFSReleaseResource( &ObjectInfo->NonPagedInfo->ObjectInfoLock);
+
+ return lCount;
+}
+
+LONG
+AFSObjectInfoDecrement( IN AFSObjectInfoCB *ObjectInfo,
+ IN LONG Reason)
+{
+
+ LONG lCount, lCount2;
+
+ AFSAcquireShared( &ObjectInfo->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ lCount = InterlockedDecrement( &ObjectInfo->ObjectReferenceCount);
+
+ if ( lCount == 0)
+ {
+
+ lCount = InterlockedIncrement( &ObjectInfo->ObjectReferenceCount);
+
+ AFSReleaseResource(&ObjectInfo->NonPagedInfo->ObjectInfoLock);
+
+ AFSAcquireExcl( &ObjectInfo->NonPagedInfo->ObjectInfoLock,
+ TRUE);
+
+ lCount = InterlockedDecrement( &ObjectInfo->ObjectReferenceCount);
+ }
+
+ lCount2 = InterlockedDecrement( &ObjectInfo->ObjectReferences[ Reason]);
+
+ ASSERT( lCount2 >= 0);
+
+ AFSReleaseResource( &ObjectInfo->NonPagedInfo->ObjectInfoLock);
+
+ return lCount;
+}
+
+AFSObjectInfoCB *
+AFSFindObjectInfo( IN AFSVolumeCB *VolumeCB,
+ IN AFSFileID *FileId)
+{
+ DWORD ntStatus = STATUS_SUCCESS;
+ ULONGLONG ullIndex;
+ AFSObjectInfoCB *pObjectInfo = NULL;
+
+ if ( AFSIsEqualFID( &VolumeCB->ObjectInformation.FileId, FileId))
+ {
+
+ pObjectInfo = &VolumeCB->ObjectInformation;
+ }
+ else
+ {
+
+ AFSAcquireExcl( VolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+
+ ullIndex = AFSCreateLowIndex( FileId);
+
+ ntStatus = AFSLocateHashEntry( VolumeCB->ObjectInfoTree.TreeHead,
+ ullIndex,
+ (AFSBTreeEntry **)&pObjectInfo);
+
+ AFSReleaseResource( VolumeCB->ObjectInfoTree.TreeLock);
+ }
+
+ if ( NT_SUCCESS( ntStatus)) {
+
+ AFSObjectInfoIncrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_FIND);
+ }
+
+ return pObjectInfo;
+}
+
+void
+AFSReleaseObjectInfo( IN AFSObjectInfoCB **ppObjectInfo)
+{
+
+ AFSObjectInfoDecrement( *ppObjectInfo,
+ AFS_OBJECT_REFERENCE_FIND);
+
+ *ppObjectInfo = NULL;
+}
+
void
-AFSDeleteObjectInfo( IN AFSObjectInfoCB *ObjectInfo)
+AFSDeleteObjectInfo( IN AFSObjectInfoCB **ppObjectInfo)
{
BOOLEAN bAcquiredTreeLock = FALSE;
+ AFSObjectInfoCB *pObjectInfo = (*ppObjectInfo);
+ BOOLEAN bHeldInService = BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE);
+ AFSObjectInfoCB * pParentObjectInfo = NULL;
+ AFSFileID FileId;
+ LONG lCount;
+
+ if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_ROOT_VOLUME))
+ {
+
+ //
+ // AFSDeleteObjectInfo should never be called on the ObjectInformationCB
+ // embedded in the VolumeCB.
+ //
+
+ ASSERT( TRUE);
+
+ return;
+ }
- if( !ExIsResourceAcquiredExclusiveLite( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock))
+ ASSERT( pObjectInfo->ObjectReferenceCount == 0);
+
+ (*ppObjectInfo) = NULL;
+
+ if( !ExIsResourceAcquiredExclusiveLite( pObjectInfo->VolumeCB->ObjectInfoTree.TreeLock))
{
- ASSERT( !ExIsResourceAcquiredLite( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock));
+ ASSERT( !ExIsResourceAcquiredLite( pObjectInfo->VolumeCB->ObjectInfoTree.TreeLock));
- AFSAcquireExcl( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock,
+ AFSAcquireExcl( pObjectInfo->VolumeCB->ObjectInfoTree.TreeLock,
TRUE);
bAcquiredTreeLock = TRUE;
}
+ if ( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
+ {
+
+ pParentObjectInfo = AFSFindObjectInfo( pObjectInfo->VolumeCB,
+ &pObjectInfo->ParentFileId);
+ }
+
//
// Remove it from the tree and list if it was inserted
//
- if( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
+ if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
{
- AFSRemoveHashEntry( &ObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
- &ObjectInfo->TreeEntry);
+ AFSRemoveHashEntry( &pObjectInfo->VolumeCB->ObjectInfoTree.TreeHead,
+ &pObjectInfo->TreeEntry);
}
- if( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_INSERTED_VOLUME_LIST))
+ if( BooleanFlagOn( pObjectInfo->Flags, AFS_OBJECT_INSERTED_VOLUME_LIST))
{
- if( ObjectInfo->ListEntry.fLink == NULL)
+ if( pObjectInfo->ListEntry.fLink == NULL)
{
- ObjectInfo->VolumeCB->ObjectInfoListTail = (AFSObjectInfoCB *)ObjectInfo->ListEntry.bLink;
+ pObjectInfo->VolumeCB->ObjectInfoListTail = (AFSObjectInfoCB *)pObjectInfo->ListEntry.bLink;
- if( ObjectInfo->VolumeCB->ObjectInfoListTail != NULL)
+ if( pObjectInfo->VolumeCB->ObjectInfoListTail != NULL)
{
- ObjectInfo->VolumeCB->ObjectInfoListTail->ListEntry.fLink = NULL;
+ pObjectInfo->VolumeCB->ObjectInfoListTail->ListEntry.fLink = NULL;
}
}
else
{
- ((AFSObjectInfoCB *)(ObjectInfo->ListEntry.fLink))->ListEntry.bLink = ObjectInfo->ListEntry.bLink;
+ ((AFSObjectInfoCB *)(pObjectInfo->ListEntry.fLink))->ListEntry.bLink = pObjectInfo->ListEntry.bLink;
}
- if( ObjectInfo->ListEntry.bLink == NULL)
+ if( pObjectInfo->ListEntry.bLink == NULL)
{
- ObjectInfo->VolumeCB->ObjectInfoListHead = (AFSObjectInfoCB *)ObjectInfo->ListEntry.fLink;
+ pObjectInfo->VolumeCB->ObjectInfoListHead = (AFSObjectInfoCB *)pObjectInfo->ListEntry.fLink;
- if( ObjectInfo->VolumeCB->ObjectInfoListHead != NULL)
+ if( pObjectInfo->VolumeCB->ObjectInfoListHead != NULL)
{
- ObjectInfo->VolumeCB->ObjectInfoListHead->ListEntry.bLink = NULL;
+ pObjectInfo->VolumeCB->ObjectInfoListHead->ListEntry.bLink = NULL;
}
}
else
{
- ((AFSObjectInfoCB *)(ObjectInfo->ListEntry.bLink))->ListEntry.fLink = ObjectInfo->ListEntry.fLink;
+ ((AFSObjectInfoCB *)(pObjectInfo->ListEntry.bLink))->ListEntry.fLink = pObjectInfo->ListEntry.fLink;
}
}
- if( ObjectInfo->ParentObjectInformation != NULL)
+ if( pParentObjectInfo != NULL)
{
- InterlockedDecrement( &ObjectInfo->ParentObjectInformation->ObjectReferenceCount);
+
+ ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_PARENT_FID);
+
+ lCount = AFSObjectInfoDecrement( pParentObjectInfo,
+ AFS_OBJECT_REFERENCE_CHILD);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSDeleteObjectInfo Decrement count on parent object %p Cnt %d\n",
+ pParentObjectInfo,
+ lCount);
+
+ AFSReleaseObjectInfo( &pParentObjectInfo);
}
if( bAcquiredTreeLock)
{
- AFSReleaseResource( ObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
+ AFSReleaseResource( pObjectInfo->VolumeCB->ObjectInfoTree.TreeLock);
}
+ if( bHeldInService)
+ {
+
+ FileId = pObjectInfo->FileId;
+ }
+
+ ExDeleteResourceLite( &pObjectInfo->NonPagedInfo->ObjectInfoLock);
+
+ ExDeleteResourceLite( &pObjectInfo->NonPagedInfo->DirectoryNodeHdrLock);
+
+ AFSExFreePoolWithTag( pObjectInfo->NonPagedInfo, AFS_NP_OBJECT_INFO_TAG);
+
+ AFSExFreePoolWithTag( pObjectInfo, AFS_OBJECT_INFO_TAG);
+
//
// Release the fid in the service
//
- if( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_HELD_IN_SERVICE))
+ if( bHeldInService)
{
- AFSReleaseFid( &ObjectInfo->FileId);
+ AFSReleaseFid( &FileId);
}
- ExDeleteResourceLite( &ObjectInfo->NonPagedInfo->DirectoryNodeHdrLock);
-
- AFSExFreePool( ObjectInfo->NonPagedInfo);
-
- AFSExFreePool( ObjectInfo);
-
return;
}
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDirEnumEntry *pDirEntry = NULL, *pLastDirEntry = NULL;
- UNICODE_STRING uniFullPathName;
+ AFSDirEnumEntry *pDirEntry = NULL;
+ UNICODE_STRING uniFullPathName = {0};
AFSNameArrayHdr *pNameArray = NULL;
AFSVolumeCB *pVolumeCB = NULL;
+ LONG VolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
+ AFSVolumeCB *pNewVolumeCB = NULL;
+ LONG NewVolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
AFSDirectoryCB *pDirectoryEntry = NULL, *pParentDirEntry = NULL;
+ AFSDirectoryCB *pNewParentDirEntry = NULL;
WCHAR *pwchBuffer = NULL;
UNICODE_STRING uniComponentName, uniRemainingPath, uniParsedName;
ULONG ulNameDifference = 0;
- GUID *pAuthGroup = NULL;
+ GUID stAuthGroup;
+ LONG lCount;
__Enter
{
+ ntStatus = AFSRetrieveValidAuthGroup( NULL,
+ DirectoryCB->ObjectInformation,
+ FALSE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
//
// Retrieve a target name for the entry
//
AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
- if( DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
- pAuthGroup,
+ &stAuthGroup,
FALSE,
&pDirEntry);
if( pDirEntry != NULL)
{
- ntStatus = STATUS_ACCESS_DENIED;
+ ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
}
try_return( ntStatus);
pVolumeCB = AFSGlobalRoot;
- AFSAcquireShared( pVolumeCB->VolumeLock,
- TRUE);
-
pParentDirEntry = AFSGlobalRoot->DirectoryCB;
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_EVAL_ROOT;
+
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ VolumeReferenceReason);
AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSEvaluateRootEntry Increment count on volume %08lX Cnt %d\n",
+ "AFSEvaluateRootEntry Increment count on volume %p Reason %u Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason,
+ lCount);
- InterlockedIncrement( &pParentDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
&pParentDirEntry->NameInformation.FileName,
pParentDirEntry,
NULL,
- pParentDirEntry->OpenReferenceCount);
+ lCount);
ntStatus = AFSLocateNameEntry( NULL,
NULL,
&uniParsedName,
pNameArray,
0,
- &pVolumeCB,
- &pParentDirEntry,
+ pVolumeCB,
+ pParentDirEntry,
+ &pNewVolumeCB,
+ &VolumeReferenceReason,
+ &pNewParentDirEntry,
&pDirectoryEntry,
NULL);
- if( !NT_SUCCESS( ntStatus))
+ if ( pNewVolumeCB != NULL)
{
-
//
- // The volume lock was released on failure above
- // Except for STATUS_OBJECT_NAME_NOT_FOUND
+ // AFSLocateNameEntry returns pNewVolumeCB with a reference held
+ // even if pVolumeCB == pNewVolumeCB. It is always safe to release
+ // the reference on pVolumeCB that was held prior to the call.
+ // If pVolumeCB == pNewVolumeCB, the reference from AFSLocateNameEntry
+ // will be released second.
//
- if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
- {
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ VolumeReferenceReason);
- if( pVolumeCB != NULL)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEvaluateRootEntry Decrement count on volume %p Reason %u Cnt %d\n",
+ pVolumeCB,
+ VolumeReferenceReason,
+ lCount);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ pVolumeCB = pNewVolumeCB;
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSEvaluateRootEntry Decrement count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ pNewVolumeCB = NULL;
- AFSReleaseResource( pVolumeCB->VolumeLock);
- }
+ VolumeReferenceReason = NewVolumeReferenceReason;
- if( pDirectoryEntry != NULL)
- {
+ NewVolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
+ }
- InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
+ //
+ // AFSLocateNameEntry does not alter the reference count of
+ // pParentDirectoryCB and it returns pNewParentDirectoryCB with
+ // a reference held.
+ //
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSEvaluateRootEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirectoryEntry->NameInformation.FileName,
- pDirectoryEntry,
- NULL,
- pDirectoryEntry->OpenReferenceCount);
- }
- else
- {
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEvaluateRootEntry DecrementX count on %wZ DE %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ lCount);
- InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
+ pParentDirEntry = pNewParentDirEntry;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSEvaluateRootEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pParentDirEntry->NameInformation.FileName,
- pParentDirEntry,
- NULL,
- pParentDirEntry->OpenReferenceCount);
- }
- }
+ pNewParentDirEntry = NULL;
+
+ if( !NT_SUCCESS( ntStatus) ||
+ ntStatus == STATUS_REPARSE)
+ {
pVolumeCB = NULL;
//
// Pass back the target dir entry for this request
+ // The caller must release the DirOpenReferenceCount
//
*TargetDirEntry = pDirectoryEntry;
+ pDirectoryEntry = NULL;
+
try_exit:
+ if( pDirectoryEntry != NULL)
+ {
+
+ lCount = InterlockedDecrement( &pDirectoryEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEvaluateRootEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirectoryEntry->NameInformation.FileName,
+ pDirectoryEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
+ }
+
+ if ( pParentDirEntry != NULL)
+ {
+
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEvaluateRootEntry Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
+ }
+
if( pDirEntry != NULL)
{
- AFSExFreePool( pDirEntry);
+ AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
}
if( pVolumeCB != NULL)
{
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ VolumeReferenceReason);
AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSEvaluateRootEntry2 Decrement count on volume %08lX Cnt %d\n",
+ "AFSEvaluateRootEntry Decrement2 count on volume %p Reason %u Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
-
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ VolumeReferenceReason,
+ lCount);
}
if( pNameArray != NULL)
// offset by the length of the server name
//
- AFSExFreePool( pwchBuffer);
-
if( uniFullPathName.Length > 0 &&
pwchBuffer != (WCHAR *)((char *)uniFullPathName.Buffer - ulNameDifference))
{
- AFSExFreePool( uniFullPathName.Buffer);
+ AFSExFreePoolWithTag( uniFullPathName.Buffer, 0);
}
+
+ AFSExFreePoolWithTag( pwchBuffer, 0);
}
}
!BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
{
- AFSAcquireExcl( &Fcb->NPFcb->Resource,
- TRUE);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupEntry Acquiring Fcb lock %p SHARED %08lX\n",
+ &Fcb->NPFcb->Resource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &Fcb->NPFcb->Resource,
+ TRUE);
if( Fcb->OpenReferenceCount > 0)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupEntry Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
__try
{
ntStatus = stIoStatus.Status;
}
- CcPurgeCacheSection( &Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- FALSE);
+ if ( Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
+ {
+
+ if ( !CcPurgeCacheSection( &Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCleanupFcb CcPurgeCacheSection [1] failure FID %08lX-%08lX-%08lX-%08lX\n",
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique);
+
+ SetFlag( Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
}
__except( EXCEPTION_EXECUTE_HANDLER)
{
+
ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSCleanupFcb Cc [1] FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique,
+ ntStatus);
+
+ SetFlag( Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupFcb Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &Fcb->NPFcb->SectionObjectResource);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupEntry Releasing Fcb lock %p SHARED %08lX\n",
+ &Fcb->NPFcb->Resource,
+ PsGetCurrentThread());
+
AFSReleaseResource( &Fcb->NPFcb->Resource);
//
// Now perform another flush on the file
//
- if( !NT_SUCCESS( AFSFlushExtents( Fcb)))
+ if( !NT_SUCCESS( AFSFlushExtents( Fcb,
+ NULL)))
{
- AFSReleaseExtentsWithFlush( Fcb);
+ AFSReleaseExtentsWithFlush( Fcb,
+ NULL,
+ TRUE);
}
}
BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
{
- AFSTearDownFcbExtents( Fcb);
+ AFSTearDownFcbExtents( Fcb,
+ NULL);
}
try_return( ntStatus);
// First up are there dirty extents in the cache to flush?
//
- if( ForceFlush ||
- ( !BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) &&
- !BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED) &&
- ( Fcb->Specific.File.ExtentsDirtyCount ||
+ if( BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
+ BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
+ {
+
+ //
+ // The file has been marked as invalid. Dump it
+ //
+
+ AFSTearDownFcbExtents( Fcb,
+ NULL);
+ }
+ else if( ForceFlush ||
+ ( ( Fcb->Specific.File.ExtentsDirtyCount ||
Fcb->Specific.File.ExtentCount) &&
(liTime.QuadPart - Fcb->Specific.File.LastServerFlush.QuadPart)
>= pControlDeviceExt->Specific.Control.FcbFlushTimeCount.QuadPart))
{
-
- if( !NT_SUCCESS( AFSFlushExtents( Fcb)) &&
+ if( !NT_SUCCESS( AFSFlushExtents( Fcb,
+ NULL)) &&
Fcb->OpenReferenceCount == 0)
{
- AFSReleaseExtentsWithFlush( Fcb);
+ AFSReleaseExtentsWithFlush( Fcb,
+ NULL,
+ TRUE);
}
}
- else if( BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
- BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
- {
-
- //
- // The file has been marked as invalid. Dump it
- //
-
- AFSTearDownFcbExtents( Fcb);
- }
//
// If there are extents and they haven't been used recently *and*
( 0 != Fcb->Specific.File.ExtentCount &&
0 != Fcb->Specific.File.LastExtentAccess.QuadPart &&
(liTime.QuadPart - Fcb->Specific.File.LastExtentAccess.QuadPart) >=
- (AFS_SERVER_PURGE_SLEEP * pControlDeviceExt->Specific.Control.FcbPurgeTimeCount.QuadPart))) &&
- AFSAcquireExcl( &Fcb->NPFcb->Resource,
- ForceFlush))
+ (AFS_SERVER_PURGE_SLEEP * pControlDeviceExt->Specific.Control.FcbPurgeTimeCount.QuadPart))))
{
- __try
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupFcb Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ if ( AFSAcquireExcl( &Fcb->NPFcb->SectionObjectResource, ForceFlush))
{
- CcFlushCache( &Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- &stIoStatus);
+ __try
+ {
+
+ CcFlushCache( &Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ &stIoStatus);
+
+ if( !NT_SUCCESS( stIoStatus.Status))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCleanupFcb CcFlushCache [2] failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique,
+ stIoStatus.Status,
+ stIoStatus.Information);
+
+ ntStatus = stIoStatus.Status;
+ }
+
+ if( ForceFlush &&
+ Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
+ {
+
+ if ( !CcPurgeCacheSection( &Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCleanupFcb CcPurgeCacheSection [2] failure FID %08lX-%08lX-%08lX-%08lX\n",
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique);
- if( !NT_SUCCESS( stIoStatus.Status))
+ SetFlag( Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSCleanupFcb CcFlushCache [2] failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSCleanupFcb Cc [2] FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
Fcb->ObjectInformation->FileId.Vnode,
Fcb->ObjectInformation->FileId.Unique,
- stIoStatus.Status,
- stIoStatus.Information);
-
- ntStatus = stIoStatus.Status;
+ ntStatus);
}
- if( ForceFlush)
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupFcb Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &Fcb->NPFcb->SectionObjectResource);
+
+ if( Fcb->OpenReferenceCount <= 0)
{
- CcPurgeCacheSection( &Fcb->NPFcb->SectionObjectPointers,
- NULL,
- 0,
- FALSE);
+ //
+ // Tear em down we'll not be needing them again
+ //
+
+ AFSTearDownFcbExtents( Fcb,
+ NULL);
}
}
- __except( EXCEPTION_EXECUTE_HANDLER)
- {
- ntStatus = GetExceptionCode();
- }
-
- AFSReleaseResource( &Fcb->NPFcb->Resource);
-
- if( Fcb->OpenReferenceCount == 0)
+ else
{
- //
- // Tear em down we'll not be needing them again
- //
-
- AFSTearDownFcbExtents( Fcb);
+ ntStatus = STATUS_RETRY;
}
}
if( BooleanFlagOn( DirectoryCB->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
{
- AFSExFreePool( DirectoryCB->NameInformation.FileName.Buffer);
+ AFSExFreePoolWithTag( DirectoryCB->NameInformation.FileName.Buffer, 0);
ClearFlag( DirectoryCB->Flags, AFS_DIR_RELEASE_NAME_BUFFER);
PIRP pIrp = NULL;
KEVENT kEvent;
PIO_STACK_LOCATION pIoStackLocation = NULL;
- AFSDeviceExt *pRdrDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
DEVICE_OBJECT *pTargetDeviceObject = NULL;
FILE_OBJECT *pCacheFileObject = NULL;
IN PVOID Context)
{
+ UNREFERENCED_PARAMETER(Irp);
+ UNREFERENCED_PARAMETER(DeviceObject);
KEVENT *pEvent = (KEVENT *)Context;
KeSetEvent( pEvent,
if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveNameEntry DE %p for %wZ has NOT_IN flag set\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName);
+
try_return( ntStatus);
}
// Remove the entry from the parent tree
//
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveNameEntry DE %p for %wZ removing from case sensitive tree\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName);
+
AFSRemoveCaseSensitiveDirEntry( &ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
DirEntry);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveNameEntry DE %p for %wZ removing from case insensitive tree\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName);
+
AFSRemoveCaseInsensitiveDirEntry( &ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
DirEntry);
- if( ParentObjectInfo->Specific.Directory.ShortNameTree &&
- DirEntry->Type.Data.ShortNameTreeEntry.HashIndex != 0)
+ if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME))
{
//
// From the short name tree
//
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveNameEntry DE %p for %wZ removing from shortname tree\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName);
+
AFSRemoveShortNameDirEntry( &ParentObjectInfo->Specific.Directory.ShortNameTree,
DirEntry);
+
+ ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveNameEntry DE %p for %wZ setting NOT_IN flag\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName);
+
SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
+ ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
+
try_exit:
NOTHING;
if( pTokenInfo != NULL)
{
- AFSExFreePool( pTokenInfo);
+ ExFreePool( pTokenInfo); // Allocated by SeQueryInformationToken
}
}
IN AFSCcb *Ccb)
{
+ UNREFERENCED_PARAMETER(Fcb);
if( Ccb->FileUnwindInfo.FileAttributes != (ULONG)-1)
{
Ccb->DirectoryCB->ObjectInformation->FileAttributes = Ccb->FileUnwindInfo.FileAttributes;
BOOLEAN bIsValid = TRUE;
ULONG ulCount = 0;
- AFSDirectoryCB *pCurrentDirEntry = NULL;
+ AFSDirectoryCB *pCurrentDirEntry = NULL, *pDirEntry = NULL;
pCurrentDirEntry = ObjectInfo->Specific.Directory.DirectoryNodeListHead;
if( !BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_FAKE))
{
ulCount++;
+
+ if( !BooleanFlagOn( pCurrentDirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
+ {
+
+ pDirEntry = NULL;
+
+ AFSLocateCaseSensitiveDirEntry( ObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
+ (ULONG)pCurrentDirEntry->CaseSensitiveTreeEntry.HashIndex,
+ &pDirEntry);
+
+ if( pDirEntry == NULL)
+ {
+ DbgBreakPoint();
+ }
+ }
}
pCurrentDirEntry = (AFSDirectoryCB *)pCurrentDirEntry->ListEntry.fLink;
}
- if( ulCount != ObjectInfo->Specific.Directory.DirectoryNodeCount)
+ if( ulCount != (ULONG) ObjectInfo->Specific.Directory.DirectoryNodeCount)
{
AFSPrint("AFSValidateDirList Count off Calc: %d Stored: %d\n",
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pControlDevExt = NULL;
ULONG ulTimeIncrement = 0;
+ LONG lCount;
__Enter
{
AFSServerName = LibraryInit->AFSServerName;
+ AFSMountRootName = LibraryInit->AFSMountRootName;
+
AFSDebugFlags = LibraryInit->AFSDebugFlags;
//
AFSExAllocatePoolWithTag = LibraryInit->AFSExAllocatePoolWithTag;
- AFSExFreePool = LibraryInit->AFSExFreePool;
+ AFSExFreePoolWithTag = LibraryInit->AFSExFreePoolWithTag;
AFSDumpTraceFilesFnc = LibraryInit->AFSDumpTraceFiles;
ulTimeIncrement = KeQueryTimeIncrement();
pControlDevExt->Specific.Control.ObjectLifeTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)AFS_OBJECT_LIFETIME / (ULONGLONG)ulTimeIncrement);
- pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart = AFS_ONE_SECOND;
- pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart *= AFS_SERVER_PURGE_DELAY;
+ pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart = AFS_SERVER_PURGE_DELAY;
pControlDevExt->Specific.Control.FcbPurgeTimeCount.QuadPart /= ulTimeIncrement;
- pControlDevExt->Specific.Control.FcbFlushTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)(AFS_ONE_SECOND * AFS_SERVER_FLUSH_DELAY) / (ULONGLONG)ulTimeIncrement);
+ pControlDevExt->Specific.Control.FcbFlushTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)AFS_SERVER_FLUSH_DELAY / (ULONGLONG)ulTimeIncrement);
pControlDevExt->Specific.Control.ExtentRequestTimeCount.QuadPart = (ULONGLONG)((ULONGLONG)AFS_EXTENT_REQUEST_TIME/(ULONGLONG)ulTimeIncrement);
//
ntStatus = AFSInitVolume( NULL,
&LibraryInit->GlobalRootFid,
+ AFS_VOLUME_REFERENCE_GLOBAL_ROOT,
&AFSGlobalRoot);
if( !NT_SUCCESS( ntStatus))
"AFSInitializeLibrary AFSInitRootFcb failure %08lX\n",
ntStatus);
+ lCount = AFSVolumeDecrement( AFSGlobalRoot,
+ AFS_VOLUME_REFERENCE_GLOBAL_ROOT);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitializeLibrary Decrement count on volume %p Cnt %d\n",
+ AFSGlobalRoot,
+ lCount);
+
AFSReleaseResource( AFSGlobalRoot->VolumeLock);
try_return( ntStatus);
SetFlag( AFSGlobalRoot->Flags, AFS_VOLUME_ACTIVE_GLOBAL_ROOT);
//
+ // Invalidate all known volumes since contact with the service and therefore
+ // the file server was lost.
+ //
+
+ AFSInvalidateAllVolumes();
+
+ //
// Drop the locks acquired above
//
AFSInitVolumeWorker( AFSGlobalRoot);
+ lCount = AFSVolumeDecrement( AFSGlobalRoot,
+ AFS_VOLUME_REFERENCE_GLOBAL_ROOT);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInitializeLibrary Decrement count on volume %p Cnt %d\n",
+ AFSGlobalRoot,
+ lCount);
+
AFSReleaseResource( AFSGlobalRoot->VolumeLock);
AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Fcb->Header.Resource);
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDirectoryCB *pDirNode = NULL, *pLastDirNode = NULL;
+ LONG lCount;
__Enter
{
if( AFSGlobalDotDirEntry != NULL)
{
- AFSDeleteObjectInfo( AFSGlobalDotDirEntry->ObjectInformation);
+ lCount = AFSObjectInfoDecrement( AFSGlobalDotDirEntry->ObjectInformation,
+ AFS_OBJECT_REFERENCE_GLOBAL);
+
+ AFSDeleteObjectInfo( &AFSGlobalDotDirEntry->ObjectInformation);
ExDeleteResourceLite( &AFSGlobalDotDirEntry->NonPaged->Lock);
if( AFSGlobalDotDotDirEntry != NULL)
{
- AFSDeleteObjectInfo( AFSGlobalDotDotDirEntry->ObjectInformation);
+ lCount = AFSObjectInfoDecrement( AFSGlobalDotDotDirEntry->ObjectInformation,
+ AFS_OBJECT_REFERENCE_GLOBAL);
+
+ AFSDeleteObjectInfo( &AFSGlobalDotDotDirEntry->ObjectInformation);
ExDeleteResourceLite( &AFSGlobalDotDotDirEntry->NonPaged->Lock);
pLastDirNode = (AFSDirectoryCB *)pDirNode->ListEntry.fLink;
- AFSDeleteObjectInfo( pDirNode->ObjectInformation);
+ lCount = AFSObjectInfoDecrement( pDirNode->ObjectInformation,
+ AFS_OBJECT_REFERENCE_GLOBAL);
+
+ AFSDeleteObjectInfo( &pDirNode->ObjectInformation);
ExDeleteResourceLite( &pDirNode->NonPaged->Lock);
...)
{
+ UNREFERENCED_PARAMETER(Subsystem);
+ UNREFERENCED_PARAMETER(Level);
NTSTATUS ntStatus = STATUS_SUCCESS;
va_list va_args;
char chDebugBuffer[ 256];
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSFcb *pFcb = NULL;
AFSVolumeCB *pVolumeCB = NULL;
+ LONG VolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
+ AFSVolumeCB *pNewVolumeCB = NULL;
+ LONG NewVolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
AFSObjectInfoCB *pObjectInfo = NULL;
ULONGLONG ullIndex = 0;
UNICODE_STRING uniFullPathName, uniRemainingPath, uniComponentName, uniParsedName;
AFSNameArrayHdr *pNameArray = NULL;
AFSDirectoryCB *pDirectoryEntry = NULL, *pParentDirEntry = NULL;
+ AFSDirectoryCB *pNewParentDirEntry = NULL;
+ LONG lCount;
__Enter
{
if( pVolumeCB != NULL)
{
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_GET_OBJECT;
+
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ VolumeReferenceReason);
AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Increment count on volume %08lX Cnt %d\n",
+ "AFSGetObjectStatus Increment count on volume %p Reason %u Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason,
+ lCount);
}
AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
pObjectInfo = &pVolumeCB->ObjectInformation;
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_STATUS);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Increment1 count on object %p Cnt %d\n",
+ pObjectInfo,
+ lCount);
}
else
{
AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
TRUE);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Decrement count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
-
ullIndex = AFSCreateLowIndex( &GetStatusInfo->FileID);
ntStatus = AFSLocateHashEntry( pVolumeCB->ObjectInfoTree.TreeHead,
// Reference the node so it won't be torn down
//
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_STATUS);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Increment count on object %08lX Cnt %d\n",
+ "AFSGetObjectStatus Increment2 count on object %p Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
}
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
pVolumeCB = AFSGlobalRoot;
- AFSAcquireShared( pVolumeCB->VolumeLock,
- TRUE);
-
pParentDirEntry = AFSGlobalRoot->DirectoryCB;
//
// Increment the ref count on the volume and dir entry for correct processing below
//
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_GET_OBJECT;
+
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ VolumeReferenceReason);
AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Increment count on volume %08lX Cnt %d\n",
+ "AFSGetObjectStatus Increment2 count on volume %p Reason %u Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ VolumeReferenceReason,
+ lCount);
- InterlockedIncrement( &pParentDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
&pParentDirEntry->NameInformation.FileName,
pParentDirEntry,
NULL,
- pParentDirEntry->OpenReferenceCount);
+ lCount);
ntStatus = AFSLocateNameEntry( NULL,
NULL,
&uniParsedName,
pNameArray,
AFS_LOCATE_FLAGS_NO_MP_TARGET_EVAL |
- AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL,
- &pVolumeCB,
- &pParentDirEntry,
+ AFS_LOCATE_FLAGS_NO_SL_TARGET_EVAL,
+ pVolumeCB,
+ pParentDirEntry,
+ &pNewVolumeCB,
+ &NewVolumeReferenceReason,
+ &pNewParentDirEntry,
&pDirectoryEntry,
NULL);
- if( !NT_SUCCESS( ntStatus))
+ if ( pNewVolumeCB != NULL)
{
//
- // The volume lock was released on failure above
- // Except for STATUS_OBJECT_NAME_NOT_FOUND
+ // AFSLocateNameEntry returns pNewVolumeCB with a reference held
+ // even if pVolumeCB == pNewVolumeCB. It is always safe to release
+ // the reference on pVolumeCB that was held prior to the call.
+ // If pVolumeCB == pNewVolumeCB, the reference from AFSLocateNameEntry
+ // will be released second.
//
- if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
- {
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ VolumeReferenceReason);
- if( pVolumeCB != NULL)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Decrement count on volume %p Reason %u Cnt %d\n",
+ pVolumeCB,
+ VolumeReferenceReason,
+ lCount);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ pVolumeCB = pNewVolumeCB;
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Decrement count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ pNewVolumeCB = NULL;
- AFSReleaseResource( pVolumeCB->VolumeLock);
- }
+ VolumeReferenceReason = NewVolumeReferenceReason;
- if( pDirectoryEntry != NULL)
- {
+ NewVolumeReferenceReason = AFS_VOLUME_REFERENCE_INVALID;
+ }
- InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
+ //
+ // AFSLocateNameEntry does not alter the reference count of
+ // pParentDirectoryCB and it returns pNewParentDirectoryCB with
+ // a reference held.
+ //
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirectoryEntry->NameInformation.FileName,
- pDirectoryEntry,
- NULL,
- pDirectoryEntry->OpenReferenceCount);
- }
- else
- {
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus DecrementX count on %wZ DE %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ lCount);
- InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
+ pParentDirEntry = pNewParentDirEntry;
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSGetObjectStatus Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pParentDirEntry->NameInformation.FileName,
- pParentDirEntry,
- NULL,
- pParentDirEntry->OpenReferenceCount);
- }
- }
+ pNewParentDirEntry = NULL;
+
+ if( !NT_SUCCESS( ntStatus) ||
+ ntStatus == STATUS_REPARSE)
+ {
pVolumeCB = NULL;
try_return( ntStatus);
}
- //
- // Remove the reference made above
- //
-
- InterlockedDecrement( &pDirectoryEntry->OpenReferenceCount);
-
pObjectInfo = pDirectoryEntry->ObjectInformation;
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
-
- if( pVolumeCB != NULL)
- {
-
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRetrieveFileAttributes Decrement2 count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_STATUS);
- AFSReleaseResource( pVolumeCB->VolumeLock);
- }
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Increment3 count on object %p Cnt %d\n",
+ pObjectInfo,
+ lCount);
}
//
try_exit:
- if( pObjectInfo != NULL)
+ if( pDirectoryEntry != NULL)
+ {
+
+ lCount = InterlockedDecrement( &pDirectoryEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirectoryEntry->NameInformation.FileName,
+ pDirectoryEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
+ }
+
+ if ( pParentDirEntry != NULL)
+ {
+
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
+ }
+
+ if( pObjectInfo != NULL)
+ {
+
+ lCount = AFSObjectInfoDecrement( pObjectInfo,
+ AFS_OBJECT_REFERENCE_STATUS);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Decrement count on object %p Cnt %d\n",
+ pObjectInfo,
+ lCount);
+ }
+
+ if( pVolumeCB != NULL)
{
- InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ VolumeReferenceReason);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSGetObjectStatus Decrement4 count on volume %p Reason %u Cnt %d\n",
+ pVolumeCB,
+ VolumeReferenceReason,
+ lCount);
}
if( pNameArray != NULL)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSDirectoryCB *pDirEntry = NULL;
ULONG ulCRC = 0;
+ LONG lCount;
__Enter
{
// a lookup in the short name tree
//
- if( RtlIsNameLegalDOS8Dot3( ComponentName,
+ if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ RtlIsNameLegalDOS8Dot3( ComponentName,
NULL,
NULL))
{
if( pDirEntry != NULL)
{
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCheckSymlinkAccess Increment count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry,
+ NULL,
+ lCount);
+
+ ASSERT( lCount >= 0);
}
AFSReleaseResource( ParentDirectoryCB->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSCheckSymlinkAccess Failed to locate entry %wZ\n",
- ComponentName);
+ "AFSCheckSymlinkAccess Failed to locate entry %wZ ntStatus %08X\n",
+ ComponentName,
+ STATUS_OBJECT_NAME_NOT_FOUND);
try_return( ntStatus = STATUS_OBJECT_NAME_NOT_FOUND);
}
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSCheckSymlinkAccess Failing symlink access to entry %wZ ACCESS_DENIED\n",
+ "AFSCheckSymlinkAccess Failing symlink access to entry %wZ REPARSE_POINT_NOT_RESOLVED\n",
ComponentName);
- ntStatus = STATUS_ACCESS_DENIED;
+ ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
+
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCheckSymlinkAccess Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry,
+ NULL,
+ lCount);
- InterlockedDecrement( &pDirEntry->OpenReferenceCount);
+ ASSERT( lCount >= 0);
try_exit:
SECURITY_DESCRIPTOR *pSecurityDescr = NULL;
ULONG ulSDLength = 0;
SECURITY_DESCRIPTOR *pRelativeSecurityDescr = NULL;
+ PSID pWorldSID = NULL;
+ ULONG *pulSubAuthority = NULL;
+ ULONG ulWorldSIDLEngth = 0;
__Enter
{
+ ulWorldSIDLEngth = RtlLengthRequiredSid( 1);
+
+ pWorldSID = (PSID)ExAllocatePoolWithTag( PagedPool,
+ ulWorldSIDLEngth,
+ AFS_GENERIC_MEMORY_29_TAG);
+
+ if( pWorldSID == NULL)
+ {
+ AFSPrint( "AFSCreateDefaultSecurityDescriptor unable to allocate World SID\n");
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ RtlZeroMemory( pWorldSID,
+ ulWorldSIDLEngth);
+
+ RtlInitializeSid( pWorldSID,
+ &SeWorldSidAuthority,
+ 1);
+
+ pulSubAuthority = RtlSubAuthoritySid(pWorldSID, 0);
+ *pulSubAuthority = SECURITY_WORLD_RID;
+
if( AFSRtlSetSaclSecurityDescriptor == NULL)
{
}
}
+ //
+ // Add in the group and owner to the SD
+ //
+
+ if( AFSRtlSetGroupSecurityDescriptor != NULL)
+ {
+ ntStatus = AFSRtlSetGroupSecurityDescriptor( pSecurityDescr,
+ pWorldSID,
+ FALSE);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlSetGroupSecurityDescriptor failed ntStatus %08lX\n",
+ ntStatus);
+
+ try_return( ntStatus);
+ }
+ }
+
+ ntStatus = RtlSetOwnerSecurityDescriptor( pSecurityDescr,
+ pWorldSID,
+ FALSE);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ AFSPrint( "AFSCreateDefaultSecurityDescriptor RtlSetOwnerSecurityDescriptor failed ntStatus %08lX\n",
+ ntStatus);
+
+ try_return( ntStatus);
+ }
+
if( !RtlValidSecurityDescriptor( pSecurityDescr))
{
{
ExFreePool( pACE);
}
+
+ if( pWorldSID != NULL)
+ {
+ ExFreePool( pWorldSID);
+ }
+ }
+
+ return ntStatus;
+}
+
+void
+AFSRetrieveParentPath( IN UNICODE_STRING *FullFileName,
+ OUT UNICODE_STRING *ParentPath)
+{
+
+ *ParentPath = *FullFileName;
+
+ //
+ // If the final character is a \, jump over it
+ //
+
+ if( ParentPath->Buffer[ (ParentPath->Length/sizeof( WCHAR)) - 1] == L'\\')
+ {
+ ParentPath->Length -= sizeof( WCHAR);
+ }
+
+ while( ParentPath->Buffer[ (ParentPath->Length/sizeof( WCHAR)) - 1] != L'\\')
+ {
+ ParentPath->Length -= sizeof( WCHAR);
+ }
+
+ //
+ // And the separator
+ //
+
+ ParentPath->Length -= sizeof( WCHAR);
+
+ return;
+}
+
+NTSTATUS
+AFSRetrieveValidAuthGroup( IN AFSFcb *Fcb,
+ IN AFSObjectInfoCB *ObjectInfo,
+ IN BOOLEAN WriteAccess,
+ OUT GUID *AuthGroup)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ GUID stAuthGroup, stZeroAuthGroup;
+ BOOLEAN bFoundAuthGroup = FALSE;
+ AFSCcb *pCcb = NULL;
+ AFSFcb *pFcb = Fcb;
+
+ __Enter
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ RtlZeroMemory( &stZeroAuthGroup,
+ sizeof( GUID));
+
+ if( Fcb == NULL)
+ {
+
+ if( ObjectInfo != NULL &&
+ ObjectInfo->Fcb != NULL)
+ {
+ pFcb = ObjectInfo->Fcb;
+ }
+ }
+
+ if( pFcb != NULL)
+ {
+
+ AFSAcquireShared( &Fcb->NPFcb->CcbListLock,
+ TRUE);
+
+ pCcb = Fcb->CcbListHead;
+
+ while( pCcb != NULL)
+ {
+
+ if( WriteAccess &&
+ pCcb->GrantedAccess & FILE_WRITE_DATA)
+ {
+ RtlCopyMemory( &stAuthGroup,
+ &pCcb->AuthGroup,
+ sizeof( GUID));
+
+ bFoundAuthGroup = TRUE;
+
+ break;
+ }
+ else if( pCcb->GrantedAccess & FILE_READ_DATA)
+ {
+ //
+ // At least get the read-only access
+ //
+
+ RtlCopyMemory( &stAuthGroup,
+ &pCcb->AuthGroup,
+ sizeof( GUID));
+
+ bFoundAuthGroup = TRUE;
+ }
+
+ pCcb = (AFSCcb *)pCcb->ListEntry.fLink;
+ }
+
+ AFSReleaseResource( &Fcb->NPFcb->CcbListLock);
+ }
+
+ if( !bFoundAuthGroup)
+ {
+
+ AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
+ (ULONGLONG)PsGetCurrentThreadId(),
+ &stAuthGroup);
+
+ if( RtlCompareMemory( &stZeroAuthGroup,
+ &stAuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
+ {
+
+ DbgPrint("AFSRetrieveValidAuthGroup Failed to locate PAG\n");
+
+ try_return( ntStatus = STATUS_ACCESS_DENIED);
+ }
+ }
+
+ RtlCopyMemory( AuthGroup,
+ &stAuthGroup,
+ sizeof( GUID));
+
+try_exit:
+
+ NOTHING;
+ }
+
+ return ntStatus;
+}
+
+NTSTATUS
+AFSPerformObjectInvalidate( IN AFSObjectInfoCB *ObjectInfo,
+ IN ULONG InvalidateReason)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ LIST_ENTRY *le;
+ AFSExtent *pEntry;
+ ULONG ulProcessCount = 0;
+ ULONG ulCount = 0;
+ LONG lCount;
+
+ __Enter
+ {
+
+ switch( InvalidateReason)
+ {
+
+ case AFS_INVALIDATE_DELETED:
+ {
+
+ if( ObjectInfo->FileType == AFS_FILE_TYPE_FILE &&
+ ObjectInfo->Fcb != NULL)
+ {
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
+ TRUE);
+
+ ObjectInfo->Links = 0;
+
+ ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_FILE_DELETED;
+
+ KeSetEvent( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
+ 0,
+ FALSE);
+
+ //
+ // Clear out the extents
+ // And get rid of them (note this involves waiting
+ // for any writes or reads to the cache to complete)
+ //
+
+ AFSTearDownFcbExtents( ObjectInfo->Fcb,
+ NULL);
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource);
+ }
+
+ break;
+ }
+
+ case AFS_INVALIDATE_DATA_VERSION:
+ {
+
+ LARGE_INTEGER liCurrentOffset = {0,0};
+ LARGE_INTEGER liFlushLength = {0,0};
+ ULONG ulFlushLength = 0;
+ BOOLEAN bLocked = FALSE;
+ BOOLEAN bExtentsLocked = FALSE;
+ BOOLEAN bCleanExtents = FALSE;
+
+ if( ObjectInfo->FileType == AFS_FILE_TYPE_FILE &&
+ ObjectInfo->Fcb != NULL)
+ {
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->Resource,
+ TRUE);
+
+ bLocked = TRUE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidate Acquiring Fcb extents lock %p SHARED %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
+ TRUE);
+
+ bExtentsLocked = TRUE;
+
+ //
+ // There are several possibilities here:
+ //
+ // 0. If there are no extents or all of the extents are dirty, do nothing.
+ //
+ // 1. There could be nothing dirty and an open reference count of zero
+ // in which case we can just tear down all of the extents without
+ // holding any resources.
+ //
+ // 2. There could be nothing dirty and a non-zero open reference count
+ // in which case we can issue a CcPurge against the entire file
+ // while holding just the Fcb Resource.
+ //
+ // 3. There can be dirty extents in which case we need to identify
+ // the non-dirty ranges and then perform a CcPurge on just the
+ // non-dirty ranges while holding just the Fcb Resource.
+ //
+
+ if ( ObjectInfo->Fcb->Specific.File.ExtentCount != ObjectInfo->Fcb->Specific.File.ExtentsDirtyCount)
+ {
+
+ if ( ObjectInfo->Fcb->Specific.File.ExtentsDirtyCount == 0)
+ {
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
+
+ bExtentsLocked = FALSE;
+
+ if ( ObjectInfo->Fcb->OpenReferenceCount == 0)
+ {
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
+
+ bLocked = FALSE;
+
+ AFSTearDownFcbExtents( ObjectInfo->Fcb,
+ NULL);
+ }
+ else
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
+
+ bLocked = FALSE;
+
+ __try
+ {
+
+ if( ObjectInfo->Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL &&
+ !CcPurgeCacheSection( &ObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSPerformObjectInvalidation CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique);
+
+ SetFlag( ObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ else
+ {
+
+ bCleanExtents = TRUE;
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
+ {
+
+ ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSPerformObjectInvalidation FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique,
+ ntStatus);
+
+ SetFlag( ObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->SectionObjectResource);
+ }
+ }
+ else
+ {
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
+
+ bExtentsLocked = FALSE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
+
+ bLocked = FALSE;
+
+ //
+ // Must build a list of non-dirty ranges from the beginning of the file
+ // to the end. There can be at most (Fcb->Specific.File.ExtentsDirtyCount + 1)
+ // ranges. In all but the most extreme random data write scenario there will
+ // be significantly fewer.
+ //
+ // For each range we need offset and size.
+ //
+
+ AFSByteRange * ByteRangeList = NULL;
+ ULONG ulByteRangeCount = 0;
+ ULONG ulIndex;
+ BOOLEAN bPurgeOnClose = FALSE;
+
+ __try
+ {
+
+ ulByteRangeCount = AFSConstructCleanByteRangeList( ObjectInfo->Fcb,
+ &ByteRangeList);
+
+ if ( ByteRangeList != NULL ||
+ ulByteRangeCount == 0)
+ {
+
+ for ( ulIndex = 0; ulIndex < ulByteRangeCount; ulIndex++)
+ {
+
+ ULONG ulSize;
+
+ do {
+
+ ulSize = ByteRangeList[ulIndex].Length.QuadPart > DWORD_MAX ? DWORD_MAX : ByteRangeList[ulIndex].Length.LowPart;
+
+ if( ObjectInfo->Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL &&
+ !CcPurgeCacheSection( &ObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ &ByteRangeList[ulIndex].FileOffset,
+ ulSize,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSPerformObjectInvalidation [1] CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique);
+
+ bPurgeOnClose = TRUE;
+ }
+ else
+ {
+
+ bCleanExtents = TRUE;
+ }
+
+ ByteRangeList[ulIndex].Length.QuadPart -= ulSize;
+
+ ByteRangeList[ulIndex].FileOffset.QuadPart += ulSize;
+
+ } while ( ByteRangeList[ulIndex].Length.QuadPart > 0);
+ }
+ }
+ else
+ {
+
+ //
+ // We couldn't allocate the memory to build the purge list
+ // so just walk the extent list while holding the ExtentsList Resource.
+ // This could deadlock but we do not have much choice.
+ //
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
+ TRUE);
+ bExtentsLocked = TRUE;
+
+ le = ObjectInfo->Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
+
+ ulProcessCount = 0;
+
+ ulCount = (ULONG)ObjectInfo->Fcb->Specific.File.ExtentCount;
+
+ if( ulCount > 0)
+ {
+ pEntry = ExtentFor( le, AFS_EXTENTS_LIST );
+
+ while( ulProcessCount < ulCount)
+ {
+ pEntry = ExtentFor( le, AFS_EXTENTS_LIST );
+
+ if( !BooleanFlagOn( pEntry->Flags, AFS_EXTENT_DIRTY))
+ {
+ if( !CcPurgeCacheSection( &ObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ &pEntry->FileOffset,
+ pEntry->Size,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSPerformObjectInvalidation [2] CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique);
+
+ bPurgeOnClose = TRUE;
+ }
+ else
+ {
+
+ bCleanExtents = TRUE;
+ }
+ }
+
+ if( liCurrentOffset.QuadPart < pEntry->FileOffset.QuadPart)
+ {
+
+ liFlushLength.QuadPart = pEntry->FileOffset.QuadPart - liCurrentOffset.QuadPart;
+
+ while( liFlushLength.QuadPart > 0)
+ {
+
+ if( liFlushLength.QuadPart > 512 * 1024000)
+ {
+ ulFlushLength = 512 * 1024000;
+ }
+ else
+ {
+ ulFlushLength = liFlushLength.LowPart;
+ }
+
+ if( !CcPurgeCacheSection( &ObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ &liCurrentOffset,
+ ulFlushLength,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSPerformObjectInvalidation [3] CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique);
+
+ bPurgeOnClose = TRUE;
+ }
+ else
+ {
+
+ bCleanExtents = TRUE;
+ }
+
+ liFlushLength.QuadPart -= ulFlushLength;
+ }
+ }
+
+ liCurrentOffset.QuadPart = pEntry->FileOffset.QuadPart + pEntry->Size;
+
+ ulProcessCount++;
+ le = le->Flink;
+ }
+ }
+ else
+ {
+ if( !CcPurgeCacheSection( &ObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSPerformObjectInvalidation [4] CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique);
+
+ bPurgeOnClose = TRUE;
+ }
+ else
+ {
+
+ bCleanExtents = TRUE;
+ }
+ }
+
+ if ( bPurgeOnClose)
+ {
+
+ SetFlag( ObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
+ {
+
+ ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSPerformObjectInvalidation FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique,
+ ntStatus);
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Releasing Fcb SectionObject lock %p EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->SectionObjectResource);
+ }
+ }
+
+ if ( bExtentsLocked)
+ {
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
+ }
+
+ if ( bLocked)
+ {
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
+ }
+
+ if ( bCleanExtents)
+ {
+
+ AFSReleaseCleanExtents( ObjectInfo->Fcb,
+ NULL);
+ }
+ }
+
+ break;
+ }
+ }
+
+ //
+ // Destroy the reference passed in by the caller to AFSInvalidateObject
+ // or AFSQueueInvalidateObject
+ //
+
+ lCount = AFSObjectInfoDecrement( ObjectInfo,
+ AFS_OBJECT_REFERENCE_INVALIDATION);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Decrement count on object %p Cnt %d\n",
+ ObjectInfo,
+ lCount);
}
return ntStatus;
git://git.openafs.org / openafs.git / blobdiff