mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1652 lines
45 KiB
1652 lines
45 KiB
/*++
|
|
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Read.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the File Read routine for Read called by the
|
|
dispatch driver.
|
|
|
|
// @@BEGIN_DDKSPLIT
|
|
|
|
Author:
|
|
|
|
David Goebel [DavidGoe] 28-Feb-1991
|
|
|
|
Revision History:
|
|
|
|
// @@END_DDKSPLIT
|
|
|
|
--*/
|
|
|
|
#include "FatProcs.h"
|
|
|
|
//
|
|
// The Bug check file id for this module
|
|
//
|
|
|
|
#define BugCheckFileId (FAT_BUG_CHECK_READ)
|
|
|
|
//
|
|
// The local debug trace level
|
|
//
|
|
|
|
#define Dbg (DEBUG_TRACE_READ)
|
|
|
|
//
|
|
// Define stack overflow read threshhold. For the x86 we'll use a smaller
|
|
// threshold than for a risc platform.
|
|
//
|
|
// Empirically, the limit is a result of the (large) amount of stack
|
|
// neccesary to throw an exception.
|
|
//
|
|
|
|
#if defined(_M_IX86)
|
|
#define OVERFLOW_READ_THRESHHOLD (0xE00)
|
|
#else
|
|
#define OVERFLOW_READ_THRESHHOLD (0x1000)
|
|
#endif // defined(_M_IX86)
|
|
|
|
|
|
//
|
|
// The following procedures handles read stack overflow operations.
|
|
//
|
|
|
|
VOID
|
|
FatStackOverflowRead (
|
|
IN PVOID Context,
|
|
IN PKEVENT Event
|
|
);
|
|
|
|
NTSTATUS
|
|
FatPostStackOverflowRead (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PIRP Irp,
|
|
IN PFCB Fcb
|
|
);
|
|
|
|
VOID
|
|
FatOverflowPagingFileRead (
|
|
IN PVOID Context,
|
|
IN PKEVENT Event
|
|
);
|
|
|
|
//
|
|
// VOID
|
|
// SafeZeroMemory (
|
|
// IN PUCHAR At,
|
|
// IN ULONG ByteCount
|
|
// );
|
|
//
|
|
|
|
//
|
|
// This macro just puts a nice little try-except around RtlZeroMemory
|
|
//
|
|
|
|
#define SafeZeroMemory(AT,BYTE_COUNT) { \
|
|
try { \
|
|
RtlZeroMemory((AT), (BYTE_COUNT)); \
|
|
} except(EXCEPTION_EXECUTE_HANDLER) { \
|
|
FatRaiseStatus( IrpContext, STATUS_INVALID_USER_BUFFER ); \
|
|
} \
|
|
}
|
|
|
|
//
|
|
// Macro to increment appropriate performance counters.
|
|
//
|
|
|
|
#define CollectReadStats(VCB,OPEN_TYPE,BYTE_COUNT) { \
|
|
PFILESYSTEM_STATISTICS Stats = &(VCB)->Statistics[KeGetCurrentProcessorNumber()].Common; \
|
|
if (((OPEN_TYPE) == UserFileOpen)) { \
|
|
Stats->UserFileReads += 1; \
|
|
Stats->UserFileReadBytes += (ULONG)(BYTE_COUNT); \
|
|
} else if (((OPEN_TYPE) == VirtualVolumeFile || ((OPEN_TYPE) == DirectoryFile))) { \
|
|
Stats->MetaDataReads += 1; \
|
|
Stats->MetaDataReadBytes += (ULONG)(BYTE_COUNT); \
|
|
} \
|
|
}
|
|
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, FatStackOverflowRead)
|
|
#pragma alloc_text(PAGE, FatPostStackOverflowRead)
|
|
#pragma alloc_text(PAGE, FatCommonRead)
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
FatFsdRead (
|
|
IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the driver entry to the common read routine for NtReadFile calls.
|
|
For synchronous requests, the CommonRead is called with Wait == TRUE,
|
|
which means the request will always be completed in the current thread,
|
|
and never passed to the Fsp. If it is not a synchronous request,
|
|
CommonRead is called with Wait == FALSE, which means the request
|
|
will be passed to the Fsp only if there is a need to block.
|
|
|
|
Arguments:
|
|
|
|
VolumeDeviceObject - Supplies the volume device object where the
|
|
file being Read exists
|
|
|
|
Irp - Supplies the Irp being processed
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The FSD status for the IRP
|
|
|
|
--*/
|
|
|
|
{
|
|
PFCB Fcb;
|
|
NTSTATUS Status;
|
|
PIRP_CONTEXT IrpContext = NULL;
|
|
|
|
BOOLEAN TopLevel;
|
|
|
|
DebugTrace(+1, Dbg, "FatFsdRead\n", 0);
|
|
|
|
//
|
|
// Call the common Read routine, with blocking allowed if synchronous
|
|
//
|
|
|
|
FsRtlEnterFileSystem();
|
|
|
|
//
|
|
// We are first going to do a quick check for paging file IO. Since this
|
|
// is a fast path, we must replicate the check for the fsdo.
|
|
//
|
|
|
|
if (!FatDeviceIsFatFsdo( IoGetCurrentIrpStackLocation(Irp)->DeviceObject)) {
|
|
|
|
Fcb = (PFCB)(IoGetCurrentIrpStackLocation(Irp)->FileObject->FsContext);
|
|
|
|
if ((NodeType(Fcb) == FAT_NTC_FCB) &&
|
|
FlagOn(Fcb->FcbState, FCB_STATE_PAGING_FILE)) {
|
|
|
|
//
|
|
// Do the usual STATUS_PENDING things.
|
|
//
|
|
|
|
IoMarkIrpPending( Irp );
|
|
|
|
//
|
|
// If there is not enough stack to do this read, then post this
|
|
// read to the overflow queue.
|
|
//
|
|
|
|
if (IoGetRemainingStackSize() < OVERFLOW_READ_THRESHHOLD) {
|
|
|
|
KEVENT Event;
|
|
PAGING_FILE_OVERFLOW_PACKET Packet;
|
|
|
|
Packet.Irp = Irp;
|
|
Packet.Fcb = Fcb;
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
FsRtlPostPagingFileStackOverflow( &Packet, &Event, FatOverflowPagingFileRead );
|
|
|
|
//
|
|
// And wait for the worker thread to complete the item
|
|
//
|
|
|
|
(VOID) KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Perform the actual IO, it will be completed when the io finishes.
|
|
//
|
|
|
|
FatPagingFileIo( Irp, Fcb );
|
|
}
|
|
|
|
FsRtlExitFileSystem();
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
}
|
|
|
|
try {
|
|
|
|
TopLevel = FatIsIrpTopLevel( Irp );
|
|
|
|
IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ) );
|
|
|
|
//
|
|
// If this is an Mdl complete request, don't go through
|
|
// common read.
|
|
//
|
|
|
|
if ( FlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE) ) {
|
|
|
|
DebugTrace(0, Dbg, "Calling FatCompleteMdl\n", 0 );
|
|
try_return( Status = FatCompleteMdl( IrpContext, Irp ));
|
|
}
|
|
|
|
//
|
|
// Check if we have enough stack space to process this request. If there
|
|
// isn't enough then we will pass the request off to the stack overflow thread.
|
|
//
|
|
|
|
if (IoGetRemainingStackSize() < OVERFLOW_READ_THRESHHOLD) {
|
|
|
|
DebugTrace(0, Dbg, "Passing StackOverflowRead off\n", 0 );
|
|
try_return( Status = FatPostStackOverflowRead( IrpContext, Irp, Fcb ) );
|
|
}
|
|
|
|
Status = FatCommonRead( IrpContext, Irp );
|
|
|
|
try_exit: NOTHING;
|
|
} except(FatExceptionFilter( IrpContext, GetExceptionInformation() )) {
|
|
|
|
//
|
|
// We had some trouble trying to perform the requested
|
|
// operation, so we'll abort the I/O request with
|
|
// the error status that we get back from the
|
|
// execption code
|
|
//
|
|
|
|
Status = FatProcessException( IrpContext, Irp, GetExceptionCode() );
|
|
}
|
|
|
|
if (TopLevel) { IoSetTopLevelIrp( NULL ); }
|
|
|
|
FsRtlExitFileSystem();
|
|
|
|
//
|
|
// And return to our caller
|
|
//
|
|
|
|
DebugTrace(-1, Dbg, "FatFsdRead -> %08lx\n", Status);
|
|
|
|
UNREFERENCED_PARAMETER( VolumeDeviceObject );
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
//
|
|
// Internal support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
FatPostStackOverflowRead (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PIRP Irp,
|
|
IN PFCB Fcb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine posts a read request that could not be processed by
|
|
the fsp thread because of stack overflow potential.
|
|
|
|
Arguments:
|
|
|
|
Irp - Supplies the request to process.
|
|
|
|
Fcb - Supplies the file.
|
|
|
|
Return Value:
|
|
|
|
STATUS_PENDING.
|
|
|
|
--*/
|
|
|
|
{
|
|
KEVENT Event;
|
|
PERESOURCE Resource;
|
|
PVCB Vcb;
|
|
|
|
DebugTrace(0, Dbg, "Getting too close to stack limit pass request to Fsp\n", 0 );
|
|
|
|
//
|
|
// Initialize an event and get shared on the resource we will
|
|
// be later using the common read.
|
|
//
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
//
|
|
// Preacquire the resource the read path will require so we know the
|
|
// worker thread can proceed without waiting.
|
|
//
|
|
|
|
if (FlagOn(Irp->Flags, IRP_PAGING_IO) && (Fcb->Header.PagingIoResource != NULL)) {
|
|
|
|
Resource = Fcb->Header.PagingIoResource;
|
|
|
|
} else {
|
|
|
|
Resource = Fcb->Header.Resource;
|
|
}
|
|
|
|
//
|
|
// If there are no resources assodicated with the file (case: the virtual
|
|
// volume file), it is OK. No resources will be acquired on the other side
|
|
// as well.
|
|
//
|
|
|
|
if (Resource) {
|
|
|
|
ExAcquireResourceSharedLite( Resource, TRUE );
|
|
}
|
|
|
|
if (NodeType( Fcb ) == FAT_NTC_VCB) {
|
|
|
|
Vcb = (PVCB) Fcb;
|
|
|
|
} else {
|
|
|
|
Vcb = Fcb->Vcb;
|
|
}
|
|
|
|
try {
|
|
|
|
//
|
|
// Make the Irp just like a regular post request and
|
|
// then send the Irp to the special overflow thread.
|
|
// After the post we will wait for the stack overflow
|
|
// read routine to set the event that indicates we can
|
|
// now release the scb resource and return.
|
|
//
|
|
|
|
FatPrePostIrp( IrpContext, Irp );
|
|
|
|
//
|
|
// If this read is the result of a verify, we have to
|
|
// tell the overflow read routne to temporarily
|
|
// hijack the Vcb->VerifyThread field so that reads
|
|
// can go through.
|
|
//
|
|
|
|
if (Vcb->VerifyThread == KeGetCurrentThread()) {
|
|
|
|
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_VERIFY_READ);
|
|
}
|
|
|
|
FsRtlPostStackOverflow( IrpContext, &Event, FatStackOverflowRead );
|
|
|
|
//
|
|
// And wait for the worker thread to complete the item
|
|
//
|
|
|
|
KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
|
|
|
|
} finally {
|
|
|
|
if (Resource) {
|
|
|
|
ExReleaseResourceLite( Resource );
|
|
}
|
|
}
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
|
|
//
|
|
// Internal support routine
|
|
//
|
|
|
|
VOID
|
|
FatStackOverflowRead (
|
|
IN PVOID Context,
|
|
IN PKEVENT Event
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine processes a read request that could not be processed by
|
|
the fsp thread because of stack overflow potential.
|
|
|
|
Arguments:
|
|
|
|
Context - Supplies the IrpContext being processed
|
|
|
|
Event - Supplies the event to be signaled when we are done processing this
|
|
request.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIRP_CONTEXT IrpContext = Context;
|
|
PKTHREAD SavedVerifyThread = NULL;
|
|
PVCB Vcb;
|
|
|
|
//
|
|
// Make it now look like we can wait for I/O to complete
|
|
//
|
|
|
|
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
|
|
|
|
//
|
|
// If this read was as the result of a verify we have to fake out the
|
|
// the Vcb->VerifyThread field.
|
|
//
|
|
|
|
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_VERIFY_READ)) {
|
|
|
|
PFCB Fcb = (PFCB)IoGetCurrentIrpStackLocation(IrpContext->OriginatingIrp)->
|
|
FileObject->FsContext;
|
|
|
|
if (NodeType( Fcb ) == FAT_NTC_VCB) {
|
|
|
|
Vcb = (PVCB) Fcb;
|
|
|
|
} else {
|
|
|
|
Vcb = Fcb->Vcb;
|
|
}
|
|
|
|
ASSERT( Vcb->VerifyThread != NULL );
|
|
SavedVerifyThread = Vcb->VerifyThread;
|
|
Vcb->VerifyThread = KeGetCurrentThread();
|
|
}
|
|
|
|
//
|
|
// Do the read operation protected by a try-except clause
|
|
//
|
|
|
|
try {
|
|
|
|
(VOID) FatCommonRead( IrpContext, IrpContext->OriginatingIrp );
|
|
|
|
} except(FatExceptionFilter( IrpContext, GetExceptionInformation() )) {
|
|
|
|
NTSTATUS ExceptionCode;
|
|
|
|
//
|
|
// We had some trouble trying to perform the requested
|
|
// operation, so we'll abort the I/O request with
|
|
// the error status that we get back from the
|
|
// execption code
|
|
//
|
|
|
|
ExceptionCode = GetExceptionCode();
|
|
|
|
if (ExceptionCode == STATUS_FILE_DELETED) {
|
|
|
|
IrpContext->ExceptionStatus = ExceptionCode = STATUS_END_OF_FILE;
|
|
IrpContext->OriginatingIrp->IoStatus.Information = 0;
|
|
}
|
|
|
|
(VOID) FatProcessException( IrpContext, IrpContext->OriginatingIrp, ExceptionCode );
|
|
}
|
|
|
|
//
|
|
// Restore the original VerifyVolumeThread
|
|
//
|
|
|
|
if (SavedVerifyThread != NULL) {
|
|
|
|
ASSERT( Vcb->VerifyThread == KeGetCurrentThread() );
|
|
Vcb->VerifyThread = SavedVerifyThread;
|
|
}
|
|
|
|
//
|
|
// Set the stack overflow item's event to tell the original
|
|
// thread that we're done.
|
|
//
|
|
|
|
KeSetEvent( Event, 0, FALSE );
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
FatCommonRead (
|
|
IN PIRP_CONTEXT IrpContext,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the common read routine for NtReadFile, called from both
|
|
the Fsd, or from the Fsp if a request could not be completed without
|
|
blocking in the Fsd. This routine has no code where it determines
|
|
whether it is running in the Fsd or Fsp. Instead, its actions are
|
|
conditionalized by the Wait input parameter, which determines whether
|
|
it is allowed to block or not. If a blocking condition is encountered
|
|
with Wait == FALSE, however, the request is posted to the Fsp, who
|
|
always calls with WAIT == TRUE.
|
|
|
|
Arguments:
|
|
|
|
Irp - Supplies the Irp to process
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
|
|
{
|
|
PVCB Vcb;
|
|
PFCB FcbOrDcb;
|
|
PCCB Ccb;
|
|
|
|
VBO StartingVbo;
|
|
ULONG ByteCount;
|
|
ULONG RequestedByteCount;
|
|
|
|
PIO_STACK_LOCATION IrpSp;
|
|
PFILE_OBJECT FileObject;
|
|
TYPE_OF_OPEN TypeOfOpen;
|
|
|
|
BOOLEAN PostIrp = FALSE;
|
|
BOOLEAN OplockPostIrp = FALSE;
|
|
|
|
BOOLEAN FcbOrDcbAcquired = FALSE;
|
|
|
|
BOOLEAN Wait;
|
|
BOOLEAN PagingIo;
|
|
BOOLEAN NonCachedIo;
|
|
BOOLEAN SynchronousIo;
|
|
|
|
NTSTATUS Status;
|
|
|
|
FAT_IO_CONTEXT StackFatIoContext;
|
|
|
|
//
|
|
// A system buffer is only used if we have to access the
|
|
// buffer directly from the Fsp to clear a portion or to
|
|
// do a synchronous I/O, or a cached transfer. It is
|
|
// possible that our caller may have already mapped a
|
|
// system buffer, in which case we must remember this so
|
|
// we do not unmap it on the way out.
|
|
//
|
|
|
|
PVOID SystemBuffer = NULL;
|
|
|
|
LARGE_INTEGER StartingByte;
|
|
|
|
//
|
|
// Get current Irp stack location.
|
|
//
|
|
|
|
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
FileObject = IrpSp->FileObject;
|
|
|
|
//
|
|
// Initialize the appropriate local variables.
|
|
//
|
|
|
|
Wait = BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
|
|
PagingIo = BooleanFlagOn(Irp->Flags, IRP_PAGING_IO);
|
|
NonCachedIo = BooleanFlagOn(Irp->Flags,IRP_NOCACHE);
|
|
SynchronousIo = BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO);
|
|
|
|
DebugTrace(+1, Dbg, "CommonRead\n", 0);
|
|
DebugTrace( 0, Dbg, " Irp = %8lx\n", Irp);
|
|
DebugTrace( 0, Dbg, " ->ByteCount = %8lx\n", IrpSp->Parameters.Read.Length);
|
|
DebugTrace( 0, Dbg, " ->ByteOffset.LowPart = %8lx\n", IrpSp->Parameters.Read.ByteOffset.LowPart);
|
|
DebugTrace( 0, Dbg, " ->ByteOffset.HighPart = %8lx\n", IrpSp->Parameters.Read.ByteOffset.HighPart);
|
|
|
|
//
|
|
// Extract starting Vbo and offset.
|
|
//
|
|
|
|
StartingByte = IrpSp->Parameters.Read.ByteOffset;
|
|
|
|
StartingVbo = StartingByte.LowPart;
|
|
|
|
ByteCount = IrpSp->Parameters.Read.Length;
|
|
RequestedByteCount = ByteCount;
|
|
|
|
//
|
|
// Check for a null request, and return immediately
|
|
//
|
|
|
|
if (ByteCount == 0) {
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Extract the nature of the read from the file object, and case on it
|
|
//
|
|
|
|
TypeOfOpen = FatDecodeFileObject(FileObject, &Vcb, &FcbOrDcb, &Ccb);
|
|
|
|
ASSERT( Vcb != NULL );
|
|
|
|
//
|
|
// Save callers who try to do cached IO to the raw volume from themselves.
|
|
//
|
|
|
|
if (TypeOfOpen == UserVolumeOpen) {
|
|
|
|
NonCachedIo = TRUE;
|
|
}
|
|
|
|
ASSERT(!(NonCachedIo == FALSE && TypeOfOpen == VirtualVolumeFile));
|
|
|
|
//
|
|
// Collect interesting statistics. The FLAG_USER_IO bit will indicate
|
|
// what type of io we're doing in the FatNonCachedIo function.
|
|
//
|
|
|
|
if (PagingIo) {
|
|
CollectReadStats(Vcb, TypeOfOpen, ByteCount);
|
|
|
|
if (TypeOfOpen == UserFileOpen) {
|
|
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_USER_IO);
|
|
} else {
|
|
ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_USER_IO);
|
|
}
|
|
}
|
|
|
|
ASSERT(!FlagOn( IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT ));
|
|
|
|
//
|
|
// Allocate if necessary and initialize a FAT_IO_CONTEXT block for
|
|
// all non cached Io. For synchronous Io we use stack storage,
|
|
// otherwise we allocate pool.
|
|
//
|
|
|
|
if (NonCachedIo) {
|
|
|
|
if (IrpContext->FatIoContext == NULL) {
|
|
|
|
if (!Wait) {
|
|
|
|
IrpContext->FatIoContext =
|
|
FsRtlAllocatePoolWithTag( NonPagedPool,
|
|
sizeof(FAT_IO_CONTEXT),
|
|
TAG_FAT_IO_CONTEXT );
|
|
|
|
} else {
|
|
|
|
IrpContext->FatIoContext = &StackFatIoContext;
|
|
|
|
SetFlag( IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT );
|
|
}
|
|
}
|
|
|
|
RtlZeroMemory( IrpContext->FatIoContext, sizeof(FAT_IO_CONTEXT) );
|
|
|
|
if (Wait) {
|
|
|
|
KeInitializeEvent( &IrpContext->FatIoContext->Wait.SyncEvent,
|
|
NotificationEvent,
|
|
FALSE );
|
|
|
|
} else {
|
|
|
|
IrpContext->FatIoContext->Wait.Async.ResourceThreadId =
|
|
ExGetCurrentResourceThread();
|
|
|
|
IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
|
|
ByteCount;
|
|
|
|
IrpContext->FatIoContext->Wait.Async.FileObject = FileObject;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// These two cases correspond to either a general opened volume, ie.
|
|
// open ("a:"), or a read of the volume file (boot sector + fat(s))
|
|
//
|
|
|
|
if ((TypeOfOpen == VirtualVolumeFile) ||
|
|
(TypeOfOpen == UserVolumeOpen)) {
|
|
|
|
LBO StartingLbo;
|
|
|
|
StartingLbo = StartingByte.QuadPart;
|
|
|
|
DebugTrace(0, Dbg, "Type of read is User Volume or virtual volume file\n", 0);
|
|
|
|
if (TypeOfOpen == UserVolumeOpen) {
|
|
|
|
//
|
|
// Verify that the volume for this handle is still valid
|
|
//
|
|
|
|
//
|
|
// Verify that the volume for this handle is still valid, permitting
|
|
// operations to proceed on dismounted volumes via the handle which
|
|
// performed the dismount.
|
|
//
|
|
|
|
if (!FlagOn( Ccb->Flags, CCB_FLAG_COMPLETE_DISMOUNT )) {
|
|
|
|
FatQuickVerifyVcb( IrpContext, Vcb );
|
|
}
|
|
|
|
if (!FlagOn( Ccb->Flags, CCB_FLAG_DASD_FLUSH_DONE )) {
|
|
|
|
(VOID)ExAcquireResourceExclusiveLite( &Vcb->Resource, TRUE );
|
|
|
|
try {
|
|
|
|
//
|
|
// If the volume isn't locked, flush it.
|
|
//
|
|
|
|
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_LOCKED)) {
|
|
|
|
FatFlushVolume( IrpContext, Vcb, Flush );
|
|
}
|
|
|
|
} finally {
|
|
|
|
ExReleaseResourceLite( &Vcb->Resource );
|
|
}
|
|
|
|
SetFlag( Ccb->Flags, CCB_FLAG_DASD_FLUSH_DONE );
|
|
}
|
|
|
|
if (!FlagOn( Ccb->Flags, CCB_FLAG_ALLOW_EXTENDED_DASD_IO )) {
|
|
|
|
LBO VolumeSize;
|
|
|
|
//
|
|
// Make sure we don't try to read past end of volume,
|
|
// reducing the byte count if necessary.
|
|
//
|
|
|
|
VolumeSize = (LBO) Vcb->Bpb.BytesPerSector *
|
|
(Vcb->Bpb.Sectors != 0 ? Vcb->Bpb.Sectors :
|
|
Vcb->Bpb.LargeSectors);
|
|
|
|
if (StartingLbo >= VolumeSize) {
|
|
Irp->IoStatus.Information = 0;
|
|
FatCompleteRequest( IrpContext, Irp, STATUS_END_OF_FILE );
|
|
return STATUS_END_OF_FILE;
|
|
}
|
|
|
|
if (ByteCount > VolumeSize - StartingLbo) {
|
|
|
|
ByteCount = RequestedByteCount = (ULONG) (VolumeSize - StartingLbo);
|
|
|
|
//
|
|
// For async reads we had set the byte count in the FatIoContext
|
|
// above, so fix that here.
|
|
//
|
|
|
|
if (!Wait) {
|
|
|
|
IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
|
|
ByteCount;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// For DASD we have to probe and lock the user's buffer
|
|
//
|
|
|
|
FatLockUserBuffer( IrpContext, Irp, IoWriteAccess, ByteCount );
|
|
|
|
|
|
} else {
|
|
|
|
//
|
|
// Virtual volume file open -- increment performance counters.
|
|
//
|
|
|
|
Vcb->Statistics[KeGetCurrentProcessorNumber()].Common.MetaDataDiskReads += 1;
|
|
|
|
}
|
|
|
|
//
|
|
// Read the data and wait for the results
|
|
//
|
|
|
|
FatSingleAsync( IrpContext,
|
|
Vcb,
|
|
StartingLbo,
|
|
ByteCount,
|
|
Irp );
|
|
|
|
if (!Wait) {
|
|
|
|
//
|
|
// We, nor anybody else, need the IrpContext any more.
|
|
//
|
|
|
|
IrpContext->FatIoContext = NULL;
|
|
|
|
FatDeleteIrpContext( IrpContext );
|
|
|
|
DebugTrace(-1, Dbg, "FatNonCachedIo -> STATUS_PENDING\n", 0);
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
FatWaitSync( IrpContext );
|
|
|
|
//
|
|
// If the call didn't succeed, raise the error status
|
|
//
|
|
|
|
if (!NT_SUCCESS( Status = Irp->IoStatus.Status )) {
|
|
|
|
ASSERT( KeGetCurrentThread() != Vcb->VerifyThread || Status != STATUS_VERIFY_REQUIRED );
|
|
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
|
}
|
|
|
|
//
|
|
// Update the current file position
|
|
//
|
|
|
|
if (SynchronousIo && !PagingIo) {
|
|
FileObject->CurrentByteOffset.QuadPart =
|
|
StartingLbo + Irp->IoStatus.Information;
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "CommonRead -> %08lx\n", Status );
|
|
|
|
FatCompleteRequest( IrpContext, Irp, Status );
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// At this point we know there is an Fcb/Dcb.
|
|
//
|
|
|
|
ASSERT( FcbOrDcb != NULL );
|
|
|
|
//
|
|
// Check for a non-zero high part offset
|
|
//
|
|
|
|
if ( StartingByte.HighPart != 0 ) {
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
FatCompleteRequest( IrpContext, Irp, STATUS_END_OF_FILE );
|
|
return STATUS_END_OF_FILE;
|
|
}
|
|
|
|
//
|
|
// Use a try-finally to free Fcb/Dcb and buffers on the way out.
|
|
//
|
|
|
|
try {
|
|
|
|
//
|
|
// This case corresponds to a normal user read file.
|
|
//
|
|
|
|
if ( TypeOfOpen == UserFileOpen) {
|
|
|
|
ULONG FileSize;
|
|
ULONG ValidDataLength;
|
|
|
|
DebugTrace(0, Dbg, "Type of read is user file open\n", 0);
|
|
|
|
//
|
|
// If this is a noncached transfer and is not a paging I/O, and
|
|
// the file has a data section, then we will do a flush here
|
|
// to avoid stale data problems. Note that we must flush before
|
|
// acquiring the Fcb shared since the write may try to acquire
|
|
// it exclusive.
|
|
//
|
|
|
|
if (!PagingIo && NonCachedIo
|
|
|
|
&&
|
|
|
|
(FileObject->SectionObjectPointer->DataSectionObject != NULL)) {
|
|
|
|
#ifndef REDUCE_SYNCHRONIZATION
|
|
if (!FatAcquireExclusiveFcb( IrpContext, FcbOrDcb )) {
|
|
|
|
try_return( PostIrp = TRUE );
|
|
}
|
|
|
|
ExAcquireResourceSharedLite( FcbOrDcb->Header.PagingIoResource, TRUE);
|
|
#endif //REDUCE_SYNCHRONIZATION
|
|
|
|
CcFlushCache( FileObject->SectionObjectPointer,
|
|
&StartingByte,
|
|
ByteCount,
|
|
&Irp->IoStatus );
|
|
|
|
#ifndef REDUCE_SYNCHRONIZATION
|
|
ExReleaseResourceLite( FcbOrDcb->Header.PagingIoResource );
|
|
FatReleaseFcb( IrpContext, FcbOrDcb );
|
|
#endif //REDUCE_SYNCHRONIZATION
|
|
|
|
if (!NT_SUCCESS( Irp->IoStatus.Status)) {
|
|
|
|
try_return( Irp->IoStatus.Status );
|
|
}
|
|
|
|
#ifndef REDUCE_SYNCHRONIZATION
|
|
ExAcquireResourceExclusiveLite( FcbOrDcb->Header.PagingIoResource, TRUE );
|
|
ExReleaseResourceLite( FcbOrDcb->Header.PagingIoResource );
|
|
#endif //REDUCE_SYNCHRONIZATION
|
|
}
|
|
|
|
//
|
|
// We need shared access to the Fcb/Dcb before proceeding.
|
|
//
|
|
|
|
if ( PagingIo ) {
|
|
|
|
if (!ExAcquireResourceSharedLite( FcbOrDcb->Header.PagingIoResource,
|
|
Wait )) {
|
|
|
|
DebugTrace( 0, Dbg, "Cannot acquire FcbOrDcb = %08lx shared without waiting\n", FcbOrDcb );
|
|
|
|
try_return( PostIrp = TRUE );
|
|
}
|
|
|
|
if (!Wait) {
|
|
|
|
IrpContext->FatIoContext->Wait.Async.Resource =
|
|
FcbOrDcb->Header.PagingIoResource;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// If this is async I/O, we will wait if there is an
|
|
// exclusive waiter.
|
|
//
|
|
|
|
if (!Wait && NonCachedIo) {
|
|
|
|
if (!FatAcquireSharedFcbWaitForEx( IrpContext, FcbOrDcb )) {
|
|
|
|
DebugTrace( 0,
|
|
Dbg,
|
|
"Cannot acquire FcbOrDcb = %08lx shared without waiting\n",
|
|
FcbOrDcb );
|
|
|
|
try_return( PostIrp = TRUE );
|
|
}
|
|
|
|
IrpContext->FatIoContext->Wait.Async.Resource =
|
|
FcbOrDcb->Header.Resource;
|
|
|
|
} else {
|
|
|
|
if (!FatAcquireSharedFcb( IrpContext, FcbOrDcb )) {
|
|
|
|
DebugTrace( 0,
|
|
Dbg,
|
|
"Cannot acquire FcbOrDcb = %08lx shared without waiting\n",
|
|
FcbOrDcb );
|
|
|
|
try_return( PostIrp = TRUE );
|
|
}
|
|
}
|
|
}
|
|
|
|
FcbOrDcbAcquired = TRUE;
|
|
|
|
//
|
|
// Make sure the FcbOrDcb is still good
|
|
//
|
|
|
|
FatVerifyFcb( IrpContext, FcbOrDcb );
|
|
|
|
//
|
|
// We now check whether we can proceed based on the state of
|
|
// the file oplocks.
|
|
//
|
|
|
|
if (!PagingIo) {
|
|
|
|
Status = FsRtlCheckOplock( &FcbOrDcb->Specific.Fcb.Oplock,
|
|
Irp,
|
|
IrpContext,
|
|
FatOplockComplete,
|
|
FatPrePostIrp );
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
|
|
OplockPostIrp = TRUE;
|
|
PostIrp = TRUE;
|
|
try_return( NOTHING );
|
|
}
|
|
|
|
//
|
|
// Reset the flag indicating if Fast I/O is possible since the oplock
|
|
// check could have broken existing (conflicting) oplocks.
|
|
//
|
|
|
|
FcbOrDcb->Header.IsFastIoPossible = FatIsFastIoPossible( FcbOrDcb );
|
|
|
|
//
|
|
// We have to check for read access according to the current
|
|
// state of the file locks, and set FileSize from the Fcb.
|
|
//
|
|
|
|
if (!PagingIo &&
|
|
!FsRtlCheckLockForReadAccess( &FcbOrDcb->Specific.Fcb.FileLock,
|
|
Irp )) {
|
|
|
|
try_return( Status = STATUS_FILE_LOCK_CONFLICT );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Pick up our sizes and check/trim the IO.
|
|
//
|
|
|
|
FileSize = FcbOrDcb->Header.FileSize.LowPart;
|
|
ValidDataLength = FcbOrDcb->Header.ValidDataLength.LowPart;
|
|
|
|
//
|
|
// If the read starts beyond End of File, return EOF.
|
|
//
|
|
|
|
if (StartingVbo >= FileSize) {
|
|
|
|
DebugTrace( 0, Dbg, "End of File\n", 0 );
|
|
|
|
try_return ( Status = STATUS_END_OF_FILE );
|
|
}
|
|
|
|
//
|
|
// If the read extends beyond EOF, truncate the read
|
|
//
|
|
|
|
if (ByteCount > FileSize - StartingVbo) {
|
|
|
|
ByteCount = RequestedByteCount = FileSize - StartingVbo;
|
|
|
|
if (NonCachedIo && !Wait) {
|
|
|
|
IrpContext->FatIoContext->Wait.Async.RequestedByteCount =
|
|
RequestedByteCount;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// HANDLE THE NON-CACHED CASE
|
|
//
|
|
|
|
if ( NonCachedIo ) {
|
|
|
|
ULONG SectorSize;
|
|
ULONG BytesToRead;
|
|
|
|
DebugTrace(0, Dbg, "Non cached read.\n", 0);
|
|
|
|
//
|
|
// Get the sector size
|
|
//
|
|
|
|
SectorSize = (ULONG)Vcb->Bpb.BytesPerSector;
|
|
|
|
//
|
|
// Start by zeroing any part of the read after Valid Data
|
|
//
|
|
|
|
if (ValidDataLength < FcbOrDcb->ValidDataToDisk) {
|
|
|
|
ValidDataLength = FcbOrDcb->ValidDataToDisk;
|
|
}
|
|
|
|
if ( StartingVbo + ByteCount > ValidDataLength ) {
|
|
|
|
SystemBuffer = FatMapUserBuffer( IrpContext, Irp );
|
|
|
|
if (StartingVbo < ValidDataLength) {
|
|
|
|
ULONG ZeroingOffset;
|
|
|
|
//
|
|
// Now zero out the user's request sector aligned beyond
|
|
// vdl. We will handle the straddling sector at completion
|
|
// time via the bytecount reduction which immediately
|
|
// follows this check.
|
|
//
|
|
// Note that we used to post in this case for async requests.
|
|
// Note also that if the request was wholly beyond VDL that
|
|
// we did not post, therefore this is consistent. Synchronous
|
|
// zeroing is fine for async requests.
|
|
//
|
|
|
|
ZeroingOffset = ((ValidDataLength - StartingVbo) + (SectorSize - 1))
|
|
& ~(SectorSize - 1);
|
|
|
|
//
|
|
// If the offset is at or above the byte count, no harm: just means
|
|
// that the read ends in the last sector and the zeroing will be
|
|
// done at completion.
|
|
//
|
|
|
|
if (ByteCount > ZeroingOffset) {
|
|
|
|
SafeZeroMemory( (PUCHAR) SystemBuffer + ZeroingOffset,
|
|
ByteCount - ZeroingOffset);
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// All we have to do now is sit here and zero the
|
|
// user's buffer, no reading is required.
|
|
//
|
|
|
|
SafeZeroMemory( (PUCHAR)SystemBuffer, ByteCount );
|
|
|
|
Irp->IoStatus.Information = ByteCount;
|
|
|
|
try_return ( Status = STATUS_SUCCESS );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Reduce the byte count to actually read if it extends beyond
|
|
// Valid Data Length
|
|
//
|
|
|
|
ByteCount = (ValidDataLength - StartingVbo < ByteCount) ?
|
|
ValidDataLength - StartingVbo : ByteCount;
|
|
//
|
|
// Round up to a sector boundary, and remember that if we are
|
|
// reading extra bytes we will zero them out during completion.
|
|
//
|
|
|
|
BytesToRead = (ByteCount + (SectorSize - 1))
|
|
& ~(SectorSize - 1);
|
|
|
|
//
|
|
// Just to help alleviate confusion. At this point:
|
|
//
|
|
// RequestedByteCount - is the number of bytes originally
|
|
// taken from the Irp, but constrained
|
|
// to filesize.
|
|
//
|
|
// ByteCount - is RequestedByteCount constrained to
|
|
// ValidDataLength.
|
|
//
|
|
// BytesToRead - is ByteCount rounded up to sector
|
|
// boundry. This is the number of bytes
|
|
// that we must physically read.
|
|
//
|
|
|
|
//
|
|
// If this request is not properly aligned, or extending
|
|
// to a sector boundary would overflow the buffer, send it off
|
|
// on a special-case path.
|
|
//
|
|
|
|
if ( (StartingVbo & (SectorSize - 1)) ||
|
|
(BytesToRead > IrpSp->Parameters.Read.Length) ) {
|
|
|
|
//
|
|
// If we can't wait, we must post this.
|
|
//
|
|
|
|
if (!Wait) {
|
|
|
|
try_return( PostIrp = TRUE );
|
|
}
|
|
|
|
//
|
|
// Do the physical read
|
|
//
|
|
|
|
FatNonCachedNonAlignedRead( IrpContext,
|
|
Irp,
|
|
FcbOrDcb,
|
|
StartingVbo,
|
|
ByteCount );
|
|
|
|
//
|
|
// Set BytesToRead to ByteCount to satify the following ASSERT.
|
|
//
|
|
|
|
BytesToRead = ByteCount;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Perform the actual IO
|
|
//
|
|
|
|
if (FatNonCachedIo( IrpContext,
|
|
Irp,
|
|
FcbOrDcb,
|
|
StartingVbo,
|
|
BytesToRead,
|
|
ByteCount ) == STATUS_PENDING) {
|
|
|
|
IrpContext->FatIoContext = NULL;
|
|
|
|
Irp = NULL;
|
|
|
|
try_return( Status = STATUS_PENDING );
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the call didn't succeed, raise the error status
|
|
//
|
|
|
|
if (!NT_SUCCESS( Status = Irp->IoStatus.Status )) {
|
|
|
|
ASSERT( KeGetCurrentThread() != Vcb->VerifyThread || Status != STATUS_VERIFY_REQUIRED );
|
|
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Else set the Irp information field to reflect the
|
|
// entire desired read.
|
|
//
|
|
|
|
ASSERT( Irp->IoStatus.Information == BytesToRead );
|
|
|
|
Irp->IoStatus.Information = RequestedByteCount;
|
|
}
|
|
|
|
//
|
|
// The transfer is complete.
|
|
//
|
|
|
|
try_return( Status );
|
|
|
|
} // if No Intermediate Buffering
|
|
|
|
|
|
//
|
|
// HANDLE CACHED CASE
|
|
//
|
|
|
|
else {
|
|
|
|
//
|
|
// We delay setting up the file cache until now, in case the
|
|
// caller never does any I/O to the file, and thus
|
|
// FileObject->PrivateCacheMap == NULL.
|
|
//
|
|
|
|
if (FileObject->PrivateCacheMap == NULL) {
|
|
|
|
DebugTrace(0, Dbg, "Initialize cache mapping.\n", 0);
|
|
|
|
//
|
|
// Get the file allocation size, and if it is less than
|
|
// the file size, raise file corrupt error.
|
|
//
|
|
|
|
if (FcbOrDcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) {
|
|
|
|
FatLookupFileAllocationSize( IrpContext, FcbOrDcb );
|
|
}
|
|
|
|
if ( FileSize > FcbOrDcb->Header.AllocationSize.LowPart ) {
|
|
|
|
FatPopUpFileCorrupt( IrpContext, FcbOrDcb );
|
|
|
|
FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
|
|
}
|
|
|
|
//
|
|
// Now initialize the cache map.
|
|
//
|
|
|
|
CcInitializeCacheMap( FileObject,
|
|
(PCC_FILE_SIZES)&FcbOrDcb->Header.AllocationSize,
|
|
FALSE,
|
|
&FatData.CacheManagerCallbacks,
|
|
FcbOrDcb );
|
|
|
|
CcSetReadAheadGranularity( FileObject, READ_AHEAD_GRANULARITY );
|
|
}
|
|
|
|
|
|
//
|
|
// DO A NORMAL CACHED READ, if the MDL bit is not set,
|
|
//
|
|
|
|
DebugTrace(0, Dbg, "Cached read.\n", 0);
|
|
|
|
if (!FlagOn(IrpContext->MinorFunction, IRP_MN_MDL)) {
|
|
|
|
//
|
|
// Get hold of the user's buffer.
|
|
//
|
|
|
|
SystemBuffer = FatMapUserBuffer( IrpContext, Irp );
|
|
|
|
//
|
|
// Now try to do the copy.
|
|
//
|
|
|
|
if (!CcCopyRead( FileObject,
|
|
&StartingByte,
|
|
ByteCount,
|
|
Wait,
|
|
SystemBuffer,
|
|
&Irp->IoStatus )) {
|
|
|
|
DebugTrace( 0, Dbg, "Cached Read could not wait\n", 0 );
|
|
|
|
try_return( PostIrp = TRUE );
|
|
}
|
|
|
|
Status = Irp->IoStatus.Status;
|
|
|
|
ASSERT( NT_SUCCESS( Status ));
|
|
|
|
try_return( Status );
|
|
}
|
|
|
|
|
|
//
|
|
// HANDLE A MDL READ
|
|
//
|
|
|
|
else {
|
|
|
|
DebugTrace(0, Dbg, "MDL read.\n", 0);
|
|
|
|
ASSERT( Wait );
|
|
|
|
CcMdlRead( FileObject,
|
|
&StartingByte,
|
|
ByteCount,
|
|
&Irp->MdlAddress,
|
|
&Irp->IoStatus );
|
|
|
|
Status = Irp->IoStatus.Status;
|
|
|
|
ASSERT( NT_SUCCESS( Status ));
|
|
|
|
try_return( Status );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// These two cases correspond to a system read directory file and
|
|
// ea file.
|
|
//
|
|
|
|
if (( TypeOfOpen == DirectoryFile ) || ( TypeOfOpen == EaFile)) {
|
|
|
|
ULONG SectorSize;
|
|
|
|
DebugTrace(0, Dbg, "Read Directory or Ea file.\n", 0);
|
|
|
|
//
|
|
// For the noncached case, assert that everything is sector
|
|
// alligned.
|
|
//
|
|
|
|
SectorSize = (ULONG)Vcb->Bpb.BytesPerSector;
|
|
|
|
//
|
|
// We make several assumptions about these two types of files.
|
|
// Make sure all of them are true.
|
|
//
|
|
|
|
ASSERT( NonCachedIo && PagingIo );
|
|
ASSERT( ((StartingVbo | ByteCount) & (SectorSize - 1)) == 0 );
|
|
|
|
//
|
|
// These calls must allways be within the allocation size
|
|
//
|
|
|
|
if (StartingVbo >= FcbOrDcb->Header.AllocationSize.LowPart) {
|
|
|
|
DebugTrace( 0, Dbg, "PagingIo dirent started beyond EOF.\n", 0 );
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
try_return( Status = STATUS_SUCCESS );
|
|
}
|
|
|
|
if ( StartingVbo + ByteCount > FcbOrDcb->Header.AllocationSize.LowPart ) {
|
|
|
|
DebugTrace( 0, Dbg, "PagingIo dirent extending beyond EOF.\n", 0 );
|
|
ByteCount = FcbOrDcb->Header.AllocationSize.LowPart - StartingVbo;
|
|
}
|
|
|
|
//
|
|
// Perform the actual IO
|
|
//
|
|
|
|
if (FatNonCachedIo( IrpContext,
|
|
Irp,
|
|
FcbOrDcb,
|
|
StartingVbo,
|
|
ByteCount,
|
|
ByteCount ) == STATUS_PENDING) {
|
|
|
|
IrpContext->FatIoContext = NULL;
|
|
|
|
Irp = NULL;
|
|
|
|
try_return( Status = STATUS_PENDING );
|
|
}
|
|
|
|
//
|
|
// If the call didn't succeed, raise the error status
|
|
//
|
|
|
|
if (!NT_SUCCESS( Status = Irp->IoStatus.Status )) {
|
|
|
|
ASSERT( KeGetCurrentThread() != Vcb->VerifyThread || Status != STATUS_VERIFY_REQUIRED );
|
|
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
|
|
|
} else {
|
|
|
|
ASSERT( Irp->IoStatus.Information == ByteCount );
|
|
}
|
|
|
|
try_return( Status );
|
|
}
|
|
|
|
//
|
|
// This is the case of a user who openned a directory. No reading is
|
|
// allowed.
|
|
//
|
|
|
|
if ( TypeOfOpen == UserDirectoryOpen ) {
|
|
|
|
DebugTrace( 0, Dbg, "CommonRead -> STATUS_INVALID_PARAMETER\n", 0);
|
|
|
|
try_return( Status = STATUS_INVALID_PARAMETER );
|
|
}
|
|
|
|
//
|
|
// If we get this far, something really serious is wrong.
|
|
//
|
|
|
|
DebugDump("Illegal TypeOfOpen\n", 0, FcbOrDcb );
|
|
|
|
FatBugCheck( TypeOfOpen, (ULONG_PTR) FcbOrDcb, 0 );
|
|
|
|
try_exit: NOTHING;
|
|
|
|
//
|
|
// If the request was not posted and there's an Irp, deal with it.
|
|
//
|
|
|
|
if ( Irp ) {
|
|
|
|
if ( !PostIrp ) {
|
|
|
|
ULONG ActualBytesRead;
|
|
|
|
DebugTrace( 0, Dbg, "Completing request with status = %08lx\n",
|
|
Status);
|
|
|
|
DebugTrace( 0, Dbg, " Information = %08lx\n",
|
|
Irp->IoStatus.Information);
|
|
|
|
//
|
|
// Record the total number of bytes actually read
|
|
//
|
|
|
|
ActualBytesRead = (ULONG)Irp->IoStatus.Information;
|
|
|
|
//
|
|
// If the file was opened for Synchronous IO, update the current
|
|
// file position.
|
|
//
|
|
|
|
if (SynchronousIo && !PagingIo) {
|
|
|
|
FileObject->CurrentByteOffset.LowPart =
|
|
StartingVbo + ActualBytesRead;
|
|
}
|
|
|
|
//
|
|
// If this was not PagingIo, mark that the last access
|
|
// time on the dirent needs to be updated on close.
|
|
//
|
|
|
|
if (NT_SUCCESS(Status) && !PagingIo) {
|
|
|
|
SetFlag( FileObject->Flags, FO_FILE_FAST_IO_READ );
|
|
}
|
|
|
|
} else {
|
|
|
|
DebugTrace( 0, Dbg, "Passing request to Fsp\n", 0 );
|
|
|
|
if (!OplockPostIrp) {
|
|
|
|
Status = FatFsdPostRequest( IrpContext, Irp );
|
|
}
|
|
}
|
|
}
|
|
|
|
} finally {
|
|
|
|
DebugUnwind( FatCommonRead );
|
|
|
|
//
|
|
// If the FcbOrDcb has been acquired, release it.
|
|
//
|
|
|
|
if (FcbOrDcbAcquired && Irp) {
|
|
|
|
if ( PagingIo ) {
|
|
|
|
ExReleaseResourceLite( FcbOrDcb->Header.PagingIoResource );
|
|
|
|
} else {
|
|
|
|
FatReleaseFcb( NULL, FcbOrDcb );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Complete the request if we didn't post it and no exception
|
|
//
|
|
// Note that FatCompleteRequest does the right thing if either
|
|
// IrpContext or Irp are NULL
|
|
//
|
|
|
|
if (!PostIrp) {
|
|
|
|
//
|
|
// If we had a stack io context, we have to make sure the contents
|
|
// are cleaned up before we leave.
|
|
//
|
|
// At present with zero mdls, this will only really happen on exceptional
|
|
// termination where we failed to dispatch the IO. Cleanup of zero mdls
|
|
// normally occurs during completion, but when we bail we must make sure
|
|
// the cleanup occurs here or the fatiocontext will go out of scope.
|
|
//
|
|
// If the operation was posted, cleanup occured there.
|
|
//
|
|
|
|
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT)) {
|
|
|
|
if (IrpContext->FatIoContext->ZeroMdl) {
|
|
IoFreeMdl( IrpContext->FatIoContext->ZeroMdl );
|
|
}
|
|
|
|
ClearFlag(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT);
|
|
IrpContext->FatIoContext = NULL;
|
|
}
|
|
|
|
if (!AbnormalTermination()) {
|
|
|
|
FatCompleteRequest( IrpContext, Irp, Status );
|
|
}
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "CommonRead -> %08lx\n", Status );
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
VOID
|
|
FatOverflowPagingFileRead (
|
|
IN PVOID Context,
|
|
IN PKEVENT Event
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The routine simply call FatPagingFileIo. It is invoked in cases when
|
|
there was not enough stack space to perform the pagefault in the
|
|
original thread. It is also responsible for freeing the packet pool.
|
|
|
|
Arguments:
|
|
|
|
Irp - Supplies the Irp being processed
|
|
|
|
Fcb - Supplies the paging file Fcb, since we have it handy.
|
|
|
|
Return Value:
|
|
|
|
VOID
|
|
|
|
--*/
|
|
|
|
{
|
|
PPAGING_FILE_OVERFLOW_PACKET Packet = Context;
|
|
|
|
FatPagingFileIo( Packet->Irp, Packet->Fcb );
|
|
|
|
//
|
|
// Set the stack overflow item's event to tell the original
|
|
// thread that we're done.
|
|
//
|
|
|
|
KeSetEvent( Event, 0, FALSE );
|
|
|
|
return;
|
|
}
|
|
|
|
|