/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
Flush.c
Abstract:
This module implements the File Flush buffers routine for Rx called by the
dispatch driver.
In a future version of the wrapper, it may be that flush will be routed thru lowio.
Author:
Joe Linn [JoeLinn] 15-dec-1994
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
//
// The local debug trace level
//
#define Dbg (DEBUG_TRACE_FLUSH)
//RXSTATUS
//RxLowIoFlushShell (
// IN PRX_CONTEXT RxContext
// );
//
//RXSTATUS
//RxLowIoFlushShellCompletion (
// IN PRX_CONTEXT RxContext
// );
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxCommonFlushBuffers)
#pragma alloc_text(PAGE, RxFlushFile)
#endif
NTSTATUS
RxCommonFlushBuffers ( RXCOMMON_SIGNATURE )
/*++
Routine Description:
This is the common routine for flushing file buffers.
Arguments:
Irp - Supplies the Irp to process
Return Value:
RXSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
RxCaptureRequestPacket;
RxCaptureFcb; RxCaptureFobx; RxCaptureParamBlock; RxCaptureFileObject;
NODE_TYPE_CODE TypeOfOpen = NodeType(capFcb);
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
BOOLEAN FcbAcquired = FALSE;
PAGED_CODE();
RxDbgTrace(+1, Dbg, ("RxCommonFlush...IrpC %08lx, Fobx %08lx, Fcb %08lx\n",
RxContext, capFobx, capFcb));
RxLog(("%s %lx %lx %lx\n","slF",RxContext,capFcb,capFobx));
//
// CcFlushCache is always synchronous, so if we can't wait enqueue
// the irp to the Fsp.
if ( !FlagOn(RxContext->Flags, RX_CONTEXT_FLAG_WAIT) ) {
Status = RxFsdPostRequest( RxContext );
RxDbgTrace(-1, Dbg, ("RxCommonFlushBuffers -> %08lx\n", Status ));
return Status;
}
Status = STATUS_SUCCESS;
try {
//
// Case on the type of open that we are trying to flush
//
switch (TypeOfOpen) {
case RDBSS_NTC_STORAGE_TYPE_FILE:
RxDbgTrace(0, Dbg, ("Flush User File Open\n", 0));
Status = RxAcquireExclusiveFcb( RxContext, capFcb );
if (Status != STATUS_SUCCESS) break;
FcbAcquired = TRUE;
//
// If the file is cached then flush its cache
//
Status = RxFlushFile( RxContext, capFcb );
if (!NT_SUCCESS( Status )) break;
//rdrs don't do this.....only local FSs
////
//// Check if we should be changing the time or file size
//
//RxAdjustFileTimesAndSize(RXCOMMON_ARGUMENTS);
// if we make this lowio.........
////
//// Initialize LowIO_CONTEXT block in the RxContext and Calldown
//
//RxInitializeLowIoContext(LowIoContext,LOWIO_OP_FLUSH);
//
//Status = RxLowIoFlushShell(RxContext);
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxFlush,(RxContext));
break;
case RDBSS_NTC_SPOOLFILE:
RxDbgTrace(0, Dbg, ("Flush Sppol File\n", 0));
Status = RxAcquireExclusiveFcb( RxContext, capFcb );
if (Status != STATUS_SUCCESS) break;
FcbAcquired = TRUE;
// should this be low io???
////
//// Initialize LowIO_CONTEXT block in the RxContext and Calldown
//
//RxInitializeLowIoContext(LowIoContext,LOWIO_OP_FLUSH);
//
//Status = RxLowIoFlushShell(RxContext);
MINIRDR_CALL(Status,RxContext,capFcb->MRxDispatch,MRxFlush,(RxContext));
break;
default:
Status = STATUS_INVALID_DEVICE_REQUEST;
}
} finally {
DebugUnwind( RxCommonFlushBuffers );
if (FcbAcquired) { RxReleaseFcb( RxContext, capFcb ); }
//
// If this is a normal termination then pass the request on
// to the target device object.
//
if (!AbnormalTermination()) {
NOTHING;
}
}
RxDbgTrace(-1, Dbg, ("RxCommonFlushBuffers -> %08lx\n", Status));
return Status;
}
#if 0
BUGBUG
THIS CODE WOULD BE USED IF THIS IS CHANGED TO LOWIO
NTSTATUS
RxLowIoFlushShellCompletion (
IN PRX_CONTEXT RxContext
)
/*++
Routine Description:
these completion shells are pretty similar. BUT as the error handling gets more
robust the routines will become increasingly dissimilar. for flush, everything is synchronous...that's
a difference with read/write/lock; we keep the same declarations and format for later when we decide to roll up the
common part of these routines.
This routine postprocesses a flush request after it comes back from the
minirdr. It is the complement of LowIoFlushShell.
Arguments:
RxContext - the usual
Return Value:
whatever value supplied by the caller or STATUS_MORE_PROCESSING_REQUIRED.
--*/
{
NTSTATUS Status;
RxCaptureRequestPacket;
RxCaptureFcb; RxCaptureFobx; RxCaptureParamBlock;
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
BOOLEAN SynchronousIo = !BooleanFlagOn(RxContext->Flags,RX_CONTEXT_FLAG_ASYNC_OPERATION);
BOOLEAN PagingIo = BooleanFlagOn(capReqPacket->Flags, IRP_PAGING_IO);
ERESOURCE_THREAD ThisResourceThreadId;
Status = RxContext->StoredStatus;
RxDbgTrace(+1, Dbg, ("RxLowIoFlushShellCompletion entry Status = %08lx\n", Status));
RxLog(("FlshShlComp %x\n",RxContext));
//switch (Status) {
//case STATUS_SUCCESS:
// break;
//case STATUS_CONNECTION_INVALID:
// //joejoe here is where the failover will happen
// //first we give the local guy current minirdr another chance...then we go
// //to fullscale retry
// //return(RxStatus(DISCONNECTED)); //special....let LowIo get us back
// break;
//}
capReqPacket->IoStatus.Status = Status;
RxDbgTrace(-1, Dbg, ("RxLowIoFlushShellCompletion exit Status = %08lx\n", Status));
return(Status);
//NOTE THAT THE ASYNC COMPLETION TAIL IS MISSING
}
#define RxSdwFlush(RXCONTEXT) {NOTHING;}
}
NTSTATUS
RxLowIoFlushShell (
IN PRX_CONTEXT RxContext
)
/*++
Routine Description:
This routine preprocesses a Flush request before it goes down to the minirdr. It does callouts
to handle compression, buffering and shadowing. It is the opposite number of LowIoFlushShellCompletion.
By the time we get here, we are going to the wire.
Flush buffering was already tried in the UncachedFlush strategy
Arguments:
RxContext - the usual
Return Value:
whatever value is returned by a callout....or by LowIo.
--*/
{
NTSTATUS Status;
RxCaptureFcb; RxCaptureFobx; RxCaptureParamBlock;
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
RxDbgTrace(+1, Dbg, ("RxLowIoFlushShell entry %08lx\n", 0));
RxLog(("FlshShl in%x\n",RxContext));
if (FlagOn(Fcb->FcbState, FCB_STATE_FILE_IS_SHADOWED)) {
RxSdwFlush(RxContext);
}
Status = RxLowIoSubmit(RxContext,RxLowIoFlushShellCompletion);
RxDbgTrace(-1, Dbg, ("RxLowIoFlushShell exit Status = %08lx\n", Status));
return(Status);
}
#endif