windows-xp/Source/XPSP1/NT/base/busdrv/acpi/driver/amlinew/sched.c

/*** sched.c - AML thread scheduler
 *
 *  Copyright (c) 1996,1998 Microsoft Corporation
 *  Author:     Michael Tsang (MikeTs)
 *  Created     03/04/98
 *
 *  MODIFICATION HISTORY
 */

#include "pch.h"

#ifdef  LOCKABLE_PRAGMA
#pragma ACPI_LOCKABLE_DATA
#pragma ACPI_LOCKABLE_CODE
#endif

/***LP  ExpireTimeSlice - DPC callback for time slice expiration
 *
 *  ENTRY
 *      pkdpc -> DPC
 *      pctxtq -> CTXTQ
 *      SysArg1 - not used
 *      SysArg2 - not used
 *
 *  EXIT
 *      None
 */

VOID ExpireTimeSlice(PKDPC pkdpc, PCTXTQ pctxtq, PVOID SysArg1, PVOID SysArg2)
{
    TRACENAME("EXPIRETIMESLICE")

    ENTER(2, ("ExpireTimeSlice(pkdpc=%x,pctxtq=%x,SysArg1=%x,SysArg2=%x\n",
              pkdpc, pctxtq, SysArg1, SysArg2));

    DEREF(pkdpc);
    DEREF(SysArg1);
    DEREF(SysArg2);

    pctxtq->dwfCtxtQ |= CQF_TIMESLICE_EXPIRED;

    EXIT(2, ("ExpireTimeSlice!\n"));
}       //ExpireTimeSlice

/***LP  StartTimeSlice - Timer callback to start a new time slice
 *
 *  ENTRY
 *      pkdpc -> DPC
 *      pctxtq -> CTXTQ
 *      SysArg1 - not used
 *      SysArg2 - not used
 *
 *  EXIT
 *      None
 */

VOID StartTimeSlice(PKDPC pkdpc, PCTXTQ pctxtq, PVOID SysArg1, PVOID SysArg2)
{
    TRACENAME("STARTTIMESLICE")

    ENTER(2, ("StartTimeSlice(pkdpc=%x,pctxtq=%x,SysArg1=%x,SysArg2=%x\n",
              pkdpc, pctxtq, SysArg1, SysArg2));

    DEREF(pkdpc);
    DEREF(SysArg1);
    DEREF(SysArg2);

    //
    // If somebody has restarted the queue, we don't have do anything.
    //
    ASSERT(pctxtq->plistCtxtQ != NULL);

    if ((pctxtq->plistCtxtQ != NULL) &&
        !(pctxtq->dwfCtxtQ & CQF_WORKITEM_SCHEDULED))
    {
        OSQueueWorkItem(&pctxtq->WorkItem);
        pctxtq->dwfCtxtQ |= CQF_WORKITEM_SCHEDULED;
    }

    EXIT(2, ("StartTimeSlice!\n"));
}       //StartTimeSlice

/***LP  StartTimeSlicePassive - Start a time slice at PASSIVE_LEVEL
 *
 *  ENTRY
 *      pctxtq -> CTXTQ
 *
 *  EXIT
 *      None
 */

VOID StartTimeSlicePassive(PCTXTQ pctxtq)
{
    TRACENAME("STARTTIMESLICEPASSIVE")

    ENTER(2, ("StartTimeSlicePassive(pctxtq=%x)\n", pctxtq));

    AcquireMutex(&pctxtq->mutCtxtQ);

    pctxtq->dwfCtxtQ &= ~CQF_WORKITEM_SCHEDULED;
    //
    // Make sure there is something in the queue and no current active context.
    //
    if ((pctxtq->plistCtxtQ != NULL) && (pctxtq->pkthCurrent == NULL) &&
        !(pctxtq->dwfCtxtQ & CQF_PAUSED))
    {
        DispatchCtxtQueue(pctxtq);
    }

    ReleaseMutex(&pctxtq->mutCtxtQ);

    EXIT(2, ("StartTimeSlicePassive!\n"));
}       //StartTimeSlicePassive

