From c4d1f1cd0dc459b1107bf2b601ef70da301ad6b9 Mon Sep 17 00:00:00 2001 From: belliash Date: Thu, 23 Feb 2023 20:11:21 +0100 Subject: [PATCH] Initial implementation of the thread initialization --- sdk/xtdk/ketypes.h | 33 ++++++ sdk/xtdk/xtstatus.h | 2 + sdk/xtdk/xtstruct.h | 3 + xtoskrnl/CMakeLists.txt | 1 + xtoskrnl/includes/amd64/kepfuncs.h | 8 ++ xtoskrnl/includes/globals.h | 3 + xtoskrnl/includes/i686/kepfuncs.h | 17 ++- xtoskrnl/includes/kepfuncs.h | 34 +++++- xtoskrnl/includes/xtos.h | 3 + xtoskrnl/ke/amd64/kthread.c | 43 +++++++ xtoskrnl/ke/globals.c | 3 + xtoskrnl/ke/i686/kthread.c | 43 +++++++ xtoskrnl/ke/kthread.c | 176 ++++++++++++++++++++++++++++- 13 files changed, 356 insertions(+), 13 deletions(-) create mode 100644 xtoskrnl/ke/amd64/kthread.c create mode 100644 xtoskrnl/ke/i686/kthread.c diff --git a/sdk/xtdk/ketypes.h b/sdk/xtdk/ketypes.h index d99e129..9bc7d2f 100644 --- a/sdk/xtdk/ketypes.h +++ b/sdk/xtdk/ketypes.h @@ -16,6 +16,11 @@ #include ARCH_HEADER(ketypes.h) +/* Exception types and handling mechanisms */ +#define EXCEPTION_CONTINUE_SEARCH 0x00 +#define EXCEPTION_EXECUTE_HANDLER 0x01 +#define EXCEPTION_CONTINUE_EXECUTION 0xFF + /* Maximum number of exception parameters */ #define EXCEPTION_MAXIMUM_PARAMETERS 15 @@ -34,6 +39,14 @@ #define KTIMER_WAIT_BLOCK 3 #define SEMAPHORE_WAIT_BLOCK 2 +/* Adjust reason */ +typedef enum _ADJUST_REASON +{ + AdjustNone = 0, + AdjustUnwait = 1, + AdjustBoost = 2 +} ADJUST_REASON, *PADJUST_REASON; + /* Exception disposition return values */ typedef enum _EXCEPTION_DISPOSITION { @@ -83,6 +96,19 @@ typedef enum _KOBJECTS MaximumKernelObject = 25 } KOBJECTS, *PKOBJECTS; +/* Thread state */ +typedef enum _KTHREAD_STATE +{ + Initialized, + Ready, + Running, + Standby, + Terminated, + Waiting, + Transition, + DeferredReady +} KTHREAD_STATE, *PKTHREAD_STATE; + /* Timer type */ typedef enum _KTIMER_TYPE { @@ -98,6 +124,13 @@ typedef enum _MODE MaximumMode } MODE, *PMODE; +/* Wait type */ +typedef enum _WAIT_TYPE +{ + WaitAll, + WaitAny +} WAIT_TYPE, *PWAIT_TYPE; + /* Kernel routine callbacks */ typedef EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE)(IN PEXCEPTION_RECORD ExceptionRecord, IN PVOID EstablisherFrame, IN OUT PCONTEXT ContextRecord, IN OUT PVOID DispatcherContext); typedef VOID (*PKNORMAL_ROUTINE)(IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2); diff --git a/sdk/xtdk/xtstatus.h b/sdk/xtdk/xtstatus.h index 7f450d1..e8675a4 100644 --- a/sdk/xtdk/xtstatus.h +++ b/sdk/xtdk/xtstatus.h @@ -48,10 +48,12 @@ /* XT status code definitions */ #define STATUS_SUCCESS ((XTSTATUS) 0x00000000L) +#define STATUS_UNSUCCESSFUL ((XTSTATUS) 0xC0000001L) #define STATUS_NOT_IMPLEMENTED ((XTSTATUS) 0xC0000002L) #define STATUS_INVALID_PARAMETER ((XTSTATUS) 0xC000000DL) #define STATUS_INSUFFICIENT_RESOURCES ((XTSTATUS) 0xC000009AL) #define STATUS_DEVICE_NOT_READY ((XTSTATUS) 0xC00000A3L) +#define STATUS_TIMEOUT ((XTSTATUS) 0x00000102L) #define STATUS_IO_DEVICE_ERROR ((XTSTATUS) 0xC0000185L) #define STATUS_NOT_FOUND ((XTSTATUS) 0xC0000225L) diff --git a/sdk/xtdk/xtstruct.h b/sdk/xtdk/xtstruct.h index b53b8de..820f6c6 100644 --- a/sdk/xtdk/xtstruct.h +++ b/sdk/xtdk/xtstruct.h @@ -13,6 +13,7 @@ /* Enumeration lists forward references */ +typedef enum _ADJUST_REASON ADJUST_REASON, *PADJUST_REASON; typedef enum _BOOLEAN BOOLEAN, *PBOOLEAN; typedef enum _EXCEPTION_DISPOSITION EXCEPTION_DISPOSITION, *PEXCEPTION_DISPOSITION; typedef enum _EFI_ALLOCATE_TYPE EFI_ALLOCATE_TYPE, *PEFI_ALLOCATE_TYPE; @@ -39,10 +40,12 @@ typedef enum _EFI_UART_STOP_BITS_TYPE EFI_UART_STOP_BITS_TYPE, *PEFI_UART_STOP_B typedef enum _EFI_UNIVERSA_GRAPHICS_BLT_OPERATION EFI_UNIVERSA_GRAPHICS_BLT_OPERATION, *PEFI_UNIVERSA_GRAPHICS_BLT_OPERATION; typedef enum _KAPC_ENVIRONMENT KAPC_ENVIRONMENT, *PKAPC_ENVIRONMENT; typedef enum _KOBJECTS KOBJECTS, *PKOBJECTS; +typedef enum _KTHREAD_STATE KTHREAD_STATE, *PKTHREAD_STATE; typedef enum _KTIMER_TYPE KTIMER_TYPE, *PKTIMER_TYPE; typedef enum _LOADER_MEMORY_TYPE LOADER_MEMORY_TYPE, *PLOADER_MEMORY_TYPE; typedef enum _MODE MODE, *PMODE; typedef enum _SYSTEM_FIRMWARE_TYPE SYSTEM_FIRMWARE_TYPE, *PSYSTEM_FIRMWARE_TYPE; +typedef enum _WAIT_TYPE WAIT_TYPE, *PWAIT_TYPE; /* Structures forward references */ typedef struct _ANSI_STRING ANSI_STRING, *PANSI_STRING; diff --git a/xtoskrnl/CMakeLists.txt b/xtoskrnl/CMakeLists.txt index d45e4b5..a6ffad3 100644 --- a/xtoskrnl/CMakeLists.txt +++ b/xtoskrnl/CMakeLists.txt @@ -24,6 +24,7 @@ list(APPEND XTOSKRNL_SOURCE ${XTOSKRNL_SOURCE_DIR}/ke/spinlock.c ${XTOSKRNL_SOURCE_DIR}/ke/timer.c ${XTOSKRNL_SOURCE_DIR}/ke/${ARCH}/krnlinit.c + ${XTOSKRNL_SOURCE_DIR}/ke/${ARCH}/kthread.c ${XTOSKRNL_SOURCE_DIR}/ke/${ARCH}/proc.c ${XTOSKRNL_SOURCE_DIR}/mm/kpools.c ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pages.c diff --git a/xtoskrnl/includes/amd64/kepfuncs.h b/xtoskrnl/includes/amd64/kepfuncs.h index f3d8347..60cc542 100644 --- a/xtoskrnl/includes/amd64/kepfuncs.h +++ b/xtoskrnl/includes/amd64/kepfuncs.h @@ -28,6 +28,14 @@ XTAPI VOID KepArchInitialize(VOID); +XTAPI +VOID +KepInitializeThreadContext(IN PKTHREAD Thread, + IN PKSYSTEM_ROUTINE SystemRoutine, + IN PKSTART_ROUTINE StartRoutine, + IN PVOID StartContext, + IN PCONTEXT ContextRecord); + XTAPI VOID KepStartKernel(VOID); diff --git a/xtoskrnl/includes/globals.h b/xtoskrnl/includes/globals.h index 5237814..6fb1d39 100644 --- a/xtoskrnl/includes/globals.h +++ b/xtoskrnl/includes/globals.h @@ -28,4 +28,7 @@ EXTERN EPROCESS KeInitialProcess; /* Kernel initial thread */ EXTERN ETHREAD KeInitialThread; +/* Kernel service descriptor table */ +EXTERN KSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable[KSERVICE_TABLES_COUNT]; + #endif /* __XTOSKRNL_GLOBALS_H */ diff --git a/xtoskrnl/includes/i686/kepfuncs.h b/xtoskrnl/includes/i686/kepfuncs.h index 25d2661..4903c28 100644 --- a/xtoskrnl/includes/i686/kepfuncs.h +++ b/xtoskrnl/includes/i686/kepfuncs.h @@ -25,19 +25,16 @@ PKTHREAD KeGetCurrentThread(VOID); XTAPI -XTSTATUS -KeInitializeThread(IN PKTHREAD Thread, - IN PVOID Stack, - IN PKSYSTEM_ROUTINE SystemRoutine, - IN PKSTART_ROUTINE StartRoutine, - IN PVOID StartContext, - IN PCONTEXT Context, - IN PVOID EnvironmentBlock, - IN PKPROCESS Process); +VOID +KepArchInitialize(VOID); XTAPI VOID -KepArchInitialize(VOID); +KepInitializeThreadContext(IN PKTHREAD Thread, + IN PKSYSTEM_ROUTINE SystemRoutine, + IN PKSTART_ROUTINE StartRoutine, + IN PVOID StartContext, + IN PCONTEXT ContextRecord); XTAPI VOID diff --git a/xtoskrnl/includes/kepfuncs.h b/xtoskrnl/includes/kepfuncs.h index 1589dfb..b090ea3 100644 --- a/xtoskrnl/includes/kepfuncs.h +++ b/xtoskrnl/includes/kepfuncs.h @@ -10,7 +10,39 @@ #define __XTOSKRNL_KEPFUNCS_H #include -#include ARCH_HEADER(kepfuncs.h) +XTAPI +XTSTATUS +KeInitializeThread(IN PKTHREAD Thread, + IN PVOID Stack, + IN PKSYSTEM_ROUTINE SystemRoutine, + IN PKSTART_ROUTINE StartRoutine, + IN PVOID StartContext, + IN PCONTEXT Context, + IN PVOID EnvironmentBlock, + IN PKPROCESS Process); + +XTAPI +VOID +KeStartThread(IN PKTHREAD Thread); + +XTAPI +VOID +KepSuspendNop(IN PKAPC Apc, + IN OUT PKNORMAL_ROUTINE *NormalRoutine, + IN OUT PVOID *NormalContext, + IN OUT PVOID *SystemArgument1, + IN OUT PVOID *SystemArgument2); + +XTAPI +VOID +KepSuspendRundown(IN PKAPC Apc); + +XTAPI +VOID +KepSuspendThread(IN PVOID NormalContext, + IN PVOID SystemArgument1, + IN PVOID SystemArgument2); + #endif /* __XTOSKRNL_KEPFUNCS_H */ diff --git a/xtoskrnl/includes/xtos.h b/xtoskrnl/includes/xtos.h index 5b00abb..9d45b5f 100644 --- a/xtoskrnl/includes/xtos.h +++ b/xtoskrnl/includes/xtos.h @@ -13,3 +13,6 @@ #include "globals.h" #include "arpfuncs.h" #include "kepfuncs.h" + +#include ARCH_HEADER(arpfuncs.h) +#include ARCH_HEADER(kepfuncs.h) diff --git a/xtoskrnl/ke/amd64/kthread.c b/xtoskrnl/ke/amd64/kthread.c new file mode 100644 index 0000000..1743739 --- /dev/null +++ b/xtoskrnl/ke/amd64/kthread.c @@ -0,0 +1,43 @@ +/** + * PROJECT: ExectOS + * COPYRIGHT: See COPYING.md in the top level directory + * FILE: xtoskrnl/ke/amd64/kthread.c + * DESCRIPTION: AMD64 thread manipulation support + * DEVELOPERS: Rafal Kupiec + */ + +#include + + +/** + * Initializes CPU architecture dependent context of a thread. + * + * @param Thread + * Supplies a pointer to the thread being initialized. + * + * @param SystemRoutine + * Supplies a pointer to the routine called during first scheduling. + * + * @param StartRoutine + * Supplies a pointer to the routine called during thread startup. + * + * @param StartContext + * Supplies a pointer to a context data that will be passed to start routine. + * + * @param ContextRecord + * Supplies a pointer to a context record which stores the initial state of the user mode thread. + * + * @return This routine does not return any value. + * + * @since XT 1.0 + */ +XTAPI +VOID +KepInitializeThreadContext(IN PKTHREAD Thread, + IN PKSYSTEM_ROUTINE SystemRoutine, + IN PKSTART_ROUTINE StartRoutine, + IN PVOID StartContext, + IN PCONTEXT ContextRecord) +{ + UNIMPLEMENTED; +} diff --git a/xtoskrnl/ke/globals.c b/xtoskrnl/ke/globals.c index 5a811de..e2c6f04 100644 --- a/xtoskrnl/ke/globals.c +++ b/xtoskrnl/ke/globals.c @@ -20,3 +20,6 @@ EPROCESS KeInitialProcess; /* Kernel initial thread */ ETHREAD KeInitialThread; + +/* Kernel service descriptor table */ +KSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable[KSERVICE_TABLES_COUNT]; diff --git a/xtoskrnl/ke/i686/kthread.c b/xtoskrnl/ke/i686/kthread.c new file mode 100644 index 0000000..3cdfd13 --- /dev/null +++ b/xtoskrnl/ke/i686/kthread.c @@ -0,0 +1,43 @@ +/** + * PROJECT: ExectOS + * COPYRIGHT: See COPYING.md in the top level directory + * FILE: xtoskrnl/ke/i686/kthread.c + * DESCRIPTION: I686 thread manipulation support + * DEVELOPERS: Rafal Kupiec + */ + +#include + + +/** + * Initializes CPU architecture dependent context of a thread. + * + * @param Thread + * Supplies a pointer to the thread being initialized. + * + * @param SystemRoutine + * Supplies a pointer to the routine called during first scheduling. + * + * @param StartRoutine + * Supplies a pointer to the routine called during thread startup. + * + * @param StartContext + * Supplies a pointer to a context data that will be passed to start routine. + * + * @param ContextRecord + * Supplies a pointer to a context record which stores the initial state of the user mode thread. + * + * @return This routine does not return any value. + * + * @since XT 1.0 + */ +XTAPI +VOID +KepInitializeThreadContext(IN PKTHREAD Thread, + IN PKSYSTEM_ROUTINE SystemRoutine, + IN PKSTART_ROUTINE StartRoutine, + IN PVOID StartContext, + IN PCONTEXT ContextRecord) +{ + UNIMPLEMENTED; +} diff --git a/xtoskrnl/ke/kthread.c b/xtoskrnl/ke/kthread.c index 3608692..c900833 100644 --- a/xtoskrnl/ke/kthread.c +++ b/xtoskrnl/ke/kthread.c @@ -51,6 +51,178 @@ KeInitializeThread(IN PKTHREAD Thread, IN PVOID EnvironmentBlock, IN PKPROCESS Process) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PKWAIT_BLOCK TimerWaitBlock; + BOOLEAN Allocation; + XTSTATUS Status; + ULONG Index; + + /* Initialize thread dispatcher header */ + Thread->Header.Type = ThreadObject; + Thread->Header.SignalState = 0; + + /* Initialize thread wait list */ + RtlInitializeListHead(&Thread->Header.WaitListHead); + + /* Initialize thread mutant list head */ + RtlInitializeListHead(&Thread->MutantListHead); + + /* Initialize the builtin wait blocks */ + for(Index = 0; Index <= KTHREAD_WAIT_BLOCK; Index++) + { + Thread->WaitBlock[Index].Thread = Thread; + } + + /* Initialize stack resident and stack swap */ + Thread->AutoAlignment = Process->AutoAlignment; + Thread->StackResident = TRUE; + Thread->StackSwap = TRUE; + Thread->SwapBusy = FALSE; + + /* Set priority adjustment reason */ + Thread->AdjustReason = AdjustNone; + + /* Initialize thread lock */ + KeInitializeSpinLock(&Thread->ThreadLock); + + /* Set thread service table */ + Thread->ServiceTable = KeServiceDescriptorTable; + + /* Initialize thread APC */ + Thread->ApcStatePointer[0] = &Thread->ApcState; + Thread->ApcStatePointer[1] = &Thread->SavedApcState; + Thread->ApcQueueable = TRUE; + Thread->ApcState.Process = Process; + Thread->Process = Process; + + /* Initialize APC list heads */ + RtlInitializeListHead(&Thread->ApcState.ApcListHead[KernelMode]); + RtlInitializeListHead(&Thread->ApcState.ApcListHead[UserMode]); + + /* Initialize APC queue lock */ + KeInitializeSpinLock(&Thread->ApcQueueLock); + + /* Initialize kernel-mode suspend APC */ + KeInitializeApc(&Thread->SuspendApc, Thread, OriginalApcEnvironment, KepSuspendNop, + KepSuspendRundown, KepSuspendThread, KernelMode, NULL); + + /* Initialize suspend semaphore */ + KeInitializeSemaphore(&Thread->SuspendSemaphore, 0, 2); + + /* Initialize the builtin timer */ + KeInitializeTimer(&Thread->Timer); + TimerWaitBlock = &Thread->WaitBlock[KTIMER_WAIT_BLOCK]; + TimerWaitBlock->Object = &Thread->Timer; + TimerWaitBlock->WaitKey = STATUS_TIMEOUT; + TimerWaitBlock->WaitType = WaitAny; + TimerWaitBlock->WaitListEntry.Flink = &(&Thread->Timer)->Header.WaitListHead; + TimerWaitBlock->WaitListEntry.Blink = &(&Thread->Timer)->Header.WaitListHead; + + /* Initialize Thread Environment Block*/ + Thread->EnvironmentBlock = EnvironmentBlock; + + Thread->InitialStack = Stack; + Thread->StackBase = Stack; + Thread->StackLimit = Stack - KERNEL_STACK_SIZE; + + /* Initialize thread context */ + KepInitializeThreadContext(Thread, SystemRoutine, StartRoutine, StartContext, Context); + + /* Mark thread as initialized and run it */ + Thread->State = Initialized; + KeStartThread(Thread); + + /* Return success */ + return STATUS_SUCCESS; +} + +/** + * Starts the thread. + * + * @param Thread + * Supplies a pointer to the thread. + * + * @return This routine does not return any value. + * + * @since NT 5.1 + */ +XTAPI +VOID +KeStartThread(IN PKTHREAD Thread) +{ + UNIMPLEMENTED; +} + +/** + * Suspend APC-built thread NOP routine. It takes no actions. + * + * @param Apc + * Supplies a pointer to the APC object. + * + * @param NormalRoutine + * Supplies a pointer to the normal routine set during the APC initialization. Unused by this routine. + * + * @param NormalContext + * Supplies a pointer a context data set during the APC initialization. Unused by this routine. + * + * @param SystemArgument1 + * Supplies a pointer to an unused system argument. + * + * @param SystemArgument2 + * Supplies a pointer to an unused system argument. + * + * @return This routine does not return any value. + * + * @since XT 1.0 + */ +XTAPI +VOID +KepSuspendNop(IN PKAPC Apc, + IN OUT PKNORMAL_ROUTINE *NormalRoutine, + IN OUT PVOID *NormalContext, + IN OUT PVOID *SystemArgument1, + IN OUT PVOID *SystemArgument2) +{ + /* No action here */ +} + +/** + * Suspend APC-built thread rundown routine. It takes no actions. + * + * @param Apc + * Supplies a pointer to the APC object. + * + * @return This routine does not return any value. + * + * @since XT 1.0 + */ +XTAPI +VOID +KepSuspendRundown(IN PKAPC Apc) +{ + /* No action here */ +} + +/** + * Suspends thread execution by waiting on the thread's semaphore. + * + * @param NormalContext + * Supplies a pointer a context data set during the APC initialization. Unused by this routine. + * + * @param SystemArgument1 + * Supplies a pointer to an unused system argument. + * + * @param SystemArgument2 + * Supplies a pointer to an unused system argument. + * + * @return This routine does not return any value. + * + * @since XT 1.0 + */ +XTAPI +VOID +KepSuspendThread(IN PVOID NormalContext, + IN PVOID SystemArgument1, + IN PVOID SystemArgument2) +{ + UNIMPLEMENTED; }