clientxrb.cpp File Reference

#include "ucx01000.h"
#include <debug.h>

Include dependency graph for clientxrb.cpp:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	UCX_REQUEST_REUSE_MUST_COMPLETE   0x00000002

Functions
NTSTATUS NTAPI	UcxCompleteUrb (_In_ PIRP Irp, _In_ PURB Urb, _In_ NTSTATUS Status, _In_ USBD_STATUS UsbdStatus)
VOID NTAPI	UcxCompleteUrbAtDispatch (_In_ PIRP Irp, _In_ PURB Urb, _In_ NTSTATUS Status, _In_ USBD_STATUS UsbdStatus)
VOID NTAPI	UcxCompleteHeldUrbIrp (_In_ PIRP Irp)
static VOID NTAPI	UcxXrbCheckOnSubmit (_In_ PIRP Irp, _In_ PURB Urb)
static NTSTATUS NTAPI	UcxXrbSubmitTransfer (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp, _In_ PURB Urb)
static NTSTATUS NTAPI	UcxXrbSubmitChainedMdlTransfer (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp, _In_ PURB Urb)
NTSTATUS NTAPI	UcxProcessSubmitUrb (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp)
NTSTATUS NTAPI	UcxForwardStreamsUrb (_In_ WDFDEVICE RootHubPdo, _In_ PIRP Irp, _In_ PURB Urb, _In_ UcxController *Controller)
static VOID NTAPI	UcxXrbFixUnprocessed (_Inout_ PIRP Irp, _Inout_ PURB Urb, _In_ UcxUsbDevice *Device)
static NTSTATUS NTAPI	UcxXrbTransferCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)
static NTSTATUS NTAPI	UcxXrbStreamsCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)

Variables
static IO_COMPLETION_ROUTINE	UcxXrbTransferCompletion
static IO_COMPLETION_ROUTINE	UcxXrbStreamsCompletion

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 10 of file clientxrb.cpp.

UCX_REQUEST_REUSE_MUST_COMPLETE

#define UCX_REQUEST_REUSE_MUST_COMPLETE   0x00000002

Definition at line 14 of file clientxrb.cpp.

Function Documentation

UcxCompleteHeldUrbIrp()

VOID NTAPI UcxCompleteHeldUrbIrp

(

_In_ PIRP

Irp

)

Completes an IRP held after STATUS_MORE_PROCESSING_REQUIRED, statuses as they are.

Definition at line 61 of file clientxrb.cpp.

