test: fix st

Signed-off-by: Niu Zhihong <zhihong@nzhnb.com>

Author: MRNIU

CMakePresets.json

@@ -97,7 +97,7 @@
         },
         "SIMPLEKERNEL_DEFAULT_STACK_SIZE": {
           "type": "STRING",
-          "value": "4096"
+          "value": "16384"
         },
         "SIMPLEKERNEL_TICK": {
           "type": "STRING",

tests/system_test/main.cpp

@@ -2,6 +2,7 @@
  * @copyright Copyright The SimpleKernel Contributors
  */
 
+#include <atomic>
 #include <cstdint>
 #include <new>
 
@@ -11,10 +12,12 @@
 #include "kernel_log.hpp"
 #include "kstd_cstdio"
 #include "kstd_libcxx.h"
+#include "kstd_memory"
 #include "per_cpu.hpp"
 #include "spinlock.hpp"
 #include "syscall.hpp"
 #include "system_test.h"
+#include "task_control_block.hpp"
 #include "task_manager.hpp"
 
 namespace {
@@ -25,7 +28,9 @@ struct test_case {
   bool is_smp_test = false;
 };
 
-std::array<test_case, 18> test_cases = {
+constexpr size_t kTestCount = 18;
+
+std::array<test_case, kTestCount> test_cases = {
     test_case{"ctor_dtor_test", ctor_dtor_test, false},
     test_case{"spinlock_test", spinlock_test, true},
     test_case{"memory_test", memory_test, false},
@@ -45,27 +50,160 @@ std::array<test_case, 18> test_cases = {
     test_case{"kernel_task_test", kernel_task_test, false},
     test_case{"user_task_test", user_task_test, false}};
 
-void run_tests_main() {
+std::array<TestResult, kTestCount> test_results{};
+
+std::atomic<size_t> g_cores_ready{0};
+
+void test_thread_entry(void* arg) {
+  auto idx = reinterpret_cast<uint64_t>(arg);
+  auto& test = test_cases[idx];
+
+  klog::Info("[TEST] Starting: {}", test.name);
+
+  bool passed = test.func();
+
+  klog::Info("[TEST] Finished: {} — {}", test.name, passed ? "PASS" : "FAIL");
+
+  sys_exit(passed ? 0 : 1);
+}
+
+void print_test_summary() {
   int passed = 0;
   int failed = 0;
+  int timed_out = 0;
 
-  for (const auto& test : test_cases) {
-    klog::Info("----{}----", test.name);
-    if (test.func()) {
-      passed++;
-      klog::Info("----{} PASS----", test.name);
+  klog::Info("========================================");
+  klog::Info("     System Test Results");
+  klog::Info("========================================");
+
+  for (size_t i = 0; i < kTestCount; ++i) {
+    auto& r = test_results[i];
+    const char* tag = "???";
+
+    switch (r.status) {
+      case TestThreadStatus::kPassed:
+        tag = "PASS";
+        passed++;
+        break;
+      case TestThreadStatus::kFailed:
+        tag = "FAIL";
+        failed++;
+        break;
+      case TestThreadStatus::kTimeout:
+        tag = "TIMEOUT";
+        timed_out++;
+        break;
+      case TestThreadStatus::kRunning:
+        tag = "TIMEOUT";
+        timed_out++;
+        break;
+      default:
+        tag = "SKIP";
+        break;
+    }
+
+    if (test_cases[i].is_smp_test) {
+      klog::Info("  [{}] {} (SMP, exit_code={})", tag, r.name, r.exit_code);
     } else {
-      failed++;
-      klog::Err("----{} FAIL----", test.name);
+      klog::Info("  [{}] {} (pid={}, exit_code={})", tag, r.name, r.pid,
+                 r.exit_code);
     }
   }
 
+  int total = static_cast<int>(kTestCount);
+
   klog::Info("========================================");
-  klog::Info("Result: {} passed, {} failed, {} total", passed, failed,
-             passed + failed);
+  klog::Info("  Total: {} | Passed: {} | Failed: {} | Timeout: {}", total,
+             passed, failed, timed_out);
   klog::Info("========================================");
+}
+
+void test_runner_entry(void* /*arg*/) {
+  auto& task_mgr = TaskManagerSingleton::instance();
+  auto* runner = task_mgr.GetCurrentTask();
+
+  // Phase 2: 为每个非 SMP 测试创建独立线程，建立父子关系
+  int thread_test_count = 0;
+
+  for (size_t i = 0; i < kTestCount; ++i) {
+    if (test_cases[i].is_smp_test) {
+      continue;
+    }
+
+    auto task = kstd::make_unique<TaskControlBlock>(
+        test_cases[i].name, 10, test_thread_entry, reinterpret_cast<void*>(i));
+
+    // Wait() requires parent-child relationship to collect exit status
+    task->aux->parent_pid = runner->pid;
+    task->aux->pgid = runner->aux->pgid;
+
+    test_results[i].pid = task->pid;
+    test_results[i].status = TestThreadStatus::kRunning;
+
+    task_mgr.AddTask(std::move(task));
+    thread_test_count++;
+  }
+
+  klog::Info("[RUNNER] Spawned {} test threads, collecting via Wait()...",
+             thread_test_count);
+
+  // Phase 3: 通过 Wait() 收集所有测试线程的退出状态
+  int collected = 0;
+  constexpr int kMaxWaitRetries = 1200;  // 1200 * 50ms = 60s 超时
+  int retries = 0;
+
+  while (collected < thread_test_count && retries < kMaxWaitRetries) {
+    int status = 0;
+    auto wait_result =
+        task_mgr.Wait(static_cast<Pid>(-1), &status, true, false);
 
-  QemuExit(failed == 0);
+    if (wait_result.has_value() && wait_result.value() > 0) {
+      Pid exited_pid = wait_result.value();
+
+      for (size_t i = 0; i < kTestCount; ++i) {
+        if (test_results[i].pid == static_cast<int64_t>(exited_pid)) {
+          test_results[i].exit_code = status;
+          test_results[i].status = (status == 0) ? TestThreadStatus::kPassed
+                                                 : TestThreadStatus::kFailed;
+
+          klog::Info("[RUNNER] Collected: {} (pid={}, exit_code={}) — {}",
+                     test_cases[i].name, exited_pid, status,
+                     (status == 0) ? "PASS" : "FAIL");
+          break;
+        }
+      }
+
+      collected++;
+    } else {
+      (void)sys_sleep(50);
+      retries++;
+    }
+  }
+
+  for (size_t i = 0; i < kTestCount; ++i) {
+    if (test_cases[i].is_smp_test) {
+      continue;
+    }
+    if (test_results[i].status == TestThreadStatus::kPending ||
+        test_results[i].status == TestThreadStatus::kRunning) {
+      test_results[i].status = TestThreadStatus::kTimeout;
+      klog::Err("[RUNNER] Timeout: {} (pid={})", test_cases[i].name,
+                test_results[i].pid);
+    }
+  }
+
+  // Phase 4: 汇总打印
+  print_test_summary();
+
+  bool all_passed = true;
+  for (size_t i = 0; i < kTestCount; ++i) {
+    if (test_results[i].status != TestThreadStatus::kPassed) {
+      all_passed = false;
+      break;
+    }
+  }
+
+  QemuExit(all_passed);
 }
 
 void run_tests_smp() {
@@ -85,18 +223,21 @@ auto main_smp(int argc, const char** argv) -> int {
   TimerInitSMP();
   klog::Info("Hello SimpleKernel SMP");
 
+  g_cores_ready.fetch_add(1, std::memory_order_release);
+
   run_tests_smp();
 
+  TaskManagerSingleton::instance().Schedule();
+
   __builtin_unreachable();
 }
 
 }  // namespace
 
-void _start(int argc, const char** argv) {
+auto _start(int argc, const char** argv) -> void {
   if (argv != nullptr) {
     CppInit();
     main(argc, argv);
-    CppDeInit();
   } else {
     main_smp(argc, argv);
   }
@@ -127,7 +268,45 @@ auto main(int argc, const char** argv) -> int {
 
   klog::Info("Hello SimpleKernel");
 
-  run_tests_main();
+  for (size_t i = 0; i < kTestCount; ++i) {
+    test_results[i].name = test_cases[i].name;
+    test_results[i].status = TestThreadStatus::kPending;
+    test_results[i].exit_code = -1;
+    test_results[i].pid = 0;
+  }
+
+  // Phase 1: SMP 测试同步运行（需要跨核屏障协调，必须在调度器启动前完成）
+  size_t expected_cores = BasicInfoSingleton::instance().core_count - 1;
+  klog::Info("[RUNNER] Waiting for {} secondary core(s) to initialize...",
+             expected_cores);
+  while (g_cores_ready.load(std::memory_order_acquire) < expected_cores) {
+    cpu_io::Pause();
+  }
+  klog::Info("[RUNNER] All cores ready, starting SMP tests");
+
+  for (size_t i = 0; i < kTestCount; ++i) {
+    if (!test_cases[i].is_smp_test) {
+      continue;
+    }
+    auto& result = test_results[i];
+    result.status = TestThreadStatus::kRunning;
+
+    klog::Info("[SMP] Running: {}", test_cases[i].name);
+    bool smp_passed = test_cases[i].func();
+
+    result.exit_code = smp_passed ? 0 : 1;
+    result.status =
+        smp_passed ? TestThreadStatus::kPassed : TestThreadStatus::kFailed;
+
+    klog::Info("[SMP] Finished: {} — {}", test_cases[i].name,
+               smp_passed ? "PASS" : "FAIL");
+  }
+
+  auto runner = kstd::make_unique<TaskControlBlock>("test_runner", 10,
+                                                    test_runner_entry, nullptr);
+  TaskManagerSingleton::instance().AddTask(std::move(runner));
+
+  TaskManagerSingleton::instance().Schedule();
 
   __builtin_unreachable();
 }

tests/system_test/system_test.h

@@ -213,3 +213,24 @@ inline void QemuExit([[maybe_unused]] bool success) {
 #endif
   __builtin_unreachable();
 }
+
+// ===========================================================================
+// Test thread result tracking
+// ===========================================================================
+
+/// 测试线程运行状态
+enum class TestThreadStatus : uint8_t {
+  kPending,  ///< 等待启动
+  kRunning,  ///< 运行中
+  kPassed,   ///< 测试通过
+  kFailed,   ///< 测试失败
+  kTimeout,  ///< 超时未完成
+};
+
+/// 单个测试线程的结果记录
+struct TestResult {
+  const char* name = nullptr;
+  int64_t pid = 0;
+  TestThreadStatus status = TestThreadStatus::kPending;
+  int exit_code = -1;
+};