Add memory channel for single Trustlet use

Author: Sabanic-P

kernel/src/process_manager/allocation.rs

@@ -84,7 +84,7 @@ impl AllocationRange {
     }
 
     pub fn delete(&self) {
-        todo!("Not implemented");
+
     }
 
 }

kernel/src/process_manager/memory_channels.rs

@@ -0,0 +1,70 @@
+use crate::{address::VirtAddr, mm::PAGE_SIZE, process_manager::process_memory::ALLOCATION_RANGE_VIRT_START};
+
+use super::{allocation::AllocationRange, process::ProcessID, process_paging::ProcessPageTableRef};
+
+pub const INPUT_VADDR: u64 = 0xFF0000000000u64;
+pub const OUTPUT_VADDR: u64 = 0xFF8000000000u64;
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct MemoryChannel {
+    pub input: AllocationRange,
+    pub output: AllocationRange,
+    pub owner: ProcessID,
+    pub last_in_channel: bool,
+    pub next: ProcessID,
+}
+
+impl MemoryChannel {
+
+    pub fn allocate_input(&mut self, page_table_ref: &mut ProcessPageTableRef, size: usize) {
+        self.input = self.allocate_range(page_table_ref, size, INPUT_VADDR);
+    }
+
+    pub fn allocate_output(&mut self, page_table_ref: &mut ProcessPageTableRef, size: usize) {
+        self.output = self.allocate_range(page_table_ref, size, OUTPUT_VADDR);
+    }
+
+    pub fn inflate_input(&mut self, page_table_ref: &mut ProcessPageTableRef, size: usize) {
+        let page_count = (size + PAGE_SIZE - (size % PAGE_SIZE)) / PAGE_SIZE;
+        self.input.inflate(page_table_ref, page_count as u64, INPUT_VADDR);
+    }
+
+    pub fn inflate_output(&mut self, page_table_ref: &mut ProcessPageTableRef, size: usize) {
+        let page_count = (size + PAGE_SIZE - (size % PAGE_SIZE)) / PAGE_SIZE;
+        self.output.inflate(page_table_ref, page_count as u64, OUTPUT_VADDR);
+    }
+
+    pub fn copy_into(&mut self, source_addr: u64, page_table: u64, size: usize) {
+        let copy_size = size + PAGE_SIZE - (size % PAGE_SIZE);
+        let copy_page_count = copy_size / PAGE_SIZE;
+        let target = VirtAddr::from(ALLOCATION_RANGE_VIRT_START);
+
+        let mut page_table_ref = ProcessPageTableRef::default();
+        page_table_ref.set_external_table(page_table);
+
+        self.input.mount();
+
+        page_table_ref.copy_address_range(VirtAddr::from(source_addr), copy_size as u64, target);
+
+    }
+
+    pub fn copy_out(&mut self, target_addr: u64, page_table: u64, size: usize) {
+        let copy_size = size + PAGE_SIZE - (size % PAGE_SIZE);
+        let copy_page_count = copy_size / PAGE_SIZE;
+        let target = VirtAddr::from(ALLOCATION_RANGE_VIRT_START);
+        let mut page_table_ref = ProcessPageTableRef::default();
+        page_table_ref.set_external_table(page_table);
+
+        self.output.mount();
+
+        page_table_ref.copy_address_range(VirtAddr::from(target), copy_size as u64, VirtAddr::from(target_addr));
+    }
+
+    fn allocate_range(&mut self, page_table_ref: &mut ProcessPageTableRef, size: usize, start: u64) -> AllocationRange{
+        let mut r = AllocationRange::default();
+        let page_count = (size + PAGE_SIZE - (size % PAGE_SIZE)) / PAGE_SIZE;
+        r.allocate_with_start_addr(page_table_ref, page_count as u64, start);
+        return r;
+    }
+
+}

kernel/src/process_manager/process.rs

@@ -173,9 +173,14 @@ impl TrustedProcess {
 
     }
 
-    pub fn trustlet(parent: ProcessID, _data: u64, _size: u64, _pgt: u64) -> Self{
+    pub fn trustlet(parent: ProcessID, data: u64, size: u64, pgt: u64) -> Self{
         // Inherit the data from the Zygote
         let trustlet = TrustedProcess::dublicate(parent);
+        if data != 0 {
+            let (function_code, function_code_range) = ProcessPageTableRef::copy_data_from_guest(data, size, pgt);
+            trustlet.base.page_table_ref.add_function(function_code, size);
+            function_code_range.delete();
+        }
         trustlet
     }
 
@@ -421,6 +426,11 @@ impl ProcessContext {
 
     }
 
+    pub fn add_function(&mut self, function: VirtAddr, size: u64) {
+        let size = size + PAGE_SIZE_4K - (size % PAGE_SIZE_4K);
+        self.base.page_table_ref.add_function(function, size);
+    }
+
     pub fn test_run(&self) {
         let apic_id = this_cpu().get_apic_id();
         log::info!("Trying to execute Context");

kernel/src/process_manager/process_paging.rs

@@ -286,6 +286,12 @@ impl ProcessPageTableRef {
         self.add_region_vaddr(VirtAddr::from(0x18000000000u64), data);
     }
 
+    pub fn add_function(&self, data:VirtAddr, size: u64) {
+        let data: *mut u8 = data.as_mut_ptr::<u8>();
+        let data = unsafe { slice::from_raw_parts(data, size as usize) };
+        self.add_region_vaddr(VirtAddr::from(0xFE8000000000u64), data);
+    }
+
     pub fn add_pages(&self, start: VirtAddr, size: u64, flags: ProcessPageFlags) {
         for i in 0..(size as usize) {
             let new_page = allocate_page();
@@ -394,7 +400,7 @@ impl ProcessPageTableRef {
     pub fn virt_to_phys(&self, vaddr: VirtAddr) -> PhysAddr {
         let (_pgd_mapping, pgd_table) = paddr_as_table!(self.process_page_table);
         let mut current_mapping = self.page_walk(&pgd_table, self.process_page_table, vaddr);
-        log::info!("Current Mapping {:?}", current_mapping);
+        //log::info!("Current Mapping {:?}", current_mapping);
         match current_mapping {
             ProcessTableLevelMapping::PTE(addr, index) => {
                 let (_mapping, table) = paddr_as_u64_slice!(addr);

kernel/src/process_runtime/runtime.rs

@@ -37,6 +37,8 @@ pub fn invoke_trustlet(params: &mut RequestParams) -> Result<(), SvsmReqError> {
     log::info!("Invoking Trustlet");
 
     let id = params.rcx;
+    let function_arg = params.r8;
+    let function_arg_size = params.r9;
 
     let trustlet = PROCESS_STORE.get(ProcessID(id.try_into().unwrap()));
 
@@ -53,6 +55,8 @@ pub fn invoke_trustlet(params: &mut RequestParams) -> Result<(), SvsmReqError> {
     let mut string_pos: usize = 0;
     let sev_features = trustlet.context.sev_features;
 
+    trustlet.context.channel.copy_into(function_arg, vmsa.cr3, function_arg_size as usize);
+
 
     let mut rc = PALContext{
         process: trustlet,