Run to completion engine. The first thread to post into an idle machine drains the queue; everyone else just enqueues. Handlers, entries and hooks run without the lock held. More...

#include <smengine.h>

Collaboration diagram for SmMachine< Machine, Event >:

[legend]

Public Types
typedef SmState< Machine, Event >	State

Public Member Functions
VOID	SmInitialize (_In_ const State *Initial)

BOOLEAN	SmPost (_In_ Event 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

Protected Member Functions
VOID	SmBeginPause ()

VOID	SmDiscardQueued (_In_ Event Ev)

BOOLEAN	SmAccepts (_In_ Event Ev)

VOID	SmReference ()

VOID	SmDereference ()

VOID	SmQueuePassive ()

VOID	SmOnDequeue (_In_ Event Ev)

VOID	SmStateChanged ()

BOOLEAN	SmCancelTimer ()

Static Protected Member Functions
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_ Event Ev)

Static Protected Attributes
static const BOOLEAN	SmCompletionsFirst = TRUE

static const USHORT	SmTimerEventId = SM_NO_EVENT

Private Member Functions
Machine *	Self ()

const State *	EffectiveState () const

BOOLEAN	IsQueued (_In_ Event Ev) const

BOOLEAN	RemoveQueued (_In_ Event Ev)

BOOLEAN	Dequeue (_Out_ Event *Ev)

VOID	Purge (_In_ const State Entered, _Inout_ KIRQL Irql)

VOID	Trace (_In_ SM_TRACE_KIND Kind, _In_ USHORT Ev)

SM_RESULT	Dispatch (_In_ Event Ev)

BOOLEAN	Run (_In_ KIRQL CallerIrql, _In_ USHORT LastEvent, _In_ SM_RESULT Result, _In_opt_ const State *Entered)
	Applies Result and keeps draining. Called without the lock. Entered is the state whose entry produced Result, if any. Returns TRUE when the machine stopped to wait for passive level or a timer and still owns the reference.

Static Private Member Functions
static BOOLEAN	HasFlag (_In_ const State *Target, _In_ ULONG Flag)

static BOOLEAN	Discards (_In_ const State *Target, _In_ Event Ev)

Private Attributes
KSPIN_LOCK	m_Lock

const State *	m_Frames [SM_MAX_DEPTH]

Event	m_Queue [SM_QUEUE_DEPTH]

UCHAR	m_Depth

UCHAR	m_Count

BOOLEAN	m_Running

BOOLEAN	m_Paused

BOOLEAN	m_WaitingForPassive

BOOLEAN	m_WaitingForTimer

UCHAR	m_TraceIndex

ULONG	m_UnexpectedCount

SM_TRACE	m_Trace [SM_TRACE_DEPTH]

Detailed Description

template<typename Machine, typename Event>
class SmMachine< Machine, Event >

Run to completion engine. The first thread to post into an idle machine drains the queue; everyone else just enqueues. Handlers, entries and hooks run without the lock held.

Machine must provide a static EventInfo[] table indexed by Event. It may hide SmAccepts, SmReference, SmDereference, SmQueuePassive, SmOnDequeue, SmStateChanged, SmCancelTimer, SmCompletionsFirst and SmTimerEventId.

Definition at line 113 of file smengine.h.

Member Typedef Documentation

◆ State

template<typename Machine , typename Event >

typedef SmState<Machine, Event> SmMachine< Machine, Event >::State

Definition at line 116 of file smengine.h.

Member Function Documentation

◆ Dequeue()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::Dequeue ( _Out_ Event * Ev )

private

Definition at line 630 of file smengine.h.

