kwin32.h

WinCE5.0部分核心源码

BOOL   SC_CeDuplicateToken (HANDLE hTok, DWORD dwFlags, PHANDLE phRet);


void SC_UpdateNLSInfo(DWORD ocp, DWORD acp, DWORD sysloc, DWORD userloc);
void SC_DebugNotify(DWORD dwFlags, DWORD data);
__int64 SC_CeGetRandomSeed();

BOOL SC_GetKPhys(void *ptr, ULONG length);
BOOL SC_GiveKPhys(void *ptr, ULONG length);
void SC_SetExceptionHandler(PEXCEPTION_ROUTINE per);
void SC_SetKernelAlarm(HANDLE hEvent, LPSYSTEMTIME lpst);
void SC_RefreshKernelAlarm(void);
void SC_CloseProcOE(DWORD);
void SC_SetGwesOOMEvent(HANDLE hEvent, DWORD cpLow, DWORD cpCritical,
                        DWORD cpLowBlockSize, DWORD cpCriticalBlockSize);
void SC_CacheRangeFlush (LPVOID pAddr, DWORD dwLength, DWORD dwFlags);
DWORD SC_FSStringCompress(LPBYTE bufin, DWORD lenin, LPBYTE bufout, DWORD lenout);
DWORD SC_FSStringDecompress(LPBYTE bufin, DWORD lenin, LPBYTE bufout, DWORD lenout);
DWORD SC_FSBinaryCompress(LPBYTE bufin, DWORD lenin, LPBYTE bufout, DWORD lenout);
DWORD SC_FSBinaryDecompress(LPBYTE bufin, DWORD lenin, LPBYTE bufout, DWORD lenout, DWORD skip);
DWORD SC_DecompressBinaryBlock( LPBYTE lpbSrc, DWORD cbSrc, LPBYTE  lpbDest, DWORD cbDest);
void UB_TakeCritSec(LPCRITICAL_SECTION lpcs);
void SC_TakeCritSec(LPCRITICAL_SECTION lpcs);
void SC_LeaveCritSec(LPCRITICAL_SECTION lpcs);
DWORD UB_WaitForMultiple(DWORD cObjects, CONST HANDLE *lphObjects, BOOL fWaitAll, DWORD dwTimeout);
DWORD SC_WaitForMultiple(DWORD cObjects, CONST HANDLE *lphObjects, BOOL fWaitAll, DWORD dwTimeout);
LPVOID SC_MapPtrToProcess(LPVOID lpv, HANDLE hProc);
LPVOID SC_MapPtrUnsecure(LPVOID lpv, HANDLE hProc);
HANDLE SC_GetProcFromPtr(LPVOID lpv);
BOOL SC_IsBadPtr(DWORD flags, LPBYTE ptr, DWORD length);
DWORD SC_GetProcAddrBits(HANDLE hProc);
DWORD SC_GetFSHeapInfo(void);
BOOL SC_OtherThreadsRunning(void);
void SC_KillAllOtherThreads(void);
void SC_KillThreadIfNeeded(void);
HANDLE SC_GetOwnerProcess(void);
HANDLE SC_GetCallerProcess(void);
DWORD SC_CeGetCurrentTrust(void);
DWORD SC_CeGetCallerTrust(void);
DWORD SC_GetIdleTime(void);
DWORD SC_SetLowestScheduledPriority(DWORD);
BOOL SC_IsPrimaryThread(void);
DWORD SC_SetProcPermissions(DWORD);
DWORD SC_GetCurrentPermissions(void);
void SC_SetTimeZoneBias(DWORD dwBias, DWORD dwDaylightBias);
void SC_SetDaylightTime(DWORD dst);
void SC_SetCleanRebootFlag(void);
HANDLE SC_CreateCrit(LPCRITICAL_SECTION lpcs);
void SC_PowerOffSystem(void);
BOOL SC_SetDbgZone(DWORD pid, LPVOID lpvMod, LPVOID baseptr, DWORD zone, LPDBGPARAM lpdbgTgt);
void SC_Sleep(DWORD dwMilliseconds);
void UB_Sleep(DWORD dwMilliseconds);
void UB_SleepTillTick (void);
BOOL SC_DuplicateHandle(HANDLE hSrcProc, HANDLE hSrcHndl, HANDLE hDstProc, LPHANDLE lpDstHndl, DWORD dwAccess, BOOL bInherit, DWORD dwOptions);
void SC_TurnOnProfiling(void);
void SC_TurnOffProfiling(void);
void SC_SetLastError(DWORD dwErr);
DWORD SC_GetLastError(void);
LPCWSTR SC_GetProcName(void);
void SC_TerminateSelf(void);
void SC_CloseAllHandles(void);
BOOL SC_SetHandleOwner(HANDLE h, HANDLE hProc);
HANDLE SC_CreateFileMapping(HANDLE hFile, LPSECURITY_ATTRIBUTES lpsa, DWORD flProtect, DWORD dwMaxSizeHigh,
    DWORD dwMaxSizeLow, LPCTSTR lpName);
