Posts run to completion under m_PostLock; IRP completion and callbacks run after it is dropped. More...

#include <idlesm.h>

Inheritance diagram for IdleMachine:

Collaboration diagram for IdleMachine:

[legend]

Public Member Functions
VOID	Initialize (_In_ HubPdo *Pdo)

NTSTATUS	Post (_In_ IdleEvent Event, _In_opt_ PIRP Irp)
	Irp is the new idle IRP for RequestSubmitted, else NULL.

HubPdo *	Pdo () const

PIRP	HeldIrp () const

Public Member Functions inherited from SmMachine< IdleMachine, IdleEvent >
VOID	SmInitialize (_In_ const State *Initial)

BOOLEAN	SmPost (_In_ IdleEvent Ev)

VOID	SmContinueOnPassive ()

const State *	SmCurrent () const

ULONG	SmDepth () const

const State *	SmFrame (_In_ ULONG Index) const

BOOLEAN	SmIsIn (_In_ const State *Ancestor) const

BOOLEAN	SmIsPaused () const

BOOLEAN	SmIsWaitingForTimer () const

ULONG	SmUnexpectedCount () const

Static Public Attributes
static const SM_EVENT_INFO	EventInfo []

Private Types
enum	IDLE_FOLLOW_UP { FollowUpNone , FollowUpCompleteHeld , FollowUpRejectNew , FollowUpCallback , FollowUpWorkItem }

enum	IDLE_POWER_CHANGE { PowerUnchanged , PowerUp , PowerDown }

Private Member Functions
SM_RESULT	OnStarting (_In_ IdleEvent Event)

SM_RESULT	OnPresent (_In_ IdleEvent Event)

SM_RESULT	OnNoRequest (_In_ IdleEvent Event)

SM_RESULT	OnReady (_In_ IdleEvent Event)

SM_RESULT	OnSuspendUnsupported (_In_ IdleEvent Event)

SM_RESULT	OnParked (_In_ IdleEvent Event)

SM_RESULT	OnHolding (_In_ IdleEvent Event)

SM_RESULT	OnPending (_In_ IdleEvent Event)

SM_RESULT	OnAwaitingWorkItem (_In_ IdleEvent Event)

SM_RESULT	OnCallbackRunning (_In_ IdleEvent Event)

SM_RESULT	OnAwaitingCancel (_In_ IdleEvent Event)

SM_RESULT	OnRemoved (_In_ IdleEvent Event)

SM_RESULT	OnCallbackRemoved (_In_ IdleEvent Event)

SM_RESULT	OnAwaitingCancelRemoved (_In_ IdleEvent Event)

VOID	FinishHeld (_In_ NTSTATUS Status)

VOID	RejectNew (_In_ NTSTATUS Status)

VOID	HoldNew ()

SM_RESULT	Release (_In_ NTSTATUS Status)

SM_RESULT	ReleaseForRemoval ()

SM_RESULT	EndCallback ()

BOOLEAN	SelectiveSuspendSupported ()

VOID	MarkRequestPending (_In_ PIRP Irp)

BOOLEAN	ArmCancel (_In_ PIRP Irp)

BOOLEAN	DisarmCancel (_In_ PIRP Irp)

VOID	QueueIdleWorkItem ()

VOID	InvokeIdleCallback (_In_ PIRP Irp)

VOID	CompleteIdleRequest (_In_ PIRP Irp, _In_ NTSTATUS Status)

Private Attributes
KSPIN_LOCK	m_PostLock

HubPdo *	m_Pdo

PIRP	m_HeldIrp

PIRP	m_NewIrp

NTSTATUS	m_FollowUpStatus

IDLE_FOLLOW_UP	m_FollowUp

IDLE_POWER_CHANGE	m_PowerChange

BOOLEAN	m_ReturnPending

BOOLEAN	m_SuspendSupported

BOOLEAN	m_CancelSeen

Static Private Attributes
static const State	Starting

static const State	Present

static const State	NoRequest

static const State	Ready

static const State	SuspendUnsupported

static const State	Parked

static const State	Holding

static const State	Pending

static const State	AwaitingWorkItem

static const State	CallbackDone

static const State	CallbackRunning

static const State	AwaitingCancel

static const State	Removed

static const State	Gone

static const State	CallbackRemoved

static const State	AwaitingCancelRemoved

Friends
class	SmMachine< IdleMachine, IdleEvent >

