/*** ctxt.c - Context Block handling functions
 *
 *  Copyright (c) 1996,1997 Microsoft Corporation
 *  Author:     Michael Tsang (MikeTs)
 *  Created     06/13/97
 *
 *  MODIFICATION HISTORY
 */

#include "pch.h"

#ifdef  LOCKABLE_PRAGMA
#pragma ACPI_LOCKABLE_DATA
#pragma ACPI_LOCKABLE_CODE
#endif

NTSTATUS
LOCAL
NewContext(
    PPCTXT ppctxt
    )
/*++

Routine Description:

    Allocate a new context structure from tne NonPaged Lookaside
    List. Also keep track of the high water marks so that the OS
    can intelligently decide what the "appropriate" number of
    contexts that it should allocate.

    Note that this code raises the possibility that if we detect
    an out-of-memory error, we might be able to save a registry
    key that includes a new larger number (to prevent this problem
    in the first place). Adaptive recovery?

Arguments:

    ppctxt  - address of to hold the newly created context

Return Value:

    NTSTATUS

--*/
{
    TRACENAME("NEWCONTEXT")
    KIRQL       oldIrql;
    NTSTATUS    rc = STATUS_SUCCESS;

    ENTER(2, ("NewContext(ppctxt=%x)\n", ppctxt));

    *ppctxt = ExAllocateFromNPagedLookasideList(
        &AMLIContextLookAsideList
        );
    if (*ppctxt == NULL) {

        AMLI_WARN(("NewContext: Could not Allocate New Context"));
        rc = AMLIERR_OUT_OF_MEM;

    } else {

        //
        // Bookkeeping for memory resources to determine the high
        // water mark
        //
        KeAcquireSpinLock(&gdwGContextSpinLock, &oldIrql );
        gdwcCTObjs++;
        if (gdwcCTObjs > 0 &&
            (ULONG) gdwcCTObjs > gdwcCTObjsMax) {

            gdwcCTObjsMax = gdwcCTObjs;

        }
        KeReleaseSpinLock(&gdwGContextSpinLock, oldIrql );

        //
        // Context Initialization
        //
        InitContext(*ppctxt, gdwCtxtBlkSize);
        AcquireMutex(&gmutCtxtList);
        ListInsertTail(&(*ppctxt)->listCtxt, &gplistCtxtHead);
        ReleaseMutex(&gmutCtxtList);

    }

    EXIT(2, ("NewContext=%x (pctxt=%x)\n", rc, *ppctxt));
    return rc;
}  //NewContext

VOID
LOCAL
FreeContext(
    PCTXT pctxt
    )
/*++

Routine Description:

    This is routine is called when a context is no longer required
    and should be returned to the system's LookAside list

Arguments:

    pctxt   - Address of the context to be freed

Return Value:

    None

--*/
{
    TRACENAME("FREECONTEXT")
    KIRQL   oldIrql;

    ENTER(2, ("FreeContext(pctxt=%x)\n", pctxt));
    ASSERT(pctxt->powner == NULL);

    //
    // Need to hold the proper mutex to touch the global ctxt list
    //
    AcquireMutex(&gmutCtxtList);
    ListRemoveEntry(&pctxt->listCtxt, &gplistCtxtHead);

    if (pctxt->pplistCtxtQueue != NULL) {

        ListRemoveEntry(&pctxt->listQueue, pctxt->pplistCtxtQueue);

    }

    //
    // Done with the global mutex
    //
    ReleaseMutex(&gmutCtxtList);

    //
    // Release any allocated storage that might not have been cleaned up
    //
    FreeDataBuffs(&pctxt->Result, 1);

    //
    // Bookkeeping for memory resources to determine the high
    // water mark
    //
    KeAcquireSpinLock(&gdwGContextSpinLock, &oldIrql );
    gdwcCTObjs--;
    ASSERT(gdwcCTObjs >= 0);
    KeReleaseSpinLock(&gdwGContextSpinLock, oldIrql );

    //
    // Log the end of a method
    //
    ACPIWMILOGEVENT((1,
                EVENT_TRACE_TYPE_END,
                GUID_List[AMLI_LOG_GUID],
                "Object = %s",
                GetObjectPath(pctxt->pnsObj)
               ));


    //
    // Return the context to the nonpaged lookaside list
    //
    ExFreeToNPagedLookasideList(&AMLIContextLookAsideList, pctxt);
    EXIT(2, ("FreeContext!\n"));
} //FreeContext

/***LP  InitContext - initialize a given context block
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      dwLen - length of context block
 *
 *  EXIT
 *      None
 */

