mirror of
https://github.com/reactos/reactos.git
synced 2024-08-30 15:18:33 +00:00
1156 lines
42 KiB
C++
1156 lines
42 KiB
C++
////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
|
|
// All rights reserved
|
|
// This file was released under the GPLv2 on June 2015.
|
|
////////////////////////////////////////////////////////////////////
|
|
/*************************************************************************
|
|
*
|
|
* File: Read.cpp
|
|
*
|
|
* Module: UDF File System Driver (Kernel mode execution only)
|
|
*
|
|
* Description:
|
|
* Contains code to handle the "Read" dispatch entry point.
|
|
*
|
|
*************************************************************************/
|
|
|
|
#include "udffs.h"
|
|
|
|
// define the file specific bug-check id
|
|
#define UDF_BUG_CHECK_ID UDF_FILE_READ
|
|
|
|
#ifdef _M_IX86
|
|
#if DBG
|
|
#define OVERFLOW_READ_THRESHHOLD (0xE00)
|
|
#else
|
|
#define OVERFLOW_READ_THRESHHOLD (0xA00)
|
|
#endif // UDF_DBG
|
|
#else // defined(_M_IX86)
|
|
#define OVERFLOW_READ_THRESHHOLD (0x1000)
|
|
#endif // defined(_M_IX86)
|
|
|
|
//#define POST_LOCK_PAGES
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFRead()
|
|
*
|
|
* Description:
|
|
* The I/O Manager will invoke this routine to handle a read
|
|
* request
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL (invocation at higher IRQL will cause execution
|
|
* to be deferred to a worker thread context)
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
NTAPI
|
|
UDFRead(
|
|
PDEVICE_OBJECT DeviceObject, // the logical volume device object
|
|
PIRP Irp) // I/O Request Packet
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PtrUDFIrpContext PtrIrpContext = NULL;
|
|
BOOLEAN AreWeTopLevel = FALSE;
|
|
|
|
TmPrint(("UDFRead: \n"));
|
|
|
|
FsRtlEnterFileSystem();
|
|
ASSERT(DeviceObject);
|
|
ASSERT(Irp);
|
|
|
|
// set the top level context
|
|
AreWeTopLevel = UDFIsIrpTopLevel(Irp);
|
|
ASSERT(!UDFIsFSDevObj(DeviceObject));
|
|
|
|
_SEH2_TRY {
|
|
|
|
// get an IRP context structure and issue the request
|
|
PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
|
|
if(PtrIrpContext) {
|
|
RC = UDFCommonRead(PtrIrpContext, Irp);
|
|
} else {
|
|
RC = STATUS_INSUFFICIENT_RESOURCES;
|
|
Irp->IoStatus.Status = RC;
|
|
Irp->IoStatus.Information = 0;
|
|
// complete the IRP
|
|
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
|
|
}
|
|
|
|
} _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
|
|
|
|
RC = UDFExceptionHandler(PtrIrpContext, Irp);
|
|
|
|
UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
|
|
} _SEH2_END;
|
|
|
|
if (AreWeTopLevel) {
|
|
IoSetTopLevelIrp(NULL);
|
|
}
|
|
|
|
FsRtlExitFileSystem();
|
|
|
|
return(RC);
|
|
} // end UDFRead()
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFPostStackOverflowRead()
|
|
*
|
|
* Description:
|
|
* Post 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.
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFPostStackOverflowRead(
|
|
IN PtrUDFIrpContext PtrIrpContext,
|
|
IN PIRP Irp,
|
|
IN PtrUDFFCB Fcb
|
|
)
|
|
{
|
|
PKEVENT Event;
|
|
PERESOURCE Resource;
|
|
|
|
UDFPrint(("Getting too close to stack limit pass request to Fsp\n"));
|
|
|
|
// Allocate an event and get shared on the resource we will
|
|
// be later using the common read.
|
|
Event = (PKEVENT)MyAllocatePool__(NonPagedPool, sizeof(KEVENT));
|
|
if(!Event)
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
KeInitializeEvent( Event, NotificationEvent, FALSE );
|
|
|
|
if ((Irp->Flags & IRP_PAGING_IO) && (Fcb->NTRequiredFCB->CommonFCBHeader.PagingIoResource)) {
|
|
Resource = Fcb->NTRequiredFCB->CommonFCBHeader.PagingIoResource;
|
|
} else {
|
|
Resource = Fcb->NTRequiredFCB->CommonFCBHeader.Resource;
|
|
}
|
|
|
|
UDFAcquireResourceShared( Resource, TRUE );
|
|
|
|
_SEH2_TRY {
|
|
// 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.
|
|
FsRtlPostStackOverflow(PtrIrpContext, Event, UDFStackOverflowRead);
|
|
// And wait for the worker thread to complete the item
|
|
DbgWaitForSingleObject(Event, NULL);
|
|
|
|
} _SEH2_FINALLY {
|
|
|
|
UDFReleaseResource( Resource );
|
|
MyFreePool__( Event );
|
|
} _SEH2_END;
|
|
|
|
return STATUS_PENDING;
|
|
|
|
} // end UDFPostStackOverflowRead()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFStackOverflowRead()
|
|
*
|
|
* Description:
|
|
* Process 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.
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: None.
|
|
*
|
|
*************************************************************************/
|
|
VOID
|
|
NTAPI
|
|
UDFStackOverflowRead(
|
|
IN PVOID Context,
|
|
IN PKEVENT Event
|
|
)
|
|
{
|
|
PtrUDFIrpContext PtrIrpContext = (PtrUDFIrpContext)Context;
|
|
NTSTATUS RC;
|
|
|
|
UDFPrint(("UDFStackOverflowRead: \n"));
|
|
// Make it now look like we can wait for I/O to complete
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_CAN_BLOCK;
|
|
|
|
// Do the read operation protected by a try-except clause
|
|
_SEH2_TRY {
|
|
UDFCommonRead(PtrIrpContext, PtrIrpContext->Irp);
|
|
} _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
|
|
RC = UDFExceptionHandler(PtrIrpContext, PtrIrpContext->Irp);
|
|
UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
|
|
} _SEH2_END;
|
|
|
|
// Set the stack overflow item's event to tell the original
|
|
// thread that we're done.
|
|
KeSetEvent( Event, 0, FALSE );
|
|
} // end UDFStackOverflowRead()
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFCommonRead()
|
|
*
|
|
* Description:
|
|
* The actual work is performed here. This routine may be invoked in one
|
|
* of the two possible contexts:
|
|
* (a) in the context of a system worker thread
|
|
* (b) in the context of the original caller
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFCommonRead(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PIO_STACK_LOCATION IrpSp = NULL;
|
|
LARGE_INTEGER ByteOffset;
|
|
ULONG ReadLength = 0, TruncatedLength = 0;
|
|
SIZE_T NumberBytesRead = 0;
|
|
PFILE_OBJECT FileObject = NULL;
|
|
PtrUDFFCB Fcb = NULL;
|
|
PtrUDFCCB Ccb = NULL;
|
|
PVCB Vcb = NULL;
|
|
PtrUDFNTRequiredFCB NtReqFcb = NULL;
|
|
PERESOURCE PtrResourceAcquired = NULL;
|
|
PERESOURCE PtrResourceAcquired2 = NULL;
|
|
PVOID SystemBuffer = NULL;
|
|
PIRP TopIrp;
|
|
// uint32 KeyValue = 0;
|
|
|
|
ULONG Res1Acq = 0;
|
|
ULONG Res2Acq = 0;
|
|
|
|
BOOLEAN CacheLocked = FALSE;
|
|
|
|
BOOLEAN CanWait = FALSE;
|
|
BOOLEAN PagingIo = FALSE;
|
|
BOOLEAN NonBufferedIo = FALSE;
|
|
BOOLEAN SynchronousIo = FALSE;
|
|
|
|
TmPrint(("UDFCommonRead: irp %x\n", Irp));
|
|
|
|
_SEH2_TRY {
|
|
|
|
TopIrp = IoGetTopLevelIrp();
|
|
switch((ULONG_PTR)TopIrp) {
|
|
case FSRTL_FSP_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_FSP_TOP_LEVEL_IRP\n"));
|
|
break;
|
|
case FSRTL_CACHE_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_CACHE_TOP_LEVEL_IRP\n"));
|
|
break;
|
|
case FSRTL_MOD_WRITE_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_MOD_WRITE_TOP_LEVEL_IRP\n"));
|
|
// BrutePoint()
|
|
break;
|
|
case FSRTL_FAST_IO_TOP_LEVEL_IRP:
|
|
UDFPrint((" FSRTL_FAST_IO_TOP_LEVEL_IRP\n"));
|
|
// BrutePoint()
|
|
break;
|
|
case NULL:
|
|
UDFPrint((" NULL TOP_LEVEL_IRP\n"));
|
|
break;
|
|
default:
|
|
if(TopIrp == Irp) {
|
|
UDFPrint((" TOP_LEVEL_IRP\n"));
|
|
} else {
|
|
UDFPrint((" RECURSIVE_IRP, TOP = %x\n", TopIrp));
|
|
}
|
|
break;
|
|
}
|
|
// First, get a pointer to the current I/O stack location
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
ASSERT(IrpSp);
|
|
MmPrint((" Enter Irp, MDL=%x\n", Irp->MdlAddress));
|
|
if(Irp->MdlAddress) {
|
|
UDFTouch(Irp->MdlAddress);
|
|
}
|
|
|
|
// If this happens to be a MDL read complete request, then
|
|
// there is not much processing that the FSD has to do.
|
|
if (IrpSp->MinorFunction & IRP_MN_COMPLETE) {
|
|
// Caller wants to tell the Cache Manager that a previously
|
|
// allocated MDL can be freed.
|
|
UDFMdlComplete(PtrIrpContext, Irp, IrpSp, TRUE);
|
|
// The IRP has been completed.
|
|
try_return(RC = STATUS_SUCCESS);
|
|
}
|
|
|
|
// If this is a request at IRQL DISPATCH_LEVEL, then post
|
|
// the request (your FSD may choose to process it synchronously
|
|
// if you implement the support correctly; obviously you will be
|
|
// quite constrained in what you can do at such IRQL).
|
|
if (IrpSp->MinorFunction & IRP_MN_DPC) {
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
|
|
FileObject = IrpSp->FileObject;
|
|
ASSERT(FileObject);
|
|
|
|
// Get the FCB and CCB pointers
|
|
Ccb = (PtrUDFCCB)(FileObject->FsContext2);
|
|
ASSERT(Ccb);
|
|
Fcb = Ccb->Fcb;
|
|
ASSERT(Fcb);
|
|
Vcb = Fcb->Vcb;
|
|
|
|
if(Fcb->FCBFlags & UDF_FCB_DELETED) {
|
|
ASSERT(FALSE);
|
|
try_return(RC = STATUS_ACCESS_DENIED);
|
|
}
|
|
|
|
// check for stack overflow
|
|
if (IoGetRemainingStackSize() < OVERFLOW_READ_THRESHHOLD) {
|
|
RC = UDFPostStackOverflowRead( PtrIrpContext, Irp, Fcb );
|
|
try_return(RC);
|
|
}
|
|
|
|
// Disk based file systems might decide to verify the logical volume
|
|
// (if required and only if removable media are supported) at this time
|
|
// As soon as Tray is locked, we needn't call UDFVerifyVcb()
|
|
|
|
ByteOffset = IrpSp->Parameters.Read.ByteOffset;
|
|
|
|
CanWait = (PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE;
|
|
PagingIo = (Irp->Flags & IRP_PAGING_IO) ? TRUE : FALSE;
|
|
NonBufferedIo = (Irp->Flags & IRP_NOCACHE) ? TRUE : FALSE;
|
|
SynchronousIo = (FileObject->Flags & FO_SYNCHRONOUS_IO) ? TRUE : FALSE;
|
|
UDFPrint((" Flags: %s %s %s %s\n",
|
|
CanWait ? "W" : "w", PagingIo ? "Pg" : "pg",
|
|
NonBufferedIo ? "NBuf" : "buff", SynchronousIo ? "Snc" : "Asc"));
|
|
|
|
if(!NonBufferedIo &&
|
|
(Fcb->NodeIdentifier.NodeType != UDF_NODE_TYPE_VCB)) {
|
|
if(UDFIsAStream(Fcb->FileInfo)) {
|
|
UDFNotifyFullReportChange( Vcb, Fcb->FileInfo,
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS,
|
|
FILE_ACTION_MODIFIED_STREAM);
|
|
} else {
|
|
UDFNotifyFullReportChange( Vcb, Fcb->FileInfo,
|
|
FILE_NOTIFY_CHANGE_LAST_ACCESS,
|
|
FILE_ACTION_MODIFIED);
|
|
}
|
|
}
|
|
|
|
// Get some of the parameters supplied to us
|
|
ReadLength = IrpSp->Parameters.Read.Length;
|
|
if (ReadLength == 0) {
|
|
// a 0 byte read can be immediately succeeded
|
|
try_return(RC);
|
|
}
|
|
UDFPrint((" ByteOffset = %I64x, ReadLength = %x\n", ByteOffset.QuadPart, ReadLength));
|
|
|
|
// Is this a read of the volume itself ?
|
|
if (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) {
|
|
// Yup, we need to send this on to the disk driver after
|
|
// validation of the offset and length.
|
|
Vcb = (PVCB)Fcb;
|
|
Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
|
|
if(!CanWait)
|
|
try_return(RC = STATUS_PENDING);
|
|
|
|
|
|
if(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_FLUSH2_REQUIRED) {
|
|
|
|
UDFPrint((" UDF_IRP_CONTEXT_FLUSH2_REQUIRED\n"));
|
|
PtrIrpContext->IrpContextFlags &= ~UDF_IRP_CONTEXT_FLUSH2_REQUIRED;
|
|
|
|
if(!(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
|
|
UDFCloseAllSystemDelayedInDir(Vcb, Vcb->RootDirFCB->FileInfo);
|
|
}
|
|
#ifdef UDF_DELAYED_CLOSE
|
|
UDFCloseAllDelayed(Vcb);
|
|
#endif //UDF_DELAYED_CLOSE
|
|
|
|
}
|
|
|
|
if(PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_FLUSH_REQUIRED) {
|
|
|
|
UDFPrint((" UDF_IRP_CONTEXT_FLUSH_REQUIRED\n"));
|
|
PtrIrpContext->IrpContextFlags &= ~UDF_IRP_CONTEXT_FLUSH_REQUIRED;
|
|
|
|
// Acquire the volume resource exclusive
|
|
UDFAcquireResourceExclusive(&(Vcb->VCBResource), TRUE);
|
|
PtrResourceAcquired = &(Vcb->VCBResource);
|
|
|
|
UDFFlushLogicalVolume(NULL, NULL, Vcb, 0);
|
|
|
|
UDFReleaseResource(PtrResourceAcquired);
|
|
PtrResourceAcquired = NULL;
|
|
}
|
|
|
|
// Acquire the volume resource shared ...
|
|
UDFAcquireResourceShared(&(Vcb->VCBResource), TRUE);
|
|
PtrResourceAcquired = &(Vcb->VCBResource);
|
|
|
|
#if 0
|
|
if(PagingIo) {
|
|
CollectStatistics(Vcb, MetaDataReads);
|
|
CollectStatisticsEx(Vcb, MetaDataReadBytes, NumberBytesRead);
|
|
}
|
|
#endif
|
|
|
|
// Forward the request to the lower level driver
|
|
// Lock the callers buffer
|
|
if (!NT_SUCCESS(RC = UDFLockCallersBuffer(PtrIrpContext, Irp, TRUE, ReadLength))) {
|
|
try_return(RC);
|
|
}
|
|
SystemBuffer = UDFGetCallersBuffer(PtrIrpContext, Irp);
|
|
if(!SystemBuffer) {
|
|
try_return(RC = STATUS_INVALID_USER_BUFFER);
|
|
}
|
|
if(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED) {
|
|
RC = UDFReadData(Vcb, TRUE, ByteOffset.QuadPart,
|
|
ReadLength, FALSE, (PCHAR)SystemBuffer,
|
|
&NumberBytesRead);
|
|
} else {
|
|
RC = UDFTRead(Vcb, SystemBuffer, ReadLength,
|
|
(ULONG)(ByteOffset.QuadPart >> Vcb->BlockSizeBits),
|
|
&NumberBytesRead);
|
|
}
|
|
UDFUnlockCallersBuffer(PtrIrpContext, Irp, SystemBuffer);
|
|
try_return(RC);
|
|
}
|
|
Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
|
|
|
|
// If the read request is directed to a page file (if your FSD
|
|
// supports paging files), send the request directly to the disk
|
|
// driver. For requests directed to a page file, you have to trust
|
|
// that the offsets will be set correctly by the VMM. You should not
|
|
// attempt to acquire any FSD resources either.
|
|
if(Fcb->FCBFlags & UDF_FCB_PAGE_FILE) {
|
|
NonBufferedIo = TRUE;
|
|
}
|
|
|
|
if(ByteOffset.HighPart == -1) {
|
|
if(ByteOffset.LowPart == FILE_USE_FILE_POINTER_POSITION) {
|
|
ByteOffset = FileObject->CurrentByteOffset;
|
|
}
|
|
}
|
|
|
|
// If this read is directed to a directory, it is not allowed
|
|
// by the UDF FSD.
|
|
if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
|
|
RC = STATUS_INVALID_DEVICE_REQUEST;
|
|
try_return(RC);
|
|
}
|
|
|
|
NtReqFcb = Fcb->NTRequiredFCB;
|
|
|
|
Res1Acq = UDFIsResourceAcquired(&(NtReqFcb->MainResource));
|
|
if(!Res1Acq) {
|
|
Res1Acq = PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_RES1_ACQ;
|
|
}
|
|
Res2Acq = UDFIsResourceAcquired(&(NtReqFcb->PagingIoResource));
|
|
if(!Res2Acq) {
|
|
Res2Acq = PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_RES2_ACQ;
|
|
}
|
|
|
|
#if 0
|
|
if(PagingIo) {
|
|
CollectStatistics(Vcb, UserFileReads);
|
|
CollectStatisticsEx(Vcb, UserFileReadBytes, NumberBytesRead);
|
|
}
|
|
#endif
|
|
|
|
// This is a good place for oplock related processing.
|
|
|
|
// If this is the normal file we have to check for
|
|
// write access according to the current state of the file locks.
|
|
if (!PagingIo &&
|
|
!FsRtlCheckLockForReadAccess( &(NtReqFcb->FileLock), Irp )) {
|
|
try_return( RC = STATUS_FILE_LOCK_CONFLICT );
|
|
}
|
|
|
|
// Validate start offset and length supplied.
|
|
// If start offset is > end-of-file, return an appropriate error. Note
|
|
// that since a FCB resource has already been acquired, and since all
|
|
// file size changes require acquisition of both FCB resources,
|
|
// the contents of the FCB and associated data structures
|
|
// can safely be examined.
|
|
|
|
// Also note that we are using the file size in the "Common FCB Header"
|
|
// to perform the check. However, your FSD might decide to keep a
|
|
// separate copy in the FCB (or some other representation of the
|
|
// file associated with the FCB).
|
|
|
|
TruncatedLength = ReadLength;
|
|
if (ByteOffset.QuadPart >= NtReqFcb->CommonFCBHeader.FileSize.QuadPart) {
|
|
// Starting offset is >= file size
|
|
try_return(RC = STATUS_END_OF_FILE);
|
|
}
|
|
// We can also go ahead and truncate the read length here
|
|
// such that it is contained within the file size
|
|
if( NtReqFcb->CommonFCBHeader.FileSize.QuadPart < (ByteOffset.QuadPart + ReadLength) ) {
|
|
TruncatedLength = (ULONG)(NtReqFcb->CommonFCBHeader.FileSize.QuadPart - ByteOffset.QuadPart);
|
|
// we can't get ZERO here
|
|
}
|
|
UDFPrint((" TruncatedLength = %x\n", TruncatedLength));
|
|
|
|
// There are certain complications that arise when the same file stream
|
|
// has been opened for cached and non-cached access. The FSD is then
|
|
// responsible for maintaining a consistent view of the data seen by
|
|
// the caller.
|
|
// Also, it is possible for file streams to be mapped in both as data files
|
|
// and as an executable. This could also lead to consistency problems since
|
|
// there now exist two separate sections (and pages) containing file
|
|
// information.
|
|
|
|
// The test below flushes the data cached in system memory if the current
|
|
// request madates non-cached access (file stream must be cached) and
|
|
// (a) the current request is not paging-io which indicates it is not
|
|
// a recursive I/O operation OR originating in the Cache Manager
|
|
// (b) OR the current request is paging-io BUT it did not originate via
|
|
// the Cache Manager (or is a recursive I/O operation) and we do
|
|
// have an image section that has been initialized.
|
|
#define UDF_REQ_NOT_VIA_CACHE_MGR(ptr) (!MmIsRecursiveIoFault() && ((ptr)->ImageSectionObject != NULL))
|
|
|
|
if(NonBufferedIo &&
|
|
(NtReqFcb->SectionObject.DataSectionObject != NULL)) {
|
|
if(!PagingIo) {
|
|
|
|
/* // We hold the main resource exclusive here because the flush
|
|
// may generate a recursive write in this thread. The PagingIo
|
|
// resource is held shared so the drop-and-release serialization
|
|
// below will work.
|
|
if(!UDFAcquireResourceExclusive(&(NtReqFcb->MainResource), CanWait)) {
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
PtrResourceAcquired = &(NtReqFcb->MainResource);
|
|
|
|
// We hold PagingIo shared around the flush to fix a
|
|
// cache coherency problem.
|
|
UDFAcquireResourceShared(&(NtReqFcb->PagingIoResource), TRUE );*/
|
|
|
|
MmPrint((" CcFlushCache()\n"));
|
|
CcFlushCache(&(NtReqFcb->SectionObject), &ByteOffset, TruncatedLength, &(Irp->IoStatus));
|
|
|
|
/* UDFReleaseResource(&(NtReqFcb->PagingIoResource));
|
|
UDFReleaseResource(PtrResourceAcquired);
|
|
PtrResourceAcquired = NULL;
|
|
// If the flush failed, return error to the caller
|
|
if(!NT_SUCCESS(RC = Irp->IoStatus.Status)) {
|
|
try_return(RC);
|
|
}
|
|
|
|
// Acquiring and immediately dropping the resource serializes
|
|
// us behind any other writes taking place (either from the
|
|
// lazy writer or modified page writer).*/
|
|
if(!Res2Acq) {
|
|
UDFAcquireResourceExclusive(&(NtReqFcb->PagingIoResource), TRUE );
|
|
UDFReleaseResource(&(NtReqFcb->PagingIoResource));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Acquire the appropriate FCB resource shared
|
|
if (PagingIo) {
|
|
// Try to acquire the FCB PagingIoResource shared
|
|
if(!Res2Acq) {
|
|
if (!UDFAcquireResourceShared(&(NtReqFcb->PagingIoResource), CanWait)) {
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
// Remember the resource that was acquired
|
|
PtrResourceAcquired2 = &(NtReqFcb->PagingIoResource);
|
|
}
|
|
} else {
|
|
// Try to acquire the FCB MainResource shared
|
|
if(NonBufferedIo) {
|
|
if(!Res2Acq) {
|
|
if(!UDFAcquireSharedWaitForExclusive(&(NtReqFcb->PagingIoResource), CanWait)) {
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
PtrResourceAcquired2 = &(NtReqFcb->PagingIoResource);
|
|
}
|
|
} else {
|
|
if(!Res1Acq) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
if(!UDFAcquireResourceShared(&(NtReqFcb->MainResource), CanWait)) {
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
// Remember the resource that was acquired
|
|
PtrResourceAcquired = &(NtReqFcb->MainResource);
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is also a good place to set whether fast-io can be performed
|
|
// on this particular file or not. Your FSD must make it's own
|
|
// determination on whether or not to allow fast-io operations.
|
|
// Commonly, fast-io is not allowed if any byte range locks exist
|
|
// on the file or if oplocks prevent fast-io. Practically any reason
|
|
// choosen by your FSD could result in your setting FastIoIsNotPossible
|
|
// OR FastIoIsQuestionable instead of FastIoIsPossible.
|
|
|
|
NtReqFcb->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(Fcb);
|
|
/* if(NtReqFcb->CommonFCBHeader.IsFastIoPossible == FastIoIsPossible)
|
|
NtReqFcb->CommonFCBHeader.IsFastIoPossible = FastIoIsQuestionable;*/
|
|
|
|
#ifdef UDF_DISABLE_SYSTEM_CACHE_MANAGER
|
|
NonBufferedIo = TRUE;
|
|
#endif
|
|
|
|
if(Fcb && Fcb->FileInfo && Fcb->FileInfo->Dloc) {
|
|
AdPrint(("UDFCommonRead: DataLoc %x, Mapping %x\n", &Fcb->FileInfo->Dloc->DataLoc, Fcb->FileInfo->Dloc->DataLoc.Mapping));
|
|
}
|
|
|
|
// Branch here for cached vs non-cached I/O
|
|
if (!NonBufferedIo) {
|
|
|
|
if(FileObject->Flags & FO_WRITE_THROUGH) {
|
|
CanWait = TRUE;
|
|
}
|
|
// The caller wishes to perform cached I/O. Initiate caching if
|
|
// this is the first cached I/O operation using this file object
|
|
if (!(FileObject->PrivateCacheMap)) {
|
|
// This is the first cached I/O operation. You must ensure
|
|
// that the FCB Common FCB Header contains valid sizes at this time
|
|
MmPrint((" CcInitializeCacheMap()\n"));
|
|
CcInitializeCacheMap(FileObject, (PCC_FILE_SIZES)(&(NtReqFcb->CommonFCBHeader.AllocationSize)),
|
|
FALSE, // We will not utilize pin access for this file
|
|
&(UDFGlobalData.CacheMgrCallBacks), // callbacks
|
|
NtReqFcb); // The context used in callbacks
|
|
MmPrint((" CcSetReadAheadGranularity()\n"));
|
|
CcSetReadAheadGranularity(FileObject, Vcb->SystemCacheGran);
|
|
}
|
|
|
|
// Check and see if this request requires a MDL returned to the caller
|
|
if (IrpSp->MinorFunction & IRP_MN_MDL) {
|
|
// Caller does want a MDL returned. Note that this mode
|
|
// implies that the caller is prepared to block
|
|
MmPrint((" CcMdlRead()\n"));
|
|
// CcMdlRead(FileObject, &ByteOffset, TruncatedLength, &(Irp->MdlAddress), &(Irp->IoStatus));
|
|
// NumberBytesRead = Irp->IoStatus.Information;
|
|
// RC = Irp->IoStatus.Status;
|
|
NumberBytesRead = 0;
|
|
RC = STATUS_INVALID_PARAMETER;
|
|
|
|
try_return(RC);
|
|
}
|
|
|
|
// This is a regular run-of-the-mill cached I/O request. Let the
|
|
// Cache Manager worry about it!
|
|
// First though, we need a buffer pointer (address) that is valid
|
|
SystemBuffer = UDFGetCallersBuffer(PtrIrpContext, Irp);
|
|
if(!SystemBuffer)
|
|
try_return(RC = STATUS_INVALID_USER_BUFFER);
|
|
ASSERT(SystemBuffer);
|
|
MmPrint((" CcCopyRead()\n"));
|
|
if (!CcCopyRead(FileObject, &(ByteOffset), TruncatedLength, CanWait, SystemBuffer, &(Irp->IoStatus))) {
|
|
// The caller was not prepared to block and data is not immediately
|
|
// available in the system cache
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
|
|
UDFUnlockCallersBuffer(PtrIrpContext, Irp, SystemBuffer);
|
|
// We have the data
|
|
RC = Irp->IoStatus.Status;
|
|
NumberBytesRead = Irp->IoStatus.Information;
|
|
|
|
try_return(RC);
|
|
|
|
} else {
|
|
|
|
MmPrint((" Read NonBufferedIo\n"));
|
|
|
|
#if 1
|
|
if((ULONG_PTR)TopIrp == FSRTL_MOD_WRITE_TOP_LEVEL_IRP) {
|
|
UDFPrint(("FSRTL_MOD_WRITE_TOP_LEVEL_IRP => CanWait\n"));
|
|
CanWait = TRUE;
|
|
} else
|
|
if((ULONG_PTR)TopIrp == FSRTL_CACHE_TOP_LEVEL_IRP) {
|
|
UDFPrint(("FSRTL_CACHE_TOP_LEVEL_IRP => CanWait\n"));
|
|
CanWait = TRUE;
|
|
}
|
|
|
|
if(NtReqFcb->AcqSectionCount || NtReqFcb->AcqFlushCount) {
|
|
MmPrint((" AcqCount (%d/%d)=> CanWait ?\n", NtReqFcb->AcqSectionCount, NtReqFcb->AcqFlushCount));
|
|
CanWait = TRUE;
|
|
} else
|
|
{}
|
|
/* if((TopIrp != Irp)) {
|
|
UDFPrint(("(TopIrp != Irp) => CanWait\n"));
|
|
CanWait = TRUE;
|
|
} else*/
|
|
#endif
|
|
if(KeGetCurrentIrql() > PASSIVE_LEVEL) {
|
|
MmPrint((" !PASSIVE_LEVEL\n"));
|
|
CanWait = FALSE;
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_FORCED_POST;
|
|
}
|
|
if(!CanWait && UDFIsFileCached__(Vcb, Fcb->FileInfo, ByteOffset.QuadPart, TruncatedLength, FALSE)) {
|
|
MmPrint((" Locked => CanWait\n"));
|
|
CacheLocked = TRUE;
|
|
CanWait = TRUE;
|
|
}
|
|
|
|
// Send the request to lower level drivers
|
|
if(!CanWait) {
|
|
try_return(RC = STATUS_PENDING);
|
|
}
|
|
|
|
// ASSERT(NT_SUCCESS(RC));
|
|
if(!Res2Acq) {
|
|
if(UDFAcquireResourceSharedWithCheck(&(NtReqFcb->PagingIoResource)))
|
|
PtrResourceAcquired2 = &(NtReqFcb->PagingIoResource);
|
|
}
|
|
|
|
RC = UDFLockCallersBuffer(PtrIrpContext, Irp, TRUE, TruncatedLength);
|
|
if(!NT_SUCCESS(RC)) {
|
|
try_return(RC);
|
|
}
|
|
|
|
SystemBuffer = UDFGetCallersBuffer(PtrIrpContext, Irp);
|
|
if(!SystemBuffer) {
|
|
try_return(RC = STATUS_INVALID_USER_BUFFER);
|
|
}
|
|
|
|
RC = UDFReadFile__(Vcb, Fcb->FileInfo, ByteOffset.QuadPart, TruncatedLength,
|
|
CacheLocked, (PCHAR)SystemBuffer, &NumberBytesRead);
|
|
/* // AFAIU, CacheManager wants this:
|
|
if(!NT_SUCCESS(RC)) {
|
|
NumberBytesRead = 0;
|
|
}*/
|
|
|
|
UDFUnlockCallersBuffer(PtrIrpContext, Irp, SystemBuffer);
|
|
|
|
#if 0
|
|
if(PagingIo) {
|
|
CollectStatistics(Vcb, UserDiskReads);
|
|
} else {
|
|
CollectStatistics2(Vcb, NonCachedDiskReads);
|
|
}
|
|
#endif
|
|
|
|
try_return(RC);
|
|
|
|
// For paging-io, the FSD has to trust the VMM to do the right thing
|
|
|
|
// Here is a common method used by Windows NT native file systems
|
|
// that are in the process of sending a request to the disk driver.
|
|
// First, mark the IRP as pending, then invoke the lower level driver
|
|
// after setting a completion routine.
|
|
// Meanwhile, this particular thread can immediately return a
|
|
// STATUS_PENDING return code.
|
|
// The completion routine is then responsible for completing the IRP
|
|
// and unlocking appropriate resources
|
|
|
|
// Also, at this point, the FSD might choose to utilize the
|
|
// information contained in the ValidDataLength field to simply
|
|
// return zeroes to the caller for reads extending beyond current
|
|
// valid data length.
|
|
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
|
|
if(CacheLocked) {
|
|
WCacheEODirect__(&(Vcb->FastCache), Vcb);
|
|
}
|
|
|
|
// Release any resources acquired here ...
|
|
if(PtrResourceAcquired2) {
|
|
UDFReleaseResource(PtrResourceAcquired2);
|
|
}
|
|
if(PtrResourceAcquired) {
|
|
if(NtReqFcb &&
|
|
(PtrResourceAcquired ==
|
|
&(NtReqFcb->MainResource))) {
|
|
UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
|
|
}
|
|
UDFReleaseResource(PtrResourceAcquired);
|
|
}
|
|
|
|
// Post IRP if required
|
|
if(RC == STATUS_PENDING) {
|
|
|
|
// Lock the callers buffer here. Then invoke a common routine to
|
|
// perform the post operation.
|
|
if (!(IrpSp->MinorFunction & IRP_MN_MDL)) {
|
|
RC = UDFLockCallersBuffer(PtrIrpContext, Irp, TRUE, ReadLength);
|
|
ASSERT(NT_SUCCESS(RC));
|
|
}
|
|
if(PagingIo) {
|
|
if(Res1Acq) {
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_RES1_ACQ;
|
|
}
|
|
if(Res2Acq) {
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_RES2_ACQ;
|
|
}
|
|
}
|
|
// Perform the post operation which will mark the IRP pending
|
|
// and will return STATUS_PENDING back to us
|
|
RC = UDFPostRequest(PtrIrpContext, Irp);
|
|
|
|
} else {
|
|
// For synchronous I/O, the FSD must maintain the current byte offset
|
|
// Do not do this however, if I/O is marked as paging-io
|
|
if (SynchronousIo && !PagingIo && NT_SUCCESS(RC)) {
|
|
FileObject->CurrentByteOffset.QuadPart = ByteOffset.QuadPart + NumberBytesRead;
|
|
}
|
|
// If the read completed successfully and this was not a paging-io
|
|
// operation, set a flag in the CCB that indicates that a read was
|
|
// performed and that the file time should be updated at cleanup
|
|
if (NT_SUCCESS(RC) && !PagingIo) {
|
|
FileObject->Flags |= FO_FILE_FAST_IO_READ;
|
|
Ccb->CCBFlags |= UDF_CCB_ACCESSED;
|
|
}
|
|
|
|
if(!_SEH2_AbnormalTermination()) {
|
|
Irp->IoStatus.Status = RC;
|
|
Irp->IoStatus.Information = NumberBytesRead;
|
|
UDFPrint((" NumberBytesRead = %x\n", NumberBytesRead));
|
|
// Free up the Irp Context
|
|
UDFReleaseIrpContext(PtrIrpContext);
|
|
// complete the IRP
|
|
MmPrint((" Complete Irp, MDL=%x\n", Irp->MdlAddress));
|
|
if(Irp->MdlAddress) {
|
|
UDFTouch(Irp->MdlAddress);
|
|
}
|
|
IoCompleteRequest(Irp, IO_DISK_INCREMENT);
|
|
}
|
|
} // can we complete the IRP ?
|
|
} _SEH2_END; // end of "__finally" processing
|
|
|
|
return(RC);
|
|
} // end UDFCommonRead()
|
|
|
|
|
|
#ifdef UDF_DBG
|
|
ULONG LockBufferCounter = 0;
|
|
ULONG BuildMdlCounter = 0;
|
|
#endif //UDF_DBG
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFGetCallersBuffer()
|
|
*
|
|
* Description:
|
|
* Obtain a pointer to the caller's buffer.
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
PVOID
|
|
UDFGetCallersBuffer(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp
|
|
)
|
|
{
|
|
VOID *ReturnedBuffer = NULL;
|
|
|
|
UDFPrint(("UDFGetCallersBuffer: \n"));
|
|
|
|
// If an MDL is supplied, use it.
|
|
if(Irp->MdlAddress) {
|
|
MmPrint((" UDFGetCallersBuffer: MmGetSystemAddressForMdl(Irp->MdlAddress) MDL=%x\n", Irp->MdlAddress));
|
|
// ReturnedBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
|
|
ReturnedBuffer = MmGetSystemAddressForMdlSafer(Irp->MdlAddress);
|
|
} else
|
|
if (PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_BUFFER_LOCKED) {
|
|
// Free buffer
|
|
#ifndef POST_LOCK_PAGES
|
|
MmPrint((" UDFGetCallersBuffer: MmGetSystemAddressForMdl(PtrIrpContext->PtrMdl) MDL=%x\n", PtrIrpContext->PtrMdl));
|
|
ReturnedBuffer = MmGetSystemAddressForMdlSafe(PtrIrpContext->PtrMdl, NormalPagePriority);
|
|
#else //POST_LOCK_PAGES
|
|
if(PtrIrpContext->TransitionBuffer) {
|
|
MmPrint((" UDFGetCallersBuffer: TransitionBuffer\n"));
|
|
return PtrIrpContext->TransitionBuffer;
|
|
}
|
|
|
|
_SEH2_TRY {
|
|
MmPrint((" MmProbeAndLockPages()\n"));
|
|
MmProbeAndLockPages(PtrIrpContext->PtrMdl, Irp->RequestorMode,
|
|
((PtrIrpContext->MajorFunction == IRP_MJ_READ) ? IoWriteAccess:IoReadAccess));
|
|
#ifdef UDF_DBG
|
|
LockBufferCounter++;
|
|
#endif //UDF_DBG
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
//RC = STATUS_INVALID_USER_BUFFER;
|
|
BrutePoint();
|
|
return NULL;
|
|
} _SEH2_END;
|
|
|
|
MmPrint((" MmGetSystemAddressForMdlSafer()\n"));
|
|
ReturnedBuffer = MmGetSystemAddressForMdlSafer(PtrIrpContext->PtrMdl);
|
|
#endif //POST_LOCK_PAGES
|
|
} else {
|
|
MmPrint((" UDFGetCallersBuffer: Irp->UserBuffer\n"));
|
|
ReturnedBuffer = Irp->UserBuffer;
|
|
}
|
|
|
|
return(ReturnedBuffer);
|
|
} // end UDFGetCallersBuffer()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFLockCallersBuffer()
|
|
*
|
|
* Description:
|
|
* Obtain a MDL that describes the buffer. Lock pages for I/O
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFLockCallersBuffer(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp,
|
|
BOOLEAN IsReadOperation,
|
|
uint32 Length
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PMDL PtrMdl = NULL;
|
|
|
|
UDFPrint(("UDFLockCallersBuffer: \n"));
|
|
|
|
ASSERT(Irp);
|
|
|
|
_SEH2_TRY {
|
|
// Is a MDL already present in the IRP
|
|
if (!(Irp->MdlAddress)) {
|
|
// Allocate a MDL
|
|
/*
|
|
if(!IsReadOperation) {
|
|
MmPrint((" Allocate TransitionBuffer\n"));
|
|
PtrIrpContext->TransitionBuffer = (PCHAR)DbgAllocatePool(NonPagedPool, Length);
|
|
if(!PtrIrpContext->TransitionBuffer) {
|
|
RC = STATUS_INSUFFICIENT_RESOURCES;
|
|
try_return(RC);
|
|
}
|
|
_SEH2_TRY {
|
|
RtlCopyMemory(PtrIrpContext->TransitionBuffer, Irp->UserBuffer, Length);
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
RC = STATUS_INVALID_USER_BUFFER;
|
|
} _SEH2_END;
|
|
} else*/ {
|
|
|
|
MmPrint((" IoAllocateMdl()\n"));
|
|
// if (!(PtrMdl = IoAllocateMdl(Irp->UserBuffer, Length, FALSE, FALSE, NULL))) {
|
|
|
|
// This will place allocated Mdl to Irp
|
|
if (!(PtrMdl = IoAllocateMdl(Irp->UserBuffer, Length, FALSE, FALSE, Irp))) {
|
|
RC = STATUS_INSUFFICIENT_RESOURCES;
|
|
try_return(RC);
|
|
}
|
|
MmPrint((" Alloc MDL=%x\n", PtrMdl));
|
|
#ifdef UDF_DBG
|
|
BuildMdlCounter++;
|
|
#endif //UDF_DBG
|
|
}
|
|
// Probe and lock the pages described by the MDL
|
|
// We could encounter an exception doing so, swallow the exception
|
|
// NOTE: The exception could be due to an unexpected (from our
|
|
// perspective), invalidation of the virtual addresses that comprise
|
|
// the passed in buffer
|
|
#ifndef POST_LOCK_PAGES
|
|
_SEH2_TRY {
|
|
MmPrint((" MmProbeAndLockPages()\n"));
|
|
MmProbeAndLockPages(PtrMdl, Irp->RequestorMode, (IsReadOperation ? IoWriteAccess:IoReadAccess));
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
MmPrint((" MmProbeAndLockPages() failed\n"));
|
|
Irp->MdlAddress = NULL;
|
|
RC = STATUS_INVALID_USER_BUFFER;
|
|
} _SEH2_END;
|
|
#endif //POST_LOCK_PAGES
|
|
|
|
if(NT_SUCCESS(RC)) {
|
|
PtrIrpContext->IrpContextFlags |= UDF_IRP_CONTEXT_BUFFER_LOCKED;
|
|
PtrIrpContext->PtrMdl = PtrMdl;
|
|
}
|
|
} else {
|
|
MmPrint((" UDFLockCallersBuffer: do nothing, MDL=%x\n", Irp->MdlAddress));
|
|
UDFTouch(Irp->MdlAddress);
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
if (!NT_SUCCESS(RC) && PtrMdl) {
|
|
MmPrint((" Free MDL=%x\n", PtrMdl));
|
|
IoFreeMdl(PtrMdl);
|
|
}
|
|
} _SEH2_END;
|
|
|
|
return(RC);
|
|
} // end UDFLockCallersBuffer()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFUnlockCallersBuffer()
|
|
*
|
|
* Description:
|
|
* Obtain a MDL that describes the buffer. Lock pages for I/O
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: STATUS_SUCCESS/Error
|
|
*
|
|
*************************************************************************/
|
|
NTSTATUS
|
|
UDFUnlockCallersBuffer(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp,
|
|
PVOID SystemBuffer
|
|
)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
|
|
UDFPrint(("UDFUnlockCallersBuffer: \n"));
|
|
|
|
ASSERT(Irp);
|
|
|
|
_SEH2_TRY {
|
|
// Is a nonPaged buffer already present in the IRP
|
|
if (PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_BUFFER_LOCKED) {
|
|
|
|
UDFPrint((" UDF_IRP_CONTEXT_BUFFER_LOCKED MDL=%x, Irp MDL=%x\n", PtrIrpContext->PtrMdl, Irp->MdlAddress));
|
|
if(PtrIrpContext->TransitionBuffer) {
|
|
MmPrint((" UDFUnlockCallersBuffer: free TransitionBuffer\n"));
|
|
DbgFreePool(PtrIrpContext->TransitionBuffer);
|
|
PtrIrpContext->TransitionBuffer = NULL;
|
|
PtrIrpContext->IrpContextFlags &= ~UDF_IRP_CONTEXT_BUFFER_LOCKED;
|
|
try_return(RC);
|
|
}
|
|
// Free buffer
|
|
KeFlushIoBuffers( PtrIrpContext->PtrMdl, TRUE, FALSE );
|
|
// MmPrint((" IrpCtx->Mdl, MmUnmapLockedPages()\n"));
|
|
// MmUnmapLockedPages(SystemBuffer, PtrIrpContext->PtrMdl);
|
|
|
|
// This will be done in IoCompleteIrp !!!
|
|
|
|
//MmPrint((" MmUnlockPages()\n"));
|
|
//MmUnlockPages(PtrIrpContext->PtrMdl);
|
|
|
|
#ifdef UDF_DBG
|
|
LockBufferCounter--;
|
|
#endif //UDF_DBG
|
|
|
|
// This will be done in IoCompleteIrp !!!
|
|
|
|
//IoFreeMdl(PtrIrpContext->PtrMdl);
|
|
|
|
#ifdef UDF_DBG
|
|
BuildMdlCounter--;
|
|
#endif //UDF_DBG
|
|
UDFTouch(PtrIrpContext->PtrMdl);
|
|
PtrIrpContext->PtrMdl = NULL;
|
|
PtrIrpContext->IrpContextFlags &= ~UDF_IRP_CONTEXT_BUFFER_LOCKED;
|
|
} else
|
|
if(Irp->MdlAddress) {
|
|
// MmPrint((" Irp->Mdl, MmUnmapLockedPages()\n"));
|
|
// MmUnmapLockedPages(SystemBuffer, Irp->MdlAddress);
|
|
UDFPrint((" UDF_IRP_CONTEXT_BUFFER_LOCKED MDL=%x, Irp MDL=%x\n", PtrIrpContext->PtrMdl, Irp->MdlAddress));
|
|
UDFTouch(Irp->MdlAddress);
|
|
KeFlushIoBuffers( Irp->MdlAddress,
|
|
((IoGetCurrentIrpStackLocation(Irp))->MajorFunction) == IRP_MJ_READ,
|
|
FALSE );
|
|
} else
|
|
{ ; }
|
|
|
|
try_exit: NOTHING;
|
|
|
|
} _SEH2_FINALLY {
|
|
NOTHING;
|
|
} _SEH2_END;
|
|
|
|
return(RC);
|
|
} // end UDFUnlockCallersBuffer()
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Function: UDFMdlComplete()
|
|
*
|
|
* Description:
|
|
* Tell Cache Manager to release MDL (and possibly flush).
|
|
*
|
|
* Expected Interrupt Level (for execution) :
|
|
*
|
|
* IRQL_PASSIVE_LEVEL
|
|
*
|
|
* Return Value: None.
|
|
*
|
|
*************************************************************************/
|
|
VOID UDFMdlComplete(
|
|
PtrUDFIrpContext PtrIrpContext,
|
|
PIRP Irp,
|
|
PIO_STACK_LOCATION IrpSp,
|
|
BOOLEAN ReadCompletion)
|
|
{
|
|
NTSTATUS RC = STATUS_SUCCESS;
|
|
PFILE_OBJECT FileObject = NULL;
|
|
|
|
UDFPrint(("UDFMdlComplete: \n"));
|
|
|
|
FileObject = IrpSp->FileObject;
|
|
ASSERT(FileObject);
|
|
|
|
UDFTouch(Irp->MdlAddress);
|
|
// Not much to do here.
|
|
if (ReadCompletion) {
|
|
MmPrint((" CcMdlReadComplete() MDL=%x\n", Irp->MdlAddress));
|
|
CcMdlReadComplete(FileObject, Irp->MdlAddress);
|
|
} else {
|
|
// The Cache Manager needs the byte offset in the I/O stack location.
|
|
MmPrint((" CcMdlWriteComplete() MDL=%x\n", Irp->MdlAddress));
|
|
CcMdlWriteComplete(FileObject, &(IrpSp->Parameters.Write.ByteOffset), Irp->MdlAddress);
|
|
}
|
|
|
|
// Clear the MDL address field in the IRP so the IoCompleteRequest()
|
|
// does not __try to play around with the MDL.
|
|
Irp->MdlAddress = NULL;
|
|
|
|
// Free up the Irp Context.
|
|
UDFReleaseIrpContext(PtrIrpContext);
|
|
|
|
// Complete the IRP.
|
|
Irp->IoStatus.Status = RC;
|
|
Irp->IoStatus.Information = 0;
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
|
|
return;
|
|
}
|