Additional Inherited Members
Public Types inherited from SmMachine< IdleMachine, IdleEvent >
typedef SmState< IdleMachine, IdleEvent >	State

Protected Member Functions inherited from SmMachine< IdleMachine, IdleEvent >
VOID	SmBeginPause ()

VOID	SmDiscardQueued (_In_ IdleEvent Ev)

BOOLEAN	SmAccepts (_In_ IdleEvent Ev)

VOID	SmReference ()

VOID	SmDereference ()

VOID	SmQueuePassive ()

VOID	SmOnDequeue (_In_ IdleEvent Ev)

VOID	SmStateChanged ()

BOOLEAN	SmCancelTimer ()

Static Protected Member Functions inherited from SmMachine< IdleMachine, IdleEvent >
static SM_RESULT	SmMakeResult (_In_ SM_RESULT_KIND Kind, _In_ USHORT Ev, _In_opt_ const VOID *Target)

static SM_RESULT	SmHandled ()

static SM_RESULT	SmUnhandled ()

static SM_RESULT	SmTransition (_In_ const State *Target)

static SM_RESULT	SmPaused ()

static SM_RESULT	SmCall (_In_ const State *Start)

static SM_RESULT	SmReturn (_In_ IdleEvent Ev)

Static Protected Attributes inherited from SmMachine< IdleMachine, IdleEvent >
static const BOOLEAN	SmCompletionsFirst

static const USHORT	SmTimerEventId

Detailed Description

Posts run to completion under m_PostLock; IRP completion and callbacks run after it is dropped.

Definition at line 43 of file idlesm.h.

Member Enumeration Documentation

◆ IDLE_FOLLOW_UP

enum IdleMachine::IDLE_FOLLOW_UP

private

Enumerator
FollowUpNone
FollowUpCompleteHeld
FollowUpRejectNew
FollowUpCallback
FollowUpWorkItem

Definition at line 73 of file idlesm.h.

    {
        FollowUpNone,
        FollowUpCompleteHeld,
        FollowUpRejectNew,
        FollowUpCallback,
        FollowUpWorkItem
    };

◆ IDLE_POWER_CHANGE

enum IdleMachine::IDLE_POWER_CHANGE

private

Enumerator
PowerUnchanged
PowerUp
PowerDown

Definition at line 82 of file idlesm.h.

    {
        PowerUnchanged,
        PowerUp,
        PowerDown
    };

Member Function Documentation

◆ ArmCancel()

BOOLEAN IdleMachine::ArmCancel ( _In_ PIRP Irp )

private

Definition at line 108 of file suspend.cpp.

{
    IoSetCancelRoutine(Irp, HubIdleCancel);
 
    if (!Irp->Cancel)
        return TRUE;
 
    /* NULL here means the cancel routine already owns it and will post */
    if (IoSetCancelRoutine(Irp, NULL) == NULL)
        return TRUE;
 
    DPRINT("Idle IRP %p was canceled before it was held\n", Irp);
    return FALSE;
}

Referenced by OnReady(), and OnSuspendUnsupported().

◆ CompleteIdleRequest()

VOID IdleMachine::CompleteIdleRequest	(	_In_ PIRP	Irp,
		_In_ NTSTATUS	Status
	)

private

Definition at line 152 of file suspend.cpp.