{
    const State* effective = EffectiveState();
    BOOLEAN takesRequests = HasFlag(effective, SM_STATE_TAKES_REQUESTS);
    BOOLEAN criticalOnly = HasFlag(effective, SM_STATE_CRITICAL_ONLY);
    ULONG pass;
    ULONG index;
    ULONG found = SM_QUEUE_DEPTH;
 
    for (pass = 0; (pass < 2) && (found == SM_QUEUE_DEPTH); pass++)
    {
        for (index = 0; index < m_Count; index++)
        {
            SM_EVENT_CLASS eventClass =
                Machine::EventInfo[static_cast<ULONG>(m_Queue[index])].Class;
            BOOLEAN eligible;
 
            if (eventClass == SmEventCritical)
                eligible = TRUE;
            else if (eventClass == SmEventRequest)
                eligible = takesRequests && (!Machine::SmCompletionsFirst || (pass == 1));
            else
                eligible = !criticalOnly;
 
            if (eligible)
            {
                found = index;
                break;
            }
        }
 
        if (!Machine::SmCompletionsFirst)
            break;
    }
 
    if (found == SM_QUEUE_DEPTH)
        return FALSE;
 
    *Ev = m_Queue[found];
    for (index = found + 1; index < m_Count; index++)
        m_Queue[index - 1] = m_Queue[index];
    m_Count--;
    return TRUE;
}

◆ Discards()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::Discards	(	_In_ const State *	Target,
		_In_ Event	Ev
	)

staticprivate

Definition at line 557 of file smengine.h.

{
    const Event* list;
 
    if (Target->Discards == NULL)
        return FALSE;
 
    for (list = Target->Discards; *list != Event::Count; list++)
    {
        if (*list == Ev)
            return TRUE;
    }
 
    return FALSE;
}

◆ Dispatch()

template<typename Machine , typename Event >

SM_RESULT SmMachine< Machine, Event >::Dispatch ( _In_ Event Ev )

private

Definition at line 721 of file smengine.h.

{
    const State* walk;
    SM_RESULT result;
    ULONG frame = m_Depth;
 
    /* Only the draining thread changes the frames, so no lock is needed here */
    for (;;)
    {
        for (walk = m_Frames[frame]; walk != NULL; walk = walk->Parent)
        {
            if (Discards(walk, Ev))
                return SmHandled();
 
            if (walk->Handler == NULL)
                continue;
 
            result = (Self()->*walk->Handler)(Ev);
            if (result.Kind != SmResultUnhandled)
            {
                result.Frame = static_cast<UCHAR>(frame);
                return result;
            }
        }
 
        if (frame == 0)
            break;
 
        frame--;
    }
 
    return SmUnhandled();
}

◆ EffectiveState()

template<typename Machine , typename Event >

const SmMachine< Machine, Event >::State * SmMachine< Machine, Event >::EffectiveState

private

Definition at line 578 of file smengine.h.

{
    ULONG frame = m_Depth;
 
    while ((frame > 0) && HasFlag(m_Frames[frame], SM_STATE_YIELDS_TO_CALLER))
        frame--;
 
    return m_Frames[frame];
}

◆ HasFlag()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::HasFlag	(	_In_ const State *	Target,
		_In_ ULONG	Flag
	)

staticprivate

Definition at line 540 of file smengine.h.

{
    const State* walk;
 
    for (walk = Target; walk != NULL; walk = walk->Parent)
    {
        if (walk->Flags & Flag)
            return TRUE;
    }
 
    return FALSE;
}

◆ IsQueued()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::IsQueued ( _In_ Event Ev ) const

private

Definition at line 590 of file smengine.h.

{
    ULONG index;
 
    for (index = 0; index < m_Count; index++)
    {
        if (m_Queue[index] == Ev)
            return TRUE;
    }
 
    return FALSE;
}

◆ Purge()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::Purge	(	_In_ const State *	Entered,
		_Inout_ KIRQL *	Irql
	)

private

Definition at line 679 of file smengine.h.

{
    const State* walk;
    const Event* list;
 
    for (walk = Entered; walk != NULL; walk = walk->Parent)
    {
        if (walk->Discards == NULL)
            continue;
 
        for (list = walk->Discards; *list != Event::Count; list++)
        {
            if (!RemoveQueued(*list))
                continue;
 
            Trace(SmTraceDiscarded, static_cast<USHORT>(*list));
            KeReleaseSpinLock(&m_Lock, *Irql);
            Self()->SmOnDequeue(*list);
            KeAcquireSpinLock(&m_Lock, Irql);
        }
    }
}

◆ RemoveQueued()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::RemoveQueued ( _In_ Event Ev )

private

Definition at line 606 of file smengine.h.