/***LP  DispatchCtxtQueue - Dispatch context from ready queue
 *
 *  ENTRY
 *      pctxtq -> CTXTQ
 *
 *  EXIT
 *      None
 *
 *  Note
 *      The caller must acquire CtxtQ mutex before entering this routine.
 */

VOID LOCAL DispatchCtxtQueue(PCTXTQ pctxtq)
{
    TRACENAME("DISPATCHCTXTQUEUE")
    LARGE_INTEGER liTimeout;
    PLIST plist;
    PCTXT pctxt;

    ENTER(2, ("DispatchCtxtQueue(pctxtq=%x)\n", pctxtq));

    ASSERT((pctxtq->plistCtxtQ != NULL) && (pctxtq->pkthCurrent == NULL));

    liTimeout.QuadPart = (INT_PTR)(-10000*(INT_PTR)pctxtq->dwmsTimeSliceLength);
    pctxtq->dwfCtxtQ &= ~CQF_TIMESLICE_EXPIRED;
    KeSetTimer(&pctxtq->Timer, liTimeout, &pctxtq->DpcExpireTimeSlice);

    while ((plist = ListRemoveHead(&pctxtq->plistCtxtQ)) != NULL)
    {
        pctxt = CONTAINING_RECORD(plist, CTXT, listQueue);

        ASSERT(pctxt->pplistCtxtQueue == &pctxtq->plistCtxtQ);

        pctxt->pplistCtxtQueue = NULL;
        pctxt->dwfCtxt &= ~CTXTF_IN_READYQ;
        RunContext(pctxt);
    }

    if (pctxtq->plistCtxtQ == NULL)
    {
        KeCancelTimer(&pctxtq->Timer);
        pctxtq->dwfCtxtQ &= ~CQF_TIMESLICE_EXPIRED;
    }
    else if (!(pctxtq->dwfCtxtQ & CQF_WORKITEM_SCHEDULED))
    {
        //
        // Our time slice has expired, reschedule another time slice if not
        // already done so.
        //
        liTimeout.QuadPart = (INT_PTR)(-10000*(INT_PTR)pctxtq->dwmsTimeSliceInterval);
        KeSetTimer(&pctxtq->Timer, liTimeout, &pctxtq->DpcStartTimeSlice);
    }

    EXIT(2, ("DispatchCtxtQueue!\n"));
}       //DispatchCtxtQueue

/***LP  InsertReadyQueue - Insert the context into the ready queue
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      fDelayExecute - queue the request, don't execute now
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 *
 *  NOTE
 *      The caller must acquire the CtxtQ mutex before entering this
 *      routine and release it after exiting this routine.
 */

