NTSTATUS
NTAPI
PciPassIrpFromFdoToPdo(IN PPCI_FDO_EXTENSION DeviceExtension,
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStackLocation;
NTSTATUS Status;
DPRINT1("Pci PassIrp ...\n");
/* Get the stack location to check which function this is */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
if (IoStackLocation->MajorFunction == IRP_MJ_POWER)
{
/* Power IRPs are special since we have to notify the Power Manager */
IoCopyCurrentIrpStackLocationToNext(Irp);
PoStartNextPowerIrp(Irp);
Status = PoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
}
else
{
/* For a normal IRP, just call the next driver in the stack */
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
}
/* Return the status back to the caller */
return Status;
}
static NTSTATUS vboxUsbPwrSetPowerDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp)
{
PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp);
DEVICE_POWER_STATE enmDevPState = pSl->Parameters.Power.State.DeviceState;
DEVICE_POWER_STATE enmCurDevPState = pDevExt->DdiState.PwrState.PowerState.DeviceState;
NTSTATUS Status = STATUS_SUCCESS;
if (enmDevPState > enmCurDevPState && enmCurDevPState == PowerDeviceD0)
{
Status = vboxUsbPwrIoWaitCompletionAndPostAsync(pDevExt, pIrp);
Assert(NT_SUCCESS(Status));
if (NT_SUCCESS(Status))
return Status;
}
PoStartNextPowerIrp(pIrp);
if (NT_SUCCESS(Status))
{
IoCopyCurrentIrpStackLocationToNext(pIrp);
IoSetCompletionRoutine(pIrp, vboxUsbPwrIoPostDevCompletion, pDevExt, TRUE, TRUE, TRUE);
Status = PoCallDriver(pDevExt->pLowerDO, pIrp);
}
else
{
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
vboxUsbDdiStateRelease(pDevExt);
}
return Status;
}
NTSTATUS
NTAPI
PciCallDownIrpStack(IN PPCI_FDO_EXTENSION DeviceExtension,
IN PIRP Irp)
{
NTSTATUS Status;
KEVENT Event;
PAGED_CODE();
DPRINT1("PciCallDownIrpStack ...\n");
ASSERT_FDO(DeviceExtension);
/* Initialize the wait event */
KeInitializeEvent(&Event, SynchronizationEvent, 0);
/* Setup a completion routine */
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp, PciSetEventCompletion, &Event, TRUE, TRUE, TRUE);
/* Call the attached device */
Status = IoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
if (Status == STATUS_PENDING)
{
/* Wait for it to complete the request, and get its status */
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
/* Return that status back to the caller */
return Status;
}
NTSTATUS DispatchForSCSI(IN PDEVICE_OBJECT fido, IN PIRP Irp)
{
// KdPrint((DRIVERNAME " - Enter DispatchForSCSI \n"));
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fido->DeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
// Pass request down without additional processing
NTSTATUS status;
status = IoAcquireRemoveLock(&pdx->RemoveLock, Irp);
if (!NT_SUCCESS(status))
return CompleteRequest(Irp, status, 0);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine( Irp,
USBSCSICompletion,
NULL,
TRUE,
TRUE,
TRUE );
status = IoCallDriver(pdx->LowerDeviceObject, Irp);
IoReleaseRemoveLock(&pdx->RemoveLock, Irp);
return status;
}
static NTSTATUS
XenStub_SendAndWaitForIrp(PDEVICE_OBJECT device_object, PIRP irp)
{
NTSTATUS status;
PXENSTUB_DEVICE_DATA xsdd = (PXENSTUB_DEVICE_DATA)device_object->DeviceExtension;
KEVENT event;
UNREFERENCED_PARAMETER(device_object);
//KdPrint((__DRIVER_NAME " --> " __FUNCTION__ "\n"));
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(irp);
IoSetCompletionRoutine(irp, XenStub_Pnp_IoCompletion, &event, TRUE, TRUE, TRUE);
status = IoCallDriver(xsdd->lower_do, irp);
if (status == STATUS_PENDING)
{
//KdPrint((__DRIVER_NAME " waiting ...\n"));
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
//KdPrint((__DRIVER_NAME " ... done\n"));
status = irp->IoStatus.Status;
}
//KdPrint((__DRIVER_NAME " <-- " __FUNCTION__"\n"));
return status;
}
NTSTATUS
NTAPI
IntVideoPortForwardIrpAndWait(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
KEVENT Event;
NTSTATUS Status;
PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension =
(PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
IntVideoPortForwardIrpAndWaitCompletionRoutine,
&Event,
TRUE,
TRUE,
TRUE);
Status = IoCallDriver(DeviceExtension->NextDeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
return Status;
}
NTSTATUS LBKFltRead(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION) pDevObj->DeviceExtension;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation( pIrp );
PREADWRITE_IO_CONTEXT Context = NULL;
DbgPrint("LBKFltRead was called \n");
Context = ExAllocatePoolWithTag(NonPagedPool, sizeof(READWRITE_IO_CONTEXT), LBKFLT_TAG_NPAGED);
if(NULL == Context){
DbgPrint("Memory allocation failure for read io context \n");
pIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
Context->liOffset = pIrpStack->Parameters.Read.ByteOffset;
Context->ulLength = pIrpStack->Parameters.Read.Length;
IoCopyCurrentIrpStackLocationToNext(pIrp);
IoSetCompletionRoutine( pIrp,
ReadIoCompletion,
Context,
TRUE,//InvokeOnSuccess
TRUE, // InvokeOnError
TRUE // InvokeOnCancel
);
return IoCallDriver(pDevExt->pTargetDeviceObject, pIrp);
}
NTSTATUS
HidKmdfPowerPassThrough(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
/*++
Routine Description:
Pass through routine for power IRPs .
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
//
// Must start the next power irp before skipping to the next stack location
//
PoStartNextPowerIrp(Irp);
//
// Copy current stack to next instead of skipping. We do this to preserve
// current stack information provided by hidclass driver to the minidriver
//
IoCopyCurrentIrpStackLocationToNext(Irp);
return PoCallDriver(GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
}
/**
* Helper to send a PnP IRP and wait until it's done.
*
* @param pDevObj Device object.
* @param pIrp Request packet.
* @param fStrict When set, returns an error if the IRP gives an error.
* @return NT status code
*/
static NTSTATUS vbgdNtSendIrpSynchronously(PDEVICE_OBJECT pDevObj, PIRP pIrp, BOOLEAN fStrict)
{
KEVENT Event;
KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(pIrp);
IoSetCompletionRoutine(pIrp, (PIO_COMPLETION_ROUTINE)vbgdNtPnpIrpComplete,
&Event, TRUE, TRUE, TRUE);
NTSTATUS rc = IoCallDriver(pDevObj, pIrp);
if (rc == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
rc = pIrp->IoStatus.Status;
}
if (!fStrict
&& (rc == STATUS_NOT_SUPPORTED || rc == STATUS_INVALID_DEVICE_REQUEST))
{
rc = STATUS_SUCCESS;
}
Log(("VBoxGuest::vbgdNtSendIrpSynchronously: Returning 0x%x\n", rc));
return rc;
}
NTSTATUS
ForwardIrpAndWait(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PDEVICE_OBJECT LowerDevice;
KEVENT Event;
NTSTATUS Status;
ASSERT(!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO);
LowerDevice = ((PPORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
TRACE_(CLASS_NAME, "Calling lower device %p\n", LowerDevice);
IoSetCompletionRoutine(Irp, ForwardIrpAndWaitCompletion, &Event, TRUE, TRUE, TRUE);
Status = IoCallDriver(LowerDevice, Irp);
if (Status == STATUS_PENDING)
{
Status = KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
if (NT_SUCCESS(Status))
Status = Irp->IoStatus.Status;
}
return Status;
}
NTSTATUS PPJoyBus_SendIrpSynchronously (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
KEVENT event;
NTSTATUS ntStatus;
PAGED_CODE();
KeInitializeEvent (&event,NotificationEvent,FALSE);
IoCopyCurrentIrpStackLocationToNext (Irp);
/* Set completion routine, to be called when lower driver is done with */
/* this IRP. From this routine we signal the event when done. */
IoSetCompletionRoutine (Irp,PPJoyBus_CompletionRoutine,&event,TRUE,TRUE,TRUE);
/* Call the lower level driver. */
ntStatus= IoCallDriver(DeviceObject,Irp);
/* Wait for the lower drivers to finish with the IRP. */
if (ntStatus == STATUS_PENDING)
{
KeWaitForSingleObject (&event,Executive,KernelMode,FALSE,NULL);
ntStatus= Irp->IoStatus.Status;
}
return ntStatus;
}
NTSTATUS
NTAPI
PcForwardIrpSynchronous(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
KEVENT Event;
PPCLASS_DEVICE_EXTENSION DeviceExt;
NTSTATUS Status;
PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
DeviceExt = (PPCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
// initialize the notification event
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp, CompletionRoutine, (PVOID)&Event, TRUE, TRUE, TRUE);
// now call the driver
Status = IoCallDriver(DeviceExt->PrevDeviceObject, Irp);
// did the request complete yet
if (Status == STATUS_PENDING)
{
// not yet, lets wait a bit
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
return Status;
}
NTSTATUS NTAPI
ForwardIrpAndWait(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
KEVENT Event;
NTSTATUS Status;
PDEVICE_OBJECT LowerDevice = ((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;
ASSERT(LowerDevice);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp, ForwardIrpAndWaitCompletion, &Event, TRUE, TRUE, TRUE);
Status = IoCallDriver(LowerDevice, Irp);
if (Status == STATUS_PENDING)
{
Status = KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
if (NT_SUCCESS(Status))
Status = Irp->IoStatus.Status;
}
return Status;
}
NTSTATUS
ImDiskDeviceControlLowerDevice(PIRP Irp, PDEVICE_EXTENSION DeviceExtension)
{
PIO_STACK_LOCATION io_stack = IoGetCurrentIrpStackLocation(Irp);
PIO_STACK_LOCATION lower_io_stack = IoGetNextIrpStackLocation(Irp);
IoCopyCurrentIrpStackLocationToNext(Irp);
if (io_stack->Parameters.DeviceIoControl.IoControlCode ==
IOCTL_IMDISK_FSCTL_PASS_THROUGH)
{
lower_io_stack->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
}
lower_io_stack->Parameters.DeviceIoControl.IoControlCode =
*(PULONG)Irp->AssociatedIrp.SystemBuffer;
lower_io_stack->Parameters.DeviceIoControl.InputBufferLength -=
sizeof(ULONG);
RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
(PUCHAR)Irp->AssociatedIrp.SystemBuffer + sizeof(ULONG),
lower_io_stack->Parameters.DeviceIoControl.InputBufferLength);
lower_io_stack->FileObject = DeviceExtension->file_object;
return IoCallDriver(DeviceExtension->dev_object, Irp);
}
NTSTATUS
KspForwardIrpSynchronous(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
KEVENT Event;
NTSTATUS Status;
PDEVICE_EXTENSION DeviceExtension;
PKSIDEVICE_HEADER DeviceHeader;
ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
/* get device extension */
DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
/* get device header */
DeviceHeader = DeviceExtension->DeviceHeader;
/* initialize the notification event */
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp, KspForwardIrpSynchronousCompletion, (PVOID)&Event, TRUE, TRUE, TRUE);
/* now call the driver */
Status = IoCallDriver(DeviceHeader->KsDevice.NextDeviceObject, Irp);
/* did the request complete yet */
if (Status == STATUS_PENDING)
{
/* not yet, lets wait a bit */
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
return Status;
}
NTSTATUS
HidUmdfPowerPassThrough(
_In_ PDEVICE_OBJECT DeviceObject,
_Inout_ PIRP Irp
)
/*++
Routine Description:
Pass through routine for power IRPs .
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
PoStartNextPowerIrp(Irp);
IoCopyCurrentIrpStackLocationToNext(Irp);
return PoCallDriver(GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
}
NTSTATUS createcomplete(PDEVICE_OBJECT dev, PIRP irp, PVOID context)
{
UNREFERENCED_PARAMETER(dev);
UNREFERENCED_PARAMETER(irp);
UNREFERENCED_PARAMETER(context);
DbgPrint("enter createcomplete\n");
PIO_STACK_LOCATION sa = IoGetCurrentIrpStackLocation(irp);
PCONTEXTI info = context;
DbgPrint("1\n");
TDI_ADDRESS_INFO *tai = ExAllocatePool(NonPagedPool, sizeof(TDI_ADDRESS_INFO));
DbgPrint("2\n");
PMDL mdl = IoAllocateMdl(tai, sizeof(TDI_ADDRESS_INFO), FALSE, FALSE, info->query_irp);
MmBuildMdlForNonPagedPool(mdl);
info->mdl = mdl;
DbgPrint("3\n");
IoCopyCurrentIrpStackLocationToNext(irp);
TdiBuildQueryInformation(info->query_irp, info->realdev, sa->FileObject, querycom, info, TDI_QUERY_ADDRESS_INFO, mdl);
DbgPrint("4\n");
if (irp->PendingReturned)
{
IoMarkIrpPending(irp);
DbgPrint("pending\n");
}
IoCallDriver(info->realdev, info->query_irp);
DbgPrint("6\n");
IoFreeMdl(info->mdl);
ExFreePool(context);
return STATUS_SUCCESS;
}
static DECLSPEC_NOINLINE NTSTATUS
PdoSurpriseRemoval(
IN PXENFILT_PDO Pdo,
IN PIRP Irp
)
{
NTSTATUS status;
status = IoAcquireRemoveLock(&Pdo->Dx->RemoveLock, Irp);
if (!NT_SUCCESS(status))
goto fail1;
__PdoSetDevicePnpState(Pdo, SurpriseRemovePending);
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
__PdoSurpriseRemoval,
Pdo,
TRUE,
TRUE,
TRUE);
status = IoCallDriver(Pdo->LowerDeviceObject, Irp);
return status;
fail1:
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
NTSTATUS my_ioctl_pop(PDEVICE_OBJECT deviceObject, PIRP Irp) {
NTSTATUS status = STATUS_SUCCESS;
DbgPrint("my_ioctl_pop called\n");
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp, (PIO_COMPLETION_ROUTINE) my_completion_routine, NULL, TRUE, TRUE, TRUE);
device_extension_t* device_extension = (device_extension_t*) deviceObject->DeviceExtension;
status = IoCallDriver(device_extension->next, Irp);
if (status != STATUS_SUCCESS) {
DbgPrint("Error: filtered driver send back an error: 0x%08X\n", status);
goto cleanup;
}
// Remaining actions after the filtered drivers
PCHAR c = (PCHAR) Irp->AssociatedIrp.SystemBuffer;
char old = *c;
if (*c >= 65 && *c <= 65 + 26) {
*c += 32;
DbgPrint("Translate: %d=>%c\n", old, *c);
Irp->IoStatus.Information = 1;
} else {
status = STATUS_UNSUCCESSFUL;
DbgPrint("Error: input is not upper case: %c\n", *c);
}
cleanup:
return status;
}
static NTSTATUS
PdoForwardIrpSynchronously(
IN PXENFILT_PDO Pdo,
IN PIRP Irp
)
{
KEVENT Event;
NTSTATUS status;
ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
__PdoForwardIrpSynchronously,
&Event,
TRUE,
TRUE,
TRUE);
status = IoCallDriver(Pdo->LowerDeviceObject, Irp);
if (status == STATUS_PENDING) {
(VOID) KeWaitForSingleObject(&Event,
Executive,
KernelMode,
FALSE,
NULL);
status = Irp->IoStatus.Status;
} else {
ASSERT3U(status, ==, Irp->IoStatus.Status);
}
return status;
}
static DECLSPEC_NOINLINE NTSTATUS
PdoDispatchDefault(
IN PXENFILT_PDO Pdo,
IN PIRP Irp
)
{
NTSTATUS status;
status = IoAcquireRemoveLock(&Pdo->Dx->RemoveLock, Irp);
if (!NT_SUCCESS(status))
goto fail1;
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
__PdoDispatchDefault,
Pdo,
TRUE,
TRUE,
TRUE);
status = IoCallDriver(Pdo->LowerDeviceObject, Irp);
return status;
fail1:
Error("fail1 (%08x)\n", status);
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
//
// This Irp Forwarding func is interested im what comes back, so it is symchronous and has a cmpletion routine (above)
//
NTSTATUS
FPFilterForwardIrpSynchronous(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PDEVICE_EXTENSION deviceExtension;
KEVENT event;
NTSTATUS status;
KeInitializeEvent(&event, NotificationEvent, FALSE);
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
// copy the irpstack for the next device
IoCopyCurrentIrpStackLocationToNext(Irp);
// set a completion routine
IoSetCompletionRoutine(Irp, FPFilterIrpCompletion, &event, TRUE, TRUE, TRUE);
// FPFilterIrpCOmpletion returns MORE_PROCESSING_REQUIRED
// so the code that calls FPFilterForwardIrpSynchronous needs to call IoCompleteRequest()
// call the next lower device
status = IoCallDriver(deviceExtension->TargetDeviceObject, Irp);
// wait for the actual completion
if (status == STATUS_PENDING)
{
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = Irp->IoStatus.Status;
}
return status;
}
NTSTATUS
Bus_SendIrpSynchronously (
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
/*++
Routine Description:
Sends the Irp down to lower driver and waits for it to
come back by setting a completion routine.
Arguments:
DeviceObject - Pointer to deviceobject
Irp - Pointer to a PnP Irp.
Return Value:
NT Status is returned.
--*/
{
KEVENT event;
NTSTATUS status;
PAGED_CODE();
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp,
Bus_CompletionRoutine,
&event,
TRUE,
TRUE,
TRUE
);
status = IoCallDriver(DeviceObject, Irp);
//
// Wait for lower drivers to be done with the Irp.
// Important thing to note here is when you allocate
// the memory for an event in the stack you must do a
// KernelMode wait instead of UserMode to prevent
// the stack from getting paged out.
//
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&event,
Executive,
KernelMode,
FALSE,
NULL
);
status = Irp->IoStatus.Status;
}
return status;
}
NTSTATUS
t1394_SubmitIrpAsync(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PIRB Irb
)
{
PIO_STACK_LOCATION NextIrpStack;
NTSTATUS ntStatus = STATUS_SUCCESS;
ENTER("t1394_SubmitIrpAsync");
if (Irb) {
NextIrpStack = IoGetNextIrpStackLocation(Irp);
NextIrpStack->Parameters.Others.Argument1 = Irb;
}
else {
IoCopyCurrentIrpStackLocationToNext(Irp);
}
ntStatus = IoCallDriver (DeviceObject, Irp);
return ntStatus;
}
NTSTATUS NTAPI HandleSystemSetPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
{
NTSTATUS ntStatus;
PDEVICE_EXTENSION deviceExtension;
SYSTEM_POWER_STATE systemState;
PIO_STACK_LOCATION irpStack;
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemSetPower: Entered\n"));
deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
irpStack = IoGetCurrentIrpStackLocation(Irp);
systemState = irpStack->Parameters.Power.State.SystemState;
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemSetPower: Set request for system power state S%X\n"
"FBTUSB: HandleSystemSetPower: Current system power state S%X\n",
systemState - 1,
deviceExtension->SysPower - 1));
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(
Irp,
(PIO_COMPLETION_ROUTINE)SysPoCompletionRoutine,
deviceExtension,
TRUE,
TRUE,
TRUE);
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemSetPower: Leaving\n"));
return STATUS_PENDING;
}
NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,
IN PIRP pIrp)
{
KdPrint(("DriverB:Enter B HelloDDKRead\n"));
NTSTATUS ntStatus = STATUS_SUCCESS;
//将自己完成IRP，改成由底层驱动负责
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
//将当前IRP堆栈拷贝底层堆栈
IoCopyCurrentIrpStackLocationToNext(pIrp);
//设置完成例程
IoSetCompletionRoutine(pIrp,MyIoCompletion,NULL,TRUE,TRUE,TRUE);
//调用底层驱动
ntStatus = IoCallDriver(pdx->TargetDevice, pIrp);
//当IoCallDriver后，并且完成例程返回的是STATUS_SUCCESS
//IRP就不在属于派遣函数了，就不能对IRP进行操作了
if (ntStatus == STATUS_PENDING)
{
KdPrint(("STATUS_PENDING\n"));
}
ntStatus = STATUS_PENDING;
KdPrint(("DriverB:Leave B HelloDDKRead\n"));
return ntStatus;
}
static NTSTATUS vboxUsbPnPMnQueryCapabilities(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp)
{
PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp);
PDEVICE_CAPABILITIES pDevCaps = pSl->Parameters.DeviceCapabilities.Capabilities;
if (pDevCaps->Version < 1 || pDevCaps->Size < sizeof (*pDevCaps))
{
Assert(0);
/* todo: return more appropriate status ?? */
return STATUS_UNSUCCESSFUL;
}
pDevCaps->SurpriseRemovalOK = TRUE;
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCopyCurrentIrpStackLocationToNext(pIrp);
NTSTATUS Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp);
Assert(NT_SUCCESS(Status));
if (NT_SUCCESS(Status))
{
pDevCaps->SurpriseRemovalOK = 1;
pDevExt->DdiState.DevCaps = *pDevCaps;
}
VBoxDrvToolIoComplete(pIrp, Status, 0);
vboxUsbDdiStateRelease(pDevExt);
return Status;
}
//----------------------------------------------------------------------------------------------
// SendAndWaitPowerRequest
//----------------------------------------------------------------------------------------------
NTSTATUS SendAndWaitPowerRequest(
IN PDEVICE_OBJECT DeviceObject
,IN PIRP Irp )
{
// 変数宣言
NTSTATUS Status;
KEVENT WaitEvent;
// 下位ドライバに I/O 要求を発行する
KeInitializeEvent( &WaitEvent, NotificationEvent, FALSE );
PoStartNextPowerIrp( Irp );
IoCopyCurrentIrpStackLocationToNext( Irp );
IoSetCompletionRoutine(
Irp
,(PIO_COMPLETION_ROUTINE)IoCompletionRoutine
,(PVOID)&WaitEvent
,TRUE
,TRUE
,TRUE );
#if (NTDDI_VERSION < NTDDI_LONGHORN)
Status = PoCallDriver( GET_NEXT_DEVICE_OBJECT( DeviceObject ), Irp );
#else
Status = IoCallDriver( GET_NEXT_DEVICE_OBJECT( DeviceObject ), Irp );
#endif
// 下位ドライバの処理が完了するまで待機する
if( Status == STATUS_PENDING )
{
KeWaitForSingleObject( &WaitEvent, Executive, KernelMode, FALSE, NULL );
Status = Irp->IoStatus.Status;
}
return( Status );
}
NTSTATUS
HidUmdfPassThrough(
_In_ PDEVICE_OBJECT DeviceObject,
_Inout_ PIRP Irp
)
/*++
Routine Description:
Pass through routine for all the IRPs except power.
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
PIO_STACK_LOCATION irpStack;
irpStack = IoGetCurrentIrpStackLocation(Irp);
IoCopyCurrentIrpStackLocationToNext(Irp);
return IoCallDriver(GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
}
NTSTATUS
HandleSystemSetPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine services irps of minor type IRP_MN_SET_POWER
for the system power state
Arguments:
DeviceObject - pointer to device object
Irp - I/O request packet sent by the power manager
Return Value:
NT status value:
--*/
{
NTSTATUS ntStatus;
PDEVICE_EXTENSION deviceExtension;
SYSTEM_POWER_STATE systemState;
PIO_STACK_LOCATION irpStack;
MobiUsb_DbgPrint(3, ("file mobipwr: HandleSystemSetPower - begins\n"));
//
// initialize variables
//
deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
irpStack = IoGetCurrentIrpStackLocation(Irp);
systemState = irpStack->Parameters.Power.State.SystemState;
MobiUsb_DbgPrint(3, ("file mobipwr: Set request for system power state S%X\n"
"Current system power state S%X\n",
systemState - 1,
deviceExtension->SysPower - 1));
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(
Irp,
(PIO_COMPLETION_ROUTINE)SysPoCompletionRoutine,
deviceExtension,
TRUE,
TRUE,
TRUE);
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
MobiUsb_DbgPrint(3, ("file mobipwr: HandleSystemSetPower - ends\n"));
return STATUS_PENDING;
}
