#include "AFSCommon.h"
+//
+// AFSLocateNameEntry
+//
+// On entry, *VolumeCB must have a held ReferenceCount provided by
+// the caller which will not be released. On successful exit, *OutVolumeCB
+// will be assigned the new current volume with a held ReferenceCount.
+//
+// On entry, *ParentDirectoryCB must have a held DirOpenReferenceCount
+// provided by the caller. This reference will not be released.
+// On exit, if OutParentDirectoryCB is set, it will have a new reference.
+//
+// On exit, if OutDirectoryCB is set, it will have a reference.
+//
+
NTSTATUS
AFSLocateNameEntry( IN GUID *AuthGroup,
IN PFILE_OBJECT FileObject,
- IN UNICODE_STRING *RootPathName,
+ IN OUT UNICODE_STRING *RootPathName,
IN UNICODE_STRING *ParsedPathName,
IN AFSNameArrayHdr *NameArray,
IN ULONG Flags,
- OUT AFSVolumeCB **VolumeCB,
- IN OUT AFSDirectoryCB **ParentDirectoryCB,
- OUT AFSDirectoryCB **DirectoryCB,
- OUT PUNICODE_STRING ComponentName)
+ IN AFSVolumeCB *VolumeCB,
+ IN AFSDirectoryCB *ParentDirectoryCB,
+ OUT AFSVolumeCB **OutVolumeCB,
+ OUT LONG *OutVolumeReferenceReason,
+ OUT AFSDirectoryCB **OutParentDirectoryCB,
+ OUT AFSDirectoryCB **OutDirectoryCB,
+ OUT PUNICODE_STRING ComponentName,
+ OUT PUNICODE_STRING TargetName)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
UNICODE_STRING uniPathName, uniComponentName, uniRemainingPath, uniSearchName, uniFullPathName;
ULONG ulCRC = 0;
AFSDirectoryCB *pDirEntry = NULL, *pParentDirEntry = NULL;
- AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
UNICODE_STRING uniSysName;
ULONG ulSubstituteIndex = 0;
BOOLEAN bSubstituteName = FALSE;
BOOLEAN bAllocatedSymLinkBuffer = FALSE;
UNICODE_STRING uniRelativeName, uniNoOpName;
AFSObjectInfoCB *pCurrentObject = NULL;
- AFSVolumeCB *pCurrentVolume = *VolumeCB;
- BOOLEAN bReleaseCurrentVolume = TRUE;
+ AFSObjectInfoCB *pParentObjectInfo = NULL;
+ AFSVolumeCB *pCurrentVolume = NULL;
+ AFSVolumeCB *pTargetVolume = NULL;
+ BOOLEAN bReleaseCurrentVolume = FALSE;
+ LONG VolumeReferenceReason;
BOOLEAN bSubstitutedName = FALSE;
+ LONG lCount;
__Enter
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ ASSERT( *OutVolumeCB != VolumeCB);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Processing full name %wZ\n",
+ "AFSLocateNameEntry (FO: %p) Processing full name %wZ\n",
FileObject,
- RootPathName);
+ RootPathName));
RtlInitUnicodeString( &uniSysName,
L"*@SYS");
pParentDirEntry = NULL;
- pDirEntry = *ParentDirectoryCB;
+ pDirEntry = ParentDirectoryCB;
+
+ //
+ // Increment our reference on this dir entry
+ //
+
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry,
+ NULL,
+ lCount));
+
+ pCurrentVolume = VolumeCB;
+
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
+
+ lCount = AFSVolumeIncrement( pCurrentVolume,
+ VolumeReferenceReason);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
+
+ bReleaseCurrentVolume = TRUE;
uniPathName = *ParsedPathName;
uniSearchName.Length = uniSearchName.MaximumLength = 0;
uniSearchName.Buffer = NULL;
- ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
-
while( TRUE)
{
+ ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
+
+ ASSERT( pDirEntry->DirOpenReferenceCount > 0);
+
//
// Check our total link count for this name array
//
if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Deleted parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Deleted parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ STATUS_FILE_DELETED));
try_return( ntStatus = STATUS_FILE_DELETED);
}
if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_PENDING_DELETE))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Delete pending on %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Delete pending on %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ STATUS_DELETE_PENDING));
try_return( ntStatus = STATUS_DELETE_PENDING);
}
!AFSIsEnumerationInProcess( pCurrentObject)))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
+
+ //
+ // Directory TreeLock should be exclusively held
+ //
+
+ AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
ntStatus = AFSVerifyEntry( AuthGroup,
- pDirEntry);
+ pDirEntry,
+ FALSE);
+
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
pCurrentObject->FileType == AFS_FILE_TYPE_UNKNOWN)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Evaluating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Evaluating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
ntStatus = AFSEvaluateNode( AuthGroup,
pDirEntry);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to evaluate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
- FileObject,
- &pDirEntry->NameInformation.FileName,
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique,
- ntStatus);
+ if ( ntStatus == STATUS_NOT_A_DIRECTORY)
+ {
+
+ if ( !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT NULL Status %08lX\n",
+ FileObject,
+ &pDirEntry->NameInformation.FileName,
+ pCurrentObject->FileId.Cell,
+ pCurrentObject->FileId.Volume,
+ pCurrentObject->FileId.Vnode,
+ pCurrentObject->FileId.Unique,
+ ntStatus));
+ }
+ else
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSLocateNameEntry (FO: %p) Failed to evaluate object %wZ FID %08lX-%08lX-%08lX-%08lX PARENT %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ FileObject,
+ &pDirEntry->NameInformation.FileName,
+ pCurrentObject->FileId.Cell,
+ pCurrentObject->FileId.Volume,
+ pCurrentObject->FileId.Vnode,
+ pCurrentObject->FileId.Unique,
+ pCurrentObject->ParentFileId.Cell,
+ pCurrentObject->ParentFileId.Volume,
+ pCurrentObject->ParentFileId.Vnode,
+ pCurrentObject->ParentFileId.Unique,
+ ntStatus));
+ }
+ }
+ else
+ {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSLocateNameEntry (FO: %p) Failed to evaluate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ FileObject,
+ &pDirEntry->NameInformation.FileName,
+ pCurrentObject->FileId.Cell,
+ pCurrentObject->FileId.Volume,
+ pCurrentObject->FileId.Vnode,
+ pCurrentObject->FileId.Unique,
+ ntStatus));
+ }
try_return( ntStatus);
}
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = pDirEntry;
- *DirectoryCB = pDirEntry;
+ pDirEntry = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
- *VolumeCB = pCurrentVolume;
+ *OutVolumeReferenceReason = VolumeReferenceReason;
+
+ bReleaseCurrentVolume = FALSE;
*RootPathName = uniFullPathName;
try_return( ntStatus);
}
+ AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
AFSAcquireExcl( &pDirEntry->NonPaged->Lock,
TRUE);
SetFlag( pCurrentObject->Flags, AFS_OBJECT_FLAGS_VERIFY);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Verifying symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Verifying symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
+
+ //
+ // Directory TreeLock should be exclusively held
+ //
ntStatus = AFSVerifyEntry( AuthGroup,
- pDirEntry);
+ pDirEntry,
+ FALSE);
+
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to verify symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to verify symlink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
AFSReleaseResource( &pDirEntry->NonPaged->Lock);
continue;
}
}
+ else
+ {
+
+ AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ }
//
// If we were given a zero length target name then deny access to the entry
if( pDirEntry->NameInformation.TargetName.Length == 0)
{
- ntStatus = STATUS_ACCESS_DENIED;
+ ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to retrieve target name for symlink %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to retrieve target name for symlink %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
AFSReleaseResource( &pDirEntry->NonPaged->Lock);
if( AFSIsRelativeName( &pDirEntry->NameInformation.TargetName))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Processing relative symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Processing relative symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.TargetName,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
//
// We'll substitute this name into the current process name
if( pTmpBuffer != NULL)
{
- AFSExFreePool( pTmpBuffer);
+ AFSExFreePoolWithTag( pTmpBuffer, 0);
}
AFSReleaseResource( &pDirEntry->NonPaged->Lock);
// Dereference the current entry ..
//
- InterlockedDecrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLocateNameEntry Decrement1 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
+
+ ASSERT( lCount >= 0);
//
// OK, need to back up one entry for the correct parent since the current
pDirEntry = AFSBackupEntry( pNameArray);
+ pCurrentObject = pDirEntry->ObjectInformation;
+
//
// Increment our reference on this dir entry
//
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
+ "AFSLocateNameEntry Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
- if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
+ if ( pParentDirEntry)
{
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
+
pParentDirEntry = NULL;
}
- else
+
+ if( !BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
{
pParentDirEntry = AFSGetParentEntry( pNameArray);
ASSERT( pParentDirEntry != pDirEntry);
+
+ lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
+ }
+
+ if ( pDirEntry->ObjectInformation->VolumeCB != pCurrentVolume)
+ {
+
+ lCount = AFSVolumeDecrement( pCurrentVolume,
+ VolumeReferenceReason);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
+
+ pCurrentVolume = pDirEntry->ObjectInformation->VolumeCB;
+
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
+
+ lCount = AFSVolumeIncrement( pCurrentVolume,
+ VolumeReferenceReason);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
}
}
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Processing absolute symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Processing absolute symlink target %wZ for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.TargetName,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
+
+ if ( !AFSIsAbsoluteAFSName( &pDirEntry->NameInformation.TargetName))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSLocateNameEntry Name %wZ contains invalid server name\n",
+ &pDirEntry->NameInformation.TargetName));
+
+ //
+ // The correct response would be STATUS_OBJECT_PATH_INVALID
+ // but that prevents cmd.exe from performing a recursive
+ // directory enumeration when opening a directory entry
+ // that represents a symlink to an invalid path is discovered.
+ //
+
+ AFSReleaseResource( &pDirEntry->NonPaged->Lock);
+
+ try_return( ntStatus = STATUS_OBJECT_PATH_NOT_FOUND);
+ }
//
// We'll substitute this name into the current process name
//
RtlCopyMemory( uniTempName.Buffer,
- pDirEntry->NameInformation.TargetName.Buffer,
- pDirEntry->NameInformation.TargetName.Length);
+ &pDirEntry->NameInformation.TargetName.Buffer[ AFSMountRootName.Length/sizeof( WCHAR)],
+ pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length);
- uniTempName.Length = pDirEntry->NameInformation.TargetName.Length;
+ uniTempName.Length = pDirEntry->NameInformation.TargetName.Length - AFSMountRootName.Length;
//
// And now any remaining portion of the name
if( pTmpBuffer != NULL)
{
- AFSExFreePool( pTmpBuffer);
+ AFSExFreePoolWithTag( pTmpBuffer, 0);
}
AFSReleaseResource( &pDirEntry->NonPaged->Lock);
if( pCurrentVolume != AFSGlobalRoot)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Current volume not global, resetting for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Current volume not global, resetting for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
- InterlockedDecrement( &pCurrentVolume->VolumeReferenceCount);
+ lCount = AFSVolumeDecrement( pCurrentVolume,
+ VolumeReferenceReason);
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Decrement count on volume %08lX Cnt %d\n",
+ "AFSLocateNameEntry Decrement count on volume %p Reason %u Cnt %d\n",
pCurrentVolume,
- pCurrentVolume->VolumeReferenceCount);
-
- AFSReleaseResource( pCurrentVolume->VolumeLock);
+ VolumeReferenceReason,
+ lCount));
pCurrentVolume = AFSGlobalRoot;
- AFSAcquireShared( pCurrentVolume->VolumeLock,
- TRUE);
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
- InterlockedIncrement( &pCurrentVolume->VolumeReferenceCount);
+ lCount = AFSVolumeIncrement( pCurrentVolume,
+ VolumeReferenceReason);
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Increment count on volume %08lX Cnt %d\n",
+ "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
pCurrentVolume,
- pCurrentVolume->VolumeReferenceCount);
+ VolumeReferenceReason,
+ lCount));
}
//
// Dereference our current dir entry
//
- InterlockedDecrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLocateNameEntry Decrement2 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
+
+ ASSERT( lCount >= 0);
pDirEntry = pCurrentVolume->DirectoryCB;
+ pCurrentObject = pDirEntry->ObjectInformation;
+
//
// Reference the new dir entry
//
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLocateNameEntry Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
//
// Reset the name array
lLinkCount = pNameArray->LinkCount;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Resetting name array for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Resetting name array for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
AFSResetNameArray( pNameArray,
pDirEntry);
pNameArray->LinkCount = lLinkCount;
- //
- // Process over the \\<Global root> portion of the name
- //
-
- FsRtlDissectName( uniPathName,
- &uniComponentName,
- &uniRemainingPath);
-
- if( RtlCompareUnicodeString( &uniComponentName,
- &AFSServerName,
- TRUE) != 0)
+ if ( pParentDirEntry)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry Name %wZ contains invalid server name\n",
- &uniPathName);
-
- //
- // The correct response would be STATUS_OBJECT_PATH_INVALID
- // but that prevents cmd.exe from performing a recursive
- // directory enumeration when opening a directory entry
- // that represents a symlink to an invalid path is discovered.
- //
- try_return( ntStatus = STATUS_OBJECT_PATH_NOT_FOUND);
- }
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
- uniPathName = uniRemainingPath;
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
- pParentDirEntry = NULL;
+ pParentDirEntry = NULL;
+ }
}
//
// Increment our link count
//
- InterlockedIncrement( &pNameArray->LinkCount);
+ lCount = InterlockedIncrement( &pNameArray->LinkCount);
continue;
}
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = pDirEntry;
+
+ pDirEntry = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
- *DirectoryCB = pDirEntry;
+ *OutVolumeReferenceReason = VolumeReferenceReason;
- *VolumeCB = pCurrentVolume;
+ bReleaseCurrentVolume = FALSE;
*RootPathName = uniFullPathName;
try_return( ntStatus);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Building MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Building MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
//
// Go retrieve the target entry for this node
// Also decrement the ref count on the volume
//
- ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
-
- InterlockedDecrement( &pCurrentVolume->VolumeReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Decrement2 count on volume %08lX Cnt %d\n",
- pCurrentVolume,
- pCurrentVolume->VolumeReferenceCount);
-
- AFSReleaseResource( pCurrentVolume->VolumeLock);
-
ntStatus = AFSBuildMountPointTarget( AuthGroup,
pDirEntry,
- &pCurrentVolume);
+ &pTargetVolume);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to build MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to build MP target for parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
- //
- // We already decremented the current volume above
- //
+ try_return( ntStatus);
+ }
- bReleaseCurrentVolume = FALSE;
+ ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
- try_return( ntStatus = STATUS_ACCESS_DENIED);
- }
+ lCount = AFSVolumeDecrement( pCurrentVolume,
+ VolumeReferenceReason);
- ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement2 count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
- ASSERT( ExIsResourceAcquiredLite( pCurrentVolume->VolumeLock));
+ pCurrentVolume = pTargetVolume;
- //
- // Replace the current name for the mp with the volume root of the target
- //
+ pTargetVolume = NULL;
+
+ ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
- AFSReplaceCurrentElement( pNameArray,
- pCurrentVolume->DirectoryCB);
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_MOUNTPT;
//
// We want to restart processing here on the new parent ...
// Deref and ref count the entries
//
- InterlockedDecrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLocateNameEntry Decrement3 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
+
+ ASSERT( lCount >= 0);
pDirEntry = pCurrentVolume->DirectoryCB;
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ pCurrentObject = pDirEntry->ObjectInformation;
+
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLocateNameEntry Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
- pParentDirEntry = NULL;
+ //
+ // The name array stores both the mount point and the target.
+ // Insert the target.
+ //
+
+ AFSInsertNextElement( pNameArray,
+ pDirEntry);
+
+ if ( pParentDirEntry)
+ {
+
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
+
+ pParentDirEntry = NULL;
+ }
//
// Increment our link count
//
- InterlockedIncrement( &pNameArray->LinkCount);
+ lCount = InterlockedIncrement( &pNameArray->LinkCount);
continue;
}
case AFS_FILE_TYPE_DFSLINK:
{
- if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL))
+ if( BooleanFlagOn( Flags, AFS_LOCATE_FLAGS_NO_DFS_LINK_EVAL) &&
+ uniRemainingPath.Length == 0)
{
//
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = pDirEntry;
+
+ pDirEntry = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
- *DirectoryCB = pDirEntry;
+ *OutVolumeReferenceReason = VolumeReferenceReason;
- *VolumeCB = pCurrentVolume;
+ bReleaseCurrentVolume = FALSE;
*RootPathName = uniFullPathName;
// system for it to reevaluate it
//
- if( FileObject != NULL)
+ if( FileObject != NULL ||
+ TargetName != NULL)
{
ntStatus = AFSProcessDFSLink( pDirEntry,
FileObject,
- &uniRemainingPath);
+ &uniRemainingPath,
+ AuthGroup,
+ TargetName);
}
else
{
ntStatus != STATUS_REPARSE)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to process DFSLink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to process DFSLink parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
}
try_return( ntStatus);
//
if( pCurrentObject->FileType == AFS_FILE_TYPE_DIRECTORY &&
- !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
+ !BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED) &&
+ uniPathName.Length > 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Enumerating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Enumerating parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
AFSAcquireExcl( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock,
TRUE);
AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to enumerate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to enumerate parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
-
- SetFlag( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED);
}
AFSReleaseResource( pCurrentObject->Specific.Directory.DirectoryNodeHdr.TreeLock);
if( uniPathName.Length > 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Encountered file node %wZ FID %08lX-%08lX-%08lX-%08lX in path processing\n",
+ "AFSLocateNameEntry (FO: %p) Encountered file node %wZ FID %08lX-%08lX-%08lX-%08lX in path processing\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
// The proper error code to return would be STATUS_OBJECT_PATH_INVALID because
// one of the components of the path is not a directory. However, returning
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Returning file %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Returning file %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
//
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = pDirEntry;
+
+ pDirEntry = NULL;
- *DirectoryCB = pDirEntry;
+ *OutVolumeCB = pCurrentVolume;
- *VolumeCB = pCurrentVolume;
+ *OutVolumeReferenceReason = VolumeReferenceReason;
+
+ bReleaseCurrentVolume = FALSE;
*RootPathName = uniFullPathName;
}
if( uniPathName.Length == 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Completed processing returning %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Completed processing returning %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
//
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
- *DirectoryCB = pDirEntry;
+ *OutDirectoryCB = pDirEntry;
- *VolumeCB = pCurrentVolume;
+ pDirEntry = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
+
+ *OutVolumeReferenceReason = VolumeReferenceReason;
+
+ bReleaseCurrentVolume = FALSE;
*RootPathName = uniFullPathName;
uniSearchName.Buffer != NULL)
{
- AFSExFreePool( uniSearchName.Buffer);
+ AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
bSubstituteName = FALSE;
TRUE) == 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Backing up entry from %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Backing up entry from %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
//
// Need to back up one entry in the name array
//
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
- InterlockedDecrement( &pDirEntry->OpenReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLocateNameEntry Decrement4 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
+
+ ASSERT( lCount >= 0);
pDirEntry = AFSBackupEntry( NameArray);
if( pDirEntry == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry AFSBackupEntry failed\n");
+ "AFSLocateNameEntry AFSBackupEntry failed\n"));
try_return(ntStatus = STATUS_OBJECT_PATH_INVALID);
}
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ pCurrentObject = pDirEntry->ObjectInformation;
+
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry,
+ NULL,
+ lCount));
- if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
+ if ( pParentDirEntry)
{
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
+
pParentDirEntry = NULL;
}
- else
+
+ if( !BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_ROOT_VOLUME))
{
pParentDirEntry = AFSGetParentEntry( pNameArray);
ASSERT( pParentDirEntry != pDirEntry);
- }
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirEntry->NameInformation.FileName,
- pDirEntry,
- NULL,
- pDirEntry->OpenReferenceCount);
+ if ( pParentDirEntry)
+ {
- uniPathName = uniRemainingPath;
+ lCount = InterlockedIncrement( &pParentDirEntry->DirOpenReferenceCount);
- continue;
- }
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
+ }
+ }
- //
- // Update our pointers
- //
+ if ( pDirEntry->ObjectInformation->VolumeCB != pCurrentVolume)
+ {
- pParentDirEntry = pDirEntry;
+ lCount = AFSVolumeDecrement( pCurrentVolume,
+ VolumeReferenceReason);
- pDirEntry = NULL;
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
+
+ pCurrentVolume = pDirEntry->ObjectInformation->VolumeCB;
+
+ VolumeReferenceReason = AFS_VOLUME_REFERENCE_LOCATE_NAME;
+
+ lCount = AFSVolumeIncrement( pCurrentVolume,
+ VolumeReferenceReason);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
+ }
+
+ uniPathName = uniRemainingPath;
+
+ continue;
+ }
+
+ //
+ // Update our pointers
+ //
+
+ if ( pParentDirEntry)
+ {
+
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
+ }
+
+ pParentDirEntry = pDirEntry;
+
+ pDirEntry = NULL;
+
+ pCurrentObject = NULL;
uniSearchName = uniComponentName;
NULL))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Processing @SYS substitution for %wZ Index %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Processing @SYS substitution for %wZ Index %08lX\n",
FileObject,
&uniComponentName,
- ulSubstituteIndex);
+ ulSubstituteIndex));
ntStatus = AFSSubstituteSysName( &uniComponentName,
&uniSearchName,
if ( NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Located substitution %wZ for %wZ Index %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Located substitution %wZ for %wZ Index %08lX\n",
FileObject,
&uniSearchName,
&uniComponentName,
- ulSubstituteIndex);
+ ulSubstituteIndex));
//
// Go reparse the name again
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to locate substitute string for %wZ Index %08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to locate substitute string for %wZ Index %08lX Status %08lX\n",
FileObject,
&uniComponentName,
ulSubstituteIndex,
- ntStatus);
+ ntStatus));
if( ntStatus == STATUS_OBJECT_NAME_NOT_FOUND)
{
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
- *DirectoryCB = NULL;
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
+
+ *OutVolumeReferenceReason = VolumeReferenceReason;
- *VolumeCB = pCurrentVolume;
+ bReleaseCurrentVolume = FALSE;
if( ComponentName != NULL)
{
// Generate the CRC on the node and perform a case sensitive lookup
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Searching for entry %wZ case sensitive\n",
+ "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case sensitive\n",
FileObject,
- &uniSearchName);
+ &uniSearchName));
ulCRC = AFSGenerateCRC( &uniSearchName,
FALSE);
// Missed so perform a case insensitive lookup
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Searching for entry %wZ case insensitive\n",
+ "AFSLocateNameEntry (FO: %p) Searching for entry %wZ case insensitive\n",
FileObject,
- &uniSearchName);
+ &uniSearchName));
ulCRC = AFSGenerateCRC( &uniSearchName,
TRUE);
// a lookup in the short name tree
//
- if( RtlIsNameLegalDOS8Dot3( &uniSearchName,
+ if( !BooleanFlagOn( pDevExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ RtlIsNameLegalDOS8Dot3( &uniSearchName,
NULL,
NULL))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Searching for entry %wZ short name\n",
+ "AFSLocateNameEntry (FO: %p) Searching for entry %wZ short name\n",
FileObject,
- &uniSearchName);
+ &uniSearchName));
AFSLocateShortNameDirEntry( pParentDirEntry->ObjectInformation->Specific.Directory.ShortNameTree,
ulCRC,
&pDirEntry);
}
+ if ( pDirEntry == NULL &&
+ pParentDirEntry->ObjectInformation->VolumeCB == AFSGlobalRoot)
+ {
+
+ //
+ // Check with the service to see if this is a valid cell name
+ // that can be automatically resolved. Drop the shared TreeLock
+ // since AFSCheckCellName must acquire it exclusively.
+ //
+
+ AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ ntStatus = AFSCheckCellName( AuthGroup,
+ &uniSearchName,
+ &pDirEntry);
+
+ AFSAcquireShared( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+ }
+
if( pDirEntry == NULL)
{
if( bSubstituteName)
{
- AFSExFreePool( uniSearchName.Buffer);
+ AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
uniSearchName = uniComponentName;
continue; // while( pDirEntry == NULL)
}
+ //
+ // Node name not found so get out
+ //
+
+ AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
if( uniRemainingPath.Length > 0)
{
ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry (FO: %p) Returning path not found for %wZ in Parent FID %08lX-%08lX-%08lX-%08lX\n",
+ FileObject,
+ &uniSearchName,
+ pParentDirEntry->ObjectInformation->FileId.Cell,
+ pParentDirEntry->ObjectInformation->FileId.Volume,
+ pParentDirEntry->ObjectInformation->FileId.Vnode,
+ pParentDirEntry->ObjectInformation->FileId.Unique));
}
else
{
ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Returning name not found for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Returning name not found for %wZ in Parent FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&uniSearchName,
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pParentDirEntry->ObjectInformation->FileId.Cell,
+ pParentDirEntry->ObjectInformation->FileId.Volume,
+ pParentDirEntry->ObjectInformation->FileId.Vnode,
+ pParentDirEntry->ObjectInformation->FileId.Unique));
//
// Pass back the directory entries
//
- *ParentDirectoryCB = pParentDirEntry;
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
- *DirectoryCB = NULL;
+ *OutVolumeReferenceReason = VolumeReferenceReason;
- *VolumeCB = pCurrentVolume;
+ bReleaseCurrentVolume = FALSE;
if( ComponentName != NULL)
{
*RootPathName = uniFullPathName;
}
- AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
-
- //
- // Node name not found so get out
- //
-
- try_return( ntStatus); // while( pDirEntry == NULL)
+ try_return( ntStatus);
}
}
else
// Is more than one link entry for this node then fail the lookup request
//
+ pCurrentObject = pDirEntry->ObjectInformation;
+
if( !BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD) ||
pDirEntry->CaseInsensitiveList.fLink != NULL)
{
+ //
+ // Increment our dir entry ref count since we will decrement it on exit
+ //
+
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry,
+ NULL,
+ lCount));
+
AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
try_return(ntStatus = STATUS_OBJECT_NAME_COLLISION);
// revalidate the parent and search again.
//
+ pCurrentObject = pDirEntry->ObjectInformation;
+
if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED) &&
BooleanFlagOn( pParentDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
{
AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Verifying(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Verifying(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pParentDirEntry->NameInformation.FileName,
pParentDirEntry->ObjectInformation->FileId.Cell,
pParentDirEntry->ObjectInformation->FileId.Volume,
pParentDirEntry->ObjectInformation->FileId.Vnode,
- pParentDirEntry->ObjectInformation->FileId.Unique);
+ pParentDirEntry->ObjectInformation->FileId.Unique));
+
+ //
+ // Directory TreeLock should be exclusively held
+ //
+
+ AFSAcquireExcl( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
ntStatus = AFSVerifyEntry( AuthGroup,
- pParentDirEntry);
+ pParentDirEntry,
+ FALSE);
+
+ AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to verify(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to verify(2) parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pParentDirEntry->NameInformation.FileName,
pParentDirEntry->ObjectInformation->FileId.Cell,
pParentDirEntry->ObjectInformation->FileId.Volume,
pParentDirEntry->ObjectInformation->FileId.Vnode,
pParentDirEntry->ObjectInformation->FileId.Unique,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Reprocessing component %wZ in parent %wZ\n",
+ "AFSLocateNameEntry (FO: %p) Reprocessing component %wZ in parent %wZ\n",
FileObject,
&uniSearchName,
- &pParentDirEntry->NameInformation.FileName);
+ &pParentDirEntry->NameInformation.FileName));
pDirEntry = NULL;
+ pCurrentObject = NULL;
+
continue;
}
// Increment our dir entry ref count
//
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pDirEntry->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
+ "AFSLocateNameEntry Increment6 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirEntry->NameInformation.FileName,
pDirEntry,
NULL,
- pDirEntry->OpenReferenceCount);
+ lCount));
}
AFSReleaseResource( pParentDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
// If we have a dirEntry for this component, perform some basic validation on it
//
- if( pDirEntry != NULL &&
- BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
+ if( pDirEntry != NULL)
{
pCurrentObject = pDirEntry->ObjectInformation;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Deleted parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
- FileObject,
- &pDirEntry->NameInformation.FileName,
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ if (BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
+ {
- //
- // This entry was deleted through the invalidation call back so perform cleanup
- // on the entry
- //
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSLocateNameEntry (FO: %p) Deleted entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ FileObject,
+ &pDirEntry->NameInformation.FileName,
+ pCurrentObject->FileId.Cell,
+ pCurrentObject->FileId.Volume,
+ pCurrentObject->FileId.Vnode,
+ pCurrentObject->FileId.Unique));
- ASSERT( pCurrentObject->ParentObjectInformation != NULL);
+ //
+ // This entry was deleted through the invalidation call back so perform cleanup
+ // on the entry
+ //
- AFSAcquireExcl( pCurrentObject->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
- TRUE);
+ if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_FLAGS_PARENT_FID))
+ {
- AFSAcquireExcl( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock,
- TRUE);
+ pParentObjectInfo = AFSFindObjectInfo( pCurrentObject->VolumeCB,
+ &pCurrentObject->ParentFileId,
+ FALSE);
+ }
- if( InterlockedDecrement( &pDirEntry->OpenReferenceCount) == 0)
- {
+ ASSERT( pParentObjectInfo != NULL);
+
+ AFSAcquireExcl( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFSAcquireExcl( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Deleting dir entry %08lX (%08lX) for %wZ\n",
+ "AFSLocateNameEntry Decrement count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
pDirEntry,
- pCurrentObject,
- &pDirEntry->NameInformation.FileName);
-
- //
- // Remove and delete the directory entry from the parent list
- //
+ NULL,
+ lCount));
- AFSDeleteDirEntry( pCurrentObject->ParentObjectInformation,
- pDirEntry);
+ ASSERT( lCount >= 0);
- if( pCurrentObject->ObjectReferenceCount == 0)
+ if( lCount == 0 &&
+ pDirEntry->NameArrayReferenceCount <= 0)
{
- if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING|AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Deleting dir entry %p (%p) for %wZ\n",
+ pDirEntry,
+ pCurrentObject,
+ &pDirEntry->NameInformation.FileName));
- AFSDbgLogMsg( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Removing object %08lX from volume tree\n",
- pCurrentObject);
+ //
+ // Remove and delete the directory entry from the parent list
+ //
- AFSRemoveHashEntry( &pCurrentObject->VolumeCB->ObjectInfoTree.TreeHead,
- &pCurrentObject->TreeEntry);
+ AFSDeleteDirEntry( pParentObjectInfo,
+ &pDirEntry);
- ClearFlag( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
- }
- }
- }
- else
- {
+ AFSAcquireShared( &pCurrentObject->NonPagedInfo->ObjectInfoLock,
+ TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Setting DELETE flag in dir entry %p for %wZ\n",
- pDirEntry,
- &pDirEntry->NameInformation.FileName);
+ if( pCurrentObject->ObjectReferenceCount <= 0)
+ {
- SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
+ if( BooleanFlagOn( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE))
+ {
- AFSRemoveNameEntry( pCurrentObject->ParentObjectInformation,
- pDirEntry);
- }
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Removing object %p from volume tree\n",
+ pCurrentObject));
- AFSReleaseResource( pCurrentObject->ParentObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
+ AFSRemoveHashEntry( &pCurrentObject->VolumeCB->ObjectInfoTree.TreeHead,
+ &pCurrentObject->TreeEntry);
- AFSReleaseResource( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock);
+ ClearFlag( pCurrentObject->Flags, AFS_OBJECT_INSERTED_HASH_TREE);
+ }
+ }
- //
- // We deleted the dir entry so check if there is any remaining portion
- // of the name to process.
- //
+ AFSReleaseResource( &pCurrentObject->NonPagedInfo->ObjectInfoLock);
+ }
+ else
+ {
- if( uniRemainingPath.Length > 0)
- {
- ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
- }
- else
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Setting DELETE flag in dir entry %p for %wZ\n",
+ pDirEntry,
+ &pDirEntry->NameInformation.FileName));
- ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
+ SetFlag( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Returning name not found(2) for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
- FileObject,
- &uniComponentName,
- pCurrentObject->FileId.Cell,
- pCurrentObject->FileId.Volume,
- pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ AFSRemoveNameEntry( pParentObjectInfo,
+ pDirEntry);
+ }
+
+ AFSReleaseResource( pParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ AFSReleaseResource( pCurrentObject->VolumeCB->ObjectInfoTree.TreeLock);
//
- // Pass back the directory entries
+ // We deleted the dir entry so check if there is any remaining portion
+ // of the name to process.
//
- *ParentDirectoryCB = pParentDirEntry;
+ if( uniRemainingPath.Length > 0)
+ {
- *DirectoryCB = NULL;
+ ntStatus = STATUS_OBJECT_PATH_NOT_FOUND;
- *VolumeCB = pCurrentVolume;
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry (FO: %p) Returning path not found(2) for %wZ in Parent FID %08lX-%08lX-%08lX-%08lX\n",
+ FileObject,
+ &uniComponentName,
+ pParentObjectInfo->FileId.Cell,
+ pParentObjectInfo->FileId.Volume,
+ pParentObjectInfo->FileId.Vnode,
+ pParentObjectInfo->FileId.Unique));
- if( ComponentName != NULL)
+ AFSReleaseObjectInfo( &pParentObjectInfo);
+ }
+ else
{
- *ComponentName = uniComponentName;
- }
+ ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
- *RootPathName = uniFullPathName;
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry (FO: %p) Returning name not found(2) for %wZ in Parent FID %08lX-%08lX-%08lX-%08lX\n",
+ FileObject,
+ &uniComponentName,
+ pParentObjectInfo->FileId.Cell,
+ pParentObjectInfo->FileId.Volume,
+ pParentObjectInfo->FileId.Vnode,
+ pParentObjectInfo->FileId.Unique));
+
+ AFSReleaseObjectInfo( &pParentObjectInfo);
+
+ //
+ // Pass back the directory entries
+ //
+
+ *OutParentDirectoryCB = pParentDirEntry;
+
+ pParentDirEntry = NULL;
+
+ *OutDirectoryCB = NULL;
+
+ *OutVolumeCB = pCurrentVolume;
+
+ *OutVolumeReferenceReason = VolumeReferenceReason;
+
+ bReleaseCurrentVolume = FALSE;
+
+ if( ComponentName != NULL)
+ {
+
+ *ComponentName = uniComponentName;
+ }
+
+ *RootPathName = uniFullPathName;
+ }
}
}
}
//
- // Decrement the previous parent
- //
-
- InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Decrement5 count on Parent %wZ DE %p Ccb %p Cnt %d\n",
- &pParentDirEntry->NameInformation.FileName,
- pParentDirEntry,
- NULL,
- pParentDirEntry->OpenReferenceCount);
-
- //
// If we ended up substituting a name in the component then update
// the full path and update the pointers
//
BOOLEAN bRelativeOpen = FALSE;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSLocateNameEntry (FO: %08lX) Substituting %wZ into %wZ Index %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Substituting %wZ into %wZ Index %08lX\n",
FileObject,
&uniSearchName,
&uniComponentName,
- ulSubstituteIndex);
+ ulSubstituteIndex));
if( FileObject != NULL &&
FileObject->RelatedFileObject != NULL)
&uniSearchName,
&uniRemainingPath,
bRelativeOpen ||
- bAllocatedSymLinkBuffer ||
- bSubstitutedName);
+ bAllocatedSymLinkBuffer ||
+ bSubstitutedName);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failure to substitute %wZ into %wZ Index %08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failure to substitute %wZ into %wZ Index %08lX Status %08lX\n",
FileObject,
&uniSearchName,
&uniComponentName,
ulSubstituteIndex,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
//
if( pCurrentObject->FileType == AFS_FILE_TYPE_SYMLINK &&
- pCurrentObject->TargetFileId.Vnode == 0 &&
- pCurrentObject->TargetFileId.Unique == 0 &&
- pDirEntry->NameInformation.TargetName.Length == 0)
+ ( pCurrentObject->TargetFileId.Vnode == 0 ||
+ pDirEntry->NameInformation.TargetName.Length == 0))
{
ntStatus = AFSValidateSymLink( AuthGroup,
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSLocateNameEntry (FO: %08lX) Failed to evaluate possible DFS Link %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Failed to evaluate possible DFS Link %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
pCurrentObject->FileId.Unique,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
// Update the name array
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Inserting name array entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSLocateNameEntry (FO: %p) Inserting name array entry %wZ FID %08lX-%08lX-%08lX-%08lX\n",
FileObject,
&pDirEntry->NameInformation.FileName,
pCurrentObject->FileId.Cell,
pCurrentObject->FileId.Volume,
pCurrentObject->FileId.Vnode,
- pCurrentObject->FileId.Unique);
+ pCurrentObject->FileId.Unique));
ntStatus = AFSInsertNextElement( pNameArray,
pDirEntry);
try_exit:
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry (FO: %08lX) Completed processing %wZ Status %08lX\n",
+ "AFSLocateNameEntry (FO: %p) Completed processing %wZ Status %08lX\n",
FileObject,
RootPathName,
- ntStatus);
+ ntStatus));
if( ( !NT_SUCCESS( ntStatus) &&
ntStatus != STATUS_OBJECT_NAME_NOT_FOUND) ||
ntStatus == STATUS_REPARSE)
{
-
- if( pDirEntry != NULL)
+ if( RootPathName->Buffer != uniFullPathName.Buffer)
{
- InterlockedDecrement( &pDirEntry->OpenReferenceCount);
+ AFSExFreePoolWithTag( uniFullPathName.Buffer, 0);
+ }
+ }
+ else
+ {
+
+ if( *OutParentDirectoryCB != NULL)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirEntry->NameInformation.FileName,
- pDirEntry,
+ "AFSLocateNameEntry Count on Parent %wZ DE %p Ccb %p Cnt %d\n",
+ &(*OutParentDirectoryCB)->NameInformation.FileName,
+ *OutParentDirectoryCB,
NULL,
- pDirEntry->OpenReferenceCount);
+ (*OutParentDirectoryCB)->DirOpenReferenceCount));
}
- else if( pParentDirEntry != NULL)
- {
- InterlockedDecrement( &pParentDirEntry->OpenReferenceCount);
+ if( *OutDirectoryCB != NULL)
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Decrement7 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pParentDirEntry->NameInformation.FileName,
- pParentDirEntry,
+ "AFSLocateNameEntry Count on %wZ DE %p Ccb %p Cnt %d\n",
+ &(*OutDirectoryCB)->NameInformation.FileName,
+ *OutDirectoryCB,
NULL,
- pParentDirEntry->OpenReferenceCount);
+ (*OutDirectoryCB)->DirOpenReferenceCount));
}
+ }
- if( bReleaseCurrentVolume)
- {
+ if( pDirEntry != NULL)
+ {
- ASSERT( pCurrentVolume->VolumeReferenceCount > 1);
+ lCount = InterlockedDecrement( &pDirEntry->DirOpenReferenceCount);
- ASSERT( ExIsResourceAcquiredLite( pCurrentVolume->VolumeLock));
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement6 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry,
+ NULL,
+ lCount));
- InterlockedDecrement( &pCurrentVolume->VolumeReferenceCount);
+ ASSERT( lCount >= 0);
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Decrement3 count on volume %08lX Cnt %d\n",
- pCurrentVolume,
- pCurrentVolume->VolumeReferenceCount);
+ if( pParentDirEntry != NULL)
+ {
- AFSReleaseResource( pCurrentVolume->VolumeLock);
- }
+ lCount = InterlockedDecrement( &pParentDirEntry->DirOpenReferenceCount);
- if( RootPathName->Buffer != uniFullPathName.Buffer)
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement7 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &pParentDirEntry->NameInformation.FileName,
+ pParentDirEntry,
+ NULL,
+ lCount));
- AFSExFreePool( uniFullPathName.Buffer);
- }
+ ASSERT( lCount >= 0);
}
- else
+
+ if( bReleaseCurrentVolume)
{
- if( *ParentDirectoryCB != NULL)
- {
+ ASSERT( pCurrentVolume->VolumeReferenceCount > 0);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Count on Parent %wZ DE %p Ccb %p Cnt %d\n",
- &(*ParentDirectoryCB)->NameInformation.FileName,
- *ParentDirectoryCB,
- NULL,
- (*ParentDirectoryCB)->OpenReferenceCount);
- }
+ lCount = AFSVolumeDecrement( pCurrentVolume,
+ VolumeReferenceReason);
- if( *DirectoryCB != NULL)
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLocateNameEntry Decrement7 count on volume %p Reason %u Cnt %d\n",
+ pCurrentVolume,
+ VolumeReferenceReason,
+ lCount));
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSLocateNameEntry Count on %wZ DE %p Ccb %p Cnt %d\n",
- &(*DirectoryCB)->NameInformation.FileName,
- *DirectoryCB,
- NULL,
- (*DirectoryCB)->OpenReferenceCount);
- }
+ bReleaseCurrentVolume = FALSE;
}
if( bSubstituteName &&
uniSearchName.Buffer != NULL)
{
- AFSExFreePool( uniSearchName.Buffer);
+ AFSExFreePoolWithTag( uniSearchName.Buffer, 0);
}
}
IN OUT AFSDirectoryCB **DirEntry)
{
+ UNREFERENCED_PARAMETER(FileName);
NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSDirectoryCB *pDirNode = NULL;
- UNICODE_STRING uniShortName;
+ AFSDirectoryCB *pDirNode = NULL, *pExistingDirNode = NULL;
LARGE_INTEGER liFileSize = {0,0};
+ LONG lCount;
__Enter
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSCreateDirEntry Creating dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX\n",
&ParentDirCB->NameInformation.FileName,
ParentObjectInfo->FileId.Vnode,
ParentObjectInfo->FileId.Unique,
ComponentName,
- Attributes);
+ Attributes));
//
// OK, before inserting the node into the parent tree, issue
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCreateDirEntry Failed to create dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ Attribs %08lX Status %08lX\n",
&ParentDirCB->NameInformation.FileName,
ParentObjectInfo->FileId.Unique,
ComponentName,
Attributes,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSCreateDirEntry Inserting dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ\n",
- &ParentDirCB->NameInformation.FileName,
- ParentObjectInfo->FileId.Cell,
- ParentObjectInfo->FileId.Volume,
- ParentObjectInfo->FileId.Vnode,
- ParentObjectInfo->FileId.Unique,
- ComponentName);
+ //
+ // If AFSNotifyFileCreate returns pDirNode != NULL, then its
+ // DirOpenReferenceCount is held.
+ //
+
+ AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
+
+ //
+ // Before attempting to insert the new entry, check if we need to validate the parent
+ //
+
+ if( BooleanFlagOn( ParentObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCreateDirEntry Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ &ParentDirCB->NameInformation.FileName,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique));
+
+ ntStatus = AFSVerifyEntry( AuthGroup,
+ ParentDirCB,
+ FALSE);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCreateDirEntry Failed to verify parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ &ParentDirCB->NameInformation.FileName,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique,
+ ntStatus));
+
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ try_return( ntStatus);
+ }
+ }
+
+ //
+ // Check for the entry in the event we raced with some other thread
+ //
+
+ AFSLocateCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
+ (ULONG)pDirNode->CaseSensitiveTreeEntry.HashIndex,
+ &pExistingDirNode);
+
+ if( pExistingDirNode != NULL)
+ {
+ if (AFSIsEqualFID( &pDirNode->ObjectInformation->FileId,
+ &pExistingDirNode->ObjectInformation->FileId))
+ {
+
+ if ( pExistingDirNode != pDirNode)
+ {
+
+ lCount = InterlockedDecrement( &pDirNode->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCreateDirEntry Decrement count on %wZ DE %p Cnt %d\n",
+ &pDirNode->NameInformation.FileName,
+ pDirNode,
+ lCount));
+
+ AFSDeleteDirEntry( ParentObjectInfo,
+ &pDirNode);
+
+ lCount = InterlockedIncrement( &pExistingDirNode->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCreateDirEntry Increment count on %wZ DE %p Cnt %d\n",
+ &pExistingDirNode->NameInformation.FileName,
+ pExistingDirNode,
+ lCount));
+
+ *DirEntry = pExistingDirNode;
+ }
+
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ try_return( ntStatus = STATUS_SUCCESS);
+ }
+ else
+ {
+
+ //
+ // Need to tear down this entry and rebuild it below
+ //
+
+ if( pExistingDirNode->DirOpenReferenceCount <= 0 &&
+ pExistingDirNode->NameArrayReferenceCount <= 0)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCreateDirEntry Different FIDs - Deleting DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pExistingDirNode,
+ &pExistingDirNode->NameInformation.FileName,
+ pExistingDirNode->ObjectInformation->FileId.Cell,
+ pExistingDirNode->ObjectInformation->FileId.Volume,
+ pExistingDirNode->ObjectInformation->FileId.Vnode,
+ pExistingDirNode->ObjectInformation->FileId.Unique,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique));
+
+ AFSDeleteDirEntry( ParentObjectInfo,
+ &pExistingDirNode);
+ }
+ else
+ {
+
+ SetFlag( pExistingDirNode->Flags, AFS_DIR_ENTRY_DELETED);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCreateDirEntry Different FIDs - Removing DE %p for %wZ Old FID %08lX-%08lX-%08lX-%08lX New FID %08lX-%08lX-%08lX-%08lX\n",
+ pExistingDirNode,
+ &pExistingDirNode->NameInformation.FileName,
+ pExistingDirNode->ObjectInformation->FileId.Cell,
+ pExistingDirNode->ObjectInformation->FileId.Volume,
+ pExistingDirNode->ObjectInformation->FileId.Vnode,
+ pExistingDirNode->ObjectInformation->FileId.Unique,
+ pDirNode->ObjectInformation->FileId.Cell,
+ pDirNode->ObjectInformation->FileId.Volume,
+ pDirNode->ObjectInformation->FileId.Vnode,
+ pDirNode->ObjectInformation->FileId.Unique));
+
+ AFSRemoveNameEntry( ParentObjectInfo,
+ pExistingDirNode);
+ }
+ }
+ }
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSCreateDirEntry Inserting dir entry in parent %wZ FID %08lX-%08lX-%08lX-%08lX Component %wZ\n",
+ &ParentDirCB->NameInformation.FileName,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique,
+ ComponentName));
//
// Insert the directory node
*DirEntry = pDirNode;
+ AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
+
try_exit:
NOTHING;
IN BOOLEAN InsertInEnumList)
{
+ LONG lCount;
+
__Enter
{
- AFSAcquireExcl( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock,
- TRUE);
+ ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
//
// Insert the node into the directory node tree
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Insert DE %p for %wZ Clearing NOT_IN flag\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead = DirEntry;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Insert DE %p to head of case sensitive tree for %wZ\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
}
else
{
AFSInsertCaseSensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseSensitiveTreeHead,
DirEntry);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Insert DE %p to case sensitive tree for %wZ\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
}
if( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead == NULL)
SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_CASE_INSENSTIVE_LIST_HEAD);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Insert DE %p to head of case insensitive tree for %wZ\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
}
else
{
AFSInsertCaseInsensitiveDirEntry( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.CaseInsensitiveTreeHead,
DirEntry);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Insert DE %p to case insensitive tree for %wZ\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
}
//
ParentObjectInfo->Specific.Directory.ShortNameTree = DirEntry;
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Insert DE %p to head of shortname tree for %wZ\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
+
+ SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
}
else
{
- AFSInsertShortNameDirEntry( ParentObjectInfo->Specific.Directory.ShortNameTree,
- DirEntry);
+ if( !NT_SUCCESS( AFSInsertShortNameDirEntry( ParentObjectInfo->Specific.Directory.ShortNameTree,
+ DirEntry)))
+ {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInsertDirectoryNode Failed to insert DE %p to shortname tree for %wZ\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName));
+ }
+ else
+ {
+ SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_SHORT_NAME);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSInsertDirectoryNode Insert DE %p to shortname tree for %wZ\n",
- DirEntry,
- &DirEntry->NameInformation.FileName);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSInsertDirectoryNode Insert DE %p to shortname tree for %wZ\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName));
+ }
}
}
// And insert the node into the directory list
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSInsertDirectoryNode Inserting entry %08lX %wZ FID %08lX-%08lX-%08lX-%08lXStatus %08lX\n",
+ "AFSInsertDirectoryNode Inserting entry %p %wZ FID %08lX-%08lX-%08lX-%08lX\n",
DirEntry,
&DirEntry->NameInformation.FileName,
DirEntry->ObjectInformation->FileId.Cell,
DirEntry->ObjectInformation->FileId.Volume,
DirEntry->ObjectInformation->FileId.Vnode,
- DirEntry->ObjectInformation->FileId.Unique);
+ DirEntry->ObjectInformation->FileId.Unique));
if( ParentObjectInfo->Specific.Directory.DirectoryNodeListHead == NULL)
{
SetFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
- InterlockedIncrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
+ lCount = InterlockedIncrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIR_NODE_COUNT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSInsertDirectoryNode Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
- &DirEntry->NameInformation.FileName,
- ParentObjectInfo->Specific.Directory.DirectoryNodeCount,
- ParentObjectInfo->FileId.Cell,
- ParentObjectInfo->FileId.Volume,
- ParentObjectInfo->FileId.Vnode,
- ParentObjectInfo->FileId.Unique);
+ &DirEntry->NameInformation.FileName,
+ lCount,
+ ParentObjectInfo->FileId.Cell,
+ ParentObjectInfo->FileId.Volume,
+ ParentObjectInfo->FileId.Vnode,
+ ParentObjectInfo->FileId.Unique));
}
-
- AFSReleaseResource( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock);
}
return;
}
-NTSTATUS
+void
AFSDeleteDirEntry( IN AFSObjectInfoCB *ParentObjectInfo,
- IN AFSDirectoryCB *DirEntry)
+ IN AFSDirectoryCB **ppDirEntry)
{
- NTSTATUS ntStatus = STATUS_SUCCESS;
+ LONG lCount;
+ AFSDirectoryCB *pDirEntry;
__Enter
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ pDirEntry = (AFSDirectoryCB *) InterlockedCompareExchangePointer( (PVOID *)ppDirEntry,
+ NULL,
+ *ppDirEntry);
+
+ if ( pDirEntry == NULL)
+ {
+
+ try_return( NOTHING);
+ }
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING | AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSDeleteDirEntry Deleting dir entry in parent %08lX Entry %08lX %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ "AFSDeleteDirEntry Deleting dir entry in parent %p Entry %p object %p %wZ RefCount %d\n",
ParentObjectInfo,
- DirEntry,
- &DirEntry->NameInformation.FileName,
- DirEntry->ObjectInformation->FileId.Cell,
- DirEntry->ObjectInformation->FileId.Volume,
- DirEntry->ObjectInformation->FileId.Vnode,
- DirEntry->ObjectInformation->FileId.Unique);
+ pDirEntry,
+ pDirEntry->ObjectInformation,
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry->DirOpenReferenceCount));
+
+ ASSERT( pDirEntry->DirOpenReferenceCount == 0);
AFSRemoveDirNodeFromParent( ParentObjectInfo,
- DirEntry,
+ pDirEntry,
TRUE);
//
// Free up the name buffer if it was reallocated
//
- if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
+ if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_RELEASE_NAME_BUFFER))
{
- AFSExFreePool( DirEntry->NameInformation.FileName.Buffer);
+ AFSExFreePoolWithTag( pDirEntry->NameInformation.FileName.Buffer, 0);
}
- if( BooleanFlagOn( DirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
+ if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_RELEASE_TARGET_NAME_BUFFER))
{
- AFSExFreePool( DirEntry->NameInformation.TargetName.Buffer);
+ AFSExFreePoolWithTag( pDirEntry->NameInformation.TargetName.Buffer, 0);
}
- //
- // Dereference the object for this dir entry
- //
+ if ( pDirEntry->ObjectInformation != NULL)
+ {
- ASSERT( DirEntry->ObjectInformation->ObjectReferenceCount > 0);
+ if( BooleanFlagOn( pDirEntry->Flags, AFS_DIR_ENTRY_DELETED) &&
+ pDirEntry->ObjectInformation->Links == 0)
+ {
- InterlockedDecrement( &DirEntry->ObjectInformation->ObjectReferenceCount);
+ SetFlag( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED);
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSDeleteDirEntry Decrement count on object %08lX Cnt %d\n",
- DirEntry->ObjectInformation,
- DirEntry->ObjectInformation->ObjectReferenceCount);
+ //
+ // Dereference the object for this dir entry
+ //
- ExDeleteResourceLite( &DirEntry->NonPaged->Lock);
+ AFSAcquireShared( pDirEntry->ObjectInformation->VolumeCB->ObjectInfoTree.TreeLock,
+ TRUE);
+
+ lCount = AFSObjectInfoDecrement( pDirEntry->ObjectInformation,
+ AFS_OBJECT_REFERENCE_DIRENTRY);
- AFSExFreePool( DirEntry->NonPaged);
+ AFSDbgTrace(( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSDeleteDirEntry Decrement count on object %p Cnt %d\n",
+ pDirEntry->ObjectInformation,
+ lCount));
+
+ AFSReleaseResource( pDirEntry->ObjectInformation->VolumeCB->ObjectInfoTree.TreeLock);
+ }
+
+ ExDeleteResourceLite( &pDirEntry->NonPaged->Lock);
+
+ AFSExFreePoolWithTag( pDirEntry->NonPaged, AFS_DIR_ENTRY_NP_TAG);
//
// Free up the dir entry
//
- AFSExFreePool( DirEntry);
- }
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_ALLOCATION,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSDeleteDirEntry AFS_DIR_ENTRY_TAG deallocating %p\n",
+ pDirEntry));
- return ntStatus;
+ AFSExFreePoolWithTag( pDirEntry, AFS_DIR_ENTRY_TAG);
+
+try_exit:
+
+ NOTHING;
+ }
}
NTSTATUS
{
NTSTATUS ntStatus = STATUS_SUCCESS;
+ LONG lCount;
__Enter
{
ASSERT( ExIsResourceAcquiredExclusiveLite( ParentObjectInfo->Specific.Directory.DirectoryNodeHdr.TreeLock));
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRemoveDirNodeFromParent Removing DirEntry %08lX %wZ FID %08lX-%08lX-%08lX-%08lX from Parent %08lX\n",
- DirEntry,
- &DirEntry->NameInformation.FileName,
- DirEntry->ObjectInformation->FileId.Cell,
- DirEntry->ObjectInformation->FileId.Volume,
- DirEntry->ObjectInformation->FileId.Vnode,
- DirEntry->ObjectInformation->FileId.Unique,
- ParentObjectInfo);
+ if ( DirEntry->ObjectInformation != NULL)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveDirNodeFromParent Removing DirEntry %p %wZ FID %08lX-%08lX-%08lX-%08lX from Parent %p\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName,
+ DirEntry->ObjectInformation->FileId.Cell,
+ DirEntry->ObjectInformation->FileId.Volume,
+ DirEntry->ObjectInformation->FileId.Vnode,
+ DirEntry->ObjectInformation->FileId.Unique,
+ ParentObjectInfo));
+ }
+ else
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRemoveDirNodeFromParent Removing DirEntry %p %wZ from Parent %p\n",
+ DirEntry,
+ &DirEntry->NameInformation.FileName,
+ ParentObjectInfo));
+ }
if( !BooleanFlagOn( DirEntry->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSRemoveDirNodeFromParent Removing DirEntry %08lX name %wZ\n",
+ "AFSRemoveDirNodeFromParent Removing DirEntry %p name %wZ\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
AFSRemoveNameEntry( ParentObjectInfo,
DirEntry);
else
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_CLEANUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveDirNodeFromParent DE %p for %wZ NOT removing entry due to flag set\n",
DirEntry,
- &DirEntry->NameInformation.FileName);
+ &DirEntry->NameInformation.FileName));
}
ASSERT( ParentObjectInfo->Specific.Directory.DirectoryNodeCount > 0);
- InterlockedDecrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
+ lCount = InterlockedDecrement( &ParentObjectInfo->Specific.Directory.DirectoryNodeCount);
ClearFlag( DirEntry->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIR_NODE_COUNT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRemoveDirNodeFromParent Removing entry %wZ Dec Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
&DirEntry->NameInformation.FileName,
- ParentObjectInfo->Specific.Directory.DirectoryNodeCount,
+ lCount,
ParentObjectInfo->FileId.Cell,
ParentObjectInfo->FileId.Volume,
ParentObjectInfo->FileId.Vnode,
- ParentObjectInfo->FileId.Unique);
+ ParentObjectInfo->FileId.Unique));
DirEntry->ListEntry.fLink = NULL;
DirEntry->ListEntry.bLink = NULL;
return ntStatus;
}
-NTSTATUS
-AFSParseName( IN PIRP Irp,
- IN GUID *AuthGroup,
- OUT PUNICODE_STRING FileName,
- OUT PUNICODE_STRING ParsedFileName,
- OUT PUNICODE_STRING RootFileName,
- OUT ULONG *ParseFlags,
- OUT AFSVolumeCB **VolumeCB,
- OUT AFSDirectoryCB **ParentDirectoryCB,
- OUT AFSNameArrayHdr **NameArray)
+static NTSTATUS
+AFSParseRelatedName( IN PIRP Irp,
+ IN GUID *AuthGroup,
+ OUT PUNICODE_STRING FileName,
+ OUT PUNICODE_STRING ParsedFileName,
+ OUT PUNICODE_STRING RootFileName,
+ OUT ULONG *ParseFlags,
+ OUT AFSVolumeCB **VolumeCB,
+ OUT AFSDirectoryCB **ParentDirectoryCB,
+ OUT AFSNameArrayHdr **NameArray)
{
-
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
- UNICODE_STRING uniFullName, uniComponentName, uniRemainingPath;
- ULONG ulCRC = 0;
- AFSDirectoryCB *pDirEntry = NULL, *pShareDirEntry = NULL, *pTargetDirEntry = NULL;
- USHORT usIndex = 0, usDriveIndex = 0;
AFSCcb *pRelatedCcb = NULL;
- AFSNameArrayHdr *pNameArray = NULL, *pRelatedNameArray = NULL;
+ AFSFcb *pRelatedFcb = NULL;
+ AFSNameArrayHdr *pRelatedNameArray = NULL;
+ UNICODE_STRING uniFullName;
+ AFSDirectoryCB *pDirEntry = NULL;
+ AFSNameArrayHdr *pNameArray = NULL;
USHORT usComponentIndex = 0;
USHORT usComponentLength = 0;
AFSVolumeCB *pVolumeCB = NULL;
- AFSFcb *pRelatedFcb = NULL;
- BOOLEAN bReleaseTreeLock = FALSE;
- BOOLEAN bIsAllShare = FALSE;
+ LONG lCount;
- __Enter
- {
+ __Enter
+ {
- //
- // Indicate we are opening a root ...
- //
+ pRelatedFcb = (AFSFcb *)pIrpSp->FileObject->RelatedFileObject->FsContext;
- *ParseFlags = AFS_PARSE_FLAG_ROOT_ACCESS;
+ pRelatedCcb = (AFSCcb *)pIrpSp->FileObject->RelatedFileObject->FsContext2;
- if( pIrpSp->FileObject->RelatedFileObject != NULL)
- {
+ pRelatedNameArray = pRelatedCcb->NameArray;
- pRelatedFcb = (AFSFcb *)pIrpSp->FileObject->RelatedFileObject->FsContext;
+ uniFullName = pIrpSp->FileObject->FileName;
- pRelatedCcb = (AFSCcb *)pIrpSp->FileObject->RelatedFileObject->FsContext2;
+ ASSERT( pRelatedFcb != NULL);
- pRelatedNameArray = pRelatedCcb->NameArray;
+ //
+ // On error, FileName indicates the path on which the failure occurred.
+ //
- uniFullName = pIrpSp->FileObject->FileName;
+ *FileName = pRelatedCcb->FullFileName;
- ASSERT( pRelatedFcb != NULL);
+ //
+ // No wild cards in the name
+ //
- //
- // No wild cards in the name
- //
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSParseRelatedName (%p) %wZ FID %08lX-%08lX-%08lX-%08lX %wZ\n",
+ Irp,
+ &pRelatedCcb->DirectoryCB->NameInformation.FileName,
+ pRelatedFcb->ObjectInformation->FileId.Cell,
+ pRelatedFcb->ObjectInformation->FileId.Volume,
+ pRelatedFcb->ObjectInformation->FileId.Vnode,
+ pRelatedFcb->ObjectInformation->FileId.Unique,
+ &pRelatedCcb->FullFileName));
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Relative open for %wZ FID %08lX-%08lX-%08lX-%08lX component %wZ\n",
- Irp,
- &pRelatedCcb->DirectoryCB->NameInformation.FileName,
- pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Cell,
- pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Volume,
- pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
- pRelatedCcb->DirectoryCB->ObjectInformation->FileId.Unique,
- &uniFullName);
-
- if( FsRtlDoesNameContainWildCards( &uniFullName))
- {
+ if( FsRtlDoesNameContainWildCards( &pRelatedCcb->FullFileName))
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Component %wZ contains wild cards\n",
- Irp,
- &uniFullName);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSParseNameRelated (%p) Component %wZ contains wild cards\n",
+ Irp,
+ &pRelatedCcb->FullFileName));
- try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
- }
+ try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
+ }
- pVolumeCB = pRelatedFcb->ObjectInformation->VolumeCB;
+ pVolumeCB = pRelatedFcb->ObjectInformation->VolumeCB;
- pDirEntry = pRelatedCcb->DirectoryCB;
+ pDirEntry = pRelatedCcb->DirectoryCB;
- *FileName = pIrpSp->FileObject->FileName;
+ //
+ // Grab the root node while checking state
+ //
- //
- // Grab the root node exclusive before returning
- //
+ AFSAcquireShared( pVolumeCB->VolumeLock,
+ TRUE);
- AFSAcquireExcl( pVolumeCB->VolumeLock,
- TRUE);
+ if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
+ BooleanFlagOn( pVolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE))
+ {
- if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
- BooleanFlagOn( pVolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE))
- {
+ //
+ // The volume has been taken off line so fail the access
+ //
- //
- // The volume has been taken off line so fail the access
- //
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSParseNameRelated (%p) Volume %08lX:%08lX OFFLINE/INVALID\n",
+ Irp,
+ pVolumeCB->ObjectInformation.FileId.Cell,
+ pVolumeCB->ObjectInformation.FileId.Volume));
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Volume %08lX:%08lX OFFLINE/INVALID\n",
- Irp,
- pVolumeCB->ObjectInformation.FileId.Cell,
- pVolumeCB->ObjectInformation.FileId.Volume);
+ AFSReleaseResource( pVolumeCB->VolumeLock);
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ try_return( ntStatus = STATUS_DEVICE_NOT_READY);
+ }
- try_return( ntStatus = STATUS_DEVICE_NOT_READY);
- }
+ if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
+ {
- if( BooleanFlagOn( pVolumeCB->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated (%p) Verifying root of volume %08lX:%08lX\n",
+ Irp,
+ pVolumeCB->ObjectInformation.FileId.Cell,
+ pVolumeCB->ObjectInformation.FileId.Volume));
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Verifying root of volume %08lX:%08lX\n",
- Irp,
- pVolumeCB->ObjectInformation.FileId.Cell,
- pVolumeCB->ObjectInformation.FileId.Volume);
+ ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
+ pVolumeCB);
- ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
- pVolumeCB);
+ if( !NT_SUCCESS( ntStatus))
+ {
- if( !NT_SUCCESS( ntStatus))
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSParseNameRelated (%p) Failed verification of root Status %08lX\n",
+ Irp,
+ ntStatus));
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Failed verification of root Status %08lX\n",
- Irp,
- ntStatus);
+ AFSReleaseResource( pVolumeCB->VolumeLock);
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ try_return( ntStatus);
+ }
+ }
- try_return( ntStatus);
- }
- }
+ AFSReleaseResource( pVolumeCB->VolumeLock);
- AFSConvertToShared( pVolumeCB->VolumeLock);
+ if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
+ {
- if( BooleanFlagOn( pDirEntry->ObjectInformation->Flags, AFS_OBJECT_FLAGS_VERIFY))
- {
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated (%p) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
+ Irp,
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry->ObjectInformation->FileId.Cell,
+ pDirEntry->ObjectInformation->FileId.Volume,
+ pDirEntry->ObjectInformation->FileId.Vnode,
+ pDirEntry->ObjectInformation->FileId.Unique));
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Verifying parent %wZ FID %08lX-%08lX-%08lX-%08lX\n",
- Irp,
- &pDirEntry->NameInformation.FileName,
- pDirEntry->ObjectInformation->FileId.Cell,
- pDirEntry->ObjectInformation->FileId.Volume,
- pDirEntry->ObjectInformation->FileId.Vnode,
- pDirEntry->ObjectInformation->FileId.Unique);
+ //
+ // Directory TreeLock should be exclusively held
+ //
- ntStatus = AFSVerifyEntry( AuthGroup,
- pDirEntry);
+ AFSAcquireExcl( pDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock,
+ TRUE);
- if( !NT_SUCCESS( ntStatus))
- {
+ ntStatus = AFSVerifyEntry( AuthGroup,
+ pDirEntry,
+ FALSE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Failed verification of parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
- Irp,
- &pDirEntry->NameInformation.FileName,
- pDirEntry->ObjectInformation->FileId.Cell,
- pDirEntry->ObjectInformation->FileId.Volume,
- pDirEntry->ObjectInformation->FileId.Vnode,
- pDirEntry->ObjectInformation->FileId.Unique,
- ntStatus);
+ AFSReleaseResource( pDirEntry->ObjectInformation->Specific.Directory.DirectoryNodeHdr.TreeLock);
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ if( !NT_SUCCESS( ntStatus))
+ {
- try_return( ntStatus);
- }
- }
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated (%p) Failed verification of parent %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ Irp,
+ &pDirEntry->NameInformation.FileName,
+ pDirEntry->ObjectInformation->FileId.Cell,
+ pDirEntry->ObjectInformation->FileId.Volume,
+ pDirEntry->ObjectInformation->FileId.Vnode,
+ pDirEntry->ObjectInformation->FileId.Unique,
+ ntStatus));
- //
- // Create our full path name buffer
- //
+ try_return( ntStatus);
+ }
+ }
- uniFullName.MaximumLength = pRelatedCcb->FullFileName.Length +
- sizeof( WCHAR) +
- pIrpSp->FileObject->FileName.Length +
- sizeof( WCHAR);
+ //
+ // Create our full path name buffer
+ //
- uniFullName.Length = 0;
+ uniFullName.MaximumLength = pRelatedCcb->FullFileName.Length
+ + sizeof( WCHAR) + pIrpSp->FileObject->FileName.Length
+ + sizeof( WCHAR);
- uniFullName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
- uniFullName.MaximumLength,
- AFS_NAME_BUFFER_THREE_TAG);
+ uniFullName.Length = 0;
- if( uniFullName.Buffer == NULL)
- {
+ uniFullName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
+ uniFullName.MaximumLength,
+ AFS_NAME_BUFFER_THREE_TAG);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Failed to allocate full name buffer\n",
- Irp);
+ if( uniFullName.Buffer == NULL)
+ {
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSParseNameRelated (%p) Failed to allocate full name buffer\n",
+ Irp));
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
- RtlZeroMemory( uniFullName.Buffer,
- uniFullName.MaximumLength);
+ SetFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
- RtlCopyMemory( uniFullName.Buffer,
- pRelatedCcb->FullFileName.Buffer,
- pRelatedCcb->FullFileName.Length);
+ RtlZeroMemory( uniFullName.Buffer,
+ uniFullName.MaximumLength);
- uniFullName.Length = pRelatedCcb->FullFileName.Length;
+ RtlCopyMemory( uniFullName.Buffer,
+ pRelatedCcb->FullFileName.Buffer,
+ pRelatedCcb->FullFileName.Length);
- usComponentIndex = (USHORT)(uniFullName.Length/sizeof( WCHAR));
+ uniFullName.Length = pRelatedCcb->FullFileName.Length;
- usComponentLength = pIrpSp->FileObject->FileName.Length;
+ usComponentIndex = (USHORT)(uniFullName.Length/sizeof( WCHAR));
- if( uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
- pIrpSp->FileObject->FileName.Length > 0 &&
- pIrpSp->FileObject->FileName.Buffer[ 0] != L'\\' &&
- pIrpSp->FileObject->FileName.Buffer[ 0] != L':')
- {
+ usComponentLength = pIrpSp->FileObject->FileName.Length;
- uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR))] = L'\\';
+ if( uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
+ pIrpSp->FileObject->FileName.Length > 0 &&
+ pIrpSp->FileObject->FileName.Buffer[ 0] != L'\\' &&
+ pIrpSp->FileObject->FileName.Buffer[ 0] != L':')
+ {
- uniFullName.Length += sizeof( WCHAR);
+ uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR))] = L'\\';
- usComponentLength += sizeof( WCHAR);
- }
+ uniFullName.Length += sizeof( WCHAR);
- if( pIrpSp->FileObject->FileName.Length > 0)
- {
+ usComponentLength += sizeof( WCHAR);
+ }
- RtlCopyMemory( &uniFullName.Buffer[ uniFullName.Length/sizeof( WCHAR)],
- pIrpSp->FileObject->FileName.Buffer,
- pIr\epSp->FileObject->FileName.Length);
+ if( pIrpSp->FileObject->FileName.Length > 0)
+ {
- uniFullName.Length += pIrpSp->FileObject->FileName.Length;
- }
+ RtlCopyMemory( &uniFullName.Buffer[ uniFullName.Length/sizeof( WCHAR)],
+ pIrpSp->FileObject->FileName.Buffer,
+ pIrpSp->FileObject->FileName.Length);
- *RootFileName = uniFullName;
+ uniFullName.Length += pIrpSp->FileObject->FileName.Length;
+ }
- //
- // We populate up to the current parent
- //
+ *RootFileName = uniFullName;
- if( pRelatedNameArray == NULL)
- {
+ //
+ // We populate up to the current parent
+ //
- //
- // Init and populate our name array
- //
+ if( pRelatedNameArray == NULL)
+ {
- pNameArray = AFSInitNameArray( NULL,
- 0);
+ //
+ // Init and populate our name array
+ //
- if( pNameArray == NULL)
- {
+ pNameArray = AFSInitNameArray( NULL,
+ 0);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Failed to initialize name array\n",
- Irp);
+ if( pNameArray == NULL)
+ {
- AFSExFreePool( uniFullName.Buffer);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated (%p) Failed to initialize name array\n",
+ Irp));
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ AFSExFreePoolWithTag( uniFullName.Buffer, 0);
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
+ ClearFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
- ntStatus = AFSPopulateNameArray( pNameArray,
- NULL,
- pRelatedCcb->DirectoryCB);
- }
- else
- {
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
- //
- // Init and populate our name array
- //
+ ntStatus = AFSPopulateNameArray( pNameArray,
+ NULL,
+ pRelatedCcb->DirectoryCB);
+ }
+ else
+ {
- pNameArray = AFSInitNameArray( NULL,
- pRelatedNameArray->MaxElementCount);
+ //
+ // Init and populate our name array
+ //
- if( pNameArray == NULL)
- {
+ pNameArray = AFSInitNameArray( NULL,
+ pRelatedNameArray->MaxElementCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Failed to initialize name array\n",
- Irp);
+ if( pNameArray == NULL)
+ {
- AFSExFreePool( uniFullName.Buffer);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated (%p) Failed to initialize name array\n",
+ Irp));
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ AFSExFreePoolWithTag( uniFullName.Buffer, 0);
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
+ ClearFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
- ntStatus = AFSPopulateNameArrayFromRelatedArray( pNameArray,
- pRelatedNameArray,
- pRelatedCcb->DirectoryCB);
- }
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
- if( !NT_SUCCESS( ntStatus))
- {
+ ntStatus = AFSPopulateNameArrayFromRelatedArray( pNameArray,
+ pRelatedNameArray,
+ pRelatedCcb->DirectoryCB);
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Failed to populate name array\n",
- Irp);
+ if( !NT_SUCCESS( ntStatus))
+ {
- AFSExFreePool( uniFullName.Buffer);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated (%p) Failed to populate name array\n",
+ Irp));
- AFSReleaseResource( pVolumeCB->VolumeLock);
+ AFSExFreePoolWithTag( uniFullName.Buffer, 0);
- try_return( ntStatus);
- }
+ ClearFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
- ParsedFileName->Length = usComponentLength;
- ParsedFileName->MaximumLength = uniFullName.MaximumLength;
+ try_return( ntStatus);
+ }
- ParsedFileName->Buffer = &uniFullName.Buffer[ usComponentIndex];
+ ParsedFileName->Length = usComponentLength;
- //
- // Indicate to caller that RootFileName must be freed
- //
+ ParsedFileName->MaximumLength = uniFullName.MaximumLength;
- SetFlag( *ParseFlags, AFS_PARSE_FLAG_FREE_FILE_BUFFER);
+ ParsedFileName->Buffer = &uniFullName.Buffer[ usComponentIndex];
- *NameArray = pNameArray;
+ *NameArray = pNameArray;
- *VolumeCB = pVolumeCB;
+ //
+ // Increment our volume reference count
+ //
- //
- // Increment our volume reference count
- //
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_PARSE_NAME);
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseNameRelated Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount));
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName Increment count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ *VolumeCB = pVolumeCB;
- *ParentDirectoryCB = pDirEntry;
+ *ParentDirectoryCB = pDirEntry;
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
+ "AFSParseNameRelated (%p) Returning full name %wZ\n",
+ Irp,
+ &uniFullName));
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirEntry->NameInformation.FileName,
- pDirEntry,
- NULL,
- pDirEntry->OpenReferenceCount);
+ try_return( ntStatus);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Returning full name %wZ\n",
- Irp,
- &uniFullName);
+try_exit:
+
+ if( NT_SUCCESS( ntStatus))
+ {
+
+ if( *ParentDirectoryCB != NULL)
+ {
+
+ lCount = InterlockedIncrement( &(*ParentDirectoryCB)->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseRelatedName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
+ &(*ParentDirectoryCB)->NameInformation.FileName,
+ (*ParentDirectoryCB),
+ NULL,
+ lCount));
+ }
+ }
+
+ if( *VolumeCB != NULL)
+ {
+ ASSERT( (*VolumeCB)->VolumeReferenceCount > 0);
+ }
+
+ if( ntStatus != STATUS_SUCCESS)
+ {
+
+ if( pNameArray != NULL)
+ {
+
+ AFSFreeNameArray( pNameArray);
+ }
+ }
+ }
+
+ return ntStatus;
+}
+
+NTSTATUS
+AFSParseName( IN PIRP Irp,
+ IN GUID *AuthGroup,
+ OUT PUNICODE_STRING FileName,
+ OUT PUNICODE_STRING ParsedFileName,
+ OUT PUNICODE_STRING RootFileName,
+ OUT ULONG *ParseFlags,
+ OUT AFSVolumeCB **VolumeCB,
+ OUT AFSDirectoryCB **ParentDirectoryCB,
+ OUT AFSNameArrayHdr **NameArray)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
+ AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
+ UNICODE_STRING uniFullName, uniComponentName, uniRemainingPath;
+ ULONG ulCRC = 0;
+ AFSDirectoryCB *pDirEntry = NULL;
+ USHORT usIndex = 0, usDriveIndex = 0;
+ AFSNameArrayHdr *pNameArray = NULL;
+ USHORT usComponentIndex = 0;
+ USHORT usComponentLength = 0;
+ AFSVolumeCB *pVolumeCB = NULL;
+ BOOLEAN bReleaseTreeLock = FALSE;
+ BOOLEAN bIsAllShare = FALSE;
+ LONG lCount;
+
+ __Enter
+ {
+
+ if( pIrpSp->FileObject->RelatedFileObject != NULL)
+ {
+
+ return AFSParseRelatedName( Irp, AuthGroup, FileName,
+ ParsedFileName, RootFileName,
+ ParseFlags, VolumeCB,
+ ParentDirectoryCB, NameArray);
+ }
+
+ //
+ // Indicate we are opening a root ...
+ //
+
+ *ParseFlags = AFS_PARSE_FLAG_ROOT_ACCESS;
+
+ *ParentDirectoryCB = NULL;
+
+ //
+ // On error, FileName indicates the path on which the failure occurred
+ //
- try_return( ntStatus);
- }
+ *FileName = pIrpSp->FileObject->FileName;
- //
- // No wild cards in the name
- //
+ //
+ // No wild cards in the name
+ //
uniFullName = pIrpSp->FileObject->FileName;
uniFullName.Length < AFSServerName.Length)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Name %wZ contains wild cards or too short\n",
+ "AFSParseName (%p) Name %wZ contains wild cards or too short\n",
Irp,
- &uniFullName);
+ &uniFullName));
try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
}
TRUE) != 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Name %wZ does not have server name\n",
+ "AFSParseName (%p) Name %wZ does not have server name\n",
Irp,
- &pIrpSp->FileObject->FileName);
+ &pIrpSp->FileObject->FileName));
try_return( ntStatus = STATUS_BAD_NETWORK_NAME);
}
!AFSIsDriveMapped( pIrpSp->FileObject->FileName.Buffer[ usDriveIndex]))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Name %wZ contains invalid drive mapping\n",
+ "AFSParseName (%p) Name %wZ contains invalid drive mapping\n",
Irp,
- &pIrpSp->FileObject->FileName);
+ &pIrpSp->FileObject->FileName));
try_return( ntStatus = STATUS_BAD_NETWORK_NAME);
}
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ if( FsRtlDoesNameContainWildCards( &uniFullName))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSParseName (%p) Component %wZ contains wild cards\n",
+ Irp,
+ &uniFullName));
+
+ try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
+ }
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Processing full name %wZ\n",
+ "AFSParseName (%p) Processing full name %wZ\n",
Irp,
- &uniFullName);
+ &uniFullName));
if( uniFullName.Length > 0 &&
uniFullName.Buffer[ (uniFullName.Length/sizeof( WCHAR)) - 1] == L'\\')
// Be sure we are online and ready to go
//
- AFSAcquireExcl( AFSGlobalRoot->VolumeLock,
- TRUE);
+ AFSAcquireShared( AFSGlobalRoot->VolumeLock,
+ TRUE);
if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
BooleanFlagOn( AFSGlobalRoot->Flags, AFS_VOLUME_FLAGS_OFFLINE))
// The volume has been taken off line so fail the access
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Volume %08lX:%08lX OFFLINE/INVALID\n",
+ "AFSParseName (%p) Volume %08lX:%08lX OFFLINE/INVALID\n",
Irp,
AFSGlobalRoot->ObjectInformation.FileId.Cell,
- AFSGlobalRoot->ObjectInformation.FileId.Volume);
+ AFSGlobalRoot->ObjectInformation.FileId.Volume));
AFSReleaseResource( AFSGlobalRoot->VolumeLock);
if( BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_VERIFY))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Verifying root of volume %08lX:%08lX\n",
+ "AFSParseName (%p) Verifying root of volume %08lX:%08lX\n",
Irp,
AFSGlobalRoot->ObjectInformation.FileId.Cell,
- AFSGlobalRoot->ObjectInformation.FileId.Volume);
+ AFSGlobalRoot->ObjectInformation.FileId.Volume));
ntStatus = AFSVerifyVolume( (ULONGLONG)PsGetCurrentProcessId(),
AFSGlobalRoot);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Failed verification of root Status %08lX\n",
+ "AFSParseName (%p) Failed verification of root Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
AFSReleaseResource( AFSGlobalRoot->VolumeLock);
}
}
+ AFSReleaseResource( AFSGlobalRoot->VolumeLock);
+
if( !BooleanFlagOn( AFSGlobalRoot->ObjectInformation.Flags, AFS_OBJECT_FLAGS_DIRECTORY_ENUMERATED))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Enumerating global root of volume %08lX:%08lX\n",
+ "AFSParseName (%p) Enumerating global root of volume %08lX:%08lX\n",
Irp,
AFSGlobalRoot->ObjectInformation.FileId.Cell,
- AFSGlobalRoot->ObjectInformation.FileId.Volume);
+ AFSGlobalRoot->ObjectInformation.FileId.Volume));
ntStatus = AFSEnumerateGlobalRoot( AuthGroup);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSParseName (%08lX) Failed enumeraiton of root Status %08lX\n",
+ "AFSParseName (%p) Failed enumeraiton of root Status %08lX\n",
Irp,
- ntStatus);
-
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
+ ntStatus));
try_return( ntStatus);
}
}
//
- // Check for the \\Server access and return it as though it where \\Server\Globalroot
+ // Check for the \\Server access and return it as though it were \\Server\Globalroot
//
if( uniRemainingPath.Buffer == NULL ||
uniRemainingPath.Buffer[ 0] == L'\\'))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Returning global root access\n",
- Irp);
+ "AFSParseName (%p) Returning global root access\n",
+ Irp));
- InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSParseName Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
&AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
AFSGlobalRoot->DirectoryCB,
NULL,
- AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
-
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
+ lCount));
*VolumeCB = NULL;
&uniComponentName,
&uniRemainingPath);
+ if( FsRtlDoesNameContainWildCards( &uniFullName))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSParseName (%p) Component %wZ contains wild cards\n",
+ Irp,
+ &uniComponentName));
+
+ try_return( ntStatus = STATUS_OBJECT_NAME_INVALID);
+ }
+
//
// If this is the ALL access then perform some additional processing
//
- if( RtlCompareUnicodeString( &uniComponentName,
+ if( uniComponentName.Length == 0 ||
+ RtlCompareUnicodeString( &uniComponentName,
&AFSGlobalRootName,
TRUE) == 0)
{
uniRemainingPath.Buffer[ 0] == L'\\'))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Returning global root access\n",
- Irp);
+ "AFSParseName (%p) Returning global root access\n",
+ Irp));
- InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSParseName Increment3 count on %wZ DE %p Ccb %p Cnt %d\n",
&AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
AFSGlobalRoot->DirectoryCB,
NULL,
- AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
-
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
+ lCount));
*VolumeCB = NULL;
TRUE) == 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Returning root PIOCtl access\n",
- Irp);
+ "AFSParseName (%p) Returning root PIOCtl access\n",
+ Irp));
- InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedIncrement( &AFSGlobalRoot->DirectoryCB->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSParseName Increment4 count on %wZ DE %p Ccb %p Cnt %d\n",
&AFSGlobalRoot->DirectoryCB->NameInformation.FileName,
AFSGlobalRoot->DirectoryCB,
NULL,
- AFSGlobalRoot->DirectoryCB->OpenReferenceCount);
-
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
+ lCount));
ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
&uniRemainingPath)) != NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
- "AFSParseName (%08lX) Returning root share name %wZ access\n",
+ "AFSParseName (%p) Returning root share name %wZ access\n",
Irp,
- &uniComponentName);
-
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
+ &uniComponentName));
//
// Add in the full share name to pass back
*FileName = uniComponentName;
- *ParentDirectoryCB = pDirEntry;
-
ClearFlag( *ParseFlags, AFS_PARSE_FLAG_ROOT_ACCESS);
- InterlockedIncrement( &pDirEntry->OpenReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName Increment5 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pDirEntry->NameInformation.FileName,
- pDirEntry,
- NULL,
- pDirEntry->OpenReferenceCount);
+ *ParentDirectoryCB = pDirEntry;
try_return( ntStatus = STATUS_SUCCESS);
}
// a lookup in the short name tree
//
- if( RtlIsNameLegalDOS8Dot3( &uniComponentName,
+ if( !BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_DISABLE_SHORTNAMES) &&
+ RtlIsNameLegalDOS8Dot3( &uniComponentName,
NULL,
NULL))
{
if( !NT_SUCCESS( ntStatus))
{
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
if ( bIsAllShare &&
uniRemainingPath.Length == 0 &&
ntStatus == STATUS_OBJECT_PATH_NOT_FOUND)
{
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseName (%p) AFSCheckCellName %wZ returned path not found; ntStatus %08X\n",
+ Irp,
+ &uniComponentName,
+ STATUS_OBJECT_NAME_NOT_FOUND));
+
ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
}
AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
}
+
//
// Be sure we are starting from the correct volume
//
pVolumeCB = pDirEntry->ObjectInformation->VolumeCB;
//
+ // Init our name array
+ //
+
+ pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
+ 0);
+
+ if( pNameArray == NULL)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseName (%p) Failed to initialize name array\n",
+ Irp));
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ ntStatus = AFSInsertNextElement( pNameArray,
+ pVolumeCB->DirectoryCB);
+
+ if ( ntStatus)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseName (%p) Failed to insert name array element\n",
+ Irp));
+
+ try_return( ntStatus);
+ }
+
+ //
// In this case don't add back in the 'share' name since that is where we are
// starting. Just put the leading slash back in
//
//
// This is a root open so pass back no parent
//
-
- *ParentDirectoryCB = NULL;
}
}
else
pVolumeCB = AFSGlobalRoot;
//
+ // Init our name array
+ //
+
+ pNameArray = AFSInitNameArray( AFSGlobalRoot->DirectoryCB,
+ 0);
+ if( pNameArray == NULL)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSParseName (%p) Failed to initialize name array\n",
+ Irp));
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ //
// Add back in the 'share' portion of the name since we will parse it out on return
//
uniRemainingPath.Length += sizeof( WCHAR);
uniRemainingPath.MaximumLength += sizeof( WCHAR);
- InterlockedIncrement( &pVolumeCB->DirectoryCB->OpenReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName Increment6 count on %wZ DE %p Ccb %p Cnt %d\n",
- &pVolumeCB->DirectoryCB->NameInformation.FileName,
- pVolumeCB->DirectoryCB,
- NULL,
- pVolumeCB->DirectoryCB->OpenReferenceCount);
-
//
// Pass back the parent being the volume root
//
}
//
- // We only need the volume shared at this point
- //
-
- AFSConvertToShared( pVolumeCB->VolumeLock);
-
- //
- // Init our name array
- //
-
- pNameArray = AFSInitNameArray( pVolumeCB->DirectoryCB,
- 0);
-
- if( pNameArray == NULL)
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName (%08lX) Failed to initialize name array\n",
- Irp);
-
- AFSReleaseResource( pVolumeCB->VolumeLock);
-
- try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
- }
-
- //
// Return the remaining portion as the file name
//
// Increment our reference on the volume
//
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_PARSE_NAME);
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName Increment2 count on global volume %08lX Cnt %d\n",
+ "AFSParseName Increment2 count on global volume %p Cnt %d\n",
pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ lCount));
try_exit:
if( *ParentDirectoryCB != NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ lCount = InterlockedIncrement( &(*ParentDirectoryCB)->DirOpenReferenceCount);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSParseName Count on %wZ DE %p Ccb %p Cnt %d\n",
+ "AFSParseName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
&(*ParentDirectoryCB)->NameInformation.FileName,
- *ParentDirectoryCB,
+ (*ParentDirectoryCB),
NULL,
- (*ParentDirectoryCB)->OpenReferenceCount);
+ lCount));
}
}
if( *VolumeCB != NULL)
{
-
- ASSERT( (*VolumeCB)->VolumeReferenceCount > 1);
+ ASSERT( (*VolumeCB)->VolumeReferenceCount > 0);
}
if( ntStatus != STATUS_SUCCESS)
NTSTATUS ntStatus = STATUS_SUCCESS;
UNICODE_STRING uniName;
- AFSFileID stFileID;
AFSDirEnumEntry *pDirEnumEntry = NULL;
- AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSDirHdr *pDirHdr = &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr;
AFSDirectoryCB *pDirNode = NULL;
UNICODE_STRING uniDirName, uniTargetName;
AFSVolumeCB *pVolumeCB = NULL;
+ LONG lCount;
__Enter
{
// OK, ask the CM about this component name
//
- stFileID = AFSGlobalRoot->ObjectInformation.FileId;
-
ntStatus = AFSEvaluateTargetByName( AuthGroup,
- &stFileID,
+ &AFSGlobalRoot->ObjectInformation,
CellName,
+ 0,
&pDirEnumEntry);
if( !NT_SUCCESS( ntStatus))
{
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCheckCellName entry %wZ does not exist parent FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ CellName,
+ AFSGlobalRoot->ObjectInformation.FileId.Cell,
+ AFSGlobalRoot->ObjectInformation.FileId.Volume,
+ AFSGlobalRoot->ObjectInformation.FileId.Vnode,
+ AFSGlobalRoot->ObjectInformation.FileId.Unique,
+ ntStatus));
+
try_return( ntStatus);
}
{
//
- // We have the global root on entry so drop it now
- //
-
- AFSReleaseResource( AFSGlobalRoot->VolumeLock);
-
- //
// Build the root volume entry
//
&pDirEnumEntry->FileId,
&pVolumeCB);
+ //
+ // On success returns with a volume reference count held
+ //
+
if( !NT_SUCCESS( ntStatus))
{
-
- //
- // On failure this routine is expecting to hold the global root
- //
-
- AFSAcquireShared( AFSGlobalRoot->VolumeLock,
- TRUE);
-
try_return( ntStatus);
}
*ShareDirEntry = pVolumeCB->DirectoryCB;
- InterlockedIncrement( &pVolumeCB->DirectoryCB->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pVolumeCB->DirectoryCB->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCheckCellName Increment1 count on %wZ DE %p Ccb %p Cnt %d\n",
&pVolumeCB->DirectoryCB->NameInformation.FileName,
pVolumeCB->DirectoryCB,
NULL,
- pVolumeCB->DirectoryCB->OpenReferenceCount);
+ lCount));
+
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_BUILD_ROOT);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCheckCellName Decrement count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount));
}
else
{
+ lCount = InterlockedIncrement( &pDirHdr->ContentIndex);
+
pDirNode = AFSInitDirEntry( &AFSGlobalRoot->ObjectInformation,
&uniDirName,
&uniTargetName,
pDirEnumEntry,
- (ULONG)InterlockedIncrement( &pDirHdr->ContentIndex));
+ (ULONG)lCount);
if( pDirNode == NULL)
{
else
{
- AFSInsertCaseSensitiveDirEntry( pDirHdr->CaseSensitiveTreeHead,
- pDirNode);
+ if( !NT_SUCCESS( AFSInsertCaseSensitiveDirEntry( pDirHdr->CaseSensitiveTreeHead,
+ pDirNode)))
+ {
+
+ AFSDeleteDirEntry( &AFSGlobalRoot->ObjectInformation,
+ &pDirNode);
+
+ AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
}
+ ClearFlag( pDirNode->Flags, AFS_DIR_ENTRY_NOT_IN_PARENT_TREE);
+
if( pDirHdr->CaseInsensitiveTreeHead == NULL)
{
SetFlag( pDirNode->Flags, AFS_DIR_ENTRY_INSERTED_ENUM_LIST);
- InterlockedIncrement( &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeCount);
+ lCount = InterlockedIncrement( &AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIR_NODE_COUNT,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIR_NODE_COUNT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCheckCellName Adding entry %wZ Inc Count %d to parent FID %08lX-%08lX-%08lX-%08lX\n",
- &pDirNode->NameInformation.FileName,
- AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeCount,
- AFSGlobalRoot->ObjectInformation.FileId.Cell,
- AFSGlobalRoot->ObjectInformation.FileId.Volume,
- AFSGlobalRoot->ObjectInformation.FileId.Vnode,
- AFSGlobalRoot->ObjectInformation.FileId.Unique);
+ &pDirNode->NameInformation.FileName,
+ lCount,
+ AFSGlobalRoot->ObjectInformation.FileId.Cell,
+ AFSGlobalRoot->ObjectInformation.FileId.Volume,
+ AFSGlobalRoot->ObjectInformation.FileId.Vnode,
+ AFSGlobalRoot->ObjectInformation.FileId.Unique));
- InterlockedIncrement( &pDirNode->OpenReferenceCount);
+ lCount = InterlockedIncrement( &pDirNode->DirOpenReferenceCount);
- AFSDbgLogMsg( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_DIRENTRY_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCheckCellName Increment2 count on %wZ DE %p Ccb %p Cnt %d\n",
&pDirNode->NameInformation.FileName,
pDirNode,
NULL,
- pDirNode->OpenReferenceCount);
+ lCount));
AFSReleaseResource( AFSGlobalRoot->ObjectInformation.Specific.Directory.DirectoryNodeHdr.TreeLock);
if( pDirEnumEntry != NULL)
{
- AFSExFreePool( pDirEnumEntry);
+ AFSExFreePoolWithTag( pDirEnumEntry, AFS_GENERIC_MEMORY_31_TAG);
}
}
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
AFSDirEnumEntry *pDirEntry = NULL;
- AFSDirectoryCB *pDirNode = NULL;
- UNICODE_STRING uniDirName, uniTargetName;
ULONGLONG ullIndex = 0;
AFSVolumeCB *pVolumeCB = NULL;
AFSFileID stTargetFileID;
+ LONG lCount;
+ BOOLEAN bReleaseVolumeLock = FALSE;
__Enter
{
// Loop on each entry, building the chain until we encounter the final target
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildMountPointTarget Building target directory for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirectoryCB->NameInformation.FileName,
DirectoryCB->ObjectInformation->FileId.Cell,
DirectoryCB->ObjectInformation->FileId.Volume,
DirectoryCB->ObjectInformation->FileId.Vnode,
- DirectoryCB->ObjectInformation->FileId.Unique);
+ DirectoryCB->ObjectInformation->FileId.Unique));
//
// Do we need to evaluate the node?
// Go evaluate the current target to get the target fid
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildMountPointTarget Evaluating target %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirectoryCB->NameInformation.FileName,
DirectoryCB->ObjectInformation->FileId.Cell,
DirectoryCB->ObjectInformation->FileId.Volume,
DirectoryCB->ObjectInformation->FileId.Vnode,
- DirectoryCB->ObjectInformation->FileId.Unique);
+ DirectoryCB->ObjectInformation->FileId.Unique));
ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
AuthGroup,
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSBuildMountPointTarget Failed to evaluate target %wZ Status %08lX\n",
&DirectoryCB->NameInformation.FileName,
- ntStatus);
+ ntStatus));
+
try_return( ntStatus);
}
pDirEntry->TargetFileId.Unique == 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSBuildMountPointTarget Target %wZ FID %08lX-%08lX-%08lX-%08lX service returned zero FID\n",
&DirectoryCB->NameInformation.FileName,
DirectoryCB->ObjectInformation->FileId.Cell,
DirectoryCB->ObjectInformation->FileId.Volume,
DirectoryCB->ObjectInformation->FileId.Vnode,
- DirectoryCB->ObjectInformation->FileId.Unique);
+ DirectoryCB->ObjectInformation->FileId.Unique));
- try_return( ntStatus = STATUS_ACCESS_DENIED);
+ try_return( ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED);
}
AFSAcquireExcl( &DirectoryCB->NonPaged->Lock,
ullIndex = AFSCreateHighIndex( &stTargetFileID);
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSBuildMountPointTarget Acquiring RDR VolumeTreeLock lock %08lX EXCL %08lX\n",
+ "AFSBuildMountPointTarget Acquiring RDR VolumeTreeLock lock %p EXCL %08lX\n",
&pDevExt->Specific.RDR.VolumeTreeLock,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock,
TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildMountPointTarget Locating volume for target %I64X\n",
- ullIndex);
+ ullIndex));
ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
ullIndex,
// Go init the root of the volume
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildMountPointTarget Initializing root for %wZ FID %08lX-%08lX-%08lX-%08lX\n",
&DirectoryCB->NameInformation.FileName,
DirectoryCB->ObjectInformation->FileId.Cell,
DirectoryCB->ObjectInformation->FileId.Volume,
DirectoryCB->ObjectInformation->FileId.Vnode,
- DirectoryCB->ObjectInformation->FileId.Unique);
+ DirectoryCB->ObjectInformation->FileId.Unique));
ntStatus = AFSInitVolume( AuthGroup,
&stTargetFileID,
+ AFS_VOLUME_REFERENCE_MOUNTPT,
&pVolumeCB);
if( !NT_SUCCESS( ntStatus))
try_return( ntStatus);
}
- }
- else
- {
//
- // Check if this volume has been deleted or taken offline
+ // pVolumeCB->VolumeLock held exclusive and
+ // pVolumeCB->VolumeReferenceCount has been incremented
+ // pVolumeCB->RootFcb == NULL
//
- if( BooleanFlagOn( pVolumeCB->Flags, AFS_VOLUME_FLAGS_OFFLINE))
- {
-
- AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
-
- try_return( ntStatus = STATUS_FILE_IS_OFFLINE);
- }
+ bReleaseVolumeLock = TRUE;
+ }
+ else
+ {
//
- // Just to ensure that things don't get torn down AND we don't create a
- // deadlock with invalidation
+ // AFSInitVolume returns with a VolumeReferenceCount
+ // obtain one to match
//
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
-
- AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_MOUNTPT);
- AFSAcquireExcl( pVolumeCB->VolumeLock,
- TRUE);
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSBuildMountPointTarget Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount));
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
}
if( pVolumeCB->RootFcb == NULL)
{
+ if ( bReleaseVolumeLock == FALSE)
+ {
+
+ AFSAcquireExcl( pVolumeCB->VolumeLock,
+ TRUE);
+
+ bReleaseVolumeLock = TRUE;
+ }
+
//
// Initialize the root fcb for this volume
//
if( !NT_SUCCESS( ntStatus))
{
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_MOUNTPT);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSBuildMountPoint Decrement count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount));
+
AFSReleaseResource( pVolumeCB->VolumeLock);
try_return( ntStatus);
AFSReleaseResource( &pVolumeCB->RootFcb->NPFcb->Resource);
}
- AFSConvertToShared( pVolumeCB->VolumeLock);
+ if ( bReleaseVolumeLock == TRUE)
+ {
+
+ AFSReleaseResource( pVolumeCB->VolumeLock);
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildMountPointTarget Evaluated target of %wZ FID %08lX-%08lX-%08lX-%08lX as root volume\n",
&pVolumeCB->DirectoryCB->NameInformation.FileName,
pVolumeCB->ObjectInformation.FileId.Cell,
pVolumeCB->ObjectInformation.FileId.Volume,
pVolumeCB->ObjectInformation.FileId.Vnode,
- pVolumeCB->ObjectInformation.FileId.Unique);
-
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSBuildMountPointTarget Increment count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ pVolumeCB->ObjectInformation.FileId.Unique));
*TargetVolumeCB = pVolumeCB;
if( pDirEntry)
{
- AFSExFreePool( pDirEntry);
+ AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
}
}
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDevExt = (AFSDeviceExt *) AFSRDRDeviceObject->DeviceExtension;
- AFSDirectoryCB *pDirNode = NULL;
- UNICODE_STRING uniDirName, uniTargetName;
ULONGLONG ullIndex = 0;
AFSVolumeCB *pVolumeCB = NULL;
+ LONG lCount;
+ BOOLEAN bReleaseVolumeLock = FALSE;
__Enter
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildRootVolume Building target volume for FID %08lX-%08lX-%08lX-%08lX\n",
FileId->Cell,
FileId->Volume,
FileId->Vnode,
- FileId->Unique);
+ FileId->Unique));
ullIndex = AFSCreateHighIndex( FileId);
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSBuildRootVolume Acquiring RDR VolumeTreeLock lock %08lX EXCL %08lX\n",
+ "AFSBuildRootVolume Acquiring RDR VolumeTreeLock lock %p EXCL %08lX\n",
&pDevExt->Specific.RDR.VolumeTreeLock,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pDevExt->Specific.RDR.VolumeTreeLock,
TRUE);
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildRootVolume Locating volume for target %I64X\n",
- ullIndex);
+ ullIndex));
ntStatus = AFSLocateHashEntry( pDevExt->Specific.RDR.VolumeTree.TreeHead,
ullIndex,
// Go init the root of the volume
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE_2,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildRootVolume Initializing root for FID %08lX-%08lX-%08lX-%08lX\n",
FileId->Cell,
FileId->Volume,
FileId->Vnode,
- FileId->Unique);
+ FileId->Unique));
ntStatus = AFSInitVolume( AuthGroup,
FileId,
+ AFS_VOLUME_REFERENCE_BUILD_ROOT,
&pVolumeCB);
if( !NT_SUCCESS( ntStatus))
try_return( ntStatus);
}
+
+ //
+ // pVolumeCB->VolumeLock is held exclusive
+ // pVolumeCB->VolumeReferenceCount has been incremented
+ // pVolumeCB->RootFcb == NULL
+ //
+
+ bReleaseVolumeLock = TRUE;
}
else
{
//
- // Just to ensure that things don't get torn down AND we don't create a
- // deadlock with invalidation
+ // AFSInitVolume returns with a VolumeReferenceCount
+ // obtain one to match
//
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = AFSVolumeIncrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_BUILD_ROOT);
- AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
-
- AFSAcquireExcl( pVolumeCB->VolumeLock,
- TRUE);
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSBuildRootVolume Increment count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount));
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
}
if( pVolumeCB->RootFcb == NULL)
{
+ if ( bReleaseVolumeLock == FALSE)
+ {
+
+ AFSAcquireExcl( pVolumeCB->VolumeLock,
+ TRUE);
+
+ bReleaseVolumeLock = TRUE;
+ }
+
//
// Initialize the root fcb for this volume
//
if( !NT_SUCCESS( ntStatus))
{
+ lCount = AFSVolumeDecrement( pVolumeCB,
+ AFS_VOLUME_REFERENCE_BUILD_ROOT);
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSBuildRootVolume Decrement count on volume %p Cnt %d\n",
+ pVolumeCB,
+ lCount));
+
AFSReleaseResource( pVolumeCB->VolumeLock);
try_return( ntStatus);
AFSReleaseResource( &pVolumeCB->RootFcb->NPFcb->Resource);
}
- AFSConvertToShared( pVolumeCB->VolumeLock);
+ if ( bReleaseVolumeLock == TRUE)
+ {
+
+ AFSReleaseResource( pVolumeCB->VolumeLock);
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE_2,
"AFSBuildRootVolume Evaluated target of %wZ FID %08lX-%08lX-%08lX-%08lX as root volume\n",
&pVolumeCB->DirectoryCB->NameInformation.FileName,
pVolumeCB->ObjectInformation.FileId.Cell,
pVolumeCB->ObjectInformation.FileId.Volume,
pVolumeCB->ObjectInformation.FileId.Vnode,
- pVolumeCB->ObjectInformation.FileId.Unique);
-
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_VOLUME_REF_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSBuildRootVolume Increment count on volume %08lX Cnt %d\n",
- pVolumeCB,
- pVolumeCB->VolumeReferenceCount);
+ pVolumeCB->ObjectInformation.FileId.Unique));
*TargetVolumeCB = pVolumeCB;
NTSTATUS
AFSProcessDFSLink( IN AFSDirectoryCB *DirEntry,
IN PFILE_OBJECT FileObject,
- IN UNICODE_STRING *RemainingPath)
+ IN UNICODE_STRING *RemainingPath,
+ IN GUID *AuthGroup,
+ OUT PUNICODE_STRING TargetName)
{
NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
UNICODE_STRING uniReparseName;
UNICODE_STRING uniMUPDeviceName;
+ UNICODE_STRING uniIOMgrDeviceName;
AFSDirEnumEntry *pDirEntry = NULL;
- GUID *pAuthGroup = NULL;
__Enter
{
- //
+ if ( FileObject != NULL && TargetName != NULL ||
+ FileObject == NULL && TargetName == NULL)
+ {
+
+ try_return( ntStatus = STATUS_INVALID_PARAMETER);
+ }
+
+ //
// Build up the name to reparse
//
RtlInitUnicodeString( &uniMUPDeviceName,
L"\\Device\\MUP");
+ RtlInitUnicodeString( &uniIOMgrDeviceName,
+ L"\\??\\");
+
uniReparseName.Length = 0;
uniReparseName.Buffer = NULL;
if( DirEntry->NameInformation.TargetName.Length == 0)
{
- if( DirEntry->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirEntry->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
- pAuthGroup,
+ AuthGroup,
FALSE,
&pDirEntry);
pDirEntry->TargetNameLength == 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSProcessDFSLink EvaluateTargetByID failed for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
&DirEntry->NameInformation.FileName,
DirEntry->ObjectInformation->FileId.Volume,
DirEntry->ObjectInformation->FileId.Vnode,
DirEntry->ObjectInformation->FileId.Unique,
- ntStatus);
+ ntStatus));
if( NT_SUCCESS( ntStatus))
{
- ntStatus = STATUS_ACCESS_DENIED;
+ ntStatus = STATUS_REPARSE_POINT_NOT_RESOLVED;
}
try_return( ntStatus);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSProcessDFSLink UpdateTargetName failed for Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
&DirEntry->NameInformation.FileName,
DirEntry->ObjectInformation->FileId.Volume,
DirEntry->ObjectInformation->FileId.Vnode,
DirEntry->ObjectInformation->FileId.Unique,
- ntStatus);
+ ntStatus));
AFSReleaseResource( &DirEntry->NonPaged->Lock);
}
//
- // Allocate the reparse buffer
- //
+ // Allocate the reparse buffer (from FS because might be returned in FileObject)
+ //
uniReparseName.Buffer = (WCHAR *)AFSExAllocatePoolWithTag( PagedPool,
uniReparseName.MaximumLength,
if( uniReparseName.Buffer == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSProcessDFSLink uniReparseName.Buffer == NULL Fcb %wZ FID %08lX-%08lX-%08lX-%08lX Status %08lX\n",
&DirEntry->NameInformation.FileName,
DirEntry->ObjectInformation->FileId.Volume,
DirEntry->ObjectInformation->FileId.Vnode,
DirEntry->ObjectInformation->FileId.Unique,
- STATUS_INSUFFICIENT_RESOURCES);
+ STATUS_INSUFFICIENT_RESOURCES));
AFSReleaseResource( &DirEntry->NonPaged->Lock);
// Start building the name
//
- RtlCopyMemory( uniReparseName.Buffer,
- uniMUPDeviceName.Buffer,
- uniMUPDeviceName.Length);
+ if ( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\' &&
+ DirEntry->NameInformation.TargetName.Buffer[ 1] == L':')
+ {
- uniReparseName.Length = uniMUPDeviceName.Length;
+ RtlCopyMemory( uniReparseName.Buffer,
+ uniIOMgrDeviceName.Buffer,
+ uniIOMgrDeviceName.Length);
- if( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\')
+ uniReparseName.Length = uniIOMgrDeviceName.Length;
+ }
+ else
{
- uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)] = L'\\';
+ RtlCopyMemory( uniReparseName.Buffer,
+ uniMUPDeviceName.Buffer,
+ uniMUPDeviceName.Length);
+
+ uniReparseName.Length = uniMUPDeviceName.Length;
+
+ if( DirEntry->NameInformation.TargetName.Buffer[ 0] != L'\\')
+ {
+
+ uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)] = L'\\';
- uniReparseName.Length += sizeof( WCHAR);
+ uniReparseName.Length += sizeof( WCHAR);
+ }
}
RtlCopyMemory( &uniReparseName.Buffer[ uniReparseName.Length/sizeof( WCHAR)],
uniReparseName.Length += RemainingPath->Length;
}
- //
- // Update the name in the file object
- //
-
- if( FileObject->FileName.Buffer != NULL)
+ if( FileObject != NULL)
{
+ //
+ // Update the name in the file object
+ //
+
+ if( FileObject->FileName.Buffer != NULL)
+ {
+
+ //
+ // original FileObject buffer was not allocated by AFS
+ //
+
+ ExFreePoolWithTag( FileObject->FileName.Buffer, 0);
+ }
- AFSExFreePool( FileObject->FileName.Buffer);
+ FileObject->FileName = uniReparseName;
}
+ else
+ {
- FileObject->FileName = uniReparseName;
+ *TargetName = uniReparseName;
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessDFSLink Reparsing access to Fcb %wZ FID %08lX-%08lX-%08lX-%08lX to %wZ\n",
&DirEntry->NameInformation.FileName,
DirEntry->ObjectInformation->FileId.Volume,
DirEntry->ObjectInformation->FileId.Vnode,
DirEntry->ObjectInformation->FileId.Unique,
- &uniReparseName);
+ &uniReparseName));
//
// Return status reparse ...
if ( pDirEntry)
{
- AFSExFreePool( pDirEntry);
+ AFSExFreePoolWithTag( pDirEntry, AFS_GENERIC_MEMORY_2_TAG);
}
}
return ntStatus;
}
+
+NTSTATUS
+AFSGetFullFileName( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb,
+ OUT ULONG *FileNameLength,
+ OUT WCHAR *FileName,
+ IN OUT LONG *RemainingLength)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ ULONG ulCopyLength = 0;
+ ULONG cchCopied = 0;
+ BOOLEAN bAddTrailingSlash = FALSE;
+ USHORT usFullNameLength = 0;
+
+ __Enter
+ {
+
+ //
+ // Add a trailing slash for anything which is of the form \server\share
+ //
+
+ if( ( Fcb->ObjectInformation->FileType == AFS_FILE_TYPE_DIRECTORY ||
+ Fcb->ObjectInformation->FileType == AFS_FILE_TYPE_MOUNTPOINT) &&
+ Ccb->FullFileName.Length > sizeof( WCHAR) &&
+ Ccb->FullFileName.Buffer[ (Ccb->FullFileName.Length/sizeof( WCHAR)) - 1] != L'\\' &&
+ AFSIsShareName( &Ccb->FullFileName))
+ {
+ bAddTrailingSlash = TRUE;
+ }
+
+ usFullNameLength = sizeof( WCHAR) +
+ AFSServerName.Length +
+ Ccb->FullFileName.Length;
+
+ if( bAddTrailingSlash)
+ {
+ usFullNameLength += sizeof( WCHAR);
+ }
+
+ if( *RemainingLength >= (LONG)usFullNameLength)
+ {
+ ulCopyLength = (LONG)usFullNameLength;
+ }
+ else
+ {
+
+ ulCopyLength = *RemainingLength;
+
+ ntStatus = STATUS_BUFFER_OVERFLOW;
+ }
+
+ *FileNameLength = (ULONG)usFullNameLength;
+
+ if( ulCopyLength > 0)
+ {
+
+ FileName[ 0] = L'\\';
+ ulCopyLength -= sizeof( WCHAR);
+
+ *RemainingLength -= sizeof( WCHAR);
+ cchCopied += 1;
+
+ if( ulCopyLength >= AFSServerName.Length)
+ {
+
+ RtlCopyMemory( &FileName[ 1],
+ AFSServerName.Buffer,
+ AFSServerName.Length);
+
+ ulCopyLength -= AFSServerName.Length;
+ *RemainingLength -= AFSServerName.Length;
+ cchCopied += AFSServerName.Length/sizeof( WCHAR);
+
+ if( ulCopyLength >= Ccb->FullFileName.Length)
+ {
+
+ RtlCopyMemory( &FileName[ cchCopied],
+ Ccb->FullFileName.Buffer,
+ Ccb->FullFileName.Length);
+
+ ulCopyLength -= Ccb->FullFileName.Length;
+ *RemainingLength -= Ccb->FullFileName.Length;
+ cchCopied += Ccb->FullFileName.Length/sizeof( WCHAR);
+
+ if( ulCopyLength > 0 &&
+ bAddTrailingSlash)
+ {
+ FileName[ cchCopied] = L'\\';
+
+ *RemainingLength -= sizeof( WCHAR);
+ }
+ }
+ else
+ {
+
+ RtlCopyMemory( &FileName[ cchCopied],
+ Ccb->FullFileName.Buffer,
+ ulCopyLength);
+
+ *RemainingLength -= ulCopyLength;
+ }
+ }
+ }
+ }
+
+ return ntStatus;
+}
git://git.openafs.org / openafs.git / blobdiff