USHORT Type;
//
- // Ranking - File Resource first, then Paging Resource
+ // Ranking - File Resource, Paging Resource,
+ // then SectionObject Resource
//
ERESOURCE Resource;
ERESOURCE PagingResource;
+ ERESOURCE SectionObjectResource;
+
//
// The section object pointer
//
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSFastIoAcquireFile Acquiring Fcb lock %08lX EXCL %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSFastIoAcquireFile Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- AFSAcquireExcl( &pFcb->NPFcb->Resource,
+ AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
TRUE);
return;
AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
- if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->Resource))
+ if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->SectionObjectResource))
{
- AFSReleaseResource( &pFcb->NPFcb->Resource);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFastIoReleaseFile Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
}
return;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSFastIoAcquireForModWrite Acquired Fcb lock %08lX EXCL %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSFastIoAcquireForModWrite Acquired Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
ntStatus = STATUS_SUCCESS;
- *ResourceToRelease = &pFcb->NPFcb->Resource;
+ *ResourceToRelease = &pFcb->NPFcb->SectionObjectResource;
}
}
NTSTATUS ntStatus = STATUS_SUCCESS;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFastIoReleaseForModWrite Releasing lock %08lX EXCL %08lX\n",
+ ResourceToRelease,
+ PsGetCurrentThread());
+
AFSReleaseResource( ResourceToRelease);
return ntStatus;
NTSTATUS ntStatus = STATUS_FILE_LOCK_CONFLICT;
AFSFcb *pFcb = (AFSFcb *)FileObject->FsContext;
- if( !ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->Resource))
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFastIoAcquireForCCFlush Acquiring Fcb PagingIo lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->PagingResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pFcb->NPFcb->PagingResource,
+ TRUE);
+
+ if( !ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->SectionObjectResource))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSFastIoAcquireForCCFlush Acquiring Fcb lock %08lX EXCL %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- AFSAcquireExcl( &pFcb->NPFcb->Resource,
+ AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
TRUE);
}
else
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSFastIoAcquireForCCFlush Acquiring Fcb lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSFastIoAcquireForCCFlush Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- AFSAcquireShared( &pFcb->NPFcb->Resource,
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
TRUE);
}
ntStatus = STATUS_SUCCESS;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSFastIoAcquireForCCFlush Acquiring Fcb PagingIo lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->PagingResource,
- PsGetCurrentThread());
-
- AFSAcquireShared( &pFcb->NPFcb->PagingResource,
- TRUE);
-
//
// Set the TopLevelIrp field for this caller
//
IoSetTopLevelIrp( NULL);
}
- if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->Resource) ||
- ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->Resource))
+ if( ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->PagingResource))
{
- AFSReleaseResource( &pFcb->NPFcb->Resource);
+ AFSReleaseResource( &pFcb->NPFcb->PagingResource);
}
else
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSFastIoReleaseForCCFlush Called for non-acquired main resource Fcb\n");
+ "AFSFastIoReleaseForCCFlush Called for non-acquired paging resource Fcb\n");
}
- if( ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->PagingResource))
+ if( ExIsResourceAcquiredExclusiveLite( &pFcb->NPFcb->SectionObjectResource) ||
+ ExIsResourceAcquiredSharedLite( &pFcb->NPFcb->SectionObjectResource))
{
- AFSReleaseResource( &pFcb->NPFcb->PagingResource);
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
}
else
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSFastIoReleaseForCCFlush Called for non-acquired paging resource Fcb\n");
+ "AFSFastIoReleaseForCCFlush Called for non-acquired SectionObject resource Fcb\n");
}
return ntStatus;
BOOLEAN bStatus = FALSE;
AFSFcb *pFcb = (AFSFcb *)Fcb;
- BOOLEAN bReleaseMain = FALSE, bReleasePaging = FALSE;
+ BOOLEAN bReleaseSectionObject = FALSE, bReleasePaging = FALSE;
//
// Try and acquire the Fcb resource
"AFSAcquireFcbForLazyWrite Acquiring Fcb %08lX\n",
Fcb);
+ //
+ // Try and grab the paging
+ //
+
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb PagingIo lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->PagingResource,
PsGetCurrentThread());
- if( AFSAcquireShared( &pFcb->NPFcb->Resource,
+ if( AFSAcquireShared( &pFcb->NPFcb->PagingResource,
Wait))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSAcquireFcbForLazyWrite Acquired Fcb lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSAcquireFcbForLazyWrite Acquired Fcb PagingIo lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->PagingResource,
PsGetCurrentThread());
- bReleaseMain = TRUE;
-
- //
- // Try and grab the paging
- //
+ bReleasePaging = TRUE;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb PagingIo lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->PagingResource,
+ "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- if( AFSAcquireShared( &pFcb->NPFcb->PagingResource,
+ if( AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
Wait))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSAcquireFcbForLazyWrite Acquired Fcb PagingIo lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->PagingResource,
+ "AFSAcquireFcbForLazyWrite Acquired Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- bReleasePaging = TRUE;
+ bReleaseSectionObject = TRUE;
//
// All is well ...
if( !bStatus)
{
- if( bReleaseMain)
+ if( bReleaseSectionObject)
{
- AFSReleaseResource( &pFcb->NPFcb->Resource);
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
}
if( bReleasePaging)
IoSetTopLevelIrp( NULL);
- AFSReleaseResource( &pFcb->NPFcb->PagingResource);
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
- AFSReleaseResource( &pFcb->NPFcb->Resource);
+ AFSReleaseResource( &pFcb->NPFcb->PagingResource);
return;
}
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSAcquireFcbForReadAhead Attempt to acquire Fcb lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSAcquireFcbForReadAhead Attempt to acquire Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- if( AFSAcquireShared( &pFcb->NPFcb->Resource,
+ if( AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
Wait))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSAcquireFcbForReadAhead Acquired Fcb lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSAcquireFcbForReadAhead Acquired Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
bStatus = TRUE;
IoSetTopLevelIrp( NULL);
- AFSReleaseResource( &pFcb->NPFcb->Resource);
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
return;
}
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSCleanup Acquiring Fcb lock %08lX EXCL %08lX\n",
- &pFcb->NPFcb->Resource,
+ "AFSCleanup Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
PsGetCurrentThread());
- AFSAcquireExcl( &pFcb->NPFcb->Resource,
+ AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
TRUE);
//
// If the handle has write permission ...
//
- if( (pCcb->GrantedAccess & FILE_WRITE_DATA) &&
+ if( ((pCcb->GrantedAccess & FILE_WRITE_DATA) || pFcb->OpenHandleCount == 1) &&
CcIsFileCached( pIrpSp->FileObject))
{
ntStatus = stIoSB.Status;
}
+
+ if ( ( pFcb->OpenHandleCount == 1 ||
+ BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE)) &&
+ pFcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL)
+ {
+
+ if ( !CcPurgeCacheSection( &pFcb->NPFcb->SectionObjectPointers,
+ NULL,
+ 0,
+ FALSE))
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCleanup CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique);
+
+ SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ else
+ {
+ ClearFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
}
__except( EXCEPTION_EXECUTE_HANDLER)
{
ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSCleanup Cc FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ pObjectInfo->FileId.Cell,
+ pObjectInfo->FileId.Volume,
+ pObjectInfo->FileId.Vnode,
+ pObjectInfo->FileId.Unique,
+ ntStatus);
+
+ SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
}
NULL,
NULL);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanup Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanup Acquiring Fcb lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->Resource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pFcb->NPFcb->Resource,
+ TRUE);
+
//
// Unlock all outstanding locks on the file, again, unconditionally
//
BooleanFlagOn(ulOptions, FILE_DELETE_ON_CLOSE))
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSProcessOpen Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
if( !MmFlushImageSection( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
MmFlushForWrite))
{
try_return( ntStatus);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSProcessOpen Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
}
if( BooleanFlagOn( ulOptions, FILE_DIRECTORY_FILE))
LARGE_INTEGER liTime;
ULONG ulCreateDisposition = 0;
BOOLEAN bAllocatedCcb = FALSE;
+ BOOLEAN bUserMapped = FALSE;
PACCESS_MASK pDesiredAccess = NULL;
USHORT usShareAccess;
AFSObjectInfoCB *pParentObjectInfo = NULL;
}
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSProcessOverwriteSupercede Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
//
// Before we actually truncate, check to see if the purge
// is going to fail.
//
- if( !MmCanFileBeTruncated( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
- &liZero))
+ bUserMapped = !MmCanFileBeTruncated( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers,
+ &liZero);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSProcessOverwriteSupercede Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
+
+ if( bUserMapped)
{
ntStatus = STATUS_USER_MAPPED_FILE;
//
le = &pExtent->Lists[AFS_EXTENTS_LIST];
- /*
- //
- // Then the check the skip lists cursors
- //
- for (ULONG i = AFS_NUM_EXTENT_LISTS-1; i > AFS_EXTENTS_LIST; i--)
- {
- if (0 == (pFileExtents->FileOffset.LowPart & ExtentsMasks[i]))
- {
- //
- // Three options:
- // - empty list (pSkipEntries[i]->Flink == pSkipEntries[i]->Flink == fcb->lists[i]
- // - We are the last on the list (pSkipEntries[i]->Flink == fcb->lists[i])
- // - We are not the last on the list. In that case we have to be strictly less than
- // that extent.
- if (pSkipEntries[i]->Flink != &Fcb->Specific.File.ExtentsLists[i]) {
-
- AFSExtent *otherExtent = ExtentFor(pSkipEntries[i]->Flink, i);
- ASSERT(pFileExtents->FileOffset.QuadPart < otherExtent->FileOffset.QuadPart);
- }
- }
- }
- */
-
//
// setup pExtent if there is one
//
ntStatus);
}
+
AFSLockForExtentsTrim( Fcb);
bExtentsLocked = TRUE;
ExInitializeResourceLite( &pNPFcb->PagingResource);
+ ExInitializeResourceLite( &pNPFcb->SectionObjectResource);
+
ExInitializeResourceLite( &pNPFcb->CcbListLock);
pFcb->Header.Resource = &pNPFcb->Resource;
ExDeleteResourceLite( &pNPFcb->Specific.File.DirtyExtentsListLock);
}
+ ExDeleteResourceLite( &pNPFcb->SectionObjectResource);
+
ExDeleteResourceLite( &pNPFcb->PagingResource);
ExDeleteResourceLite( &pNPFcb->CcbListLock);
ExDeleteResourceLite( &pFcb->NPFcb->PagingResource);
+ ExDeleteResourceLite( &pFcb->NPFcb->SectionObjectResource);
+
ExDeleteResourceLite( &pFcb->NPFcb->CcbListLock);
//
else if( pFcb->Header.NodeTypeCode == AFS_FILE_FCB)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetDispositionInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
//
// Attempt to flush any outstanding data
//
SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetDispositionInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
}
}
else
pTargetFcb = pTargetDirEntry->ObjectInformation->Fcb;
- AFSAcquireExcl( &pTargetFcb->NPFcb->Resource,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetRenameInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pTargetFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pTargetFcb->NPFcb->SectionObjectResource,
TRUE);
//
&pTargetDirEntry->NameInformation.FileName);
}
- AFSReleaseResource( &pTargetFcb->NPFcb->Resource);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetRenameInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pTargetFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pTargetFcb->NPFcb->SectionObjectResource);
}
ASSERT( pTargetDirEntry->DirOpenReferenceCount > 0);
BOOLEAN bReleasePaging = FALSE;
BOOLEAN bTellCc = FALSE;
BOOLEAN bTellService = FALSE;
+ BOOLEAN bUserMapped = FALSE;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
PFILE_OBJECT pFileObject = pIrpSp->FileObject;
AFSFcb *pFcb = NULL;
if( pFcb->Header.AllocationSize.QuadPart > pBuffer->AllocationSize.QuadPart)
{
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetAllocationInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
+ &pBuffer->AllocationSize);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetAllocationInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
//
// Truncating the file
//
- if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
- &pBuffer->AllocationSize))
+ if ( bUserMapped)
{
ntStatus = STATUS_USER_MAPPED_FILE ;
}
else
{
+
//
// If this is a truncation we need to grab the paging IO resource.
//
BOOLEAN bModified = FALSE;
BOOLEAN bReleasePaging = FALSE;
BOOLEAN bTruncated = FALSE;
+ BOOLEAN bUserMapped = FALSE;
AFSFcb *pFcb = NULL;
AFSCcb *pCcb = NULL;
if( pBuffer->EndOfFile.QuadPart < pFcb->Header.FileSize.QuadPart)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetEndOfFileInfo Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ bUserMapped = !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
+ &pBuffer->EndOfFile);
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetEndOfFileInfo Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
// Truncating the file
- if( !MmCanFileBeTruncated( pFileObject->SectionObjectPointer,
- &pBuffer->EndOfFile))
+ if ( bUserMapped)
{
ntStatus = STATUS_USER_MAPPED_FILE;
AFSFcb *pFcb = (AFSFcb *)pFileObject->FsContext;
AFSCcb *pCcb = (AFSCcb *)pFileObject->FsContext2;
IO_STATUS_BLOCK iosb = {0};
+ BOOLEAN bReleaseSectionObject = FALSE;
pIrpSp = IoGetCurrentIrpStackLocation( Irp);
//
try_return( ntStatus = STATUS_INVALID_PARAMETER);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFlushBuffers Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ bReleaseSectionObject = TRUE;
+
//
// The flush consists of two parts. We firstly flush our
// cache (if we have one), then we tell the service to write
try_return( ntStatus = GetExceptionCode());
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFlushBuffers Releasing Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
+ bReleaseSectionObject = FALSE;
+
//
// Now, flush to the server - if there is stuff to do
//
try_exit:
+ if ( bReleaseSectionObject)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSFlushBuffers Releasing Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+ }
+
AFSCompleteRequest( Irp, ntStatus);
}
(*ppObjectInfo)->FileId.Vnode,
(*ppObjectInfo)->FileId.Unique);
- AFSAcquireExcl( &(*ppObjectInfo)->Fcb->NPFcb->Resource,
+ AFSAcquireExcl( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectResource,
TRUE);
__try
SetFlag( (*ppObjectInfo)->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
- AFSReleaseResource( &(*ppObjectInfo)->Fcb->NPFcb->Resource);
+ AFSReleaseResource( &(*ppObjectInfo)->Fcb->NPFcb->SectionObjectResource);
//
// Clear out the extents
pObjectInfo->FileId.Vnode,
pObjectInfo->FileId.Unique);
- AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
TRUE);
__try
SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
- AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
if ( bPurgeExtents)
{
pObjectInfo->Fcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
pObjectInfo->Fcb->Header.ValidDataLength.QuadPart = pObjectInfo->EndOfFile.QuadPart;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
if ( pCCFileObject != NULL)
(PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSVerifyEntry Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
+
AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
}
else
ClearFlag( pObjectInfo->Flags, AFS_OBJECT_FLAGS_VERIFY_DATA);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ //
+ // Release Fcb->Resource to avoid Trend Micro deadlock
+ //
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Resource);
+
__try
{
SetFlag( pObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->Resource,
+ TRUE);
}
else
{
if( pObjectInfo->Fcb != NULL)
{
- FILE_OBJECT *pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
+ FILE_OBJECT *pCCFileObject;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ pCCFileObject = CcGetFileObjectFromSectionPtrs( &pObjectInfo->Fcb->NPFcb->SectionObjectPointers);
pObjectInfo->Fcb->Header.AllocationSize.QuadPart = pObjectInfo->AllocationSize.QuadPart;
pObjectInfo->Fcb->Header.FileSize.QuadPart = pObjectInfo->EndOfFile.QuadPart;
CcSetFileSizes( pCCFileObject,
(PCC_FILE_SIZES)&pObjectInfo->Fcb->Header.AllocationSize);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSValidateEntry Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->SectionObjectResource);
}
}
break;
!BooleanFlagOn( Fcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
{
- AFSAcquireExcl( &Fcb->NPFcb->Resource,
- TRUE);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupEntry Acquiring Fcb lock %08lX SHARED %08lX\n",
+ &Fcb->NPFcb->Resource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &Fcb->NPFcb->Resource,
+ TRUE);
if( Fcb->OpenReferenceCount > 0)
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupEntry Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
__try
{
SetFlag( Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupFcb Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &Fcb->NPFcb->SectionObjectResource);
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupEntry Releasing Fcb lock %08lX SHARED %08lX\n",
+ &Fcb->NPFcb->Resource,
+ PsGetCurrentThread());
+
AFSReleaseResource( &Fcb->NPFcb->Resource);
//
(AFS_SERVER_PURGE_SLEEP * pControlDeviceExt->Specific.Control.FcbPurgeTimeCount.QuadPart))))
{
- if ( AFSAcquireExcl( &Fcb->NPFcb->Resource, ForceFlush))
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupFcb Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ if ( AFSAcquireExcl( &Fcb->NPFcb->SectionObjectResource, ForceFlush))
{
__try
ntStatus);
}
- AFSReleaseResource( &Fcb->NPFcb->Resource);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCleanupFcb Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &Fcb->NPFcb->SectionObjectResource);
if( Fcb->OpenReferenceCount <= 0)
{
if ( ObjectInfo->Fcb->Specific.File.ExtentsDirtyCount == 0)
{
- if ( ObjectInfo->Fcb->OpenReferenceCount == 0)
- {
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
- AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
+ bExtentsLocked = FALSE;
- bExtentsLocked = FALSE;
+ if ( ObjectInfo->Fcb->OpenReferenceCount == 0)
+ {
AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
else
{
- __try
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
- AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
+ bLocked = FALSE;
- bExtentsLocked = FALSE;
+ __try
+ {
if( ObjectInfo->Fcb->NPFcb->SectionObjectPointers.DataSectionObject != NULL &&
!CcPurgeCacheSection( &ObjectInfo->Fcb->NPFcb->SectionObjectPointers,
SetFlag( ObjectInfo->Fcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->SectionObjectResource);
}
}
else
{
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
+
+ bExtentsLocked = FALSE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Resource);
+
+ bLocked = FALSE;
+
//
// Must build a list of non-dirty ranges from the beginning of the file
// to the end. There can be at most (Fcb->Specific.File.ExtentsDirtyCount + 1)
ulByteRangeCount == 0)
{
- AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource );
-
- bExtentsLocked = FALSE;
-
for ( ulIndex = 0; ulIndex < ulByteRangeCount; ulIndex++)
{
// This could deadlock but we do not have much choice.
//
+ AFSAcquireExcl( &ObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource,
+ TRUE);
+ bExtentsLocked = TRUE;
+
le = ObjectInfo->Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
ulProcessCount = 0;
ObjectInfo->FileId.Unique,
ntStatus);
}
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSPerformObjectInvalidation Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &ObjectInfo->Fcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &ObjectInfo->Fcb->NPFcb->SectionObjectResource);
}
}
// Flush data and then release the locks on the file server
//
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLockControl Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
CcFlushCache( &pFcb->NPFcb->SectionObjectPointers,
NULL,
0,
ntStatus = stIoStatus.Status;
}
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLockControl Releasing Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
RtlZeroMemory( &stUnlockRequestCB,
sizeof( AFSByteRangeUnlockRequestCB));
// Flush the data and then release the file server locks
//
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLockControl Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
CcFlushCache( &pFcb->NPFcb->SectionObjectPointers,
&pIrpSp->Parameters.LockControl.ByteOffset,
pIrpSp->Parameters.LockControl.Length->LowPart,
&stIoStatus);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSLockControl Releasing Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
if( !NT_SUCCESS( stIoStatus.Status))
{
AFSFcb *pFcb = NULL;
AFSCcb *pCcb = NULL;
BOOLEAN bReleaseMain = FALSE;
+ BOOLEAN bReleaseSectionObject = FALSE;
BOOLEAN bReleasePaging = FALSE;
BOOLEAN bPagingIo = FALSE;
BOOLEAN bNonCachedIo = FALSE;
if ( FlagOn(pIrpSp->MinorFunction, IRP_MN_COMPLETE) )
{
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonRead Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ bReleaseSectionObject = TRUE;
+
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonRead (%08lX) IRP_MN_COMPLETE being processed\n",
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonRead Acquiring Fcb PagingIo lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->PagingResource,
- PsGetCurrentThread());
+ &pFcb->NPFcb->PagingResource,
+ PsGetCurrentThread());
AFSAcquireShared( &pFcb->NPFcb->PagingResource,
TRUE);
bReleasePaging = TRUE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonRead Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
+ TRUE);
+
+ bReleaseSectionObject = TRUE;
+
}
else
{
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonRead Acquiring Fcb lock %08lX SHARED %08lX\n",
- &pFcb->NPFcb->Resource,
- PsGetCurrentThread());
+ "AFSCommonRead Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pFcb->NPFcb->SectionObjectResource,
+ PsGetCurrentThread());
- AFSAcquireShared( &pFcb->NPFcb->Resource,
+ AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
TRUE);
- bReleaseMain = TRUE;
+ bReleaseSectionObject = TRUE;
//
// Check the BR locks
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonRead Initialize caching on Fcb %08lX FO %08lX\n",
- pFcb,
- pFileObject);
+ pFcb,
+ pFileObject);
CcInitializeCacheMap( pFileObject,
(PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
else
{
+ if( bReleasePaging)
+ {
+
+ AFSReleaseResource( &pFcb->NPFcb->PagingResource);
+
+ bReleasePaging = FALSE;
+ }
+
+ if( bReleaseSectionObject)
+ {
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+
+ bReleaseSectionObject = FALSE;
+ }
+
+ if( bReleaseMain)
+ {
+
+ AFSReleaseResource( &pFcb->NPFcb->Resource);
+
+ bReleaseMain = FALSE;
+ }
+
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonRead (%08lX) Processing NON-CACHED request Offset %I64X Len %08lX\n",
AFSReleaseResource( &pFcb->NPFcb->PagingResource);
}
+ if( bReleaseSectionObject)
+ {
+
+ AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
+ }
+
if( bReleaseMain)
{
BOOLEAN bPagingIo = FALSE;
BOOLEAN bNonCachedIo = FALSE;
BOOLEAN bReleaseMain = FALSE;
+ BOOLEAN bReleaseSectionObject = FALSE;
BOOLEAN bReleasePaging = FALSE;
BOOLEAN bExtendingWrite = FALSE;
BOOLEAN bCompleteIrp = TRUE;
bNonCachedIo = FALSE;
}
- if( (!bPagingIo && !bNonCachedIo))
- {
+ if ( !bNonCachedIo) {
- if( pFileObject->PrivateCacheMap == NULL)
+ if( !bPagingIo)
{
- __try
+ if( pFileObject->PrivateCacheMap == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite Initialize caching on Fcb %08lX FileObject %08lX\n",
- pFcb,
- pFileObject);
+ "AFSCommonWrite Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pNPFcb->SectionObjectResource,
+ PsGetCurrentThread());
- CcInitializeCacheMap( pFileObject,
- (PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
- FALSE,
- AFSLibCacheManagerCallbacks,
- pFcb);
+ AFSAcquireExcl( &pNPFcb->SectionObjectResource,
+ TRUE);
- CcSetReadAheadGranularity( pFileObject,
- pDeviceExt->Specific.RDR.MaximumRPCLength);
+ bReleaseSectionObject = TRUE;
- CcSetDirtyPageThreshold( pFileObject,
- AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength);
- }
- __except( EXCEPTION_EXECUTE_HANDLER)
- {
+ __try
+ {
- ntStatus = GetExceptionCode();
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Initialize caching on Fcb %08lX FileObject %08lX\n",
+ pFcb,
+ pFileObject);
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSCommonWrite (%08lX) Exception thrown while initializing cache map Status %08lX\n",
- Irp,
- ntStatus);
- }
+ CcInitializeCacheMap( pFileObject,
+ (PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
+ FALSE,
+ AFSLibCacheManagerCallbacks,
+ pFcb);
- if( !NT_SUCCESS( ntStatus))
- {
+ CcSetReadAheadGranularity( pFileObject,
+ pDeviceExt->Specific.RDR.MaximumRPCLength);
- try_return( ntStatus);
+ CcSetDirtyPageThreshold( pFileObject,
+ AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength);
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
+ {
+
+ ntStatus = GetExceptionCode();
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCommonWrite (%08lX) Exception thrown while initializing cache map Status %08lX\n",
+ Irp,
+ ntStatus);
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Releasing Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pNPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pNPFcb->SectionObjectResource);
+
+ bReleaseSectionObject = FALSE;
+
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ try_return( ntStatus);
+ }
}
}
- }
- while (!bNonCachedIo && !CcCanIWrite( pFileObject,
- ulByteCount,
- FALSE,
- bRetry))
- {
- static const LONGLONG llWriteDelay = (LONGLONG)-100000;
- bRetry = TRUE;
- KeDelayExecutionThread(KernelMode, FALSE, (PLARGE_INTEGER)&llWriteDelay);
+ while (!CcCanIWrite( pFileObject,
+ ulByteCount,
+ FALSE,
+ bRetry))
+ {
+ static const LONGLONG llWriteDelay = (LONGLONG)-100000;
+ bRetry = TRUE;
+ KeDelayExecutionThread(KernelMode, FALSE, (PLARGE_INTEGER)&llWriteDelay);
+ }
}
//
}
}
- //
- // We should be ready to go. So first of all ask for the extents
- // Provoke a get of the extents - if we need to.
- //
-
- /*
- if( !bPagingIo && !bNonCachedIo)
- {
-
- ntStatus = AFSRequestExtentsAsync( pFcb, pCcb, &liStartingByte, ulByteCount);
-
- if (!NT_SUCCESS(ntStatus))
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSCommonWrite (%08lX) Failed to request extents Status %08lX\n",
- Irp,
- ntStatus);
-
- try_return( ntStatus );
- }
- }
- */
-
//
// Take locks
//
- // - if Paging then we need to nothing (the precalls will
+ // - if Paging then we need to do nothing (the precalls will
// have acquired the paging resource), for clarity we will collect
// the paging resource
// - If extending Write then take the fileresource EX (EOF will change, Allocation will only move out)
do
{
- if( !bPagingIo)
- {
-
- bExtendingWrite = (((liStartingByte.QuadPart + ulByteCount) >=
- pFcb->Header.FileSize.QuadPart) ||
- (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
- liStartingByte.HighPart == -1)) ;
- }
-
if( bPagingIo)
{
//
bLockOK = TRUE;
}
- else if( bExtendingWrite)
+ else
{
- //
- // Check for lock inversion
- //
- ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
+ bExtendingWrite = (((liStartingByte.QuadPart + ulByteCount) >=
+ pFcb->Header.FileSize.QuadPart) ||
+ (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
+ liStartingByte.HighPart == -1)) ;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite Acquiring Fcb lock %08lX EXCL %08lX\n",
- &pNPFcb->Resource,
- PsGetCurrentThread());
+ if( bExtendingWrite)
+ {
+ //
+ // Check for lock inversion
+ //
- AFSAcquireExcl( &pNPFcb->Resource,
- TRUE);
+ ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
- if (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
- liStartingByte.HighPart == -1)
- {
- if (pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
- {
- liStartingByte = pFcb->Header.ValidDataLength;
- }
- else
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Acquiring Fcb lock %08lX EXCL %08lX\n",
+ &pNPFcb->Resource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pNPFcb->Resource,
+ TRUE);
+
+ bReleaseMain = TRUE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Acquiring Fcb SectionObject lock %08lX EXCL %08lX\n",
+ &pNPFcb->SectionObjectResource,
+ PsGetCurrentThread());
+
+ AFSAcquireExcl( &pNPFcb->SectionObjectResource,
+ TRUE);
+
+ bReleaseSectionObject = TRUE;
+
+ if (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
+ liStartingByte.HighPart == -1)
{
- liStartingByte = pFcb->Header.FileSize;
+ if (pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
+ {
+ liStartingByte = pFcb->Header.ValidDataLength;
+ }
+ else
+ {
+ liStartingByte = pFcb->Header.FileSize;
+ }
}
+
+ //
+ // We have the correct lock - even if we don't end up truncating
+ //
+ bLockOK = TRUE;
}
- bReleaseMain = TRUE;
+ else
+ {
+ ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
- //
- // We have the correct lock - even if we don't end up truncating
- //
- bLockOK = TRUE;
- }
- else
- {
- ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Acquiring Fcb lock %08lX SHARED %08lX\n",
+ &pNPFcb->Resource,
+ PsGetCurrentThread());
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite Acquiring Fcb lock %08lX SHARED %08lX\n",
- &pNPFcb->Resource,
- PsGetCurrentThread());
+ AFSAcquireShared( &pNPFcb->Resource,
+ TRUE);
- AFSAcquireShared( &pNPFcb->Resource,
- TRUE);
+ bReleaseMain = TRUE;
- bReleaseMain = TRUE;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
+ &pNPFcb->SectionObjectResource,
+ PsGetCurrentThread());
- //
- // Have things moved? Are we extending? If so, the the lock isn't OK
- //
- bLockOK = (liStartingByte.QuadPart + ulByteCount) < pFcb->Header.FileSize.QuadPart;
+ AFSAcquireShared( &pNPFcb->SectionObjectResource,
+ TRUE);
- if (!bLockOK)
- {
- AFSReleaseResource( &pNPFcb->Resource);
- bReleaseMain = FALSE;
+ bReleaseSectionObject = TRUE;
+
+ //
+ // Have things moved? Are we extending? If so, the the lock isn't OK
+ //
+ bLockOK = (liStartingByte.QuadPart + ulByteCount) < pFcb->Header.FileSize.QuadPart;
+
+ if (!bLockOK)
+ {
+ AFSReleaseResource( &pNPFcb->Resource);
+
+ bReleaseMain = FALSE;
+ }
}
}
}
while (!bLockOK);
- //
- // Check the BR locks on the file.
- //
-
- if( !bPagingIo &&
- !FsRtlCheckLockForWriteAccess( &pFcb->Specific.File.FileLock,
- Irp))
+ if( !bPagingIo)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSCommonWrite (%08lX) Request failed due to lock conflict\n",
- Irp);
+ //
+ // Check the BR locks on the file.
+ //
- try_return( ntStatus = STATUS_FILE_LOCK_CONFLICT);
- }
+ if ( !FsRtlCheckLockForWriteAccess( &pFcb->Specific.File.FileLock,
+ Irp))
+ {
- if( bExtendingWrite)
- {
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCommonWrite (%08lX) Request failed due to lock conflict\n",
+ Irp);
- ntStatus = AFSExtendingWrite( pFcb, pFileObject, (liStartingByte.QuadPart + ulByteCount));
+ try_return( ntStatus = STATUS_FILE_LOCK_CONFLICT);
+ }
- if( !NT_SUCCESS(ntStatus))
+ if( bExtendingWrite)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSCommonWrite (%08lX) Failed extending write request Status %08lX\n",
- Irp,
- ntStatus);
+ ntStatus = AFSExtendingWrite( pFcb, pFileObject, (liStartingByte.QuadPart + ulByteCount));
+
+ if( !NT_SUCCESS(ntStatus))
+ {
- try_return( ntStatus );
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCommonWrite (%08lX) Failed extending write request Status %08lX\n",
+ Irp,
+ ntStatus);
+
+ try_return( ntStatus );
+ }
}
}
!bNonCachedIo)
{
+ //
+ // Main and SectionObject resources held Shared
+ //
+
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite (%08lX) Processing CACHED request Offset %I64X Len %08lX\n",
else
{
+ //
+ // if bPagingIo, Paging Resource held Shared
+ // else Main and SectionObject resources held Shared
+ //
+
+ if( bReleaseSectionObject)
+ {
+
+ AFSReleaseResource( &pNPFcb->SectionObjectResource);
+
+ bReleaseSectionObject = FALSE;
+ }
+
+ if( bReleasePaging)
+ {
+
+ AFSReleaseResource( &pNPFcb->PagingResource);
+
+ bReleasePaging = FALSE;
+ }
+
+ if( bReleaseMain)
+ {
+
+ AFSReleaseResource( &pNPFcb->Resource);
+
+ bReleaseMain = FALSE;
+ }
+
AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite (%08lX) Processing NON-CACHED request Offset %I64X Len %08lX\n",
ObDereferenceObject(pFileObject);
- if( bReleaseMain)
+ if( bReleaseSectionObject)
{
- AFSReleaseResource( &pNPFcb->Resource);
+ AFSReleaseResource( &pNPFcb->SectionObjectResource);
}
if( bReleasePaging)
AFSReleaseResource( &pNPFcb->PagingResource);
}
+ if( bReleaseMain)
+ {
+
+ AFSReleaseResource( &pNPFcb->Resource);
+ }
+
if( bCompleteIrp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSCcb *pCcb = (AFSCcb *)FileObject->FsContext2;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSExtendingWrite Acquiring Fcb PagingIo lock %08lX EXCL %08lX\n",
- &Fcb->NPFcb->PagingResource,
- PsGetCurrentThread());
-
- AFSAcquireExcl( &Fcb->NPFcb->PagingResource,
- TRUE);
-
if( NewLength > Fcb->Header.AllocationSize.QuadPart)
{
Fcb->Header.AllocationSize = liSaveAllocation;
}
- AFSReleaseResource( &Fcb->NPFcb->PagingResource);
-
//
// DownConvert file resource to shared
//
projects / packages / o / openafs.git / commitdiff