kmisc.c

可用于嵌入式编程学习

			(*ppNext)->procentry.th32ModuleID = 0;
			(*ppNext)->procentry.cntThreads = 0;
			for (pTh = ProcArray[loop].pTh; pTh; pTh = pTh->pNextInProc)
				(*ppNext)->procentry.cntThreads++;
			(*ppNext)->procentry.th32ParentProcessID = 0;
			(*ppNext)->procentry.pcPriClassBase = THREAD_PRIORITY_NORMAL;
			(*ppNext)->procentry.dwFlags = ProcArray[loop].ZonePtr ? ProcArray[loop].ZonePtr->ulZoneMask : 0;
			(*ppNext)->procentry.th32MemoryBase = ProcArray[loop].dwVMBase;
			(*ppNext)->procentry.th32AccessKey = ProcArray[loop].aky;
			kstrcpyW((*ppNext)->procentry.szExeFile,ProcArray[loop].lpszProcName);
			if (loop && bGetHeap) {
				pNextFree = pSnap->pNextFree;
				__try {
					cbi.hProc = ProcArray[loop].hProc;
					cbi.pfn = (FARPROC)pGetProcessHeap;
					cbi.pvArg0 = 0;
					(*ppNext)->procentry.th32DefaultHeapID = PerformCallBack4(&cbi);
					cbi.pfn = (FARPROC)pGetHeapSnapshot;
					cbi.pvArg0 = pSnap;
					if (!PerformCallBack4(&cbi,1,&(*ppNext)->pMainHeapEntry)) {
						(*ppNext)->procentry.th32DefaultHeapID = 0;
						(*ppNext)->pMainHeapEntry = 0;
						pSnap->pNextFree = pNextFree;
					}
				} __except (EXCEPTION_EXECUTE_HANDLER) {
					(*ppNext)->procentry.th32DefaultHeapID = 0;
					(*ppNext)->pMainHeapEntry = 0;
					pSnap->pNextFree = pNextFree;
				}
			} else {
				(*ppNext)->procentry.th32DefaultHeapID = 0;
				(*ppNext)->pMainHeapEntry = 0;
			}
			ppNext = &(*ppNext)->pNext;
		}
	}
	*ppNext = 0;
	return TRUE;
}

BOOL THGetMods(THSNAP *pSnap, DWORD dwProcID) {
	TH32MOD **ppNext;
	PMODULE pMod;
	PPROCESS pProc;
	DWORD loop;
	ppNext = &pSnap->pMod;
	if (dwProcID && !(pProc = HandleToProc((HANDLE)dwProcID)))
		return FALSE;
	for (pMod = pModList; pMod; pMod = pMod->pMod) {
		if (dwProcID && !HasModRefProcPtr(pMod,pProc))
			continue;
		if (!(*ppNext = (TH32MOD *)THGrow(pSnap,sizeof(TH32MOD))))
			return FALSE;
		(*ppNext)->modentry.dwSize = sizeof(MODULEENTRY32);
		(*ppNext)->modentry.th32ModuleID = (DWORD)pMod;
		(*ppNext)->modentry.th32ProcessID = dwProcID;
		(*ppNext)->modentry.GlblcntUsage = 0;
		for (loop = 0; loop < MAX_PROCESSES; loop++)
			(*ppNext)->modentry.GlblcntUsage += pMod->refcnt[loop];
		(*ppNext)->modentry.ProccntUsage = dwProcID ? pMod->refcnt[pProc->procnum] : pMod->inuse;
		(*ppNext)->modentry.modBaseAddr = (LPBYTE)ZeroPtr(pMod->BasePtr);
		(*ppNext)->modentry.modBaseSize = pMod->e32.e32_vsize;
		(*ppNext)->modentry.hModule = (HMODULE)pMod;
		(*ppNext)->modentry.dwFlags = pMod->ZonePtr ? pMod->ZonePtr->ulZoneMask : 0;
		kstrcpyW((*ppNext)->modentry.szModule,pMod->lpszModName);
		(*ppNext)->modentry.szExePath[0] = 0;
		ppNext = &(*ppNext)->pNext;
	}
	*ppNext = 0;
	return TRUE;
}

