virtual-machine 0.0.3 → 0.0.10

package/src/mmu.rs

@@ -1,331 +0,0 @@
-use crate::bus::Bus;
-use crate::csr::Mode;
-use crate::Trap;
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum AccessType {
-    Instruction,
-    Load,
-    Store,
-}
-
-const PAGE_SIZE: u64 = 4096;
-const PTE_SIZE: u64 = 8;
-const MAX_LEVELS: usize = 4;
-
-const TLB_SIZE: usize = 64;
-
-#[derive(Clone, Copy, Debug)]
-pub struct TlbEntry {
-    pub vpn: u64,
-    pub ppn: u64,
-    pub valid: bool,
-    pub asid: u64,
-    pub global: bool, // Global mapping bit
-    pub r: bool,
-    pub w: bool,
-    pub x: bool,
-    pub u: bool,
-    pub a: bool,
-    pub d: bool,
-}
-
-impl Default for TlbEntry {
-    fn default() -> Self {
-        Self {
-            vpn: 0,
-            ppn: 0,
-            valid: false,
-            asid: 0,
-            global: false,
-            r: false,
-            w: false,
-            x: false,
-            u: false,
-            a: false,
-            d: false,
-        }
-    }
-}
-
-pub struct Tlb {
-    entries: [TlbEntry; TLB_SIZE],
-}
-
-impl Tlb {
-    pub fn new() -> Self {
-        Self {
-            entries: [TlbEntry::default(); TLB_SIZE],
-        }
-    }
-
-    pub fn flush(&mut self) {
-        for entry in self.entries.iter_mut() {
-            entry.valid = false;
-        }
-    }
-
-    pub fn flush_asid(&mut self, asid: u64) {
-        for entry in self.entries.iter_mut() {
-            if !entry.global && entry.asid == asid {
-                entry.valid = false;
-            }
-        }
-    }
-
-    pub fn flush_page(&mut self, vpn: u64, asid: u64) {
-        let idx = (vpn as usize) % TLB_SIZE;
-        let entry = &mut self.entries[idx];
-
-        if entry.valid && entry.vpn == vpn {
-            // For page-specific flush, invalidate matching ASID mappings.
-            // Global mappings ignore ASID and are treated as matching.
-            let match_asid = entry.global || entry.asid == asid;
-            if match_asid {
-                entry.valid = false;
-            }
-        }
-    }
-
-    pub fn lookup(&self, vpn: u64, asid: u64) -> Option<&TlbEntry> {
-        let idx = (vpn as usize) % TLB_SIZE;
-        let entry = &self.entries[idx];
-
-        // Hit if: valid AND VPN matches AND (entry is global OR ASID matches).
-        if entry.valid && entry.vpn == vpn && (entry.global || entry.asid == asid) {
-            Some(entry)
-        } else {
-            None
-        }
-    }
-
-    pub fn insert(&mut self, entry: TlbEntry) {
-        let idx = (entry.vpn as usize) % TLB_SIZE;
-        self.entries[idx] = entry;
-    }
-}
-
-/// Sv39/Sv48 translation + A/D bit updates.
-///
-/// `addr` is a virtual address. Returns the translated physical address or a
-/// `Trap` corresponding to the appropriate page/access fault.
-pub fn translate(
-    bus: &mut dyn Bus,
-    tlb: &mut Tlb,
-    mode: Mode,
-    satp: u64,
-    mstatus: u64,
-    addr: u64,
-    access_type: AccessType,
-) -> Result<u64, Trap> {
-    // No translation in Machine mode (always Bare).
-    if mode == Mode::Machine {
-        return Ok(addr);
-    }
-
-    let satp_mode = (satp >> 60) & 0xF;
-    let current_asid = (satp >> 44) & 0xFFFF;
-
-    let (levels, va_bits, vpn_full_mask): (usize, u64, u64) = match satp_mode {
-        0 => {
-            // Bare: no translation.
-            return Ok(addr);
-        }
-        8 => {
-            // Sv39
-            let levels = 3;
-            let va_bits = 39;
-            let vpn_full_mask = (1u64 << (9 * levels)) - 1;
-            (levels, va_bits, vpn_full_mask)
-        }
-        9 => {
-            // Sv48 (supported by this MMU, though not required for virt).
-            let levels = 4;
-            let va_bits = 48;
-            let vpn_full_mask = (1u64 << (9 * levels)) - 1;
-            (levels, va_bits, vpn_full_mask)
-        }
-        _ => {
-            // Unsupported mode: treat as Bare.
-            return Ok(addr);
-        }
-    };
-
-    // Check canonical form of the virtual address for the configured VA width.
-    let sign_bit = va_bits - 1;
-    let upper_mask = !((1u64 << va_bits) - 1);
-    let sign = (addr >> sign_bit) & 1;
-    let expected_upper = if sign == 1 { upper_mask } else { 0 };
-    if (addr & upper_mask) != expected_upper {
-        return Err(page_fault(access_type, addr));
-    }
-
-    let vpn_full = (addr >> 12) & vpn_full_mask;
-
-    // TLB hit path.
-    if let Some(entry) = tlb.lookup(vpn_full, current_asid) {
-        if check_permission_tlb(mode, mstatus, entry, access_type) {
-            // For now we do not lazily update A/D on TLB hits – page table
-            // entries are already marked by the walk that inserted this entry.
-            let offset = addr & 0xFFF;
-            let pa = (entry.ppn << 12) | offset;
-            return Ok(pa);
-        } else {
-            return Err(page_fault(access_type, addr));
-        }
-    }
-
-    // Page table walk on TLB miss.
-    let mut vpn = [0u64; MAX_LEVELS];
-    for level in 0..levels {
-        vpn[level] = (addr >> (12 + 9 * level as u64)) & 0x1FF;
-    }
-
-    let root_ppn = satp & ((1u64 << 44) - 1);
-    let mut a = root_ppn * PAGE_SIZE;
-
-    for i in (0..levels).rev() {
-        let pte_addr = a + vpn[i] * PTE_SIZE;
-
-        let pte = match bus.load(pte_addr, 8) {
-            Ok(val) => val,
-            Err(_) => return Err(access_fault(access_type, addr)),
-        };
-
-        let v = (pte >> 0) & 1;
-        let r = (pte >> 1) & 1;
-        let w = (pte >> 2) & 1;
-        let x = (pte >> 3) & 1;
-
-        // Invalid or malformed.
-        if v == 0 || (r == 0 && w == 1) {
-            return Err(page_fault(access_type, addr));
-        }
-
-        // Pointer to next level if R=X=0.
-        if r == 0 && x == 0 {
-            if i == 0 {
-                return Err(page_fault(access_type, addr));
-            }
-            let ppn = (pte >> 10) & 0xFFF_FFFF_FFFF;
-            a = ppn * PAGE_SIZE;
-            continue;
-        }
-
-        // Leaf PTE.
-        let mut entry = TlbEntry {
-            vpn: vpn_full,
-            ppn: (pte >> 10) & 0xFFF_FFFF_FFFF,
-            valid: true,
-            asid: current_asid,
-            global: (pte >> 5) & 1 != 0, // G bit
-            r: r != 0,
-            w: w != 0,
-            x: x != 0,
-            u: (pte >> 4) & 1 != 0,
-            a: (pte >> 6) & 1 != 0,
-            d: (pte >> 7) & 1 != 0,
-        };
-
-        if !check_permission_tlb(mode, mstatus, &entry, access_type) {
-            return Err(page_fault(access_type, addr));
-        }
-
-        // Superpage alignment checks (Sv39/48 spec).
-        if i > 0 {
-            let ppn_mask = (1 << (9 * i)) - 1;
-            let ppn = (pte >> 10) & 0xFFF_FFFF_FFFF;
-            if (ppn & ppn_mask) != 0 {
-                return Err(page_fault(access_type, addr));
-            }
-        }
-
-        // A/D bit updates: set in memory and in the cached entry.
-        let mut new_pte = pte;
-        let mut update = false;
-
-        if !entry.a {
-            new_pte |= 1 << 6;
-            entry.a = true;
-            update = true;
-        }
-        if matches!(access_type, AccessType::Store) && !entry.d {
-            new_pte |= 1 << 7;
-            entry.d = true;
-            update = true;
-        }
-
-        if update {
-            if bus.store(pte_addr, 8, new_pte).is_err() {
-                return Err(access_fault(access_type, addr));
-            }
-        }
-
-        let offset_in_page = addr & 0xFFF;
-
-        // Construct final PPN, filling low parts from the VA on superpages.
-        let ppn = (pte >> 10) & 0xFFF_FFFF_FFFF;
-        let vpn_mask = (1 << (9 * i)) - 1;
-        let result_ppn = (ppn & !vpn_mask) | ((addr >> 12) & vpn_mask);
-
-        entry.ppn = result_ppn;
-        tlb.insert(entry);
-
-        let pa = (result_ppn << 12) | offset_in_page;
-        return Ok(pa);
-    }
-
-    Err(page_fault(access_type, addr))
-}
-
-fn check_permission_tlb(mode: Mode, mstatus: u64, entry: &TlbEntry, access_type: AccessType) -> bool {
-    let mxr = (mstatus >> 19) & 1;
-    let sum = (mstatus >> 18) & 1;
-
-    match mode {
-        Mode::Supervisor => {
-            if entry.u {
-                if matches!(access_type, AccessType::Instruction) {
-                    return false;
-                }
-                if sum == 0 {
-                    return false;
-                }
-            }
-        }
-        Mode::User => {
-            if !entry.u {
-                return false;
-            }
-        }
-        Mode::Machine => {}
-    }
-
-    match access_type {
-        AccessType::Instruction => entry.x,
-        AccessType::Store => entry.w,
-        AccessType::Load => {
-            if entry.r {
-                true
-            } else {
-                mxr == 1 && entry.x
-            }
-        }
-    }
-}
-
-fn page_fault(access_type: AccessType, addr: u64) -> Trap {
-    match access_type {
-        AccessType::Instruction => Trap::InstructionPageFault(addr),
-        AccessType::Load => Trap::LoadPageFault(addr),
-        AccessType::Store => Trap::StorePageFault(addr),
-    }
-}
-
-fn access_fault(access_type: AccessType, addr: u64) -> Trap {
-    match access_type {
-        AccessType::Instruction => Trap::InstructionAccessFault(addr),
-        AccessType::Load => Trap::LoadAccessFault(addr),
-        AccessType::Store => Trap::StoreAccessFault(addr),
-    }
-}

