VOID
CdRaiseStatusEx (
_In_ PIRP_CONTEXT IrpContext,
_In_ NTSTATUS Status,
_In_ BOOLEAN NormalizeStatus,
_In_opt_ ULONG FileId,
_In_opt_ ULONG Line
)
{
BOOLEAN BreakIn = FALSE;
AssertVerifyDevice( IrpContext, Status);
if (CdTraceRaises) {
DbgPrint( "%p CdRaiseStatusEx 0x%x @ fid %d, line %d\n", PsGetCurrentThread(), Status, FileId, Line);
}
if (CdTestRaisedStatus && !CdBreakOnAnyRaise) {
ULONG Index;
for (Index = 0;
Index < (sizeof( CdInterestingExceptionCodes) / sizeof( CdInterestingExceptionCodes[0]));
Index++) {
if ((STATUS_SUCCESS != CdInterestingExceptionCodes[Index]) &&
(CdInterestingExceptionCodes[Index] == Status)) {
BreakIn = TRUE;
break;
}
}
}
if (BreakIn || CdBreakOnAnyRaise) {
DbgPrint( "CDFS: Breaking on raised status %08x (BI=%d,BA=%d)\n", Status, BreakIn, CdBreakOnAnyRaise);
DbgPrint( "CDFS: (FILEID %d LINE %d)\n", FileId, Line);
DbgPrint( "CDFS: Contact CDFS.SYS component owner for triage.\n");
DbgPrint( "CDFS: 'eb %p 0;eb %p 0' to disable this alert.\n", &CdTestRaisedStatus, &CdBreakOnAnyRaise);
NT_ASSERT(FALSE);
}
if (NormalizeStatus) {
IrpContext->ExceptionStatus = FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR);
}
else {
IrpContext->ExceptionStatus = Status;
}
IrpContext->RaisedAtLineFile = (FileId << 16) | Line;
ExRaiseStatus( IrpContext->ExceptionStatus);
}
NTSTATUS
CdCommonWrite (
_Inout_ PIRP_CONTEXT IrpContext,
_Inout_ PIRP Irp
)
/*++
Routine Description:
This is the common entry point for NtWriteFile calls. For synchronous requests,
CommonWrite will complete the request in the current thread. If not
synchronous the request will be passed to the Fsp if there is a need to
block.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The result of this operation.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
TYPE_OF_OPEN TypeOfOpen;
PFCB Fcb;
PCCB Ccb;
BOOLEAN Wait;
ULONG SynchronousIo;
PVOID UserBuffer;
LONGLONG StartingOffset;
LONGLONG ByteRange;
ULONG ByteCount;
ULONG WriteByteCount;
ULONG OriginalByteCount;
BOOLEAN ReleaseFile = TRUE;
CD_IO_CONTEXT LocalIoContext;
PAGED_CODE();
//
// If this is a zero length write then return SUCCESS immediately.
//
if (IrpSp->Parameters.Write.Length == 0) {
CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
return STATUS_SUCCESS;
}
//
// Decode the file object and verify we support write on this. It
// must be a volume file.
//
TypeOfOpen = CdDecodeFileObject( IrpContext, IrpSp->FileObject, &Fcb, &Ccb );
// Internal lock object is acquired if return status is STATUS_PENDING
_Analysis_suppress_lock_checking_(Fcb->Resource);
if (TypeOfOpen != UserVolumeOpen) {
CdCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
return STATUS_INVALID_DEVICE_REQUEST;
}
//
// Examine our input parameters to determine if this is noncached and/or
// a paging io operation.
//
Wait = BooleanFlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
SynchronousIo = FlagOn( IrpSp->FileObject->Flags, FO_SYNCHRONOUS_IO );
//
// Extract the range of the Io.
//
StartingOffset = IrpSp->Parameters.Write.ByteOffset.QuadPart;
OriginalByteCount = ByteCount = IrpSp->Parameters.Write.Length;
ByteRange = StartingOffset + ByteCount;
//
// Acquire the file shared to perform the write.
//
CdAcquireFileShared( IrpContext, Fcb );
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// Verify the Fcb. Allow writes if this is a DASD handle that is
// dismounting the volume.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_DISMOUNT_ON_CLOSE )) {
CdVerifyFcbOperation( IrpContext, Fcb );
}
if (!FlagOn( Ccb->Flags, CCB_FLAG_ALLOW_EXTENDED_DASD_IO )) {
//
// Complete the request if it begins beyond the end of file.
//
if (StartingOffset >= Fcb->FileSize.QuadPart) {
try_return( Status = STATUS_END_OF_FILE );
}
//
// Truncate the write if it extends beyond the end of the file.
//
if (ByteRange > Fcb->FileSize.QuadPart) {
ByteCount = (ULONG) (Fcb->FileSize.QuadPart - StartingOffset);
ByteRange = Fcb->FileSize.QuadPart;
}
}
//
// If we have an unaligned transfer then post this request if
// we can't wait. Unaligned means that the starting offset
// is not on a sector boundary or the write is not integral
// sectors.
//
WriteByteCount = BlockAlign( Fcb->Vcb, ByteCount );
if (SectorOffset( StartingOffset ) ||
SectorOffset( WriteByteCount ) ||
(WriteByteCount > OriginalByteCount)) {
if (!Wait) {
CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
}
//
// Make sure we don't overwrite the buffer.
//
WriteByteCount = ByteCount;
}
//
// Initialize the IoContext for the write.
// If there is a context pointer, we need to make sure it was
// allocated and not a stale stack pointer.
//
if (IrpContext->IoContext == NULL ||
!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO )) {
//
// If we can wait, use the context on the stack. Otherwise
// we need to allocate one.
//
if (Wait) {
IrpContext->IoContext = &LocalIoContext;
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO );
} else {
IrpContext->IoContext = CdAllocateIoContext();
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO );
}
}
RtlZeroMemory( IrpContext->IoContext, sizeof( CD_IO_CONTEXT ) );
//
// Store whether we allocated this context structure in the structure
// itself.
//
IrpContext->IoContext->AllocatedContext =
BooleanFlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO );
if (Wait) {
KeInitializeEvent( &IrpContext->IoContext->SyncEvent,
NotificationEvent,
FALSE );
} else {
IrpContext->IoContext->ResourceThreadId = ExGetCurrentResourceThread();
IrpContext->IoContext->Resource = Fcb->Resource;
IrpContext->IoContext->RequestedByteCount = ByteCount;
}
Irp->IoStatus.Information = WriteByteCount;
//
// Set the FO_MODIFIED flag here to trigger a verify when this
// handle is closed. Note that we can err on the conservative
// side with no problem, i.e. if we accidently do an extra
// verify there is no problem.
//
SetFlag( IrpSp->FileObject->Flags, FO_FILE_MODIFIED );
//
// Dasd access is always non-cached. Call the Dasd write routine to
// perform the actual write.
//
Status = CdVolumeDasdWrite( IrpContext, Fcb, StartingOffset, WriteByteCount );
//
// Don't complete this request now if STATUS_PENDING was returned.
//
if (Status == STATUS_PENDING) {
Irp = NULL;
ReleaseFile = FALSE;
//
// Test is we should zero part of the buffer or update the
// synchronous file position.
//
} else {
//
// Convert any unknown error code to IO_ERROR.
//
if (!NT_SUCCESS( Status )) {
//
// Set the information field to zero.
//
Irp->IoStatus.Information = 0;
//
// Raise if this is a user induced error.
//
if (IoIsErrorUserInduced( Status )) {
CdRaiseStatus( IrpContext, Status );
}
Status = FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR );
//
// Check if there is any portion of the user's buffer to zero.
//
} else if (WriteByteCount != ByteCount) {
CdMapUserBuffer( IrpContext, &UserBuffer );
SafeZeroMemory( IrpContext,
Add2Ptr( UserBuffer,
ByteCount,
PVOID ),
WriteByteCount - ByteCount );
Irp->IoStatus.Information = ByteCount;
}
//
// Update the file position if this is a synchronous request.
//
if (SynchronousIo && NT_SUCCESS( Status )) {
IrpSp->FileObject->CurrentByteOffset.QuadPart = ByteRange;
}
}
try_exit: NOTHING;
} finally {
//
// Release the Fcb.
//
if (ReleaseFile) {
CdReleaseFile( IrpContext, Fcb );
}
}
//
// Post the request if we got CANT_WAIT.
//
if (Status == STATUS_CANT_WAIT) {
Status = CdFsdPostRequest( IrpContext, Irp );
//
// Otherwise complete the request.
//
} else {
CdCompleteRequest( IrpContext, Irp, Status );
}
return Status;
}
VOID
CcMdlWriteComplete2 (
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PMDL MdlChain
)
/*++
Routine Description:
This routine must be called at IPL0 after a call to CcPrepareMdlWrite.
The caller supplies the ActualLength of data that it actually wrote
into the buffer, which may be less than or equal to the Length specified
in CcPrepareMdlWrite.
This call does the following:
Makes sure the data up to ActualLength eventually gets written.
If WriteThrough is FALSE, the data will not be written immediately.
If WriteThrough is TRUE, then the data is written synchronously.
Unmaps the pages (if mapped), unlocks them and deletes the MdlChain
Arguments:
FileObject - Pointer to the file object for a file which was
opened with NO_INTERMEDIATE_BUFFERING clear, i.e., for
which CcInitializeCacheMap was called by the file system.
FileOffset - Original file offset read above.
MdlChain - same as returned from corresponding call to CcPrepareMdlWrite.
Return Value:
None
--*/
{
PMDL MdlNext;
PSHARED_CACHE_MAP SharedCacheMap;
LARGE_INTEGER FOffset;
IO_STATUS_BLOCK IoStatus;
KIRQL OldIrql;
NTSTATUS StatusToRaise = STATUS_SUCCESS;
DebugTrace(+1, me, "CcMdlWriteComplete\n", 0 );
DebugTrace( 0, me, " FileObject = %08lx\n", FileObject );
DebugTrace( 0, me, " MdlChain = %08lx\n", MdlChain );
SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap;
//
// Deallocate the Mdls
//
FOffset.QuadPart = *(LONGLONG UNALIGNED *)FileOffset;
while (MdlChain != NULL) {
MdlNext = MdlChain->Next;
DebugTrace( 0, mm, "MmUnlockPages/IoFreeMdl:\n", 0 );
DebugTrace( 0, mm, " Mdl = %08lx\n", MdlChain );
//
// Now clear the dirty bits in the Pte and set them in the
// Pfn.
//
MmUnlockPages( MdlChain );
//
// Extract the File Offset for this part of the transfer.
//
if (FlagOn(FileObject->Flags, FO_WRITE_THROUGH)) {
MmFlushSection ( FileObject->SectionObjectPointer,
&FOffset,
MdlChain->ByteCount,
&IoStatus,
TRUE );
//
// If we got an I/O error, remember it.
//
if (!NT_SUCCESS(IoStatus.Status)) {
StatusToRaise = IoStatus.Status;
}
} else {
//
// Ignore the only exception (allocation error), and console
// ourselves for having tried.
//
CcSetDirtyInMask( SharedCacheMap, &FOffset, MdlChain->ByteCount );
}
FOffset.QuadPart = FOffset.QuadPart + (LONGLONG)(MdlChain->ByteCount);
IoFreeMdl( MdlChain );
MdlChain = MdlNext;
}
//
// Now release our open count.
//
CcAcquireMasterLock( &OldIrql );
CcDecrementOpenCount( SharedCacheMap, 'ldmC' );
if ((SharedCacheMap->OpenCount == 0) &&
!FlagOn(SharedCacheMap->Flags, WRITE_QUEUED) &&
(SharedCacheMap->DirtyPages == 0)) {
//
// Move to the dirty list.
//
RemoveEntryList( &SharedCacheMap->SharedCacheMapLinks );
InsertTailList( &CcDirtySharedCacheMapList.SharedCacheMapLinks,
&SharedCacheMap->SharedCacheMapLinks );
//
// Make sure the Lazy Writer will wake up, because we
// want him to delete this SharedCacheMap.
//
LazyWriter.OtherWork = TRUE;
if (!LazyWriter.ScanActive) {
CcScheduleLazyWriteScan();
}
}
CcReleaseMasterLock( OldIrql );
//
// If we got an I/O error, raise it now.
//
if (!NT_SUCCESS(StatusToRaise)) {
FsRtlNormalizeNtstatus( StatusToRaise,
STATUS_UNEXPECTED_IO_ERROR );
}
DebugTrace(-1, me, "CcMdlWriteComplete -> TRUE\n", 0 );
return;
}