{
    PURB Urb = (PURB)IoGetCurrentIrpStackLocation(Irp)->Parameters.Others.Argument1;
 
    if (UcxIsXrbIrp(Irp, Urb))
        UcxXrbMarkInactive(Urb);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by EndpointMachine::FinishStreamsCloseRequest(), EndpointMachine::FinishStreamsOpenRequest(), and UcxEndpoint::OpenStaticStreamsComplete().

UcxCompleteUrb()

NTSTATUS NTAPI UcxCompleteUrb	(	_In_ PIRP	Irp,
		_In_ PURB	Urb,
		_In_ NTSTATUS	Status,
		_In_ USBD_STATUS	UsbdStatus
	)

Sets both statuses and completes at the current IRQL; returns Status.

Definition at line 23 of file clientxrb.cpp.

{
    if (UcxIsXrbIrp(Irp, Urb))
        UcxXrbMarkInactive(Urb);
 
    Urb->UrbHeader.Status = UsbdStatus;
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by UcxEndpoint::AbortPipe(), UcxEndpoint::CloseStaticStreams(), UcxEndpoint::GetIsochPathDelays(), UcxCompleteUrbAtDispatch(), UcxFailStreamsUrb(), UcxHandleGetCurrentFrame(), UcxHandleIsoch(), UcxHandleStandardRequest(), UcxProcessLegacyUrb(), and UcxXrbSubmitChainedMdlTransfer().

UcxCompleteUrbAtDispatch()

VOID NTAPI UcxCompleteUrbAtDispatch	(	_In_ PIRP	Irp,
		_In_ PURB	Urb,
		_In_ NTSTATUS	Status,
		_In_ USBD_STATUS	UsbdStatus
	)

Same, but plain URBs complete at DISPATCH_LEVEL as they did under USBPORT.

Definition at line 42 of file clientxrb.cpp.

{
    if (UcxIsXrbIrp(Irp, Urb))
    {
        UcxCompleteUrb(Irp, Urb, Status, UsbdStatus);
        return;
    }
 
    DispatchLevelGuard Raise;
    UcxCompleteUrb(Irp, Urb, Status, UsbdStatus);
}

Referenced by EndpointMachine::CompleteAbortUrb(), and UcxCsqCompleteCanceledAbortIrp().

UcxForwardStreamsUrb()

NTSTATUS NTAPI UcxForwardStreamsUrb	(	_In_ WDFDEVICE	RootHubPdo,
		_In_ PIRP	Irp,
		_In_ PURB	Urb,
		_In_ UcxController *	Controller
	)

Definition at line 212 of file clientxrb.cpp.

{
    Urb->UrbHeader.Status = USBD_STATUS_PENDING;
 
    return UcxForwardIrpToQueue(RootHubPdo, Irp, UcxXrbStreamsCompletion, Urb, Controller->m_DeviceMgmtQueue);
}

Referenced by UcxEndpoint::CloseStaticStreams(), and UcxEndpoint::OpenStaticStreams().

UcxProcessSubmitUrb()

NTSTATUS NTAPI UcxProcessSubmitUrb	(	_In_ WDFDEVICE	RootHubPdo,
		_In_ PIRP	Irp
	)

Definition at line 169 of file clientxrb.cpp.

{
    PURB Urb = (PURB)IoGetCurrentIrpStackLocation(Irp)->Parameters.Others.Argument1;
 
    if (!UcxIsXrbIrp(Irp, Urb))
        return UcxProcessLegacyUrb(RootHubPdo, Irp, Urb);
 
    UcxXrbCheckOnSubmit(Irp, Urb);
 
    /* Older contracts take the legacy path; its completions reset the state */
    if (UcxXrbFromUrb(Urb)->ContractVersion < USBD_CLIENT_CONTRACT_VERSION_602)
        return UcxProcessLegacyUrb(RootHubPdo, Irp, Urb);
 
    switch (Urb->UrbHeader.Function)
    {
        case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
        case URB_FUNCTION_ISOCH_TRANSFER:
            return UcxXrbSubmitTransfer(RootHubPdo, Irp, Urb);
 
        case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER_USING_CHAINED_MDL:
        case URB_FUNCTION_ISOCH_TRANSFER_USING_CHAINED_MDL:
            return UcxXrbSubmitChainedMdlTransfer(RootHubPdo, Irp, Urb);
 
        case URB_FUNCTION_OPEN_STATIC_STREAMS:
            return UcxEndpoint::FromPipe(Urb->UrbOpenStaticStreams.PipeHandle)->OpenStaticStreams(Irp, Urb);
 
        /* The pipe handle sits at the same offset in both stream URBs */
        case URB_FUNCTION_CLOSE_STATIC_STREAMS:
            return UcxEndpoint::FromPipe(Urb->UrbOpenStaticStreams.PipeHandle)->CloseStaticStreams(Irp, Urb);
 
        /* Only XRBs reach this; a plain URB with this function is invalid */
        case URB_FUNCTION_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS:
            return UcxEndpoint::FromPipe(Urb->UrbGetIsochPipeTransferPathDelays.PipeHandle)->GetIsochPathDelays(Irp, Urb);
 
        default:
            return UcxProcessLegacyUrb(RootHubPdo, Irp, Urb);
    }
}

Referenced by UcxEvtRootHubPreprocessInternalIoctl().

UcxXrbCheckOnSubmit()

static VOID NTAPI UcxXrbCheckOnSubmit ( _In_ PIRP  Irp, _In_ PURB  Urb  )

static

Bugchecks a client that corrupted its XRB or submitted one that is still in flight.

Definition at line 78 of file clientxrb.cpp.

{
    UcxXrbPreamble* Xrb = UcxXrbFromUrb(Urb);
 
    if (Xrb->Signature != UCX_XRB_SIGNATURE)
    {
        DPRINT1("IRP %p submitted corrupted XRB for URB %p\n", Irp, Urb);
        KeBugCheckEx(UCX_BUGCHECK_USB3,
                     UCX_USB3_XRB_CORRUPTED,
                     (ULONG_PTR)Irp,
                     (ULONG_PTR)Urb,
                     (ULONG_PTR)Xrb->Handle->m_ClientDeviceObject);
    }
 
    if (Xrb->State != UCX_XRB_IDLE)
    {
        DPRINT1("IRP %p resubmitted URB %p while it is still active\n", Irp, Urb);
        KeBugCheckEx(UCX_BUGCHECK_USB3,
                     UCX_USB3_ACTIVE_URB_REUSED,
                     (ULONG_PTR)Irp,
                     (ULONG_PTR)Urb,
                     (ULONG_PTR)Xrb->Handle->m_ClientDeviceObject);
    }
 
    Xrb->State = UCX_XRB_IN_FLIGHT;
}

Referenced by UcxProcessSubmitUrb().

UcxXrbFixUnprocessed()

static VOID NTAPI UcxXrbFixUnprocessed ( _Inout_ PIRP  Irp, _Inout_ PURB  Urb, _In_ UcxUsbDevice *  Device  )

static

Normalizes a URB the HCD never saw.

Definition at line 229 of file clientxrb.cpp.

{
    if (Device->m_Disconnected)
    {
        Urb->UrbHeader.Status = USBD_STATUS_DEVICE_GONE;
        Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
    }
    else
    {
        Urb->UrbHeader.Status = USBD_STATUS_CANCELED;
    }
}

Referenced by UcxXrbStreamsCompletion(), and UcxXrbTransferCompletion().

UcxXrbStreamsCompletion()

static NTSTATUS NTAPI UcxXrbStreamsCompletion ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID  Context  )

static

Definition at line 299 of file clientxrb.cpp.

{
    PURB Urb = (PURB)Context;
    UcxUsbDevice* Device = UcxUsbDevice::FromHandle((UCXUSBDEVICE)Urb->UrbHeader.UsbdDeviceHandle);
    UcxEndpoint* Endpoint;
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    if (Urb->UrbHeader.Status == USBD_STATUS_PENDING)
    {
        DPRINT1("Streams URB %p function 0x%x never reached the HCD\n", Urb, Urb->UrbHeader.Function);
        UcxXrbFixUnprocessed(Irp, Urb, Device);
    }
    else
    {
        if (!USBD_SUCCESS(Urb->UrbHeader.Status))
        {
            DPRINT1("Streams URB %p function 0x%x failed, USBD status 0x%lx\n",
                    Urb, Urb->UrbHeader.Function, Urb->UrbHeader.Status);
        }
 
        Irp->IoStatus.Status = UcxUsbdStatusToNtStatus(Urb->UrbHeader.Status);
    }
 
    if (Irp->PendingReturned)
        IoMarkIrpPending(Irp);
 
    Endpoint = UcxEndpoint::FromPipe(Urb->UrbOpenStaticStreams.PipeHandle);
 
    switch (Urb->UrbHeader.Function)
    {
        case URB_FUNCTION_OPEN_STATIC_STREAMS:
            return Endpoint->OpenStaticStreamsComplete(Irp, Urb);
 
        case URB_FUNCTION_CLOSE_STATIC_STREAMS:
            return Endpoint->CloseStaticStreamsComplete(Irp);
 
        default:
            UcxXrbMarkInactive(Urb);
            return STATUS_CONTINUE_COMPLETION;
    }
}

UcxXrbSubmitChainedMdlTransfer()

static NTSTATUS NTAPI UcxXrbSubmitChainedMdlTransfer ( _In_ WDFDEVICE  RootHubPdo, _In_ PIRP  Irp, _In_ PURB  Urb  )

static

Definition at line 141 of file clientxrb.cpp.

{
    UcxUsbdHandle* Handle = UcxXrbFromUrb(Urb)->Handle;
 
    if (!Handle->m_ChainedMdlGranted)
    {
        DPRINT1("Chained MDL URB %p from handle %p without the capability\n", Urb, Handle);
 
        if (Handle->m_VerifierEnabled)
        {
            KeBugCheckEx(UCX_BUGCHECK_USB3,
                         UCX_USB3_CHAINED_MDL,
                         (ULONG_PTR)Irp,
                         (ULONG_PTR)Urb,
                         (ULONG_PTR)Handle->m_ClientDeviceObject);
        }
 
        return UcxCompleteUrb(Irp, Urb, STATUS_INVALID_PARAMETER, USBD_STATUS_INVALID_PARAMETER);
    }
 
    return UcxXrbSubmitTransfer(RootHubPdo, Irp, Urb);
}

Referenced by UcxProcessSubmitUrb().

UcxXrbSubmitTransfer()

static NTSTATUS NTAPI UcxXrbSubmitTransfer ( _In_ WDFDEVICE  RootHubPdo, _In_ PIRP  Irp, _In_ PURB  Urb  )

static

Definition at line 111 of file clientxrb.cpp.

{
    UcxXrbPreamble* Xrb = UcxXrbFromUrb(Urb);
    UcxPipe* Pipe;
    WDF_REQUEST_REUSE_PARAMS Reuse;
 
    Urb->UrbHeader.Status = USBD_STATUS_PENDING;
 
    Pipe = UcxPipe::FromHandle(Urb->UrbBulkOrInterruptTransfer.PipeHandle);
    UcxSetTransferDirection(Urb, Pipe);
    UcxStampProcessorNumber(Urb);
    UcxLockTransferBuffer(Urb);
 
    if (Xrb->Request == NULL)
        return UcxForwardIrpToQueue(RootHubPdo, Irp, UcxXrbTransferCompletion, Urb, Pipe->Queue);
 
    /* The preallocated request saves a KMDF allocation per transfer */
    WDF_REQUEST_REUSE_PARAMS_INIT(&Reuse, WDF_REQUEST_REUSE_SET_NEW_IRP | UCX_REQUEST_REUSE_MUST_COMPLETE, STATUS_SUCCESS);
    WDF_REQUEST_REUSE_PARAMS_SET_NEW_IRP(&Reuse, Irp);
    WdfRequestReuse(Xrb->Request, &Reuse);
 
    return UcxForwardIrpWithRequest(RootHubPdo, Irp, UcxXrbTransferCompletion, Urb, Pipe->Queue, Xrb->Request);
}

Referenced by UcxProcessSubmitUrb(), and UcxXrbSubmitChainedMdlTransfer().

UcxXrbTransferCompletion()

static NTSTATUS NTAPI UcxXrbTransferCompletion ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID  Context  )