LPVOID SC_MapViewOfFile(HANDLE hMap, DWORD fdwAccess, DWORD dwOffsetLow, DWORD dwOffsetHigh, DWORD cbMap);
BOOL SC_UnmapViewOfFile(LPVOID lpvAddr);
BOOL SC_FlushViewOfFile(LPCVOID lpBaseAddress, DWORD dwNumberOfBytesToFlush);
BOOL SC_FlushViewOfFileMaybe(LPCVOID lpBaseAddress, DWORD dwNumberOfBytesToFlush);
HANDLE SC_CreateFileForMapping(LPCTSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
    LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes,
    HANDLE hTemplateFile);
BOOL OEMIoControl(DWORD dwIoControlCode, LPVOID lpInBuf, DWORD nInBufSize,
    LPVOID lpOutBuf, DWORD nOutBufSize, LPDWORD lpBytesReturned);
void SC_NotifyForceCleanboot(void);
DWORD SC_ReadRegistryFromOEM(DWORD dwFlags, LPBYTE pBuf, DWORD len);
BOOL SC_WriteRegistryToOEM(DWORD dwFlags, LPBYTE pBuf, DWORD len);

BOOL SC_ThreadCloseHandle(HANDLE hTh);
DWORD SC_ThreadSuspend(HANDLE hTh);
DWORD UB_ThreadSuspend(HANDLE hTh);
DWORD SC_ThreadResume(HANDLE hTh);
BOOL SC_ThreadSetPrio(HANDLE hTh, DWORD prio);
int SC_ThreadGetPrio(HANDLE hTh);
BOOL SC_ThreadGetCode(HANDLE hTh, LPDWORD dwExit);
BOOL SC_ThreadGetContext(HANDLE hTh, LPCONTEXT lpContext);
BOOL SC_ThreadSetContext(HANDLE hTh, const CONTEXT *lpContext);
BOOL SC_ThreadTerminate(HANDLE hTh, DWORD dwExitCode);

BOOL SC_ProcCloseHandle(HANDLE hProc);
BOOL SC_ProcTerminate(HANDLE hProc, DWORD dwExitCode);
LPCHAR SC_ProcGetName(HANDLE hProc);
BOOL SC_ProcGetCode(HANDLE hProc, LPDWORD dwExit);
DWORD SC_ProcGetIndex(HANDLE hProc);
HANDLE SC_ProcGetIDFromIndex(DWORD dwIdx);

BOOL SC_ProcFlushICache(HANDLE hProc, LPCVOID lpBaseAddress, DWORD dwSize);
BOOL SC_ProcReadMemory(HANDLE hProcess, LPCVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead);
BOOL SC_ProcWriteMemory(HANDLE hProcess, LPVOID lpBaseAddress, LPVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesWritten);

