Shell And Tools

Add fd_table field to Process struct. Why it matters: Per-process file descriptors are required for correct POSIX semantics where each process has independent FD state. Focus on `Process::fd_table` and `Process` in `kernel/src/process/mod.rs` while you trace the snippet.

/// Descriptor for a single userspace process.
pub struct Process {
    /// This process's unique identifier.
    pub pid: Pid,
    /// Parent PID.  0 means no parent (init or an orphan).
    pub ppid: Pid,
    /// Current lifecycle state.
    pub state: ProcessState,
    /// Root physical address of this process's page table.
    ///
    /// `None` means the process has not yet been assigned a dedicated
    /// address space and shares the kernel's mappings (pre-Phase 12).
    pub page_table_root: Option<x86_64::PhysAddr>,
    /// Top of this process's kernel-mode stack (virtual address).
    pub kernel_stack_top: u64,
    /// Userspace entry-point virtual address.
    pub entry_point: u64,
    /// Initial userspace RSP: the virtual address of `argc` on the ABI stack,
    /// as returned by `setup_abi_stack`.  This is **not** the raw top of the
    /// stack allocation — it points into the stack, below the argv/envp data.
    pub user_stack_top: u64,
    /// Exit code written when the process transitions to [`ProcessState::Zombie`].
    pub exit_code: Option<i32>,
    /// Signal that caused the process to stop (set when transitioning to Stopped).

View on GitHub

Deep-clone fd_table in sys_fork. Why it matters: Forked children must inherit the parent's open file descriptors so pipes and redirections work across fork boundaries. Focus on `sys_fork` and `fd_table` in `kernel/src/arch/x86_64/syscall.rs` while you trace the snippet.

/// `fork()` — create a child process that resumes after the syscall with rax=0.
///
/// Allocates a fresh page table for the child (eager copy of user pages),
/// registers the child in the process table, and spawns a kernel task whose
/// entry function enters ring 3 at `user_rip` with `user_rsp` and rax=0.
///
/// Returns the child PID to the parent.
fn sys_fork(user_rip: u64, user_rsp: u64) -> u64 {
    let parent_pid = crate::process::CURRENT_PID.load(core::sync::atomic::Ordering::Relaxed);
    log::info!("[p{}] fork()", parent_pid);

    // Allocate a new page table for the child, copying kernel entries.
    let child_cr3 = match crate::mm::new_process_page_table() {
        Some(f) => f,
        None => {
            log::warn!("[fork] out of frames for child page table");
            return u64::MAX;
        }
    };

    // Copy all user-accessible pages from parent into child's page table.
    let phys_off = crate::mm::phys_offset();
    {
        // SAFETY: child_cr3 was just allocated; no other mapper over it exists.

View on GitHub

Define Pipe struct. Why it matters: The kernel pipe buffer is the foundation for inter-process communication via the shell pipeline operator. Focus on `Pipe` in `kernel/src/pipe.rs` while you trace the snippet.

/// A kernel pipe: ring buffer with ref-counted reader/writer ends.
pub struct Pipe {
    buf: [u8; PIPE_BUF_SIZE],
    /// Read position in the ring buffer.
    read_pos: usize,
    /// Number of valid bytes in the buffer (0 = empty, PIPE_BUF_SIZE = full).
    count: usize,
    /// Number of open read-end references (FDs pointing to PipeRead for this pipe).
    pub reader_count: u32,
    /// Number of open write-end references (FDs pointing to PipeWrite for this pipe).
    pub writer_count: u32,
}

View on GitHub