ktmgr.h

自己动手写操作系统源代码,不可多得的代码

//***********************************************************************/
//    Author                    : Garry
//    Original Date             : Oct,18 2004
//    Module Name               : ktmgr.h
//    Module Funciton           : 
//                                This module countains kernel thread and kernel thread 
//                                manager's definition.
//
//                                ************
//                                This file is the most important file of Hello China.
//                                ************
//    Last modified Author      :
//    Last modified Date        :
//    Last modified Content     :
//                                1.
//                                2.
//    Lines number              :
//***********************************************************************/

#ifndef __KTMGR_H__
#define __KTMGR_H__

//
//***********************************************************************
//
#define SYSTEM_TIME_SLICE  10    //***** debug *****

DECLARE_PREDEFINED_OBJECT(__KERNEL_FILE)
DECLARE_PREDEFINED_OBJECT(__EVENT)

//Kernel thread's context.

BEGIN_DEFINE_OBJECT(__KERNEL_THREAD_CONTEXT)
#ifdef __I386
    DWORD           dwEFlags;
    WORD            wCS;
	WORD            wReserved;
	DWORD           dwEIP;
	DWORD           dwEAX;
	DWORD           dwEBX;
	DWORD           dwECX;
	DWORD           dwEDX;
	DWORD           dwESI;
	DWORD           dwEDI;
	DWORD           dwEBP;
	DWORD           dwESP;

//
//The following macro is used to initialize a kernel thread's executation
//context.
//

#define INIT_EFLAGS_VALUE 512
#define INIT_KERNEL_THREAD_CONTEXT_I(lpContext,initEip,initEsp) \
    (lpContext)->dwEFlags    = INIT_EFLAGS_VALUE;               \
    (lpContext)->wCS         = 0x08;                            \
	(lpContext)->wReserved   = 0x00;                            \
	(lpContext)->dwEIP       = initEip;                         \
	(lpContext)->dwEAX       = 0x00000000;                      \
	(lpContext)->dwEBX       = 0x00000000;                      \
	(lpContext)->dwECX       = 0x00000000;                      \
	(lpContext)->dwEDX       = 0x00000000;                      \
	(lpContext)->dwESI       = 0x00000000;                      \
	(lpContext)->dwEDI       = 0x00000000;                      \
	(lpContext)->dwEBP       = 0x00000000;                      \
	(lpContext)->dwESP       = initEsp;

//
//In order to access the members of a context giving it's base address,
//we define the following macros to make this job easy.
//

#define CONTEXT_OFFSET_EFLAGS        0x00
#define CONTEXT_OFFSET_CS            0x04
#define CONTEXT_OFFSET_EIP           0x08
#define CONTEXT_OFFSET_EAX           0x0C
#define CONTEXT_OFFSET_EBX           0x10
#define CONTEXT_OFFSET_ECX           0x14
#define CONTEXT_OFFSET_EDX           0x18
#define CONTEXT_OFFSET_ESI           0x1C
#define CONTEXT_OFFSET_EDI           0x20
#define CONTEXT_OFFSET_EBP           0x24
#define CONTEXT_OFFSET_ESP           0x28


#elif (defined(__PPC))    //Power PC platform's definition.
#define INIT_KERNEL_THREAD_CONTEXT_P()

#elif (defined(__ALPHA))  //Alpha platform's definition.
#define INIT_KERNEL_THREAD_CONTEXT_A()

#elif (defined(__SPARC))  //Sparc platfrom's definition.
#define INIT_KERNEL_THREAD_CONTEXT_S()
#else
#endif

END_DEFINE_OBJECT()

//
//Kernel Thread's object table.
//When an object is created,such as FILE,EVENT,MUTEX,etc,a entry is added
//to the kernel thread's object table.
//When the kernel thread is running over,the object(s) reside(s) in the table
//will be deleted by system,to release system resource.
//
#ifndef MAX_KTHREAD_OBJECT_PER_TABLE
#define MAX_KTHREAD_OBJECT_PER_TABLE 16
#endif

BEGIN_DEFINE_OBJECT(__KERNEL_THREAD_OBJECT_TABLE)
    __COMMON_OBJECT*               ObjectBase[MAX_KTHREAD_OBJECT_PER_TABLE];
	__KERNEL_THREAD_OBJECT_TABLE*  lpNextObjectTable;
END_DEFINE_OBJECT()

//
//Kernel thread object's definition.
//

//
//Common synchronization object's definition.
//The common synchronization object is a abstract object,all synchronization objects,such
//as event,mutex,etc,all inherited from this object.
//

BEGIN_DEFINE_OBJECT(__COMMON_SYNCHRONIZATION_OBJECT)
    DWORD                (*WaitForThisObject)(__COMMON_SYNCHRONIZATION_OBJECT*);
END_DEFINE_OBJECT()

//
//The following macro is defined to be used by other objects to inherit from
//common synchronization object.
//
#define INHERIT_FROM_COMMON_SYNCHRONIZATION_OBJECT \
	DWORD                (*WaitForThisObject)(__COMMON_OBJECT*);