NTSTATUS LOCAL InsertReadyQueue(PCTXT pctxt, BOOLEAN fDelayExecute)
{
    TRACENAME("INSERTREADYQUEUE")
    NTSTATUS rc = STATUS_SUCCESS;

    ENTER(2, ("InsertReadyQueue(pctxt=%x,fDelayExecute=%x)\n",
              pctxt, fDelayExecute));

    CHKDEBUGGERREQ();

    //
    // Make sure we do have the spin lock.
    //
    LOGSCHEDEVENT('INSQ', (ULONG_PTR)pctxt, (ULONG_PTR)
                  (pctxt->pnctxt? pctxt->pnctxt->pnsObj: pctxt->pnsObj),
                  (ULONG_PTR)pctxt->pbOp);
    //
    // If there is a pending timer, cancel it.
    //
    if (pctxt->dwfCtxt & CTXTF_TIMER_PENDING)
    {
        BOOLEAN fTimerCancelled;

        pctxt->dwfCtxt &= ~CTXTF_TIMER_PENDING;
        fTimerCancelled = KeCancelTimer(&pctxt->Timer);

        //
        // If the timer could not be cancelled (already queued), wait
        // for it to fire and dispatch the context from there.  The
        // pending timer is referring to this context and we can not
        // have it completed with the timer outstanding.  Plus this
        // also interlocked to setting of timers and timeout processing
        // to ensure that a timeout is not mistakenly performed on
        // the next timer.
        //
        if (!fTimerCancelled)
        {
            pctxt->dwfCtxt |= CTXTF_TIMER_DISPATCH;
        }
    }
    //
    // Make this context ready.
    //
    pctxt->dwfCtxt |= CTXTF_READY;

    //
    // If this context is already running, we are done; otherwise, process it.
    //
    if (!(pctxt->dwfCtxt & CTXTF_TIMER_DISPATCH) &&
        (!(pctxt->dwfCtxt & CTXTF_RUNNING) ||
         (pctxt->dwfCtxt & CTXTF_NEST_EVAL)))
    {
        if (fDelayExecute)
        {
            //
            // This context is from a completion callback of current context,
            // we need to unblock/restart current context.
            //
            ReleaseMutex(&gReadyQueue.mutCtxtQ);
            AsyncCallBack(pctxt, AMLISTA_CONTINUE);
            AcquireMutex(&gReadyQueue.mutCtxtQ);
        }
        else if ((pctxt->dwfCtxt & CTXTF_NEST_EVAL) &&
                 (gReadyQueue.pkthCurrent == KeGetCurrentThread()))
        {
            LOGSCHEDEVENT('NEST', (ULONG_PTR)pctxt, (ULONG_PTR)
                          (pctxt->pnctxt? pctxt->pnctxt->pnsObj: pctxt->pnsObj),
                          (ULONG_PTR)pctxt->pbOp);
            //
            // Somebody is running a new method on the callout of the current
            // context.  We must run this new context first or else we will
            // dead lock the current context.  We assume that if pending is
            // returned, the callout will return.
            //
            rc = RunContext(pctxt);
        }
        else if ((gReadyQueue.pkthCurrent == NULL) &&
                 !(gReadyQueue.dwfCtxtQ & CQF_PAUSED))
            //
            // We only execute the method if we are not in paused state.
            //
        {
            LOGSCHEDEVENT('EVAL', (ULONG_PTR)pctxt, (ULONG_PTR)
                          (pctxt->pnctxt? pctxt->pnctxt->pnsObj: pctxt->pnsObj),
                          (ULONG_PTR)pctxt->pbOp);
            //
            // There is no active context and we can execute it immediately.
            //
            rc = RunContext(pctxt);

            if ((gReadyQueue.plistCtxtQ != NULL) &&
                !(gReadyQueue.dwfCtxtQ & CQF_WORKITEM_SCHEDULED))
            {
                //
                // If we have more jobs in the queue and we haven't scheduled
                // a dispatch, schedule one.
                //
                LOGSCHEDEVENT('KICK', (ULONG_PTR)rc, 0, 0);
                OSQueueWorkItem(&gReadyQueue.WorkItem);
                gReadyQueue.dwfCtxtQ |= CQF_WORKITEM_SCHEDULED;
            }
        }
        else
        {
            //
            // Insert the context in the ready queue.
            //
            ASSERT(!(pctxt->dwfCtxt & (CTXTF_IN_READYQ | CTXTF_RUNNING)));
            LOGSCHEDEVENT('QCTX', (ULONG_PTR)pctxt, (ULONG_PTR)
                          (pctxt->pnctxt? pctxt->pnctxt->pnsObj: pctxt->pnsObj),
                          (ULONG_PTR)pctxt->pbOp);
            if (!(pctxt->dwfCtxt & CTXTF_IN_READYQ))
            {
                pctxt->dwfCtxt |= CTXTF_IN_READYQ;
                ListInsertTail(&pctxt->listQueue, &gReadyQueue.plistCtxtQ);
                pctxt->pplistCtxtQueue = &gReadyQueue.plistCtxtQ;
            }

            pctxt->dwfCtxt |= CTXTF_NEED_CALLBACK;
            rc = AMLISTA_PENDING;
        }
    }

    EXIT(2, ("InsertReadyQueue=%x\n", rc));
    return rc;
}       //InsertReadyQueue

