read.c File Reference

#include "fatprocs.h"

Include dependency graph for read.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_READ)
#define	Dbg   (DEBUG_TRACE_READ)
#define	OVERFLOW_READ_THRESHHOLD   (0x1000)
#define	SafeZeroMemory(AT, BYTE_COUNT)
#define	CollectReadStats(VCB, OPEN_TYPE, BYTE_COUNT)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
VOID NTAPI	FatOverflowPagingFileRead (IN PVOID Context, IN PKEVENT Event)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_READ)

Definition at line 23 of file read.c.

CollectReadStats

#define CollectReadStats	(		VCB,
			OPEN_TYPE,
			BYTE_COUNT
	)

Value:

    {                                         \
    PFILESYSTEM_STATISTICS Stats = &(VCB)->Statistics[KeGetCurrentProcessorNumber() % FatData.NumberProcessors].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);                                     \
    }                                                                                        \
}

Dbg

#define Dbg   (DEBUG_TRACE_READ)

Definition at line 29 of file read.c.

OVERFLOW_READ_THRESHHOLD

#define OVERFLOW_READ_THRESHHOLD   (0x1000)

Definition at line 42 of file read.c.

SafeZeroMemory

#define SafeZeroMemory	(		AT,
			BYTE_COUNT
	)

Value:

    {                            \
    _SEH2_TRY {                                                    \
        RtlZeroMemory((AT), (BYTE_COUNT));                         \
    } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {                    \
         FatRaiseStatus( IrpContext, STATUS_INVALID_USER_BUFFER ); \
    } _SEH2_END;                                                   \
}

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 50 of file read.c.

                                      {                            \
    _SEH2_TRY {                                                    \
        RtlZeroMemory((AT), (BYTE_COUNT));                         \
    } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {                    \
         FatRaiseStatus( IrpContext, STATUS_INVALID_USER_BUFFER ); \
    } _SEH2_END;                                                   \
}
 
//
//  Macro to increment appropriate performance counters.
//
 
#define CollectReadStats(VCB,OPEN_TYPE,BYTE_COUNT) {                                         \
    PFILESYSTEM_STATISTICS Stats = &(VCB)->Statistics[KeGetCurrentProcessorNumber() % FatData.NumberProcessors].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
 
 
_Function_class_(IRP_MJ_READ)
_Function_class_(DRIVER_DISPATCH)
NTSTATUS
NTAPI
FatFsdRead (
    _In_ PVOLUME_DEVICE_OBJECT VolumeDeviceObject,
    _Inout_ 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 = NULL;
    NTSTATUS Status;
    PIRP_CONTEXT IrpContext = NULL;
 
    BOOLEAN TopLevel = FALSE;
 
    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;
        }
    }
 
    _SEH2_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;
    } _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_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, _SEH2_GetExceptionCode() );
    } _SEH2_END;
 
    if (TopLevel) { IoSetTopLevelIrp( NULL ); }
 
    FsRtlExitFileSystem();
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatFsdRead -> %08lx\n", Status);
 
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    return Status;
}

FatOverflowPagingFileRead()

VOID NTAPI FatOverflowPagingFileRead	(	IN PVOID	Context,
		IN PKEVENT	Event
	)

Definition at line 1706 of file read.c.

{
    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;
}