BOOL THGetThreads(THSNAP *pSnap) {
	TH32THREAD **ppNext;
	PTHREAD pTh;
	DWORD loop;
	ppNext = &pSnap->pThread;
	for (loop = 0; loop < MAX_PROCESSES; loop++) {
		if (ProcArray[loop].dwVMBase && (!loop || ProcStarted(&ProcArray[loop]))) {
			for (pTh = ProcArray[loop].pTh; pTh; pTh = pTh->pNextInProc) {
				if (!(*ppNext = (TH32THREAD *)THGrow(pSnap,sizeof(TH32THREAD))))
					return FALSE;
				(*ppNext)->threadentry.dwSize = sizeof(THREADENTRY32);
				(*ppNext)->threadentry.cntUsage = 1;
				(*ppNext)->threadentry.th32ThreadID = (DWORD)pTh->hTh;
				(*ppNext)->threadentry.th32OwnerProcessID = (DWORD)ProcArray[loop].hProc;
				(*ppNext)->threadentry.tpBasePri = GET_BPRIO(pTh);
				(*ppNext)->threadentry.tpDeltaPri = GET_BPRIO(pTh) - GET_CPRIO(pTh);
				(*ppNext)->threadentry.dwFlags = GET_SLEEPING(pTh) ? 4 + (pTh->lpProxy != 0) + (pTh->bSuspendCnt != 0) * 2 : GET_RUNSTATE(pTh);
				(*ppNext)->threadentry.th32CurrentProcessID = (DWORD)pTh->pProc->hProc;
				(*ppNext)->threadentry.th32AccessKey = pTh->aky;
				ppNext = &(*ppNext)->pNext;
			}
		}
	}
	*ppNext = 0;
	return TRUE;
}

BOOL THGetHeaps(THSNAP *pSnap, DWORD dwProcID) {
	CALLBACKINFO cbi;
	LPBYTE pNextFree = pSnap->pNextFree;
	if ((HANDLE)dwProcID == ProcArray[0].hProc)
		pSnap->pHeap = 0;
	else {
		__try {
			cbi.hProc = (HANDLE)dwProcID;
			cbi.pfn = (FARPROC)pGetHeapSnapshot;
			cbi.pvArg0 = pSnap;
			if (!PerformCallBack4(&cbi,0,&pSnap->pHeap))
				return FALSE;
		} __except (EXCEPTION_EXECUTE_HANDLER) {
			pSnap->pNextFree = pNextFree;
			pSnap->pHeap = 0;
		}
	}
	return TRUE;
}

THSNAP *SC_THCreateSnapshot(DWORD dwFlags, DWORD dwProcID) {
    ACCESSKEY ulOldKey;
	THSNAP *pSnap;
	if (!dwProcID || (dwProcID == (DWORD)GetCurrentProcess()))
		dwProcID = (DWORD)hCurProc;
	else if (GetHandleType((HANDLE)dwProcID) != SH_CURPROC) {
		SetLastError(ERROR_INVALID_PARAMETER);
		return INVALID_HANDLE_VALUE;
	}
	if (!(pSnap = VirtualAlloc(0, THSNAP_RESERVE, MEM_RESERVE, PAGE_NOACCESS))) {
		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
		return INVALID_HANDLE_VALUE;
	}
	pSnap = MapPtr(pSnap);
	if (!VirtualAlloc(pSnap,PAGE_SIZE, MEM_COMMIT, PAGE_READWRITE)) {
		VirtualFree(pSnap,0,MEM_RELEASE);
		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
		return INVALID_HANDLE_VALUE;
	}
	pSnap->pNextFree = (LPBYTE)pSnap + sizeof(THSNAP);
	pSnap->pHighCommit = (LPBYTE)pSnap + PAGE_SIZE;
	pSnap->pHighReserve = (LPBYTE)pSnap + THSNAP_RESERVE;
    SWITCHKEY(ulOldKey,0xffffffff);
	EnterCriticalSection(&LLcs);
	if (((dwFlags & TH32CS_SNAPPROCESS) && !THGetProcs(pSnap,(dwFlags & TH32CS_SNAPNOHEAPS ? 0 : 1))) ||
		((dwFlags & TH32CS_SNAPMODULE) && !THGetMods(pSnap,(dwFlags & TH32CS_GETALLMODS) ? 0 : dwProcID)) ||
		((dwFlags & TH32CS_SNAPTHREAD) && !THGetThreads(pSnap)) ||
		((dwFlags & TH32CS_SNAPHEAPLIST) && !THGetHeaps(pSnap,dwProcID))) {
		VirtualFree(pSnap,THSNAP_RESERVE,MEM_DECOMMIT);
		VirtualFree(pSnap,0,MEM_RELEASE);
		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
		pSnap = INVALID_HANDLE_VALUE;
	}
	LeaveCriticalSection(&LLcs);
	SETCURKEY(ulOldKey);
	return pSnap;
}