/***LP  RestartContext - Restart a context
 *
 *  ENTRY
 *      pctxt -> CTXT structure
 *      fDelayExecute - TRUE to queue for delay execution
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 *      None
 */

NTSTATUS LOCAL RestartContext(PCTXT pctxt, BOOLEAN fDelayExecute)
{
    TRACENAME("RESTARTCONTEXT")
    NTSTATUS rc = STATUS_SUCCESS;
    PRESTART prest;

    ENTER(2, ("RestartContext(pctxt=%x,fDelayExecute=%x)\n",
              pctxt, fDelayExecute));

    ASSERT(!(pctxt->dwfCtxt & CTXTF_TIMER_PENDING));
    ASSERT((fDelayExecute == FALSE) || !(pctxt->dwfCtxt & CTXTF_ASYNC_EVAL));

    LOGSCHEDEVENT('REST', (ULONG_PTR)pctxt, (ULONG_PTR)
                  (pctxt->pnctxt? pctxt->pnctxt->pnsObj: pctxt->pnsObj),
                  (ULONG_PTR)pctxt->pbOp);
    if (KeGetCurrentIrql() < DISPATCH_LEVEL)
    {
        AcquireMutex(&gReadyQueue.mutCtxtQ);
        rc = InsertReadyQueue(pctxt, fDelayExecute);
        ReleaseMutex(&gReadyQueue.mutCtxtQ);
    }
    else if ((prest = NEWRESTOBJ(sizeof(RESTART))) != NULL)
    {
        pctxt->dwfCtxt |= CTXTF_NEED_CALLBACK;
        prest->pctxt = pctxt;
        ExInitializeWorkItem(&prest->WorkItem, RestartCtxtPassive, prest);
        OSQueueWorkItem(&prest->WorkItem);
        rc = AMLISTA_PENDING;
    }
    else
    {
        rc = AMLI_LOGERR(AMLIERR_FATAL,
                         ("RestartContext: failed to allocate restart context item"));
    }

    EXIT(2, ("RestartContext=%x\n", rc));
    return rc;
}       //RestartContext

/***LP  RestartCtxtPassive - Restart context running at PASSIVE_LEVEL
 *
 *  ENTRY
 *      prest-> RESTART
 *
 *  EXIT
 *      None
 */

VOID RestartCtxtPassive(PRESTART prest)
{
    TRACENAME("RESTARTCTXTPASSIVE")

    ENTER(2, ("RestartCtxtPassive(prest=%x)\n", prest));

    AcquireMutex(&gReadyQueue.mutCtxtQ);
    InsertReadyQueue(prest->pctxt,
                     (BOOLEAN)((prest->pctxt->dwfCtxt & CTXTF_ASYNC_EVAL) == 0));
    ReleaseMutex(&gReadyQueue.mutCtxtQ);

    FREERESTOBJ(prest);

    EXIT(2, ("RestartCtxtPassive!\n"));
}       //RestartCtxtPassive

/***LP  RestartCtxtCallback - Callback to restart a context
 *
 *  ENTRY
 *      pctxtdata -> CTXTDATA structure
 *
 *  EXIT
 *      None
 */

VOID EXPORT RestartCtxtCallback(PCTXTDATA pctxtdata)
{
    TRACENAME("RESTARTCTXTCALLBACK")
    PCTXT pctxt = CONTAINING_RECORD(pctxtdata, CTXT, CtxtData);

    ENTER(2, ("RestartCtxtCallback(pctxt=%x)\n", pctxt));

    ASSERT(pctxt->dwSig == SIG_CTXT);
    LOGSCHEDEVENT('RSCB', (ULONG_PTR)pctxt, 0, 0);
    RestartContext(pctxt,
                   (BOOLEAN)((pctxt->dwfCtxt & CTXTF_ASYNC_EVAL) == 0));

    EXIT(2, ("RestartCtxtCallback!\n"));
}       //RestartCtxtCallback