{
    if (NT_SUCCESS(Status) || Status == STATUS_CANCELLED || Status == STATUS_POWER_STATE_INVALID)
        DPRINT("Idle IRP %p on port %u completed 0x%lx\n", Irp, m_Pdo->m_PortNumber, Status);
    else
        DPRINT1("Idle IRP %p on port %u failed 0x%lx\n", Irp, m_Pdo->m_PortNumber, Status);
 
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by Post().

◆ DisarmCancel()

BOOLEAN IdleMachine::DisarmCancel ( _In_ PIRP Irp )

private

Definition at line 126 of file suspend.cpp.

{
    return IoSetCancelRoutine(Irp, NULL) != NULL;
}

Referenced by Release(), and ReleaseForRemoval().

◆ EndCallback()

SM_RESULT IdleMachine::EndCallback ( )

private

Definition at line 220 of file idlesm.cpp.

{
    NTSTATUS status;
 
    if (m_PowerChange == PowerUp)
        status = STATUS_SUCCESS;
    else if (m_PowerChange == PowerDown)
        status = STATUS_POWER_STATE_INVALID;
    else
        status = STATUS_CANCELLED;
 
    if (m_CancelSeen)
    {
        FinishHeld(status);
        return SmTransition(&Ready);
    }
 
    if (m_PowerChange == PowerUnchanged)
        return SmTransition(&CallbackDone);
 
    return Release(status);
}

Referenced by OnCallbackRunning().

◆ FinishHeld()

VOID IdleMachine::FinishHeld ( _In_ NTSTATUS Status )

private

Definition at line 171 of file idlesm.cpp.

{
    m_FollowUp = FollowUpCompleteHeld;
    m_FollowUpStatus = Status;
}

Referenced by EndCallback(), OnAwaitingCancel(), OnAwaitingCancelRemoved(), OnParked(), OnPending(), OnReady(), OnSuspendUnsupported(), Release(), and ReleaseForRemoval().

◆ HeldIrp()

PIRP IdleMachine::HeldIrp ( ) const

inline

Definition at line 65 of file idlesm.h.

    {
        return m_HeldIrp;
    }

◆ HoldNew()

VOID IdleMachine::HoldNew ( )

private

Definition at line 188 of file idlesm.cpp.

{
    NT_ASSERT(m_HeldIrp == NULL);
 
    m_HeldIrp = m_NewIrp;
    MarkRequestPending(m_HeldIrp);
}

Referenced by OnReady(), and OnSuspendUnsupported().

◆ Initialize()

VOID IdleMachine::Initialize ( _In_ HubPdo * Pdo )

Definition at line 87 of file idlesm.cpp.

{
    KeInitializeSpinLock(&m_PostLock);
    m_Pdo = Pdo;
    m_HeldIrp = NULL;
    m_NewIrp = NULL;
    m_FollowUpStatus = STATUS_PENDING;
    m_FollowUp = FollowUpNone;
    m_PowerChange = PowerUnchanged;
    m_ReturnPending = FALSE;
    m_SuspendSupported = FALSE;
    m_CancelSeen = FALSE;
 
    SmInitialize(&Starting);
}

◆ InvokeIdleCallback()

VOID IdleMachine::InvokeIdleCallback ( _In_ PIRP Irp )

private

Definition at line 140 of file suspend.cpp.

{
    PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
    PUSB_IDLE_CALLBACK_INFO Info = (PUSB_IDLE_CALLBACK_INFO)Stack->Parameters.DeviceIoControl.Type3InputBuffer;
 
    DPRINT("Calling idle callback of port %u\n", m_Pdo->m_PortNumber);
    Info->IdleCallback(Info->IdleContext);
}

Referenced by Post().

◆ MarkRequestPending()

VOID IdleMachine::MarkRequestPending ( _In_ PIRP Irp )

private

Definition at line 100 of file suspend.cpp.

{
    IoMarkIrpPending(Irp);
}

Referenced by HoldNew().

◆ OnAwaitingCancel()

SM_RESULT IdleMachine::OnAwaitingCancel ( _In_ IdleEvent Event )

private

Definition at line 426 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::RequestCanceled:
            FinishHeld(STATUS_CANCELLED);
            return SmTransition(&Ready);
 
        case IdleEvent::Cleanup:
            return SmTransition(&AwaitingCancelRemoved);
 
        default:
            return SmUnhandled();
    }
}

◆ OnAwaitingCancelRemoved()

SM_RESULT IdleMachine::OnAwaitingCancelRemoved ( _In_ IdleEvent Event )

private

Definition at line 474 of file idlesm.cpp.

{
    if (Event != IdleEvent::RequestCanceled)
        return SmUnhandled();
 
    FinishHeld(STATUS_NO_SUCH_DEVICE);
    return SmTransition(&Gone);
}

◆ OnAwaitingWorkItem()

SM_RESULT IdleMachine::OnAwaitingWorkItem ( _In_ IdleEvent Event )

private

Definition at line 382 of file idlesm.cpp.

{
    if (Event != IdleEvent::WorkItemRan)
        return SmUnhandled();
 
    m_PowerChange = PowerUnchanged;
    m_CancelSeen = FALSE;
    m_FollowUp = FollowUpCallback;
    return SmTransition(&CallbackRunning);
}

◆ OnCallbackRemoved()

SM_RESULT IdleMachine::OnCallbackRemoved ( _In_ IdleEvent Event )

private

