[mm]: Implement lazy allocation & mapping

modules/axmm/src/aspace.rs

@@ -172,6 +172,27 @@ impl AddrSpace {
     pub fn clear(&mut self) {
         self.areas.clear(&mut self.pt).unwrap();
     }
+
+    /// Handles a page fault at the given address.
+    ///
+    /// `access_flags` indicates the access type that caused the page fault.
+    ///
+    /// Returns `true` if the page fault is handled successfully (not a real
+    /// fault).
+    pub fn handle_page_fault(&mut self, vaddr: VirtAddr, access_flags: MappingFlags) -> bool {
+        if !self.va_range.contains(vaddr) {
+            return false;
+        }
+        if let Some(area) = self.areas.find(vaddr) {
+            let orig_flags = area.flags();
+            if orig_flags.contains(access_flags) {
+                return area
+                    .backend()
+                    .handle_page_fault(vaddr, orig_flags, &mut self.pt);
+            }
+        }
+        false
+    }
 }
 
 impl fmt::Debug for AddrSpace {

modules/axmm/src/backend/alloc.rs

@@ -40,17 +40,25 @@ impl Backend {
             flags,
             populate
         );
-        // allocate all possible physical frames for populated mapping.
-        for addr in PageIter4K::new(start, start + size).unwrap() {
-            if let Some(frame) = alloc_frame(true) {
-                if let Ok(tlb) = pt.map(addr, frame, PageSize::Size4K, flags) {
-                    tlb.ignore(); // TLB flush on map is unnecessary, as there are no outdated mappings.
-                } else {
-                    return false;
+        if populate {
+            // allocate all possible physical frames for populated mapping.
+            for addr in PageIter4K::new(start, start + size).unwrap() {
+                if let Some(frame) = alloc_frame(true) {
+                    if let Ok(tlb) = pt.map(addr, frame, PageSize::Size4K, flags) {
+                        tlb.ignore(); // TLB flush on map is unnecessary, as there are no outdated mappings.
+                    } else {
+                        return false;
+                    }
                 }
             }
+            true
+        } else {
+            // Map to a empty entry for on-demand mapping.
+            let flags = MappingFlags::empty();
+            pt.map_region(start, |_| 0.into(), size, flags, false, false)
+                .map(|tlb| tlb.ignore())
+                .is_ok()
         }
-        true
     }
 
     pub(crate) fn unmap_alloc(
@@ -76,4 +84,25 @@ impl Backend {
         }
         true
     }
+
+    pub(crate) fn handle_page_fault_alloc(
+        &self,
+        vaddr: VirtAddr,
+        orig_flags: MappingFlags,
+        pt: &mut PageTable,
+        populate: bool,
+    ) -> bool {
+        if populate {
+            false // Populated mappings should not trigger page faults.
+        } else if let Some(frame) = alloc_frame(true) {
+            // Allocate a physical frame lazily and map it to the fault address.
+            // `vaddr` does not need to be aligned. It will be automatically
+            // aligned during `pt.remap` regardless of the page size.
+            pt.remap(vaddr, frame, orig_flags)
+                .map(|(_, tlb)| tlb.flush())
+                .is_ok()
+        } else {
+            false
+        }
+    }
 }

modules/axmm/src/backend/mod.rs

@@ -53,3 +53,19 @@ impl MappingBackend<MappingFlags, PageTable> for Backend {
         }
     }
 }
+
+impl Backend {
+    pub(crate) fn handle_page_fault(
+        &self,
+        vaddr: VirtAddr,
+        orig_flags: MappingFlags,
+        page_table: &mut PageTable,
+    ) -> bool {
+        match *self {
+            Self::Linear { .. } => false, // Linear mappings should not trigger page faults.
+            Self::Alloc { populate } => {
+                self.handle_page_fault_alloc(vaddr, orig_flags, page_table, populate)
+            }
+        }
+    }
+}