Added additional unit tests + bug fixes

kernel/src/arch/x86/ap_startup.cpp

@@ -91,6 +91,8 @@ void _prepareApStartupMemoryMappings() {
 }
 
 void initializeApCores() {
+    const uint32_t coreStartupMaxTimeout = 3; // seconds
+
     auto& acpiController = AcpiController::get();
     Madt* apicTable = acpiController.getApicTable();
 
@@ -122,6 +124,9 @@ void initializeApCores() {
         // Let the AP cores continue on their own asynchronously
         _releaseApStartupSpinlockFlag();
     });
+
+    // Wait for all cores to fully start and finish initializing
+    sleep(coreStartupMaxTimeout);
 }
 
 void bootAndInitApCore(uint8_t apicid) {
@@ -170,6 +175,9 @@ void apStartupEntryC(int apicid) {
     size_t usermodeStackSize = 8 * PAGE_SIZE;
     size_t userStackTop = (uint64_t)(usermodeStack + usermodeStackSize);
 
+    // Set the userStackTop field of the CPU's swapper task
+    g_kernelSwapperTasks[apicid].userStackTop = userStackTop;
+
     __call_lowered_entry(apStartupEntryLowered, (void*)userStackTop);
     while (1);
 }

kernel/src/entry/kernel_entry.cpp

@@ -23,15 +23,9 @@
 #include <time/ktime.h>
 #include <kprint.h>
 
-#include "tests/kernel_unit_tests.h"
-#include "tests/kernel_entry_tests.h"
-
-// #define KE_TEST_MULTITHREADING
-// #define KE_TEST_XHCI_INIT
-// #define KE_TEST_AP_STARTUP
-// #define KE_TEST_CPU_TEMP_READINGS
-// #define KE_TEST_PRINT_CURRENT_TIME
-// #define KE_TEST_GRAPHICS
+#ifdef KRUN_UNIT_TESTS
+    #include "tests/kernel_unit_tests.h"
+#endif
 
 EXTERN_C __PRIVILEGED_CODE void _kentry(KernelEntryParams* params);
 extern uint64_t __kern_phys_base;
@@ -75,6 +69,8 @@ __PRIVILEGED_CODE void _kentry(KernelEntryParams* params) {
     g_kernelSwapperTasks[BSP_CPU_ID].pid = 1;
     zeromem(&g_kernelSwapperTasks[BSP_CPU_ID].context, sizeof(CpuContext));
     g_kernelSwapperTasks[BSP_CPU_ID].context.rflags |= 0x200;
+    g_kernelSwapperTasks[BSP_CPU_ID].userStackTop =
+        (uint64_t)(__usermodeKernelEntryStack + USERMODE_KERNEL_ENTRY_STACK_SIZE);
 
     // Elevated flag must be 0 since we are going to lower ourselves in the next few calls.
     // TO-DO: investigate further why setting elevated flag to 1 here causes a crash. 
@@ -183,30 +179,6 @@ void _kuser_entry() {
     // Bring up all available processor cores
     initializeApCores();
 
-#ifdef KE_TEST_MULTITHREADING
-    ke_test_multithreading();
-#endif
-
-#ifdef KE_TEST_XHCI_INIT
-    ke_test_xhci_init();
-#endif
-
-#ifdef KE_TEST_AP_STARTUP
-    ke_test_ap_startup();
-#endif
-
-#ifdef KE_TEST_CPU_TEMP_READINGS
-    ke_test_read_cpu_temps();
-#endif
-
-#ifdef KE_TEST_PRINT_CURRENT_TIME
-    ke_test_print_current_time();
-#endif
-
-#ifdef KE_TEST_GRAPHICS
-    ke_test_graphics();
-#endif
-
 #ifdef KRUN_UNIT_TESTS
     // Run unit tests
     executeUnitTests();

kernel/src/entry/tests/kernel_entry_xhci_init_test.cpp

@@ -1,4 +1,3 @@
-#include "kernel_entry_tests.h"
 #include <core/kprint.h>
 #include <kelevate/kelevate.h>
 #include <acpi/acpi_controller.h>

kernel/src/entry/tests/memory_allocation.test.cpp

@@ -83,16 +83,16 @@ DECLARE_UNIT_TEST("Heap Allocate - Heavy", kheapHeavyAllocateUnitTest) {
         // Print progress every 10% of iterations or every 100 MB
         if ((i + 1) % reportInterval == 0 || totalAllocatedBytes >= nextMemoryMilestone) {
             kuPrint(UNIT_TEST "Allocated %llu MB of memory after %llu iterations\n",
-                (unsigned long long)(totalAllocatedBytes / bytesPerMB),
-                (unsigned long long)(i + 1));
+                (uint64_t)(totalAllocatedBytes / bytesPerMB),
+                (uint64_t)(i + 1));
 
             // Update the memory milestone for the next 100 MB
             nextMemoryMilestone += 100 * bytesPerMB;
         }
     }
 
     kuPrint(UNIT_TEST "Finished allocating %llu MB of memory in total\n", 
-        (unsigned long long)(totalAllocatedBytes / bytesPerMB));
+        (uint64_t)(totalAllocatedBytes / bytesPerMB));
 
     // Free all the allocated memory in this test
     for (size_t i = 0; i < iterations; i++) {
@@ -204,3 +204,63 @@ DECLARE_UNIT_TEST("Paging - Allocate Multiple Zeroed Pages", pagingAllocateMulti
 
     return UNIT_TEST_SUCCESS;
 }
+
+DECLARE_UNIT_TEST("Paging and Heap Allocation Combined Test", kheapWithPagingAllocationUnitTest) {
+    const size_t allocSize = 100000;  // Allocation size in bytes
+    const size_t iterations = 8000; // Number of allocations
+    const size_t reportInterval = iterations / 10; // Report every 10% of iterations
+    const size_t bytesPerMB = 1024 * 1024;
+    size_t nextMemoryMilestone = 100 * bytesPerMB; // First memory milestone (100 MB)
+
+    void** savedHeapPointers = (void**)kmalloc(sizeof(void*) * iterations);
+    ASSERT_TRUE_CRITICAL(savedHeapPointers, "Failed to allocate a buffer for heap memory pointers");
+
+    void** savedPagePointers = (void**)kmalloc(sizeof(void*) * iterations);
+    ASSERT_TRUE_CRITICAL(savedPagePointers, "Failed to allocate a buffer for allocated page pointers");
+
+    size_t totalAllocatedBytes = 0;  // Track total allocated memory in bytes
+
+    // Perform a heavy-weight tight loop allocation test
+    for (size_t i = 0; i < iterations; i++) {
+        void* ptr = kmalloc(allocSize);
+        ASSERT_TRUE_CRITICAL(ptr, "Allocated heap memory pointer was null");
+
+        void* page = zallocPage();
+        ASSERT_TRUE_CRITICAL(page, "Allocated virtual page pointer was null");
+
+        savedHeapPointers[i] = ptr;
+        savedPagePointers[i] = page;
+
+        totalAllocatedBytes += allocSize;
+
+        // Print progress every 10% of iterations or every 100 MB
+        if ((i + 1) % reportInterval == 0 || totalAllocatedBytes >= nextMemoryMilestone) {
+            kuPrint(UNIT_TEST "Allocated %llu MB of heap memory and %llu pages after %llu iterations\n",
+                (uint64_t)(totalAllocatedBytes / bytesPerMB),
+                (uint64_t)(i + 1),
+                (uint64_t)(i + 1));
+
+            // Update the memory milestone for the next 100 MB
+            nextMemoryMilestone += 100 * bytesPerMB;
+        }
+    }
+
+    kuPrint(UNIT_TEST "Finished allocating %llu MB of heap memory and %llu pages in total\n", 
+        (uint64_t)(totalAllocatedBytes / bytesPerMB), iterations);
+
+    // Free all the allocated heap memory in this test
+    for (size_t i = 0; i < iterations; i++) {
+        kfree(savedHeapPointers[i]);
+    }
+
+    // Free all the allocated pages in this test
+    for (size_t i = 0; i < iterations; i++) {
+        freePage(savedPagePointers[i]);
+    }
+
+    // Free the pointer buffers
+    kfree(savedHeapPointers);
+    kfree(savedPagePointers);
+
+    return UNIT_TEST_SUCCESS;
+}