Expanded Memory

permissions to set when demand-mapping a frame, and mprotect needs flags to split. Why it matters: The page fault handler needs protection bits to know what. Focus on `MemoryMapping` in `kernel/src/process/mod.rs` while you trace the snippet.

/// Describes a contiguous anonymous memory mapping created by `mmap`.
#[derive(Clone, Debug)]
pub struct MemoryMapping {
    /// Starting virtual address (page-aligned).
    pub start: u64,
    /// Length in bytes (page-aligned, as recorded by `sys_linux_mmap`).
    pub len: u64,
    /// Protection bits (`PROT_READ | PROT_WRITE | PROT_EXEC`).
    pub prot: u64,
    /// Mapping flags (`MAP_PRIVATE | MAP_ANONYMOUS`).
    pub flags: u64,
}

View on GitHub

protection and flags so later fault handling and mprotect can use them. Why it matters: The VMA entry created by mmap must carry the caller's requested. Focus on `sys_linux_mmap` and `prot` in `kernel/src/arch/x86_64/syscall.rs` while you trace the snippet.

fn sys_linux_mmap(addr_hint: u64, len: u64, prot: u64) -> u64 {
    // Read flags from SYSCALL_ARG3 (r10 at syscall entry).
    // SAFETY: single-CPU, read after every SYSCALL entry stores to SYSCALL_ARG3.
    let flags = per_core_syscall_arg3();

    const MAP_PRIVATE: u64 = 0x02;
    const MAP_ANONYMOUS: u64 = 0x20;
    if flags & MAP_ANONYMOUS == 0 {
        log::warn!(
            "[mmap] non-anonymous mmap not supported (flags={:#x})",
            flags
        );
        return NEG_EINVAL;
    }
    // Mask prot and flags to supported bits only.
    const PROT_MASK: u64 = 0x7; // PROT_READ | PROT_WRITE | PROT_EXEC
    let prot = prot & PROT_MASK;
    let flags = flags & (MAP_PRIVATE | MAP_ANONYMOUS);

    let len = if len == 0 {
        return NEG_EINVAL;
    } else {
        len
    };

View on GitHub

must check the VMA list to decide whether to allocate a frame or deliver SIGSEGV. Why it matters: This is the demand paging implementation — the page fault handler. Focus on `page_fault_handler` and `prot` in `kernel/src/arch/x86_64/interrupts.rs` while you trace the snippet.

extern "x86-interrupt" fn page_fault_handler(
    mut stack_frame: InterruptStackFrame,
    err: PageFaultErrorCode,
) {
    let addr = x86_64::registers::control::Cr2::read();

    // Check if the fault came from ring 3 (user mode).
    if stack_frame.code_segment.rpl() == x86_64::PrivilegeLevel::Ring3 {
        // P17-T031: detect CoW faults — a write to a present, non-writable
        // page marked with BIT_9 (the CoW marker set by cow_clone_user_pages).
        let is_write = err.contains(PageFaultErrorCode::CAUSED_BY_WRITE);
        let is_present = err.contains(PageFaultErrorCode::PROTECTION_VIOLATION);
        if is_write
            && is_present
            && let Ok(fault_vaddr) = addr
        {
            let fault_addr_u64 = fault_vaddr.as_u64();
            if has_cow_marker(fault_addr_u64) {
                // CoW fault — resolve directly in the ISR. Safe because
                // the fault is from ring 3 (no kernel locks held) and
                // we're on a single CPU. On OOM, fall through to kill.
                if resolve_cow_fault(fault_addr_u64) {
                    return;
                }

View on GitHub