ahrightos-kernel 0.1.0

RISC-V 64 Rust teaching kernel for AhRightOS.
Documentation
//! Bounded user-pointer helpers for syscall implementations.
//!
//! When Sv39 is active, these helpers validate every touched page against the
//! current page table before dereferencing: syscall pointers must refer to
//! user-accessible PTEs and have the requested read/write permission. Early
//! kernel self-tests that run before paging is enabled still use the direct
//! no-Sv39 path.

use crate::errno::{self, Errno};
use crate::memory::{PageTable, PageTableEntry, PageTableFlags, PhysAddr, VirtAddr, PAGE_SIZE};
use alloc::string::String;
use alloc::vec::Vec;
use core::{cmp, mem, ptr, slice, str};

pub const MAX_C_STRING_LEN: usize = 4096;
pub const MAX_USER_COPY_LEN: usize = 64 * 1024;

#[derive(Clone, Copy)]
enum Access {
    Read,
    Write,
}

pub fn read_raw_c_string(ptr: usize) -> Result<String, Errno> {
    if ptr == 0 {
        return Err(errno::EFAULT);
    }

    let mut bytes = Vec::new();
    for offset in 0..MAX_C_STRING_LEN {
        let addr = ptr.checked_add(offset).ok_or(errno::EFAULT)?;
        validate_user_range(addr, 1, Access::Read)?;

        // SAFETY: AhRightOS currently reads user memory directly; invalid
        // mappings are handled by the trap path. The loop bounds the read.
        let byte = unsafe { *(addr as *const u8) };
        if byte == 0 {
            return str::from_utf8(&bytes)
                .map(String::from)
                .map_err(|_| errno::EINVAL);
        }
        bytes.push(byte);
    }

    Err(errno::EINVAL)
}

#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub fn raw_copy_from_user(ptr: *const u8, len: usize) -> Result<Vec<u8>, Errno> {
    if len == 0 {
        return Ok(Vec::new());
    }
    if ptr.is_null() {
        return Err(errno::EFAULT);
    }

    let capped_len = cmp::min(len, MAX_USER_COPY_LEN);
    validate_user_range(ptr as usize, capped_len, Access::Read)?;

    // SAFETY: See module docs. The helper preserves the existing direct-copy
    // behavior while bounding allocation and copy size.
    Ok(unsafe { slice::from_raw_parts(ptr, capped_len).to_vec() })
}

pub fn raw_copy_to_user(ptr: usize, bytes: &[u8]) -> Result<(), Errno> {
    if bytes.is_empty() {
        return Ok(());
    }
    if ptr == 0 {
        return Err(errno::EFAULT);
    }

    validate_user_range(ptr, bytes.len(), Access::Write)?;

    // SAFETY: See module docs. Destination length is exactly `bytes.len()`.
    unsafe {
        slice::from_raw_parts_mut(ptr as *mut u8, bytes.len()).copy_from_slice(bytes);
    }
    Ok(())
}

pub fn raw_write_value<T: Copy>(ptr: usize, value: T) -> Result<(), Errno> {
    if ptr == 0 {
        return Err(errno::EFAULT);
    }

    validate_user_range(ptr, mem::size_of::<T>(), Access::Write)?;

    // SAFETY: See module docs. Caller passes a C-compatible value for the
    // target syscall ABI.
    unsafe {
        ptr::write(ptr as *mut T, value);
    }
    Ok(())
}

pub fn raw_write_values<T: Copy>(ptr: usize, values: &[T]) -> Result<(), Errno> {
    if values.is_empty() {
        return Ok(());
    }
    if ptr == 0 {
        return Err(errno::EFAULT);
    }

    let byte_len = values
        .len()
        .checked_mul(mem::size_of::<T>())
        .ok_or(errno::EFAULT)?;
    validate_user_range(ptr, byte_len, Access::Write)?;

    // SAFETY: See module docs. Elements are written contiguously into the
    // caller-provided output buffer.
    unsafe {
        let dst = ptr as *mut T;
        for (idx, value) in values.iter().copied().enumerate() {
            ptr::write(dst.add(idx), value);
        }
    }
    Ok(())
}

fn validate_user_range(start: usize, len: usize, access: Access) -> Result<(), Errno> {
    if len == 0 {
        return Ok(());
    }

    let end = start.checked_add(len - 1).ok_or(errno::EFAULT)?;
    let root = match active_sv39_root() {
        Some(root) => root,
        None => return Ok(()),
    };
    if !is_sv39_canonical(start) || !is_sv39_canonical(end) {
        return Err(errno::EFAULT);
    }

    let mut page = start & !(PAGE_SIZE - 1);
    let last_page = end & !(PAGE_SIZE - 1);
    loop {
        if !is_sv39_canonical(page) {
            return Err(errno::EFAULT);
        }
        let pte = lookup_leaf_pte(root, VirtAddr::new(page)).ok_or(errno::EFAULT)?;
        validate_user_pte(pte, access)?;

        if page == last_page {
            break;
        }
        page = page.checked_add(PAGE_SIZE).ok_or(errno::EFAULT)?;
    }

    Ok(())
}

