diff --git a/pvmfw/src/exceptions.rs b/pvmfw/src/exceptions.rs
index 09994ba..802ebbb 100644
--- a/pvmfw/src/exceptions.rs
+++ b/pvmfw/src/exceptions.rs
@@ -14,6 +14,7 @@
 
 //! Exception handlers.
 
+use aarch64_paging::paging::VirtualAddress;
 use core::fmt;
 use vmbase::console;
 use vmbase::logger;
@@ -90,14 +91,14 @@
 }
 
 #[inline]
-fn handle_translation_fault(far: usize) -> Result<(), HandleExceptionError> {
+fn handle_translation_fault(far: VirtualAddress) -> Result<(), HandleExceptionError> {
     let mut guard = MEMORY.try_lock().ok_or(HandleExceptionError::PageTableUnavailable)?;
     let memory = guard.as_mut().ok_or(HandleExceptionError::PageTableNotInitialized)?;
     Ok(memory.handle_mmio_fault(far)?)
 }
 
 #[inline]
-fn handle_permission_fault(far: usize) -> Result<(), HandleExceptionError> {
+fn handle_permission_fault(far: VirtualAddress) -> Result<(), HandleExceptionError> {
     let mut guard = MEMORY.try_lock().ok_or(HandleExceptionError::PageTableUnavailable)?;
     let memory = guard.as_mut().ok_or(HandleExceptionError::PageTableNotInitialized)?;
     Ok(memory.handle_permission_fault(far)?)
@@ -118,13 +119,13 @@
 struct ArmException {
     /// The value of the exception syndrome register.
     esr: Esr,
-    /// The value of the fault address register.
-    far: usize,
+    /// The faulting virtual address read from the fault address register.
+    far: VirtualAddress,
 }
 
 impl fmt::Display for ArmException {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "ArmException: esr={}, far={:#08x}", self.esr, self.far)
+        write!(f, "ArmException: esr={}, far={}", self.esr, self.far)
     }
 }
 
@@ -135,7 +136,7 @@
     fn from_el1_regs() -> Self {
         let esr: Esr = read_sysreg!("esr_el1").into();
         let far = read_sysreg!("far_el1");
-        Self { esr, far }
+        Self { esr, far: VirtualAddress(far) }
     }
 
     /// Prints the details of an obj and the exception, excluding UART exceptions.
@@ -149,7 +150,7 @@
     }
 
     fn is_uart_exception(&self) -> bool {
-        self.esr == Esr::DataAbortSyncExternalAbort && page_4kb_of(self.far) == UART_PAGE
+        self.esr == Esr::DataAbortSyncExternalAbort && page_4kb_of(self.far.0) == UART_PAGE
     }
 }
 
diff --git a/vmbase/src/memory/shared.rs b/vmbase/src/memory/shared.rs
index c8b7d35..3faee5b 100644
--- a/vmbase/src/memory/shared.rs
+++ b/vmbase/src/memory/shared.rs
@@ -270,8 +270,8 @@
 
     /// Handles translation fault for blocks flagged for lazy MMIO mapping by enabling the page
     /// table entry and MMIO guard mapping the block. Breaks apart a block entry if required.
-    pub fn handle_mmio_fault(&mut self, addr: usize) -> Result<()> {
-        let page_start = VirtualAddress(page_4kb_of(addr));
+    pub fn handle_mmio_fault(&mut self, addr: VirtualAddress) -> Result<()> {
+        let page_start = VirtualAddress(page_4kb_of(addr.0));
         let page_range: VaRange = (page_start..page_start + MMIO_GUARD_GRANULE_SIZE).into();
         self.page_table
             .modify_range(&page_range, &verify_lazy_mapped_block)
@@ -301,8 +301,7 @@
     /// Handles permission fault for read-only blocks by setting writable-dirty state.
     /// In general, this should be called from the exception handler when hardware dirty
     /// state management is disabled or unavailable.
-    pub fn handle_permission_fault(&mut self, addr: usize) -> Result<()> {
-        let addr = VirtualAddress(addr);
+    pub fn handle_permission_fault(&mut self, addr: VirtualAddress) -> Result<()> {
         self.page_table
             .modify_range(&(addr..addr + 1).into(), &mark_dirty_block)
             .map_err(|_| MemoryTrackerError::SetPteDirtyFailed)