Merge pull request #136 from roy-hopkins/task_stack

task, percpu: Use VMR to manage the task pagetable and VMKernelStack to allocate the task kernel stack

Author: joergroedel

src/cpu/percpu.rs

@@ -16,7 +16,7 @@ use crate::locking::{LockGuard, RWLock, SpinLock};
 use crate::mm::alloc::{allocate_page, allocate_zeroed_page};
 use crate::mm::pagetable::{get_init_pgtable_locked, PTEntryFlags, PageTable, PageTableRef};
 use crate::mm::virtualrange::VirtualRange;
-use crate::mm::vm::{Mapping, VMKernelStack, VMPhysMem, VMReserved, VMR};
+use crate::mm::vm::{Mapping, VMKernelStack, VMPhysMem, VMRMapping, VMReserved, VMR};
 use crate::mm::{
     virt_to_phys, SVSM_PERCPU_BASE, SVSM_PERCPU_CAA_BASE, SVSM_PERCPU_END,
     SVSM_PERCPU_TEMP_BASE_2M, SVSM_PERCPU_TEMP_BASE_4K, SVSM_PERCPU_TEMP_END_2M,
@@ -537,6 +537,31 @@ impl PerCpu {
         self.vrange_2m
             .init(SVSM_PERCPU_TEMP_BASE_2M, page_count, PAGE_SHIFT_2M);
     }
+
+    /// Create a new virtual memory mapping in the PerCpu VMR
+    ///
+    /// # Arguments
+    ///
+    /// * `mapping` - The mapping to insert into the PerCpu VMR
+    ///
+    /// # Returns
+    ///
+    /// On success, a new ['VMRMapping'} that provides a virtual memory address for
+    /// the mapping which remains valid until the ['VRMapping'] is dropped.
+    ///
+    /// On error, an ['SvsmError'].
+    pub fn new_mapping(&mut self, mapping: Arc<Mapping>) -> Result<VMRMapping, SvsmError> {
+        VMRMapping::new(&mut self.vm_range, mapping)
+    }
+
+    /// Add the PerCpu virtual range into the provided pagetable
+    ///
+    /// # Arguments
+    ///
+    /// * `pt` - The page table to populate the the PerCpu range into
+    pub fn populate_page_table(&self, pt: &mut PageTableRef) {
+        self.vm_range.populate(pt);
+    }
 }
 
 unsafe impl Sync for PerCpu {}

src/mm/address_space.rs

@@ -148,23 +148,14 @@ pub const SVSM_PERCPU_TEMP_END_4K: VirtAddr = SVSM_PERCPU_TEMP_BASE_4K.const_add
 pub const SVSM_PERCPU_TEMP_BASE_2M: VirtAddr = SVSM_PERCPU_TEMP_BASE.const_add(SIZE_LEVEL1);
 pub const SVSM_PERCPU_TEMP_END_2M: VirtAddr = SVSM_PERCPU_TEMP_BASE.const_add(SIZE_LEVEL2);
 
-/// Per-task memory map
-/// Use the region from 0xfffffe0000000000 - 0xffffff0000000000 for tasks
+/// Task mappings level 3 index
 pub const PGTABLE_LVL3_IDX_PERTASK: usize = 508;
-/// Layout of the per-task memory space is:
-///
-/// +------------------+------------------+-------------------------------------+
-/// | Start            | End              | Size | Description                  |
-/// +------------------+------------------+------+------------------------------+
-/// | fffffeffffff0000 | ffffff0000000000 | 64K  | Task stack                   |
-/// +------------------+------------------+------+------------------------------+
-/// | fffffe0000000000 | fffffe0004000000 | 64M  | Dynamic memory allocation    |
-/// +------------------+------------------+------+------------------------------+
+
+/// Base address of task memory region
 pub const SVSM_PERTASK_BASE: VirtAddr = virt_from_idx(PGTABLE_LVL3_IDX_PERTASK);
 
-/// Virtual addresses for dynamic memory allocation
-pub const SVSM_PERTASK_DYNAMIC_MEMORY: VirtAddr = SVSM_PERTASK_BASE;
+/// End address of task memory region
+pub const SVSM_PERTASK_END: VirtAddr = SVSM_PERTASK_BASE.const_add(SIZE_LEVEL3);
 