fn is_sv39_canonical(addr: usize) -> bool {
    const SV39_SIGN_BIT: usize = 1 << 38;
    const SV39_UPPER_SHIFT: usize = 39;
    const SV39_UPPER_BITS: usize = usize::BITS as usize - SV39_UPPER_SHIFT;
    const SV39_UPPER_MASK: usize = (1usize << SV39_UPPER_BITS) - 1;

    let upper = addr >> SV39_UPPER_SHIFT;
    if (addr & SV39_SIGN_BIT) == 0 {
        upper == 0
    } else {
        upper == SV39_UPPER_MASK
    }
}

fn active_sv39_root() -> Option<PhysAddr> {
    const SATP_MODE_SHIFT: usize = 60;
    const SATP_MODE_SV39: usize = 8;
    const SATP_PPN_MASK: usize = (1usize << 44) - 1;

    let satp: usize;
    unsafe {
        core::arch::asm!("csrr {}, satp", out(reg) satp);
    }

    if (satp >> SATP_MODE_SHIFT) != SATP_MODE_SV39 {
        return None;
    }

    Some(PhysAddr::new((satp & SATP_PPN_MASK) << 12))
}

fn lookup_leaf_pte(root_paddr: PhysAddr, vaddr: VirtAddr) -> Option<PageTableEntry> {
    let root = unsafe { &*(root_paddr.as_usize() as *const PageTable) };
    let pte2 = *root.get_entry(vaddr.vpn2());
    if !pte2.is_valid() {
        return None;
    }
    if pte2.is_leaf() {
        return Some(pte2);
    }

    let table1 = unsafe { &*(pte2.phys_addr().as_usize() as *const PageTable) };
    let pte1 = *table1.get_entry(vaddr.vpn1());
    if !pte1.is_valid() {
        return None;
    }
    if pte1.is_leaf() {
        return Some(pte1);
    }

    let table0 = unsafe { &*(pte1.phys_addr().as_usize() as *const PageTable) };
    let pte0 = *table0.get_entry(vaddr.vpn0());
    if pte0.is_valid() && pte0.is_leaf() {
        Some(pte0)
    } else {
        None
    }
}

fn validate_user_pte(pte: PageTableEntry, access: Access) -> Result<(), Errno> {
    let flags = pte.flags();
    if (flags & PageTableFlags::User as usize) == 0 {
        return Err(errno::EFAULT);
    }

    match access {
        Access::Read if (flags & PageTableFlags::Read as usize) == 0 => Err(errno::EFAULT),
        Access::Write if (flags & PageTableFlags::Write as usize) == 0 => Err(errno::EFAULT),
        _ => Ok(()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn pte_with_flags(flags: usize) -> PageTableEntry {
        let mut pte = PageTableEntry::new();
        pte.set(0x80000, flags | PageTableFlags::Valid as usize);
        pte
    }

    #[test_case]
    fn rejects_kernel_pte_without_user_flag() {
        let pte = pte_with_flags(PageTableFlags::Read as usize | PageTableFlags::Write as usize);
        assert_eq!(validate_user_pte(pte, Access::Read), Err(errno::EFAULT));
        assert_eq!(validate_user_pte(pte, Access::Write), Err(errno::EFAULT));
    }

    #[test_case]
    fn enforces_requested_user_permission() {
        let read_only =
            pte_with_flags(PageTableFlags::User as usize | PageTableFlags::Read as usize);
        assert_eq!(validate_user_pte(read_only, Access::Read), Ok(()));
        assert_eq!(
            validate_user_pte(read_only, Access::Write),
            Err(errno::EFAULT)
        );
    }

    #[test_case]
    fn rejects_overflowing_user_range() {
        assert_eq!(
            validate_user_range(usize::MAX, 2, Access::Read),
            Err(errno::EFAULT)
        );
    }

    #[test_case]
    fn rejects_noncanonical_sv39_addresses() {
        assert!(is_sv39_canonical(0));
        assert!(is_sv39_canonical((1usize << 38) - 1));
        assert!(!is_sv39_canonical(1usize << 39));
        assert!(!is_sv39_canonical(usize::MAX >> 1));
    }
}