schedule.c

WinCE5.0部分核心源码

PostBoostCrit1(
    LPCRIT pcrit
    ) 
{
    PTHREAD pth;
    KCALLPROFON(57);
    if (pCurThread->bWaitState == WAITSTATE_PROCESSING) {
        pth = HandleToThread((HANDLE)((DWORD)pcrit->lpcs->OwnerThread & ~1));
        DEBUGCHK(pth);
        ReprioCritMut(pcrit,pth);
    }
    KCALLPROFOFF(57);
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
PostBoostCrit2(
    LPCRIT pcrit
    ) 
{
    PTHREAD pth;
    BYTE prio;
    KCALLPROFON(60);
    if (pCurThread->bWaitState == WAITSTATE_PROCESSING) {
        pth = HandleToThread((HANDLE)((DWORD)pcrit->lpcs->OwnerThread & ~1));
        DEBUGCHK(pth);
        if (pcrit->pProxList && ((prio = pcrit->pProxList->prio) < GET_CPRIO(pth))) {
            BoostCPrio(pth,prio);
            if (IsCeLogStatus(CELOGSTATUS_ENABLED_GENERAL)) {
                CELOG_SystemInvert(pth->hTh, prio);
            }
        }
    }
    KCALLPROFOFF(60);
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
CritFinalBoost(
    LPCRITICAL_SECTION lpcs
    ) 
{
    LPCRIT pcrit;
    DWORD prio;
    KCALLPROFON(59);
    DEBUGCHK(lpcs->OwnerThread == hCurThread);
    pcrit = (LPCRIT)lpcs->hCrit;
    if (!pcrit->bListed && pcrit->pProxList)
        LinkCritMut(pcrit,pCurThread,1);
    if (pcrit->pProxList && ((prio = pcrit->pProxList->prio) < GET_CPRIO(pCurThread))) {
        SET_CPRIO(pCurThread,prio);
        if (IsCeLogStatus(CELOGSTATUS_ENABLED_GENERAL)) {
            CELOG_SystemInvert(pCurThread->hTh, prio);
        }
    }
    KCALLPROFOFF(59);
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
VOID 
AddToProcRunnable(
    PPROCESS pproc,
    PTHREAD pth
    ) 
{
    KCALLPROFON(24);
    pth->pNextInProc = pproc->pTh;
    pth->pPrevInProc = 0;
    DEBUGCHK(!pproc->pTh->pPrevInProc);
    pproc->pTh->pPrevInProc = pth;
    pproc->pTh = pth;
    MakeRun(pth);
    KCALLPROFOFF(24);
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
HANDLE 
WakeOneThreadInterruptDelayed(
    LPEVENT lpe
    ) 
{
    PTHREAD pth;
    LPPROXY pprox;
    HANDLE hRet;
    pprox = lpe->pProxList;
    DEBUGCHK(pprox->pObject == (LPBYTE)lpe);
    DEBUGCHK(pprox->bType == HT_MANUALEVENT);
    DEBUGCHK(pprox->pQDown == pprox);
    DEBUGCHK(pprox->pQPrev == (LPPROXY)lpe);
    DEBUGCHK(pprox->dwRetVal == WAIT_OBJECT_0);
    lpe->pProxList = 0;
    pth = pprox->pTh;
    DEBUGCHK(!pth->lpce);
    pth->wCount++;
    DEBUGCHK(pth->lpProxy == pprox);
    pth->lpProxy = 0;
    if (pth->bWaitState == WAITSTATE_BLOCKED) {
        DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_RUNNABLE);
        DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_RUNNING);
        DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_NEEDSRUN);
        pth->retValue = WAIT_OBJECT_0;
        hRet = pth->hTh;
        SET_RUNSTATE(pth,RUNSTATE_NEEDSRUN);
    } else {
        DEBUGCHK(!GET_SLEEPING(pth));
        DEBUGCHK(pth->bWaitState == WAITSTATE_PROCESSING);
        pth->dwPendReturn = WAIT_OBJECT_0;
        pth->bWaitState = WAITSTATE_SIGNALLED;
        hRet = 0;
    }
    return hRet;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
WakeOneThreadFlat(
    LPEVENT pObject,
    HANDLE *phTh
    ) 
{
    PTHREAD pth;
    LPPROXY pprox, pDown;
    KCALLPROFON(41);
    if (pprox = pObject->pProxList) {
        DEBUGCHK((pprox->bType == SH_CURPROC) || (pprox->bType == SH_CURTHREAD) || (pprox->bType == HT_MANUALEVENT));
        DEBUGCHK(pprox->pQPrev == (LPPROXY)pObject);
        pDown = pprox->pQDown;
        DEBUGCHK(pDown);
        if (pDown == pprox) { // we're alone
            pObject->pProxList = 0;
        } else {
            pDown->pQUp = pprox->pQUp;
            pprox->pQUp->pQDown = pObject->pProxList = pDown;
            pDown->pQPrev = (LPPROXY)pObject;
        }
        pprox->pQDown = 0;
        pth = pprox->pTh;
        DEBUGCHK(pth);
        if (pth->wCount == pprox->wCount) {
            DEBUGCHK(pth->lpce);
            pth->lpce->base = pth->lpProxy;
            pth->lpce->size = (DWORD)pth->lpPendProxy;
            pth->lpProxy = 0;
            pth->wCount++;
            if (pth->bWaitState == WAITSTATE_BLOCKED) {
                DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_RUNNABLE);
                DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_RUNNING);
                DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_NEEDSRUN);
                pth->retValue = pprox->dwRetVal;
                SET_RUNSTATE(pth,RUNSTATE_NEEDSRUN);
                *phTh = pth->hTh;
            } else {
                DEBUGCHK(!GET_SLEEPING(pth));
                DEBUGCHK(pth->bWaitState == WAITSTATE_PROCESSING);
                pth->dwPendReturn = pprox->dwRetVal;
                pth->bWaitState = WAITSTATE_SIGNALLED;
            }
        }
    }
    KCALLPROFOFF(41);
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DWORD 
EventModMan(
    LPEVENT lpe,
    LPSTUBEVENT lpse,
    DWORD action
    ) 
{
    DWORD prio;
    KCALLPROFON(15);
    prio = lpe->bMaxPrio;
    lpe->bMaxPrio = THREAD_RT_PRIORITY_IDLE;
    if (lpse->pProxList = lpe->pProxList) {
        lpse->pProxList->pQPrev = (LPPROXY)lpse;
        DEBUGCHK(lpse->pProxList->pQDown);
        lpe->pProxList = 0;
    }
    lpe->state = (action == EVENT_SET);
    KCALLPROFOFF(15);
    return prio;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL 
EventModAuto(
    LPEVENT lpe,
    DWORD action,
    HANDLE *phTh
    ) 
{
    BOOL bRet;
    PTHREAD pth;
    LPPROXY pprox, pDown, pNext;
    BYTE prio;
    KCALLPROFON(16);
    bRet = 0;

    if (!(pprox = lpe->pProxList)) {
        lpe->state = (action == EVENT_SET);
    } else {
        pDown = pprox->pQDown;
        if (lpe->onequeue) {
            DEBUGCHK(pprox->pQPrev = (LPPROXY)lpe);
            if (pDown == pprox) { // we're alone
                lpe->pProxList = 0;
            } else {
                pDown->pQUp = pprox->pQUp;
                pprox->pQUp->pQDown = lpe->pProxList = pDown;
                pDown->pQPrev = (LPPROXY)lpe;
            }
        } else {
            prio = pprox->prio/PRIORITY_LEVELS_HASHSCALE;
            pNext = pprox->pQNext;
            if (lpe->pProxHash[prio] == pprox) {
                lpe->pProxHash[prio] = ((pDown != pprox) ? pDown :
                    (pNext && (pNext->prio/PRIORITY_LEVELS_HASHSCALE == prio)) ? pNext : 0);
            }
            if (pDown == pprox) {
                if (lpe->pProxList = pNext)
                    pNext->pQPrev = 0;
            } else {
                pDown->pQUp = pprox->pQUp;
                pprox->pQUp->pQDown = pDown;
                lpe->pProxList = pDown;
                DEBUGCHK(!pDown->pQPrev);
                if (pNext) {
                    pNext->pQPrev = pDown;
                    pDown->pQNext = pNext;
                }
            }
        }
        pprox->pQDown = 0;
        pth = pprox->pTh;
        DEBUGCHK(pth);
        if (pth->wCount != pprox->wCount)
            bRet = 1;
        else {
            DEBUGCHK(pth->lpce);
            pth->lpce->base = pth->lpProxy;
            pth->lpce->size = (DWORD)pth->lpPendProxy;
            pth->lpProxy = 0;
            pth->wCount++;
            if (pth->bWaitState == WAITSTATE_BLOCKED) {
                DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_RUNNABLE);
                DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_RUNNING);
                DEBUGCHK(GET_RUNSTATE(pth) != RUNSTATE_NEEDSRUN);
                pth->retValue = pprox->dwRetVal;
                SET_RUNSTATE(pth,RUNSTATE_NEEDSRUN);
                *phTh = pth->hTh;
            } else {
                DEBUGCHK(!GET_SLEEPING(pth));
                DEBUGCHK(pth->bWaitState == WAITSTATE_PROCESSING);
                pth->dwPendReturn = pprox->dwRetVal;
                pth->bWaitState = WAITSTATE_SIGNALLED;
            }
            lpe->state = 0;
        }
    }
    KCALLPROFOFF(16);
    return bRet;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
