_UCXHUB_WORKITEM Struct Reference

#include <hostctl.h>

Collaboration diagram for _UCXHUB_WORKITEM:

Public Member Functions
VOID	Free ()
VOID	Enqueue (_In_ PUCXHUB_WORKITEM_ROUTINE NewRoutine, _In_opt_ PVOID NewContext, _In_ UCXHUB_WORKITEM_ENQUEUE_OPTIONS Options)
VOID	Flush ()
VOID	Run ()

Static Public Member Functions
static PUCXHUB_WORKITEM	Allocate (_In_ UcxController *Controller, _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG Flags)

Public Attributes
LIST_ENTRY	ThreadQueueEntry
UcxController *	Controller
PDEVICE_OBJECT	DeviceObject
PIO_WORKITEM	IoWorkItem
PUCXHUB_WORKITEM_ROUTINE	Routine
PVOID	RoutineContext
KSPIN_LOCK	Lock
ULONG	RunningCount
KEVENT	Idle
BOOLEAN	NeedsFlush
BOOLEAN	Queued

Detailed Description

Definition at line 48 of file hostctl.h.

Member Function Documentation

Allocate()

PUCXHUB_WORKITEM UcxWorkItem::Allocate ( _In_ UcxController *  Controller, _In_ PDEVICE_OBJECT  DeviceObject, _In_ ULONG  Flags  )

static

Definition at line 16 of file workitem.cpp.

{
    UcxWorkItem* Item;
 
    Item = (UcxWorkItem*)ExAllocatePoolZero(NonPagedPool, sizeof(*Item), UCX_POOL_TAG);
    if (Item == NULL)
    {
        DPRINT1("Controller %p work item allocation failed\n", Controller);
        return NULL;
    }
 
    Item->IoWorkItem = IoAllocateWorkItem(DeviceObject);
    if (Item->IoWorkItem == NULL)
    {
        DPRINT1("Controller %p IO work item allocation failed for %p\n", Controller, DeviceObject);
        ExFreePoolWithTag(Item, UCX_POOL_TAG);
        return NULL;
    }
 
    Item->Controller = Controller;
    Item->DeviceObject = DeviceObject;
    KeInitializeSpinLock(&Item->Lock);
    KeInitializeEvent(&Item->Idle, NotificationEvent, TRUE);
    Item->NeedsFlush = (Flags & UCXHUB_WORKITEM_FLAG_NEEDS_FLUSH) != 0;
 
    return Item;
}

Referenced by UcxController::Initialize(), and UcxHubWorkItemAllocate().

Enqueue()

VOID UcxWorkItem::Enqueue	(	_In_ PUCXHUB_WORKITEM_ROUTINE	NewRoutine,
		_In_opt_ PVOID	NewContext,
		_In_ UCXHUB_WORKITEM_ENQUEUE_OPTIONS	Options
	)

Definition at line 56 of file workitem.cpp.

{
    BOOLEAN Queued = FALSE;
 
    NT_ASSERT(!this->Queued && Routine == NULL);
 
    Routine = NewRoutine;
    RoutineContext = NewContext;
    this->Queued = TRUE;
 
    if (NeedsFlush)
    {
        SpinLockGuard Guard(&Lock);
 
        RunningCount++;
        KeClearEvent(&Idle);
    }
 
    if (UcxDriver.IoTryQueueWorkItem != NULL)
        Queued = UcxDriver.IoTryQueueWorkItem(IoWorkItem, UcxWorkItemIoRoutine, DelayedWorkQueue, this);
 
    if (Queued)
        return;
 
    /* The worker pool is out of threads; fall back to the controller's own thread */
    if (Options == UcxHubWorkItemForwardProgressNotRequired || !Controller->HasWorkerThread())
    {
        IoQueueWorkItemEx(IoWorkItem, UcxWorkItemIoRoutine, DelayedWorkQueue, this);
    }
    else
    {
        DPRINT("Work item %p sent to controller %p system thread\n", this, Controller);
        Controller->QueueOnWorkerThread(this);
    }
}

