summaryrefslogtreecommitdiff
path: root/test/test_exec.cc
diff options
context:
space:
mode:
Diffstat (limited to 'test/test_exec.cc')
-rw-r--r--test/test_exec.cc447
1 files changed, 447 insertions, 0 deletions
diff --git a/test/test_exec.cc b/test/test_exec.cc
new file mode 100644
index 0000000..bbfa3b6
--- /dev/null
+++ b/test/test_exec.cc
@@ -0,0 +1,447 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* Copyright (C) 2026 Richard Qin */
+
+/*
+ * test_exec.cc — Self-tests for execve / ELF loader
+ *
+ * Tests the ELF validation, binary loading, and user stack construction
+ * by creating synthetic ELF binaries in RamFS and invoking do_execve
+ * in a controlled environment.
+ *
+ * We cannot test the actual user-space transition (that requires
+ * sret to U-mode), but we CAN test everything up to and including
+ * the trapframe setup.
+ */
+
+#include <lume/selftest.h>
+#include <lume/elf.h>
+#include <lume/task.h>
+#include <lume/vmm.h>
+#include <lume/pmm.h>
+#include <lume/addr.h>
+#include <lume/errno.h>
+#include <lume/fdtable.h>
+#include <lume/fs.h>
+#include <lume/fs_struct.h>
+#include <lume/dcache.h>
+#include <lume/namei.h>
+#include <lume/file.h>
+#include <lume/mm_layout.h>
+#include <arch/trapframe.h>
+#include <arch/pmap.h>
+
+/* Extern: do_execve (kernel/exec.cc) */
+int do_execve(const char* pathname, const char* const* argv,
+ const char* const* envp);
+
+/* Extern: VFS file creation syscalls */
+int64 sys_openat(uint64, uint64, uint64, uint64, uint64, uint64);
+int64 sys_write(uint64, uint64, uint64, uint64, uint64, uint64);
+int64 sys_close(uint64, uint64, uint64, uint64, uint64, uint64);
+
+/* ================================================================== */
+/* Helper: build a minimal valid RISC-V ELF64 in a buffer */
+/* ================================================================== */
+
+struct TestElf {
+ Elf64_Ehdr ehdr;
+ Elf64_Phdr phdr;
+ uint8 code[16]; /* Tiny "program" — just a few NOPs */
+};
+
+/*
+ * Build a minimal static ELF64 for RISC-V.
+ * Single PT_LOAD segment mapping the tiny code at 0x10000.
+ * Entry point = 0x10000 + offsetof(code).
+ */
+static void build_minimal_elf(TestElf* elf)
+{
+ /* Zero everything */
+ for (uint64 i = 0; i < sizeof(*elf); i++)
+ reinterpret_cast<uint8*>(elf)[i] = 0;
+
+ /* ELF header */
+ Elf64_Ehdr* e = &elf->ehdr;
+ e->e_ident[EI_MAG0] = ELFMAG0;
+ e->e_ident[EI_MAG1] = ELFMAG1;
+ e->e_ident[EI_MAG2] = ELFMAG2;
+ e->e_ident[EI_MAG3] = ELFMAG3;
+ e->e_ident[EI_CLASS] = ELFCLASS64;
+ e->e_ident[EI_DATA] = ELFDATA2LSB;
+ e->e_ident[EI_VERSION] = 1;
+ e->e_type = ET_EXEC;
+ e->e_machine = EM_RISCV;
+ e->e_version = 1;
+ e->e_phoff = sizeof(Elf64_Ehdr);
+ e->e_phentsize = sizeof(Elf64_Phdr);
+ e->e_phnum = 1;
+ e->e_ehsize = sizeof(Elf64_Ehdr);
+
+ /* Code section offset within the file */
+ uint64 code_offset = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr);
+
+ /* Entry point = vaddr of code */
+ uint64 load_vaddr = 0x10000;
+ e->e_entry = load_vaddr + code_offset;
+
+ /* Program header — single PT_LOAD covering entire file */
+ Elf64_Phdr* p = &elf->phdr;
+ p->p_type = PT_LOAD;
+ p->p_flags = PF_R | PF_X;
+ p->p_offset = 0;
+ p->p_vaddr = load_vaddr;
+ p->p_paddr = load_vaddr;
+ p->p_filesz = sizeof(TestElf);
+ p->p_memsz = sizeof(TestElf);
+ p->p_align = 0x1000;
+
+ /* Code: RISC-V "unimp" (all zeros = illegal instruction, but good enough for testing) */
+ /* We just need the loader to succeed; we won't actually execute this. */
+ elf->code[0] = 0x13; /* nop = addi x0, x0, 0 */
+ elf->code[4] = 0x13;
+ elf->code[8] = 0x73; /* ebreak */
+}
+
+/* ================================================================== */
+/* Helper: write a buffer to a file in RamFS */
+/* ================================================================== */
+
+static int create_test_file(const char* path, const void* data, uint64 size)
+{
+ /* Open with O_CREAT | O_WRONLY | O_TRUNC */
+ int64 fd = sys_openat(
+ static_cast<uint64>(-100), /* AT_FDCWD */
+ reinterpret_cast<uint64>(path),
+ O_CREAT | O_WRONLY | O_TRUNC,
+ 0755, 0, 0);
+ if (fd < 0) return static_cast<int>(fd);
+
+ int64 written = sys_write(
+ static_cast<uint64>(fd),
+ reinterpret_cast<uint64>(data),
+ size, 0, 0, 0);
+
+ sys_close(static_cast<uint64>(fd), 0, 0, 0, 0, 0);
+
+ if (written < 0) return static_cast<int>(written);
+ if (static_cast<uint64>(written) != size) return -EIO;
+ return 0;
+}
+
+/* ================================================================== */
+/* Helper: ensure current task has VFS context for file ops */
+/* ================================================================== */
+
+struct ExecTestCtx {
+ TaskControlBlock* curr;
+ VmSpace* old_mm;
+ arch::TrapFrame fake_tf;
+ arch::TrapFrame* old_tf;
+ uint64 saved_satp;
+};
+
+static void exec_test_setup(ExecTestCtx* ctx)
+{
+ ctx->curr = current_task();
+
+ /* Save kernel SATP so we can restore it in teardown */
+ asm volatile("csrr %0, satp" : "=r"(ctx->saved_satp));
+
+ /* Save and replace mm with a fresh one */
+ ctx->old_mm = ctx->curr->mm;
+ ctx->curr->mm = VmSpace::create();
+
+ /* Set up a fake trapframe so do_execve can modify it */
+ for (uint64 i = 0; i < sizeof(ctx->fake_tf); i++)
+ reinterpret_cast<uint8*>(&ctx->fake_tf)[i] = 0;
+ ctx->old_tf = ctx->curr->trapframe;
+ ctx->curr->trapframe = &ctx->fake_tf;
+}
+
+static void exec_test_teardown(ExecTestCtx* ctx)
+{
+ /* Restore trapframe */
+ ctx->curr->trapframe = ctx->old_tf;
+
+ /* Destroy the test mm (may have been replaced by do_execve) */
+ VmSpace* test_mm = ctx->curr->mm;
+ ctx->curr->mm = ctx->old_mm;
+ if (test_mm && test_mm != ctx->old_mm) {
+ /* If do_execve succeeded, it activated new_mm's page table.
+ * Switch back to the kernel page table before destroying. */
+ asm volatile("csrw satp, %0" :: "r"(ctx->saved_satp));
+ asm volatile("sfence.vma");
+ test_mm->put();
+ }
+}
+
+/* ================================================================== */
+/* Test cases */
+/* ================================================================== */
+
+void selftest_exec()
+{
+ /* ---- 1a. Non-existent path under missing directory ---- */
+ st_begin("exec: missing path returns error");
+ {
+ const char* argv[] = { "/no_such_dir/no_file", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/no_such_dir/no_file", argv, envp);
+ ST_ASSERT(ret < 0); /* -ENOENT from filename_lookup */
+ }
+ st_pass();
+
+ /* ---- 1b. Directory is not executable ---- */
+ st_begin("exec: directory returns -EACCES");
+ {
+ /* "/" exists and is a directory */
+ const char* argv[] = { "/dev", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/dev", argv, envp);
+ ST_ASSERT_EQ(ret, -EACCES);
+ }
+ st_pass();
+
+ /* ---- 2. Bad ELF magic ---- */
+ st_begin("exec: bad ELF magic returns -ENOEXEC");
+ {
+ uint8 garbage[128];
+ for (int i = 0; i < 128; i++) garbage[i] = 0xAA;
+ int err = create_test_file("/test_bad_magic", garbage, 128);
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_bad_magic", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_bad_magic", argv, envp);
+ ST_ASSERT_EQ(ret, -ENOEXEC);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 3. Wrong ELF class (32-bit) ---- */
+ st_begin("exec: 32-bit ELF returns -ENOEXEC");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ elf.ehdr.e_ident[EI_CLASS] = 1; /* ELFCLASS32 */
+ int err = create_test_file("/test_elf32", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_elf32", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_elf32", argv, envp);
+ ST_ASSERT_EQ(ret, -ENOEXEC);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 4. Wrong endianness (big-endian) ---- */
+ st_begin("exec: big-endian ELF returns -ENOEXEC");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ elf.ehdr.e_ident[EI_DATA] = 2; /* ELFDATA2MSB */
+ int err = create_test_file("/test_be", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_be", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_be", argv, envp);
+ ST_ASSERT_EQ(ret, -ENOEXEC);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 5. Wrong machine (x86_64 instead of RISC-V) ---- */
+ st_begin("exec: wrong machine type returns -ENOEXEC");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ elf.ehdr.e_machine = 62; /* EM_X86_64 */
+ int err = create_test_file("/test_x86", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_x86", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_x86", argv, envp);
+ ST_ASSERT_EQ(ret, -ENOEXEC);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 6. Truncated ELF (too small for header) ---- */
+ st_begin("exec: truncated ELF returns -ENOEXEC");
+ {
+ /* Valid magic but file is too short for full header */
+ uint8 tiny[8] = { 0x7f, 'E', 'L', 'F', 2, 1, 1, 0 };
+ int err = create_test_file("/test_tiny", tiny, sizeof(tiny));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_tiny", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_tiny", argv, envp);
+ ST_ASSERT_EQ(ret, -ENOEXEC);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 7. Zero program headers ---- */
+ st_begin("exec: zero phnum returns -ENOEXEC");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ elf.ehdr.e_phnum = 0;
+ int err = create_test_file("/test_nophdr", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_nophdr", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_nophdr", argv, envp);
+ ST_ASSERT_EQ(ret, -ENOEXEC);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 8. Valid ELF: successful load and trapframe setup ---- */
+ st_begin("exec: valid ELF loads and sets up trapframe");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ int err = create_test_file("/test_valid", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_valid", nullptr };
+ const char* envp[] = { "HOME=/", nullptr };
+ int ret = do_execve("/test_valid", argv, envp);
+ ST_ASSERT_EQ(ret, 0);
+
+ /* Verify trapframe was set up correctly */
+ arch::TrapFrame* tf = &ctx.fake_tf;
+
+ /* Entry point should match what we set in the ELF */
+ uint64 code_offset = sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr);
+ uint64 expected_entry = 0x10000 + code_offset;
+ ST_ASSERT_EQ(tf->epc, expected_entry);
+
+ /* Stack pointer should be in user space, below the stack top */
+ ST_ASSERT(tf->sp > 0);
+ ST_ASSERT(tf->sp < kUserStackTop);
+ ST_ASSERT(tf->sp >= kUserStackBase);
+
+ /* sstatus: SPP=0 (U-mode), SPIE=1 (interrupts enabled on sret) */
+ uint64 spp_bit = (1ULL << 8);
+ uint64 spie_bit = (1ULL << 5);
+ ST_ASSERT_EQ(tf->sstatus & spp_bit, 0ULL); /* Not S-mode */
+ ST_ASSERT_EQ(tf->sstatus & spie_bit, spie_bit); /* SPIE set */
+
+ /* General registers should be zeroed */
+ ST_ASSERT_EQ(tf->ra, 0ULL);
+ ST_ASSERT_EQ(tf->gp, 0ULL);
+ ST_ASSERT_EQ(tf->tp, 0ULL);
+ for (int i = 0; i < 7; i++)
+ ST_ASSERT_EQ(tf->t[i], 0ULL);
+ for (int i = 0; i < 12; i++)
+ ST_ASSERT_EQ(tf->s[i], 0ULL);
+ for (int i = 0; i < 8; i++)
+ ST_ASSERT_EQ(tf->a[i], 0ULL);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 9. Verify user stack layout (argc/argv) ---- */
+ st_begin("exec: user stack has correct argc/argv layout");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ int err = create_test_file("/test_stack", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ const char* argv[] = { "/test_stack", "arg1", nullptr };
+ const char* envp[] = { "A=B", nullptr };
+ int ret = do_execve("/test_stack", argv, envp);
+ ST_ASSERT_EQ(ret, 0);
+
+ /* The stack was set up in the new mm.
+ * Read argc from the top of the stack using pmap lookup. */
+ VmSpace* mm = ctx.curr->mm;
+ uint64 sp = ctx.fake_tf.sp;
+
+ /* Look up the physical page for sp */
+ uint64 pa = 0;
+ bool mapped = pmap::lookup(mm->root_pa, sp & ~(kPageSize - 1), &pa);
+ ST_ASSERT(mapped);
+
+ /* Read argc (first uint64 on stack) */
+ uint64 page_offset = sp & (kPageSize - 1);
+ uint8* kva = reinterpret_cast<uint8*>(pa_to_va(PhysAddr{pa}).raw);
+ uint64 argc = *reinterpret_cast<uint64*>(kva + page_offset);
+ ST_ASSERT_EQ(argc, 2ULL); /* "/test_stack" and "arg1" */
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+
+ /* ---- 10. Multiple consecutive execve replaces mm correctly ---- */
+ st_begin("exec: consecutive execve replaces address space");
+ {
+ TestElf elf;
+ build_minimal_elf(&elf);
+ int err = create_test_file("/test_reexec", &elf, sizeof(elf));
+ ST_ASSERT_EQ(err, 0);
+
+ ExecTestCtx ctx;
+ exec_test_setup(&ctx);
+
+ /* First exec */
+ const char* argv[] = { "/test_reexec", nullptr };
+ const char* envp[] = { nullptr };
+ int ret = do_execve("/test_reexec", argv, envp);
+ ST_ASSERT_EQ(ret, 0);
+
+ VmSpace* first_mm = ctx.curr->mm;
+ ST_ASSERT(first_mm != nullptr);
+
+ /* Second exec — should replace the first mm */
+ ret = do_execve("/test_reexec", argv, envp);
+ ST_ASSERT_EQ(ret, 0);
+
+ /* mm should be different (new address space) */
+ VmSpace* second_mm = ctx.curr->mm;
+ ST_ASSERT(second_mm != nullptr);
+ ST_ASSERT_NE(first_mm, second_mm);
+
+ exec_test_teardown(&ctx);
+ }
+ st_pass();
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-10-29 02:27:30 +0000