mirror of
https://github.com/reactos/reactos.git
synced 2024-07-02 10:45:24 +00:00
a3c58ca76f
The reserve IRP is an IRP which is allocated on system boot and kept during the whole system life. Its purpose is to allow page reads in case of low-memory situations where the system doesn't have enough memory left to allocate an IRP to read from the page file (would be catastrophic situation).
2016 lines
57 KiB
C
2016 lines
57 KiB
C
/*
|
|
* PROJECT: ReactOS Kernel
|
|
* LICENSE: GPL - See COPYING in the top level directory
|
|
* FILE: ntoskrnl/io/iomgr/irp.c
|
|
* PURPOSE: IRP Handling Functions
|
|
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
|
|
* Gunnar Dalsnes
|
|
* Filip Navara (navaraf@reactos.org)
|
|
* Pierre Schweitzer (pierre@reactos.org)
|
|
*/
|
|
|
|
/* INCLUDES ****************************************************************/
|
|
|
|
#include <ntoskrnl.h>
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
PIRP IopDeadIrp;
|
|
RESERVE_IRP_ALLOCATOR IopReserveIrpAllocator;
|
|
|
|
/* PRIVATE FUNCTIONS ********************************************************/
|
|
|
|
VOID
|
|
NTAPI
|
|
IopFreeIrpKernelApc(IN PKAPC Apc,
|
|
IN PKNORMAL_ROUTINE *NormalRoutine,
|
|
IN PVOID *NormalContext,
|
|
IN PVOID *SystemArgument1,
|
|
IN PVOID *SystemArgument2)
|
|
{
|
|
/* Free the IRP */
|
|
IoFreeIrp(CONTAINING_RECORD(Apc, IRP, Tail.Apc));
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
IopAbortIrpKernelApc(IN PKAPC Apc)
|
|
{
|
|
/* Free the IRP */
|
|
IoFreeIrp(CONTAINING_RECORD(Apc, IRP, Tail.Apc));
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
IopCleanupFailedIrp(IN PFILE_OBJECT FileObject,
|
|
IN PKEVENT EventObject OPTIONAL,
|
|
IN PVOID Buffer OPTIONAL)
|
|
{
|
|
PAGED_CODE();
|
|
|
|
/* Dereference the event */
|
|
if (EventObject) ObDereferenceObject(EventObject);
|
|
|
|
/* Free a buffer, if any */
|
|
if (Buffer) ExFreePool(Buffer);
|
|
|
|
/* If this was a file opened for synch I/O, then unlock it */
|
|
if (FileObject->Flags & FO_SYNCHRONOUS_IO) IopUnlockFileObject(FileObject);
|
|
|
|
/* Now dereference it and return */
|
|
ObDereferenceObject(FileObject);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
IopAbortInterruptedIrp(IN PKEVENT EventObject,
|
|
IN PIRP Irp)
|
|
{
|
|
KIRQL OldIrql;
|
|
BOOLEAN CancelResult;
|
|
LARGE_INTEGER Wait;
|
|
PAGED_CODE();
|
|
|
|
/* Raise IRQL to APC */
|
|
KeRaiseIrql(APC_LEVEL, &OldIrql);
|
|
|
|
/* Check if nobody completed it yet */
|
|
if (!KeReadStateEvent(EventObject))
|
|
{
|
|
/* First, cancel it */
|
|
CancelResult = IoCancelIrp(Irp);
|
|
KeLowerIrql(OldIrql);
|
|
|
|
/* Check if we cancelled it */
|
|
if (CancelResult)
|
|
{
|
|
/* Wait for the IRP to be cancelled */
|
|
Wait.QuadPart = -100000;
|
|
while (!KeReadStateEvent(EventObject))
|
|
{
|
|
/* Delay indefintely */
|
|
KeDelayExecutionThread(KernelMode, FALSE, &Wait);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* No cancellation done, so wait for the I/O system to kill it */
|
|
KeWaitForSingleObject(EventObject,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* We got preempted, so give up */
|
|
KeLowerIrql(OldIrql);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
IopDisassociateThreadIrp(VOID)
|
|
{
|
|
KIRQL OldIrql, LockIrql;
|
|
PETHREAD IrpThread;
|
|
PLIST_ENTRY IrpEntry;
|
|
PIO_ERROR_LOG_PACKET ErrorLogEntry;
|
|
PDEVICE_OBJECT DeviceObject = NULL;
|
|
PIO_STACK_LOCATION IoStackLocation;
|
|
|
|
/* First, raise to APC to protect IrpList */
|
|
KeRaiseIrql(APC_LEVEL, &OldIrql);
|
|
|
|
/* Get the Thread and check the list */
|
|
IrpThread = PsGetCurrentThread();
|
|
if (IsListEmpty(&IrpThread->IrpList))
|
|
{
|
|
/* It got completed now, so quit */
|
|
KeLowerIrql(OldIrql);
|
|
return;
|
|
}
|
|
|
|
/* Ensure no one will come disturb */
|
|
LockIrql = KeAcquireQueuedSpinLock(LockQueueIoCompletionLock);
|
|
|
|
/* Get the misbehaving IRP */
|
|
IrpEntry = IrpThread->IrpList.Flink;
|
|
IopDeadIrp = CONTAINING_RECORD(IrpEntry, IRP, ThreadListEntry);
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Deassociating IRP %p for %p\n",
|
|
__FUNCTION__,
|
|
IopDeadIrp,
|
|
IrpThread);
|
|
|
|
/* Don't cancel the IRP if it's already been completed far */
|
|
if (IopDeadIrp->CurrentLocation == (IopDeadIrp->StackCount + 2))
|
|
{
|
|
/* Return */
|
|
KeReleaseQueuedSpinLock(LockQueueIoCompletionLock, LockIrql);
|
|
KeLowerIrql(OldIrql);
|
|
return;
|
|
}
|
|
|
|
/* Disown the IRP! */
|
|
IopDeadIrp->Tail.Overlay.Thread = NULL;
|
|
RemoveHeadList(&IrpThread->IrpList);
|
|
InitializeListHead(&IopDeadIrp->ThreadListEntry);
|
|
|
|
/* Get the stack location and check if it's valid */
|
|
IoStackLocation = IoGetCurrentIrpStackLocation(IopDeadIrp);
|
|
if (IopDeadIrp->CurrentLocation <= IopDeadIrp->StackCount)
|
|
{
|
|
/* Get the device object */
|
|
DeviceObject = IoStackLocation->DeviceObject;
|
|
}
|
|
|
|
KeReleaseQueuedSpinLock(LockQueueIoCompletionLock, LockIrql);
|
|
/* Lower IRQL now, since we have the pointers we need */
|
|
KeLowerIrql(OldIrql);
|
|
|
|
/* Check if we can send an Error Log Entry*/
|
|
if (DeviceObject)
|
|
{
|
|
/* Allocate an entry */
|
|
ErrorLogEntry = IoAllocateErrorLogEntry(DeviceObject,
|
|
sizeof(IO_ERROR_LOG_PACKET));
|
|
if (ErrorLogEntry)
|
|
{
|
|
/* Write the entry */
|
|
ErrorLogEntry->ErrorCode = IO_DRIVER_CANCEL_TIMEOUT;
|
|
IoWriteErrorLogEntry(ErrorLogEntry);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
IopCleanupIrp(IN PIRP Irp,
|
|
IN PFILE_OBJECT FileObject)
|
|
{
|
|
PMDL Mdl;
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Cleaning IRP %p for %p\n",
|
|
__FUNCTION__,
|
|
Irp,
|
|
FileObject);
|
|
|
|
/* Check if there's an MDL */
|
|
while ((Mdl = Irp->MdlAddress))
|
|
{
|
|
/* Clear all of them */
|
|
Irp->MdlAddress = Mdl->Next;
|
|
IoFreeMdl(Mdl);
|
|
}
|
|
|
|
/* Check if the IRP has system buffer */
|
|
if (Irp->Flags & IRP_DEALLOCATE_BUFFER)
|
|
{
|
|
/* Free the buffer */
|
|
ExFreePoolWithTag(Irp->AssociatedIrp.SystemBuffer, TAG_SYS_BUF);
|
|
}
|
|
|
|
/* Check if this IRP has a user event, a file object, and is async */
|
|
if ((Irp->UserEvent) &&
|
|
!(Irp->Flags & IRP_SYNCHRONOUS_API) &&
|
|
(FileObject))
|
|
{
|
|
/* Dereference the User Event */
|
|
ObDereferenceObject(Irp->UserEvent);
|
|
}
|
|
|
|
/* Check if we have a file object and this isn't a create operation */
|
|
if ((FileObject) && !(Irp->Flags & IRP_CREATE_OPERATION))
|
|
{
|
|
/* Dereference the file object */
|
|
ObDereferenceObject(FileObject);
|
|
}
|
|
|
|
/* Free the IRP */
|
|
IoFreeIrp(Irp);
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
IopCompleteRequest(IN PKAPC Apc,
|
|
IN PKNORMAL_ROUTINE* NormalRoutine,
|
|
IN PVOID* NormalContext,
|
|
IN PVOID* SystemArgument1,
|
|
IN PVOID* SystemArgument2)
|
|
{
|
|
PFILE_OBJECT FileObject;
|
|
PIRP Irp;
|
|
PMDL Mdl, NextMdl;
|
|
PVOID Port = NULL, Key = NULL;
|
|
BOOLEAN SignaledCreateRequest = FALSE;
|
|
|
|
/* Get data from the APC */
|
|
FileObject = (PFILE_OBJECT)*SystemArgument1;
|
|
Irp = CONTAINING_RECORD(Apc, IRP, Tail.Apc);
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Completing IRP %p for %p\n",
|
|
__FUNCTION__,
|
|
Irp,
|
|
FileObject);
|
|
|
|
/* Sanity check */
|
|
ASSERT(Irp->IoStatus.Status != (NTSTATUS)0xFFFFFFFF);
|
|
|
|
/* Check if we have a file object */
|
|
if (*SystemArgument2)
|
|
{
|
|
/* Check if we're reparsing */
|
|
if ((Irp->IoStatus.Status == STATUS_REPARSE) &&
|
|
(Irp->IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT))
|
|
{
|
|
PREPARSE_DATA_BUFFER ReparseData;
|
|
|
|
ReparseData = (PREPARSE_DATA_BUFFER)*SystemArgument2;
|
|
|
|
ASSERT(ReparseData->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT);
|
|
ASSERT(ReparseData->ReparseDataLength < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
|
|
ASSERT(ReparseData->Reserved < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
|
|
|
|
IopDoNameTransmogrify(Irp, FileObject, ReparseData);
|
|
}
|
|
}
|
|
|
|
/* Handle Buffered case first */
|
|
if (Irp->Flags & IRP_BUFFERED_IO)
|
|
{
|
|
/* Check if we have an input buffer and if we succeeded */
|
|
if ((Irp->Flags & IRP_INPUT_OPERATION) &&
|
|
(Irp->IoStatus.Status != STATUS_VERIFY_REQUIRED) &&
|
|
!(NT_ERROR(Irp->IoStatus.Status)))
|
|
{
|
|
_SEH2_TRY
|
|
{
|
|
/* Copy the buffer back to the user */
|
|
RtlCopyMemory(Irp->UserBuffer,
|
|
Irp->AssociatedIrp.SystemBuffer,
|
|
Irp->IoStatus.Information);
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
/* Fail the IRP */
|
|
Irp->IoStatus.Status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
}
|
|
|
|
/* Also check if we should de-allocate it */
|
|
if (Irp->Flags & IRP_DEALLOCATE_BUFFER)
|
|
{
|
|
/* Deallocate it */
|
|
ExFreePool(Irp->AssociatedIrp.SystemBuffer);
|
|
}
|
|
}
|
|
|
|
/* Now we got rid of these two... */
|
|
Irp->Flags &= ~(IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
|
|
|
|
/* Check if there's an MDL */
|
|
for (Mdl = Irp->MdlAddress; Mdl; Mdl = NextMdl)
|
|
{
|
|
/* Free it */
|
|
NextMdl = Mdl->Next;
|
|
IoFreeMdl(Mdl);
|
|
}
|
|
|
|
/* No MDLs left */
|
|
Irp->MdlAddress = NULL;
|
|
|
|
/*
|
|
* Check if either the request was completed without any errors
|
|
* (but warnings are OK!), or if it was completed with an error, but
|
|
* did return from a pending I/O Operation and is not synchronous.
|
|
*/
|
|
if (!NT_ERROR(Irp->IoStatus.Status) ||
|
|
(Irp->PendingReturned &&
|
|
!IsIrpSynchronous(Irp, FileObject)))
|
|
{
|
|
/* Get any information we need from the FO before we kill it */
|
|
if ((FileObject) && (FileObject->CompletionContext))
|
|
{
|
|
/* Save Completion Data */
|
|
Port = FileObject->CompletionContext->Port;
|
|
Key = FileObject->CompletionContext->Key;
|
|
}
|
|
|
|
/* Check for UserIos */
|
|
if (Irp->UserIosb != NULL)
|
|
{
|
|
/* Use SEH to make sure we don't write somewhere invalid */
|
|
_SEH2_TRY
|
|
{
|
|
/* Save the IOSB Information */
|
|
*Irp->UserIosb = Irp->IoStatus;
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
/* Ignore any error */
|
|
}
|
|
_SEH2_END;
|
|
}
|
|
|
|
/* Check if we have an event or a file object */
|
|
if (Irp->UserEvent)
|
|
{
|
|
/* At the very least, this is a PKEVENT, so signal it always */
|
|
KeSetEvent(Irp->UserEvent, 0, FALSE);
|
|
|
|
/* Check if we also have a File Object */
|
|
if (FileObject)
|
|
{
|
|
/* Check if this is an Asynch API */
|
|
if (!(Irp->Flags & IRP_SYNCHRONOUS_API))
|
|
{
|
|
/* Dereference the event */
|
|
ObDereferenceObject(Irp->UserEvent);
|
|
}
|
|
|
|
/*
|
|
* Now, if this is a Synch I/O File Object, then this event is
|
|
* NOT an actual Executive Event, so we won't dereference it,
|
|
* and instead, we will signal the File Object
|
|
*/
|
|
if ((FileObject->Flags & FO_SYNCHRONOUS_IO) &&
|
|
!(Irp->Flags & IRP_OB_QUERY_NAME))
|
|
{
|
|
/* Signal the file object and set the status */
|
|
KeSetEvent(&FileObject->Event, 0, FALSE);
|
|
FileObject->FinalStatus = Irp->IoStatus.Status;
|
|
}
|
|
|
|
/*
|
|
* This could also be a create operation, in which case we want
|
|
* to make sure there's no APC fired.
|
|
*/
|
|
if (Irp->Flags & IRP_CREATE_OPERATION)
|
|
{
|
|
/* Clear the APC Routine and remember this */
|
|
Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
|
|
SignaledCreateRequest = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else if (FileObject)
|
|
{
|
|
/* Signal the file object and set the status */
|
|
KeSetEvent(&FileObject->Event, 0, FALSE);
|
|
FileObject->FinalStatus = Irp->IoStatus.Status;
|
|
|
|
/*
|
|
* This could also be a create operation, in which case we want
|
|
* to make sure there's no APC fired.
|
|
*/
|
|
if (Irp->Flags & IRP_CREATE_OPERATION)
|
|
{
|
|
/* Clear the APC Routine and remember this */
|
|
Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
|
|
SignaledCreateRequest = TRUE;
|
|
}
|
|
}
|
|
|
|
/* Update transfer count for everything but create operation */
|
|
if (!(Irp->Flags & IRP_CREATE_OPERATION))
|
|
{
|
|
if (Irp->Flags & IRP_WRITE_OPERATION)
|
|
{
|
|
/* Update write transfer count */
|
|
IopUpdateTransferCount(IopWriteTransfer,
|
|
(ULONG)Irp->IoStatus.Information);
|
|
}
|
|
else if (Irp->Flags & IRP_READ_OPERATION)
|
|
{
|
|
/* Update read transfer count */
|
|
IopUpdateTransferCount(IopReadTransfer,
|
|
(ULONG)Irp->IoStatus.Information);
|
|
}
|
|
else
|
|
{
|
|
/* Update other transfer count */
|
|
IopUpdateTransferCount(IopOtherTransfer,
|
|
(ULONG)Irp->IoStatus.Information);
|
|
}
|
|
}
|
|
|
|
/* Now that we've signaled the events, de-associate the IRP */
|
|
IopUnQueueIrpFromThread(Irp);
|
|
|
|
/* Now check if a User APC Routine was requested */
|
|
if (Irp->Overlay.AsynchronousParameters.UserApcRoutine)
|
|
{
|
|
/* Initialize it */
|
|
KeInitializeApc(&Irp->Tail.Apc,
|
|
KeGetCurrentThread(),
|
|
CurrentApcEnvironment,
|
|
IopFreeIrpKernelApc,
|
|
IopAbortIrpKernelApc,
|
|
(PKNORMAL_ROUTINE)Irp->
|
|
Overlay.AsynchronousParameters.UserApcRoutine,
|
|
Irp->RequestorMode,
|
|
Irp->
|
|
Overlay.AsynchronousParameters.UserApcContext);
|
|
|
|
/* Queue it */
|
|
KeInsertQueueApc(&Irp->Tail.Apc, Irp->UserIosb, NULL, 2);
|
|
}
|
|
else if ((Port) &&
|
|
(Irp->Overlay.AsynchronousParameters.UserApcContext))
|
|
{
|
|
/* We have an I/O Completion setup... create the special Overlay */
|
|
Irp->Tail.CompletionKey = Key;
|
|
Irp->Tail.Overlay.PacketType = IopCompletionPacketIrp;
|
|
KeInsertQueue(Port, &Irp->Tail.Overlay.ListEntry);
|
|
}
|
|
else
|
|
{
|
|
/* Free the IRP since we don't need it anymore */
|
|
IoFreeIrp(Irp);
|
|
}
|
|
|
|
/* Check if we have a file object that wasn't part of a create */
|
|
if ((FileObject) && !(SignaledCreateRequest))
|
|
{
|
|
/* Dereference it, since it's not needed anymore either */
|
|
ObDereferenceObjectDeferDelete(FileObject);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Either we didn't return from the request, or we did return but this
|
|
* request was synchronous.
|
|
*/
|
|
if ((Irp->PendingReturned) && (FileObject))
|
|
{
|
|
/* So we did return with a synch operation, was it the IRP? */
|
|
if (Irp->Flags & IRP_SYNCHRONOUS_API)
|
|
{
|
|
/* Yes, this IRP was synchronous, so return the I/O Status */
|
|
*Irp->UserIosb = Irp->IoStatus;
|
|
|
|
/* Now check if the user gave an event */
|
|
if (Irp->UserEvent)
|
|
{
|
|
/* Signal it */
|
|
KeSetEvent(Irp->UserEvent, 0, FALSE);
|
|
}
|
|
else
|
|
{
|
|
/* No event was given, so signal the FO instead */
|
|
KeSetEvent(&FileObject->Event, 0, FALSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* It's not the IRP that was synchronous, it was the FO
|
|
* that was opened this way. Signal its event.
|
|
*/
|
|
FileObject->FinalStatus = Irp->IoStatus.Status;
|
|
KeSetEvent(&FileObject->Event, 0, FALSE);
|
|
}
|
|
}
|
|
|
|
/* Now that we got here, we do this for incomplete I/Os as well */
|
|
if ((FileObject) && !(Irp->Flags & IRP_CREATE_OPERATION))
|
|
{
|
|
/* Dereference the File Object unless this was a create */
|
|
ObDereferenceObjectDeferDelete(FileObject);
|
|
}
|
|
|
|
/*
|
|
* Check if this was an Executive Event (remember that we know this
|
|
* by checking if the IRP is synchronous)
|
|
*/
|
|
if ((Irp->UserEvent) &&
|
|
(FileObject) &&
|
|
!(Irp->Flags & IRP_SYNCHRONOUS_API))
|
|
{
|
|
/* This isn't a PKEVENT, so dereference it */
|
|
ObDereferenceObject(Irp->UserEvent);
|
|
}
|
|
|
|
/* Now that we've signaled the events, de-associate the IRP */
|
|
IopUnQueueIrpFromThread(Irp);
|
|
|
|
/* Free the IRP as well */
|
|
IoFreeIrp(Irp);
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
NTAPI
|
|
IopInitializeReserveIrp(IN PRESERVE_IRP_ALLOCATOR ReserveIrpAllocator)
|
|
{
|
|
/* Our allocated stack size */
|
|
ReserveIrpAllocator->StackSize = 20;
|
|
|
|
/* Allocate the IRP now */
|
|
ReserveIrpAllocator->ReserveIrp = IoAllocateIrp(ReserveIrpAllocator->StackSize, FALSE);
|
|
/* If we cannot, abort system boot */
|
|
if (ReserveIrpAllocator->ReserveIrp == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
/* It's not in use */
|
|
ReserveIrpAllocator->ReserveIrpInUse = 0;
|
|
/* And init the event */
|
|
KeInitializeEvent(&ReserveIrpAllocator->WaitEvent, SynchronizationEvent, FALSE);
|
|
|
|
/* All good, keep booting */
|
|
return TRUE;
|
|
}
|
|
|
|
PIRP
|
|
NTAPI
|
|
IopAllocateReserveIrp(IN CCHAR StackSize)
|
|
{
|
|
/* If we need a stack size higher than what was allocated, then fail */
|
|
if (StackSize > IopReserveIrpAllocator.StackSize)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Now, wait until the IRP becomes available and reserve it immediately */
|
|
while (InterlockedExchange(&IopReserveIrpAllocator.ReserveIrpInUse, 1) == 1)
|
|
{
|
|
KeWaitForSingleObject(&IopReserveIrpAllocator.WaitEvent,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
/* It's ours! Initialize it */
|
|
IoInitializeIrp(IopReserveIrpAllocator.ReserveIrp, IoSizeOfIrp(StackSize), StackSize);
|
|
|
|
/* And return it to the caller */
|
|
return IopReserveIrpAllocator.ReserveIrp;
|
|
}
|
|
|
|
VOID
|
|
IopFreeReserveIrp(IN CCHAR PriorityBoost)
|
|
{
|
|
/* Mark we don't use the IRP anymore */
|
|
InterlockedExchange(&IopReserveIrpAllocator.ReserveIrpInUse, 0);
|
|
|
|
/* And set the event if someone is waiting on the IRP */
|
|
KeSetEvent(&IopReserveIrpAllocator.WaitEvent, PriorityBoost, FALSE);
|
|
}
|
|
|
|
/* FUNCTIONS *****************************************************************/
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IoAllocateIrp(IN CCHAR StackSize,
|
|
IN BOOLEAN ChargeQuota)
|
|
{
|
|
PIRP Irp = NULL;
|
|
USHORT Size = IoSizeOfIrp(StackSize);
|
|
PKPRCB Prcb;
|
|
UCHAR Flags = 0;
|
|
PNPAGED_LOOKASIDE_LIST List = NULL;
|
|
PP_NPAGED_LOOKASIDE_NUMBER ListType = LookasideSmallIrpList;
|
|
|
|
/* Set Charge Quota Flag */
|
|
if (ChargeQuota) Flags |= IRP_QUOTA_CHARGED;
|
|
|
|
/* Get the PRCB */
|
|
Prcb = KeGetCurrentPrcb();
|
|
|
|
/* Figure out which Lookaside List to use */
|
|
if ((StackSize <= 8) && (ChargeQuota == FALSE || Prcb->LookasideIrpFloat > 0))
|
|
{
|
|
/* Set Fixed Size Flag */
|
|
Flags |= IRP_ALLOCATED_FIXED_SIZE;
|
|
|
|
/* See if we should use big list */
|
|
if (StackSize != 1)
|
|
{
|
|
Size = IoSizeOfIrp(8);
|
|
ListType = LookasideLargeIrpList;
|
|
}
|
|
|
|
/* Get the P List First */
|
|
List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[ListType].P;
|
|
|
|
/* Attempt allocation */
|
|
List->L.TotalAllocates++;
|
|
Irp = (PIRP)InterlockedPopEntrySList(&List->L.ListHead);
|
|
|
|
/* Check if the P List failed */
|
|
if (!Irp)
|
|
{
|
|
/* Let the balancer know */
|
|
List->L.AllocateMisses++;
|
|
|
|
/* Try the L List */
|
|
List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[ListType].L;
|
|
List->L.TotalAllocates++;
|
|
Irp = (PIRP)InterlockedPopEntrySList(&List->L.ListHead);
|
|
}
|
|
}
|
|
|
|
/* Check if we have to use the pool */
|
|
if (!Irp)
|
|
{
|
|
/* Did we try lookaside and fail? */
|
|
if (Flags & IRP_ALLOCATED_FIXED_SIZE) List->L.AllocateMisses++;
|
|
|
|
/* Check if we should charge quota */
|
|
if (ChargeQuota)
|
|
{
|
|
Irp = ExAllocatePoolWithQuotaTag(NonPagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
|
|
Size,
|
|
TAG_IRP);
|
|
}
|
|
else
|
|
{
|
|
/* Allocate the IRP with no quota charge */
|
|
Irp = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_IRP);
|
|
}
|
|
|
|
/* Make sure it was sucessful */
|
|
if (!Irp) return NULL;
|
|
}
|
|
else if (Flags & IRP_QUOTA_CHARGED)
|
|
{
|
|
/* Decrement lookaside float */
|
|
InterlockedDecrement(&Prcb->LookasideIrpFloat);
|
|
Flags |= IRP_LOOKASIDE_ALLOCATION;
|
|
|
|
/* In this case there is no charge quota */
|
|
Flags &= ~IRP_QUOTA_CHARGED;
|
|
}
|
|
|
|
/* Now Initialize it */
|
|
IoInitializeIrp(Irp, Size, StackSize);
|
|
|
|
/* Set the Allocation Flags */
|
|
Irp->AllocationFlags = Flags;
|
|
|
|
/* Return it */
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Allocated IRP %p with allocation flags %lx\n",
|
|
__FUNCTION__,
|
|
Irp,
|
|
Flags);
|
|
return Irp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IopAllocateIrpMustSucceed(IN CCHAR StackSize)
|
|
{
|
|
LONG i;
|
|
PIRP Irp;
|
|
LARGE_INTEGER Sleep;
|
|
|
|
/* Try to get an IRP */
|
|
Irp = IoAllocateIrp(StackSize, FALSE);
|
|
if (Irp)
|
|
return Irp;
|
|
|
|
/* If we fail, start looping till we may get one */
|
|
i = LONG_MAX;
|
|
do {
|
|
i--;
|
|
|
|
/* First, sleep for 10ms */
|
|
Sleep.QuadPart = -10 * 1000 * 10;
|
|
KeDelayExecutionThread(KernelMode, FALSE, &Sleep);
|
|
|
|
/* Then, retry allocation */
|
|
Irp = IoAllocateIrp(StackSize, FALSE);
|
|
if (Irp)
|
|
return Irp;
|
|
} while (i > 0);
|
|
|
|
return Irp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IoBuildAsynchronousFsdRequest(IN ULONG MajorFunction,
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PVOID Buffer,
|
|
IN ULONG Length,
|
|
IN PLARGE_INTEGER StartingOffset,
|
|
IN PIO_STATUS_BLOCK IoStatusBlock)
|
|
{
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION StackPtr;
|
|
|
|
/* Allocate IRP */
|
|
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
|
|
if (!Irp) return NULL;
|
|
|
|
/* Get the Stack */
|
|
StackPtr = IoGetNextIrpStackLocation(Irp);
|
|
|
|
/* Write the Major function and then deal with it */
|
|
StackPtr->MajorFunction = (UCHAR)MajorFunction;
|
|
|
|
/* Do not handle the following here */
|
|
if ((MajorFunction != IRP_MJ_FLUSH_BUFFERS) &&
|
|
(MajorFunction != IRP_MJ_SHUTDOWN) &&
|
|
(MajorFunction != IRP_MJ_PNP) &&
|
|
(MajorFunction != IRP_MJ_POWER))
|
|
{
|
|
/* Check if this is Buffered IO */
|
|
if (DeviceObject->Flags & DO_BUFFERED_IO)
|
|
{
|
|
/* Allocate the System Buffer */
|
|
Irp->AssociatedIrp.SystemBuffer =
|
|
ExAllocatePoolWithTag(NonPagedPool, Length, TAG_SYS_BUF);
|
|
if (!Irp->AssociatedIrp.SystemBuffer)
|
|
{
|
|
/* Free the IRP and fail */
|
|
IoFreeIrp(Irp);
|
|
return NULL;
|
|
}
|
|
|
|
/* Set flags */
|
|
Irp->Flags = IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER;
|
|
|
|
/* Handle special IRP_MJ_WRITE Case */
|
|
if (MajorFunction == IRP_MJ_WRITE)
|
|
{
|
|
/* Copy the buffer data */
|
|
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, Buffer, Length);
|
|
}
|
|
else
|
|
{
|
|
/* Set the Input Operation flag and set this as a User Buffer */
|
|
Irp->Flags |= IRP_INPUT_OPERATION;
|
|
Irp->UserBuffer = Buffer;
|
|
}
|
|
}
|
|
else if (DeviceObject->Flags & DO_DIRECT_IO)
|
|
{
|
|
/* Use an MDL for Direct I/O */
|
|
Irp->MdlAddress = IoAllocateMdl(Buffer,
|
|
Length,
|
|
FALSE,
|
|
FALSE,
|
|
NULL);
|
|
if (!Irp->MdlAddress)
|
|
{
|
|
/* Free the IRP and fail */
|
|
IoFreeIrp(Irp);
|
|
return NULL;
|
|
}
|
|
|
|
/* Probe and Lock */
|
|
_SEH2_TRY
|
|
{
|
|
/* Do the probe */
|
|
MmProbeAndLockPages(Irp->MdlAddress,
|
|
KernelMode,
|
|
MajorFunction == IRP_MJ_READ ?
|
|
IoWriteAccess : IoReadAccess);
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
/* Free the IRP and its MDL */
|
|
IoFreeMdl(Irp->MdlAddress);
|
|
IoFreeIrp(Irp);
|
|
|
|
/* Fail */
|
|
_SEH2_YIELD(return NULL);
|
|
}
|
|
_SEH2_END;
|
|
}
|
|
else
|
|
{
|
|
/* Neither, use the buffer */
|
|
Irp->UserBuffer = Buffer;
|
|
}
|
|
|
|
/* Check if this is a read */
|
|
if (MajorFunction == IRP_MJ_READ)
|
|
{
|
|
/* Set the parameters for a read */
|
|
StackPtr->Parameters.Read.Length = Length;
|
|
StackPtr->Parameters.Read.ByteOffset = *StartingOffset;
|
|
}
|
|
else if (MajorFunction == IRP_MJ_WRITE)
|
|
{
|
|
/* Otherwise, set write parameters */
|
|
StackPtr->Parameters.Write.Length = Length;
|
|
StackPtr->Parameters.Write.ByteOffset = *StartingOffset;
|
|
}
|
|
}
|
|
|
|
/* Set the Current Thread and IOSB */
|
|
Irp->UserIosb = IoStatusBlock;
|
|
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
|
|
|
|
/* Return the IRP */
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Built IRP %p with Major, Buffer, DO %lx %p %p\n",
|
|
__FUNCTION__,
|
|
Irp,
|
|
MajorFunction,
|
|
Buffer,
|
|
DeviceObject);
|
|
return Irp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IoBuildDeviceIoControlRequest(IN ULONG IoControlCode,
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PVOID InputBuffer,
|
|
IN ULONG InputBufferLength,
|
|
IN PVOID OutputBuffer,
|
|
IN ULONG OutputBufferLength,
|
|
IN BOOLEAN InternalDeviceIoControl,
|
|
IN PKEVENT Event,
|
|
IN PIO_STATUS_BLOCK IoStatusBlock)
|
|
{
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION StackPtr;
|
|
ULONG BufferLength;
|
|
|
|
/* Allocate IRP */
|
|
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
|
|
if (!Irp) return NULL;
|
|
|
|
/* Get the Stack */
|
|
StackPtr = IoGetNextIrpStackLocation(Irp);
|
|
|
|
/* Set the DevCtl Type */
|
|
StackPtr->MajorFunction = InternalDeviceIoControl ?
|
|
IRP_MJ_INTERNAL_DEVICE_CONTROL :
|
|
IRP_MJ_DEVICE_CONTROL;
|
|
|
|
/* Set the IOCTL Data */
|
|
StackPtr->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
|
|
StackPtr->Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
|
|
StackPtr->Parameters.DeviceIoControl.OutputBufferLength =
|
|
OutputBufferLength;
|
|
|
|
/* Handle the Methods */
|
|
switch (IO_METHOD_FROM_CTL_CODE(IoControlCode))
|
|
{
|
|
/* Buffered I/O */
|
|
case METHOD_BUFFERED:
|
|
|
|
/* Select the right Buffer Length */
|
|
BufferLength = InputBufferLength > OutputBufferLength ?
|
|
InputBufferLength : OutputBufferLength;
|
|
|
|
/* Make sure there is one */
|
|
if (BufferLength)
|
|
{
|
|
/* Allocate the System Buffer */
|
|
Irp->AssociatedIrp.SystemBuffer =
|
|
ExAllocatePoolWithTag(NonPagedPool,
|
|
BufferLength,
|
|
TAG_SYS_BUF);
|
|
if (!Irp->AssociatedIrp.SystemBuffer)
|
|
{
|
|
/* Free the IRP and fail */
|
|
IoFreeIrp(Irp);
|
|
return NULL;
|
|
}
|
|
|
|
/* Check if we got a buffer */
|
|
if (InputBuffer)
|
|
{
|
|
/* Copy into the System Buffer */
|
|
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
|
|
InputBuffer,
|
|
InputBufferLength);
|
|
}
|
|
|
|
/* Write the flags */
|
|
Irp->Flags = IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER;
|
|
if (OutputBuffer) Irp->Flags |= IRP_INPUT_OPERATION;
|
|
|
|
/* Save the Buffer */
|
|
Irp->UserBuffer = OutputBuffer;
|
|
}
|
|
else
|
|
{
|
|
/* Clear the Flags and Buffer */
|
|
Irp->Flags = 0;
|
|
Irp->UserBuffer = NULL;
|
|
}
|
|
break;
|
|
|
|
/* Direct I/O */
|
|
case METHOD_IN_DIRECT:
|
|
case METHOD_OUT_DIRECT:
|
|
|
|
/* Check if we got an input buffer */
|
|
if (InputBuffer)
|
|
{
|
|
/* Allocate the System Buffer */
|
|
Irp->AssociatedIrp.SystemBuffer =
|
|
ExAllocatePoolWithTag(NonPagedPool,
|
|
InputBufferLength,
|
|
TAG_SYS_BUF);
|
|
if (!Irp->AssociatedIrp.SystemBuffer)
|
|
{
|
|
/* Free the IRP and fail */
|
|
IoFreeIrp(Irp);
|
|
return NULL;
|
|
}
|
|
|
|
/* Copy into the System Buffer */
|
|
RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
|
|
InputBuffer,
|
|
InputBufferLength);
|
|
|
|
/* Write the flags */
|
|
Irp->Flags = IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER;
|
|
}
|
|
else
|
|
{
|
|
/* Clear the flags */
|
|
Irp->Flags = 0;
|
|
}
|
|
|
|
/* Check if we got an output buffer */
|
|
if (OutputBuffer)
|
|
{
|
|
/* Allocate the System Buffer */
|
|
Irp->MdlAddress = IoAllocateMdl(OutputBuffer,
|
|
OutputBufferLength,
|
|
FALSE,
|
|
FALSE,
|
|
Irp);
|
|
if (!Irp->MdlAddress)
|
|
{
|
|
/* Free the IRP and fail */
|
|
IoFreeIrp(Irp);
|
|
return NULL;
|
|
}
|
|
|
|
/* Probe and Lock */
|
|
_SEH2_TRY
|
|
{
|
|
/* Do the probe */
|
|
MmProbeAndLockPages(Irp->MdlAddress,
|
|
KernelMode,
|
|
IO_METHOD_FROM_CTL_CODE(IoControlCode) ==
|
|
METHOD_IN_DIRECT ?
|
|
IoReadAccess : IoWriteAccess);
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
/* Free the MDL */
|
|
IoFreeMdl(Irp->MdlAddress);
|
|
|
|
/* Free the input buffer and IRP */
|
|
if (InputBuffer) ExFreePool(Irp->AssociatedIrp.SystemBuffer);
|
|
IoFreeIrp(Irp);
|
|
|
|
/* Fail */
|
|
_SEH2_YIELD(return NULL);
|
|
}
|
|
_SEH2_END;
|
|
}
|
|
break;
|
|
|
|
case METHOD_NEITHER:
|
|
|
|
/* Just save the Buffer */
|
|
Irp->UserBuffer = OutputBuffer;
|
|
StackPtr->Parameters.DeviceIoControl.Type3InputBuffer = InputBuffer;
|
|
}
|
|
|
|
/* Now write the Event and IoSB */
|
|
Irp->UserIosb = IoStatusBlock;
|
|
Irp->UserEvent = Event;
|
|
|
|
/* Sync IRPs are queued to requestor thread's irp cancel/cleanup list */
|
|
Irp->Tail.Overlay.Thread = PsGetCurrentThread();
|
|
IoQueueThreadIrp(Irp);
|
|
|
|
/* Return the IRP */
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Built IRP %p with IOCTL, Buffers, DO %lx %p %p %p\n",
|
|
__FUNCTION__,
|
|
Irp,
|
|
IoControlCode,
|
|
InputBuffer,
|
|
OutputBuffer,
|
|
DeviceObject);
|
|
return Irp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IoBuildSynchronousFsdRequest(IN ULONG MajorFunction,
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PVOID Buffer,
|
|
IN ULONG Length,
|
|
IN PLARGE_INTEGER StartingOffset,
|
|
IN PKEVENT Event,
|
|
IN PIO_STATUS_BLOCK IoStatusBlock)
|
|
{
|
|
PIRP Irp;
|
|
|
|
/* Do the big work to set up the IRP */
|
|
Irp = IoBuildAsynchronousFsdRequest(MajorFunction,
|
|
DeviceObject,
|
|
Buffer,
|
|
Length,
|
|
StartingOffset,
|
|
IoStatusBlock );
|
|
if (!Irp) return NULL;
|
|
|
|
/* Set the Event which makes it Syncronous */
|
|
Irp->UserEvent = Event;
|
|
|
|
/* Sync IRPs are queued to requestor thread's irp cancel/cleanup list */
|
|
IoQueueThreadIrp(Irp);
|
|
return Irp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
BOOLEAN
|
|
NTAPI
|
|
IoCancelIrp(IN PIRP Irp)
|
|
{
|
|
KIRQL OldIrql;
|
|
PDRIVER_CANCEL CancelRoutine;
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Canceling IRP %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
ASSERT(Irp->Type == IO_TYPE_IRP);
|
|
|
|
/* Acquire the cancel lock and cancel the IRP */
|
|
IoAcquireCancelSpinLock(&OldIrql);
|
|
Irp->Cancel = TRUE;
|
|
|
|
/* Clear the cancel routine and get the old one */
|
|
CancelRoutine = IoSetCancelRoutine(Irp, NULL);
|
|
if (CancelRoutine)
|
|
{
|
|
/* We had a routine, make sure the IRP isn't completed */
|
|
if (Irp->CurrentLocation > (Irp->StackCount + 1))
|
|
{
|
|
/* It is, bugcheck */
|
|
KeBugCheckEx(CANCEL_STATE_IN_COMPLETED_IRP,
|
|
(ULONG_PTR)Irp,
|
|
(ULONG_PTR)CancelRoutine,
|
|
0,
|
|
0);
|
|
}
|
|
|
|
/* Set the cancel IRQL And call the routine */
|
|
Irp->CancelIrql = OldIrql;
|
|
CancelRoutine(IoGetCurrentIrpStackLocation(Irp)->DeviceObject, Irp);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Otherwise, release the cancel lock and fail */
|
|
IoReleaseCancelSpinLock(OldIrql);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoCancelThreadIo(IN PETHREAD Thread)
|
|
{
|
|
KIRQL OldIrql;
|
|
ULONG Retries = 3000;
|
|
LARGE_INTEGER Interval;
|
|
PLIST_ENTRY ListHead, NextEntry;
|
|
PIRP Irp;
|
|
PAGED_CODE();
|
|
|
|
/* Windows isn't using given thread, but using current. */
|
|
Thread = PsGetCurrentThread();
|
|
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Canceling IRPs for Thread %p\n",
|
|
__FUNCTION__,
|
|
Thread);
|
|
|
|
/* Raise to APC to protect the IrpList */
|
|
KeRaiseIrql(APC_LEVEL, &OldIrql);
|
|
|
|
/* Start by cancelling all the IRPs in the current thread queue. */
|
|
ListHead = &Thread->IrpList;
|
|
NextEntry = ListHead->Flink;
|
|
while (ListHead != NextEntry)
|
|
{
|
|
/* Get the IRP */
|
|
Irp = CONTAINING_RECORD(NextEntry, IRP, ThreadListEntry);
|
|
|
|
/* Cancel it */
|
|
IoCancelIrp(Irp);
|
|
|
|
/* Move to the next entry */
|
|
NextEntry = NextEntry->Flink;
|
|
}
|
|
|
|
/* Wait 100 milliseconds */
|
|
Interval.QuadPart = -1000000;
|
|
|
|
/* Wait till all the IRPs are completed or cancelled. */
|
|
while (!IsListEmpty(&Thread->IrpList))
|
|
{
|
|
/* Now we can lower */
|
|
KeLowerIrql(OldIrql);
|
|
|
|
/* Wait a short while and then look if all our IRPs were completed. */
|
|
KeDelayExecutionThread(KernelMode, FALSE, &Interval);
|
|
|
|
/*
|
|
* Don't stay here forever if some broken driver doesn't complete
|
|
* the IRP.
|
|
*/
|
|
if (!(Retries--))
|
|
{
|
|
/* Print out a message and remove the IRP */
|
|
DPRINT1("Broken driver did not complete!\n");
|
|
IopDisassociateThreadIrp();
|
|
}
|
|
|
|
/* Raise the IRQL Again */
|
|
KeRaiseIrql(APC_LEVEL, &OldIrql);
|
|
}
|
|
|
|
/* We're done, lower the IRQL */
|
|
KeLowerIrql(OldIrql);
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
#undef IoCallDriver
|
|
NTSTATUS
|
|
NTAPI
|
|
IoCallDriver(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
/* Call fastcall */
|
|
return IofCallDriver(DeviceObject, Irp);
|
|
}
|
|
|
|
#define IoCallDriver IofCallDriver
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
#undef IoCompleteRequest
|
|
VOID
|
|
NTAPI
|
|
IoCompleteRequest(IN PIRP Irp,
|
|
IN CCHAR PriorityBoost)
|
|
{
|
|
/* Call the fastcall */
|
|
IofCompleteRequest(Irp, PriorityBoost);
|
|
}
|
|
|
|
#define IoCompleteRequest IofCompleteRequest
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoEnqueueIrp(IN PIRP Irp)
|
|
{
|
|
/* This is the same as calling IoQueueThreadIrp */
|
|
IoQueueThreadIrp(Irp);
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
NTSTATUS
|
|
FASTCALL
|
|
IofCallDriver(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
PDRIVER_OBJECT DriverObject;
|
|
PIO_STACK_LOCATION StackPtr;
|
|
|
|
/* Make sure this is a valid IRP */
|
|
ASSERT(Irp->Type == IO_TYPE_IRP);
|
|
|
|
/* Get the Driver Object */
|
|
DriverObject = DeviceObject->DriverObject;
|
|
|
|
/* Decrease the current location and check if */
|
|
Irp->CurrentLocation--;
|
|
if (Irp->CurrentLocation <= 0)
|
|
{
|
|
/* This IRP ran out of stack, bugcheck */
|
|
KeBugCheckEx(NO_MORE_IRP_STACK_LOCATIONS, (ULONG_PTR)Irp, 0, 0, 0);
|
|
}
|
|
|
|
/* Now update the stack location */
|
|
StackPtr = IoGetNextIrpStackLocation(Irp);
|
|
Irp->Tail.Overlay.CurrentStackLocation = StackPtr;
|
|
|
|
/* Get the Device Object */
|
|
StackPtr->DeviceObject = DeviceObject;
|
|
|
|
/* Call it */
|
|
return DriverObject->MajorFunction[StackPtr->MajorFunction](DeviceObject,
|
|
Irp);
|
|
}
|
|
|
|
FORCEINLINE
|
|
VOID
|
|
IopClearStackLocation(IN PIO_STACK_LOCATION IoStackLocation)
|
|
{
|
|
IoStackLocation->MinorFunction = 0;
|
|
IoStackLocation->Flags = 0;
|
|
IoStackLocation->Control &= SL_ERROR_RETURNED;
|
|
IoStackLocation->Parameters.Others.Argument1 = 0;
|
|
IoStackLocation->Parameters.Others.Argument2 = 0;
|
|
IoStackLocation->Parameters.Others.Argument3 = 0;
|
|
IoStackLocation->FileObject = NULL;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
FASTCALL
|
|
IofCompleteRequest(IN PIRP Irp,
|
|
IN CCHAR PriorityBoost)
|
|
{
|
|
PIO_STACK_LOCATION StackPtr, LastStackPtr;
|
|
PDEVICE_OBJECT DeviceObject;
|
|
PFILE_OBJECT FileObject;
|
|
PETHREAD Thread;
|
|
NTSTATUS Status;
|
|
PMDL Mdl, NextMdl;
|
|
ULONG MasterCount;
|
|
PIRP MasterIrp;
|
|
ULONG Flags;
|
|
NTSTATUS ErrorCode = STATUS_SUCCESS;
|
|
PREPARSE_DATA_BUFFER DataBuffer = NULL;
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Completing IRP %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
|
|
/* Make sure this IRP isn't getting completed twice or is invalid */
|
|
if ((Irp->CurrentLocation) > (Irp->StackCount + 1))
|
|
{
|
|
/* Bugcheck */
|
|
KeBugCheckEx(MULTIPLE_IRP_COMPLETE_REQUESTS, (ULONG_PTR)Irp, 0, 0, 0);
|
|
}
|
|
|
|
/* Some sanity checks */
|
|
ASSERT(Irp->Type == IO_TYPE_IRP);
|
|
ASSERT(!Irp->CancelRoutine);
|
|
ASSERT(Irp->IoStatus.Status != STATUS_PENDING);
|
|
ASSERT(Irp->IoStatus.Status != (NTSTATUS)0xFFFFFFFF);
|
|
|
|
/* Get the last stack */
|
|
LastStackPtr = (PIO_STACK_LOCATION)(Irp + 1);
|
|
if (LastStackPtr->Control & SL_ERROR_RETURNED)
|
|
{
|
|
/* Get the error code */
|
|
ErrorCode = PtrToUlong(LastStackPtr->Parameters.Others.Argument4);
|
|
}
|
|
|
|
/*
|
|
* Start the loop with the current stack and point the IRP to the next stack
|
|
* and then keep incrementing the stack as we loop through. The IRP should
|
|
* always point to the next stack location w.r.t the one currently being
|
|
* analyzed, so completion routine code will see the appropriate value.
|
|
* Because of this, we must loop until the current stack location is +1 of
|
|
* the stack count, because when StackPtr is at the end, CurrentLocation is +1.
|
|
*/
|
|
for (StackPtr = IoGetCurrentIrpStackLocation(Irp),
|
|
Irp->CurrentLocation++,
|
|
Irp->Tail.Overlay.CurrentStackLocation++;
|
|
Irp->CurrentLocation <= (Irp->StackCount + 1);
|
|
StackPtr++,
|
|
Irp->CurrentLocation++,
|
|
Irp->Tail.Overlay.CurrentStackLocation++)
|
|
{
|
|
/* Set Pending Returned */
|
|
Irp->PendingReturned = StackPtr->Control & SL_PENDING_RETURNED;
|
|
|
|
/* Check if we failed */
|
|
if (!NT_SUCCESS(Irp->IoStatus.Status))
|
|
{
|
|
/* Check if it was changed by a completion routine */
|
|
if (Irp->IoStatus.Status != ErrorCode)
|
|
{
|
|
/* Update the error for the current stack */
|
|
ErrorCode = Irp->IoStatus.Status;
|
|
StackPtr->Control |= SL_ERROR_RETURNED;
|
|
LastStackPtr->Parameters.Others.Argument4 = UlongToPtr(ErrorCode);
|
|
LastStackPtr->Control |= SL_ERROR_RETURNED;
|
|
}
|
|
}
|
|
|
|
/* Check if there is a Completion Routine to Call */
|
|
if ((NT_SUCCESS(Irp->IoStatus.Status) &&
|
|
(StackPtr->Control & SL_INVOKE_ON_SUCCESS)) ||
|
|
(!NT_SUCCESS(Irp->IoStatus.Status) &&
|
|
(StackPtr->Control & SL_INVOKE_ON_ERROR)) ||
|
|
(Irp->Cancel &&
|
|
(StackPtr->Control & SL_INVOKE_ON_CANCEL)))
|
|
{
|
|
/* Clear the stack location */
|
|
IopClearStackLocation(StackPtr);
|
|
|
|
/* Check for highest-level device completion routines */
|
|
if (Irp->CurrentLocation == (Irp->StackCount + 1))
|
|
{
|
|
/* Clear the DO, since the current stack location is invalid */
|
|
DeviceObject = NULL;
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, return the real one */
|
|
DeviceObject = IoGetCurrentIrpStackLocation(Irp)->DeviceObject;
|
|
}
|
|
|
|
/* Call the completion routine */
|
|
Status = StackPtr->CompletionRoutine(DeviceObject,
|
|
Irp,
|
|
StackPtr->Context);
|
|
|
|
/* Don't touch the Packet in this case, since it might be gone! */
|
|
if (Status == STATUS_MORE_PROCESSING_REQUIRED) return;
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, check if this is a completed IRP */
|
|
if ((Irp->CurrentLocation <= Irp->StackCount) &&
|
|
(Irp->PendingReturned))
|
|
{
|
|
/* Mark it as pending */
|
|
IoMarkIrpPending(Irp);
|
|
}
|
|
|
|
/* Clear the stack location */
|
|
IopClearStackLocation(StackPtr);
|
|
}
|
|
}
|
|
|
|
/* Check if the IRP is an associated IRP */
|
|
if (Irp->Flags & IRP_ASSOCIATED_IRP)
|
|
{
|
|
/* Get the master IRP and count */
|
|
MasterIrp = Irp->AssociatedIrp.MasterIrp;
|
|
MasterCount = InterlockedDecrement(&MasterIrp->AssociatedIrp.IrpCount);
|
|
|
|
/* Free the MDLs */
|
|
for (Mdl = Irp->MdlAddress; Mdl; Mdl = NextMdl)
|
|
{
|
|
/* Go to the next one */
|
|
NextMdl = Mdl->Next;
|
|
IoFreeMdl(Mdl);
|
|
}
|
|
|
|
/* Free the IRP itself */
|
|
IoFreeIrp(Irp);
|
|
|
|
/* Complete the Master IRP */
|
|
if (!MasterCount) IofCompleteRequest(MasterIrp, PriorityBoost);
|
|
return;
|
|
}
|
|
|
|
/* Check whether we have to reparse */
|
|
if (Irp->IoStatus.Status == STATUS_REPARSE)
|
|
{
|
|
if (Irp->IoStatus.Information > IO_REMOUNT)
|
|
{
|
|
/* If that's a reparse tag we understand, save the buffer from deletion */
|
|
if (Irp->IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT)
|
|
{
|
|
ASSERT(Irp->Tail.Overlay.AuxiliaryBuffer != NULL);
|
|
DataBuffer = (PREPARSE_DATA_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
|
|
Irp->Tail.Overlay.AuxiliaryBuffer = NULL;
|
|
}
|
|
else
|
|
{
|
|
Irp->IoStatus.Status = STATUS_IO_REPARSE_TAG_NOT_HANDLED;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Check if we have an auxiliary buffer */
|
|
if (Irp->Tail.Overlay.AuxiliaryBuffer)
|
|
{
|
|
/* Free it */
|
|
ExFreePool(Irp->Tail.Overlay.AuxiliaryBuffer);
|
|
Irp->Tail.Overlay.AuxiliaryBuffer = NULL;
|
|
}
|
|
|
|
/* Check if this is a Paging I/O or Close Operation */
|
|
if (Irp->Flags & (IRP_PAGING_IO | IRP_CLOSE_OPERATION))
|
|
{
|
|
/* Handle a Close Operation or Sync Paging I/O */
|
|
if (Irp->Flags & (IRP_SYNCHRONOUS_PAGING_IO | IRP_CLOSE_OPERATION))
|
|
{
|
|
/* Set the I/O Status and Signal the Event */
|
|
Flags = Irp->Flags & (IRP_SYNCHRONOUS_PAGING_IO | IRP_PAGING_IO);
|
|
*Irp->UserIosb = Irp->IoStatus;
|
|
KeSetEvent(Irp->UserEvent, PriorityBoost, FALSE);
|
|
|
|
/* Free the IRP for a Paging I/O Only, Close is handled by us */
|
|
if (Flags)
|
|
{
|
|
/* If we were using the reserve IRP, then call the appropriate
|
|
* free function (to make the IRP available again)
|
|
*/
|
|
if (Irp == IopReserveIrpAllocator.ReserveIrp)
|
|
{
|
|
IopFreeReserveIrp(PriorityBoost);
|
|
}
|
|
/* Otherwise, free for real! */
|
|
else
|
|
{
|
|
IoFreeIrp(Irp);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if 0
|
|
/* Page 166 */
|
|
KeInitializeApc(&Irp->Tail.Apc
|
|
&Irp->Tail.Overlay.Thread->Tcb,
|
|
Irp->ApcEnvironment,
|
|
IopCompletePageWrite,
|
|
NULL,
|
|
NULL,
|
|
KernelMode,
|
|
NULL);
|
|
KeInsertQueueApc(&Irp->Tail.Apc,
|
|
NULL,
|
|
NULL,
|
|
PriorityBoost);
|
|
#else
|
|
/* Not implemented yet. */
|
|
UNIMPLEMENTED_DBGBREAK("Not supported!\n");
|
|
#endif
|
|
}
|
|
|
|
/* Get out of here */
|
|
return;
|
|
}
|
|
|
|
/* Unlock MDL Pages, page 167. */
|
|
Mdl = Irp->MdlAddress;
|
|
while (Mdl)
|
|
{
|
|
MmUnlockPages(Mdl);
|
|
Mdl = Mdl->Next;
|
|
}
|
|
|
|
/* Check if we should exit because of a Deferred I/O (page 168) */
|
|
if ((Irp->Flags & IRP_DEFER_IO_COMPLETION) && !(Irp->PendingReturned))
|
|
{
|
|
/* Restore the saved reparse buffer for the caller */
|
|
if (Irp->IoStatus.Status == STATUS_REPARSE &&
|
|
Irp->IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT)
|
|
{
|
|
Irp->Tail.Overlay.AuxiliaryBuffer = (PCHAR)DataBuffer;
|
|
}
|
|
|
|
/*
|
|
* Return without queuing the completion APC, since the caller will
|
|
* take care of doing its own optimized completion at PASSIVE_LEVEL.
|
|
*/
|
|
return;
|
|
}
|
|
|
|
/* Get the thread and file object */
|
|
Thread = Irp->Tail.Overlay.Thread;
|
|
FileObject = Irp->Tail.Overlay.OriginalFileObject;
|
|
|
|
/* Make sure the IRP isn't canceled */
|
|
if (!Irp->Cancel)
|
|
{
|
|
/* Initialize the APC */
|
|
KeInitializeApc(&Irp->Tail.Apc,
|
|
&Thread->Tcb,
|
|
Irp->ApcEnvironment,
|
|
IopCompleteRequest,
|
|
NULL,
|
|
NULL,
|
|
KernelMode,
|
|
NULL);
|
|
|
|
/* Queue it */
|
|
KeInsertQueueApc(&Irp->Tail.Apc,
|
|
FileObject,
|
|
DataBuffer,
|
|
PriorityBoost);
|
|
}
|
|
else
|
|
{
|
|
/* The IRP just got canceled... does a thread still own it? */
|
|
if (Thread)
|
|
{
|
|
/* Yes! There is still hope! Initialize the APC */
|
|
KeInitializeApc(&Irp->Tail.Apc,
|
|
&Thread->Tcb,
|
|
Irp->ApcEnvironment,
|
|
IopCompleteRequest,
|
|
NULL,
|
|
NULL,
|
|
KernelMode,
|
|
NULL);
|
|
|
|
/* Queue it */
|
|
KeInsertQueueApc(&Irp->Tail.Apc,
|
|
FileObject,
|
|
DataBuffer,
|
|
PriorityBoost);
|
|
}
|
|
else
|
|
{
|
|
/* Nothing left for us to do, kill it */
|
|
ASSERT(Irp->Cancel);
|
|
IopCleanupIrp(Irp, FileObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
IopSynchronousCompletion(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context)
|
|
{
|
|
if (Irp->PendingReturned)
|
|
KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, FALSE);
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
BOOLEAN
|
|
NTAPI
|
|
IoForwardIrpSynchronously(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
KEVENT Event;
|
|
NTSTATUS Status;
|
|
|
|
/* Check if next stack location is available */
|
|
if (Irp->CurrentLocation < Irp->StackCount)
|
|
{
|
|
/* No more stack location */
|
|
return FALSE;
|
|
}
|
|
|
|
/* Initialize event */
|
|
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
|
|
|
/* Copy stack location for next driver */
|
|
IoCopyCurrentIrpStackLocationToNext(Irp);
|
|
|
|
/* Set a completion routine, which will signal the event */
|
|
IoSetCompletionRoutine(Irp, IopSynchronousCompletion, &Event, TRUE, TRUE, TRUE);
|
|
|
|
/* Call next driver */
|
|
Status = IoCallDriver(DeviceObject, Irp);
|
|
|
|
/* Check if irp is pending */
|
|
if (Status == STATUS_PENDING)
|
|
{
|
|
/* Yes, wait for its completion */
|
|
KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
|
|
}
|
|
|
|
/* Return success */
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoFreeIrp(IN PIRP Irp)
|
|
{
|
|
PNPAGED_LOOKASIDE_LIST List;
|
|
PP_NPAGED_LOOKASIDE_NUMBER ListType = LookasideSmallIrpList;
|
|
PKPRCB Prcb;
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Freeing IRPs %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
|
|
/* Make sure the Thread IRP list is empty and that it OK to free it */
|
|
ASSERT(Irp->Type == IO_TYPE_IRP);
|
|
ASSERT(IsListEmpty(&Irp->ThreadListEntry));
|
|
ASSERT(Irp->CurrentLocation >= Irp->StackCount);
|
|
|
|
/* Get the PRCB */
|
|
Prcb = KeGetCurrentPrcb();
|
|
|
|
/* If this was a lookaside alloc, increment lookaside float */
|
|
if (Irp->AllocationFlags & IRP_LOOKASIDE_ALLOCATION)
|
|
{
|
|
Irp->AllocationFlags &= ~IRP_LOOKASIDE_ALLOCATION;
|
|
InterlockedIncrement(&Prcb->LookasideIrpFloat);
|
|
}
|
|
|
|
/* If this was a pool alloc, free it with the pool */
|
|
if (!(Irp->AllocationFlags & IRP_ALLOCATED_FIXED_SIZE))
|
|
{
|
|
/* Free it */
|
|
ExFreePoolWithTag(Irp, TAG_IRP);
|
|
}
|
|
else
|
|
{
|
|
/* Check if this was a Big IRP */
|
|
if (Irp->StackCount != 1) ListType = LookasideLargeIrpList;
|
|
|
|
/* Use the P List */
|
|
List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[ListType].P;
|
|
List->L.TotalFrees++;
|
|
|
|
/* Check if the Free was within the Depth or not */
|
|
if (ExQueryDepthSList(&List->L.ListHead) >= List->L.Depth)
|
|
{
|
|
/* Let the balancer know */
|
|
List->L.FreeMisses++;
|
|
|
|
/* Use the L List */
|
|
List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[ListType].L;
|
|
List->L.TotalFrees++;
|
|
|
|
/* Check if the Free was within the Depth or not */
|
|
if (ExQueryDepthSList(&List->L.ListHead) >= List->L.Depth)
|
|
{
|
|
/* All lists failed, use the pool */
|
|
List->L.FreeMisses++;
|
|
ExFreePoolWithTag(Irp, TAG_IRP);
|
|
Irp = NULL;
|
|
}
|
|
}
|
|
|
|
/* The free was within the Depth */
|
|
if (Irp)
|
|
{
|
|
/* Remove the association with the process */
|
|
if (Irp->AllocationFlags & IRP_QUOTA_CHARGED)
|
|
{
|
|
ExReturnPoolQuota(Irp);
|
|
Irp->AllocationFlags &= ~IRP_QUOTA_CHARGED;
|
|
}
|
|
|
|
/* Add it to the lookaside list */
|
|
InterlockedPushEntrySList(&List->L.ListHead,
|
|
(PSLIST_ENTRY)Irp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
IO_PAGING_PRIORITY
|
|
FASTCALL
|
|
IoGetPagingIoPriority(IN PIRP Irp)
|
|
{
|
|
IO_PAGING_PRIORITY Priority;
|
|
ULONG Flags;
|
|
|
|
/* Get the flags */
|
|
Flags = Irp->Flags;
|
|
|
|
/* Check what priority it has */
|
|
if (Flags & IRP_CLASS_CACHE_OPERATION)
|
|
{
|
|
/* High priority */
|
|
Priority = IoPagingPriorityHigh;
|
|
}
|
|
else if (Flags & IRP_PAGING_IO)
|
|
{
|
|
/* Normal priority */
|
|
Priority = IoPagingPriorityNormal;
|
|
}
|
|
else
|
|
{
|
|
/* Invalid -- not a paging IRP */
|
|
Priority = IoPagingPriorityInvalid;
|
|
}
|
|
|
|
/* Return the priority */
|
|
return Priority;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PEPROCESS
|
|
NTAPI
|
|
IoGetRequestorProcess(IN PIRP Irp)
|
|
{
|
|
/* Return the requestor process */
|
|
if (Irp->Tail.Overlay.Thread)
|
|
{
|
|
if (Irp->ApcEnvironment == OriginalApcEnvironment)
|
|
{
|
|
return Irp->Tail.Overlay.Thread->ThreadsProcess;
|
|
}
|
|
else if (Irp->ApcEnvironment == AttachedApcEnvironment)
|
|
{
|
|
return (PEPROCESS)Irp->Tail.Overlay.Thread->Tcb.ApcState.Process;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
ULONG
|
|
NTAPI
|
|
IoGetRequestorProcessId(IN PIRP Irp)
|
|
{
|
|
PEPROCESS Process;
|
|
|
|
/* Return the requestor process' id */
|
|
Process = IoGetRequestorProcess(Irp);
|
|
if (Process) return PtrToUlong(Process->UniqueProcessId);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
NTSTATUS
|
|
NTAPI
|
|
IoGetRequestorSessionId(IN PIRP Irp,
|
|
OUT PULONG pSessionId)
|
|
{
|
|
PEPROCESS Process;
|
|
|
|
/* Return the session */
|
|
if (Irp->Tail.Overlay.Thread)
|
|
{
|
|
Process = Irp->Tail.Overlay.Thread->ThreadsProcess;
|
|
*pSessionId = MmGetSessionId(Process);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
*pSessionId = (ULONG)-1;
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IoGetTopLevelIrp(VOID)
|
|
{
|
|
/* Return the IRP */
|
|
return (PIRP)PsGetCurrentThread()->TopLevelIrp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoInitializeIrp(IN PIRP Irp,
|
|
IN USHORT PacketSize,
|
|
IN CCHAR StackSize)
|
|
{
|
|
/* Clear it */
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Initializing IRP %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
RtlZeroMemory(Irp, PacketSize);
|
|
|
|
/* Set the Header and other data */
|
|
Irp->Type = IO_TYPE_IRP;
|
|
Irp->Size = PacketSize;
|
|
Irp->StackCount = StackSize;
|
|
Irp->CurrentLocation = StackSize + 1;
|
|
Irp->ApcEnvironment = KeGetCurrentThread()->ApcStateIndex;
|
|
Irp->Tail.Overlay.CurrentStackLocation = (PIO_STACK_LOCATION)(Irp + 1) + StackSize;
|
|
|
|
/* Initialize the Thread List */
|
|
InitializeListHead(&Irp->ThreadListEntry);
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
BOOLEAN
|
|
NTAPI
|
|
IoIsOperationSynchronous(IN PIRP Irp)
|
|
{
|
|
BOOLEAN SynchIO;
|
|
BOOLEAN ForceAsync;
|
|
|
|
/* If the IRP requests synchronous paging I/O, if the file object was opened
|
|
for synchronous I/O, if the IRP_SYNCHRONOUS_API flag is set in the IRP
|
|
the operation is synchronous */
|
|
SynchIO = (IoGetCurrentIrpStackLocation(Irp)->FileObject->Flags & FO_SYNCHRONOUS_IO) ||
|
|
(Irp->Flags & IRP_SYNCHRONOUS_API) || (Irp->Flags & IRP_SYNCHRONOUS_PAGING_IO);
|
|
|
|
/* If the IRP requests asynchronous paging I/O, the operation is asynchronous,
|
|
even if one of the above conditions is true */
|
|
ForceAsync = (Irp->Flags & IRP_PAGING_IO) && !(Irp->Flags & IRP_SYNCHRONOUS_PAGING_IO);
|
|
|
|
/* Check the flags */
|
|
if (SynchIO && !ForceAsync)
|
|
{
|
|
/* Synch API or Paging I/O is OK, as is Sync File I/O */
|
|
return TRUE;
|
|
}
|
|
|
|
/* Otherwise, it is an asynchronous operation. */
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* @unimplemented
|
|
*/
|
|
BOOLEAN
|
|
NTAPI
|
|
IoIsValidNameGraftingBuffer(IN PIRP Irp,
|
|
IN PREPARSE_DATA_BUFFER ReparseBuffer)
|
|
{
|
|
UNIMPLEMENTED;
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
PIRP
|
|
NTAPI
|
|
IoMakeAssociatedIrp(IN PIRP Irp,
|
|
IN CCHAR StackSize)
|
|
{
|
|
PIRP AssocIrp;
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Associating IRP %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
|
|
/* Allocate the IRP */
|
|
AssocIrp = IoAllocateIrp(StackSize, FALSE);
|
|
if (!AssocIrp) return NULL;
|
|
|
|
/* Set the Flags */
|
|
AssocIrp->Flags |= IRP_ASSOCIATED_IRP;
|
|
|
|
/* Set the Thread */
|
|
AssocIrp->Tail.Overlay.Thread = Irp->Tail.Overlay.Thread;
|
|
|
|
/* Associate them */
|
|
AssocIrp->AssociatedIrp.MasterIrp = Irp;
|
|
return AssocIrp;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoQueueThreadIrp(IN PIRP Irp)
|
|
{
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Queueing IRP %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
|
|
/* Use our inlined routine */
|
|
IopQueueIrpToThread(Irp);
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
* Reference: Chris Cant's "Writing WDM Device Drivers"
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoReuseIrp(IN OUT PIRP Irp,
|
|
IN NTSTATUS Status)
|
|
{
|
|
UCHAR AllocationFlags;
|
|
IOTRACE(IO_IRP_DEBUG,
|
|
"%s - Reusing IRP %p\n",
|
|
__FUNCTION__,
|
|
Irp);
|
|
|
|
/* Make sure it's OK to reuse it */
|
|
ASSERT(!Irp->CancelRoutine);
|
|
ASSERT(IsListEmpty(&Irp->ThreadListEntry));
|
|
|
|
/* Get the old flags */
|
|
AllocationFlags = Irp->AllocationFlags;
|
|
|
|
/* Reinitialize the IRP */
|
|
IoInitializeIrp(Irp, Irp->Size, Irp->StackCount);
|
|
|
|
/* Duplicate the data */
|
|
Irp->IoStatus.Status = Status;
|
|
Irp->AllocationFlags = AllocationFlags;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
IoSetTopLevelIrp(IN PIRP Irp)
|
|
{
|
|
/* Set the IRP */
|
|
PsGetCurrentThread()->TopLevelIrp = (ULONG_PTR)Irp;
|
|
}
|
|
|
|
#if defined (_WIN64)
|
|
BOOLEAN
|
|
NTAPI
|
|
IoIs32bitProcess(
|
|
IN PIRP Irp OPTIONAL)
|
|
{
|
|
UNIMPLEMENTED;
|
|
return FALSE;
|
|
}
|
|
#endif
|