{
    ULONG read;
    ULONG write = 0;
 
    for (read = 0; read < m_Count; read++)
    {
        if (m_Queue[read] != Ev)
        {
            m_Queue[write] = m_Queue[read];
            write++;
        }
    }
 
    if (write == m_Count)
        return FALSE;
 
    m_Count = static_cast<UCHAR>(write);
    return TRUE;
}

◆ Run()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::Run	(	_In_ KIRQL	CallerIrql,
		_In_ USHORT	LastEvent,
		_In_ SM_RESULT	Result,
		_In_opt_ const State *	Entered
	)

private

Applies Result and keeps draining. Called without the lock. Entered is the state whose entry produced Result, if any. Returns TRUE when the machine stopped to wait for passive level or a timer and still owns the reference.

Definition at line 764 of file smengine.h.

{
    const State* target;
    const State* previous;
    USHORT traced = LastEvent;
    ULONG frame;
    BOOLEAN canceled;
    Event ev;
    KIRQL irql;
 
    for (;;)
    {
        /* Whoever posts the resume event owns the machine now, touch nothing */
        if (Result.Kind == SmResultPaused)
            return FALSE;
 
        KeAcquireSpinLock(&m_Lock, &irql);
 
        if ((Entered != NULL) && (Result.Kind != SmResultCall))
            Purge(Entered, &irql);
        Entered = NULL;
 
        if (Result.Kind == SmResultReturn)
        {
            NT_ASSERTMSG("Return from the outermost frame", m_Depth > 0);
            m_Depth--;
            Trace(SmTraceReturned, Result.Event);
            Purge(SmCurrent(), &irql);
            traced = Result.Event;
            KeReleaseSpinLock(&m_Lock, irql);
            Result = Dispatch(static_cast<Event>(Result.Event));
            continue;
        }
 
        if ((Result.Kind == SmResultTransition) || (Result.Kind == SmResultCall))
        {
            target = static_cast<const State*>(Result.Target);
 
            if (Result.Kind == SmResultCall)
            {
                NT_ASSERTMSG("State machine frames exhausted", m_Depth + 1 < SM_MAX_DEPTH);
                m_Depth++;
                m_Frames[m_Depth] = target;
                Trace(SmTraceCalled, traced);
            }
            else
            {
                frame = (Result.Frame == SM_FRAME_INNERMOST) ? m_Depth : Result.Frame;
                while (m_Depth > frame)
                {
                    if (!HasFlag(m_Frames[m_Depth], SM_STATE_YIELDS_TO_CALLER))
                        SM_BREAK("Caller left a frame that does not yield to it");
                    m_Depth--;
                }
 
                previous = m_Frames[frame];
                m_Frames[frame] = target;
                Trace(SmTraceEntered, traced);
 
                KeReleaseSpinLock(&m_Lock, irql);
                Self()->SmStateChanged();
 
                if (HasFlag(previous, SM_STATE_STOP_TIMER_ON_EXIT) &&
                    (traced != Machine::SmTimerEventId))
                {
                    canceled = Self()->SmCancelTimer();
                    KeAcquireSpinLock(&m_Lock, &irql);
 
                    if (!canceled && !RemoveQueued(static_cast<Event>(Machine::SmTimerEventId)))
                    {
                        m_WaitingForTimer = TRUE;
                        Trace(SmTraceWaitTimer, traced);
                        KeReleaseSpinLock(&m_Lock, irql);
                        return TRUE;
                    }
                }
                else
                {
                    KeAcquireSpinLock(&m_Lock, &irql);
                }
            }
 
            if (HasFlag(target, SM_STATE_NEEDS_PASSIVE) && (CallerIrql > PASSIVE_LEVEL))
            {
                m_WaitingForPassive = TRUE;
                Trace(SmTraceWaitPassive, traced);
                KeReleaseSpinLock(&m_Lock, irql);
                Self()->SmQueuePassive();
                return TRUE;
            }
 
            KeReleaseSpinLock(&m_Lock, irql);
            Entered = target;
            Result = target->Entry ? (Self()->*target->Entry)() : SmHandled();
            continue;
        }
 
        if (Result.Kind == SmResultUnhandled)
        {
            m_UnexpectedCount++;
            Trace(SmTraceUnhandled, traced);
            SM_BREAK("State machine got an event no state handles");
        }
 
        if (!Dequeue(&ev))
        {
            m_Running = FALSE;
            KeReleaseSpinLock(&m_Lock, irql);
            return FALSE;
        }
 
        traced = static_cast<USHORT>(ev);
        Trace(SmTraceDispatched, traced);
        KeReleaseSpinLock(&m_Lock, irql);
 
        Self()->SmOnDequeue(ev);
        Result = Dispatch(ev);
    }
}