DWORD SC_GetProcessVersion(DWORD dwProcessId) {
	PPROCESS pProc;
	if (!dwProcessId)
		pProc = pCurProc;
	else if (!(pProc = HandleToProc((HANDLE)dwProcessId))) {
		SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
	}
	return MAKELONG(pProc->e32.e32_ceverminor,pProc->e32.e32_cevermajor);
}

BOOL SC_SetStdioPathW(DWORD id, LPCWSTR pwszPath) {
	LPName pName, pName2;
	DWORD len;
	if ((id >= 3) || (pwszPath && ((len = strlenW(pwszPath)) > MAX_PATH-1))) {
		KSetLastError(pCurThread,ERROR_INVALID_PARAMETER);
		return FALSE;
	}
	if (pwszPath) {
		if (!(pName = AllocName(sizeof(WCHAR)*(len+1)))) {
			KSetLastError(pCurThread,ERROR_OUTOFMEMORY);
			return FALSE;
		}
		memcpy(pName->name,pwszPath,sizeof(WCHAR)*(len+1));
	} else
		pName = 0;
	EnterCriticalSection(&NameCS);
	pName2 = pCurProc->pStdNames[id];
	pCurProc->pStdNames[id] = pName;
	LeaveCriticalSection(&NameCS);
	if (pName2)
		FreeName(pName2);
	return TRUE;
}

BOOL SC_GetStdioPathW(DWORD id, PWSTR pwszBuf, LPDWORD lpdwLen) {
	DWORD len;
	Name name;
	if (id >= 3) {
		KSetLastError(pCurThread,ERROR_INVALID_PARAMETER);
		return FALSE;
	}
	LockPages(&name,sizeof(name),0,LOCKFLAG_WRITE);
	EnterCriticalSection(&NameCS);
	if (!(pCurProc->pStdNames[id]))
		len = 0;
	else {
		len = strlenW(pCurProc->pStdNames[id]->name)+1;
		memcpy(name.name,pCurProc->pStdNames[id]->name,sizeof(WCHAR)*len);
	}
	LeaveCriticalSection(&NameCS);
	UnlockPages(&name,sizeof(name));
	if (*lpdwLen < len) {
		*lpdwLen = len;
		KSetLastError(pCurThread,ERROR_INSUFFICIENT_BUFFER);
		return FALSE;
	}
	*lpdwLen = len;
	memcpy(pwszBuf,name.name,sizeof(WCHAR)*len);
	return TRUE;
}

BOOL (*pQueryPerformanceCounter)(LARGE_INTEGER *lpPerformanceCount);
BOOL (*pQueryPerformanceFrequency)(LARGE_INTEGER *lpPerformanceFrequency);

BOOL SC_QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount) {
	if (pQueryPerformanceCounter)
		return pQueryPerformanceCounter(lpPerformanceCount);
	lpPerformanceCount->HighPart = 0;
	lpPerformanceCount->LowPart = CurMSec;
	return TRUE;
}

