winhal.cpp

一个更为先进的嵌入式操作系统.采用RMS线程调度算法,具有信号量等同步对象.亦包括GUI. 通过该系统您可以极大知道Windows的内部秘密.

#include "..\gpmp.h"
#include "WinHal.h"
#include "SimDisplay.h"
#include "SimDisplay.h"

#include <stdio.h>
#include <crtdbg.h>
#include <stdarg.h>

#undef Sleep
#undef SwitchToThread

#define GlobalHeapSize (2<<20)

#define PAGE_READWRITE         0x04     
#define MEM_COMMIT           0x1000     
#define MEM_RELEASE          0x8000     
#define PRI_SWITCH 15 //1-15
#define PRI_NORMAL 0 //0

#define TH(pThread) HANDLE(*PDWORD(pThread->m_pStack))

static BOOL m_bIdle=FALSE;
static HANDLE m_evtSwitch;

CHAL* g_pHAL;
CDesktop* g_pDesktop=NULL;
HANDLE m_hMouseMsg;

//Win32API函数
extern "C"{

VOID __stdcall Sleep(DWORD dwMilliseconds);
DWORD __stdcall SuspendThread(HANDLE hThread);
DWORD __stdcall ResumeThread(HANDLE hThread);
BOOL __stdcall SetThreadPriority(HANDLE hThread,int nPriority);
BOOL __stdcall SwitchToThread(void);
PVOID __stdcall VirtualAlloc(PVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);
BOOL __stdcall VirtualFree(PVOID lpAddress,SIZE_T dwSize,DWORD dwFreeType);
DWORD __stdcall WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);
HANDLE __stdcall CreateEventA(PVOID lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName);
BOOL __stdcall SetEvent(HANDLE hEvent);
BOOL __stdcall ResetEvent(HANDLE hEvent);
BOOL __stdcall CloseHandle(HANDLE hObject);
BOOL __stdcall TerminateThread(HANDLE hThread,DWORD dwExitCode);
void __stdcall ExitThread(DWORD dwExitCode);
HANDLE __stdcall CreateThread(PVOID lpThreadAttributes,SIZE_T dwStackSize,PVOID lpStartAddress,PVOID lpParameter,DWORD dwCreationFlags,PDWORD lpThreadId);

}//extern "C"
#ifdef _DEBUG
#undef TRACE
void TRACE(LPCTSTR pszFormat,...)
{
	TCHAR szTrace[1024];
	va_list args;

	va_start(args,pszFormat);
	vsprintf(szTrace,pszFormat,args);
	_CrtDbgReport(0, NULL, 0, NULL, szTrace);
	va_end(args);
}
#endif

//#define TRACE(x)

extern "C" LRESULT HalMain(UINT message, WPARAM wParam, LPARAM lParam)
{
	/*
	CKernel kernel;
	CHAL hal;
	g_pKernel=&kernel;
	g_pHAL=&hal;

	初始化关键的中断或设备寄存器;
	初始化全局堆栈
	初始化驱动
	g_pKernel->Run();
	...
	*/
	switch(message)
	{
	case halCreate:{
		HANDLE hThread=::CreateThread(NULL,0,CHAL::RunGOS,0,CreateSuspend,NULL);
		TRACE("创建GOS内核线程0x%08x\r\n",hThread);
		m_evtSwitch=hThread;
		::ResumeThread(hThread);
		}break;
	case halMouseEvent:
		switch(wParam)
		{
		case 0x200: message=WM_MOUSEMOVE;break;
		case 0x201: message=WM_LBUTTONDOWN;break;
		case 0x202: message=WM_LBUTTONUP;break;
		}
		g_pDesktop->PulseMessageEvent(m_hMouseMsg,message,lParam);
		break;
	case halSetWallpaper:{
		g_pDesktop->SetWallpaper(PBITMAPFILEHEADER(wParam));
		}break;
	}
	return 0;
}