◆ Self()

template<typename Machine , typename Event >

Machine * SmMachine< Machine, Event >::Self ( )

inlineprivate

Definition at line 280 of file smengine.h.

    {
        return static_cast<Machine*>(this);
    }

◆ SmAccepts()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::SmAccepts ( _In_ Event Ev )

inlineprotected

Definition at line 236 of file smengine.h.

    {
        UNREFERENCED_PARAMETER(Ev);
        return TRUE;
    }

◆ SmBeginPause()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmBeginPause

protected

Definition at line 510 of file smengine.h.

{
    KIRQL irql;
 
    KeAcquireSpinLock(&m_Lock, &irql);
    m_Paused = TRUE;
    Trace(SmTracePaused, SM_NO_EVENT);
    KeReleaseSpinLock(&m_Lock, irql);
}

◆ SmCall()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmCall ( _In_ const State * Start )

inlinestaticprotected

Definition at line 209 of file smengine.h.

    {
        return SmMakeResult(SmResultCall, SM_NO_EVENT, Start);
    }

◆ SmCancelTimer()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::SmCancelTimer ( )

inlineprotected

Definition at line 273 of file smengine.h.

    {
        return TRUE;
    }

◆ SmContinueOnPassive()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmContinueOnPassive

Definition at line 462 of file smengine.h.

{
    const State* current;
    SM_RESULT result;
    KIRQL irql;
 
    KeAcquireSpinLock(&m_Lock, &irql);
 
    if (!m_WaitingForPassive || !m_Running)
    {
        m_UnexpectedCount++;
        KeReleaseSpinLock(&m_Lock, irql);
        SM_BREAK("Passive continuation without a state waiting for it");
        return;
    }
 
    m_WaitingForPassive = FALSE;
    current = SmCurrent();
    KeReleaseSpinLock(&m_Lock, irql);
 
    /* The reference taken by the drainer that queued the work item carries over */
    result = current->Entry ? (Self()->*current->Entry)() : SmHandled();
    if (!Run(PASSIVE_LEVEL, SM_NO_EVENT, result, current))
        Self()->SmDereference();
}

◆ SmCurrent()

template<typename Machine , typename Event >

const State * SmMachine< Machine, Event >::SmCurrent ( ) const

inline

Definition at line 130 of file smengine.h.

    {
        return m_Frames[m_Depth];
    }

◆ SmDepth()

template<typename Machine , typename Event >

ULONG SmMachine< Machine, Event >::SmDepth ( ) const

inline

Definition at line 136 of file smengine.h.

    {
        return m_Depth;
    }

◆ SmDereference()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmDereference ( )

inlineprotected

Definition at line 249 of file smengine.h.

250 {

251 }

◆ SmDiscardQueued()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmDiscardQueued ( _In_ Event Ev )

protected

Definition at line 522 of file smengine.h.

{
    BOOLEAN removed;
    KIRQL irql;
 
    KeAcquireSpinLock(&m_Lock, &irql);
    removed = RemoveQueued(Ev);
    if (removed)
        Trace(SmTraceDiscarded, static_cast<USHORT>(Ev));
    KeReleaseSpinLock(&m_Lock, irql);
 
    if (removed)
        Self()->SmOnDequeue(Ev);
}

◆ SmFrame()

template<typename Machine , typename Event >

const State * SmMachine< Machine, Event >::SmFrame ( _In_ ULONG Index ) const

inline

Definition at line 142 of file smengine.h.

    {
        return m_Frames[Index];
    }

◆ SmHandled()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmHandled ( )

inlinestaticprotected

Definition at line 182 of file smengine.h.

    {
        return SmMakeResult(SmResultHandled, SM_NO_EVENT, NULL);
    }