Definition at line 464 of file idlesm.cpp.

{
    if (Event == IdleEvent::ClientCallbackFinished)
        return SmTransition(&Gone);
 
    return SmUnhandled();
}

◆ OnCallbackRunning()

SM_RESULT IdleMachine::OnCallbackRunning ( _In_ IdleEvent Event )

private

Definition at line 395 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::ClientCallbackFinished:
            return EndCallback();
 
        case IdleEvent::PoweredUp:
        case IdleEvent::PoweringDown:
            if (m_PowerChange == PowerUnchanged && !m_CancelSeen)
                m_PowerChange = (Event == IdleEvent::PoweredUp) ? PowerUp : PowerDown;
            return SmHandled();
 
        case IdleEvent::RequestCanceled:
            /* A second cancel is not expected */
            if (m_CancelSeen)
                return SmUnhandled();
 
            m_CancelSeen = TRUE;
            return SmHandled();
 
        case IdleEvent::Cleanup:
            return SmTransition(&CallbackRemoved);
 
        default:
            return SmUnhandled();
    }
}

◆ OnHolding()

SM_RESULT IdleMachine::OnHolding ( _In_ IdleEvent Event )

private

Definition at line 340 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::RequestSubmitted:
            RejectNew(STATUS_DEVICE_BUSY);
            return SmHandled();
 
        case IdleEvent::WorkItemRan:
            return SmHandled();
 
        default:
            return SmUnhandled();
    }
}

◆ OnNoRequest()

SM_RESULT IdleMachine::OnNoRequest ( _In_ IdleEvent Event )

private

Definition at line 265 of file idlesm.cpp.

{
    if (Event == IdleEvent::Cleanup)
        return SmTransition(&Gone);
 
    return SmUnhandled();
}

◆ OnParked()

SM_RESULT IdleMachine::OnParked ( _In_ IdleEvent Event )

private

Definition at line 318 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::RequestSubmitted:
            RejectNew(STATUS_DEVICE_BUSY);
            return SmHandled();
 
        case IdleEvent::RequestCanceled:
            FinishHeld(STATUS_CANCELLED);
            return SmTransition(&SuspendUnsupported);
 
        case IdleEvent::Cleanup:
            return ReleaseForRemoval();
 
        default:
            return SmUnhandled();
    }
}

◆ OnPending()

SM_RESULT IdleMachine::OnPending ( _In_ IdleEvent Event )

private

Definition at line 358 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::RequestCanceled:
            FinishHeld(STATUS_CANCELLED);
            return SmTransition(&Ready);
 
        case IdleEvent::PoweredUp:
            return Release(STATUS_SUCCESS);
 
        case IdleEvent::PoweringDown:
            return Release(STATUS_POWER_STATE_INVALID);
 
        case IdleEvent::Cleanup:
            return ReleaseForRemoval();
 
        default:
            return SmUnhandled();
    }
}

◆ OnPresent()

SM_RESULT IdleMachine::OnPresent ( _In_ IdleEvent Event )

private

Definition at line 255 of file idlesm.cpp.

{
    if (Event == IdleEvent::PoweredUp || Event == IdleEvent::PoweringDown)
        return SmHandled();
 
    return SmUnhandled();
}

◆ OnReady()

SM_RESULT IdleMachine::OnReady ( _In_ IdleEvent Event )

private

Definition at line 275 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::RequestSubmitted:
            HoldNew();
            if (ArmCancel(m_HeldIrp))
            {
                m_FollowUp = FollowUpWorkItem;
                return SmTransition(&AwaitingWorkItem);
            }
 
            /* Already canceled; the IRP was marked pending, so return pending */
            FinishHeld(STATUS_CANCELLED);
            m_ReturnPending = TRUE;
            return SmHandled();
 
        case IdleEvent::RequestCanceled:
        case IdleEvent::WorkItemRan:
            return SmHandled();
 
        default:
            return SmUnhandled();
    }
}

◆ OnRemoved()

SM_RESULT IdleMachine::OnRemoved ( _In_ IdleEvent Event )

private

Definition at line 444 of file idlesm.cpp.

{
    switch (Event)
    {
        case IdleEvent::RequestSubmitted:
            RejectNew(STATUS_NO_SUCH_DEVICE);
            return SmHandled();
 
        case IdleEvent::RequestCanceled:
        case IdleEvent::WorkItemRan:
            return SmHandled();
 
        default:
            return SmUnhandled();
    }
}