package/src/net.rs

@@ -1,121 +0,0 @@
-//! Network backend abstraction for VirtIO networking.
-//!
-//! This module defines the `NetworkBackend` trait that abstracts packet I/O
-//! to support both Host (TAP) and WASM (WebSocket) environments.
-
-/// Trait for network backends that provide packet I/O.
-/// 
-/// Implementations must be `Send` to allow the backend to be used
-/// across thread boundaries (e.g., when the VM runs in a separate thread).
-pub trait NetworkBackend: Send {
-    /// Initialize the backend (e.g., open TAP device or connect WebSocket).
-    fn init(&mut self) -> Result<(), String>;
-    
-    /// Poll for an incoming packet. Returns None if no packet is available.
-    /// This should be non-blocking.
-    fn recv(&mut self) -> Result<Option<Vec<u8>>, String>;
-    
-    /// Send a packet.
-    fn send(&self, buf: &[u8]) -> Result<(), String>;
-    
-    /// Get the MAC address of the backend (if available).
-    /// Returns a default MAC if the backend doesn't have one.
-    fn mac_address(&self) -> [u8; 6] {
-        // Default MAC: locally administered, unicast
-        [0x52, 0x54, 0x00, 0x12, 0x34, 0x56]
-    }
-}
-
-/// A no-op network backend for testing purposes.
-/// 
-/// This backend discards all sent packets and never receives any packets.
-pub struct DummyBackend {
-    initialized: bool,
-    mac: [u8; 6],
-}
-
-impl DummyBackend {
-    pub fn new() -> Self {
-        Self {
-            initialized: false,
-            mac: [0x52, 0x54, 0x00, 0x12, 0x34, 0x56],
-        }
-    }
-    
-    /// Create a dummy backend with a custom MAC address.
-    pub fn with_mac(mac: [u8; 6]) -> Self {
-        Self {
-            initialized: false,
-            mac,
-        }
-    }
-}
-
-impl Default for DummyBackend {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl NetworkBackend for DummyBackend {
-    fn init(&mut self) -> Result<(), String> {
-        self.initialized = true;
-        log::debug!("[DummyBackend] Initialized (no-op)");
-        Ok(())
-    }
-    
-    fn recv(&mut self) -> Result<Option<Vec<u8>>, String> {
-        // No packets ever available
-        Ok(None)
-    }
-    
-    fn send(&self, buf: &[u8]) -> Result<(), String> {
-        // Discard packet, but log it for debugging
-        log::trace!("[DummyBackend] Discarding {} byte packet", buf.len());
-        Ok(())
-    }
-    
-    fn mac_address(&self) -> [u8; 6] {
-        self.mac
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    
-    #[test]
-    fn test_dummy_backend_init() {
-        let mut backend = DummyBackend::new();
-        assert!(backend.init().is_ok());
-    }
-    
-    #[test]
-    fn test_dummy_backend_recv_returns_none() {
-        let mut backend = DummyBackend::new();
-        backend.init().unwrap();
-        assert!(backend.recv().unwrap().is_none());
-    }
-    
-    #[test]
-    fn test_dummy_backend_send_succeeds() {
-        let backend = DummyBackend::new();
-        assert!(backend.send(&[1, 2, 3, 4]).is_ok());
-    }
-    
-    #[test]
-    fn test_dummy_backend_mac_address() {
-        let backend = DummyBackend::new();
-        let mac = backend.mac_address();
-        // Check locally administered bit is set (second bit of first byte)
-        assert_eq!(mac[0] & 0x02, 0x02);
-    }
-    
-    #[test]
-    fn test_dummy_backend_custom_mac() {
-        let custom_mac = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF];
-        let backend = DummyBackend::with_mac(custom_mac);
-        assert_eq!(backend.mac_address(), custom_mac);
-    }
-}
-

package/src/net_tap.rs

@@ -1,164 +0,0 @@
-//! TAP network backend for native (non-WASM) builds.
-//!
-//! This module provides a network backend that uses a TAP interface
-//! to communicate with the host network stack on Linux/macOS.
-
-use crate::net::NetworkBackend;
-use std::io::Write;
-use std::os::unix::io::AsRawFd;
-
-/// TAP network backend using the tun-tap crate.
-pub struct TapBackend {
-    name: String,
-    iface: Option<tun_tap::Iface>,
-    mac: [u8; 6],
-}
-
-impl TapBackend {
-    /// Create a new TAP backend with the given interface name.
-    /// 
-    /// The interface will not be opened until `init()` is called.
-    /// Creating the TAP interface typically requires root privileges.
-    /// 
-    /// # Example
-    /// ```ignore
-    /// let mut tap = TapBackend::new("tap0");
-    /// tap.init()?;
-    /// ```
-    pub fn new(name: &str) -> Self {
-        Self {
-            name: name.to_string(),
-            iface: None,
-            // Default MAC - locally administered, unicast
-            mac: [0x52, 0x54, 0x00, 0x12, 0x34, 0x56],
-        }
-    }
-    
-    /// Create a TAP backend with a custom MAC address.
-    pub fn with_mac(name: &str, mac: [u8; 6]) -> Self {
-        Self {
-            name: name.to_string(),
-            iface: None,
-            mac,
-        }
-    }
-    
-    /// Set the interface to non-blocking mode.
-    fn set_nonblocking(&self) -> Result<(), String> {
-        if let Some(ref iface) = self.iface {
-            let fd = iface.as_raw_fd();
-            
-            // Get current flags
-            let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
-            if flags < 0 {
-                return Err(format!(
-                    "Failed to get fd flags: {}",
-                    std::io::Error::last_os_error()
-                ));
-            }
-            
-            // Set non-blocking flag
-            let result = unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) };
-            if result < 0 {
-                return Err(format!(
-                    "Failed to set non-blocking mode: {}",
-                    std::io::Error::last_os_error()
-                ));
-            }
-        }
-        Ok(())
-    }
-}
-
-impl NetworkBackend for TapBackend {
-    fn init(&mut self) -> Result<(), String> {
-        // Open the TAP interface
-        let iface = tun_tap::Iface::without_packet_info(&self.name, tun_tap::Mode::Tap)
-            .map_err(|e| format!("Failed to open TAP interface '{}': {}", self.name, e))?;
-        
-        self.iface = Some(iface);
-        
-        // Set non-blocking mode for recv polling
-        self.set_nonblocking()?;
-        
-        log::info!("[TapBackend] Opened TAP interface '{}'", self.name);
-        Ok(())
-    }
-    
-    fn recv(&mut self) -> Result<Option<Vec<u8>>, String> {
-        let iface = self.iface.as_mut().ok_or("TAP interface not initialized")?;
-        
-        // Buffer for maximum Ethernet frame size (MTU 1500 + headers)
-        let mut buf = vec![0u8; 1514];
-        
-        match iface.recv(&mut buf) {
-            Ok(n) => {
-                buf.truncate(n);
-                log::trace!("[TapBackend] Received {} byte packet", n);
-                Ok(Some(buf))
-            }
-            Err(e) => {
-                // Check if it's a would-block error (no data available)
-                if e.kind() == std::io::ErrorKind::WouldBlock {
-                    Ok(None)
-                } else {
-                    Err(format!("TAP recv error: {}", e))
-                }
-            }
-        }
-    }
-    
-    fn send(&self, buf: &[u8]) -> Result<(), String> {
-        let iface = self.iface.as_ref().ok_or("TAP interface not initialized")?;
-        
-        // tun_tap::Iface doesn't implement Send on the write side,
-        // so we need to use the raw fd for writing. However, for simplicity
-        // we'll just write directly. Note: this may need adjustment for
-        // thread safety in the future.
-        let mut iface_clone = unsafe {
-            // This is safe because we're only writing and the fd is valid
-            std::fs::File::from_raw_fd(std::os::unix::io::AsRawFd::as_raw_fd(iface))
-        };
-        
-        let result = iface_clone.write_all(buf);
-        
-        // Don't drop the file - it doesn't own the fd
-        std::mem::forget(iface_clone);
-        
-        result.map_err(|e| format!("TAP send error: {}", e))?;
-        log::trace!("[TapBackend] Sent {} byte packet", buf.len());
-        Ok(())
-    }
-    
-    fn mac_address(&self) -> [u8; 6] {
-        self.mac
-    }
-}
-
-// Manual implementation to handle the Iface not being Send
-unsafe impl Send for TapBackend {}
-
-use std::os::unix::io::FromRawFd;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    
-    #[test]
-    fn test_tap_backend_creation() {
-        let tap = TapBackend::new("test0");
-        assert_eq!(tap.name, "test0");
-        assert!(tap.iface.is_none());
-    }
-    
-    #[test]
-    fn test_tap_backend_custom_mac() {
-        let mac = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF];
-        let tap = TapBackend::with_mac("test0", mac);
-        assert_eq!(tap.mac_address(), mac);
-    }
-    
-    // Note: Actually opening a TAP interface requires root privileges,
-    // so we can't test init() in regular unit tests.
-}
-