◆ SmInitialize()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmInitialize ( _In_ const State * Initial )

Definition at line 349 of file smengine.h.

{
    NT_ASSERT(Initial->Entry == NULL);
 
    KeInitializeSpinLock(&m_Lock);
    m_Frames[0] = Initial;
    m_Depth = 0;
    m_Count = 0;
    m_Running = FALSE;
    m_Paused = FALSE;
    m_WaitingForPassive = FALSE;
    m_WaitingForTimer = FALSE;
    m_TraceIndex = 0;
    m_UnexpectedCount = 0;
    RtlZeroMemory(m_Trace, sizeof(m_Trace));
    Trace(SmTraceEntered, SM_NO_EVENT);
}

◆ SmIsIn()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::SmIsIn ( _In_ const State * Ancestor ) const

Definition at line 490 of file smengine.h.

{
    const State* walk;
    ULONG frame;
 
    for (frame = 0; frame <= m_Depth; frame++)
    {
        for (walk = m_Frames[frame]; walk != NULL; walk = walk->Parent)
        {
            if (walk == Ancestor)
                return TRUE;
        }
    }
 
    return FALSE;
}

◆ SmIsPaused()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::SmIsPaused ( ) const

inline

Definition at line 153 of file smengine.h.

    {
        return m_Paused;
    }

◆ SmIsWaitingForTimer()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::SmIsWaitingForTimer ( ) const

inline

Definition at line 159 of file smengine.h.

    {
        return m_WaitingForTimer;
    }

◆ SmMakeResult()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmMakeResult	(	_In_ SM_RESULT_KIND	Kind,
		_In_ USHORT	Ev,
		_In_opt_ const VOID *	Target
	)

inlinestaticprotected

Definition at line 172 of file smengine.h.

    {
        SM_RESULT result = { static_cast<UCHAR>(Kind), SM_FRAME_INNERMOST, Ev, Target };
        return result;
    }

Referenced by SmMachine< Machine, Event >::SmCall(), SmMachine< Machine, Event >::SmHandled(), SmMachine< Machine, Event >::SmPaused(), SmMachine< Machine, Event >::SmReturn(), SmMachine< Machine, Event >::SmTransition(), and SmMachine< Machine, Event >::SmUnhandled().

◆ SmOnDequeue()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmOnDequeue ( _In_ Event Ev )

inlineprotected

Definition at line 260 of file smengine.h.

    {
        UNREFERENCED_PARAMETER(Ev);
    }

◆ SmPaused()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmPaused ( )

inlinestaticprotected

Definition at line 202 of file smengine.h.

    {
        return SmMakeResult(SmResultPaused, SM_NO_EVENT, NULL);
    }

◆ SmPost()

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::SmPost ( _In_ Event Ev )

Definition at line 370 of file smengine.h.

