/*
- * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
- * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Kernel Drivers, LLC.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Your File System, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
- * notice,
- * this list of conditions and the following disclaimer in the
- * documentation
- * and/or other materials provided with the distribution.
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
* - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
* nor the names of their contributors may be used to endorse or promote
* products derived from this software without specific prior written
ULONG ulRequestFlags = AFS_REQUEST_FLAG_SYNCHRONOUS;
ULONG ulCRC = 0;
UNICODE_STRING uniGUID;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
__Enter
{
+ ASSERT( ExIsResourceAcquiredExclusiveLite( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock));
+
+ if( BooleanFlagOn( ObjectInfoCB->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
+ {
+
+ try_return( ntStatus = STATUS_SUCCESS);
+ }
+
uniGUID.Length = 0;
uniGUID.MaximumLength = 0;
uniGUID.Buffer = NULL;
&uniGUID);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Enumerating FID %08lX-%08lX-%08lX-%08lX AuthGroup %wZ\n",
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
ObjectInfoCB->FileId.Unique,
- &uniGUID);
+ &uniGUID));
if( AuthGroup != NULL)
{
// Initialize the directory enumeration buffer for the directory
//
- pBuffer = AFSExAllocatePoolWithTag( PagedPool,
- AFS_DIR_ENUM_BUFFER_LEN,
- AFS_DIR_BUFFER_TAG);
+ pBuffer = AFSLibExAllocatePoolWithTag( PagedPool,
+ AFS_DIR_ENUM_BUFFER_LEN,
+ AFS_DIR_BUFFER_TAG);
if( pBuffer == NULL)
{
{
//
- // Go and retrieve the directory contents
+ // If the enumeration handle is -1 then we are done
//
- ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_DIR_ENUM,
- ulRequestFlags,
- AuthGroup,
- NULL,
- &ObjectInfoCB->FileId,
- (void *)pDirQueryCB,
- sizeof( AFSDirQueryCB),
- pBuffer,
- &ulResultLen);
+ if( ((ULONG)-1) == pDirQueryCB->EnumHandle )
+ {
+
+ ntStatus = STATUS_NO_MORE_ENTRIES;
+ }
+ else
+ {
+
+ //
+ // Go and retrieve the directory contents
+ //
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_DIR_ENUM,
+ ulRequestFlags,
+ AuthGroup,
+ NULL,
+ &ObjectInfoCB->FileId,
+ ObjectInfoCB->VolumeCB->VolumeInformation.Cell,
+ ObjectInfoCB->VolumeCB->VolumeInformation.CellLength,
+ (void *)pDirQueryCB,
+ sizeof( AFSDirQueryCB),
+ pBuffer,
+ &ulResultLen);
+ }
if( ntStatus != STATUS_SUCCESS ||
ulResultLen == 0)
{
ntStatus = STATUS_SUCCESS;
+
+ pDirEnumResponse = (AFSDirEnumResp *)pBuffer;
+
+ AFSAcquireExcl( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Directory Complete FID %08lX-%08lX-%08lX-%08lX Snapshot-DV %08lX:%08lX Current-DV %08lX:%08lX Status %08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ pDirEnumResponse->SnapshotDataVersion.HighPart,
+ pDirEnumResponse->SnapshotDataVersion.LowPart,
+ pDirEnumResponse->CurrentDataVersion.HighPart,
+ pDirEnumResponse->CurrentDataVersion.LowPart,
+ ntStatus));
+
+ ObjectInfoCB->DataVersion = pDirEnumResponse->SnapshotDataVersion;
+
+ if ( pDirEnumResponse->SnapshotDataVersion.QuadPart != pDirEnumResponse->CurrentDataVersion.QuadPart )
+ {
+
+ SetFlag( ObjectInfoCB->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ObjectInfoCB->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Force Verify due to DV change during enumeration FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique));
+ }
+
+ AFSReleaseResource( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock);
}
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSEnumerateDirectory Failed to enumerate directory Status %08lX\n",
- ntStatus);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Failed to enumerate directory FID %08lX-%08lX-%08lX-%08lX AuthGroup %wZ Status %08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ &uniGUID,
+ ntStatus));
}
break;
pCurrentDirEntry = (AFSDirEnumEntry *)pDirEnumResponse->Entry;
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Enumerating FID %08lX-%08lX-%08lX-%08lX Snapshot-DV %08lX:%08lX Current-DV %08lX:%08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ pDirEnumResponse->SnapshotDataVersion.HighPart,
+ pDirEnumResponse->SnapshotDataVersion.LowPart,
+ pDirEnumResponse->CurrentDataVersion.HighPart,
+ pDirEnumResponse->CurrentDataVersion.LowPart));
+
//
// Remove the leading header from the processed length
//
{
//
- // Duplicate entry, skip it
+ // Check that the FIDs are the same
//
- ulEntryLength = QuadAlign( sizeof( AFSDirEnumEntry) +
- uniDirName.Length +
- uniTargetName.Length);
+ if( AFSIsEqualFID( &pCurrentDirEntry->FileId,
+ &pDirNode->ObjectInformation->FileId))
+ {
+
+ //
+ // Duplicate entry, skip it
+ //
- pCurrentDirEntry = (AFSDirEnumEntry *)((char *)pCurrentDirEntry + ulEntryLength);
+ ulEntryLength = QuadAlign( sizeof( AFSDirEnumEntry) +
+ uniDirName.Length +
+ uniTargetName.Length);
- if( ulResultLen >= ulEntryLength)
- {
- ulResultLen -= ulEntryLength;
+ pCurrentDirEntry = (AFSDirEnumEntry *)((char *)pCurrentDirEntry + ulEntryLength);
+
+ if( ulResultLen >= ulEntryLength)
+ {
+ ulResultLen -= ulEntryLength;
+ }
+ else
+ {
+ ulResultLen = 0;
+ }
+
+ //
+ // Update the metadata for the entry
+ //
+
+ if( pDirNode->ObjectInformation->DataVersion.QuadPart != pCurrentDirEntry->DataVersion.QuadPart)
+ {
+
+ AFSUpdateMetaData( pDirNode,
+ pCurrentDirEntry);
+ }
+
+ continue;
}
else
{
- ulResultLen = 0;
- }
- continue;
+ //
+ // Need to tear down this entry and rebuild it below
+ //
+
+ if( pDirNode->DirOpenReferenceCount <= 0 &&
+ pDirNode->NameArrayReferenceCount <= 0)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ &pDirNode->NameInformation.FileName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pCurrentDirEntry->FileId.Cell,
+ pCurrentDirEntry->FileId.Volume,
+ pCurrentDirEntry->FileId.Vnode,
+ pCurrentDirEntry->FileId.Unique));
+
+ AFSDeleteDirEntry( ObjectInfoCB,
+ &pDirNode);
+ }
+ else
+ {
+
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_DELETED);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ &pDirNode->NameInformation.FileName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pCurrentDirEntry->FileId.Cell,
+ pCurrentDirEntry->FileId.Volume,
+ pCurrentDirEntry->FileId.Vnode,
+ pCurrentDirEntry->FileId.Unique));
+
+ AFSRemoveNameEntry( ObjectInfoCB,
+ pDirNode);
+ }
+
+ pDirNode = NULL;
+ }
}
pDirNode = AFSInitDirEntry( ObjectInfoCB,
break;
}
+ AFSUpdateMetaData( pDirNode,
+ pCurrentDirEntry);
+
+ if( pDirNode->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSEnumerateDirectory Setting VERIFY on entry %wZ for FID %08lX-%08lX-%08lX-%08lX\n",
+ &uniDirName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique));
+
+ AFSAcquireExcl( pDirNode->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ SetFlag( pDirNode->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pDirNode->ObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ AFSReleaseResource( pDirNode->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
+
//
// Set up the entry length
//
ulEntryLength = QuadAlign( sizeof( AFSDirEnumEntry) +
- pCurrentDirEntry->FileNameLength +
- pCurrentDirEntry->TargetNameLength);
+ pCurrentDirEntry->FileNameLength +
+ pCurrentDirEntry->TargetNameLength);
//
// Init the short name if we have one
//
- if( pCurrentDirEntry->ShortNameLength > 0)
+ if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ pCurrentDirEntry->ShortNameLength > 0)
{
UNICODE_STRING uniShortName;
pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Initialized short name %wZ for DE %p for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&uniShortName,
pCurrentDirEntry->FileId.Cell,
pCurrentDirEntry->FileId.Volume,
pCurrentDirEntry->FileId.Vnode,
- pCurrentDirEntry->FileId.Unique);
+ pCurrentDirEntry->FileId.Unique));
}
else
{
(12 * sizeof( WCHAR)));
}
}
+ else
+ {
+
+ //
+ // No short name or short names are disabled
+ //
+
+ pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = 0;
+ }
//
// Insert the node into the name tree
//
- ASSERT( ExIsResourceAcquiredExclusiveLite( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock));
-
if( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead == NULL)
{
ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = pDirNode;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Insert DE %p to head of case sensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Insert DE %p to case sensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
if( !NT_SUCCESS( AFSInsertCaseSensitiveDirEntry( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
pDirNode)))
//
AFSDeleteDirEntry( ObjectInfoCB,
- pDirNode);
+ &pDirNode);
pCurrentDirEntry = (AFSDirEnumEntry *)((char *)pCurrentDirEntry + ulEntryLength);
if( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Insert DE %p to head of case insensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead = pDirNode;
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Insert DE %p to case insensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
AFSInsertCaseInsensitiveDirEntry( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
pDirNode);
InterlockedIncrement( &ObjectInfoCB->Specific.Directory.DirectoryNodeCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIR_NODE_COUNT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
&pDirNode->NameInformation.FileName,
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
- ObjectInfoCB->FileId.Unique);
+ ObjectInfoCB->FileId.Unique));
if( pDirNode->Type.Data.ShortNameTreeEntry.HashIndex != 0)
{
if( ObjectInfoCB->Specific.Directory.ShortNameTree == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Insert DE %p to head of shortname tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
ObjectInfoCB->Specific.Directory.ShortNameTree = pDirNode;
{
SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory Insert DE %p to shortname tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
}
}
pDirQueryCB->EnumHandle = pDirEnumResponse->EnumHandle;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSEnumerateDirectory EnumHandle %08lX\n",
- pDirQueryCB->EnumHandle);
-
- //
- // If the enumeration handle is -1 then we are done
- //
-
- if( ((ULONG)-1) == pDirQueryCB->EnumHandle )
- {
-
- break;
- }
+ pDirQueryCB->EnumHandle));
}
try_exit:
if( pBuffer != NULL)
{
- AFSExFreePool( pBuffer);
+ AFSExFreePoolWithTag( pBuffer, AFS_DIR_BUFFER_TAG);
}
- //
- // If the processing failed then we should reset the directory content in the event
- // it is re-enumerated
- //
+ if ( NT_SUCCESS( ntStatus))
+ {
- if( !NT_SUCCESS( ntStatus))
+ SetFlag( ObjectInfoCB->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
+ }
+ else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ //
+ // If the processing failed then we should reset the directory
+ // content in the event it is re-enumerated
+ //
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSEnumerateDirectory Resetting content for FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
ObjectInfoCB->FileId.Unique,
- ntStatus);
+ ntStatus));
AFSResetDirectoryContent( ObjectInfoCB);
}
AuthGroup,
NULL,
FileId,
+ NULL,
+ 0,
(void *)&stDirQueryCB,
sizeof( AFSDirQueryCB),
NULL,
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSEnumerateDirectoryNoResponse Failed to enumerate directory Status %08lX\n",
- ntStatus);
+ ntStatus));
}
}
}
AFSObjectInfoCB *pObjectInfo = NULL;
ULONGLONG ullIndex = 0;
UNICODE_STRING uniGUID;
+ LONG lCount;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
__Enter
{
+ ASSERT( ExIsResourceAcquiredExclusiveLite( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock));
+
uniGUID.Length = 0;
uniGUID.MaximumLength = 0;
uniGUID.Buffer = NULL;
&uniGUID);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Verifying content for FID %08lX-%08lX-%08lX-%08lX AuthGroup %wZ\n",
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
ObjectInfoCB->FileId.Unique,
- &uniGUID);
+ &uniGUID));
if( AuthGroup != NULL)
{
// Initialize the directory enumeration buffer for the directory
//
- pBuffer = AFSExAllocatePoolWithTag( PagedPool,
- AFS_DIR_ENUM_BUFFER_LEN,
- AFS_DIR_BUFFER_TAG);
+ pBuffer = AFSLibExAllocatePoolWithTag( PagedPool,
+ AFS_DIR_ENUM_BUFFER_LEN,
+ AFS_DIR_BUFFER_TAG);
if( pBuffer == NULL)
{
{
//
- // Go and retrieve the directory contents
+ // If the enumeration handle is -1 then we are done
//
- ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_DIR_ENUM,
- ulRequestFlags,
- AuthGroup,
- NULL,
- &ObjectInfoCB->FileId,
- (void *)pDirQueryCB,
- sizeof( AFSDirQueryCB),
- pBuffer,
- &ulResultLen);
+ if( ((ULONG)-1) == pDirQueryCB->EnumHandle )
+ {
+
+ ntStatus = STATUS_NO_MORE_ENTRIES;
+ }
+ else
+ {
+
+ //
+ // Go and retrieve the directory contents
+ //
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_DIR_ENUM,
+ ulRequestFlags,
+ AuthGroup,
+ NULL,
+ &ObjectInfoCB->FileId,
+ ObjectInfoCB->VolumeCB->VolumeInformation.Cell,
+ ObjectInfoCB->VolumeCB->VolumeInformation.CellLength,
+ (void *)pDirQueryCB,
+ sizeof( AFSDirQueryCB),
+ pBuffer,
+ &ulResultLen);
+ }
if( ntStatus != STATUS_SUCCESS ||
ulResultLen == 0)
ntStatus == STATUS_NO_MORE_ENTRIES)
{
+ pDirEnumResponse = (AFSDirEnumResp *)pBuffer;
+
+ AFSAcquireExcl( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent Directory Complete FID %08lX-%08lX-%08lX-%08lX Snapshot-DV %08lX:%08lX Current-DV %08lX:%08lX Status %08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ pDirEnumResponse->SnapshotDataVersion.HighPart,
+ pDirEnumResponse->SnapshotDataVersion.LowPart,
+ pDirEnumResponse->CurrentDataVersion.HighPart,
+ pDirEnumResponse->CurrentDataVersion.LowPart,
+ ntStatus));
+
ntStatus = STATUS_SUCCESS;
+
+ if ( pDirEnumResponse->SnapshotDataVersion.QuadPart != pDirEnumResponse->CurrentDataVersion.QuadPart )
+ {
+
+ SetFlag( ObjectInfoCB->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ObjectInfoCB->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent Force Verify due to DV change during enumeration FID %08lX-%08lX-%08lX-%08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique));
+ }
+ else
+ {
+
+ ObjectInfoCB->DataVersion = pDirEnumResponse->SnapshotDataVersion;
+ }
+
+ AFSReleaseResource( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock);
}
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSVerifyDirectoryContent Failed to enumerate directory Status %08lX\n",
- ntStatus);
+ "AFSVerifyDirectoryContent Failed to enumerate directory FID %08lX-%08lX-%08lX-%08lX AuthGroup %wZ Status %08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ &uniGUID,
+ ntStatus));
}
break;
pCurrentDirEntry = (AFSDirEnumEntry *)pDirEnumResponse->Entry;
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent EnumResponse FID %08lX-%08lX-%08lX-%08lX Snapshot-DV %08lX:%08lX Current-DV %08lX:%08lX\n",
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ pDirEnumResponse->SnapshotDataVersion.HighPart,
+ pDirEnumResponse->SnapshotDataVersion.LowPart,
+ pDirEnumResponse->CurrentDataVersion.HighPart,
+ pDirEnumResponse->CurrentDataVersion.LowPart));
+
//
// Remove the leading header from the processed length
//
ulCRC = AFSGenerateCRC( &uniDirName,
FALSE);
- ASSERT( ExIsResourceAcquiredExclusiveLite( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.TreeLock));
-
AFSLocateCaseSensitiveDirEntry( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
ulCRC,
&pDirNode);
pCurrentDirEntry->FileNameLength +
pCurrentDirEntry->TargetNameLength);
- if( pDirNode != NULL)
+ if( pDirNode &&
+ AFSIsEqualFID( &pCurrentDirEntry->FileId,
+ &pDirNode->ObjectInformation->FileId))
{
//
- // Check that the FIDs are the same
+ // Found matching directory entry by name and FileID
//
- if( AFSIsEqualFID( &pCurrentDirEntry->FileId,
- &pDirNode->ObjectInformation->FileId))
- {
+ AFSAcquireShared( ObjectInfoCB->VolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+
+ ullIndex = AFSCreateLowIndex( &pCurrentDirEntry->FileId);
- AFSAcquireShared( ObjectInfoCB->VolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
+ ntStatus = AFSLocateHashEntry( ObjectInfoCB->VolumeCB->ObjectInfoTree.TreeHead,
+ ullIndex,
+ (AFSBTreeEntry **)&pObjectInfo);
- ullIndex = AFSCreateLowIndex( &pCurrentDirEntry->FileId);
+ AFSReleaseResource( ObjectInfoCB->VolumeCB->ObjectInfoTree.TreeLock);
+
+ if( NT_SUCCESS( ntStatus) &&
+ pObjectInfo != NULL)
+ {
+
+ //
+ // Indicate this is a valid entry
+ //
- ntStatus = AFSLocateHashEntry( ObjectInfoCB->VolumeCB->ObjectInfoTree.TreeHead,
- ullIndex,
- (AFSBTreeEntry **)&pObjectInfo);
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID);
- AFSReleaseResource( ObjectInfoCB->VolumeCB->ObjectInfoTree.TreeLock);
+ KeQueryTickCount( &ObjectInfoCB->LastAccessCount);
- if( NT_SUCCESS( ntStatus) &&
- pObjectInfo != NULL)
+ if( pCurrentDirEntry->ShortNameLength > 0 &&
+ pDirNode->NameInformation.ShortNameLength > 0)
+ {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) parent FID %08lX-%08lX-%08lX-%08lX old short name %S New short name %S\n",
+ &uniDirName,
+ &pDirNode->NameInformation.FileName,
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ pDirNode->NameInformation.ShortName,
+ pCurrentDirEntry->ShortName));
+ }
+ else if( pCurrentDirEntry->ShortNameLength == 0 &&
+ pDirNode->NameInformation.ShortNameLength > 0)
{
- //
- // Indicate this is a valid entry
- //
-
- SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID);
-
- if( pCurrentDirEntry->ShortNameLength > 0 &&
- pDirNode->NameInformation.ShortNameLength > 0)
- {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) old short name %S New short name %S\n",
- &uniDirName,
- &pDirNode->NameInformation.FileName,
- pDirNode->NameInformation.ShortName,
- pCurrentDirEntry->ShortName);
- }
- else if( pCurrentDirEntry->ShortNameLength == 0 &&
- pDirNode->NameInformation.ShortNameLength > 0)
- {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) old short name %S New short name NULL\n",
- &uniDirName,
- &pDirNode->NameInformation.FileName,
- pDirNode->NameInformation.ShortName);
- }
- else if( pCurrentDirEntry->ShortNameLength > 0 &&
- pDirNode->NameInformation.ShortNameLength == 0)
- {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) old short name NULL New short name %S\n",
- &uniDirName,
- &pDirNode->NameInformation.FileName,
- pCurrentDirEntry->ShortName);
- }
- else
- {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) old short name NULL New short name NULL\n",
- &uniDirName,
- &pDirNode->NameInformation.FileName);
- }
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent Verified entry %wZ for parent FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) parent FID %08lX-%08lX-%08lX-%08lX old short name %S New short name NULL\n",
&uniDirName,
+ &pDirNode->NameInformation.FileName,
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
- ObjectInfoCB->FileId.Unique);
-
-
- //
- // Update the metadata for the entry
- //
-
- if( pObjectInfo->DataVersion.QuadPart == 0 ||
- pObjectInfo->DataVersion.QuadPart != pCurrentDirEntry->DataVersion.QuadPart)
- {
-
- AFSUpdateMetaData( pDirNode,
- pCurrentDirEntry);
-
- if( pObjectInfo->FileType == AFS_FILE_TYPE_DIRECTORY)
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent Setting VERIFY on entry %wZ for FID %08lX-%08lX-%08lX-%08lX\n",
- &uniDirName,
- pObjectInfo->FileId.Cell,
- pObjectInfo->FileId.Volume,
- pObjectInfo->FileId.Vnode,
- pObjectInfo->FileId.Unique);
-
- SetFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
- pObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
- pObjectInfo->Expiration.QuadPart = 0;
- }
- }
-
- //
- // Next dir entry
- //
-
- pCurrentDirEntry = (AFSDirEnumEntry *)((char *)pCurrentDirEntry + ulEntryLength);
-
- if( ulResultLen >= ulEntryLength)
- {
- ulResultLen -= ulEntryLength;
- }
- else
- {
- ulResultLen = 0;
- }
-
- continue;
+ ObjectInfoCB->FileId.Unique,
+ pDirNode->NameInformation.ShortName));
}
+ else if( pCurrentDirEntry->ShortNameLength > 0 &&
+ pDirNode->NameInformation.ShortNameLength == 0)
+ {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) parent FID %08lX-%08lX-%08lX-%08lX old short name NULL New short name %S\n",
+ &uniDirName,
+ &pDirNode->NameInformation.FileName,
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique,
+ pCurrentDirEntry->ShortName));
+ }
+ else
+ {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent Verified entry %wZ (%wZ) parent FID %08lX-%08lX-%08lX-%08lX old short name NULL New short name NULL\n",
+ &uniDirName,
+ &pDirNode->NameInformation.FileName,
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique));
+ }
+
+ //
+ // Update the metadata for the entry
+ //
+
+ if( pObjectInfo->DataVersion.QuadPart != pCurrentDirEntry->DataVersion.QuadPart)
+ {
+
+ AFSUpdateMetaData( pDirNode,
+ pCurrentDirEntry);
+ }
+
+ //
+ // Next dir entry
+ //
+
+ pCurrentDirEntry = (AFSDirEnumEntry *)((char *)pCurrentDirEntry + ulEntryLength);
+
+ if( ulResultLen >= ulEntryLength)
+ {
+ ulResultLen -= ulEntryLength;
+ }
+ else
+ {
+ ulResultLen = 0;
+ }
+
+ continue;
}
+ }
+ else if ( pDirNode)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ //
+ // File name matches but FileID does not.
+ //
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Processing dir entry %p %wZ with different FID, same name in parent FID %08lX-%08lX-%08lX-%08lX\n",
pDirNode,
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
- ObjectInfoCB->FileId.Unique);
+ ObjectInfoCB->FileId.Unique));
//
// Need to tear down this entry and rebuild it below
//
- if( pDirNode->OpenReferenceCount == 0)
+ if( pDirNode->DirOpenReferenceCount <= 0 &&
+ pDirNode->NameArrayReferenceCount <= 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
pDirNode,
pCurrentDirEntry->FileId.Cell,
pCurrentDirEntry->FileId.Volume,
pCurrentDirEntry->FileId.Vnode,
- pCurrentDirEntry->FileId.Unique);
+ pCurrentDirEntry->FileId.Unique));
AFSDeleteDirEntry( ObjectInfoCB,
- pDirNode);
+ &pDirNode);
}
else
{
SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_DELETED);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
"AFSVerifyDirectoryContent Different FIDs - removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
pDirNode,
&pDirNode->NameInformation.FileName,
pCurrentDirEntry->FileId.Cell,
pCurrentDirEntry->FileId.Volume,
pCurrentDirEntry->FileId.Vnode,
- pCurrentDirEntry->FileId.Unique);
+ pCurrentDirEntry->FileId.Unique));
AFSRemoveNameEntry( ObjectInfoCB,
pDirNode);
}
}
+ else
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent New entry %wZ for parent FID %08lX-%08lX-%08lX-%08lX\n",
+ &uniDirName,
+ ObjectInfoCB->FileId.Cell,
+ ObjectInfoCB->FileId.Volume,
+ ObjectInfoCB->FileId.Vnode,
+ ObjectInfoCB->FileId.Unique));
+ }
pDirNode = AFSInitDirEntry( ObjectInfoCB,
&uniDirName,
break;
}
+ AFSUpdateMetaData( pDirNode,
+ pCurrentDirEntry);
+
+ if( pDirNode->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyDirectoryContent Setting VERIFY on entry %wZ for FID %08lX-%08lX-%08lX-%08lX\n",
+ &uniDirName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique));
+
+ AFSAcquireExcl( pDirNode->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ SetFlag( pDirNode->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pDirNode->ObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ AFSReleaseResource( pDirNode->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
+
//
// Init the short name if we have one
//
- if( pCurrentDirEntry->ShortNameLength > 0)
+ if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ pCurrentDirEntry->ShortNameLength > 0)
{
UNICODE_STRING uniShortName;
pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Initialized short name %wZ for DE %p for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&uniShortName,
pCurrentDirEntry->FileId.Cell,
pCurrentDirEntry->FileId.Volume,
pCurrentDirEntry->FileId.Vnode,
- pCurrentDirEntry->FileId.Unique);
+ pCurrentDirEntry->FileId.Unique));
}
else
{
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSVerifyDirectoryContent NO short name for DE %p for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
- pDirNode,
- &pDirNode->NameInformation.FileName,
- pCurrentDirEntry->FileId.Cell,
- pCurrentDirEntry->FileId.Volume,
- pCurrentDirEntry->FileId.Vnode,
- pCurrentDirEntry->FileId.Unique);
+ //
+ // No short name or short names have been disabled
+ //
+
+ pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = 0;
}
//
ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = pDirNode;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Insert DE %p to head of case sensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
else
{
if( !NT_SUCCESS( AFSInsertCaseSensitiveDirEntry( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
pDirNode)))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Failed to insert DE %p to case sensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
//
// Delete this dir entry and continue on
//
AFSDeleteDirEntry( ObjectInfoCB,
- pDirNode);
+ &pDirNode);
pCurrentDirEntry = (AFSDirEnumEntry *)((char *)pCurrentDirEntry + ulEntryLength);
}
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Insert DE %p to case sensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
}
SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Insert DE %p to head of case insensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
else
{
AFSInsertCaseInsensitiveDirEntry( ObjectInfoCB->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
pDirNode);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Insert DE %p to case insensitive tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
if( ObjectInfoCB->Specific.Directory.DirectoryNodeListHead == NULL)
InterlockedIncrement( &ObjectInfoCB->Specific.Directory.DirectoryNodeCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIR_NODE_COUNT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
&pDirNode->NameInformation.FileName,
ObjectInfoCB->FileId.Cell,
ObjectInfoCB->FileId.Volume,
ObjectInfoCB->FileId.Vnode,
- ObjectInfoCB->FileId.Unique);
+ ObjectInfoCB->FileId.Unique));
if( pDirNode->Type.Data.ShortNameTreeEntry.HashIndex != 0)
{
ObjectInfoCB->Specific.Directory.ShortNameTree = pDirNode;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Insert DE %p to head of shortname tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
}
if( !NT_SUCCESS( AFSInsertShortNameDirEntry( ObjectInfoCB->Specific.Directory.ShortNameTree,
pDirNode)))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Failed to insert DE %p (%08lX) to shortname tree for %wZ\n",
pDirNode,
pDirNode->Type.Data.ShortNameTreeEntry.HashIndex,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
else
{
SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSVerifyDirectoryContent Insert DE %p to shortname tree for %wZ\n",
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
}
}
}
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_VALID);
+
//
// Next dir entry
//
//
pDirQueryCB->EnumHandle = pDirEnumResponse->EnumHandle;
-
- //
- // If the enumeration handle is -1 then we are done
- //
-
- if( ((ULONG)-1) == pDirQueryCB->EnumHandle )
- {
-
- break;
- }
}
try_exit:
if( pBuffer != NULL)
{
- AFSExFreePool( pBuffer);
+ AFSExFreePoolWithTag( pBuffer, AFS_DIR_BUFFER_TAG);
}
}
UNICODE_STRING uniTargetName;
AFSDirectoryCB *pDirNode = NULL;
ULONG ulCRC = 0;
+ LONG lCount;
LARGE_INTEGER liOldDataVersion;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ BOOLEAN bReleaseParentTreeLock = FALSE;
__Enter
{
+ *DirNode = NULL;
+
//
// Init the control block for the request
//
// Allocate our return buffer
//
- pResultCB = (AFSFileCreateResultCB *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_GENERIC_MEMORY_1_TAG);
+ pResultCB = (AFSFileCreateResultCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_GENERIC_MEMORY_1_TAG);
if( pResultCB == NULL)
{
AuthGroup,
FileName,
NULL,
+ NULL,
+ 0,
&stCreateCB,
sizeof( AFSFileCreateCB),
pResultCB,
// The check is to ensure the DV has been modified
//
- if( liOldDataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart - 1 ||
- liOldDataVersion.QuadPart != ParentObjectInfo->DataVersion.QuadPart)
+ AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ bReleaseParentTreeLock = TRUE;
+
+ if( ParentObjectInfo->DataVersion.QuadPart != pResultCB->ParentDataVersion.QuadPart - 1)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSNotifyFileCreate Raced with an invalidate call and a re-enumeration for entry %wZ\n",
- FileName);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSNotifyFileCreate Raced with an invalidate call and a re-enumeration for entry %wZ ParentFID %08lX-%08lX-%08lX-%08lX Version (%08lX:%08lX != %08lX:%08lX - 1)\n",
+ FileName,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique,
+ ParentObjectInfo->DataVersion.HighPart,
+ ParentObjectInfo->DataVersion.LowPart,
+ pResultCB->ParentDataVersion.HighPart,
+ pResultCB->ParentDataVersion.LowPart));
//
// We raced so go and lookup the directory entry in the parent
ulCRC = AFSGenerateCRC( FileName,
FALSE);
- AFSAcquireShared( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
- TRUE);
-
AFSLocateCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
ulCRC,
&pDirNode);
if( pDirNode != NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSNotifyFileCreate Located dir entry for file %wZ\n",
- FileName);
+ "AFSNotifyFileCreate Located dir entry %p for file %wZ\n",
+ pDirNode,
+ FileName));
- InterlockedIncrement( &pDirNode->OpenReferenceCount);
+ if ( AFSIsEqualFID( &pDirNode->ObjectInformation->FileId,
+ &pResultCB->DirEnum.FileId))
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSNotifyFileCreate Increment count on %wZ DE %p Cnt %d\n",
- &pDirNode->NameInformation.FileName,
- pDirNode,
- pDirNode->OpenReferenceCount);
+ *DirNode = pDirNode;
- *DirNode = pDirNode;
+ try_return( ntStatus = STATUS_REPARSE);
+ }
+ else
+ {
- AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ //
+ // We found an entry that matches the desired name but it is not the
+ // same as the one that was created for us by the file server.
+ //
- try_return( ntStatus = STATUS_REPARSE);
- }
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNotifyFileCreate Found matching name entry %wZ DE %p FID %08lX-%08lX-%08lX-%08lX != FID %08lX-%08lX-%08lX-%08lX\n",
+ FileName,
+ pDirNode,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pResultCB->DirEnum.FileId.Cell,
+ pResultCB->DirEnum.FileId.Volume,
+ pResultCB->DirEnum.FileId.Vnode,
+ pResultCB->DirEnum.FileId.Unique));
+
+ if( pDirNode->DirOpenReferenceCount <= 0 &&
+ pDirNode->NameArrayReferenceCount <= 0)
+ {
- AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyFileCreate Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ &pDirNode->NameInformation.FileName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pResultCB->DirEnum.FileId.Cell,
+ pResultCB->DirEnum.FileId.Volume,
+ pResultCB->DirEnum.FileId.Vnode,
+ pResultCB->DirEnum.FileId.Unique));
+
+ AFSDeleteDirEntry( ParentObjectInfo,
+ &pDirNode);
+ }
+ else
+ {
+
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_DELETED);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyFileCreate Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ &pDirNode->NameInformation.FileName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pResultCB->DirEnum.FileId.Cell,
+ pResultCB->DirEnum.FileId.Volume,
+ pResultCB->DirEnum.FileId.Vnode,
+ pResultCB->DirEnum.FileId.Unique));
+
+ AFSRemoveNameEntry( ParentObjectInfo,
+ pDirNode);
+ }
+
+ pDirNode = NULL;
+ }
+ }
//
// We are unsure of our current data so set the verify flag. It may already be set
ParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
}
- else
- {
-
- //
- // Update the parent data version
- //
- ParentObjectInfo->DataVersion = pResultCB->ParentDataVersion;
- }
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNotifyFileCreate Creating new entry %wZ\n",
- FileName);
+ FileName));
//
// Initialize the directory entry
if( pDirNode == NULL)
{
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
// Init the short name if we have one
//
- if( pResultCB->DirEnum.ShortNameLength > 0)
+ if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ pResultCB->DirEnum.ShortNameLength > 0)
{
UNICODE_STRING uniShortName;
pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNotifyFileCreate Initialized short name %wZ for DE %p for %wZ\n",
&uniShortName,
pDirNode,
- &pDirNode->NameInformation.FileName);
+ &pDirNode->NameInformation.FileName));
+ }
+ else
+ {
+ //
+ // No short name or short names are disabled
+ //
+
+ pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = 0;
+ }
+
+ if ( !BooleanFlagOn( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
+ {
+
+ //
+ // Update the parent data version
+ //
+
+ ParentObjectInfo->DataVersion = pResultCB->ParentDataVersion;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyFileCreate entry %wZ ParentFID %08lX-%08lX-%08lX-%08lX Version %08lX:%08lX\n",
+ FileName,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique,
+ ParentObjectInfo->DataVersion.QuadPart));
}
//
try_exit:
+ if ( *DirNode != NULL)
+ {
+
+ lCount = InterlockedIncrement( &(*DirNode)->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyFileCreate Increment count on %wZ DE %p Cnt %d\n",
+ &(*DirNode)->NameInformation.FileName,
+ *DirNode,
+ lCount));
+
+ ASSERT( lCount >= 0);
+ }
+
+ if ( bReleaseParentTreeLock)
+ {
+
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
+
if( pResultCB != NULL)
{
- AFSExFreePool( pResultCB);
+ AFSExFreePoolWithTag( pResultCB, AFS_GENERIC_MEMORY_1_TAG);
}
}
{
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSFileUpdateCB stUpdateCB;
ULONG ulResultLen = 0;
AFSFileUpdateResultCB *pUpdateResultCB = NULL;
stUpdateCB.LastWriteTime = ObjectInfo->LastWriteTime;
- pUpdateResultCB = (AFSFileUpdateResultCB *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_UPDATE_RESULT_TAG);
+ pUpdateResultCB = (AFSFileUpdateResultCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_UPDATE_RESULT_TAG);
if( pUpdateResultCB == NULL)
{
AuthGroup,
NULL,
&ObjectInfo->FileId,
+ ObjectInfo->VolumeCB->VolumeInformation.Cell,
+ ObjectInfo->VolumeCB->VolumeInformation.CellLength,
&stUpdateCB,
sizeof( AFSFileUpdateCB),
pUpdateResultCB,
if( ntStatus != STATUS_SUCCESS)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSUpdateFileInformation failed FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
ObjectInfo->FileId.Cell,
ObjectInfo->FileId.Volume,
ObjectInfo->FileId.Vnode,
ObjectInfo->FileId.Unique,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
// Update the data version
//
- ObjectInfo->DataVersion = pUpdateResultCB->DirEnum.DataVersion;
+ AFSAcquireExcl( ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ if ( !BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
+ {
+
+ ObjectInfo->DataVersion = pUpdateResultCB->DirEnum.DataVersion;
+ }
+
+ AFSReleaseResource( ObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
try_exit:
if( pUpdateResultCB != NULL)
{
- AFSExFreePool( pUpdateResultCB);
+ AFSExFreePoolWithTag( pUpdateResultCB, AFS_UPDATE_RESULT_TAG);
}
}
AFSFileDeleteCB stDelete;
AFSFileDeleteResultCB stDeleteResult;
ULONG ulRequestFlags = AFS_REQUEST_FLAG_SYNCHRONOUS;
+ AFSObjectInfoCB *pObjectInfo = NULL;
+ AFSObjectInfoCB *pParentObjectInfo = NULL;
__Enter
{
- stDelete.ParentId = DirectoryCB->ObjectInformation->ParentObjectInformation->FileId;
+ pObjectInfo = DirectoryCB->ObjectInformation;
+
+ pParentObjectInfo = AFSFindObjectInfo( pObjectInfo->VolumeCB,
+ &pObjectInfo->ParentFileId,
+ FALSE);
+
+ stDelete.ParentId = pObjectInfo->ParentFileId;
stDelete.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
ulRequestFlags,
AuthGroup,
&DirectoryCB->NameInformation.FileName,
- &DirectoryCB->ObjectInformation->FileId,
+ &pObjectInfo->FileId,
+ pObjectInfo->VolumeCB->VolumeInformation.Cell,
+ pObjectInfo->VolumeCB->VolumeInformation.CellLength,
&stDelete,
sizeof( AFSFileDeleteCB),
&stDeleteResult,
&ulResultLen);
- if( ntStatus != STATUS_SUCCESS)
+ if( ntStatus != STATUS_SUCCESS)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNotifyDelete failed ParentFID %08lX-%08lX-%08lX-%08lX %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ stDelete.ParentId.Cell,
+ stDelete.ParentId.Volume,
+ stDelete.ParentId.Vnode,
+ stDelete.ParentId.Unique,
+ &DirectoryCB->NameInformation.FileName,
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique,
+ ntStatus));
+
+ try_return( ntStatus);
+ }
+
+ AFSAcquireExcl( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ if( CheckOnly)
+ {
+
+ //
+ // Validate the parent data version
+ //
+
+ if( pParentObjectInfo->DataVersion.QuadPart != stDeleteResult.ParentDataVersion.QuadPart)
+ {
+
+ SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+ }
+ else
+ {
+
+ //
+ // Update the parent data version
+ //
+
+ if( pParentObjectInfo->DataVersion.QuadPart != stDeleteResult.ParentDataVersion.QuadPart - 1)
+ {
+
+ SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+ else
+ {
+
+ //
+ // TODO -- The entry must be removed from the directory at which point the
+ // Directory data version number can be updated. Until then we must force
+ // a verification.
+ //
+ // pParentObjectInfor->DataVersion.QuadPart = stDeleteResult.ParentDataVersion.QuadPart;
+ //
+
+ SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+ }
+
+ AFSReleaseResource( pObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+try_exit:
+
+ if ( pParentObjectInfo)
+ {
+
+ AFSReleaseObjectInfo( &pParentObjectInfo);
+ }
+ }
+
+ return ntStatus;
+}
+
+
+NTSTATUS
+AFSNotifyHardLink( IN AFSObjectInfoCB *ObjectInfo,
+ IN GUID *AuthGroup,
+ IN AFSObjectInfoCB *ParentObjectInfo,
+ IN AFSObjectInfoCB *TargetParentObjectInfo,
+ IN AFSDirectoryCB *SourceDirectoryCB,
+ IN UNICODE_STRING *TargetName,
+ IN BOOLEAN bReplaceIfExists,
+ OUT AFSDirectoryCB **TargetDirectoryCB)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSFileHardLinkCB *pHardLinkCB = NULL;
+ AFSFileHardLinkResultCB *pResultCB = NULL;
+ ULONG ulResultLen = 0;
+ AFSDirectoryCB *pDirNode = NULL;
+ ULONG ulCRC = 0;
+ BOOLEAN bReleaseParentLock = FALSE, bReleaseTargetParentLock = FALSE;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ LONG lCount;
+
+ __Enter
+ {
+
+ //
+ // Init the control block for the request
+ //
+
+ pHardLinkCB = (AFSFileHardLinkCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_HARDLINK_REQUEST_TAG);
+
+ if( pHardLinkCB == NULL)
+ {
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ RtlZeroMemory( pHardLinkCB,
+ PAGE_SIZE);
+
+ pHardLinkCB->SourceParentId = ParentObjectInfo->FileId;
+
+ pHardLinkCB->TargetParentId = TargetParentObjectInfo->FileId;
+
+ pHardLinkCB->TargetNameLength = TargetName->Length;
+
+ RtlCopyMemory( pHardLinkCB->TargetName,
+ TargetName->Buffer,
+ TargetName->Length);
+
+ pHardLinkCB->bReplaceIfExists = bReplaceIfExists;
+
+ //
+ // Use the same buffer for the result control block
+ //
+
+ pResultCB = (AFSFileHardLinkResultCB *)pHardLinkCB;
+
+ ulResultLen = PAGE_SIZE;
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_HARDLINK_FILE,
+ AFS_REQUEST_FLAG_SYNCHRONOUS,
+ AuthGroup,
+ &SourceDirectoryCB->NameInformation.FileName,
+ &ObjectInfo->FileId,
+ ObjectInfo->VolumeCB->VolumeInformation.Cell,
+ ObjectInfo->VolumeCB->VolumeInformation.CellLength,
+ pHardLinkCB,
+ sizeof( AFSFileHardLinkCB) + TargetName->Length,
+ pResultCB,
+ &ulResultLen);
+
+ if( ntStatus != STATUS_SUCCESS)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNotifyHardLink failed FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique,
+ ntStatus));
+
+ try_return( ntStatus);
+ }
+
+ //
+ // Update the information from the returned data
+ //
+
+ if ( ParentObjectInfo != TargetParentObjectInfo)
+ {
+
+ AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ bReleaseParentLock = TRUE;
+
+ if ( ParentObjectInfo->DataVersion.QuadPart == pResultCB->SourceParentDataVersion.QuadPart - 1)
+ {
+
+ ParentObjectInfo->DataVersion = pResultCB->SourceParentDataVersion;
+ }
+ else
+ {
+
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+ }
+
+ AFSAcquireExcl( TargetParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ bReleaseTargetParentLock = TRUE;
+
+ if ( TargetParentObjectInfo->DataVersion.QuadPart == pResultCB->TargetParentDataVersion.QuadPart - 1)
+ {
+
+ TargetParentObjectInfo->DataVersion = pResultCB->TargetParentDataVersion;
+ }
+ else
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSNotifyHardLink Raced with an invalidate call and a re-enumeration for entry %wZ ParentFID %08lX-%08lX-%08lX-%08lX Version (%08lX:%08lX != %08lX:%08lX - 1)\n",
+ TargetName,
+ TargetParentObjectInfo->FileId.Cell,
+ TargetParentObjectInfo->FileId.Volume,
+ TargetParentObjectInfo->FileId.Vnode,
+ TargetParentObjectInfo->FileId.Unique,
+ TargetParentObjectInfo->DataVersion.HighPart,
+ TargetParentObjectInfo->DataVersion.LowPart,
+ pResultCB->TargetParentDataVersion.HighPart,
+ pResultCB->TargetParentDataVersion.LowPart));
+
+ //
+ // We raced so go and lookup the directory entry in the parent
+ //
+
+ ulCRC = AFSGenerateCRC( TargetName,
+ FALSE);
+
+ AFSLocateCaseSensitiveDirEntry( TargetParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
+ ulCRC,
+ &pDirNode);
+
+ if( pDirNode != NULL)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink Located dir entry %p for file %wZ\n",
+ pDirNode,
+ TargetName));
+
+ if ( AFSIsEqualFID( &pDirNode->ObjectInformation->FileId,
+ &pResultCB->DirEnum.FileId))
+ {
+
+ try_return( ntStatus = STATUS_REPARSE);
+ }
+ else
+ {
+
+ //
+ // We found an entry that matches the desired name but it is not the
+ // same as the one that was created for us by the file server.
+ //
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNotifyHardLink Found matching name entry %wZ DE %p FID %08lX-%08lX-%08lX-%08lX != FID %08lX-%08lX-%08lX-%08lX\n",
+ TargetName,
+ pDirNode,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pResultCB->DirEnum.FileId.Cell,
+ pResultCB->DirEnum.FileId.Volume,
+ pResultCB->DirEnum.FileId.Vnode,
+ pResultCB->DirEnum.FileId.Unique));
+
+ if( pDirNode->DirOpenReferenceCount <= 0 &&
+ pDirNode->NameArrayReferenceCount <= 0)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ &pDirNode->NameInformation.FileName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pResultCB->DirEnum.FileId.Cell,
+ pResultCB->DirEnum.FileId.Volume,
+ pResultCB->DirEnum.FileId.Vnode,
+ pResultCB->DirEnum.FileId.Unique));
+
+ AFSDeleteDirEntry( TargetParentObjectInfo,
+ &pDirNode);
+ }
+ else
+ {
+
+ SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_DELETED);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pDirNode,
+ &pDirNode->NameInformation.FileName,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique,
+ pResultCB->DirEnum.FileId.Cell,
+ pResultCB->DirEnum.FileId.Volume,
+ pResultCB->DirEnum.FileId.Vnode,
+ pResultCB->DirEnum.FileId.Unique));
+
+ AFSRemoveNameEntry( TargetParentObjectInfo,
+ pDirNode);
+ }
+
+ pDirNode = NULL;
+ }
+ }
+
+ //
+ // We are unsure of our current data so set the verify flag. It may already be set
+ // but no big deal to reset it
+ //
+
+ SetFlag( TargetParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ TargetParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+
+ //
+ // Create the hard link entry
+ //
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink Creating new entry %wZ\n",
+ TargetName));
+
+ //
+ // Initialize the directory entry
+ //
+
+ pDirNode = AFSInitDirEntry( TargetParentObjectInfo,
+ TargetName,
+ NULL,
+ &pResultCB->DirEnum,
+ (ULONG)InterlockedIncrement( &TargetParentObjectInfo->Specific.Directory.DirectoryNodeHdr.ContentIndex));
+
+ if( pDirNode == NULL)
+ {
+
+ SetFlag( TargetParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ TargetParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ //
+ // Init the short name if we have one
+ //
+
+ if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ pResultCB->DirEnum.ShortNameLength > 0)
+ {
+
+ UNICODE_STRING uniShortName;
+
+ pDirNode->NameInformation.ShortNameLength = pResultCB->DirEnum.ShortNameLength;
+
+ RtlCopyMemory( pDirNode->NameInformation.ShortName,
+ pResultCB->DirEnum.ShortName,
+ pDirNode->NameInformation.ShortNameLength);
+
+ //
+ // Generate the short name index
+ //
+
+ uniShortName.Length = pDirNode->NameInformation.ShortNameLength;
+ uniShortName.Buffer = pDirNode->NameInformation.ShortName;
+
+ pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = AFSGenerateCRC( &uniShortName,
+ TRUE);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink Initialized short name %wZ for DE %p for %wZ\n",
+ &uniShortName,
+ pDirNode,
+ &pDirNode->NameInformation.FileName));
+ }
+ else
+ {
+ //
+ // No short name or short names are disabled
+ //
+
+ pDirNode->Type.Data.ShortNameTreeEntry.HashIndex = 0;
+ }
+
+ if ( !BooleanFlagOn( TargetParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
+ {
+
+ //
+ // Update the target parent data version
+ //
+
+ TargetParentObjectInfo->DataVersion = pResultCB->TargetParentDataVersion;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink entry %wZ ParentFID %08lX-%08lX-%08lX-%08lX Version %08lX:%08lX\n",
+ TargetName,
+ TargetParentObjectInfo->FileId.Cell,
+ TargetParentObjectInfo->FileId.Volume,
+ TargetParentObjectInfo->FileId.Vnode,
+ TargetParentObjectInfo->FileId.Unique,
+ TargetParentObjectInfo->DataVersion.QuadPart));
+ }
+
+try_exit:
+
+ if ( TargetDirectoryCB != NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSNotifyDelete failed FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
- &DirectoryCB->ObjectInformation->FileId.Cell,
- &DirectoryCB->ObjectInformation->FileId.Volume,
- &DirectoryCB->ObjectInformation->FileId.Vnode,
- &DirectoryCB->ObjectInformation->FileId.Unique,
- ntStatus);
+ lCount = InterlockedIncrement( &pDirNode->DirOpenReferenceCount);
- try_return( ntStatus);
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNotifyHardLink Increment count on %wZ DE %p Cnt %d\n",
+ &pDirNode->NameInformation.FileName,
+ pDirNode,
+ lCount));
+
+ ASSERT( lCount >= 0);
+
+ *TargetDirectoryCB = pDirNode;
}
- if( !CheckOnly)
+ if ( bReleaseTargetParentLock)
{
- //
- // Update the parent data version
- //
-
- if( DirectoryCB->ObjectInformation->ParentObjectInformation->DataVersion.QuadPart != stDeleteResult.ParentDataVersion.QuadPart)
- {
+ AFSReleaseResource( TargetParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
- SetFlag( DirectoryCB->ObjectInformation->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
+ if ( bReleaseParentLock)
+ {
- DirectoryCB->ObjectInformation->ParentObjectInformation->DataVersion.QuadPart = (ULONGLONG)-1;
- }
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
}
-try_exit:
+ if( pHardLinkCB != NULL)
+ {
- NOTHING;
+ AFSExFreePoolWithTag( pHardLinkCB, AFS_HARDLINK_REQUEST_TAG);
+ }
}
return ntStatus;
}
+
+
NTSTATUS
AFSNotifyRename( IN AFSObjectInfoCB *ObjectInfo,
IN GUID *AuthGroup,
AFSFileRenameCB *pRenameCB = NULL;
AFSFileRenameResultCB *pRenameResultCB = NULL;
ULONG ulResultLen = 0;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
__Enter
{
// Init the control block for the request
//
- pRenameCB = (AFSFileRenameCB *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_RENAME_REQUEST_TAG);
+ pRenameCB = (AFSFileRenameCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_RENAME_REQUEST_TAG);
if( pRenameCB == NULL)
{
AuthGroup,
&DirectoryCB->NameInformation.FileName,
&ObjectInfo->FileId,
+ ObjectInfo->VolumeCB->VolumeInformation.Cell,
+ ObjectInfo->VolumeCB->VolumeInformation.CellLength,
pRenameCB,
sizeof( AFSFileRenameCB) + TargetName->Length,
pRenameResultCB,
if( ntStatus != STATUS_SUCCESS)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNotifyRename failed FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
ObjectInfo->FileId.Cell,
ObjectInfo->FileId.Volume,
ObjectInfo->FileId.Vnode,
ObjectInfo->FileId.Unique,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
// Update the information from the returned data
//
- ParentObjectInfo->DataVersion = pRenameResultCB->SourceParentDataVersion;
+ AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ if ( ParentObjectInfo->DataVersion.QuadPart == pRenameResultCB->SourceParentDataVersion.QuadPart - 1)
+ {
+
+ ParentObjectInfo->DataVersion = pRenameResultCB->SourceParentDataVersion;
+ }
+ else
+ {
+
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+
+ if ( ParentObjectInfo != TargetParentObjectInfo)
+ {
+
+ AFSAcquireExcl( TargetParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ if ( TargetParentObjectInfo->DataVersion.QuadPart == pRenameResultCB->TargetParentDataVersion.QuadPart - 1)
+ {
+
+ TargetParentObjectInfo->DataVersion = pRenameResultCB->TargetParentDataVersion;
+ }
+ else
+ {
+
+ SetFlag( TargetParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
- TargetParentObjectInfo->DataVersion = pRenameResultCB->TargetParentDataVersion;
+ TargetParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+ }
//
// Move over the short name
DirectoryCB->NameInformation.ShortNameLength = pRenameResultCB->DirEnum.ShortNameLength;
- if( DirectoryCB->NameInformation.ShortNameLength > 0)
+ if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ DirectoryCB->NameInformation.ShortNameLength > 0)
{
UNICODE_STRING uniShortName;
uniShortName.MaximumLength = uniShortName.Length;
uniShortName.Buffer = DirectoryCB->NameInformation.ShortName;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNotifyRename Update old short name %wZ for DE %p for %wZ\n",
&uniShortName,
DirectoryCB,
- &DirectoryCB->NameInformation.FileName);
+ &DirectoryCB->NameInformation.FileName));
DirectoryCB->NameInformation.ShortNameLength = pRenameResultCB->DirEnum.ShortNameLength;
uniShortName.MaximumLength = uniShortName.Length;
uniShortName.Buffer = DirectoryCB->NameInformation.ShortName;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNotifyRename Initialized short name %wZ for DE %p for %wZ\n",
&uniShortName,
DirectoryCB,
- &DirectoryCB->NameInformation.FileName);
+ &DirectoryCB->NameInformation.FileName));
}
else
{
uniShortName.MaximumLength = uniShortName.Length;
uniShortName.Buffer = DirectoryCB->NameInformation.ShortName;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNotifyRename Removing old short name %wZ for DE %p for %wZ\n",
&uniShortName,
DirectoryCB,
- &DirectoryCB->NameInformation.FileName);
+ &DirectoryCB->NameInformation.FileName));
DirectoryCB->NameInformation.ShortNameLength = 0;
DirectoryCB->Type.Data.ShortNameTreeEntry.HashIndex = 0;
}
+ if ( ParentObjectInfo != TargetParentObjectInfo)
+ {
+
+ AFSReleaseResource( TargetParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
+
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
if( UpdatedFID != NULL)
{
*UpdatedFID = pRenameResultCB->DirEnum.FileId;
if( pRenameCB != NULL)
{
- AFSExFreePool( pRenameCB);
+ AFSExFreePoolWithTag( pRenameCB, AFS_RENAME_REQUEST_TAG);
}
}
AFSFileEvalResultCB *pEvalResultCB = NULL;
AFSDirEnumEntry *pDirEnumCB = NULL;
ULONG ulRequestFlags = AFS_REQUEST_FLAG_SYNCHRONOUS;
+ AFSObjectInfoCB *pParentObjectInfo = NULL;
__Enter
{
RtlZeroMemory( &stTargetID,
sizeof( AFSEvalTargetCB));
- if( ObjectInfo->ParentObjectInformation != NULL)
+ if ( BooleanFlagOn( ObjectInfo->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
{
- stTargetID.ParentId = ObjectInfo->ParentObjectInformation->FileId;
+ pParentObjectInfo = AFSFindObjectInfo( ObjectInfo->VolumeCB,
+ &ObjectInfo->ParentFileId,
+ TRUE);
+
+ stTargetID.ParentId = ObjectInfo->ParentFileId;
}
//
// Allocate our response buffer
//
- pEvalResultCB = (AFSFileEvalResultCB *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_GENERIC_MEMORY_30_TAG);
+ pEvalResultCB = (AFSFileEvalResultCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_GENERIC_MEMORY_30_TAG);
if( pEvalResultCB == NULL)
{
AuthGroup,
NULL,
&ObjectInfo->FileId,
+ ObjectInfo->VolumeCB->VolumeInformation.Cell,
+ ObjectInfo->VolumeCB->VolumeInformation.CellLength,
&stTargetID,
sizeof( AFSEvalTargetCB),
pEvalResultCB,
// verification
//
- if( ntStatus == STATUS_INVALID_HANDLE)
+ if( ntStatus == STATUS_OBJECT_PATH_INVALID)
{
- if( ObjectInfo->ParentObjectInformation != NULL)
+ if( pParentObjectInfo != NULL)
{
- SetFlag( ObjectInfo->ParentObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY);
+ AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
}
}
}
//
+ // A BSOD can occur if the pEvalResultCB->FileType is FILE but the
+ // ObjectInfo->FileType is something else. The same is true for
+ // pDirEnumEntry->FileType is DIRECTORY. Perform a sanity check
+ // to ensure consistency. An inconsistent pDirEnumEntry can be
+ // produced as a result of invalid status info received from a file
+ // server. If the types are inconsistent or if the type does not
+ // match the implied type derived from the vnode (odd values are
+ // directories and even values are other types), prevent the request
+ // from completing successfully. This may prevent access to the file or
+ // directory but will prevent a BSOD.
+ //
+
+ if ( !AFSIsEqualFID( &ObjectInfo->FileId,
+ &pEvalResultCB->DirEnum.FileId))
+ {
+
+ try_return( ntStatus = STATUS_UNSUCCESSFUL);
+ }
+
+ switch ( pEvalResultCB->DirEnum.FileType)
+ {
+
+ case AFS_FILE_TYPE_DIRECTORY:
+ if ( (pEvalResultCB->DirEnum.FileId.Vnode & 0x1) != 0x1)
+ {
+
+ try_return( ntStatus = STATUS_UNSUCCESSFUL);
+ }
+
+ if ( ObjectInfo->FileType != AFS_FILE_TYPE_UNKNOWN &&
+ ObjectInfo->FileType != AFS_FILE_TYPE_DIRECTORY)
+ {
+
+ try_return( ntStatus = STATUS_UNSUCCESSFUL);
+ }
+
+ break;
+
+ case AFS_FILE_TYPE_FILE:
+ if ( (pEvalResultCB->DirEnum.FileId.Vnode & 0x1) != 0x0)
+ {
+
+ try_return( ntStatus = STATUS_UNSUCCESSFUL);
+ }
+
+ if ( ObjectInfo->FileType != AFS_FILE_TYPE_UNKNOWN &&
+ ObjectInfo->FileType != AFS_FILE_TYPE_FILE)
+ {
+
+ try_return( ntStatus = STATUS_UNSUCCESSFUL);
+ }
+
+ break;
+ }
+
+ //
+ // Validate the parent data version
+ //
+
+ if ( pParentObjectInfo != NULL)
+ {
+
+ AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ if ( pParentObjectInfo->DataVersion.QuadPart != pEvalResultCB->ParentDataVersion.QuadPart)
+ {
+
+ SetFlag( pParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ pParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+
+ AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
+
+ //
// Pass back the dir enum entry
//
if( DirEnumEntry != NULL)
{
- pDirEnumCB = (AFSDirEnumEntry *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_GENERIC_MEMORY_2_TAG);
+ pDirEnumCB = (AFSDirEnumEntry *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_GENERIC_MEMORY_2_TAG);
if( pDirEnumCB == NULL)
{
try_exit:
+ if ( pParentObjectInfo != NULL)
+ {
+
+ AFSReleaseObjectInfo( &pParentObjectInfo);
+ }
+
if( pEvalResultCB != NULL)
{
- AFSExFreePool( pEvalResultCB);
+ AFSExFreePoolWithTag( pEvalResultCB, AFS_GENERIC_MEMORY_30_TAG);
}
if( !NT_SUCCESS( ntStatus))
if( pDirEnumCB != NULL)
{
- AFSExFreePool( pDirEnumCB);
+ AFSExFreePoolWithTag( pDirEnumCB, AFS_GENERIC_MEMORY_2_TAG);
}
*DirEnumEntry = NULL;
NTSTATUS
AFSEvaluateTargetByName( IN GUID *AuthGroup,
- IN AFSFileID *ParentFileId,
+ IN AFSObjectInfoCB *ParentObjectInfo,
IN PUNICODE_STRING SourceName,
+ IN ULONG Flags,
OUT AFSDirEnumEntry **DirEnumEntry)
{
__Enter
{
- stTargetID.ParentId = *ParentFileId;
+ stTargetID.ParentId = ParentObjectInfo->FileId;
//
// Allocate our response buffer
//
- pEvalResultCB = (AFSFileEvalResultCB *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_GENERIC_MEMORY_31_TAG);
+ pEvalResultCB = (AFSFileEvalResultCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_GENERIC_MEMORY_31_TAG);
if( pEvalResultCB == NULL)
{
ulResultBufferLength = PAGE_SIZE;
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_EVAL_TARGET_BY_NAME,
- AFS_REQUEST_FLAG_SYNCHRONOUS,
+ AFS_REQUEST_FLAG_SYNCHRONOUS | Flags,
AuthGroup,
SourceName,
NULL,
+ ParentObjectInfo->VolumeCB->VolumeInformation.Cell,
+ ParentObjectInfo->VolumeCB->VolumeInformation.CellLength,
&stTargetID,
sizeof( AFSEvalTargetCB),
pEvalResultCB,
if( ntStatus != STATUS_SUCCESS)
{
+ if( ntStatus == STATUS_OBJECT_PATH_INVALID)
+ {
+
+ AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
+
try_return( ntStatus);
}
//
+ // Validate the parent data version
+ //
+
+ AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ if ( ParentObjectInfo->DataVersion.QuadPart != pEvalResultCB->ParentDataVersion.QuadPart)
+ {
+
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ParentObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
+ }
+
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ //
// Pass back the dir enum entry
//
if( DirEnumEntry != NULL)
{
- pDirEnumCB = (AFSDirEnumEntry *)AFSExAllocatePoolWithTag( PagedPool,
- PAGE_SIZE,
- AFS_GENERIC_MEMORY_3_TAG);
+ pDirEnumCB = (AFSDirEnumEntry *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_GENERIC_MEMORY_3_TAG);
if( pDirEnumCB == NULL)
{
if( pEvalResultCB != NULL)
{
- AFSExFreePool( pEvalResultCB);
+ AFSExFreePoolWithTag( pEvalResultCB, AFS_GENERIC_MEMORY_31_TAG);
}
if( !NT_SUCCESS( ntStatus))
if( pDirEnumCB != NULL)
{
- AFSExFreePool( pDirEnumCB);
+ AFSExFreePoolWithTag( pDirEnumCB, AFS_GENERIC_MEMORY_3_TAG);
}
*DirEnumEntry = NULL;
FileID,
NULL,
0,
+ NULL,
+ 0,
VolumeInformation,
&ulResultLen);
}
NTSTATUS
+AFSRetrieveVolumeSizeInformation( IN GUID *AuthGroup,
+ IN AFSFileID *FileID,
+ OUT AFSVolumeSizeInfoCB *VolumeSizeInformation)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ ULONG ulResultLen = 0;
+
+ __Enter
+ {
+
+ ulResultLen = sizeof( AFSVolumeSizeInfoCB);
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_GET_VOLUME_SIZE_INFO,
+ AFS_REQUEST_FLAG_SYNCHRONOUS,
+ AuthGroup,
+ NULL,
+ FileID,
+ NULL,
+ 0,
+ NULL,
+ 0,
+ VolumeSizeInformation,
+ &ulResultLen);
+
+ if( ntStatus != STATUS_SUCCESS)
+ {
+
+ try_return( ntStatus);
+ }
+
+try_exit:
+
+ NOTHING;
+ }
+
+ return ntStatus;
+}
+
+NTSTATUS
AFSNotifyPipeTransceive( IN AFSCcb *Ccb,
IN ULONG InputLength,
IN ULONG OutputLength,
ULONG ulResultLen = 0;
MDL *pInputMdl = NULL, *pOutputMdl = NULL;
void *pInputSystemBuffer = NULL, *pOutputSystemBuffer = NULL;
- ULONG ulBufferLength = OutputLength;
AFSPipeIORequestCB *pIoRequest = NULL;
__Enter
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
- pIoRequest = (AFSPipeIORequestCB *)AFSExAllocatePoolWithTag( PagedPool,
- sizeof( AFSPipeIORequestCB) +
+ pIoRequest = (AFSPipeIORequestCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ sizeof( AFSPipeIORequestCB) +
InputLength,
- AFS_GENERIC_MEMORY_4_TAG);
+ AFS_GENERIC_MEMORY_4_TAG);
if( pIoRequest == NULL)
{
&Ccb->AuthGroup,
&Ccb->DirectoryCB->NameInformation.FileName,
NULL,
+ NULL,
+ 0,
pIoRequest,
sizeof( AFSPipeIORequestCB) + InputLength,
pOutputSystemBuffer,
if( pIoRequest != NULL)
{
- AFSExFreePool( pIoRequest);
+ AFSExFreePoolWithTag( pIoRequest, AFS_GENERIC_MEMORY_4_TAG);
}
}
__Enter
{
- pInfoRequest = (AFSPipeInfoRequestCB *)AFSExAllocatePoolWithTag( PagedPool,
- sizeof( AFSPipeInfoRequestCB) +
+ pInfoRequest = (AFSPipeInfoRequestCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ sizeof( AFSPipeInfoRequestCB) +
InputLength,
- AFS_GENERIC_MEMORY_5_TAG);
+ AFS_GENERIC_MEMORY_5_TAG);
if( pInfoRequest == NULL)
{
&Ccb->AuthGroup,
&Ccb->DirectoryCB->NameInformation.FileName,
NULL,
+ NULL,
+ 0,
pInfoRequest,
sizeof( AFSPipeInfoRequestCB) + InputLength,
NULL,
if( pInfoRequest != NULL)
{
- AFSExFreePool( pInfoRequest);
+ AFSExFreePoolWithTag( pInfoRequest, AFS_GENERIC_MEMORY_5_TAG);
}
}
&Ccb->AuthGroup,
&Ccb->DirectoryCB->NameInformation.FileName,
NULL,
+ NULL,
+ 0,
&stInfoRequest,
sizeof( AFSPipeInfoRequestCB),
DataBuffer,
NULL,
0,
NULL,
+ 0,
+ NULL,
NULL);
}
{
BOOLEAN bRequestQueued = FALSE;
- NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
AFSCommSrvcCB *pCommSrvc = NULL;
AFSPoolEntry *pPoolEntry = NULL;
return bRequestQueued;
}
+
+NTSTATUS
+AFSCreateSymlink( IN GUID *AuthGroup,
+ IN AFSObjectInfoCB *ParentObjectInfo,
+ IN UNICODE_STRING *FileName,
+ IN AFSObjectInfoCB *ObjectInfo,
+ IN UNICODE_STRING *TargetName)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSCreateSymlinkCB *pSymlinkCreate = NULL;
+ ULONG ulResultLen = 0;
+ AFSCreateSymlinkResultCB *pSymlinkResult = NULL;
+
+ __Enter
+ {
+
+ //
+ // Allocate our request and result structures
+ //
+
+ pSymlinkCreate = (AFSCreateSymlinkCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ sizeof( AFSCreateSymlinkCB) +
+ TargetName->Length,
+ AFS_SYMLINK_REQUEST_TAG);
+
+ if( pSymlinkCreate == NULL)
+ {
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ RtlZeroMemory( pSymlinkCreate,
+ sizeof( AFSCreateSymlinkCB) +
+ TargetName->Length);
+
+ pSymlinkResult = (AFSCreateSymlinkResultCB *)AFSLibExAllocatePoolWithTag( PagedPool,
+ PAGE_SIZE,
+ AFS_SYMLINK_REQUEST_TAG);
+
+ if( pSymlinkResult == NULL)
+ {
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ RtlZeroMemory( pSymlinkResult,
+ PAGE_SIZE);
+
+ //
+ // Populate the request buffer
+ //
+
+ RtlCopyMemory( &pSymlinkCreate->ParentId,
+ &ObjectInfo->ParentFileId,
+ sizeof( AFSFileID));
+
+ pSymlinkCreate->TargetNameLength = TargetName->Length;
+
+ RtlCopyMemory( pSymlinkCreate->TargetName,
+ TargetName->Buffer,
+ TargetName->Length);
+
+ ulResultLen = PAGE_SIZE;
+
+ //
+ // Call the service to create the symlink entry
+ //
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CREATE_SYMLINK,
+ AFS_REQUEST_FLAG_SYNCHRONOUS,
+ AuthGroup,
+ FileName,
+ &ObjectInfo->FileId,
+ ObjectInfo->VolumeCB->VolumeInformation.Cell,
+ ObjectInfo->VolumeCB->VolumeInformation.CellLength,
+ pSymlinkCreate,
+ sizeof( AFSCreateSymlinkCB) +
+ TargetName->Length,
+ pSymlinkResult,
+ &ulResultLen);
+
+ if ( ntStatus == STATUS_FILE_DELETED )
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCreateSymlink failed FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique,
+ ntStatus));
+
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ClearFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
+
+ SetFlag( ObjectInfo->Flags, AFS_OBJECT_FLAGS_DELETED);
+
+ try_return( ntStatus = STATUS_ACCESS_DENIED);
+ }
+ else if( ntStatus != STATUS_SUCCESS)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCreateSymlink failed FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ ObjectInfo->FileId.Cell,
+ ObjectInfo->FileId.Volume,
+ ObjectInfo->FileId.Vnode,
+ ObjectInfo->FileId.Unique,
+ ntStatus));
+
+ try_return( ntStatus);
+ }
+
+ //
+ // After successful creation the open object has been deleted and replaced by
+ // the actual symlink.
+ //
+
+ SetFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY);
+
+ ClearFlag( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
+
+ SetFlag( ObjectInfo->Flags, AFS_OBJECT_FLAGS_DELETED);
+
+try_exit:
+
+ if( pSymlinkCreate != NULL)
+ {
+
+ AFSExFreePoolWithTag( pSymlinkCreate, AFS_SYMLINK_REQUEST_TAG);
+ }
+
+ if( pSymlinkResult != NULL)
+ {
+
+ AFSExFreePoolWithTag( pSymlinkResult, AFS_SYMLINK_REQUEST_TAG);
+ }
+ }
+
+ return ntStatus;
+}