BOOL SC_WaitForDebugEvent(LPDEBUG_EVENT lpDebugEvent, DWORD dwMilliseconds);
BOOL SC_ContinueDebugEvent(DWORD dwProcessId, DWORD dwThreadId, DWORD dwContinueStatus);
BOOL SC_ProcDebug(DWORD dwProcessId);

BOOL SC_EventCloseHandle(HANDLE hEvent);
BOOL SC_EventModify(HANDLE hEvent, DWORD action);
BOOL SC_EventAddAccess(HANDLE hEvent);

BOOL SC_EventSetData (HANDLE hEvent, DWORD dwData);
DWORD SC_EventGetData (HANDLE hEvent);

BOOL SC_MutexCloseHandle(HANDLE hMutex);
BOOL SC_ReleaseMutex(HANDLE hMutex);
BOOL SC_SemCloseHandle(HANDLE hSem);
BOOL SC_ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);

BOOL SC_ConnectDebugger(LPVOID pInit);
BOOL SC_ConnectHdstub(LPVOID pInit);
BOOL SC_ConnectOsAxsT0(LPVOID pInit);
BOOL SC_ConnectOsAxsT1(LPVOID pInit);

BOOL SC_InterruptInitialize(DWORD idInt, HANDLE hEvent, LPVOID pvData, DWORD cbData);
void SC_InterruptDone(DWORD idInt);
void SC_InterruptDisable(DWORD idInt);
void SC_InterruptMask (DWORD idInt, BOOL fDisable);

BOOL SC_SetKMode(BOOL bPriv);
BOOL SC_SetRAMMode(BOOL bEnable, LPVOID *lplpvAddress, LPDWORD lpLength);
LPVOID SC_SetStoreQueueBase(DWORD dwPhysPage);
BOOL SC_SetPowerOffHandler(FARPROC pfn);
BOOL SC_SetGwesPowerHandler(FARPROC pfn);
BOOL SC_SetWDevicePowerHandler(FARPROC pfn);
BOOL SC_SetHardwareWatch(LPVOID vAddr, DWORD flags);
int SC_QueryAPISetID(char *pName);
void CaptureContext(void);

DWORD SC_GetCallerIndex(void);
HANDLE SC_OpenProcess(DWORD fdwAccess, BOOL fInherit, DWORD IDProcess);
THSNAP *SC_THCreateSnapshot(DWORD dwFlags, DWORD dwProcID);
LPBYTE SC_THGrow(THSNAP *pSnap, DWORD dwSize);
void SC_DumpKCallProfile(DWORD bReset);
BOOL SC_SetStdioPathW(DWORD id, LPCWSTR pwszPath);
BOOL SC_GetStdioPathW(DWORD id, PWSTR pwszBuf, LPDWORD lpdwLen);

LPVOID SC_MapCallerPtr (LPVOID ptr, DWORD dwLen);

LPVOID SC_MapPtrWithSize (LPVOID ptr, DWORD dwLen, HANDLE hProc);

ULONG SC_GetThreadCallStack (HANDLE hThrd, ULONG dwMaxFrames, LPVOID lpFrames, DWORD dwFlags, DWORD dwSkip);

void SC_CeLogData(BOOL fTimeStamp, WORD wID, VOID *pData, WORD wLen,
                  DWORD dwZoneUser, DWORD dwZoneCE, WORD wFlag, BOOL fFlagged);
void SC_CeLogSetZones(DWORD dwZoneUser, DWORD dwZoneCE, DWORD dwZoneProcess);
BOOL SC_CeLogGetZones(LPDWORD lpdwZoneUser, LPDWORD lpdwZoneCE,
                      LPDWORD lpdwZoneProcess, LPDWORD lpdwAvailableZones);
BOOL SC_CeLogReSync();

BOOL SC_FreeModFromCurrProc (PDLLMAININFO pList, DWORD nMods);
BOOL SC_GetProcModList (PDLLMAININFO pList, DWORD dwCnt);

#ifdef __cplusplus
};
#endif  /* __cplusplus */