{
    const SM_EVENT_INFO* info = &Machine::EventInfo[static_cast<ULONG>(Ev)];
    const State* current;
    SM_RESULT result;
    KIRQL irql;
 
    KeAcquireSpinLock(&m_Lock, &irql);
 
    if (!Self()->SmAccepts(Ev) || (info->Coalesce && IsQueued(Ev)))
    {
        Trace(SmTraceRejected, static_cast<USHORT>(Ev));
        KeReleaseSpinLock(&m_Lock, irql);
        return FALSE;
    }
 
    Trace(SmTracePosted, static_cast<USHORT>(Ev));
 
    if (info->Replace && RemoveQueued(Ev))
    {
        KeReleaseSpinLock(&m_Lock, irql);
        Self()->SmOnDequeue(Ev);
        KeAcquireSpinLock(&m_Lock, &irql);
    }
 
    if (info->Class == SmEventResume)
    {
        if (!m_Paused || !m_Running)
        {
            m_UnexpectedCount++;
            Trace(SmTraceUnhandled, static_cast<USHORT>(Ev));
            KeReleaseSpinLock(&m_Lock, irql);
            SM_BREAK("Resume event posted to a machine that is not paused");
            return TRUE;
        }
 
        /* The paused drainer already left, this thread takes over */
        m_Paused = FALSE;
        Trace(SmTraceResumed, static_cast<USHORT>(Ev));
        KeReleaseSpinLock(&m_Lock, irql);
 
        Self()->SmReference();
        result = Dispatch(Ev);
        if (!Run(irql, static_cast<USHORT>(Ev), result, NULL))
            Self()->SmDereference();
        return TRUE;
    }
 
    if (m_WaitingForTimer)
    {
        /* The drainer stopped after entering a state, the entry runs once the timer is done */
        if (static_cast<USHORT>(Ev) != Machine::SmTimerEventId)
        {
            NT_ASSERTMSG("State machine queue overflow", m_Count < SM_QUEUE_DEPTH);
            m_Queue[m_Count] = Ev;
            m_Count++;
            KeReleaseSpinLock(&m_Lock, irql);
            return TRUE;
        }
 
        m_WaitingForTimer = FALSE;
        current = SmCurrent();
        KeReleaseSpinLock(&m_Lock, irql);
 
        result = current->Entry ? (Self()->*current->Entry)() : SmHandled();
        if (!Run(irql, static_cast<USHORT>(Ev), result, current))
            Self()->SmDereference();
        return TRUE;
    }
 
    NT_ASSERTMSG("State machine queue overflow", m_Count < SM_QUEUE_DEPTH);
    m_Queue[m_Count] = Ev;
    m_Count++;
 
    if (m_Running)
    {
        KeReleaseSpinLock(&m_Lock, irql);
        return TRUE;
    }
 
    m_Running = TRUE;
    KeReleaseSpinLock(&m_Lock, irql);
 
    Self()->SmReference();
    if (!Run(irql, static_cast<USHORT>(Ev), SmHandled(), NULL))
        Self()->SmDereference();
    return TRUE;
}

◆ SmQueuePassive()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmQueuePassive ( )

inlineprotected

Definition at line 254 of file smengine.h.

    {
        SM_BREAK("State needs passive level but the machine has no work item");
    }

◆ SmReference()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmReference ( )

inlineprotected

Definition at line 244 of file smengine.h.

245 {

246 }

◆ SmReturn()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmReturn ( _In_ Event Ev )

inlinestaticprotected

Definition at line 217 of file smengine.h.

    {
        return SmMakeResult(SmResultReturn, static_cast<USHORT>(Ev), NULL);
    }

◆ SmStateChanged()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::SmStateChanged ( )

inlineprotected

Definition at line 267 of file smengine.h.

268 {

269 }

◆ SmTransition()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmTransition ( _In_ const State * Target )

inlinestaticprotected

Definition at line 194 of file smengine.h.

    {
        return SmMakeResult(SmResultTransition, SM_NO_EVENT, Target);
    }

◆ SmUnexpectedCount()

template<typename Machine , typename Event >

ULONG SmMachine< Machine, Event >::SmUnexpectedCount ( ) const

inline

Definition at line 165 of file smengine.h.

    {
        return m_UnexpectedCount;
    }

◆ SmUnhandled()

template<typename Machine , typename Event >

static SM_RESULT SmMachine< Machine, Event >::SmUnhandled ( )

inlinestaticprotected

Definition at line 188 of file smengine.h.

    {
        return SmMakeResult(SmResultUnhandled, SM_NO_EVENT, NULL);
    }

◆ Trace()

template<typename Machine , typename Event >

VOID SmMachine< Machine, Event >::Trace	(	_In_ SM_TRACE_KIND	Kind,
		_In_ USHORT	Ev
	)

private

Definition at line 706 of file smengine.h.

{
    PSM_TRACE entry = &m_Trace[m_TraceIndex];
 
    entry->State = SmCurrent()->Name;
    entry->Event = Ev;
    entry->Kind = static_cast<UCHAR>(Kind);
    entry->Depth = m_Depth;
    m_TraceIndex = (m_TraceIndex + 1) & SM_TRACE_MASK;
}

Member Data Documentation

◆ m_Count

template<typename Machine , typename Event >

UCHAR SmMachine< Machine, Event >::m_Count

private

Definition at line 335 of file smengine.h.

◆ m_Depth

template<typename Machine , typename Event >

UCHAR SmMachine< Machine, Event >::m_Depth

private