Referenced by ControllerResetMachine::QueuePassiveWork().

Flush()

VOID UcxWorkItem::Flush

(

)

Waits until the last queued run finished touching the item.

Definition at line 97 of file workitem.cpp.

{
    PAGED_CODE();
 
    if (!NeedsFlush)
    {
        DPRINT1("Flush on work item %p allocated without flush support\n", this);
        NT_ASSERT(FALSE);
        return;
    }
 
    KeWaitForSingleObject(&Idle, Executive, KernelMode, FALSE, NULL);
 
    /* The runner signals Idle while holding the lock; let it leave */
    SpinLockGuard Guard(&Lock);
}

Referenced by Run().

Free()

VOID UcxWorkItem::Free

(

)

With flush support the caller must have flushed first.

Definition at line 49 of file workitem.cpp.

{
    IoFreeWorkItem(IoWorkItem);
    ExFreePoolWithTag(this, UCX_POOL_TAG);
}

Referenced by UcxController::Destroy().

Run()

VOID UcxWorkItem::Run

(

)

Definition at line 115 of file workitem.cpp.

{
    PUCXHUB_WORKITEM_ROUTINE RunRoutine;
    PDEVICE_OBJECT Object;
    PVOID RunContext;
    BOOLEAN Flush = NeedsFlush;
 
    Queued = FALSE;
    RunRoutine = Routine;
    RunContext = RoutineContext;
    Routine = NULL;
    RoutineContext = NULL;
 
    /* Keeps the owner of the device object loaded across its own callback */
    Object = DeviceObject;
    ObReferenceObject(Object);
    RunRoutine(Object, RunContext, this);
    ObDereferenceObject(Object);
 
    /* Without flush support the routine may already have freed the item */
    if (Flush)
    {
        SpinLockGuard Guard(&Lock);
 
        if (--RunningCount == 0)
            KeSetEvent(&Idle, IO_NO_INCREMENT, FALSE);
    }
}

Member Data Documentation

Controller

UcxController* _UCXHUB_WORKITEM::Controller

Definition at line 51 of file hostctl.h.

Referenced by Allocate().

DeviceObject

PDEVICE_OBJECT _UCXHUB_WORKITEM::DeviceObject

Definition at line 52 of file hostctl.h.

Referenced by Allocate(), and Run().

Idle

KEVENT _UCXHUB_WORKITEM::Idle

Definition at line 58 of file hostctl.h.

Referenced by Enqueue(), Flush(), and Run().

IoWorkItem

PIO_WORKITEM _UCXHUB_WORKITEM::IoWorkItem

Definition at line 53 of file hostctl.h.

Lock

KSPIN_LOCK _UCXHUB_WORKITEM::Lock

Definition at line 56 of file hostctl.h.

NeedsFlush

BOOLEAN _UCXHUB_WORKITEM::NeedsFlush

Definition at line 59 of file hostctl.h.

Referenced by Enqueue(), Flush(), and Run().

Queued

BOOLEAN _UCXHUB_WORKITEM::Queued

Definition at line 60 of file hostctl.h.

Referenced by Enqueue(), and Run().

Routine

PUCXHUB_WORKITEM_ROUTINE _UCXHUB_WORKITEM::Routine

Definition at line 54 of file hostctl.h.

Referenced by Enqueue(), and Run().

RoutineContext

PVOID _UCXHUB_WORKITEM::RoutineContext

Definition at line 55 of file hostctl.h.

Referenced by Enqueue(), and Run().

RunningCount

ULONG _UCXHUB_WORKITEM::RunningCount

Definition at line 57 of file hostctl.h.

Referenced by Enqueue(), and Run().

ThreadQueueEntry

LIST_ENTRY _UCXHUB_WORKITEM::ThreadQueueEntry

Definition at line 50 of file hostctl.h.

---

The documentation for this struct was generated from the following files:

• drivers/usb/ucx01000/hostctl.h
• drivers/usb/ucx01000/workitem.cpp