DWORD CHAL::RunGOS(PVOID pParam)
{
	CKernel kernel;
	CHAL hal;
	CSimDisplay sd;
	CPMPDesktop scr;

	g_pKernel=&kernel;
	g_pHAL=&hal;
	g_pDesktop=&scr;

	PDWORD pGlobalHeapStack=(PDWORD)::VirtualAlloc(0,GlobalHeapSize,MEM_COMMIT,PAGE_READWRITE);
	*pGlobalHeapStack=GlobalHeapSize-4;
	g_pKernel->CreateThread(pGlobalHeapStack+1);
	*PDWORD(kernel.m_pStack)=DWORD(m_evtSwitch);
	
	m_evtSwitch=::CreateEventA(NULL,FALSE,FALSE,NULL);
	HANDLE hThread=::CreateThread(NULL,0,SimSWI,0,CreateSuspend,NULL);
	::SetThreadPriority(hThread,PRI_SWITCH);
	::ResumeThread(hThread);

	scr.Create(g_pKernel,&sd,NULL,NULL);
	m_hMouseMsg=scr.SetMessageEvent(PriorityHighest);
	RunThread(g_pKernel);

	::CloseHandle(m_evtSwitch);
	::VirtualFree(pGlobalHeapStack,0,MEM_RELEASE);
	return 0;
}

DWORD CHAL::RunThread(PVOID pParam)
{
	PTHREAD pThread=PTHREAD(pParam);
	PDWORD pSP=PDWORD(pThread->m_pStack)-1;
	pParam=PVOID(*pSP);
	__asm
	{
		mov eax,pSP;
		mov pSP,esp;
		mov esp,eax;
	}
	pParam=(PVOID)pThread->Run(pParam);
	__asm
	{
		mov esp,pSP;
	}
	return DWORD(pParam);
}

DWORD CHAL::SimSWI(PVOID pParam)
{
	LONG nTime;
	for(;;)
	{
		if(m_bIdle)
		{
			//TRACE("HAL挂起线程0x%08x(0x%04x)\r\n",GetCurrentThread(),TH(GetCurrentThread()));
			SuspendThread(TH(GetCurrentThread()));
		}
		nTime=LONG(g_pKernel->GetSwitchTime()-GetTickCount());
		while(nTime>0)
		{
			::WaitForSingleObject(m_evtSwitch,nTime);
			nTime=g_pKernel->IsLockSwitch()?ThreadSwitchInterval:0;
		}
		if(m_bIdle)
		{
			::ResumeThread(TH(GetCurrentThread()));
		}
		g_pKernel->SwitchThread();
	}
	return 0;
}

void CHAL::CreateThread(CThread* pThread,PVOID pParam)
{
	/*
	sp=pThread->m_pStack;
	将所有寄存器入栈
	*/
	HANDLE hThread=::CreateThread(NULL,0,RunThread,pThread,CreateSuspend,NULL);
	::SetThreadPriority(hThread,PRI_NORMAL);
	*PDWORD(pThread->m_pStack)=DWORD(hThread);
	*(PDWORD(pThread->m_pStack)-1)=DWORD(pParam);
	TRACE("HAL创建线程0x%08x(0x%04x)\r\n",pThread,TH(pThread));
}

void CHAL::ExitThread(CThread* pThread)
{
	TRACE("HAL终止线程0x%08x(0x%04x)\r\n",pThread,TH(pThread));
	::TerminateThread(TH(pThread),pThread->GetLastError());
}

BOOL CHAL::SwitchThread(void)
{
	/*
	激活软中断，以调用切换函数
	*/

	::SetEvent(m_evtSwitch);
#if PRI_SWITCH-PRI_NORMAL<3
	::SwitchToThread();
#endif
	return TRUE;
}

void CHAL::SwitchThread(CThread* pFromThread,CThread* pToThread)
{
	/*
	将所有寄存器入栈
	pFromThread->m_pStack=sp;
	sp=pToThread;
	将所在寄存器出栈
	*/
	//TRACE("HAL切换线程0x%08x(0x%04x) -> 0x%08x(0x%04x)\r\n",pFromThread,TH(pFromThread),pToThread,TH(pToThread));
	::SuspendThread(TH(pFromThread));
	::ResumeThread(TH(pToThread));
}

void CHAL::OnSwitchThread(BOOL bIdle)
{
	/*计算下个换醒时间，配置唤醒定时器
	if(bIdle)
	{
		调用系统休眠函数，系统休眠
		...
		调用系统唤醒函数
	}
	//最后，定时器引发软中断，将调用g_pKernel->SwitchThread()
	*/
	m_bIdle=bIdle;
}

LRESULT CHAL::MsgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	return CMsgObject::MsgProc(message,wParam,lParam);
}