use crate::backend::MemoryOps;
use crate::error::{Error, Result};
use crate::types::*;
pub const PFN_MASK: u64 = (!0xFu64 << 8) & 0xFFFFFFFFFu64;
pub const PAGE_SIZE: usize = 0x1000; pub const PAGE_SHIFT: u32 = 12;
pub const PTE_SHIFT: u8 = 12;
pub const PDE_SHIFT: u8 = 21;
pub const PDPTE_SHIFT: u8 = 30;
pub const PML4E_SHIFT: u8 = 39;
pub const PT_INDEX_MASK: u64 = 0x1FF;
pub const DTB_IDENTITY: Dtb = u64::MAX;
pub struct AddressSpace<'a, B: MemoryOps<PhysAddr>> {
backend: &'a B,
dtb: Dtb,
}
pub struct Translation {
#[allow(dead_code)]
pub address: PhysAddr,
#[allow(dead_code)]
pub large: bool,
#[allow(dead_code)]
pub writable: bool,
#[allow(dead_code)]
pub user: bool,
pub nx: bool,
}
impl Translation {
pub const fn new_huge(pml4e: PageTableEntry, pdpte: PageTableEntry, va: VirtAddr) -> Self {
Self {
address: pdpte.page_frame() + va.huge_page_offset(),
large: true,
writable: pml4e.is_writable() && pdpte.is_writable(),
user: pml4e.is_user() && pdpte.is_user(),
nx: pml4e.is_nx() || pdpte.is_nx(),
}
}
pub const fn new_large(
pml4e: PageTableEntry,
pdpte: PageTableEntry,
pde: PageTableEntry,
va: VirtAddr,
) -> Self {
Self {
address: pde.page_frame() + va.large_page_offset(),
large: true,
writable: pml4e.is_writable() && pdpte.is_writable() && pde.is_writable(),
user: pml4e.is_user() && pdpte.is_user() && pde.is_user(),
nx: pml4e.is_nx() || pdpte.is_nx() || pde.is_nx(),
}
}
pub const fn new(
pml4e: PageTableEntry,
pdpte: PageTableEntry,
pde: PageTableEntry,
pte: PageTableEntry,
va: VirtAddr,
) -> Self {
Self {
address: pte.page_frame() + va.page_offset(),
large: false,
writable: pml4e.is_writable()
&& pdpte.is_writable()
&& pde.is_writable()
&& pte.is_writable(),
user: pml4e.is_user() && pdpte.is_user() && pde.is_user() && pte.is_user(),
nx: pml4e.is_nx() || pdpte.is_nx() || pde.is_nx() || pte.is_nx(),
}
}
}
impl<'a, B: MemoryOps<PhysAddr>> AddressSpace<'a, B> {
pub fn new(backend: &'a B, dtb: Dtb) -> Self {
Self { backend, dtb }
}
fn read_pt_entry(&self, table_base: PhysAddr, index: usize) -> Result<Option<PageTableEntry>> {
match self.backend.read(table_base + 8 * index as u64) {
Ok(entry) => Ok(Some(entry)),
Err(Error::BadPhysicalAddress(_)) => Ok(None),
Err(e) => Err(e),
}
}
pub fn virt_to_phys(&self, va: VirtAddr) -> Result<Option<Translation>> {
if self.dtb == DTB_IDENTITY {
return Ok(Some(Translation {
address: va.0,
large: false,
writable: false,
user: false,
nx: false,
}));
}
let Some(pml4e) = self.read_pt_entry(self.dtb, va.pml4_index())? else {
return Ok(None);
};
if !pml4e.is_present() {
return Ok(None);
}
let Some(pdpte) = self.read_pt_entry(pml4e.page_frame(), va.pdpt_index())? else {
return Ok(None);
};
if !pdpte.is_present() {
return Ok(None);
}
if pdpte.is_large_page() {
return Ok(Some(Translation::new_huge(pml4e, pdpte, va)));
}
let Some(pde) = self.read_pt_entry(pdpte.page_frame(), va.pd_index())? else {
return Ok(None);
};
if !pde.is_present() {
return Ok(None);
}
if pde.is_large_page() {
return Ok(Some(Translation::new_large(pml4e, pdpte, pde, va)));
}
let Some(pte) = self.read_pt_entry(pde.page_frame(), va.pt_index())? else {
return Ok(None);
};
if !pte.is_present() {
return Ok(None);
}
Ok(Some(Translation::new(pml4e, pdpte, pde, pte, va)))
}
}
impl<'a, B: MemoryOps<PhysAddr>> MemoryOps<VirtAddr> for AddressSpace<'a, B> {
fn read_bytes(&self, addr: VirtAddr, buf: &mut [u8]) -> Result<()> {
let mut offset = 0;
while offset < buf.len() {
let curr_vaddr = addr + offset as u64;
let translation = match self.virt_to_phys(curr_vaddr)? {
Some(translation) => translation,
None => {
if offset > 0 {
return Err(Error::PartialRead(offset));
} else {
return Err(Error::BadVirtualAddress(curr_vaddr));
}
}
};
let bytes_available = PAGE_SIZE - curr_vaddr.page_offset() as usize;
let chunk_size = (buf.len() - offset).min(bytes_available);
self.backend
.read_bytes(translation.address, &mut buf[offset..offset + chunk_size])?;
offset += chunk_size;
}
Ok(())
}
fn write_bytes(&self, addr: VirtAddr, buf: &[u8]) -> Result<()> {
let mut offset = 0;
while offset < buf.len() {
let curr_vaddr = addr + offset as u64;
let translation = match self.virt_to_phys(curr_vaddr)? {
Some(translation) => translation,
None => {
if offset > 0 {
return Err(Error::PartialWrite(offset));
} else {
return Err(Error::BadVirtualAddress(curr_vaddr));
}
}
};
let bytes_available = PAGE_SIZE - curr_vaddr.page_offset() as usize;
let chunk_size = (buf.len() - offset).min(bytes_available);
self.backend
.write_bytes(translation.address, &buf[offset..offset + chunk_size])?;
offset += chunk_size;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::MemoryOps;
struct FakePhysMem {
data: Vec<u8>,
}
impl MemoryOps<PhysAddr> for FakePhysMem {
fn read_bytes(&self, addr: PhysAddr, buf: &mut [u8]) -> Result<()> {
let start = addr as usize;
let end = start + buf.len();
if end > self.data.len() {
return Err(Error::BadPhysicalAddress(addr));
}
buf.copy_from_slice(&self.data[start..end]);
Ok(())
}
fn write_bytes(&self, _addr: PhysAddr, _buf: &[u8]) -> Result<()> {
Err(Error::BadPhysicalAddress(0))
}
}
#[test]
fn identity_dtb_skips_page_table_walk() {
let mut data = vec![0u8; 0x2000];
data[0x1000..0x1008].copy_from_slice(&0xDEADBEEFCAFEBABEu64.to_le_bytes());
let mem = FakePhysMem { data };
let space = AddressSpace::new(&mem, DTB_IDENTITY);
let mut buf = [0u8; 8];
space.read_bytes(VirtAddr(0x1000), &mut buf).unwrap();
assert_eq!(u64::from_le_bytes(buf), 0xDEADBEEFCAFEBABE);
}
#[test]
fn identity_dtb_cross_boundary_read() {
let mut data = vec![0u8; 0x3000];
for (i, byte) in data[0xFF0..0x1010].iter_mut().enumerate() {
*byte = ((0xFF0 + i) & 0xFF) as u8;
}
let mem = FakePhysMem { data };
let space = AddressSpace::new(&mem, DTB_IDENTITY);
let mut buf = [0u8; 0x20];
space.read_bytes(VirtAddr(0xFF0), &mut buf).unwrap();
assert_eq!(buf[0], 0xF0);
assert_eq!(buf[0x10], 0x00); assert_eq!(buf[0x1F], 0x0F); }
}