//
//Kernel thread's message.
//

BEGIN_DEFINE_OBJECT(__KERNEL_THREAD_MESSAGE)
    WORD             wCommand;
    WORD             wParam;
	DWORD            dwParam;
	//DWORD            (*MsgAssocRoutine)(__KERNEL_THREAD_MESSAGE*);
END_DEFINE_OBJECT()

//
//The definition of kernel thread's message.
//

//#define KERNEL_MESSAGE_TERMINAL    0x0001
//#define KERNEL_MESSAGE_TIMER       0x0002

#ifndef MAX_KTHREAD_MSG_NUM
#define MAX_KTHREAD_MSG_NUM 32  //The maximal message number in the kernel thread's message
                                //queue.
#endif

								
#define KERNEL_THREAD_STATUS_RUNNING    0x00000001  //Kernel thread's status.
#define KERNEL_THREAD_STATUS_READY      0x00000002
#define KERNEL_THREAD_STATUS_SUSPENDED  0x00000003
#define KERNEL_THREAD_STATUS_SLEEPING   0x00000004
#define KERNEL_THREAD_STATUS_TERMINAL   0x00000005
#define KERNEL_THREAD_STATUS_BLOCKED    0x00000006

#define PRIORITY_LEVEL_REALTIME         0x00000020  //Kernel thread's priority level.
#define PRIORITY_LEVEL_CRITICAL         0x00000010
#define PRIORITY_LEVEL_IMPORTANT        0x00000008
#define PRIORITY_LEVEL_NORMAL           0x00000004
#define PRIORITY_LEVEL_LOW              0x00000002
#define PRIORITY_LEVEL_LOWEST           0x00000001
#define PRIORITY_LEVEL_INVALID          0x00000000

#define DEFAULT_STACK_SIZE              0x00004000  //Default stack size,if the dwStackSize
								                    //parameter of CreateKernelThread is 0,
													//then the CreateKernelThread will allocate
													//DEFAULT_STACK_SIZE bytes to be used as
													//stack.

//
//The kernel thread object's definition.
//

BEGIN_DEFINE_OBJECT(__KERNEL_THREAD_OBJECT)
    INHERIT_FROM_COMMON_OBJECT
	INHERIT_FROM_COMMON_SYNCHRONIZATION_OBJECT
	__KERNEL_THREAD_CONTEXT              KernelThreadContext;
    DWORD                                dwThreadID;
	DWORD                                dwThreadStatus;          //Kernel Thread's current
	                                                              //status.
	__PRIORITY_QUEUE*                    lpWaitingQueue;          //Waiting queue of the
	                                                              //kernel thread object.
	                                                              //One kernel thread who
	                                                              //want to wait the current
	                                                              //kernel thread object
	                                                              //will be put into this
	                                                              //queue.

	DWORD                                dwThreadPriority;        //Initialize priority.
	DWORD                                dwScheduleCounter;       //Schedule counter,used to
	                                                              //control the scheduler.
	DWORD                                dwReturnValue;

	DWORD                                dwTotalRunTime;
	DWORD                                dwTotalMemSize;

	LPVOID                               lpHeapObject;           //Pointing to the heap list.
	LPVOID                               lpDefaultHeap;          //Default heap.

	__KERNEL_FILE*                       lpCurrentDirectory;     //Current working directory.
	__KERNEL_FILE*                       lpRootDirectory;        //Root directory.
	__KERNEL_FILE*                       lpModuleDirectory;      //The executable module's
	                                                             //directory of this kernel
	                                                             //thread.

	__COMMON_OBJECT*                     StartTime;

	BOOL                                 bUsedMath;              //If used math co-process.

	DWORD                                dwStackSize;
	LPVOID                               lpInitStackPointer;

	DWORD                                (*KernelThreadRoutine)(LPVOID);  //Start address.
	LPVOID                               lpRoutineParam;

	//The following four members are used to manage the message queue of the
	//current kernel thread.
	__KERNEL_THREAD_MESSAGE              KernelThreadMsg[MAX_KTHREAD_MSG_NUM];
	UCHAR                                ucMsgQueueHeader;
	UCHAR                                ucMsgQueueTrial;
	UCHAR                                ucCurrentMsgNum;
	UCHAR                                ucAligment;
	__EVENT*                             lpMsgEvent;

	DWORD                                dwLastError;

	__KERNEL_THREAD_OBJECT_TABLE         KernelObjectTable;  //Object's table.
	__KERNEL_THREAD_OBJECT*              lpParentKernelThread;

END_DEFINE_OBJECT()

//Kernel thread object's initialize and uninitialize routine's definition.
BOOL KernelThreadInitialize(__COMMON_OBJECT* lpThis);
VOID KernelThreadUninitialize(__COMMON_OBJECT* lpThis);


typedef DWORD (*__KERNEL_THREAD_ROUTINE)(LPVOID);  //Kernel thread's start routine.