Definition at line 334 of file smengine.h.

Referenced by SmMachine< Machine, Event >::SmCurrent(), and SmMachine< Machine, Event >::SmDepth().

◆ m_Frames

template<typename Machine , typename Event >

const State* SmMachine< Machine, Event >::m_Frames[SM_MAX_DEPTH]

private

Definition at line 332 of file smengine.h.

Referenced by SmMachine< Machine, Event >::SmCurrent(), and SmMachine< Machine, Event >::SmFrame().

◆ m_Lock

template<typename Machine , typename Event >

KSPIN_LOCK SmMachine< Machine, Event >::m_Lock

private

Definition at line 331 of file smengine.h.

◆ m_Paused

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::m_Paused

private

Definition at line 337 of file smengine.h.

Referenced by SmMachine< Machine, Event >::SmIsPaused().

◆ m_Queue

template<typename Machine , typename Event >

Event SmMachine< Machine, Event >::m_Queue[SM_QUEUE_DEPTH]

private

Definition at line 333 of file smengine.h.

◆ m_Running

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::m_Running

private

Definition at line 336 of file smengine.h.

◆ m_Trace

template<typename Machine , typename Event >

SM_TRACE SmMachine< Machine, Event >::m_Trace[SM_TRACE_DEPTH]

private

Definition at line 342 of file smengine.h.

◆ m_TraceIndex

template<typename Machine , typename Event >

UCHAR SmMachine< Machine, Event >::m_TraceIndex

private

Definition at line 340 of file smengine.h.

◆ m_UnexpectedCount

template<typename Machine , typename Event >

ULONG SmMachine< Machine, Event >::m_UnexpectedCount

private

Definition at line 341 of file smengine.h.

Referenced by SmMachine< Machine, Event >::SmUnexpectedCount().

◆ m_WaitingForPassive

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::m_WaitingForPassive

private

Definition at line 338 of file smengine.h.

◆ m_WaitingForTimer

template<typename Machine , typename Event >

BOOLEAN SmMachine< Machine, Event >::m_WaitingForTimer

private

Definition at line 339 of file smengine.h.

Referenced by SmMachine< Machine, Event >::SmIsWaitingForTimer().

◆ SmCompletionsFirst

template<typename Machine , typename Event >

const BOOLEAN SmMachine< Machine, Event >::SmCompletionsFirst = TRUE

staticprotected

Definition at line 232 of file smengine.h.

◆ SmTimerEventId

template<typename Machine , typename Event >

const USHORT SmMachine< Machine, Event >::SmTimerEventId = SM_NO_EVENT

staticprotected

Definition at line 233 of file smengine.h.

The documentation for this class was generated from the following file:

sdk/include/reactos/drivers/usb3/smengine.h

Public Types

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ State

Member Function Documentation

◆ Dequeue()

◆ Discards()

◆ Dispatch()

◆ EffectiveState()

◆ HasFlag()

◆ IsQueued()

◆ Purge()

◆ RemoveQueued()

◆ Run()

◆ Self()

◆ SmAccepts()

◆ SmBeginPause()

◆ SmCall()

◆ SmCancelTimer()

◆ SmContinueOnPassive()

◆ SmCurrent()

◆ SmDepth()

◆ SmDereference()

◆ SmDiscardQueued()

◆ SmFrame()

◆ SmHandled()

◆ SmInitialize()

◆ SmIsIn()

◆ SmIsPaused()

◆ SmIsWaitingForTimer()

◆ SmMakeResult()

◆ SmOnDequeue()

◆ SmPaused()

◆ SmPost()

◆ SmQueuePassive()

◆ SmReference()

◆ SmReturn()

◆ SmStateChanged()

◆ SmTransition()

◆ SmUnexpectedCount()

◆ SmUnhandled()

◆ Trace()

Member Data Documentation

◆ m_Count

◆ m_Depth

◆ m_Frames

◆ m_Lock

◆ m_Paused

◆ m_Queue

◆ m_Running

◆ m_Trace

◆ m_TraceIndex

◆ m_UnexpectedCount

◆ m_WaitingForPassive

◆ m_WaitingForTimer

◆ SmCompletionsFirst

◆ SmTimerEventId