DoFreeMutex(
    LPMUTEX lpm
    ) 
{
    KCALLPROFON(34);
    UnlinkCritMut((LPCRIT)lpm,lpm->pOwner);
    KCALLPROFOFF(34);
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
DoFreeCrit(
    LPCRIT lpcrit
    ) 
{
    PTHREAD pth;
    KCALLPROFON(45);
    if (lpcrit->bListed == 1) {
        pth = HandleToThread(lpcrit->lpcs->OwnerThread);
        DEBUGCHK(pth);
        UnlinkCritMut(lpcrit,pth);
    }
    KCALLPROFOFF(45);
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL 
SC_EventAddAccess(
    HANDLE hEvent
    ) 
{
    BOOL retval;
    TRUSTED_API (L"SC_EventAddAccess", FALSE);
    
    DEBUGMSG(ZONE_ENTRY,(L"SC_EventAddAccess entry: %8.8lx\r\n",hEvent));
    retval = IncRef(hEvent,pCurProc);
    DEBUGMSG(ZONE_ENTRY,(L"SC_EventAddAccess exit: %d\r\n",retval));
    return retval;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
HANDLE 
EventModIntr(
    LPEVENT lpe,
    DWORD type
    ) 
{
    HANDLE hRet;
    KCALLPROFON(42);
    if (!lpe->pProxList) {
        lpe->state = (type == EVENT_SET);
        hRet = 0;
    } else {
        lpe->state = 0;
        hRet = WakeOneThreadInterruptDelayed(lpe);
    }
    DEBUGCHK(!lpe->manualreset);
    KCALLPROFOFF(42);
    return hRet;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
AdjustPrioDown() 
{
    DWORD dwPrio, dwPrio2;
    KCALLPROFON(66);
    dwPrio = GET_BPRIO(pCurThread);
    if (pCurThread->pOwnedList && ((dwPrio2 = pCurThread->pOwnedList->bListedPrio) < dwPrio))
        dwPrio = dwPrio2;
    SET_CPRIO(pCurThread,dwPrio);
    if (RunList.pRunnable && (dwPrio > GET_CPRIO(RunList.pRunnable)))
        SetReschedule();
    KCALLPROFOFF(66);
}


BOOL SC_EventSetData (HANDLE hEvent, DWORD dwData)
{
    LPEVENT lpe;
    TRUSTED_API (L"SC_EventSetData", FALSE);
    
    DEBUGMSG(ZONE_ENTRY,(L"SC_EventSetData entry: %8.8lx %8.8lx\r\n",hEvent,dwData));
    if (!(lpe = HandleToEventPerm(hEvent))) {
        KSetLastError(pCurThread, ERROR_INVALID_HANDLE);
        DEBUGMSG(ZONE_ENTRY,(L"SC_EventSetData exit: 0\r\n"));
        return FALSE;
    }

    lpe->dwData = dwData;
    DEBUGMSG(ZONE_ENTRY,(L"SC_EventSetData exit: 1\r\n"));
    return TRUE;
}

DWORD SC_EventGetData (HANDLE hEvent)
{
    LPEVENT lpe;
    TRUSTED_API (L"SC_EventGetData", FALSE);