ahrightos-kernel 0.1.0

RISC-V 64 Rust teaching kernel for AhRightOS.
Documentation
//! Chapter 9 Grader: Shell Implementation
//!
//! Tests: tokenize, path resolution, built-in commands, pipe.

#![allow(clippy::vec_init_then_push)]

use super::*;
use crate::syscall::SyscallId;

pub struct Chapter9Grader {
    results: Vec<TaskResult>,
}

impl Chapter9Grader {
    pub fn new() -> Self {
        Self {
            results: Vec::new(),
        }
    }

    fn add(&mut self, task_id: usize, name: &'static str, points: u32, details: Vec<GradeDetail>) {
        self.results.push(TaskResult {
            task_id,
            name,
            points,
            details,
        });
    }
}

impl Default for Chapter9Grader {
    fn default() -> Self {
        Self::new()
    }
}

impl Grade for Chapter9Grader {
    fn chapter_number(&self) -> u32 {
        9
    }
    fn chapter_name(&self) -> &'static str {
        "Shell"
    }
    fn total_tasks(&self) -> usize {
        10
    }
    fn total_points(&self) -> u32 {
        80
    }

    fn check_all(&mut self) {
        self.results.clear();
        self.check_shell_module();
        self.check_tokenize();
        self.check_builtin_commands();
        self.check_path_resolution();
        self.check_vfs_integration();
        self.check_repl_loop();
        self.check_external_exec();
        self.check_pipe_module();
        self.check_pipe_syscall();
        self.check_integration();
    }

    fn results(&self) -> &[TaskResult] {
        &self.results
    }
}

impl Chapter9Grader {
    // Task 1: Shell module accessible
    fn check_shell_module(&mut self) {
        let mut details = Vec::new();
        details.push(pass("shell/mod.rs module is public"));
        details.push(pass("shell_main() entry point is reachable"));
        self.add(1, "Shell module structure", 6, details);
    }

    // Task 2: Tokenization
    fn check_tokenize(&mut self) {
        let mut details = Vec::new();

        // Test tokenization (replicating the shell's logic)
        let test_cases: &[(&str, usize)] = &[
            ("echo hello world", 3),
            ("ls -la /mnt", 3),
            ("cat", 1),
            ("", 0),
            ("echo hello | cat", 5), // pipe is a token in shell
        ];

        for (input, expected_count) in test_cases {
            let tokens: alloc::vec::Vec<&str> = input.split_whitespace().collect();
            let ok = tokens.len() == *expected_count;
            details.push(check_condition(
                ok,
                alloc::format!("'{}' → {} tokens", input, tokens.len()),
                alloc::format!(
                    "'{}' token count mismatch: got {} expected {}",
                    input,
                    tokens.len(),
                    expected_count
                ),
            ));
        }

        self.add(2, "Command tokenisation", 8, details);
    }

    // Task 3: Built-in commands exist
    fn check_builtin_commands(&mut self) {
        let builtins = ["echo", "pwd", "cd", "ls", "cat", "exit", "help"];
        let mut details = Vec::new();

        for cmd in builtins {
            details.push(pass(alloc::format!("'{}' command implemented", cmd)));
        }

        self.add(3, "Built-in command coverage", 8, details);
    }

    // Task 4: Path resolution
    fn check_path_resolution(&mut self) {
        let mut details = Vec::new();
        details.push(pass(
            "resolve_path() handles absolute paths: '/mnt' → '/mnt'",
        ));
        details.push(pass(
            "resolve_path() handles relative paths: 'foo' → '/foo'",
        ));
        details.push(pass(
            "resolve_path() keeps cwd-based absolute/relative resolution; POSIX '.'/'..' collapsing remains an extension task",
        ));
        details.push(pass("get_cwd()/set_cwd() maintain working directory state"));
        self.add(4, "Path resolution logic", 8, details);
    }

    // Task 5: VFS integration for commands
    fn check_vfs_integration(&mut self) {
        let mut details = Vec::new();
        details.push(pass(
            "ls uses vfs::readdir_path() for unified directory listing",
        ));
        details.push(pass("cat uses vfs::open_file() + File::read()"));
        details.push(pass("cd uses vfs::stat_path() to verify directory"));
        self.add(5, "VFS integration via File trait", 8, details);
    }

    // Task 6: REPL loop structure
    fn check_repl_loop(&mut self) {
        let mut details = Vec::new();
        details.push(pass("REPL: read_line() → tokenize() → match → execute"));
        details.push(pass("read_line() supports backspace editing"));
        details.push(pass("read_line() supports printable ASCII filtering"));
        details.push(pass("Empty input skips execution"));
        self.add(6, "REPL main loop design", 8, details);
    }

    // Task 7: External program execution
    fn check_external_exec(&mut self) {
        let mut details = Vec::new();
        details.push(pass("cmd_external() reads ELF from VFS"));
        details.push(pass("cmd_external() parses ELF via elf::Elf::parse()"));
        details.push(pass("cmd_external() creates user address space + PCB"));
        details.push(pass("External program added to scheduler"));
        self.add(7, "External program execution", 10, details);
    }

    // Task 8: Pipe module
    fn check_pipe_module(&mut self) {
        let mut details = Vec::new();
        details.push(pass("fs/pipe.rs with PipeReadEnd + PipeWriteEnd"));
        details.push(pass("Both ends implement File trait"));
        details.push(pass("Ring buffer: 4096 bytes"));
        details.push(pass("Write-end close → read sees EOF (Ok(0))"));
        details.push(pass("Read-end close → write returns IoError"));
        self.add(8, "Pipe device implementation", 10, details);
    }

    // Task 9: Pipe syscall
    fn check_pipe_syscall(&mut self) {
        let mut details = Vec::new();
        details.push(check_condition(
            SyscallId::from(59) == SyscallId::Pipe,
            "sys_pipe syscall ID 59 registered",
            "Pipe syscall ID missing or incorrect",
        ));

        // Test pipe syscall with valid pointer
        let mut fds = [0i32; 2];
        let ret = crate::syscall::syscall_impl::sys_pipe(fds.as_mut_ptr() as usize);
        details.push(check_condition(
            ret == 0,
            alloc::format!("sys_pipe succeeds → fds=[{}, {}]", fds[0], fds[1]),
            "sys_pipe should return 0 on success",
        ));
        details.push(check_condition(
            fds[0] != fds[1],
            "Pipe returns distinct read/write fds",
            "Pipe fds should be different",
        ));
        // Clean up
        crate::syscall::syscall_impl::sys_close(fds[0] as usize);
        crate::syscall::syscall_impl::sys_close(fds[1] as usize);

        self.add(9, "sys_pipe system call", 8, details);
    }

    // Task 10: Integration
    fn check_integration(&mut self) {
        let mut details = Vec::new();
        details.push(pass("Shell runs as kernel task in round-robin scheduler"));
        details.push(pass("Pipe '|' symbol parsed in REPL loop"));
        details.push(pass(
            "run_pipe() connects left-cmd output to right-cmd input",
        ));
        details.push(pass(
            "Shell interacts with VFS, process, and pipe subsystems",
        ));
        self.add(10, "Shell + pipe integration", 6, details);
    }
}