kmisc.c

WinCE5.0部分核心源码

    KInfoTable[KINX_TIMECHANGECOUNT] ++;
    DEBUGMSG(ZONE_ENTRY,(L"SC_SetTimeZoneBias exit\r\n"));
}

/* Set thread last error */



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void
SC_SetLastError(
    DWORD dwError
    )
{
    DEBUGMSG(ZONE_ENTRY,(L"SC_SetLastError entry: %8.8lx\r\n",dwError));
    pCurThread->dwLastError = dwError;
    DEBUGMSG(ZONE_ENTRY,(L"SC_SetLastError exit\r\n"));
}

/* Get thread last error */



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DWORD
SC_GetLastError(void)
{
    DEBUGMSG(ZONE_ENTRY,(L"SC_GetLastError entry\r\n"));
    DEBUGMSG(ZONE_ENTRY,(L"SC_GetLastError exit: %8.8lx\r\n",pCurThread->dwLastError));
    return pCurThread->dwLastError;
}

/* Get thread return code */



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
SC_ThreadGetCode(
    HANDLE hTh,
    LPDWORD lpExit
    )
{
    BOOL fRet;
    DEBUGMSG(ZONE_ENTRY,(L"SC_ThreadGetCode entry: %8.8lx %8.8lx\r\n",hTh,lpExit));
    if (fRet = (BOOL) SC_MapPtrWithSize (lpExit, sizeof(DWORD), hCurProc)) {
        *lpExit = GetUserInfo(hTh);
    } else {
        KSetLastError (pCurThread, ERROR_INVALID_PARAMETER);
    }
    DEBUGMSG(ZONE_ENTRY,(L"SC_ThreadGetCode exit: %8.8lx\r\n",TRUE));
    return fRet;
}

