mapping/file_mapping: Implement copy-on-write for writeable file mapped vm regions

Currently, a writeable VMFileMapping will copy the entire contents of
the region from the source pages into a read/write copy. This is
inefficient in cases where the mapping may be quite large or only
sparsely accessed.

This commit adds page fault handling to VMFileMapping. The original file
pages are mapped as read-only and when a write occurs the page fault is
handled and a copy taken of the page where the fault occurred. The copy
is stored in a sparse vector in RawAllocMapping. The VMR will update the
pagetable for the virtual range to map the new page with the correct
access flags.

Signed-off-by: Roy Hopkins <[email protected]>

Author: roy-hopkins

src/mm/vm/mapping/file_mapping.rs

@@ -6,11 +6,16 @@
 
 extern crate alloc;
 
+use core::slice::from_raw_parts_mut;
+
+use alloc::sync::Arc;
 use alloc::vec::Vec;
 
-use super::{RawAllocMapping, VirtualMapping};
+use super::{Mapping, RawAllocMapping, VMPageFaultResolution, VMPhysMem, VirtualMapping};
+use crate::address::Address;
 use crate::error::SvsmError;
 use crate::fs::FileHandle;
+use crate::mm::vm::VMR;
 use crate::mm::PageRef;
 use crate::mm::{pagetable::PageTable, PAGE_SIZE};
 use crate::types::PAGE_SHIFT;
@@ -19,6 +24,16 @@ use crate::utils::align_up;
 #[derive(Debug)]
 struct VMWriteFileMapping(RawAllocMapping);
 
+impl VMWriteFileMapping {
+    pub fn get_alloc(&self) -> &RawAllocMapping {
+        &self.0
+    }
+
+    pub fn get_alloc_mut(&mut self) -> &mut RawAllocMapping {
+        &mut self.0
+    }
+}
+
 impl VirtualMapping for VMWriteFileMapping {
     fn mapping_size(&self) -> usize {
         self.0.mapping_size()
@@ -57,6 +72,9 @@ pub struct VMFileMapping {
 
     /// A vec containing references to mapped pages within the file
     pages: Vec<Option<PageRef>>,
+
+    /// A copy of the file pages for mappings with Write permission
+    write_copy: Option<VMWriteFileMapping>,
 }
 
 impl VMFileMapping {
@@ -96,12 +114,22 @@ impl VMFileMapping {
         for page_index in 0..count {
             pages.push(file.mapping(offset + page_index * PAGE_SIZE));
         }
+        // For ranges with write access we need to take a copy of the ram pages
+        // to allow them to be written to without modifying the contents of the
+        // file itself and also to prevent pointer aliasing with any other
+        // FileHandles that may be open on the same file.
+        let write_copy = if permission == VMFileMappingPermission::Write {
+            Some(VMWriteFileMapping(RawAllocMapping::new(size)))
+        } else {
+            None
+        };
 
         Ok(Self {
             file,
             size,
             permission,
             pages,
+            write_copy,
         })
     }
 }
@@ -116,14 +144,67 @@ impl VirtualMapping for VMFileMapping {
         if page_index >= self.pages.len() {
             return None;
         }
+        if let Some(write_copy) = &self.write_copy {
+            let write_addr = write_copy.map(offset);
+            if write_addr.is_some() {
+                return write_addr;
+            }
+        }
         self.pages[page_index].as_ref().map(|p| p.phys_addr())
     }
 
-    fn pt_flags(&self, _offset: usize) -> crate::mm::pagetable::PTEntryFlags {
+    fn pt_flags(&self, offset: usize) -> crate::mm::pagetable::PTEntryFlags {
         match self.permission {
             VMFileMappingPermission::Read => PageTable::task_data_ro_flags(),
-            VMFileMappingPermission::Write => PageTable::task_data_flags(),
+            VMFileMappingPermission::Write => {
+                if let Some(write_copy) = &self.write_copy {
+                    if write_copy.get_alloc().present(offset) {
+                        PageTable::task_data_flags()
+                    } else {
+                        PageTable::task_data_ro_flags()
+                    }
+                } else {
+                    PageTable::task_data_ro_flags()
+                }
+            }
             VMFileMappingPermission::Execute => PageTable::task_exec_flags(),
         }
     }
+
+    fn handle_page_fault(
+        &mut self,
+        vmr: &VMR,
+        offset: usize,
+        write: bool,
+    ) -> Result<VMPageFaultResolution, SvsmError> {
+        let page_size = self.page_size();
+        if write {
+            if let Some(write_copy) = self.write_copy.as_mut() {
+                // This is a writeable region with copy-on-write access. The
+                // page fault will have occurred because the page has not yet
+                // been allocated. Allocate a page and copy the readonly source
+                // page into the new writeable page.
+                let offset_aligned = offset & !(page_size - 1);
+                if write_copy
+                    .get_alloc_mut()
+                    .alloc_page(offset_aligned)
+                    .is_ok()
+                {
+                    let paddr_new_page = write_copy.map(offset_aligned).ok_or(SvsmError::Mem)?;
+                    let temp_map = VMPhysMem::new(paddr_new_page, page_size, true);
+                    let vaddr_new_page = vmr.insert(Arc::new(Mapping::new(temp_map)))?;
+                    let slice =
+                        unsafe { from_raw_parts_mut(vaddr_new_page.bits() as *mut u8, page_size) };
+                    self.file.seek(offset_aligned);
+                    self.file.read(slice)?;
+                    vmr.remove(vaddr_new_page)?;
+                    return Ok(VMPageFaultResolution {
+                        paddr: paddr_new_page,
+                        flags: PageTable::task_data_flags(),
+                    });
+                }
+            }
+        }
+        Err(SvsmError::Mem)
+    }
 }