◆ OnStarting()

SM_RESULT IdleMachine::OnStarting ( _In_ IdleEvent Event )

private

Definition at line 244 of file idlesm.cpp.

{
    if (Event != IdleEvent::Start)
        return SmUnhandled();
 
    m_SuspendSupported = SelectiveSuspendSupported();
    return SmTransition(m_SuspendSupported ? &Ready : &SuspendUnsupported);
}

◆ OnSuspendUnsupported()

SM_RESULT IdleMachine::OnSuspendUnsupported ( _In_ IdleEvent Event )

private

Definition at line 303 of file idlesm.cpp.

{
    if (Event != IdleEvent::RequestSubmitted)
        return SmUnhandled();
 
    HoldNew();
    if (ArmCancel(m_HeldIrp))
        return SmTransition(&Parked);
 
    FinishHeld(STATUS_CANCELLED);
    return SmHandled();
}

◆ Pdo()

HubPdo * IdleMachine::Pdo ( ) const

inline

Definition at line 58 of file idlesm.h.

    {
        return m_Pdo;
    }

Referenced by Initialize().

◆ Post()

NTSTATUS IdleMachine::Post	(	_In_ IdleEvent	Event,
		_In_opt_ PIRP	Irp
	)

Irp is the new idle IRP for RequestSubmitted, else NULL.

Returns: STATUS_PENDING, or the status the IRP of this post was completed with.

Definition at line 112 of file idlesm.cpp.

{
    IDLE_FOLLOW_UP followUp;
    PIRP finished = NULL;
    PIRP callbackIrp = NULL;
    NTSTATUS status;
    BOOLEAN MustPend;
    KIRQL irql;
 
    KeAcquireSpinLock(&m_PostLock, &irql);
 
    m_NewIrp = Irp;
    m_FollowUp = FollowUpNone;
    m_FollowUpStatus = STATUS_PENDING;
    m_ReturnPending = FALSE;
 
    SmPost(Event);
 
    followUp = m_FollowUp;
    status = m_FollowUpStatus;
    MustPend = m_ReturnPending;
 
    if (followUp == FollowUpCompleteHeld)
    {
        finished = m_HeldIrp;
        m_HeldIrp = NULL;
    }
    else if (followUp == FollowUpRejectNew)
    {
        finished = Irp;
    }
    else if (followUp == FollowUpCallback)
    {
        callbackIrp = m_HeldIrp;
    }
 
    m_NewIrp = NULL;
    KeReleaseSpinLock(&m_PostLock, irql);
 
    if (followUp == FollowUpCallback)
    {
        InvokeIdleCallback(callbackIrp);
        Post(IdleEvent::ClientCallbackFinished, NULL);
    }
    else if (followUp == FollowUpWorkItem)
    {
        QueueIdleWorkItem();
    }
 
    if (finished != NULL)
        CompleteIdleRequest(finished, status);
 
    return MustPend ? STATUS_PENDING : status;
}

Referenced by Post().

◆ QueueIdleWorkItem()

VOID IdleMachine::QueueIdleWorkItem ( )

private

Definition at line 134 of file suspend.cpp.

{
    WdfWorkItemEnqueue(m_Pdo->m_IdleWorkItem);
}

Referenced by Post().

◆ RejectNew()

VOID IdleMachine::RejectNew ( _In_ NTSTATUS Status )

private

Definition at line 180 of file idlesm.cpp.

{
    m_FollowUp = FollowUpRejectNew;
    m_FollowUpStatus = Status;
}

Referenced by OnHolding(), OnParked(), and OnRemoved().

◆ Release()

SM_RESULT IdleMachine::Release ( _In_ NTSTATUS Status )

private

Definition at line 198 of file idlesm.cpp.

{
    if (!DisarmCancel(m_HeldIrp))
        return SmTransition(&AwaitingCancel);
 
    FinishHeld(Status);
    return SmTransition(&Ready);
}

◆ ReleaseForRemoval()

SM_RESULT IdleMachine::ReleaseForRemoval ( )

private

Definition at line 209 of file idlesm.cpp.

{
    if (!DisarmCancel(m_HeldIrp))
        return SmTransition(&AwaitingCancelRemoved);
 
    FinishHeld(STATUS_NO_SUCH_DEVICE);
    return SmTransition(&Gone);
}