-/// Task stack
-pub const SVSM_PERTASK_STACK_BASE: VirtAddr = SVSM_PERTASK_BASE.const_add(0xffffff0000);
-pub const SVSM_PERTASK_STACK_TOP: VirtAddr = SVSM_PERTASK_STACK_BASE.const_add(0x10000);
+/// Kernel stack for a task
+pub const SVSM_PERTASK_STACK_BASE: VirtAddr = SVSM_PERTASK_BASE;

src/mm/vm/mod.rs

@@ -11,4 +11,4 @@ pub use mapping::{
     Mapping, RawAllocMapping, VMKernelStack, VMMAdapter, VMPhysMem, VMReserved, VMalloc,
     VirtualMapping, VMM,
 };
-pub use range::{VMR, VMR_GRANULE};
+pub use range::{VMRMapping, VMR, VMR_GRANULE};

src/mm/vm/range.rs

@@ -374,3 +374,28 @@ impl VMR {
         }
     }
 }
+
+#[derive(Debug)]
+pub struct VMRMapping<'a> {
+    vmr: &'a mut VMR,
+    va: VirtAddr,
+}
+
+impl<'a> VMRMapping<'a> {
+    pub fn new(vmr: &'a mut VMR, mapping: Arc<Mapping>) -> Result<Self, SvsmError> {
+        let va = vmr.insert(mapping)?;
+        Ok(Self { vmr, va })
+    }
+
+    pub fn virt_addr(&self) -> VirtAddr {
+        self.va
+    }
+}
+
+impl<'a> Drop for VMRMapping<'a> {
+    fn drop(&mut self) {
+        self.vmr
+            .remove(self.va)
+            .expect("Error removing VRMapping virtual memory range");
+    }
+}

src/task/tasks.rs

@@ -6,31 +6,25 @@
 
 extern crate alloc;
 
+use alloc::boxed::Box;
+use alloc::sync::Arc;
 use core::arch::{asm, global_asm};
 use core::fmt;
 use core::mem::size_of;
 use core::sync::atomic::{AtomicU32, Ordering};
 
-use alloc::boxed::Box;
-
-use crate::address::{Address, PhysAddr, VirtAddr};
+use crate::address::{Address, VirtAddr};
 use crate::cpu::msr::{rdtsc, read_flags};
-use crate::cpu::percpu::this_cpu;
+use crate::cpu::percpu::{this_cpu, this_cpu_mut};
 use crate::cpu::X86GeneralRegs;
 use crate::error::SvsmError;
 use crate::locking::SpinLock;
-use crate::mm::alloc::{allocate_pages, get_order};
-use crate::mm::pagetable::{get_init_pgtable_locked, PageTable, PageTableRef};
-use crate::mm::{
-    virt_to_phys, PAGE_SIZE, PGTABLE_LVL3_IDX_PERCPU, SVSM_PERTASK_STACK_BASE,
-    SVSM_PERTASK_STACK_TOP,
-};
-use crate::utils::zero_mem_region;
+use crate::mm::pagetable::{get_init_pgtable_locked, PTEntryFlags, PageTableRef};
+use crate::mm::vm::{Mapping, VMKernelStack, VMR};
+use crate::mm::{SVSM_PERTASK_BASE, SVSM_PERTASK_END, SVSM_PERTASK_STACK_BASE};
 
 pub const INITIAL_TASK_ID: u32 = 1;
 