BOOL SC_QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency) {
	if (pQueryPerformanceFrequency)
		return pQueryPerformanceFrequency(lpFrequency);
	lpFrequency->HighPart = 0;
	lpFrequency->LowPart = 1000;
	return TRUE;
}

DWORD (*pReadRegistryFromOEM)(DWORD dwFlags, LPBYTE pBuf, DWORD len);
BOOL (*pWriteRegistryToOEM)(DWORD dwFlags, LPBYTE pBuf, DWORD len);

DWORD SC_ReadRegistryFromOEM(DWORD dwFlags, LPBYTE pBuf, DWORD len) {
	if (pReadRegistryFromOEM)
		return pReadRegistryFromOEM(dwFlags, pBuf, len);
	return 0;
}

BOOL SC_WriteRegistryToOEM(DWORD dwFlags, LPBYTE pBuf, DWORD len) {
	if (dwFlags == REG_WRITE_BYTES_PROBE)
		return (pWriteRegistryToOEM ? TRUE : FALSE);
	if (pWriteRegistryToOEM)
		return pWriteRegistryToOEM(dwFlags, pBuf, len);
	return 0;
}

DWORD SC_GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSize) {
	PPROCESS pProc;
	openexe_t *oe;
	CEOIDINFO ceoi;
	LPWSTR pstr;
	int loop;
	if (!nSize) {
		SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
	}
	if (!hModule)
		oe = &pCurProc->oe;
	else if (pProc = HandleToProc((HANDLE)hModule))
		oe = &pProc->oe;
	else if (IsValidModule((PMODULE)hModule))
		oe = &(((LPMODULE)hModule)->oe);
	else {
		SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
	}
	if (!GetNameFromOE(&ceoi,oe)) {
		SetLastError(ERROR_INVALID_PARAMETER);
		return 0;
	}
	for (pstr = ceoi.infFile.szFileName, loop = 1; (loop < (int)nSize) && *pstr; loop++)
		*lpFilename++ = *pstr++;
	*lpFilename = 0;
	return loop-1;
}

void SC_CacheSync(int flags) {
#if defined(SH3)
	if ((flags & CACHE_SYNC_WRITEBACK) && !(flags & (CACHE_SYNC_DISCARD)))
		FlushCacheNoDiscard();
	else
		FlushCache();
#elif defined(x86)
	FlushCache();
#else
	FlushDCache();
	if (flags & (CACHE_SYNC_INSTRUCTIONS | CACHE_SYNC_DISCARD))
		FlushICache();
#endif
}

void SC_RegisterGwesHandler(LPVOID pfn) {
	pGwesHandler = pfn;
}

VOID xxx_RaiseException(DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD cArgs, CONST DWORD *lpArgs) {
	RaiseException(dwExceptionCode, dwExceptionFlags, cArgs, lpArgs);
}

void DoMapPtr(LPVOID *P) {
	if (((DWORD)*P >= 0x10000) && !((DWORD)*P >> VA_SECTION))
		*P = (LPVOID)((DWORD)*P | (DWORD)pCurProc->dwVMBase);
}
#define MapArgPtr(P) DoMapPtr((LPVOID *)&(P))

const CINFO *SwitchToProc(PCALLSTACK pcstk, DWORD dwAPISet) {
	const CINFO *pci;
	if (!(pci = SystemAPISets[dwAPISet]))
        RaiseException(STATUS_INVALID_SYSTEM_SERVICE, EXCEPTION_NONCONTINUABLE, 0, 0);
    pcstk->pprcLast = pCurProc;
    pcstk->akyLast = CurAKey;
    pcstk->retAddr = 0;
    pcstk->pcstkNext = pCurThread->pcstkTop;
    pCurThread->pcstkTop = pcstk;
	pCurThread->pProc = pci->pServer;
	AddAccess(&pCurThread->aky, pci->pServer->aky);
	SetCPUASID(pCurThread);
	randdw1 = ((randdw1<<5) | (randdw1>>27)) ^ (CurMSec & 0x1f);
	return pci;
}

