FAST_MUTEX AdvancedHdrMutex;
+ ERESOURCE CcbListLock;
+
union
{
struct _AFS_OBJECT_INFORMATION_CB *ObjectInformation;
//
- // Authentication group GUID
+ // Ccb list pointers
//
- GUID AuthGroup;
+ struct _AFS_CCB *CcbListHead;
+
+ struct _AFS_CCB *CcbListTail;
//
// Union for node type specific information
// the file
//
- AFSTearDownFcbExtents( pFcb);
+ AFSTearDownFcbExtents( pFcb,
+ &pCcb->AuthGroup);
ntStatus = STATUS_SUCCESS;
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pObjectInfo->FileId,
&stFileCleanup,
if( pFcb->Specific.File.ExtentsDirtyCount)
{
- AFSFlushExtents( pFcb);
+ AFSFlushExtents( pFcb,
+ &pCcb->AuthGroup);
}
if( pFcb->OpenHandleCount == 0)
AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pObjectInfo->FileId,
&stFileCleanup,
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pObjectInfo->FileId,
&stFileCleanup,
AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pObjectInfo->FileId,
&stFileCleanup,
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pObjectInfo->FileId,
&stFileCleanup,
AFSProcessRequest( AFS_REQUEST_TYPE_CLEANUP_PROCESSING,
ulNotificationFlags | AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pObjectInfo->FileId,
&stFileCleanup,
AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_CLOSE,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
NULL,
&stParentFileId,
(void *)&stPIOCtlClose,
// Remove the Ccb and de-allocate it
//
- ntStatus = AFSRemoveCcb( pCcb);
+ ntStatus = AFSRemoveCcb( pFcb,
+ pCcb);
if( !NT_SUCCESS( ntStatus))
{
// Remove the Ccb and de-allocate it
//
- ntStatus = AFSRemoveCcb( pCcb);
+ ntStatus = AFSRemoveCcb( pFcb,
+ pCcb);
if( !NT_SUCCESS( ntStatus))
{
pDirCB = pCcb->DirectoryCB;
- //
- // Remove the Ccb and de-allocate it
- //
-
- ntStatus = AFSRemoveCcb( pCcb);
-
- if( !NT_SUCCESS( ntStatus))
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
- AFS_TRACE_LEVEL_WARNING,
- "AFSClose Failed to remove Ccb from Fcb Status %08lX\n",
- ntStatus);
-
- //
- // We can't actually fail a close operation so reset the status
- //
-
- ntStatus = STATUS_SUCCESS;
- }
-
//
// If this entry is deleted then remove the object from the volume tree
//
if( pFcb->Specific.File.ExtentsDirtyCount)
{
- AFSFlushExtents( pFcb);
+ AFSFlushExtents( pFcb,
+ &pCcb->AuthGroup);
}
//
// Tear 'em down, we'll not be needing them again
//
- if( AFSTearDownFcbExtents( pFcb))
+ if( AFSTearDownFcbExtents( pFcb,
+ &pCcb->AuthGroup))
{
//
AFSProcessRequest( AFS_REQUEST_TYPE_FLUSH_FILE,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
NULL,
&pFcb->ObjectInformation->FileId,
NULL,
if( pFcb->Specific.File.ExtentsDirtyCount)
{
- AFSFlushExtents( pFcb);
+ AFSFlushExtents( pFcb,
+ &pCcb->AuthGroup);
}
}
AFSReleaseResource( &pFcb->NPFcb->Resource);
}
+ //
+ // Remove the Ccb and de-allocate it
+ //
+
+ ntStatus = AFSRemoveCcb( pFcb,
+ pCcb);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSClose Failed to remove Ccb from Fcb Status %08lX\n",
+ ntStatus);
+
+ //
+ // We can't actually fail a close operation so reset the status
+ //
+
+ ntStatus = STATUS_SUCCESS;
+ }
+
//
// Decrement the reference count on the Fcb. this is protecting it from teardown.
//
// Remove the Ccb and de-allocate it
//
- ntStatus = AFSRemoveCcb( pCcb);
+ ntStatus = AFSRemoveCcb( pFcb,
+ pCcb);
if( !NT_SUCCESS( ntStatus))
{
NTSTATUS
AFSNotifyDelete( IN AFSDirectoryCB *DirectoryCB,
- IN BOOLEAN CheckOnly)
+ IN GUID *AuthGroup,
+ IN BOOLEAN CheckOnly)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
ULONG ulResultLen = 0;
AFSFileDeleteCB stDelete;
AFSFileDeleteResultCB stDeleteResult;
ULONG ulRequestFlags = AFS_REQUEST_FLAG_SYNCHRONOUS;
- GUID *pAuthGroup = NULL;
__Enter
{
ulRequestFlags |= AFS_REQUEST_FLAG_CHECK_ONLY;
}
- if( DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_DELETE_FILE,
ulRequestFlags,
- pAuthGroup,
+ AuthGroup,
&DirectoryCB->NameInformation.FileName,
&DirectoryCB->ObjectInformation->FileId,
&stDelete,
NTSTATUS
AFSNotifyRename( IN AFSObjectInfoCB *ObjectInfo,
+ IN GUID *AuthGroup,
IN AFSObjectInfoCB *ParentObjectInfo,
IN AFSObjectInfoCB *TargetParentObjectInfo,
IN AFSDirectoryCB *DirectoryCB,
AFSFileRenameCB *pRenameCB = NULL;
AFSFileRenameResultCB *pRenameResultCB = NULL;
ULONG ulResultLen = 0;
- GUID *pAuthGroup = NULL;
__Enter
{
TargetName->Buffer,
TargetName->Length);
- if( ObjectInfo->Fcb != NULL)
- {
- pAuthGroup = &ObjectInfo->Fcb->AuthGroup;
- }
-
//
// Use the same buffer for the result control block
//
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RENAME_FILE,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- pAuthGroup,
+ AuthGroup,
&DirectoryCB->NameInformation.FileName,
&ObjectInfo->FileId,
pRenameCB,
void *pInputSystemBuffer = NULL, *pOutputSystemBuffer = NULL;
ULONG ulBufferLength = OutputLength;
AFSPipeIORequestCB *pIoRequest = NULL;
- GUID *pAuthGroup = NULL;
__Enter
{
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
- if( Ccb->DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &Ccb->DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
//
// Send the call to the service
//
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_TRANSCEIVE,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- pAuthGroup,
+ &Ccb->AuthGroup,
&Ccb->DirectoryCB->NameInformation.FileName,
NULL,
pIoRequest,
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSPipeInfoRequestCB *pInfoRequest = NULL;
- GUID *pAuthGroup = NULL;
__Enter
{
DataBuffer,
InputLength);
- if( Ccb->DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &Ccb->DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
//
// Send the call to the service
//
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_SET_INFO,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- pAuthGroup,
+ &Ccb->AuthGroup,
&Ccb->DirectoryCB->NameInformation.FileName,
NULL,
pInfoRequest,
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSPipeInfoRequestCB stInfoRequest;
ULONG ulBytesProcessed = 0;
- GUID *pAuthGroup = NULL;
__Enter
{
ulBytesProcessed = OutputLength;
- if( Ccb->DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &Ccb->DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
//
// Send the call to the service
//
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_QUERY_INFO,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- pAuthGroup,
+ &Ccb->AuthGroup,
&Ccb->DirectoryCB->NameInformation.FileName,
NULL,
&stInfoRequest,
if( pCcb != NULL)
{
+ RtlCopyMemory( &pCcb->AuthGroup,
+ &stAuthGroup,
+ sizeof( GUID));
+
//
// If we have a substitute name, then use it
//
ClearFlag( pFcb->Flags, AFS_FCB_FILE_CLOSED);
- RtlCopyMemory( &pFcb->AuthGroup,
- &stAuthGroup,
- sizeof( GUID));
-
//
// For files perform additional processing
//
//
KeQuerySystemTime( &pFcb->ObjectInformation->LastAccessTime);
+
+ if( pCcb != NULL)
+ {
+ AFSInsertCcb( pFcb,
+ pCcb);
+ }
}
else
{
(*Ccb)->DirectoryCB = VolumeCB->DirectoryCB;
+ (*Ccb)->GrantedAccess = *pDesiredAccess;
+
//
// OK, update the share access on the fileobject
//
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
*Ccb = NULL;
}
(*Ccb)->DirectoryCB = pDirEntry;
+ (*Ccb)->GrantedAccess = *pDesiredAccess;
+
//
// If this is a file, update the headers filesizes.
//
FALSE); // Leave it in the enum list so the worker cleans it up
AFSNotifyDelete( pDirEntry,
+ AuthGroup,
FALSE);
//
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
}
if( bAllocatedFcb)
(*Ccb)->DirectoryCB = ParentDirectoryCB;
+ (*Ccb)->GrantedAccess = *pDesiredAccess;
+
if( TargetDirectoryCB != NULL &&
FsRtlAreNamesEqual( &TargetDirectoryCB->NameInformation.FileName,
TargetName,
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
}
*Ccb = NULL;
{
ntStatus = AFSNotifyDelete( DirectoryCB,
+ AuthGroup,
TRUE);
if( !NT_SUCCESS( ntStatus))
(*Ccb)->FileAccess = ulFileAccess;
+ (*Ccb)->GrantedAccess = *pDesiredAccess;
+
//
// Perform the access check on the target if this is a mount point or symlink
//
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
}
*Ccb = NULL;
(*Ccb)->DirectoryCB = DirectoryCB;
+ (*Ccb)->GrantedAccess = *pDesiredAccess;
+
//
// Need to purge any data currently in the cache
//
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
}
*Ccb = NULL;
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
*Ccb = NULL;
}
if( bAllocatedCcb)
{
- AFSRemoveCcb( *Ccb);
+ AFSRemoveCcb( NULL,
+ *Ccb);
*Ccb = NULL;
}
// Tell the service to prime the cache of the directory content
//
- ntStatus = AFSEnumerateDirectoryNoResponse( &pFcb->AuthGroup,
+ ntStatus = AFSEnumerateDirectoryNoResponse( &pCcb->AuthGroup,
&pFcb->ObjectInformation->FileId);
if( !NT_SUCCESS( ntStatus))
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique);
- ntStatus = AFSVerifyEntry( &pFcb->AuthGroup,
+ ntStatus = AFSVerifyEntry( &pCcb->AuthGroup,
pCcb->DirectoryCB);
if( !NT_SUCCESS( ntStatus))
//
AFSValidateEntry( pDirEntry,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
FALSE,
FALSE);
pDirEntry,
&pCcb->FullFileName,
pCcb->NameArray,
+ &pCcb->AuthGroup,
&stFileInfo)))
{
// Pull all the extents away from the FCB.
//
BOOLEAN
-AFSTearDownFcbExtents( IN AFSFcb *Fcb )
+AFSTearDownFcbExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
BOOLEAN bFoundExtents = FALSE;
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
BOOLEAN locked = FALSE;
NTSTATUS ntStatus;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
__Enter
{
+ if( pAuthGroup == NULL)
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
//
// Ensure that no one is working with the extents and grab the
// lock
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &Fcb->AuthGroup,
+ pAuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
pRelease,
NTSTATUS
AFSRequestExtents( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb,
IN PLARGE_INTEGER Offset,
IN ULONG Size,
OUT BOOLEAN *FullyMapped)
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
0,
- &Fcb->AuthGroup,
+ &Ccb->AuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
&request,
NTSTATUS
AFSRequestExtentsAsync( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb,
IN PLARGE_INTEGER Offset,
IN ULONG Size)
{
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
0,
- &Fcb->AuthGroup,
+ &Ccb->AuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
&request,
AFSObjectInfoCB *pObjectInfo = NULL;
BOOLEAN bLocked = FALSE;
BOOLEAN bDirtyExtents = FALSE;
+ GUID stAuthGroup;
__Enter
{
// Stash away the auth group
//
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( pFcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
RtlCopyMemory( &pFile->AuthGroup,
- &pFcb->AuthGroup,
+ &stAuthGroup,
sizeof( GUID));
//
}
NTSTATUS
-AFSFlushExtents( IN AFSFcb *Fcb)
+AFSFlushExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSExtent *pExtent, *pNextExtent;
LARGE_INTEGER liLastFlush;
AFSExtent *pDirtyListHead = NULL, *pDirtyListTail = NULL;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
__Enter
{
+ if( pAuthGroup == NULL)
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
//
// Lock extents while we count and set up the array to send to
// the service
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &Fcb->AuthGroup,
+ pAuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
pRelease,
}
NTSTATUS
-AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb)
+AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSExtent *pExtent;
LARGE_INTEGER liLastFlush;
ULONG ulRemainingExtentLength = 0;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
__Enter
{
+ if( pAuthGroup == NULL)
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
//
// Look for a start in the list to flush entries
//
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &Fcb->AuthGroup,
+ pAuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
pRelease,
pCcb->DirectoryCB->ObjectInformation->FileId.Vnode,
pCcb->DirectoryCB->ObjectInformation->FileId.Unique);
- ntStatus = AFSVerifyEntry( &pFcb->AuthGroup,
+ ntStatus = AFSVerifyEntry( &pCcb->AuthGroup,
pCcb->DirectoryCB);
if( !NT_SUCCESS( ntStatus))
ExInitializeResourceLite( &pNPFcb->PagingResource);
+ ExInitializeResourceLite( &pNPFcb->CcbListLock);
+
pFcb->Header.Resource = &pNPFcb->Resource;
pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
ExDeleteResourceLite( &pNPFcb->PagingResource);
+ ExDeleteResourceLite( &pNPFcb->CcbListLock);
+
ExDeleteResourceLite( &pNPFcb->Resource);
}
ExInitializeResourceLite( &pNPFcb->PagingResource);
+ ExInitializeResourceLite( &pNPFcb->CcbListLock);
+
pFcb->Header.Resource = &pNPFcb->Resource;
pFcb->Header.PagingIoResource = &pNPFcb->PagingResource;
ExDeleteResourceLite( &RootFcb->NPFcb->PagingResource);
+ ExDeleteResourceLite( &RootFcb->NPFcb->CcbListLock);
+
//
// The non paged region
//
ExDeleteResourceLite( &Fcb->NPFcb->PagingResource);
-
+ ExDeleteResourceLite( &Fcb->NPFcb->CcbListLock);
//
// The non paged region
//
NTSTATUS
-AFSRemoveCcb( IN AFSCcb *Ccb)
+AFSRemoveCcb( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
+ if( Fcb != NULL &&
+ BooleanFlagOn( Ccb->Flags, CCB_FLAG_INSERTED_CCB_LIST))
+ {
+
+ AFSAcquireExcl( &Fcb->NPFcb->CcbListLock,
+ TRUE);
+
+ if( Ccb->ListEntry.fLink == NULL)
+ {
+
+ Fcb->CcbListTail = (AFSCcb *)Ccb->ListEntry.bLink;
+
+ if( Fcb->CcbListTail != NULL)
+ {
+ Fcb->CcbListTail->ListEntry.fLink = NULL;
+ }
+ }
+ else
+ {
+ ((AFSCcb *)(Ccb->ListEntry.fLink))->ListEntry.bLink = Ccb->ListEntry.bLink;
+ }
+
+ if( Ccb->ListEntry.bLink == NULL)
+ {
+
+ Fcb->CcbListHead = (AFSCcb *)Ccb->ListEntry.fLink;
+
+ if( Fcb->CcbListHead != NULL)
+ {
+ Fcb->CcbListHead->ListEntry.bLink = NULL;
+ }
+ }
+ else
+ {
+ ((AFSCcb *)(Ccb->ListEntry.bLink))->ListEntry.fLink = Ccb->ListEntry.fLink;
+ }
+
+ AFSReleaseResource( &Fcb->NPFcb->CcbListLock);
+ }
+
if( Ccb->MaskName.Buffer != NULL)
{
return ntStatus;
}
+
+NTSTATUS
+AFSInsertCcb( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+
+ AFSAcquireExcl( &Fcb->NPFcb->CcbListLock,
+ TRUE);
+
+ if( Fcb->CcbListHead == NULL)
+ {
+ Fcb->CcbListHead = Ccb;
+ }
+ else
+ {
+ Fcb->CcbListTail->ListEntry.fLink = (void *)Ccb;
+
+ Ccb->ListEntry.bLink = (void *)Fcb->CcbListTail;
+ }
+
+ Fcb->CcbListTail = Ccb;
+
+ SetFlag( Ccb->Flags, CCB_FLAG_INSERTED_CCB_LIST);
+
+ AFSReleaseResource( &Fcb->NPFcb->CcbListLock);
+
+ return ntStatus;
+}
ntStatus = AFSUpdateFileInformation( &stParentFileId,
pFcb->ObjectInformation,
- &pFcb->AuthGroup);
+ &pCcb->AuthGroup);
if( !NT_SUCCESS( ntStatus))
{
DirectoryCB,
&uniParentPath,
NULL,
+ &pCcb->AuthGroup,
&stFileInfo)))
{
ulFileAttribs = stFileInfo.FileAttributes;
DirectoryCB,
&uniParentPath,
NULL,
+ &pCcb->AuthGroup,
&stFileInfo)))
{
ulFileAttribs = stFileInfo.FileAttributes;
DirectoryCB,
&uniParentPath,
NULL,
+ &pCcb->AuthGroup,
&stFileInfo)))
{
ulFileAttribs = stFileInfo.FileAttributes;
DirectoryCB,
&uniParentPath,
NULL,
+ &pCcb->AuthGroup,
&stFileInfo)))
{
ulFileAttribs = stFileInfo.FileAttributes;
//
ntStatus = AFSNotifyDelete( DirectoryCB,
+ &pCcb->AuthGroup,
TRUE);
if( !NT_SUCCESS( ntStatus))
//
ntStatus = AFSNotifyRename( pSrcFcb->ObjectInformation,
+ &pSrcCcb->AuthGroup,
pSrcFcb->ObjectInformation->ParentObjectInformation,
pTargetDcb->ObjectInformation,
pSrcCcb->DirectoryCB,
{
ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
pFcb->ObjectInformation,
- &pFcb->AuthGroup);
+ &pCcb->AuthGroup);
}
if (NT_SUCCESS(ntStatus))
ntStatus = AFSUpdateFileInformation( &pFcb->ObjectInformation->ParentObjectInformation->FileId,
pFcb->ObjectInformation,
- &pFcb->AuthGroup);
+ &pCcb->AuthGroup);
if( NT_SUCCESS(ntStatus))
{
// Now, flush to the server - if there is stuff to do
//
- ntStatus = AFSFlushExtents( pFcb);
+ ntStatus = AFSFlushExtents( pFcb,
+ &pCcb->AuthGroup);
if( !NT_SUCCESS( ntStatus))
{
- AFSReleaseExtentsWithFlush( pFcb);
+ AFSReleaseExtentsWithFlush( pFcb,
+ &pCcb->AuthGroup);
ntStatus = STATUS_SUCCESS;
}
// for any writes or reads to the cache to complete)
//
- (VOID) AFSTearDownFcbExtents( pObjectInfo->Fcb);
+ (VOID) AFSTearDownFcbExtents( pObjectInfo->Fcb,
+ NULL);
}
break;
// for any writes or reads to the cache to complete)
//
- (VOID) AFSTearDownFcbExtents( pObjectInfo->Fcb);
+ (VOID) AFSTearDownFcbExtents( pObjectInfo->Fcb,
+ NULL);
}
pObjectInfo->DataVersion.QuadPart = (ULONGLONG)-1;
// for any writes or reads to the cache to complete)
//
- (VOID) AFSTearDownFcbExtents( pFcb);
+ (VOID) AFSTearDownFcbExtents( pFcb,
+ NULL);
}
pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
if ( bPurgeExtents)
{
- AFSFlushExtents( pObjectInfo->Fcb);
+ AFSFlushExtents( pObjectInfo->Fcb,
+ AuthGroup);
}
//
// for any writes or reads to the cache to complete)
//
- (VOID) AFSTearDownFcbExtents( pFcb);
+ (VOID) AFSTearDownFcbExtents( pFcb,
+ NULL);
}
pCurrentObject = (AFSObjectInfoCB *)pCurrentObject->ListEntry.fLink;
if ( bPurgeExtents)
{
- AFSFlushExtents( pCurrentFcb);
+ AFSFlushExtents( pCurrentFcb,
+ AuthGroup);
}
//
IN AFSDirectoryCB *DirectoryCB,
IN UNICODE_STRING *ParentPathName,
IN AFSNameArrayHdr *RelatedNameArray,
+ IN GUID *AuthGroup,
OUT AFSFileInfoCB *FileInfo)
{
WCHAR *pwchBuffer = NULL;
UNICODE_STRING uniComponentName, uniRemainingPath, uniParsedName;
ULONG ulNameDifference = 0;
- GUID *pAuthGroup = NULL;
__Enter
{
AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
- if( ParentDirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &ParentDirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
- else if( DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
- pAuthGroup,
+ AuthGroup,
FALSE,
&pDirEntry);
WCHAR *pwchBuffer = NULL;
UNICODE_STRING uniComponentName, uniRemainingPath, uniParsedName;
ULONG ulNameDifference = 0;
- GUID *pAuthGroup = NULL;
+ GUID stAuthGroup;
__Enter
{
+ ntStatus = AFSRetrieveValidAuthGroup( NULL,
+ DirectoryCB->ObjectInformation,
+ FALSE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
//
// Retrieve a target name for the entry
//
AFSReleaseResource( &DirectoryCB->NonPaged->Lock);
- if( DirectoryCB->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirectoryCB->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSEvaluateTargetByID( DirectoryCB->ObjectInformation,
- pAuthGroup,
+ &stAuthGroup,
FALSE,
&pDirEntry);
// Now perform another flush on the file
//
- if( !NT_SUCCESS( AFSFlushExtents( Fcb)))
+ if( !NT_SUCCESS( AFSFlushExtents( Fcb,
+ NULL)))
{
- AFSReleaseExtentsWithFlush( Fcb);
+ AFSReleaseExtentsWithFlush( Fcb,
+ NULL);
}
}
BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
{
- AFSTearDownFcbExtents( Fcb);
+ AFSTearDownFcbExtents( Fcb,
+ NULL);
}
try_return( ntStatus);
(liTime.QuadPart - Fcb->Specific.File.LastServerFlush.QuadPart)
>= pControlDeviceExt->Specific.Control.FcbFlushTimeCount.QuadPart))
{
-
- if( !NT_SUCCESS( AFSFlushExtents( Fcb)) &&
+ if( !NT_SUCCESS( AFSFlushExtents( Fcb,
+ NULL)) &&
Fcb->OpenReferenceCount == 0)
{
- AFSReleaseExtentsWithFlush( Fcb);
+ AFSReleaseExtentsWithFlush( Fcb,
+ NULL);
}
}
else if( BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID) ||
// The file has been marked as invalid. Dump it
//
- AFSTearDownFcbExtents( Fcb);
+ AFSTearDownFcbExtents( Fcb,
+ NULL);
}
//
// Tear em down we'll not be needing them again
//
- AFSTearDownFcbExtents( Fcb);
+ AFSTearDownFcbExtents( Fcb,
+ NULL);
}
}
return;
}
+NTSTATUS
+AFSRetrieveValidAuthGroup( IN AFSFcb *Fcb,
+ IN AFSObjectInfoCB *ObjectInfo,
+ IN BOOLEAN WriteAccess,
+ OUT GUID *AuthGroup)
+{
+
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ GUID stAuthGroup, stZeroAuthGroup;
+ BOOLEAN bFoundAuthGroup = FALSE;
+ AFSCcb *pCcb = NULL;
+ AFSFcb *pFcb = Fcb;
+
+ __Enter
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ RtlZeroMemory( &stZeroAuthGroup,
+ sizeof( GUID));
+
+ if( Fcb == NULL)
+ {
+
+ if( ObjectInfo != NULL &&
+ ObjectInfo->Fcb != NULL)
+ {
+ pFcb = ObjectInfo->Fcb;
+ }
+ }
+
+ if( pFcb != NULL)
+ {
+
+ AFSAcquireShared( &Fcb->NPFcb->CcbListLock,
+ TRUE);
+
+ pCcb = Fcb->CcbListHead;
+
+ while( pCcb != NULL)
+ {
+
+ if( WriteAccess &&
+ pCcb->GrantedAccess & FILE_WRITE_DATA)
+ {
+ RtlCopyMemory( &stAuthGroup,
+ &pCcb->AuthGroup,
+ sizeof( GUID));
+
+ bFoundAuthGroup = TRUE;
+
+ break;
+ }
+ else if( pCcb->GrantedAccess != 0)
+ {
+ //
+ // At least get the read-only access
+ //
+
+ RtlCopyMemory( &stAuthGroup,
+ &pCcb->AuthGroup,
+ sizeof( GUID));
+
+ bFoundAuthGroup = TRUE;
+ }
+
+ pCcb = (AFSCcb *)pCcb->ListEntry.fLink;
+ }
+
+ AFSReleaseResource( &Fcb->NPFcb->CcbListLock);
+ }
+
+ if( !bFoundAuthGroup)
+ {
+
+ AFSRetrieveAuthGroupFnc( (ULONGLONG)PsGetCurrentProcessId(),
+ (ULONGLONG)PsGetCurrentThreadId(),
+ &stAuthGroup);
+
+ if( RtlCompareMemory( &stZeroAuthGroup,
+ &stAuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
+ {
+
+ DbgPrint("AFSRetrieveValidAuthGroup Failed to locate PAG\n");
+
+ try_return( ntStatus = STATUS_ACCESS_DENIED);
+ }
+ }
+
+ RtlCopyMemory( AuthGroup,
+ &stAuthGroup,
+ sizeof( GUID));
+
+try_exit:
+
+ NOTHING;
+ }
+
+ return ntStatus;
+}
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_BYTE_RANGE_LOCK,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pFcb->ObjectInformation->FileId,
&stLockRequestCB,
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK_ALL,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pFcb->ObjectInformation->FileId,
(void *)&stUnlockRequestCB,
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
&pFcb->ObjectInformation->FileId,
(void *)&stUnlockRequestCB,
ntStatus = AFSProcessDFSLink( pDirEntry,
FileObject,
- &uniRemainingPath);
+ &uniRemainingPath,
+ AuthGroup);
}
else
{
NTSTATUS
AFSProcessDFSLink( IN AFSDirectoryCB *DirEntry,
IN PFILE_OBJECT FileObject,
- IN UNICODE_STRING *RemainingPath)
+ IN UNICODE_STRING *RemainingPath,
+ IN GUID *AuthGroup)
{
NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
UNICODE_STRING uniReparseName;
UNICODE_STRING uniMUPDeviceName;
AFSDirEnumEntry *pDirEntry = NULL;
- GUID *pAuthGroup = NULL;
__Enter
{
if( DirEntry->NameInformation.TargetName.Length == 0)
{
- if( DirEntry->ObjectInformation->Fcb != NULL)
- {
- pAuthGroup = &DirEntry->ObjectInformation->Fcb->AuthGroup;
- }
-
ntStatus = AFSEvaluateTargetByID( DirEntry->ObjectInformation,
- pAuthGroup,
+ AuthGroup,
FALSE,
&pDirEntry);
IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
PFILE_OBJECT pFileObject = pIrpSp->FileObject;
AFSFcb *pFcb = (AFSFcb *)pFileObject->FsContext;
+ AFSCcb *pCcb = (AFSCcb *)pFileObject->FsContext2;
BOOLEAN bSynchronousIo = IoIsOperationSynchronous(Irp);
VOID *pSystemBuffer = NULL;
BOOLEAN bPagingIo = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
ulReadByteCount);
ntStatus = AFSRequestExtentsAsync( pFcb,
+ pCcb,
&StartingByte,
ulReadByteCount);
ulReadByteCount);
ntStatus = AFSRequestExtentsAsync( pFcb,
+ pCcb,
&StartingByte,
ulReadByteCount);
// The data is there now. Give back the extents now so the service
// has some in hand
//
- (VOID) AFSReleaseExtentsWithFlush( pFcb);
+ (VOID) AFSReleaseExtentsWithFlush( pFcb,
+ &pCcb->AuthGroup);
try_exit:
if( !bPagingIo && !bNonCachedIo)
{
- ntStatus = AFSRequestExtentsAsync( pFcb, &liStartingByte, ulByteCount);
+ ntStatus = AFSRequestExtentsAsync( pFcb, pCcb, &liStartingByte, ulByteCount);
if (!NT_SUCCESS(ntStatus))
{
pFcb->Specific.File.ExtentLength > 1500)
{
- AFSQueueFlushExtents( pFcb);
+ AFSQueueFlushExtents( pFcb,
+ &pCcb->AuthGroup);
}
#endif
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_READ,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
NULL,
&stParentFID,
(void *)&stIORequestCB,
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_READ,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
NULL,
(void *)&stIoRequest,
case AFS_WORK_FLUSH_FCB:
{
- ntStatus = AFSFlushExtents( pWorkItem->Specific.Fcb.Fcb);
+ ntStatus = AFSFlushExtents( pWorkItem->Specific.Fcb.Fcb,
+ &pWorkItem->AuthGroup);
if( !NT_SUCCESS( ntStatus))
{
- AFSReleaseExtentsWithFlush( pWorkItem->Specific.Fcb.Fcb);
+ AFSReleaseExtentsWithFlush( pWorkItem->Specific.Fcb.Fcb,
+ &pWorkItem->AuthGroup);
}
ASSERT( pWorkItem->Specific.Fcb.Fcb->OpenReferenceCount != 0);
}
NTSTATUS
-AFSQueueFlushExtents( IN AFSFcb *Fcb)
+AFSQueueFlushExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
pWorkItem->RequestType = AFS_WORK_FLUSH_FCB;
+ RtlCopyMemory( &pWorkItem->AuthGroup,
+ AuthGroup,
+ sizeof( GUID));
+
pWorkItem->Specific.Fcb.Fcb = Fcb;
InterlockedIncrement( &Fcb->OpenReferenceCount);
if( !bPagingIo && !bNonCachedIo)
{
- ntStatus = AFSRequestExtentsAsync( pFcb, &liStartingByte, ulByteCount);
+ ntStatus = AFSRequestExtentsAsync( pFcb, pCcb, &liStartingByte, ulByteCount);
if (!NT_SUCCESS(ntStatus))
{
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIOCTL_WRITE,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
NULL,
&stParentFID,
(void *)&stIORequestCB,
ByteCount);
ntStatus = AFSRequestExtentsAsync( pFcb,
+ pCcb,
&StartingByte,
ByteCount);
ByteCount);
ntStatus = AFSRequestExtentsAsync( pFcb,
+ pCcb,
&StartingByte,
ByteCount);
ntStatus = AFSUpdateFileInformation( &Fcb->ObjectInformation->ParentObjectInformation->FileId,
Fcb->ObjectInformation,
- &Fcb->AuthGroup);
+ &pCcb->AuthGroup);
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PIPE_WRITE,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &pFcb->AuthGroup,
+ &pCcb->AuthGroup,
&pCcb->DirectoryCB->NameInformation.FileName,
NULL,
pIoRequest,
NTSTATUS
AFSNotifyDelete( IN AFSDirectoryCB *DirectoryCB,
- IN BOOLEAN CheckOnly);
+ IN GUID *AuthGroup,
+ IN BOOLEAN CheckOnly);
NTSTATUS
AFSNotifyRename( IN AFSObjectInfoCB *ObjectInfo,
+ IN GUID *AuthGroup,
IN AFSObjectInfoCB *ParentObjectInfo,
IN AFSObjectInfoCB *TargetParentObjectInfo,
IN AFSDirectoryCB *DirectoryCB,
NTSTATUS
AFSRequestExtents( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb,
IN PLARGE_INTEGER Offset,
IN ULONG Size,
OUT BOOLEAN *FullyMApped);
NTSTATUS
AFSRequestExtentsAsync( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb,
IN PLARGE_INTEGER Offset,
IN ULONG Size);
IN AFSFileExtentCB *Result);
NTSTATUS
-AFSFlushExtents( IN AFSFcb *pFcb);
+AFSFlushExtents( IN AFSFcb *pFcb,
+ IN GUID *AuthGroup);
NTSTATUS
-AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb);
+AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup);
VOID
AFSMarkDirty( IN AFSFcb *pFcb,
IN LARGE_INTEGER *StartingByte);
BOOLEAN
-AFSTearDownFcbExtents( IN AFSFcb *Fcb ) ;
+AFSTearDownFcbExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup);
void
AFSTrimExtents( IN AFSFcb *Fcb,
AFSRemoveFcb( IN AFSFcb *Fcb);
NTSTATUS
-AFSRemoveCcb( IN AFSCcb *Ccb);
+AFSRemoveCcb( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb);
+
+NTSTATUS
+AFSInsertCcb( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb);
//
// AFSNameSupport.cpp Prototypes
NTSTATUS
AFSProcessDFSLink( IN AFSDirectoryCB *DirEntry,
IN PFILE_OBJECT FileObject,
- IN UNICODE_STRING *RemainingPath);
+ IN UNICODE_STRING *RemainingPath,
+ IN GUID *AuthGroup);
//
// AFSNetworkProviderSupport.cpp
IN AFSDirectoryCB *DirectoryCB,
IN UNICODE_STRING *ParentPathName,
IN AFSNameArrayHdr *RelatedNameArray,
+ IN GUID *AuthGroup,
OUT AFSFileInfoCB *FileInfo);
AFSObjectInfoCB *
AFSRetrieveParentPath( IN UNICODE_STRING *FullFileName,
OUT UNICODE_STRING *ParentPath);
+NTSTATUS
+AFSRetrieveValidAuthGroup( IN AFSFcb *Fcb,
+ IN AFSObjectInfoCB *ObjectInfo,
+ IN BOOLEAN WriteAccess,
+ OUT GUID *AuthGroup);
+
//
// AFSWorker.cpp Prototypes
//
AFSShutdownVolumeWorker( IN AFSVolumeCB *VolumeCB);
NTSTATUS
-AFSQueueFlushExtents( IN AFSFcb *Fcb);
+AFSQueueFlushExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup);
NTSTATUS
AFSQueueAsyncRead( IN PDEVICE_OBJECT DeviceObject,
#define CCB_FLAGS_DIRECTORY_QUERY_MAPPED 0x00000020
#define CCB_FLAG_MASK_PIOCTL_QUERY 0x00000040
#define CCB_FLAG_MASK_OPENED_REPARSE_POINT 0x00000080
+#define CCB_FLAG_INSERTED_CCB_LIST 0x00000100
//
// DirEntry flags
ULONG Flags;
+ AFSListEntry ListEntry;
+
//
// Directory enumeration informaiton
//
UNICODE_STRING NotifyMask;
+ ACCESS_MASK GrantedAccess;
+
//
// File unwind info
//
ULONG FileAccess;
+ //
+ // Authentication group GUID
+ //
+
+ GUID AuthGroup;
+
} AFSCcb;
//
ULONGLONG ProcessID;
+ GUID AuthGroup;
+
union
{
struct