-const STACK_SIZE: usize = 65536;
-
 #[derive(PartialEq, Debug, Copy, Clone, Default)]
 pub enum TaskState {
     RUNNING,
@@ -39,13 +33,6 @@ pub enum TaskState {
     TERMINATED,
 }
 
-#[derive(Debug, Default)]
-pub struct TaskStack {
-    pub virt_base: VirtAddr,
-    pub virt_top: VirtAddr,
-    pub phys: PhysAddr,
-}
-
 pub const TASK_FLAG_SHARE_PT: u16 = 0x01;
 
 #[derive(Debug, Default)]
@@ -183,12 +170,12 @@ pub struct TaskContext {
 pub struct Task {
     pub rsp: u64,
 
-    /// Information about the task stack
-    pub stack: TaskStack,
-
     /// Page table that is loaded when the task is scheduled
     pub page_table: SpinLock<PageTableRef>,
 
+    /// Task virtual memory range for use at CPL 0
+    vm_kernel_range: VMR,
+
     /// Current state of the task
     pub state: TaskState,
 
@@ -208,7 +195,6 @@ impl fmt::Debug for Task {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Task")
             .field("rsp", &self.rsp)
-            .field("stack", &self.stack)
             .field("state", &self.state)
             .field("affinity", &self.affinity)
             .field("id", &self.id)
@@ -225,12 +211,18 @@ impl Task {
             Self::allocate_page_table()?
         };
 
-        let (task_stack, rsp) = Self::allocate_stack(entry, &mut pgtable)?;
+        let mut vm_kernel_range = VMR::new(SVSM_PERTASK_BASE, SVSM_PERTASK_END, PTEntryFlags::USER);
+        vm_kernel_range.initialize()?;
+
+        let (stack, rsp_offset) = Self::allocate_stack(entry)?;
+        vm_kernel_range.insert_at(SVSM_PERTASK_STACK_BASE, stack)?;
+
+        vm_kernel_range.populate(&mut pgtable);
 
         let task: Box<Task> = Box::new(Task {
-            rsp: u64::from(rsp),
-            stack: task_stack,
+            rsp: (SVSM_PERTASK_STACK_BASE.bits() + rsp_offset.bits()) as u64,
             page_table: SpinLock::new(pgtable),
+            vm_kernel_range,
             state: TaskState::RUNNING,
             affinity: None,
             id: TASK_ID_ALLOCATOR.next_id(),
@@ -262,35 +254,16 @@ impl Task {
         self.affinity = affinity;
     }
 
-    fn allocate_stack(
-        entry: extern "C" fn(),
-        pgtable: &mut PageTableRef,
-    ) -> Result<(TaskStack, VirtAddr), SvsmError> {
-        let stack_size = SVSM_PERTASK_STACK_TOP - SVSM_PERTASK_STACK_BASE;
-        let num_pages = 1 << get_order(STACK_SIZE);
-        assert!(stack_size == num_pages * PAGE_SIZE);
-        let pages = allocate_pages(get_order(STACK_SIZE))?;
-        zero_mem_region(pages, pages + stack_size);
-
-        let task_stack = TaskStack {
-            virt_base: SVSM_PERTASK_STACK_BASE,
-            virt_top: SVSM_PERTASK_STACK_TOP,
-            phys: virt_to_phys(pages),
-        };
+    fn allocate_stack(entry: extern "C" fn()) -> Result<(Arc<Mapping>, VirtAddr), SvsmError> {
+        let stack = VMKernelStack::new()?;
+        let offset = stack.top_of_stack(VirtAddr::from(0u64));
 
-        // We current have a virtual address in SVSM shared memory for the stack. Configure
-        // the per-task pagetable to map the stack into the task memory map.
-        pgtable.map_region_4k(
-            task_stack.virt_base,
-            task_stack.virt_top,
-            task_stack.phys,
-            PageTable::task_data_flags(),
-        )?;
+        let mapping = Arc::new(Mapping::new(stack));
+        let percpu_mapping = this_cpu_mut().new_mapping(mapping.clone())?;
 
         // We need to setup a context on the stack that matches the stack layout
         // defined in switch_context below.
-        let stack_pos = pages + stack_size;
-        let stack_ptr: *mut u64 = stack_pos.as_mut_ptr();
+        let stack_ptr: *mut u64 = (percpu_mapping.virt_addr().bits() + offset.bits()) as *mut u64;
 
         // 'Push' the task frame onto the stack
         unsafe {
@@ -302,8 +275,10 @@ impl Task {
             stack_ptr.offset(-1).write(task_exit as *const () as u64);
         }
 
-        let initial_rsp = SVSM_PERTASK_STACK_TOP - (size_of::<TaskContext>() + size_of::<u64>());
-        Ok((task_stack, initial_rsp))
+        Ok((
+            mapping,
+            offset - (size_of::<TaskContext>() + size_of::<u64>()),
+        ))
     }
 
     fn allocate_page_table() -> Result<PageTableRef, SvsmError> {
@@ -323,7 +298,7 @@ extern "C" fn task_exit() {
 extern "C" fn apply_new_context(new_task: *mut Task) -> u64 {
     unsafe {
         let mut pt = (*new_task).page_table.lock();
-        pt.copy_entry(&this_cpu().get_pgtable(), PGTABLE_LVL3_IDX_PERCPU);
+        this_cpu().populate_page_table(&mut pt);
         pt.cr3_value().bits() as u64
     }
 }