const CINFO *SwitchToProcHandle(PCALLSTACK pcstk, HANDLE *ph, DWORD dwType) {
	const CINFO *pci;
    const HDATA *phd;
    phd = HandleToPointer(*ph);
    if (!phd || !TestAccess(&phd->lock, &pCurThread->aky))
    	return 0;
    pci = phd->pci;
    if (pci->type != dwType)
		return 0;
	*ph = (HANDLE)phd->pvObj;
    pcstk->pprcLast = pCurProc;
    pcstk->akyLast = CurAKey;
    pcstk->retAddr = 0;
    pcstk->pcstkNext = pCurThread->pcstkTop;
    pCurThread->pcstkTop = pcstk;
	pCurThread->pProc = pci->pServer;
	AddAccess(&pCurThread->aky, pci->pServer->aky);
	SetCPUASID(pCurThread);
	randdw1 = ((randdw1<<5) | (randdw1>>27)) ^ (CurMSec & 0x1f);
	return pci;
}

extern BOOL TryCloseMappedHandle(HANDLE h);

const CINFO *SwitchToProcHandleClosing(PCALLSTACK pcstk, HANDLE *ph, LPBOOL bRet) {
	const CINFO *pci;
    const HDATA *phd;
    HANDLE hVal;
    phd = HandleToPointer(*ph);
    if (!phd)
    	return 0;
    pci = phd->pci;
    if (!TestAccess(&phd->lock, &pCurProc->aky)) {
	    if ((phd->lock == 1) && (phd->ref.count == 1)) {
	    	*bRet = TryCloseMappedHandle(*ph);
			return 0;
		}
		return 0;
	}
	if (pci->disp == DISPATCH_KERNEL_PSL) {
		*bRet = (*(BOOL (*)(HANDLE))(pci->ppfnMethods[0]))(*ph);
		return 0;
	}
	hVal = (HANDLE)phd->pvObj;
	if (DecRef(*ph, pCurProc, FALSE))
		FreeHandle(*ph);
	*ph = hVal;
    pcstk->pprcLast = pCurProc;
    pcstk->akyLast = CurAKey;
    pcstk->retAddr = 0;
    pcstk->pcstkNext = pCurThread->pcstkTop;
    pCurThread->pcstkTop = pcstk;
	pCurThread->pProc = pci->pServer;
	AddAccess(&pCurThread->aky, pci->pServer->aky);
	SetCPUASID(pCurThread);
	randdw1 = ((randdw1<<5) | (randdw1>>27)) ^ (CurMSec & 0x1f);
	return pci;
}

void SwitchBack() {
	PCALLSTACK pcstk;
	pcstk = pCurThread->pcstkTop;
	pCurThread->pcstkTop = pcstk->pcstkNext;
	SETCURKEY(pcstk->akyLast);
	pCurThread->pProc = pcstk->pprcLast;
    SetCPUASID(pCurThread);
}

DWORD PerformCallBack4Int(CALLBACKINFO *pcbi, LPVOID p2, LPVOID p3, LPVOID p4) {
	CALLSTACK cstk, *pcstk;
	DWORD dwRet, dwFault = 0;
	PPROCESS pProc;
	if (!(pProc = HandleToProc(pcbi->hProc))) {
        RaiseException(STATUS_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
        return 0;
	}
    cstk.pprcLast = pCurProc;
    cstk.akyLast = CurAKey;
    cstk.retAddr = 0;
    cstk.pcstkNext = pCurThread->pcstkTop;
    pCurThread->pProc = pProc;
    pCurThread->pcstkTop = &cstk;
    if (pProc != &ProcArray[0]) {
	    pcstk = &cstk;
	    while ((pcstk = (PCALLSTACK)((ulong)pcstk->pcstkNext&~1)) && (pcstk->pprcLast != pProc))
	       	;
	    if (pcstk)