VOID LOCAL InitContext(PCTXT pctxt, ULONG dwLen)
{
    TRACENAME("INITCONTEXT")

    ENTER(2, ("InitContext(pctxt=%x,Len=%d)\n", pctxt, dwLen));

    MEMZERO(pctxt, sizeof(CTXT) - sizeof(HEAP));
    pctxt->dwSig = SIG_CTXT;
    pctxt->pbCtxtEnd = (PUCHAR)pctxt + dwLen;
    pctxt->pheapCurrent = &pctxt->LocalHeap;
//  #ifdef DEBUGGER
//    KeQuerySystemTime(&pctxt->Timestamp);
//  #endif
    KeInitializeDpc(&pctxt->Dpc, TimeoutCallback, pctxt);
    KeInitializeTimer(&pctxt->Timer);
    InitHeap(&pctxt->LocalHeap,
             (ULONG)(pctxt->pbCtxtEnd - (PUCHAR)&pctxt->LocalHeap));
    pctxt->LocalHeap.pheapHead = &pctxt->LocalHeap;

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

/***LP  IsStackEmpty - determine if the stack is empty
 *
 *  ENTRY
 *      pctxt -> CTXT
 *
 *  EXIT-SUCCESS
 *      returns TRUE - stack is empty
 *  EXIT-FAILURE
 *      returns FALSE
 */

BOOLEAN LOCAL IsStackEmpty(PCTXT pctxt)
{
    TRACENAME("ISSTACKEMPTY")
    BOOLEAN rc;

    ENTER(2, ("IsStackEmpty(pctxt=%p)\n", pctxt));

    rc = (BOOLEAN)(pctxt->LocalHeap.pbHeapEnd == pctxt->pbCtxtEnd);

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

/***LP  PushFrame - Push a new frame on the stack
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      dwSig - frame object signature
 *      dwLen - size of the frame object
 *      pfnParse -> frame object parse function
 *      ppvFrame -> to hold pointer to the newly pushed frame (can be NULL)
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 */

NTSTATUS LOCAL PushFrame(PCTXT pctxt, ULONG dwSig, ULONG dwLen,
                         PFNPARSE pfnParse, PVOID *ppvFrame)
{
    TRACENAME("PUSHFRAME")
    NTSTATUS rc = STATUS_SUCCESS;

    ENTER(2, ("PushFrame(pctxt=%p,Sig=%s,Len=%d,pfnParse=%p,ppvFrame=%p)\n",
              pctxt, NameSegString(dwSig), dwLen, pfnParse, ppvFrame));
    //
    // Check to see if we have enough space, make sure it doesn't run into the
    // heap.
    //
    if (pctxt->LocalHeap.pbHeapEnd - dwLen >= pctxt->LocalHeap.pbHeapTop)
    {
        PFRAMEHDR pfh;

        pctxt->LocalHeap.pbHeapEnd -= dwLen;
        pfh = (PFRAMEHDR)pctxt->LocalHeap.pbHeapEnd;
        MEMZERO(pfh, dwLen);
        pfh->dwSig = dwSig;
        pfh->dwLen = dwLen;
        pfh->pfnParse = pfnParse;

        if (ppvFrame != NULL)
        {
            *ppvFrame = pfh;
        }

      #ifdef DEBUG
        if ((ULONG)(pctxt->pbCtxtEnd - pctxt->LocalHeap.pbHeapEnd) >
            gdwLocalStackMax)
        {
            gdwLocalStackMax = (ULONG)(pctxt->pbCtxtEnd -
                                       pctxt->LocalHeap.pbHeapEnd);
        }
      #endif
    }
    else
    {
        rc = AMLI_LOGERR(AMLIERR_STACK_OVERFLOW,
                         ("PushFrame: stack ran out of space"));
    }

    EXIT(2, ("PushFrame=%x (StackTop=%x)\n", rc, pctxt->LocalHeap.pbHeapEnd));
    return rc;
}       //PushFrame

/***LP  PopFrame - Pop a frame off the stack
 *
 *  ENTRY
 *      pctxt -> CTXT
 *
 *  EXIT
 *      None
 */

VOID LOCAL PopFrame(PCTXT pctxt)
{
    TRACENAME("POPFRAME")

    ENTER(2, ("PopFrame(pctxt=%p)\n", pctxt));

    ASSERT(!IsStackEmpty(pctxt));
    ASSERT(((PFRAMEHDR)pctxt->LocalHeap.pbHeapEnd)->dwSig != 0);
    pctxt->LocalHeap.pbHeapEnd +=
        ((PFRAMEHDR)pctxt->LocalHeap.pbHeapEnd)->dwLen;

    EXIT(2, ("PopFrame! (StackTop=%p)\n", pctxt->LocalHeap.pbHeapEnd));
}       //PopFrame

/***LP  PushPost - Push a Post frame on the stack
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      pfnPost -> post processing function
 *      uipData1 - data1
 *      uipData2 - data2
 *      pdataResult -> result object
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 */

NTSTATUS LOCAL PushPost(PCTXT pctxt, PFNPARSE pfnPost, ULONG_PTR uipData1,
                        ULONG_PTR uipData2, POBJDATA pdataResult)
{
    TRACENAME("PUSHPOST")
    NTSTATUS rc = STATUS_SUCCESS;
    PPOST ppost;

    ENTER(2, ("PushPost(pctxt=%x,pfnPost=%x,Data1=%x,Data2=%x,pdataResult=%x)\n",
              pctxt, pfnPost, uipData1, uipData2, pdataResult));

    if ((rc = PushFrame(pctxt, SIG_POST, sizeof(POST), pfnPost, &ppost)) ==
        STATUS_SUCCESS)
    {
        ppost->uipData1 = uipData1;
        ppost->uipData2 = uipData2;
        ppost->pdataResult = pdataResult;
    }

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

/***LP  PushScope - Push a ParseScope frame on the stack
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      pbOpBegin -> beginning of scope
 *      pbOpEnd -> end of scope
 *      pbOpRet -> return address after end of scope (NULL if continue on)
 *      pnsScope -> new scope
 *      powner -> new owner
 *      pheap -> new heap
 *      pdataResult -> result object
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 */

NTSTATUS LOCAL PushScope(PCTXT pctxt, PUCHAR pbOpBegin, PUCHAR pbOpEnd,
                         PUCHAR pbOpRet, PNSOBJ pnsScope, POBJOWNER powner,
                         PHEAP pheap, POBJDATA pdataResult)
{
    TRACENAME("PUSHSCOPE")
    NTSTATUS rc = STATUS_SUCCESS;
    PSCOPE pscope;

    ENTER(2, ("PushScope(pctxt=%x,pbOpBegin=%x,pbOpEnd=%x,pbOpRet=%x,pnsScope=%x,pheap=%x,pdataResult=%x)\n",
              pctxt, pbOpBegin, pbOpEnd, pbOpRet, pnsScope, pheap,
              pdataResult));

    if ((rc = PushFrame(pctxt, SIG_SCOPE, sizeof(SCOPE), ParseScope, &pscope))
        == STATUS_SUCCESS)
    {
        pctxt->pbOp = pbOpBegin;
        pscope->pbOpEnd = pbOpEnd;
        pscope->pbOpRet = pbOpRet;
        pscope->pnsPrevScope = pctxt->pnsScope;
        pctxt->pnsScope = pnsScope;
        pscope->pownerPrev = pctxt->powner;
        pctxt->powner = powner;
        pscope->pheapPrev = pctxt->pheapCurrent;
        pctxt->pheapCurrent = pheap;
        pscope->pdataResult = pdataResult;
    }

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

/***LP  PushCall - Push a Call frame on the stack
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      pnsMethod -> method object
 *      pdataResult -> result object
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 */

NTSTATUS LOCAL PushCall(PCTXT pctxt, PNSOBJ pnsMethod, POBJDATA pdataResult)
{
    TRACENAME("PUSHCALL")
    NTSTATUS rc = STATUS_SUCCESS;
    PCALL pcall;

    ENTER(2, ("PushCall(pctxt=%x,pnsMethod=%s,pdataResult=%x)\n",
              pctxt, GetObjectPath(pnsMethod), pdataResult));

    ASSERT((pnsMethod == NULL) ||
           (pnsMethod->ObjData.dwDataType == OBJTYPE_METHOD));

    if ((rc = PushFrame(pctxt, SIG_CALL, sizeof(CALL), ParseCall, &pcall))
        == STATUS_SUCCESS)
    {
        if (pnsMethod != NULL)
        {
            PMETHODOBJ pm = (PMETHODOBJ)pnsMethod->ObjData.pbDataBuff;

            pcall->pnsMethod = pnsMethod;
            if (pm->bMethodFlags & METHOD_SERIALIZED)
            {
                pcall->FrameHdr.dwfFrame |= CALLF_NEED_MUTEX;
            }
            pcall->icArgs = (int)(pm->bMethodFlags & METHOD_NUMARG_MASK);
            if (pcall->icArgs > 0)
            {
                if ((pcall->pdataArgs = NEWODOBJ(pctxt->pheapCurrent,
                                                 sizeof(OBJDATA)*pcall->icArgs))
                    == NULL)
                {
                    rc = AMLI_LOGERR(AMLIERR_OUT_OF_MEM,
                                     ("PushCall: failed to allocate argument objects"));
                }
                else
                {
                    MEMZERO(pcall->pdataArgs, sizeof(OBJDATA)*pcall->icArgs);
                }
            }
        }
        else
        {
            //
            // This is a dummy call frame for AMLILoadDDB.  We just need it
            // for its Locals array in case there is ASL referencing them.
            // But we don't really want to parse a call frame, so let's set
            // it to final clean up stage.
            //
            ASSERT(pctxt->pcall == NULL);
            pctxt->pcall = pcall;
            pcall->FrameHdr.dwfFrame = 4;
        }

        pcall->pdataResult = pdataResult;
    }

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

/***LP  PushTerm - Push a Term frame on the stack
 *
 *  ENTRY
 *      pctxt -> CTXT
 *      pbOpTerm -> term opcode
 *      pbScopeEnd -> end of current scope
 *      pamlterm -> AMLTERM
 *      pdataResult -> result object
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 */

NTSTATUS LOCAL PushTerm(PCTXT pctxt, PUCHAR pbOpTerm, PUCHAR pbScopeEnd,
                        PAMLTERM pamlterm, POBJDATA pdataResult)
{
    TRACENAME("PUSHTERM")
    NTSTATUS rc = STATUS_SUCCESS;
    PTERM pterm;

    ENTER(2, ("PushTerm(pctxt=%x,pbOpTerm=%x,pbScopeEnd=%x,pamlterm=%x,pdataResult=%x)\n",
              pctxt, pbOpTerm, pbScopeEnd, pamlterm, pdataResult));

    if ((rc = PushFrame(pctxt, SIG_TERM, sizeof(TERM), ParseTerm, &pterm)) ==
        STATUS_SUCCESS)
    {
        pterm->pbOpTerm = pbOpTerm;
        pterm->pbScopeEnd = pbScopeEnd;
        pterm->pamlterm = pamlterm;
        pterm->pdataResult = pdataResult;
        pterm->icArgs = pamlterm->pszArgTypes? STRLEN(pamlterm->pszArgTypes): 0;
        if (pterm->icArgs > 0)
        {
            if ((pterm->pdataArgs = NEWODOBJ(pctxt->pheapCurrent,
                                             sizeof(OBJDATA)*pterm->icArgs)) ==
                NULL)
            {
                rc = AMLI_LOGERR(AMLIERR_OUT_OF_MEM,
                                 ("PushTerm: failed to allocate argument objects"));
            }
            else
            {
                MEMZERO(pterm->pdataArgs, sizeof(OBJDATA)*pterm->icArgs);
            }
        }
    }

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

/***LP  RunContext - Run a context
 *
 *  ENTRY
 *      pctxt -> CTXT
 *
 *  EXIT-SUCCESS
 *      returns STATUS_SUCCESS
 *  EXIT-FAILURE
 *      returns AMLIERR_ code
 *
 *  NOTE
 *      Caller must own the scheduler lock such that the context flags can
 *      be updated properly.  The lock is dropped and re-obtain around
 *      execution of the target context.
 */

NTSTATUS LOCAL RunContext(PCTXT pctxt)
{
    TRACENAME("RUNCONTEXT")
    NTSTATUS rc;
    PFRAMEHDR pfh;
    PKTHREAD pkthSave = gReadyQueue.pkthCurrent;
    PCTXT pctxtSave = gReadyQueue.pctxtCurrent;

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

    //
    // Better be a Ready Context structure.
    //
    ASSERT(pctxt->dwSig == SIG_CTXT);
    ASSERT(pctxt->dwfCtxt & CTXTF_READY);

    //
    // Remember previous context and thread.
    //
    gReadyQueue.pctxtCurrent = pctxt;
    gReadyQueue.pkthCurrent = KeGetCurrentThread();

    LOGSCHEDEVENT('RUNC', (ULONG_PTR)pctxt, (ULONG_PTR)
                  (pctxt->pnctxt? pctxt->pnctxt->pnsObj: pctxt->pnsObj),
                  (ULONG_PTR)pctxt->dwfCtxt);

    //
    // As long as the context is ready, execute it.
    //
    for (;;)
    {
        //
        // Transistion context from Ready to Running.
        //
        rc = STATUS_SUCCESS;
        pctxt->dwfCtxt &= ~CTXTF_READY;
        pctxt->dwfCtxt |= CTXTF_RUNNING;

        //
        // Drop scheduler lock and execute context.
        //
        ReleaseMutex(&gReadyQueue.mutCtxtQ);

        //
        // Go for as long as there's work to perform.
        //
        while (!IsStackEmpty(pctxt))
        {
            CHKDEBUGGERREQ();
            pfh = (PFRAMEHDR)pctxt->LocalHeap.pbHeapEnd;
            ASSERT(pfh->pfnParse != NULL);

            rc = pfh->pfnParse(pctxt, pfh, rc);
            if ((rc == AMLISTA_PENDING) || (rc == AMLISTA_DONE))
            {
                break;
            }
        }

        //
        // Get the scheduler lock, and clear the running flag.
        //
        AcquireMutex(&gReadyQueue.mutCtxtQ);

        //
        // If we are in nested eval and the nested context is done,
        // we must not clear the running flag because the parent thread
        // is still running.
        //
        if (!(pctxt->dwfCtxt & CTXTF_NEST_EVAL) || (rc != AMLISTA_DONE))
        {
            pctxt->dwfCtxt &= ~CTXTF_RUNNING;
        }

        //
        // If the context is no longer ready, we're done.
        //
        if (!(pctxt->dwfCtxt & CTXTF_READY))
        {
            break;
        }

        //
        // Context became Ready during a pending operation, keep
        // dispatching.
        //
        ASSERT (rc == AMLISTA_PENDING);
    }

    if (rc == AMLISTA_PENDING)
    {
        pctxt->dwfCtxt |= CTXTF_NEED_CALLBACK;
    }
    else if (rc == AMLISTA_DONE)
    {
        if (pctxt->pnctxt == NULL)
        {
            pctxt->dwfCtxt &= ~CTXTF_NEST_EVAL;
        }
        rc = STATUS_SUCCESS;
    }
    else
    {
        ReleaseMutex(&gReadyQueue.mutCtxtQ);
        if ((rc == STATUS_SUCCESS) && (pctxt->pdataCallBack != NULL))
        {
            rc = DupObjData(gpheapGlobal, pctxt->pdataCallBack, &pctxt->Result);
        }

        if (pctxt->dwfCtxt & CTXTF_NEED_CALLBACK)
        {
            AsyncCallBack(pctxt, rc);

            if(pctxt->dwfCtxt & CTXTF_ASYNC_EVAL)
            {    
                rc = AMLISTA_PENDING;
            }
        }

        //
        // Free any owned resources the context may not have freed.
        //
        while (pctxt->plistResources != NULL)
        {
            PRESOURCE pres;

            pres = CONTAINING_RECORD(pctxt->plistResources, RESOURCE, list);
            ASSERT (pres->pctxtOwner == pctxt);

            //
            // Note that it is the responsibility of the corresponding
            // resource release functions (e.g. ReleaseASLMutex) to dequeue
            // the resource from the list and free it.
            //
            switch (pres->dwResType)
            {
                case RESTYPE_MUTEX:
                    ReleaseASLMutex(pctxt, pres->pvResObj);
                    break;

                default:
                    //
                    // We should never come here.  In case we do, we need to
                    // dequeue the unknown resource object and free it.
                    //
                    pres = CONTAINING_RECORD(
                               ListRemoveHead(&pctxt->plistResources),
                               RESOURCE, list);
                    ASSERT(pres == NULL);
                    FREECROBJ(pres);
            }
        }

        FreeContext(pctxt);

        AcquireMutex(&gReadyQueue.mutCtxtQ);
    }

    //
    // Restore previous context and thread.
    //
    gReadyQueue.pkthCurrent = pkthSave;
    gReadyQueue.pctxtCurrent = pctxtSave;

    if ((gReadyQueue.dwfCtxtQ & CQF_FLUSHING) && (gplistCtxtHead == NULL))
    {
        //
        // We just flushed the last pending ctxt, let's go into paused state.
        //
        gReadyQueue.dwfCtxtQ &= ~CQF_FLUSHING;
        gReadyQueue.dwfCtxtQ |= CQF_PAUSED;
        if (gReadyQueue.pfnPauseCallback != NULL)
        {
            //
            // We are in paused state and all pending contexts are flushed,
            // tell core driver that we are done flushing.
            //
            gReadyQueue.pfnPauseCallback(gReadyQueue.PauseCBContext);
            LOGSCHEDEVENT('PACB', (ULONG_PTR)pctxt, (ULONG_PTR)rc, 0);
        }
    }

    LOGSCHEDEVENT('RUN!', (ULONG_PTR)pctxt, (ULONG_PTR)rc, 0);

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