Referenced by OnParked(), and OnPending().

◆ SelectiveSuspendSupported()

BOOLEAN IdleMachine::SelectiveSuspendSupported ( )

private

Definition at line 88 of file suspend.cpp.

{
    if (m_Pdo->m_Hub->HasFlag(HubFlag::ParentNoSelectiveSuspend))
    {
        DPRINT("Port %u: parent stack has no selective suspend\n", m_Pdo->m_PortNumber);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by OnStarting().

Friends And Related Function Documentation

◆ SmMachine< IdleMachine, IdleEvent >

friend class SmMachine< IdleMachine, IdleEvent >

friend

Definition at line 1 of file idlesm.h.

Member Data Documentation

◆ AwaitingCancel

const IdleMachine::State IdleMachine::AwaitingCancel

staticprivate

Initial value:

=

{ &Holding, "AwaitingCancel", 0, &IdleMachine::OnAwaitingCancel, NULL }

IdleMachine::Holding

static const State Holding

Definition: idlesm.h:96

IdleMachine::OnAwaitingCancel

SM_RESULT OnAwaitingCancel(_In_ IdleEvent Event)

Definition: idlesm.cpp:426

Definition at line 101 of file idlesm.h.

Referenced by Release().

◆ AwaitingCancelRemoved

const IdleMachine::State IdleMachine::AwaitingCancelRemoved

staticprivate

Initial value:

=

{ &Removed, "AwaitingCancelRemoved", 0, &IdleMachine::OnAwaitingCancelRemoved, NULL }

IdleMachine::OnAwaitingCancelRemoved

SM_RESULT OnAwaitingCancelRemoved(_In_ IdleEvent Event)

Definition: idlesm.cpp:474

IdleMachine::Removed

static const State Removed

Definition: idlesm.h:102

Definition at line 105 of file idlesm.h.

Referenced by OnAwaitingCancel(), and ReleaseForRemoval().

◆ AwaitingWorkItem

const IdleMachine::State IdleMachine::AwaitingWorkItem

staticprivate

Initial value:

=

{ &Pending, "AwaitingWorkItem", 0, &IdleMachine::OnAwaitingWorkItem, NULL }

IdleMachine::Pending

static const State Pending

Definition: idlesm.h:97

IdleMachine::OnAwaitingWorkItem

SM_RESULT OnAwaitingWorkItem(_In_ IdleEvent Event)

Definition: idlesm.cpp:382

Definition at line 98 of file idlesm.h.

Referenced by OnReady().

◆ CallbackDone

const IdleMachine::State IdleMachine::CallbackDone

staticprivate

Initial value:

=

{ &Pending, "CallbackDone", 0, NULL, NULL }

Definition at line 99 of file idlesm.h.

Referenced by EndCallback().

◆ CallbackRemoved

const IdleMachine::State IdleMachine::CallbackRemoved

staticprivate

Initial value:

=

{ &Removed, "CallbackRemoved", 0, &IdleMachine::OnCallbackRemoved, NULL }

IdleMachine::OnCallbackRemoved

SM_RESULT OnCallbackRemoved(_In_ IdleEvent Event)

Definition: idlesm.cpp:464

Definition at line 104 of file idlesm.h.

Referenced by OnCallbackRunning().

◆ CallbackRunning

const IdleMachine::State IdleMachine::CallbackRunning

staticprivate

Initial value:

=

{ &Holding, "CallbackRunning", 0, &IdleMachine::OnCallbackRunning, NULL }

IdleMachine::OnCallbackRunning

SM_RESULT OnCallbackRunning(_In_ IdleEvent Event)

Definition: idlesm.cpp:395

Definition at line 100 of file idlesm.h.

Referenced by OnAwaitingWorkItem().

◆ EventInfo

const SM_EVENT_INFO IdleMachine::EventInfo

static

Initial value:

=
{
    { "Start",              SmEventCompletion, FALSE },
    { "RequestSubmitted",   SmEventCompletion, FALSE },
    { "RequestCanceled",    SmEventCompletion, FALSE },
    { "WorkItemRan",        SmEventCompletion, FALSE },
    { "ClientCallbackFinished",   SmEventCompletion, FALSE },
    { "PoweredUp",          SmEventCompletion, FALSE },
    { "PoweringDown",       SmEventCompletion, FALSE },
    { "Cleanup",            SmEventCompletion, FALSE },
}