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)?;
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)?;
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)?;
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)?;
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)?;
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));
}
}