Initial implementation of the thread initialization

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

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);

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 */

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

xtoskrnl/includes/kepfuncs.h

@@ -10,7 +10,39 @@
 #define __XTOSKRNL_KEPFUNCS_H
 
 #include <xtos.h>
-#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 */

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)

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 <belliash@codingworkshop.eu.org>
+ */
+
+#include <xtos.h>
+
+
+/**
+ * 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;
+}

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];

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 <belliash@codingworkshop.eu.org>
+ */
+
+#include <xtos.h>
+
+
+/**
+ * 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;
+}

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;
 }