static

Definition at line 248 of file clientxrb.cpp.

{
    PURB Urb = (PURB)Context;
    UcxUsbDevice* Device = UcxUsbDevice::FromHandle((UCXUSBDEVICE)Urb->UrbHeader.UsbdDeviceHandle);
    ULONG Index;
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    if (Urb->UrbHeader.Status == USBD_STATUS_PENDING)
    {
        DPRINT("XRB URB %p function 0x%x canceled before reaching the HCD\n", Urb, Urb->UrbHeader.Function);
        Device->m_TransferFailureCount++;
        Urb->UrbBulkOrInterruptTransfer.TransferBufferLength = 0;
        UcxXrbFixUnprocessed(Irp, Urb, Device);
 
        /* Only the plain isoch function; the chained MDL one keeps its packets */
        if (!Device->m_Disconnected && Urb->UrbHeader.Function == URB_FUNCTION_ISOCH_TRANSFER)
        {
            for (Index = 0; Index < Urb->UrbIsochronousTransfer.NumberOfPackets; Index++)
                Urb->UrbIsochronousTransfer.IsoPacket[Index].Status = 0xFFFFFFFF;
            Urb->UrbIsochronousTransfer.ErrorCount = 0;
        }
    }
    else
    {
        if (!USBD_SUCCESS(Urb->UrbHeader.Status))
        {
            DPRINT("XRB URB %p function 0x%x on device %p failed, USBD status 0x%lx\n",
                   Urb, Urb->UrbHeader.Function, Device, Urb->UrbHeader.Status);
            Device->m_TransferFailureCount++;
            Device->ReportNoPingResponseIfPending();
        }
 
        /* The URB status always wins on this path */
        Irp->IoStatus.Status = UcxUsbdStatusToNtStatus(Urb->UrbHeader.Status);
    }
 
    if (Irp->PendingReturned)
        IoMarkIrpPending(Irp);
 
    UcxUnlockTransferBuffer(Urb);
    UcxXrbMarkInactive(Urb);
    return STATUS_CONTINUE_COMPLETION;
}

Variable Documentation

UcxXrbStreamsCompletion

IO_COMPLETION_ROUTINE UcxXrbStreamsCompletion

static

Definition at line 17 of file clientxrb.cpp.

Referenced by UcxForwardStreamsUrb().

UcxXrbTransferCompletion

IO_COMPLETION_ROUTINE UcxXrbTransferCompletion

static

Definition at line 16 of file clientxrb.cpp.

Referenced by UcxXrbSubmitTransfer().