kernel/mm: Implement resize support for struct VMalloc

Support the resizing of VMalloc mappings.

Signed-off-by: Joerg Roedel <joerg.roedel@amd.com>

Author: joergroedel

kernel/src/mm/vm/mapping/rawalloc.rs

@@ -11,6 +11,7 @@ use crate::error::SvsmError;
 use crate::mm::alloc::PageRef;
 use crate::types::{PAGE_SHIFT, PAGE_SIZE};
 use crate::utils::align_up;
+use core::cmp::Ordering;
 
 extern crate alloc;
 use alloc::vec::Vec;
@@ -24,6 +25,9 @@ pub struct RawAllocMapping {
 
     /// Number of pages required in `pages`
     count: usize,
+
+    /// Pages to flush
+    unmapped_pages: Vec<Option<PageRef>>,
 }
 
 impl RawAllocMapping {
@@ -39,7 +43,12 @@ impl RawAllocMapping {
     pub fn new(size: usize) -> Self {
         let count = align_up(size, PAGE_SIZE) >> PAGE_SHIFT;
         let pages: Vec<Option<PageRef>> = iter::repeat_n(None, count).collect();
-        RawAllocMapping { pages, count }
+        let unmapped_pages: Vec<Option<PageRef>> = Vec::new();
+        RawAllocMapping {
+            pages,
+            count,
+            unmapped_pages,
+        }
     }
 
     /// Allocates a single backing page of type PageFile if the page has not already
@@ -61,18 +70,32 @@ impl RawAllocMapping {
         Ok(())
     }
 
-    /// Allocates a full set of backing pages of type PageFile
+    /// Allocates backing pages for the mapping starting at a give offset
+    ///
+    /// # Arguments:
+    ///
+    /// * `offset` - Byte offset into the mapping to start allocating from
     ///
     /// # Returns
     ///
     /// `Ok(())` when all pages could be allocated, `Err(SvsmError::Mem)` otherwise
-    pub fn alloc_pages(&mut self) -> Result<(), SvsmError> {
-        for index in 0..self.count {
+    fn alloc_pages_offset(&mut self, offset: usize) -> Result<(), SvsmError> {
+        let start = offset / PAGE_SIZE;
+        for index in start..self.count {
             self.alloc_page(index * PAGE_SIZE)?;
         }
         Ok(())
     }
 
+    /// Allocates a full set of backing pages of type PageFile
+    ///
+    /// # Returns
+    ///
+    /// `Ok(())` when all pages could be allocated, `Err(SvsmError::Mem)` otherwise
+    pub fn alloc_pages(&mut self) -> Result<(), SvsmError> {
+        self.alloc_pages_offset(0)
+    }
+
     /// Returns a reference to a page at a given index. The page must already
     /// been allocated.
     ///
@@ -101,6 +124,61 @@ impl RawAllocMapping {
         self.count * PAGE_SIZE
     }
 
+    /// Change the size of the mapping. Note that the backing pages are not yet
+    /// freed when the mapping is shrinked. To free the pages a separate call to
+    /// the `flush()` method is required.
+    ///
+    /// # Arguments
+    ///
+    /// * `size` - The new size of the mapping. This will be rounded up to the
+    ///   next PAGE_SIZE boundary.
+    ///
+    /// # Returns
+    ///
+    /// Returns `OK(new_aligned_size)` on success, `Err(SvsmError)` on failure.
+    pub fn resize(&mut self, size: usize) -> Result<usize, SvsmError> {
+        let size = align_up(size, PAGE_SIZE);
+        let old_size = self.mapping_size();
+
+        match size.cmp(&old_size) {
+            Ordering::Equal => Ok(size),
+            Ordering::Greater => {
+                // Increase pages vector
+                let diff_count = (size - old_size) / PAGE_SIZE;
+                let new_total_count = size / PAGE_SIZE;
+                // Reserve memory in pages vector
+                self.pages
+                    .try_reserve_exact(diff_count)
+                    .map_err(|_| SvsmError::Mem)?;
+                // Increase pages vector
+                self.pages.resize_with(new_total_count, || None);
+                self.count += diff_count;
+                // Try to allocate the pages
+                if let Err(e) = self.alloc_pages_offset(old_size) {
+                    // Shrink pages vector
+                    self.count -= diff_count;
+                    // Free any stale backing pages
+                    self.pages.truncate(self.count);
+                    Err(e)
+                } else {
+                    Ok(size)
+                }
+            }
+            Ordering::Less => {
+                self.count = size / PAGE_SIZE;
+                let mut old_pages = self.pages.split_off(self.count);
+                self.unmapped_pages.append(&mut old_pages);
+                Ok(size)
+            }
+        }
+    }
+
+    /// Free unmapped pages. This needs to be called after the unmapped pages
+    /// have been flushed out of all TLBs.
+    pub fn flush(&mut self) {
+        self.unmapped_pages.clear();
+    }
+
     /// Request physical address to map for a given offset
     ///
     /// # Arguments

kernel/src/mm/vm/mapping/vmalloc.rs

@@ -74,6 +74,14 @@ impl VirtualMapping for VMalloc {
         self.alloc.mapping_size()
     }
 
+    fn resize(&mut self, size: usize) -> Result<usize, SvsmError> {
+        self.alloc.resize(size)
+    }
+
+    fn flush(&mut self) {
+        self.alloc.flush();
+    }
+
     fn map(&self, offset: usize) -> Option<PhysAddr> {
         self.alloc.map(offset)
     }