/*
* Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
- * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Your File System, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
static
NTSTATUS
+AFSNonCachedWriteDirect( IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN LARGE_INTEGER StartingByte,
+ IN ULONG ByteCount);
+
+static
+NTSTATUS
AFSExtendingWrite( IN AFSFcb *Fcb,
IN PFILE_OBJECT FileObject,
IN LONGLONG NewLength);
__try
{
- ntStatus = AFSCommonWrite( AFSRDRDeviceObject, Irp, NULL);
+ ntStatus = AFSCommonWrite( AFSRDRDeviceObject, Irp, NULL, FALSE);
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
NTSTATUS
AFSCommonWrite( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
- IN HANDLE OnBehalfOf)
+ IN HANDLE OnBehalfOf,
+ IN BOOLEAN bRetry)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
BOOLEAN bReleaseSectionObject = FALSE;
BOOLEAN bReleasePaging = FALSE;
BOOLEAN bExtendingWrite = FALSE;
+ BOOLEAN bSynchronousFo = FALSE;
+ BOOLEAN bWriteToEndOfFile = FALSE;
+ BOOLEAN bWait = FALSE;
BOOLEAN bCompleteIrp = TRUE;
+ BOOLEAN bForceFlush = FALSE;
BOOLEAN bLockOK;
HANDLE hCallingUser = OnBehalfOf;
- BOOLEAN bRetry = FALSE;
ULONGLONG ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
+ AFSDeviceExt *pRDRDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
pIrpSp = IoGetCurrentIrpStackLocation( Irp);
__Enter
{
+ Irp->IoStatus.Information = 0;
+
pFileObject = pIrpSp->FileObject;
//
if( pFcb == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite Attempted write (%p) when pFcb == NULL\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
}
if( BooleanFlagOn( pDeviceExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_WARNING,
"AFSCommonWrite (%p) Open request after shutdown\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_TOO_LATE);
}
liStartingByte = pIrpSp->Parameters.Write.ByteOffset;
bPagingIo = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
bNonCachedIo = BooleanFlagOn( Irp->Flags, IRP_NOCACHE);
+ bWait = IoIsOperationSynchronous( Irp);
ulByteCount = pIrpSp->Parameters.Write.Length;
+ bSynchronousFo = BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO);
if( pFcb->Header.NodeTypeCode != AFS_IOCTL_FCB &&
pFcb->Header.NodeTypeCode != AFS_FILE_FCB &&
pFcb->Header.NodeTypeCode != AFS_SPECIAL_SHARE_FCB)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite Attempted write (%p) on an invalid node type %08lX\n",
Irp,
- pFcb->Header.NodeTypeCode);
+ pFcb->Header.NodeTypeCode));
try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
}
if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite (%p) Processing file (PIOCTL) Offset %I64X Length %08lX Irp Flags %08lX\n",
+ "AFSCommonWrite (%p) Processing file (PIOCTL) Offset %0I64X Length %08lX Irp Flags %08lX\n",
Irp,
liStartingByte.QuadPart,
ulByteCount,
- Irp->Flags);
+ Irp->Flags));
ntStatus = AFSIOCtlWrite( DeviceObject,
Irp);
else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite (%p) Processing file (SHARE) Offset %I64X Length %08lX Irp Flags %08lX\n",
+ "AFSCommonWrite (%p) Processing file (SHARE) Offset %0I64X Length %08lX Irp Flags %08lX\n",
Irp,
liStartingByte.QuadPart,
ulByteCount,
- Irp->Flags);
+ Irp->Flags));
ntStatus = AFSShareWrite( DeviceObject,
Irp);
// Is the Cache not there yet? Exit.
//
if( !BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE) &&
+ !BooleanFlagOn( pRDRDevExt->DeviceFlags, AFS_REDIR_INIT_PERFORM_SERVICE_IO) &&
NULL == pDeviceExt->Specific.RDR.CacheFileObject)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Request failed due to AFS cache closed\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_TOO_LATE );
}
if( pFcb->ObjectInformation->VolumeCB != NULL &&
- BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.Characteristics, FILE_READ_ONLY_DEVICE))
+ BooleanFlagOn( pFcb->ObjectInformation->VolumeCB->VolumeInformation.FileSystemAttributes, FILE_READ_ONLY_VOLUME))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Request failed due to read only volume\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_ACCESS_DENIED);
}
if( ulByteCount == 0)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite (%p) Request completed due to zero length\n",
- Irp);
+ Irp));
try_return( ntStatus);
}
if( BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_OBJECT_INVALID))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Failing request due to INVALID fcb\n",
- Irp);
-
- Irp->IoStatus.Information = 0;
+ Irp));
try_return( ntStatus = STATUS_FILE_DELETED);
}
BooleanFlagOn( pFcb->ObjectInformation->Flags, AFS_OBJECT_FLAGS_DELETED))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Request failed due to file deleted\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_FILE_DELETED);
}
if( FlagOn( pIrpSp->MinorFunction, IRP_MN_COMPLETE))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite (%p) IRP_MN_COMPLETE being processed\n",
- Irp);
+ Irp));
CcMdlWriteComplete(pFileObject, &pIrpSp->Parameters.Write.ByteOffset, Irp->MdlAddress);
if( NULL != pFileObject->SectionObjectPointer->DataSectionObject && !bPagingIo && bNonCachedIo)
{
bNonCachedIo = FALSE;
+ bForceFlush = TRUE;
}
if ( !bNonCachedIo && !bPagingIo)
if( pFileObject->PrivateCacheMap == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
&pNPFcb->SectionObjectResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireExcl( &pNPFcb->SectionObjectResource,
TRUE);
__try
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Initialize caching on Fcb %p FileObject %p\n",
pFcb,
- pFileObject);
+ pFileObject));
CcInitializeCacheMap( pFileObject,
(PCC_FILE_SIZES)&pFcb->Header.AllocationSize,
CcSetDirtyPageThreshold( pFileObject,
AFS_DIRTY_CHUNK_THRESHOLD * pDeviceExt->Specific.RDR.MaximumRPCLength / 4096);
}
- __except( EXCEPTION_EXECUTE_HANDLER)
+ __except( EXCEPTION_EXECUTE_HANDLER)
{
ntStatus = GetExceptionCode();
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Exception thrown while initializing cache map Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Releasing Fcb SectionObject lock %p EXCL %08lX\n",
&pNPFcb->SectionObjectResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSReleaseResource( &pNPFcb->SectionObjectResource);
}
}
- while (!CcCanIWrite( pFileObject,
- ulByteCount,
- FALSE,
- bRetry))
- {
- static const LONGLONG llWriteDelay = (LONGLONG)-100000;
- bRetry = TRUE;
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_WARNING,
- "AFSCommonWrite (FO: %p) CcCanIWrite says No room for %u bytes! Retry in 10ms\n",
- pFileObject,
- ulByteCount);
-
- KeDelayExecutionThread(KernelMode, FALSE, (PLARGE_INTEGER)&llWriteDelay);
- }
+ //
+ // On versions of Microsoft Windows older than Vista the IO Manager
+ // will issue multiple outstanding writes on a synchronous file object
+ // if one of the cached writes completes with STATUS_PENDING. This can
+ // result in the writes being completed out of order which can corrupt
+ // the end of file marker. On OS versions older than Vista use a spin
+ // loop instead of deferring the write.
+ //
+
+ if ( bSynchronousFo &&
+ AFSRtlSysVersion.dwMajorVersion < 6)
+ {
+
+ while (!CcCanIWrite( pFileObject,
+ ulByteCount,
+ bWait && !bRetry,
+ bRetry))
+ {
+ static const LONGLONG llWriteDelay = (LONGLONG)-100000;
+ bRetry = TRUE;
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCommonWrite (FO: %p) CcCanIWrite says No room for %u bytes! Retry in 10ms\n",
+ pFileObject,
+ ulByteCount);
+
+ KeDelayExecutionThread(KernelMode, FALSE, (PLARGE_INTEGER)&llWriteDelay);
+ }
+ }
+ else
+ {
+
+ if (!CcCanIWrite( pFileObject,
+ ulByteCount,
+ bWait && !bRetry,
+ bRetry))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCommonWrite (FO: %p) CcCanIWrite says No room for Offset %0I64X Length %08lX bytes! Deferring%s\n",
+ pFileObject,
+ liStartingByte.QuadPart,
+ ulByteCount,
+ bRetry ? " RETRY" : ""));
+
+ ntStatus = AFSDeferWrite( DeviceObject, pFileObject, hCallingUser, Irp, ulByteCount, bRetry);
+
+ if ( STATUS_PENDING == ntStatus)
+ {
+
+ bCompleteIrp = FALSE;
+ }
+ else
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCommonWrite (FO: %p) AFSDeferWrite failure Status %08lX\n",
+ pFileObject,
+ ntStatus));
+ }
+
+ try_return( ntStatus);
+ }
+ }
}
//
if( ullProcessId == (ULONGLONG)AFSSysProcess)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_WARNING,
"%s Setting LastWriterExtentProcessId to system process for Fcb %p\n",
__FUNCTION__,
- pFcb);
+ pFcb));
}
}
//ASSERT( NULL != OnBehalfOf || ExIsResourceAcquiredLite( &pNPFcb->Resource ));
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Acquiring Fcb PagingIo lock %p SHARED %08lX\n",
&pNPFcb->PagingResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pNPFcb->PagingResource,
TRUE);
else
{
- bExtendingWrite = (((liStartingByte.QuadPart + ulByteCount) >=
- pFcb->Header.FileSize.QuadPart) ||
- (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
- liStartingByte.HighPart == -1)) ;
+ bWriteToEndOfFile = liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
+ liStartingByte.HighPart == -1;
- if( bExtendingWrite)
+ bExtendingWrite = ( bWriteToEndOfFile ||
+ ((liStartingByte.QuadPart + ulByteCount) >=
+ pFcb->Header.FileSize.QuadPart));
+
+ if( bExtendingWrite || bNonCachedIo)
{
//
// Check for lock inversion
//
+ //
+ // For bExtendingWrite the PagingResource is needed to protect
+ // the CcSetFileSizes call in AFSExtendingWrite
+ //
+
ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Acquiring Fcb lock %p EXCL %08lX\n",
&pNPFcb->Resource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireExcl( &pNPFcb->Resource,
TRUE);
bReleaseMain = TRUE;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Acquiring Fcb SectionObject lock %p EXCL %08lX\n",
&pNPFcb->SectionObjectResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireExcl( &pNPFcb->SectionObjectResource,
TRUE);
bReleaseSectionObject = TRUE;
- if (liStartingByte.LowPart == FILE_WRITE_TO_END_OF_FILE &&
- liStartingByte.HighPart == -1)
+ if ( bWriteToEndOfFile)
{
if (pFcb->Header.ValidDataLength.QuadPart > pFcb->Header.FileSize.QuadPart)
{
{
ASSERT( !ExIsResourceAcquiredLite( &pNPFcb->PagingResource ));
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Acquiring Fcb lock %p SHARED %08lX\n",
&pNPFcb->Resource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pNPFcb->Resource,
TRUE);
bReleaseMain = TRUE;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonWrite Acquiring Fcb SectionObject lock %p SHARED %08lX\n",
&pNPFcb->SectionObjectResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pNPFcb->SectionObjectResource,
TRUE);
if (!bLockOK)
{
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Releasing Fcb SectionObject lock %p SHARED %08lX\n",
+ &pNPFcb->SectionObjectResource,
+ PsGetCurrentThread()));
+
+ AFSReleaseResource( &pNPFcb->SectionObjectResource);
+
+ bReleaseSectionObject = FALSE;
+
AFSReleaseResource( &pNPFcb->Resource);
bReleaseMain = FALSE;
Irp))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Request failed due to lock conflict\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_FILE_LOCK_CONFLICT);
}
ntStatus = AFSExtendingWrite( pFcb, pFileObject, (liStartingByte.QuadPart + ulByteCount));
+ //
+ // Fcb->NPFcb->Resource is now held SHARED
+ //
+
if( !NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCommonWrite (%p) Failed extending write request Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
try_return( ntStatus );
}
{
//
- // Main and SectionObject resources held Shared
+ // Main resource held Shared
+ // SectionObject resource held exclusive if extending write
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite (%p) Processing CACHED request Offset %I64X Len %08lX\n",
+ "AFSCommonWrite (%p) Processing CACHED request Offset %0I64X Len %08lX%s\n",
Irp,
liStartingByte.QuadPart,
- ulByteCount);
-
- ntStatus = AFSCachedWrite( DeviceObject, Irp, liStartingByte, ulByteCount, TRUE);
+ ulByteCount,
+ bRetry ? " RETRY" : ""));
+ ntStatus = AFSCachedWrite( DeviceObject, Irp, liStartingByte, ulByteCount, bForceFlush);
}
else
{
- //
- // if bPagingIo, Paging Resource held Shared
- // else Main and SectionObject resources held Shared
- //
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite (%p) Processing NON-CACHED request Offset %0I64X Len %08lX%s\n",
+ Irp,
+ liStartingByte.QuadPart,
+ ulByteCount,
+ bRetry ? " RETRY" : ""));
- if( bReleaseSectionObject)
+ if( BooleanFlagOn( pRDRDevExt->DeviceFlags, AFS_DEVICE_FLAG_DIRECT_SERVICE_IO))
{
- AFSReleaseResource( &pNPFcb->SectionObjectResource);
-
- bReleaseSectionObject = FALSE;
+ ntStatus = AFSNonCachedWriteDirect( DeviceObject, Irp, liStartingByte, ulByteCount);
+ }
+ else
+ {
+ ntStatus = AFSNonCachedWrite( DeviceObject, Irp, liStartingByte, ulByteCount);
}
+ }
+
+try_exit:
- if( bReleasePaging)
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite (%p) Process complete Status %08lX\n",
+ Irp,
+ ntStatus));
+
+ if ( NT_SUCCESS( ntStatus) &&
+ ntStatus != STATUS_PENDING)
+ {
+ if ( !bPagingIo)
{
- AFSReleaseResource( &pNPFcb->PagingResource);
+ if( bSynchronousFo)
+ {
- bReleasePaging = FALSE;
+ pFileObject->CurrentByteOffset.QuadPart = liStartingByte.QuadPart + ulByteCount;
+ }
+
+ //
+ // If this extended the VDL, then update it accordingly.
+ // Increasing the VDL does not require a call to CcSetFileSizes.
+ //
+
+ if( liStartingByte.QuadPart + ulByteCount > pFcb->Header.ValidDataLength.QuadPart)
+ {
+
+ pFcb->Header.ValidDataLength.QuadPart = liStartingByte.QuadPart + ulByteCount;
+ }
+
+ if( !BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME))
+ {
+
+ SetFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_WRITE_TIME);
+
+ KeQuerySystemTime( &pFcb->ObjectInformation->LastWriteTime);
+ }
}
+ }
+
+ if ( ntStatus != STATUS_PENDING &&
+ !bPagingIo && bNonCachedIo && CcIsFileCached( pFileObject) &&
+ pNPFcb->SectionObjectPointers.DataSectionObject != NULL &&
+ bReleaseSectionObject)
+ {
+ //
+ // Regardless of whether or not the a non-paging non-cached write
+ // succeeds or fails, if the file is cached the contents of the
+ // cache are no longer up to date. A CcPurgeCacheSection must be
+ // performed to force subsequent cached reads to obtain the data
+ // from the service.
+ //
+ // The Fcb Resource is dropped in order to permit filters that perform
+ // an open via a worker thread in response to a purge to do so without
+ // deadlocking. The SectionObjectResource is held across the purge to
+ // prevent racing with other cache operations.
+ //
if( bReleaseMain)
{
bReleaseMain = FALSE;
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite (%p) Processing NON-CACHED request Offset %I64X Len %08lX\n",
- Irp,
- liStartingByte.QuadPart,
- ulByteCount);
-
- ntStatus = AFSNonCachedWrite( DeviceObject, Irp, liStartingByte, ulByteCount);
- }
+ __try
+ {
-try_exit:
+ if ( !CcPurgeCacheSection( &pNPFcb->SectionObjectPointers,
+ &liStartingByte,
+ ulByteCount,
+ FALSE))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_WARNING,
+ "AFSCommonWrite CcPurgeCacheSection failure FID %08lX-%08lX-%08lX-%08lX\n",
+ pFcb->ObjectInformation->FileId.Cell,
+ pFcb->ObjectInformation->FileId.Volume,
+ pFcb->ObjectInformation->FileId.Vnode,
+ pFcb->ObjectInformation->FileId.Unique));
+
+ SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
+ {
+
+ DWORD ntStatus2 = GetExceptionCode();
+
+ AFSDbgTrace(( 0,
+ 0,
+ "EXCEPTION - AFSCommonWrite CcPurgeCacheSection failed FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX\n",
+ pFcb->ObjectInformation->FileId.Cell,
+ pFcb->ObjectInformation->FileId.Volume,
+ pFcb->ObjectInformation->FileId.Vnode,
+ pFcb->ObjectInformation->FileId.Unique,
+ ntStatus2));
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSCommonWrite (%p) Process complete Status %08lX\n",
- Irp,
- ntStatus);
+ SetFlag( pFcb->Flags, AFS_FCB_FLAG_PURGE_ON_CLOSE);
+ }
+ }
ObDereferenceObject(pFileObject);
if( bReleaseSectionObject)
{
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING|AFS_SUBSYSTEM_SECTION_OBJECT,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSCommonWrite Releasing Fcb SectionObject lock %p EXCL/SHARED %08lX\n",
+ &pNPFcb->SectionObjectResource,
+ PsGetCurrentThread()));
+
AFSReleaseResource( &pNPFcb->SectionObjectResource);
}
__Enter
{
+ Irp->IoStatus.Information = 0;
+
RtlZeroMemory( &stIORequestCB,
sizeof( AFSPIOCtlIORequestCB));
pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSIOCtlWrite Acquiring Fcb lock %p SHARED %08lX\n",
&pFcb->NPFcb->Resource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pFcb->NPFcb->Resource,
TRUE);
__Enter
{
- Irp->IoStatus.Information = 0;
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite (FO: %p) StartingByte %08lX:%08lX Length %08lX\n",
pFileObject,
StartingByte.HighPart,
StartingByte.LowPart,
- ByteCount);
+ ByteCount));
if (ByteCount > pDevExt->Specific.RDR.MaxIo.QuadPart)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Request %08lX Actual %08lX larger than MaxIO %I64X\n",
Irp,
ByteCount,
pIrpSp->Parameters.Write.Length,
- pDevExt->Specific.RDR.MaxIo.QuadPart);
+ pDevExt->Specific.RDR.MaxIo.QuadPart));
try_return( ntStatus = STATUS_UNSUCCESSFUL);
}
if( pSystemBuffer == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to map system buffer\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
// Provoke a get of the extents - if we need to.
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSNonCachedWrite Requesting extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
+ "AFSNonCachedWrite Requesting extents for fid %08lX-%08lX-%08lX-%08lX Offset %0I64X Length %08lX\n",
pFcb->ObjectInformation->FileId.Cell,
pFcb->ObjectInformation->FileId.Volume,
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique,
StartingByte.QuadPart,
- ByteCount);
+ ByteCount));
ntStatus = AFSRequestExtentsAsync( pFcb,
pCcb,
if (!NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to request extents Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
while (TRUE)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Acquiring Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
ASSERT( !ExIsResourceAcquiredLite( &pFcb->NPFcb->Specific.File.ExtentsResource ));
KeClearEvent( &pFcb->NPFcb->Specific.File.ExtentsRequestComplete );
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Releasing(1) Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
bLocked= FALSE;
if( liCurrentTime.QuadPart - liLastRequestTime.QuadPart >= pControlDevExt->Specific.Control.ExtentRequestTimeCount.QuadPart)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSNonCachedWrite Requesting extents, again, for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
+ "AFSNonCachedWrite Requesting extents, again, for fid %08lX-%08lX-%08lX-%08lX Offset %0I64X Length %08lX\n",
pFcb->ObjectInformation->FileId.Cell,
pFcb->ObjectInformation->FileId.Volume,
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique,
StartingByte.QuadPart,
- ByteCount);
+ ByteCount));
ntStatus = AFSRequestExtentsAsync( pFcb,
pCcb,
if (!NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to request extents Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSNonCachedWrite Waiting for extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
+ "AFSNonCachedWrite Waiting for extents for fid %08lX-%08lX-%08lX-%08lX Offset %0I64X Length %08lX\n",
pFcb->ObjectInformation->FileId.Cell,
pFcb->ObjectInformation->FileId.Volume,
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique,
StartingByte.QuadPart,
- ByteCount);
+ ByteCount));
//
// Wait for it
if (!NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSNonCachedWrite Failed wait for extents for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX Status %08lX\n",
+ "AFSNonCachedWrite Failed wait for extents for fid %08lX-%08lX-%08lX-%08lX Offset %0I64X Length %08lX Status %08lX\n",
pFcb->ObjectInformation->FileId.Cell,
pFcb->ObjectInformation->FileId.Volume,
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique,
StartingByte.QuadPart,
ByteCount,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
// As per the read path -
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSNonCachedWrite Extents located for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX\n",
+ "AFSNonCachedWrite Extents located for fid %08lX-%08lX-%08lX-%08lX Offset %0I64X Length %08lX\n",
pFcb->ObjectInformation->FileId.Cell,
pFcb->ObjectInformation->FileId.Volume,
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique,
StartingByte.QuadPart,
- ByteCount);
+ ByteCount));
ntStatus = AFSGetExtents( pFcb,
&StartingByte,
if (!NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to retrieve mapped extents Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
try_return( ntStatus );
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite (%p) Successfully retrieved map extents count %d run count %d\n",
Irp,
extentsCount,
- runCount);
+ runCount));
if( BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE))
{
if (!NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to process extent run for non-persistent cache Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
}
try_return( ntStatus);
ntStatus = STATUS_DEVICE_NOT_READY;
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSNonCachedWrite Failed to retrieve cache fileobject for fid %08lX-%08lX-%08lX-%08lX Offset %I64X Length %08lX Status %08lX\n",
+ "AFSNonCachedWrite Failed to retrieve cache fileobject for fid %08lX-%08lX-%08lX-%08lX Offset %0I64X Length %08lX Status %08lX\n",
pFcb->ObjectInformation->FileId.Cell,
pFcb->ObjectInformation->FileId.Volume,
pFcb->ObjectInformation->FileId.Vnode,
pFcb->ObjectInformation->FileId.Unique,
StartingByte.QuadPart,
ByteCount,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
if (NULL == pIoRuns)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to allocate IO run block\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
if (!NT_SUCCESS(ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to initialize IO run block Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
try_return( ntStatus );
}
bDerefExtents = TRUE;
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Releasing(2) Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
bLocked = FALSE;
if (NULL == pGatherIo)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSNonCachedWrite (%p) Failed to allocate IO gather block\n",
- Irp);
+ Irp));
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Acquiring(1) Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
TRUE);
runCount,
pGatherIo);
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite (%p) AFSStartIos completed Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Acquiring(2) Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
TRUE);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Acquiring(3) Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSAcquireShared( &pFcb->NPFcb->Specific.File.ExtentsResource,
TRUE);
AFSReleaseCacheFileObject( pCacheFileObject);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite (FO: %p) StartingByte %08lX:%08lX Length %08lX Status %08lX\n",
pFileObject,
StartingByte.HighPart,
StartingByte.LowPart,
ByteCount,
- ntStatus);
+ ntStatus));
if (NT_SUCCESS(ntStatus) &&
!bPagingIo &&
if( bLocked)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Releasing Fcb extents lock %p SHARED %08lX\n",
&pFcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ PsGetCurrentThread()));
AFSReleaseResource( &pFcb->NPFcb->Specific.File.ExtentsResource );
}
if( bCompleteIrp)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSNonCachedWrite Completing Irp %p Status %08lX Info %08lX\n",
Irp,
ntStatus,
- Irp->IoStatus.Information);
+ Irp->IoStatus.Information));
AFSCompleteRequest( Irp, ntStatus);
}
static
NTSTATUS
+AFSNonCachedWriteDirect( IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN LARGE_INTEGER StartingByte,
+ IN ULONG ByteCount)
+{
+ NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
+ VOID *pSystemBuffer = NULL;
+ BOOLEAN bPagingIo = BooleanFlagOn( Irp->Flags, IRP_PAGING_IO);
+ IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
+ PFILE_OBJECT pFileObject = pIrpSp->FileObject;
+ AFSFcb *pFcb = (AFSFcb *)pFileObject->FsContext;
+ AFSCcb *pCcb = (AFSCcb *)pFileObject->FsContext2;
+ BOOLEAN bSynchronousFo = BooleanFlagOn( pFileObject->Flags, FO_SYNCHRONOUS_IO);
+ BOOLEAN bNoIntermediateBuffering = BooleanFlagOn( pFileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING);
+ AFSDeviceExt *pDevExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
+ AFSFileIOCB stFileIORequest;
+ AFSFileIOResultCB stFileIOResult;
+ ULONG ulResultLen = 0;
+ ULONG ulFlags;
+
+ __Enter
+ {
+ Irp->IoStatus.Information = 0;
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNonCachedWriteDirect (FO: %p) StartingByte %08lX:%08lX Length %08lX\n",
+ pFileObject,
+ StartingByte.HighPart,
+ StartingByte.LowPart,
+ ByteCount));
+
+ if (ByteCount > pDevExt->Specific.RDR.MaxIo.QuadPart)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNonCachedWriteDirect (%p) Request %08lX Actual %08lX larger than MaxIO %I64X\n",
+ Irp,
+ ByteCount,
+ pIrpSp->Parameters.Write.Length,
+ pDevExt->Specific.RDR.MaxIo.QuadPart));
+
+ try_return( ntStatus = STATUS_UNSUCCESSFUL);
+ }
+
+ //
+ // Get the mapping for the buffer
+ //
+ pSystemBuffer = AFSLockSystemBuffer( Irp,
+ ByteCount);
+
+ if( pSystemBuffer == NULL)
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNonCachedWriteDirect (%p) Failed to map system buffer\n",
+ Irp));
+
+ try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ //
+ // Issue the request at the service for processing
+ //
+
+ ulResultLen = sizeof( AFSFileIOResultCB);
+
+ RtlZeroMemory( &stFileIORequest,
+ sizeof( AFSFileIOCB));
+
+ RtlZeroMemory( &stFileIOResult,
+ sizeof( AFSFileIOResultCB));
+
+ stFileIORequest.SystemIOBuffer = pSystemBuffer;
+
+ stFileIORequest.SystemIOBufferMdl = Irp->MdlAddress;
+
+ stFileIORequest.IOLength = ByteCount;
+
+ stFileIORequest.IOOffset = StartingByte;
+
+ ulFlags = AFS_REQUEST_FLAG_SYNCHRONOUS;
+
+ if ( bNoIntermediateBuffering)
+ {
+
+ ulFlags |= AFS_REQUEST_FLAG_CACHE_BYPASS;
+ }
+
+ //
+ // Update file metadata
+ //
+
+ stFileIORequest.EndOfFile = pFcb->ObjectInformation->EndOfFile;
+
+ stFileIORequest.CreateTime = pFcb->ObjectInformation->CreationTime;
+
+ stFileIORequest.ChangeTime = pFcb->ObjectInformation->ChangeTime;
+
+ stFileIORequest.LastAccessTime = pFcb->ObjectInformation->LastAccessTime;
+
+ stFileIORequest.LastWriteTime = pFcb->ObjectInformation->LastWriteTime;
+
+ //
+ // Write the data to the service
+ //
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_PROCESS_WRITE_FILE,
+ ulFlags,
+ &pCcb->AuthGroup,
+ &pCcb->DirectoryCB->NameInformation.FileName,
+ &pFcb->ObjectInformation->FileId,
+ pFcb->ObjectInformation->VolumeCB->VolumeInformation.Cell,
+ pFcb->ObjectInformation->VolumeCB->VolumeInformation.CellLength,
+ &stFileIORequest,
+ sizeof( AFSFileIOCB),
+ &stFileIOResult,
+ &ulResultLen);
+
+ if( NT_SUCCESS( ntStatus))
+ {
+
+ Irp->IoStatus.Information = (ULONG_PTR)stFileIOResult.Length;
+ }
+ else
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSNonCachedWriteDirect (%p) Failed to send write to service Status %08lX\n",
+ Irp,
+ ntStatus));
+ }
+
+try_exit:
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNonCachedWriteDirect (FO: %p) StartingByte %08lX:%08lX Length %08lX Status %08lX\n",
+ pFileObject,
+ StartingByte.HighPart,
+ StartingByte.LowPart,
+ ByteCount,
+ ntStatus));
+
+ if (NT_SUCCESS(ntStatus) &&
+ !bPagingIo &&
+ bSynchronousFo)
+ {
+
+ pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ByteCount;
+ }
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSNonCachedWriteDirect Completing Irp %p Status %08lX Info %08lX\n",
+ Irp,
+ ntStatus,
+ Irp->IoStatus.Information));
+
+ AFSCompleteRequest( Irp, ntStatus);
+ }
+
+ return ntStatus;
+}
+
+static
+NTSTATUS
AFSCachedWrite( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN LARGE_INTEGER StartingByte,
ntStatus = Irp->IoStatus.Status;
}
- __except( EXCEPTION_EXECUTE_HANDLER)
+ __except( EXCEPTION_EXECUTE_HANDLER)
{
ntStatus = GetExceptionCode();
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCachedWrite (%p) Exception thrown while preparing mdl write Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
}
if( !NT_SUCCESS( ntStatus))
Irp->MdlAddress = NULL;
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCachedWrite (%p) Failed to process MDL write Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
}
try_return( ntStatus);
if( pSystemBuffer == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCachedWrite (%p) Failed to lock system buffer\n",
- Irp);
+ Irp));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
// Failed to process request.
//
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCachedWrite (%p) Failed to issue CcCopyWrite %wZ @ %0I64X Status %08lX\n",
Irp,
&pFileObject->FileName,
liCurrentOffset.QuadPart,
- Irp->IoStatus.Status);
+ Irp->IoStatus.Status));
try_return( ntStatus = STATUS_UNSUCCESSFUL);
}
}
- __except( EXCEPTION_EXECUTE_HANDLER)
+ __except( EXCEPTION_EXECUTE_HANDLER)
{
ntStatus = GetExceptionCode();
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSCachedWrite (%p) CcCopyWrite Threw exception %wZ @ %0I64X Status %08lX\n",
Irp,
&pFileObject->FileName,
liCurrentOffset.QuadPart,
- ntStatus);
+ ntStatus));
}
if( !NT_SUCCESS( ntStatus))
BooleanFlagOn(pFileObject->Flags, (FO_NO_INTERMEDIATE_BUFFERING + FO_WRITE_THROUGH)))
{
- //
- // We have detected a file we do a write through with.
- //
-
- CcFlushCache(&pFcb->NPFcb->SectionObjectPointers,
- &liCurrentOffset,
- ulCurrentIO,
- &iosbFlush);
-
- if( !NT_SUCCESS( iosbFlush.Status))
+ __try
+ {
+ //
+ // We have detected a file we do a write through with.
+ //
+
+ CcFlushCache(&pFcb->NPFcb->SectionObjectPointers,
+ &liCurrentOffset,
+ ulCurrentIO,
+ &iosbFlush);
+
+ if( !NT_SUCCESS( iosbFlush.Status))
+ {
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSCachedWrite (%p) CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ Irp,
+ &pFileObject->FileName,
+ pFcb->ObjectInformation->FileId.Cell,
+ pFcb->ObjectInformation->FileId.Volume,
+ pFcb->ObjectInformation->FileId.Vnode,
+ pFcb->ObjectInformation->FileId.Unique,
+ iosbFlush.Status,
+ iosbFlush.Information));
+
+ try_return( ntStatus = iosbFlush.Status);
+ }
+ }
+ __except( EXCEPTION_EXECUTE_HANDLER)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
+ ntStatus = GetExceptionCode();
+
+ AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSCachedWrite (%p) CcFlushCache failure %wZ FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
+ "AFSCachedWrite (%p) CcFlushCache Threw exception %wZ @ %0I64X Status %08lX\n",
Irp,
&pFileObject->FileName,
- pFcb->ObjectInformation->FileId.Cell,
- pFcb->ObjectInformation->FileId.Volume,
- pFcb->ObjectInformation->FileId.Vnode,
- pFcb->ObjectInformation->FileId.Unique,
- iosbFlush.Status,
- iosbFlush.Information);
-
- try_return( ntStatus = iosbFlush.Status);
+ liCurrentOffset.QuadPart,
+ ntStatus));
+
+ try_return( ntStatus);
}
}
Irp->IoStatus.Information = ByteCount;
- if( bSynchronousFo)
- {
-
- pFileObject->CurrentByteOffset.QuadPart = StartingByte.QuadPart + ByteCount;
- }
-
- //
- // If this extended the Vdl, then update it accordingly
- //
-
- if( StartingByte.QuadPart + ByteCount > pFcb->Header.ValidDataLength.QuadPart)
- {
-
- pFcb->Header.ValidDataLength.QuadPart = StartingByte.QuadPart + ByteCount;
- }
-
if ( ForceFlush ||
BooleanFlagOn(pFileObject->Flags, (FO_NO_INTERMEDIATE_BUFFERING + FO_WRITE_THROUGH)))
{
//
pFcb->Specific.File.LastServerFlush.QuadPart = 0;
}
-
- if( !BooleanFlagOn( pFcb->Flags, AFS_FCB_FLAG_UPDATE_LAST_WRITE_TIME))
- {
-
- SetFlag( pFcb->Flags, AFS_FCB_FLAG_UPDATE_WRITE_TIME);
-
- KeQuerySystemTime( &pFcb->ObjectInformation->LastWriteTime);
- }
}
AFSCompleteRequest( Irp,
return ntStatus;
}
+//
+// Called with Fcb->NPFcb->SectionObjectResource and Fcb->NPFcb->Resource held
+//
+
static
NTSTATUS
AFSExtendingWrite( IN AFSFcb *Fcb,
//
// If the file is currently cached, then let the MM know about the extension
//
+ // The CcSetFileSizes call should be made with only the PagingResource held
+ // which we are currently not holding.
+ //
if( CcIsFileCached( FileObject))
{
__Enter
{
- pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
-
pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
- AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSShareWrite On pipe %wZ Length %08lX\n",
&pCcb->DirectoryCB->NameInformation.FileName,
- pIrpSp->Parameters.Write.Length);
+ pIrpSp->Parameters.Write.Length));
if( pIrpSp->Parameters.Write.Length == 0)
{
if( pBuffer == NULL)
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSShareWrite Failed to map buffer on pipe %wZ\n",
- &pCcb->DirectoryCB->NameInformation.FileName);
+ &pCcb->DirectoryCB->NameInformation.FileName));
try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
}
+ pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
+
AFSAcquireShared( &pFcb->NPFcb->Resource,
TRUE);
if( !NT_SUCCESS( ntStatus))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSShareWrite (%p) Failed service write Status %08lX\n",
Irp,
- ntStatus);
+ ntStatus));
try_return( ntStatus);
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_PIPE_PROCESSING,
+ AFSDbgTrace(( AFS_SUBSYSTEM_PIPE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSShareWrite Completed on pipe %wZ Length read %08lX\n",
&pCcb->DirectoryCB->NameInformation.FileName,
- stIoResult.BytesProcessed);
+ stIoResult.BytesProcessed));
Irp->IoStatus.Information = stIoResult.BytesProcessed;
git://git.openafs.org / openafs.git / blobdiff