FileObject);
/* Sanity check */
- ASSERT(Irp->IoStatus.Status != 0xFFFFFFFF);
+ ASSERT(Irp->IoStatus.Status != (NTSTATUS)0xFFFFFFFF);
/* Check if we have a file object */
if (*SystemArgument2)
if (Irp->Flags & IRP_DEALLOCATE_BUFFER)
{
/* Deallocate it */
- ExFreePoolWithTag(Irp->AssociatedIrp.SystemBuffer, TAG_SYS_BUF);
+ ExFreePool(Irp->AssociatedIrp.SystemBuffer);
}
}
}
/* Use SEH to make sure we don't write somewhere invalid */
- _SEH_TRY
+ _SEH2_TRY
{
/* Save the IOSB Information */
*Irp->UserIosb = Irp->IoStatus;
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Ignore any error */
}
- _SEH_END;
+ _SEH2_END;
/* Check if we have an event or a file object */
if (Irp->UserEvent)
}
}
+ /* 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);
{
/* We have an I/O Completion setup... create the special Overlay */
Irp->Tail.CompletionKey = Key;
- Irp->Tail.Overlay.PacketType = IrpCompletionPacket;
+ Irp->Tail.Overlay.PacketType = IopCompletionPacketIrp;
KeInsertQueue(Port, &Irp->Tail.Overlay.ListEntry);
}
else
}
else
{
+ /* Check if we have an associated user IOSB */
+ if (Irp->UserIosb)
+ {
+ /* We do, so let's give them the final status */
+ _SEH2_TRY
+ {
+ /* Save the IOSB Information */
+ *Irp->UserIosb = Irp->IoStatus;
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Ignore any error */
+ }
+ _SEH2_END;
+ }
+
/*
* Either we didn't return from the request, or we did return but this
* request was synchronous.
/* 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)
{
/* Set Charge Quota Flag */
if (ChargeQuota) Flags |= IRP_QUOTA_CHARGED;
+ /* FIXME: Implement Lookaside Floats */
+
/* Figure out which Lookaside List to use */
if ((StackSize <= 8) && (ChargeQuota == FALSE))
{
}
else
{
- /* We have an IRP from Lookaside */
- if (ChargeQuota) Flags |= IRP_LOOKASIDE_ALLOCATION;
-
/* In this case there is no charge quota */
Flags &= ~IRP_QUOTA_CHARGED;
}
}
/* Probe and Lock */
- _SEH_TRY
+ _SEH2_TRY
{
/* Do the probe */
MmProbeAndLockPages(Irp->MdlAddress,
MajorFunction == IRP_MJ_READ ?
IoWriteAccess : IoReadAccess);
}
- _SEH_HANDLE
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Free the IRP and its MDL */
IoFreeMdl(Irp->MdlAddress);
IoFreeIrp(Irp);
- Irp = NULL;
+
+ /* Fail */
+ _SEH2_YIELD(return NULL);
}
- _SEH_END;
-
- /* This is how we know if we failed during the probe */
- if (!Irp) return NULL;
+ _SEH2_END;
}
else
{
}
/* Probe and Lock */
- _SEH_TRY
+ _SEH2_TRY
{
/* Do the probe */
MmProbeAndLockPages(Irp->MdlAddress,
METHOD_IN_DIRECT ?
IoReadAccess : IoWriteAccess);
}
- _SEH_HANDLE
+ _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);
- Irp = NULL;
- }
- _SEH_END;
- /* This is how we know if probing failed */
- if (!Irp) return NULL;
+ /* Fail */
+ _SEH2_YIELD(return NULL);
+ }
+ _SEH2_END;
}
break;
Irp->Cancel = TRUE;
/* Clear the cancel routine and get the old one */
- CancelRoutine = IoSetCancelRoutine(Irp, NULL);
+ CancelRoutine = (PVOID)IoSetCancelRoutine(Irp, NULL);
if (CancelRoutine)
{
/* We had a routine, make sure the IRP isn't completed */
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;
ASSERT(Irp->Type == IO_TYPE_IRP);
ASSERT(!Irp->CancelRoutine);
ASSERT(Irp->IoStatus.Status != STATUS_PENDING);
- ASSERT(Irp->IoStatus.Status != 0xFFFFFFFF);
+ 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 = (NTSTATUS)LastStackPtr->Parameters.Others.Argument4;
+ ErrorCode = PtrToUlong(LastStackPtr->Parameters.Others.Argument4);
}
- /* Get the Current Stack and skip it */
+ /* Get the Current Stack */
StackPtr = IoGetCurrentIrpStackLocation(Irp);
- IoSkipCurrentIrpStackLocation(Irp);
/* Loop the Stacks and complete the IRPs */
do
{
+ /* Skip current stack location */
+ IoSkipCurrentIrpStackLocation(Irp);
+
/* Set Pending Returned */
Irp->PendingReturned = StackPtr->Control & SL_PENDING_RETURNED;
/* Update the error for the current stack */
ErrorCode = Irp->IoStatus.Status;
StackPtr->Control |= SL_ERROR_RETURNED;
- LastStackPtr->Parameters.Others.Argument4 = (PVOID)ErrorCode;
+ LastStackPtr->Parameters.Others.Argument4 = UlongToPtr(ErrorCode);
LastStackPtr->Control |= SL_ERROR_RETURNED;
}
}
IopClearStackLocation(StackPtr);
}
- /* Move to next stack location and pointer */
- IoSkipCurrentIrpStackLocation(Irp);
+ /* Move pointer to next stack location */
StackPtr++;
- } while (Irp->CurrentLocation <= (Irp->StackCount + 1));
+ } while (Irp->CurrentLocation <= Irp->StackCount);
/* Check if the IRP is an associated IRP */
if (Irp->Flags & IRP_ASSOCIATED_IRP)
IoGetRequestorProcessId(IN PIRP Irp)
{
/* Return the requestor process' id */
- return (ULONG)(IoGetRequestorProcess(Irp)->UniqueProcessId);
+ return PtrToUlong(IoGetRequestorProcess(Irp)->UniqueProcessId);
}
/*
IoSetTopLevelIrp(IN PIRP Irp)
{
/* Set the IRP */
- PsGetCurrentThread()->TopLevelIrp = (ULONG)Irp;
+ PsGetCurrentThread()->TopLevelIrp = (ULONG_PTR)Irp;
}
projects / reactos.git / blobdiff