?? shell.cpp
字號:
{
__KERNEL_THREAD_OBJECT* lpSysDiagThread = NULL;
lpSysDiagThread = KernelThreadManager.CreateKernelThread(
(__COMMON_OBJECT*)&KernelThreadManager,
0L,
KERNEL_THREAD_STATUS_READY,
PRIORITY_LEVEL_NORMAL,
SysDiagStart,
NULL,
NULL,
"SYS DIAG");
if(NULL == lpSysDiagThread) //Can not create the kernel thread.
{
PrintLine("Can not start system diag application,please retry again.");
return;
}
DeviceInputManager.SetFocusThread((__COMMON_OBJECT*)&DeviceInputManager,
(__COMMON_OBJECT*)lpSysDiagThread);
lpSysDiagThread->WaitForThisObject((__COMMON_OBJECT*)lpSysDiagThread);
KernelThreadManager.DestroyKernelThread((__COMMON_OBJECT*)&KernelThreadManager,
(__COMMON_OBJECT*)lpSysDiagThread); //Destroy the kernel thread object.
}
static __MUTEX* lpMutexObj = NULL;
static DWORD ProduceRoutine(LPVOID)
{
DWORD dwCounter = 2;
while(TRUE)
{
KernelThreadManager.Sleep((__COMMON_OBJECT*)&KernelThreadManager,
2000);
lpMutexObj->ReleaseMutex((__COMMON_OBJECT*)lpMutexObj);
dwCounter --;
if(dwCounter == 0)
{
break;
}
}
PrintLine("Produce kernel thread run over.");
DestroyMutex((__COMMON_OBJECT*)lpMutexObj); //DestroyMutex.
return 0L;
}
static DWORD ConsumerRoutine1(LPVOID)
{
DWORD dwResult;
while(TRUE)
{
dwResult = lpMutexObj->WaitForThisObjectEx((__COMMON_OBJECT*)lpMutexObj,
500);
switch(dwResult)
{
case OBJECT_WAIT_RESOURCE:
PrintLine("Consumer1 --> OK,resource is available.");
break;
case OBJECT_WAIT_TIMEOUT:
PrintLine("Consumer1 --> Waiting time out...");
break;
case OBJECT_WAIT_DELETED:
PrintLine("Consumer1 --> Produce kernel thread is over,exit.");
return 0L;
default:
BUG();
}
//lpEventObj->ResetEvent((__COMMON_OBJECT*)lpEventObj); //Reset event.
}
return 0L;
}
static DWORD ConsumerRoutine2(LPVOID)
{
DWORD dwResult;
while(TRUE)
{
dwResult = lpMutexObj->WaitForThisObjectEx((__COMMON_OBJECT*)lpMutexObj,
800);
switch(dwResult)
{
case OBJECT_WAIT_RESOURCE:
PrintLine("Consumer2 --> OK,resource is available.");
break;
case OBJECT_WAIT_TIMEOUT:
PrintLine("Consumer2 --> Waiting time out...");
break;
case OBJECT_WAIT_DELETED:
PrintLine("Consumer2 --> Produce kernel thread is over,exit.");
return 0L;
default:
BUG();
}
//lpEventObj->ResetEvent((__COMMON_OBJECT*)lpEventObj); //Reset event.
}
return 0L;
}
static DWORD ConsumerRoutine3(LPVOID)
{
DWORD dwResult;
while(TRUE)
{
dwResult = lpMutexObj->WaitForThisObjectEx((__COMMON_OBJECT*)lpMutexObj,
1000);
switch(dwResult)
{
case OBJECT_WAIT_RESOURCE:
PrintLine("Consumer3 --> OK,resource is available.");
break;
case OBJECT_WAIT_TIMEOUT:
PrintLine("Consumer3 --> Waiting time out...");
break;
case OBJECT_WAIT_DELETED:
PrintLine("Consumer3 --> Produce kernel thread is over,exit.");
return 0L;
default:
BUG();
}
//lpEventObj->ResetEvent((__COMMON_OBJECT*)lpEventObj); //Reset event.
}
return 0L;
}
VOID UnTestHandler(LPSTR)
{
__KERNEL_THREAD_OBJECT* lpProduce;
__KERNEL_THREAD_OBJECT* lpConsumer1;
__KERNEL_THREAD_OBJECT* lpConsumer2;
__KERNEL_THREAD_OBJECT* lpConsumer3;
lpMutexObj = (__MUTEX*)CreateMutex(); //Create event object.
if(NULL == lpMutexObj)
{
PrintLine("Can not create Mutex object.");
return;
}
lpProduce = KernelThreadManager.CreateKernelThread((__COMMON_OBJECT*)&KernelThreadManager,
0L,
KERNEL_THREAD_STATUS_READY,
PRIORITY_LEVEL_NORMAL,
ProduceRoutine,
NULL,
NULL,
"Produce");
if(NULL == lpProduce)
{
PrintLine("Can not create produce kernel thread.");
return;
}
lpConsumer1 = KernelThreadManager.CreateKernelThread((__COMMON_OBJECT*)&KernelThreadManager,
0L,
KERNEL_THREAD_STATUS_READY,
PRIORITY_LEVEL_NORMAL,
ConsumerRoutine1,
NULL,
NULL,
"CONS1");
if(NULL == lpConsumer1)
{
PrintLine("Can not create consumer1 kernel thread.");
return;
}
lpConsumer2 = KernelThreadManager.CreateKernelThread((__COMMON_OBJECT*)&KernelThreadManager,
0L,
KERNEL_THREAD_STATUS_READY,
PRIORITY_LEVEL_NORMAL,
ConsumerRoutine2,
NULL,
NULL,
"CONS2");
if(NULL == lpConsumer2)
{
PrintLine("Can not create consumer2 kernel thread.");
return;
}
lpConsumer3 = KernelThreadManager.CreateKernelThread((__COMMON_OBJECT*)&KernelThreadManager,
0L,
KERNEL_THREAD_STATUS_READY,
PRIORITY_LEVEL_NORMAL,
ConsumerRoutine3,
NULL,
NULL,
"CONS3");
if(NULL == lpConsumer3)
{
PrintLine("Can not create consumer3 kernel thread.");
return;
}
lpProduce->WaitForThisObject((__COMMON_OBJECT*)lpProduce);
lpConsumer1->WaitForThisObject((__COMMON_OBJECT*)lpConsumer1);
lpConsumer2->WaitForThisObject((__COMMON_OBJECT*)lpConsumer2);
lpConsumer3->WaitForThisObject((__COMMON_OBJECT*)lpConsumer3);
}
VOID RunTimeHandler(LPSTR)
{
DWORD dwTime = System.GetClockTickCounter((__COMMON_OBJECT*)&System);
BYTE Buffer[12];
dwTime /= SYSTEM_TIME_SLICE;
PrintLine("The system has running ");
Int2Str(dwTime,Buffer);
PrintStr(Buffer);
PrintStr(" second(s).");
}
VOID ClsHandler(LPSTR)
{
ClearScreen();
}
VOID VerHandler(LPSTR)
{
GotoHome();
ChangeLine();
PrintStr(VERSION_INFO);
}
VOID MemHandler(LPSTR)
{
PrintLine("------------------ ** memory layout ** ------------------");
PrintLine(" 0x00000000 - 0x000FFFFF Hardware buffer ");
PrintLine(" 0x00100000 - 0x0010FFFF Mini-kernal ");
PrintLine(" 0x00110000 - 0x013FFFFF Master(OS Kernal) ");
PrintLine(" 0x01400000 - 0xFFFFFFFF User Space ");
}
LPSTR strHdr[] = { //I have put the defination of this strings
//in the function SysInfoHandler,but it do
//not work,see the asm code,it generates the
//incorrect asm code!Fuck Bill Gates!.
" EDI : 0x",
" ESI : 0x",
" EBP : 0x",
" ESP : 0x",
" EBX : 0x",
" EDX : 0x",
" ECX : 0x",
" EAX : 0x",
" CS-DS : 0x",
" FS-GS : 0x",
" ES-SS : 0x"};
static BYTE Buffer[] = {"Hello,China!"};
VOID SysInfoHandler(LPSTR)
{
DWORD sysContext[11];
#ifdef __I386__
__asm{ //Get the system information.
pushad //Save all the general registers.
//NOTICE: This operation only get
//the current status of system
//where this instruction is executed.
push eax
mov eax,dword ptr [esp + 0x04]
mov dword ptr [ebp - 0x2c],eax //Get the eax register's value.
//Fuck Bill Gates!!!!!
mov eax,dword ptr [esp + 0x08]
mov dword ptr [ebp - 0x28],eax //Get the ecx value.
mov eax,dword ptr [esp + 0x0c]
mov dword ptr [ebp - 0x24],eax //edx
mov eax,dword ptr [esp + 0x10]
mov dword ptr [ebp - 0x20],eax //ebx
mov eax,dword ptr [esp + 0x14]
mov dword ptr [ebp - 0x1c],eax //esp
mov eax,dword ptr [esp + 0x18]
mov dword ptr [ebp - 0x18],eax //ebp
mov eax,dword ptr [esp + 0x1c]
mov dword ptr [ebp - 0x14],eax //esi
mov eax,dword ptr [esp + 0x20]
mov dword ptr [ebp - 0x10],eax //edi
mov ax,cs
shl eax,0x10
mov ax,ds
mov dword ptr [ebp - 0x0c],eax //Get cs : ds.
mov ax,fs
shl eax,0x10
mov ax,gs
mov dword ptr [ebp - 0x08],eax //Get fs : gs.
mov ax,es
shl eax,0x10
mov ax,ss
mov dword ptr [ebp - 0x04],eax //Get es : ss.
pop eax
popad //Restore the stack frame.
}
#else //If not an I386 or above platform.
GotoHome();
ChangeLine();
PrintStr(" This operation can not supported on no-I386 platform.");
return;
#endif //Now,we got the general registers and segment
//registers' value,print them out.
GotoHome();
ChangeLine();
PrintStr(" System context information(general registers and segment registers):");
for(DWORD bt = 0;bt < 11;bt ++)
{
GotoHome();
ChangeLine();
PrintStr(strHdr[bt]);
Hex2Str(sysContext[bt],Buffer);
//Buffer[8] = 0x00;
PrintStr(Buffer);
}
return;
}
VOID DateHandler(LPSTR)
{
GotoHome();
ChangeLine();
PrintStr("DateHandler called.");
}
VOID TimeHandler(LPSTR)
{
GotoHome();
ChangeLine();
PrintStr("Time Handler called.");
}
VOID CpuHandler(LPSTR)
{
GotoHome();
ChangeLine();
PrintStr("Cpu Handler called.");
}
VOID SptHandler(LPSTR) //Command 'support' handler.
{
LPSTR strSupportInfo1 = " For any technical support,send E-Mail to:";
LPSTR strSupportInfo2 = " garryxin@yahoo.com.cn.";
GotoHome();
ChangeLine();
PrintStr(strSupportInfo1);
GotoHome();
ChangeLine();
PrintStr(strSupportInfo2);
return;
}
VOID DefaultHandler(LPSTR) //Default command handler.
{
LPSTR strPrompt = "You entered incorrect command name.";
ChangeLine();
GotoHome();
PrintStr(strPrompt);
return;
}
//static BYTE tmpBuffer[36] = {0x00000000}; //If I declare this variable as the local
//variable,as following,it would not work,
//but I put it here,it works,I don't know
//why,maybe some rules I do not know,but I
//think it's would be gate's reason,so I
//want to fuck bill gates again!!!
VOID DoCommand()
{
DWORD wIndex = 0x0000;
BOOL bResult = FALSE; //If find the correct command object,then
//This flag set to TRUE.
BYTE tmpBuffer[36];
__KERNEL_THREAD_OBJECT* hKernelThread = NULL;
CmdBuffer[BufferPtr] = 0x00; //Prepare the command string.
BufferPtr = 0;
while((' ' != CmdBuffer[wIndex]) && CmdBuffer[wIndex] && (wIndex < 32))
{
tmpBuffer[wIndex] = CmdBuffer[wIndex];
wIndex ++;
}
tmpBuffer[wIndex] = 0;
for(DWORD dwIndex = 0;dwIndex < CMD_OBJ_NUM;dwIndex ++)
{
if(StrCmp(&tmpBuffer[0],CmdObj[dwIndex].CmdStr))
{
CmdObj[dwIndex].CmdHandler(&CmdBuffer[wIndex]); //Call the command handler.
bResult = TRUE; //Set the flag.
break;
}
}
if(bResult)
goto __END;
dwIndex = 0; //Now,should search external command array.
while(ExtCmdArray[dwIndex].lpszCmdName)
{
if(StrCmp(&tmpBuffer[0],ExtCmdArray[dwIndex].lpszCmdName)) //Found.
{
hKernelThread = KernelThreadManager.CreateKernelThread(
(__COMMON_OBJECT*)&KernelThreadManager,
0L,
KERNEL_THREAD_STATUS_READY,
PRIORITY_LEVEL_NORMAL,
ExtCmdArray[dwIndex].ExtCmdHandler,
(LPVOID)&CmdBuffer[wIndex],
NULL,
NULL);
if(!ExtCmdArray[dwIndex].bBackground) //Should wait.
{
hKernelThread->WaitForThisObject((__COMMON_OBJECT*)hKernelThread);
KernelThreadManager.DestroyKernelThread(
(__COMMON_OBJECT*)&KernelThreadManager,
(__COMMON_OBJECT*)hKernelThread); //Destroy it.
}
bResult = TRUE;
goto __END;
}
dwIndex ++;
}
if(!bResult)
{
DefaultHandler(NULL); //Call the default command handler.
}
__END:
return;
}
VOID PrintPrompt()
{
LPSTR pszSysName = "[system-view]";
if(HostName[0])
{
PrintLine(&HostName[0]);
}
else
{
ChangeLine();
GotoHome();
PrintStr(pszSysName);
}
return;
}
BOOL EventHandler(WORD wCommand,WORD wParam,DWORD dwParam)
{
WORD wr = 0x0700;
BYTE bt = 0x00;
BYTE Buffer[12];
switch(wCommand)
{
case MSG_KEY_DOWN:
bt = LOBYTE(LOWORD(dwParam));
if(VK_RETURN == bt)
{
if(BufferPtr)
DoCommand();
PrintPrompt();
break;
}
if(VK_BACKSPACE == bt)
{
if(0 != BufferPtr)
{
GotoPrev();
BufferPtr --;
}
break;
}
else
{
if(MAX_BUFFER_LEN - 1 > BufferPtr)
{
CmdBuffer[BufferPtr] = bt;
BufferPtr ++;
wr += LOBYTE(LOWORD(dwParam));
PrintCh(wr);
}
}
break;
case KERNEL_MESSAGE_TIMER:
switch(dwParam){
case 100:
GotoHome();
ChangeLine();
PrintStr("Timer ID = 100,please handle it.");
Int2Str(100,Buffer);
PrintStr(Buffer);
break;
case 200:
GotoHome();
ChangeLine();
PrintStr("Timer ID = 200,please handle it.");
Int2Str(200,Buffer);
PrintStr(Buffer);
break;
case 300:
GotoHome();
ChangeLine();
PrintStr("Timer ID = 300,please handle it.");
break;
case 400:
GotoHome();
ChangeLine();
PrintStr("Timer ID = 400,please handle it.");
break;
case 500:
GotoHome();
ChangeLine();
PrintStr("Timer ID = 500,please handle it.");
break;
default:
break;
}
default:
break;
}
return 0L;
}
//
//Entry point.
//
DWORD EntryPoint()
{
//__KTHREAD_MSG Msg;
__KERNEL_THREAD_MESSAGE KernelThreadMessage;
PrintPrompt();
while(TRUE)
{
if(GetMessage(&KernelThreadMessage))
{
if(KTMSG_THREAD_TERMINAL == KernelThreadMessage.wCommand)
goto __TERMINAL;
DispatchMessage(&KernelThreadMessage,EventHandler);
}
}
__TERMINAL: //Terminal code here.
return 0L;
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -