read.c File Reference

#include "cdprocs.h"

Include dependency graph for read.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_READ)
#define	SafeZeroMemory(IC, AT, BYTE_COUNT)
#define	READ_AHEAD_GRANULARITY   (0x10000)

Functions
	_Requires_lock_held_ (_Global_critical_region_)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_READ)

Definition at line 23 of file read.c.

READ_AHEAD_GRANULARITY

#define READ_AHEAD_GRANULARITY   (0x10000)

Definition at line 60 of file read.c.

SafeZeroMemory

#define SafeZeroMemory	(		IC,
			AT,
			BYTE_COUNT
	)

Value:

    {                  \
    _SEH2_TRY {                                             \
        RtlZeroMemory( (AT), (BYTE_COUNT) );                \
__pragma(warning(suppress: 6320))                           \
    } _SEH2_EXCEPT( EXCEPTION_EXECUTE_HANDLER ) {           \
         CdRaiseStatus( IC, STATUS_INVALID_USER_BUFFER );   \
    } _SEH2_END;                                            \
}

Definition at line 38 of file read.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 68 of file read.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    TYPE_OF_OPEN TypeOfOpen;
    PFCB Fcb;
    PCCB Ccb;
 
    BOOLEAN Wait;
    ULONG PagingIo;
    ULONG SynchronousIo;
    ULONG NonCachedIo;
    PVOID UserBuffer;
 
    LONGLONG StartingOffset;
    LONGLONG ByteRange;
    ULONG ByteCount;
    ULONG ReadByteCount;
    ULONG OriginalByteCount;
 
    PVOID SystemBuffer;
 
    BOOLEAN ReleaseFile = TRUE;
 
    CD_IO_CONTEXT LocalIoContext;
 
    PAGED_CODE();
 
    //
    //  If this is a zero length read then return SUCCESS immediately.
    //
 
    if (IrpSp->Parameters.Read.Length == 0) {
 
        CdCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
        return STATUS_SUCCESS;
    }
 
    //
    //  Decode the file object and verify we support read on this.  It
    //  must be a user file, stream file or volume file (for a data disk).
    //
 
    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 == UnopenedFileObject) ||
        (TypeOfOpen == UserDirectoryOpen)) {
 
        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 );
    PagingIo = FlagOn( Irp->Flags, IRP_PAGING_IO );
    NonCachedIo = FlagOn( Irp->Flags, IRP_NOCACHE );
    SynchronousIo = FlagOn( IrpSp->FileObject->Flags, FO_SYNCHRONOUS_IO );
 
 
    //
    //  Extract the range of the Io.
    //
 
    StartingOffset = IrpSp->Parameters.Read.ByteOffset.QuadPart;
    OriginalByteCount = ByteCount = IrpSp->Parameters.Read.Length;
 
    ByteRange = StartingOffset + ByteCount;
 
    //
    //  Make sure that Dasd access is always non-cached.
    //
 
    if (TypeOfOpen == UserVolumeOpen) {
 
        NonCachedIo = TRUE;
    }
 
    //
    //  Acquire the file shared to perform the read.  If we are doing paging IO,
    //  it may be the case that we would have a deadlock imminent because we may
    //  block on shared access, so starve out any exclusive waiters.  This requires
    //  a degree of caution - we believe that any paging IO bursts will recede and
    //  allow the exclusive waiter in.
    //
 
    if (PagingIo) {
 
        CdAcquireFileSharedStarveExclusive( IrpContext, Fcb );
 
    } else {
 
        CdAcquireFileShared( IrpContext, Fcb );
    }
 
    //
    //  Use a try-finally to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        //
        //  Verify the Fcb.  Allow reads if this is a DASD handle that is
        //  dismounting the volume.
        //
 
        if ((TypeOfOpen != UserVolumeOpen) || (NULL == Ccb) ||
            !FlagOn( Ccb->Flags, CCB_FLAG_DISMOUNT_ON_CLOSE))  {
 
            CdVerifyFcbOperation( IrpContext, Fcb );
        }
 
        //
        //  If this is a non-cached then check whether we need to post this
        //  request if this thread can't block.
        //
 
        if (!Wait && NonCachedIo) {
 
            //
            //  XA requests must always be waitable.
            //
 
            if (FlagOn( Fcb->FcbState, FCB_STATE_RAWSECTOR_MASK )) {
 
                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST );
                try_return( Status = STATUS_CANT_WAIT );
            }
        }
 
        //
        //  If this is a user request then verify the oplock and filelock state.
        //
 
        if (TypeOfOpen == UserFileOpen) {
 
            //
            //  We check whether we can proceed
            //  based on the state of the file oplocks.
            //
 
            Status = FsRtlCheckOplock( CdGetFcbOplock(Fcb),
                                       Irp,
                                       IrpContext,
                                       (PVOID)CdOplockComplete,/* ReactOS Change: GCC "assignment from incompatible pointer type" */
                                       (PVOID)CdPrePostIrp );/* ReactOS Change: GCC "assignment from incompatible pointer type" */
 
            //
            //  If the result is not STATUS_SUCCESS then the Irp was completed
            //  elsewhere.
            //
 
            if (Status != STATUS_SUCCESS) {
 
                Irp = NULL;
                IrpContext = NULL;
 
                try_return( NOTHING );
            }
 
            if (!PagingIo &&
                (Fcb->FileLock != NULL) &&
                !FsRtlCheckLockForReadAccess( Fcb->FileLock, Irp )) {
 
                try_return( Status = STATUS_FILE_LOCK_CONFLICT );
            }
        }
 
        //
        //  Check request beyond end of file if this is not a read on a volume
        //  handle marked for extended DASD IO.
        //
 
        if ((TypeOfOpen != UserVolumeOpen) ||
            (!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 read if it extends beyond the end of the file.
            //
 
            if (ByteRange > Fcb->FileSize.QuadPart) {
 
                ByteCount = (ULONG) (Fcb->FileSize.QuadPart - StartingOffset);
                ByteRange = Fcb->FileSize.QuadPart;
            }
        }
 
        //
        //  Handle the non-cached read first.
        //
 
        if (NonCachedIo) {
 
            //
            //  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 read is not integral
            //  sectors.
            //
 
            ReadByteCount = BlockAlign( Fcb->Vcb, ByteCount );
 
            if (SectorOffset( StartingOffset ) ||
                SectorOffset( ReadByteCount ) ||
                (ReadByteCount > OriginalByteCount)) {
 
                if (!Wait) {
 
                    CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
                }
 
                //
                //  Make sure we don't overwrite the buffer.
                //
 
                ReadByteCount = ByteCount;
            }
 
            //
            //  Initialize the IoContext for the read.
            //  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 = ReadByteCount;
 
            //
            //  Call one of the NonCacheIo routines to perform the actual
            //  read.
            //
 
            if (FlagOn( Fcb->FcbState, FCB_STATE_RAWSECTOR_MASK )) {
 
                Status = CdNonCachedXARead( IrpContext, Fcb, StartingOffset, ReadByteCount );
 
            } else {
 
                Status = CdNonCachedRead( IrpContext, Fcb, StartingOffset, ReadByteCount );
            }
 
            //
            //  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 (ReadByteCount != ByteCount) {
 
                    CdMapUserBuffer( IrpContext, &UserBuffer);
 
                    SafeZeroMemory( IrpContext,
                                    Add2Ptr( UserBuffer,
                                             ByteCount,
                                             PVOID ),
                                    ReadByteCount - ByteCount );
 
                    Irp->IoStatus.Information = ByteCount;
                }
 
                //
                //  Update the file position if this is a synchronous request.
                //
 
                if (SynchronousIo && !PagingIo && NT_SUCCESS( Status )) {
 
                    IrpSp->FileObject->CurrentByteOffset.QuadPart = ByteRange;
                }
            }
 
            try_return( NOTHING );
        }
 
        //
        //  Handle the cached case.  Start by initializing the private
        //  cache map.
        //
 
        if (IrpSp->FileObject->PrivateCacheMap == NULL) {
 
            //
            //  Now initialize the cache map.
            //
 
            CcInitializeCacheMap( IrpSp->FileObject,
                                  (PCC_FILE_SIZES) &Fcb->AllocationSize,
                                  FALSE,
                                  &CdData.CacheManagerCallbacks,
                                  Fcb );
 
            CcSetReadAheadGranularity( IrpSp->FileObject, READ_AHEAD_GRANULARITY );
        }
 
        //
        //  Read from the cache if this is not an Mdl read.
        //
 
        if (!FlagOn( IrpContext->MinorFunction, IRP_MN_MDL )) {
 
            //
            // If we are in the Fsp now because we had to wait earlier,
            // we must map the user buffer, otherwise we can use the
            // user's buffer directly.
            //
 
            CdMapUserBuffer( IrpContext, &SystemBuffer );
 
            //
            // Now try to do the copy.
            //
 
            if (!CcCopyRead( IrpSp->FileObject,
                             (PLARGE_INTEGER) &StartingOffset,
                             ByteCount,
                             Wait,
                             SystemBuffer,
                             &Irp->IoStatus )) {
 
                try_return( Status = STATUS_CANT_WAIT );
            }
 
            //
            //  If the call didn't succeed, raise the error status
            //
 
            if (!NT_SUCCESS( Irp->IoStatus.Status )) {
 
                CdNormalizeAndRaiseStatus( IrpContext, Irp->IoStatus.Status );
            }
 
        //
        //  Otherwise perform the MdlRead operation.
        //
 
        } else {
 
            CcMdlRead( IrpSp->FileObject,
                       (PLARGE_INTEGER) &StartingOffset,
                       ByteCount,
                       &Irp->MdlAddress,
                       &Irp->IoStatus );
 
            Status = Irp->IoStatus.Status;
        }
 
        //
        //  Update the current file position in the user file object.
        //
 
        if (SynchronousIo && !PagingIo && NT_SUCCESS( Status )) {
 
            IrpSp->FileObject->CurrentByteOffset.QuadPart = ByteRange;
        }
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        //
        //  Release the Fcb.
        //
 
        if (ReleaseFile) {
 
            CdReleaseFile( IrpContext, Fcb );
        }
    } _SEH2_END;
 
    //
    //  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;
}