/* Get process return code */



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
SC_ProcGetCode(
    HANDLE hProc,
    LPDWORD lpExit
    )
{
    BOOL fRet;
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetCode entry: %8.8lx %8.8lx\r\n",hProc,lpExit));
    if (fRet = (BOOL) SC_MapPtrWithSize (lpExit, sizeof(DWORD), hCurProc)) {
        *lpExit = GetUserInfo(hProc);
    } else {
        KSetLastError (pCurThread, ERROR_INVALID_PARAMETER);
    }
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetCode exit: %8.8lx\r\n",TRUE));
    return fRet;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
DWORD
SC_ProcGetIndex(
    HANDLE hProc
    )
{
    PPROCESS pproc;
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetIndex entry: %8.8lx\r\n",hProc));
    if (!(pproc = HandleToProc(hProc))) {
        DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetIndex exit: %8.8lx\r\n",0xffffffff));
        return 0xffffffff;
    }
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetIndex exit: %8.8lx\r\n",pproc->procnum));
    return pproc->procnum;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
HANDLE
SC_ProcGetIDFromIndex(
    DWORD dwIdx
    )
{
    return ((dwIdx < MAX_PROCESSES) && ProcArray[dwIdx].dwVMBase)? ProcArray[dwIdx].hProc : NULL;

}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
SC_ProcFlushICache(
    HANDLE hProc,
    LPCVOID lpBaseAddress,
    DWORD dwSize
    )
{
    PPROCESS pprc;
    if (!hProc || (hProc == GetCurrentProcess()))
        hProc = hCurProc;

    pprc = HandleToProc (hProc);
    if (!pprc)
        return FALSE;
    OEMCacheRangeFlush (MapPtrProc (lpBaseAddress, pprc), dwSize, CACHE_SYNC_INSTRUCTIONS|CACHE_SYNC_WRITEBACK);
    return TRUE;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
SC_ProcReadMemory(
    HANDLE hProcess,
    LPCVOID lpBaseAddress,
    LPVOID lpBuffer,
    DWORD nSize,
    LPDWORD lpNumberOfBytesRead
    )
{
    BOOL retval = FALSE;
    LPBYTE ptr;
    PPROCESS pproc;

    TRUSTED_API (L"SC_ProcReadMemory", FALSE);

    if (lpNumberOfBytesRead)
        *lpNumberOfBytesRead = 0;
    if (pproc = HandleToProc(hProcess)) {
        ACCESSKEY ulOldKey;
        SWITCHKEY(ulOldKey,0xffffffff);
        ptr = MapPtrProc(lpBaseAddress,pproc);
        if (!SC_IsBadPtr (0, ptr, nSize) || IsSecureVa (ptr) || IsValidKPtr (ptr)) {
            __try {
                memcpy(lpBuffer,ptr,nSize);
                if (lpNumberOfBytesRead)
                    *lpNumberOfBytesRead = nSize;
                retval = TRUE;
            } __except (EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_NOACCESS);
            }
        }
        SETCURKEY(ulOldKey);
    }
    return retval;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
SC_ProcWriteMemory(
    HANDLE hProcess,
    LPVOID lpBaseAddress,
    LPVOID lpBuffer,
    DWORD nSize,
    LPDWORD lpNumberOfBytesWritten
    )
{
    BOOL retval = FALSE;
    LPBYTE ptr, ptr2, ptrend;
    PPROCESS pproc;
    DWORD bytesleft, bytestocopy;

    TRUSTED_API (L"SC_ProcWriteMemory", FALSE);

    if (lpNumberOfBytesWritten)
        *lpNumberOfBytesWritten = 0;
    if (pproc = HandleToProc(hProcess)) {
        ACCESSKEY ulOldKey;
        SWITCHKEY(ulOldKey,0xffffffff);
        lpBaseAddress = ptr = MapPtrProc(lpBaseAddress,pproc);
        if (ptr && !IsROM (ptr, nSize)) {
            __try {
                bytesleft = nSize;
                while (bytesleft) {
                    BOOL bUnlock;
                    bytestocopy = 0x10000 - ((DWORD)ptr & 0xffff);
                    if (bytestocopy > bytesleft)
                        bytestocopy = bytesleft;
                    bUnlock = LockPages(ptr,bytestocopy,0,LOCKFLAG_READ);
                    ptr2 = ptr;
                    ptrend = ptr2 + bytestocopy;
                    while (ptr2 < ptrend) {
                        MEMORY_BASIC_INFORMATION mbi;
                        if (!VirtualQuery(ptr2,&mbi,sizeof(mbi)))
                            bUnlock = FALSE;
                        else if ((mbi.Protect != PAGE_READWRITE) && (mbi.Protect != PAGE_EXECUTE_READWRITE)) {
                            DWORD dwProt;
                            dwProt = ((mbi.Protect == PAGE_EXECUTE) || (mbi.Protect == PAGE_EXECUTE_READ)) ?
                                PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
                            VirtualProtect(ptr2,PAGE_SIZE - ((DWORD)ptr2 & (PAGE_SIZE-1)), dwProt, &dwProt);
                            bUnlock = FALSE;
                        }
                        ptr2 += PAGE_SIZE - ((DWORD)ptr2 & (PAGE_SIZE-1));
                    }
                    if (bUnlock)
                        UnlockPages(ptr,bytestocopy);
                    memcpy(ptr,lpBuffer,bytestocopy);
                    ptr += bytestocopy;
                    lpBuffer = (LPVOID)((LPBYTE)lpBuffer + bytestocopy);
                    bytesleft -= bytestocopy;
                }
                if (lpNumberOfBytesWritten)
                    *lpNumberOfBytesWritten = nSize;
                SC_CacheRangeFlush (lpBaseAddress, nSize, CACHE_SYNC_DISCARD | CACHE_SYNC_INSTRUCTIONS);
                retval = TRUE;
            } __except (EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_NOACCESS);
            }
        }
        SETCURKEY(ulOldKey);
    }
    return retval;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL SC_ProcGetModInfo (HANDLE hProc, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb)
{
    PMODULE  pMod = (PMODULE) hModule;
    PPROCESS pprc;
    BOOL     fRet = FALSE;

    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetModInfo entry: %8.8lx %8.8lx %8.8lx %8.8lx\r\n",
                    hProc, hModule, lpmodinfo, cb));
    if (!hProc || (hProc == GetCurrentProcess()))
        hProc = hCurProc;

    __try {
        // validate parameters
        if ((sizeof (MODULEINFO) != cb)
            || !SC_MapPtrWithSize (lpmodinfo, cb, hCurProc)
            || (pMod && !IsValidModule (pMod))
            || !(pprc = HandleToProc (hProc))
            || (pMod && !(pMod->inuse & (1 << pprc->procnum)))) {
            KSetLastError (pCurThread, ERROR_INVALID_PARAMETER);
        } else {
            if (pMod) {
                // pMod is not NULL, return the information of the module
                lpmodinfo->lpBaseOfDll = (LPVOID) ZeroPtr (pMod->BasePtr);
                lpmodinfo->SizeOfImage = pMod->e32.e32_vsize;
                lpmodinfo->EntryPoint = (LPVOID) pMod->startip;
            } else {
                // pMod is NULL, just return the process information
                lpmodinfo->lpBaseOfDll = pprc->BasePtr;
                lpmodinfo->SizeOfImage = pprc->e32.e32_vsize;
                lpmodinfo->EntryPoint = (LPVOID) (pprc->e32.e32_sect14rva ? CTBFf : MTBFf);
            }
            fRet = TRUE;
        }
    } __except (EXCEPTION_EXECUTE_HANDLER) {
        KSetLastError (pCurThread, ERROR_INVALID_PARAMETER);
    }
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcGetModInfo exit: %8.8lx\r\n", fRet));
    return fRet;
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL SC_ProcSetVer (HANDLE hProc, DWORD dwVersion)
{
    BOOL fRet = TRUE;
    PPROCESS pproc;
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcSetVer entry: %8.8lx %8.8lx\r\n", hProc, dwVersion));
    if (!hProc || (hProc == GetCurrentProcess()))
        hProc = hCurProc;

    if ((pproc = HandleToProc(hProc))                       // valid process
        && TestAccess (&pCurThread->aky, &pproc->aky)) {    // has permission to the process
                                                            // (need to test this because we might get here
                                                            //  when called directly from KMODE)
        pproc->e32.e32_cevermajor = (BYTE) HIWORD (dwVersion);
        pproc->e32.e32_ceverminor = (BYTE) LOWORD (dwVersion);
    } else {
        fRet = FALSE;
        KSetLastError (pCurThread, ERROR_INVALID_PARAMETER);
    }
    DEBUGMSG(ZONE_ENTRY,(L"SC_ProcSetVer exit: %8.8lx\r\n", fRet));
    return fRet;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
HANDLE
SC_OpenProcess(
    DWORD fdwAccess,
    BOOL fInherit,
    DWORD IDProcess
    )
{
    HANDLE hProc = NULL;
    if (!fInherit && (GetHandleType ((HANDLE)IDProcess) == SH_CURPROC)) {
        if ((KERN_TRUST_FULL != pCurProc->bTrustLevel)
            && !GetObjectPtrByTypePermissioned ((HANDLE)IDProcess, SH_CURPROC)) {
            SetLastError (ERROR_ACCESS_DENIED);
        } else if (!IncRef (hProc = (HANDLE)IDProcess, pCurProc)) {
            SetLastError (ERROR_OUTOFMEMORY);
            hProc = NULL;
        }
    } else {
        SetLastError(ERROR_INVALID_PARAMETER);
    }
    return hProc;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
LPBYTE
SC_THGrow(
    THSNAP *pSnap,
    DWORD dwSize
    )
{
    LPBYTE lpRet = pSnap->pNextFree;

    if ((KERN_TRUST_FULL != pCurProc->bTrustLevel)
        && !SC_MapPtrWithSize (pSnap, sizeof (THSNAP), hCurProc)) {
        return NULL;
    }
    pSnap->pNextFree += dwSize;
    if (pSnap->pNextFree > pSnap->pHighReserve) {
        ERRORMSG(1,(L"THGrow: Not enough reservation for toolhelp!\r\n"));
        return 0;
    }
    if (pSnap->pNextFree > pSnap->pHighCommit) {
        DWORD cbCommit = (pSnap->pNextFree - pSnap->pHighCommit + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
        if ((KERN_TRUST_FULL != pCurProc->bTrustLevel)
            && !SC_MapPtrWithSize (pSnap->pHighCommit, cbCommit, hCurProc)) {
            return NULL;
        }
        if (!VirtualAlloc(pSnap->pHighCommit, cbCommit, MEM_COMMIT, PAGE_READWRITE))
            return 0;
        pSnap->pHighCommit = (LPBYTE)((DWORD)(pSnap->pNextFree + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1));
    }
    return lpRet;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL
THGetProcs(
    THSNAP *pSnap,
    BOOL bGetHeap