Add result call for Trustlet

Stops the Trustlet execution
AllocationRanges now flush the tlb

Author: Sabanic-P

kernel/src/process_manager/allocation.rs

@@ -1,3 +1,4 @@
+use crate::cpu::flush_tlb_global;
 use crate::process_manager::process_memory::allocate_page;
 use crate::mm::PAGE_SIZE;
 use crate::address::{Address, VirtAddr};
@@ -63,6 +64,7 @@ impl AllocationRange {
             self.0 = pgd[offset];
             self.1 = pages;
         }
+        flush_tlb_global();
     }
 
     pub fn inflate(&mut self, page_table_ref: &mut ProcessPageTableRef, pages: u64, start_addr: u64) {
@@ -83,6 +85,7 @@ impl AllocationRange {
     pub fn mount(&self) {
         let (_mapping, pgd) = paddr_as_slice!(read_cr3());
         pgd[DEFAULT_ALLOCATION_RANGE_MOUNT] = self.0;
+        flush_tlb_global();
     }
 
     pub fn mount_at(&self, loc: usize) -> u64 {

kernel/src/process_manager/memory_channels.rs

@@ -1,6 +1,6 @@
 use log::Metadata;
 
-use crate::{address::{PhysAddr, VirtAddr}, map_paddr, mm::{PerCPUPageMappingGuard, PAGE_SIZE}, paddr_as_slice, process_manager::process_memory::ALLOCATION_RANGE_VIRT_START, vaddr_as_slice};
+use crate::{address::{PhysAddr, VirtAddr}, cpu::flush_tlb_global, map_paddr, mm::{PerCPUPageMappingGuard, PAGE_SIZE}, paddr_as_slice, process_manager::process_memory::ALLOCATION_RANGE_VIRT_START, vaddr_as_slice};
 
 use super::{allocation::AllocationRange, process::ProcessID, process_paging::ProcessPageTableRef};
 
@@ -37,28 +37,19 @@ impl MemoryChannel {
     }
 
     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();
         ProcessPageTableRef::copy_data_from_guest_to(source_addr, size as u64, page_table, ALLOCATION_RANGE_VIRT_START);
     }
 
     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);
-
+        let source = VirtAddr::from(ALLOCATION_RANGE_VIRT_START);
         self.output.mount();
-
-        page_table_ref.copy_address_range(VirtAddr::from(target), copy_size as u64, VirtAddr::from(target_addr));
+        ProcessPageTableRef::copy_data_to_guest(target_addr, copy_size as u64, page_table);
     }
 
+
     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;

kernel/src/process_manager/process_paging.rs

@@ -356,6 +356,23 @@ impl ProcessPageTableRef {
         }
     }
 
+    pub fn copy_address_range_to_guest(&self, dst: VirtAddr, size: u64, source: VirtAddr) {
+        let copy_page_count = size / PAGE_SIZE_4K;
+        for i in 0..copy_page_count {
+            let dst_phys = self.get_page(dst + 4096usize * (i as usize));
+            if dst_phys == PhysAddr::null() {
+                break;
+            }
+            let (_mapping,dst_slice) = paddr_as_slice!(dst_phys);
+
+            let source_vaddr = source + 4096usize * (i as usize);
+            let source_slice = vaddr_as_slice!(source_vaddr);
+            _ = replace(dst_slice, *source_slice);
+        }
+
+    }
+
+
     pub fn get_page(&self, addr: VirtAddr) -> PhysAddr{
         //Mapping the page table into Memory and get the next layer based on the address
         let (_pgd_mapping, pgd_table) = paddr_as_table!(self.process_page_table);
@@ -506,14 +523,23 @@ impl ProcessPageTableRef {
 
     pub fn copy_data_from_guest_to(addr: u64, size: u64, page_table: u64, dst: u64) {
         let copy_size = size + (PAGE_SIZE_4K - size % PAGE_SIZE_4K);
-        let copy_page_count = copy_size / PAGE_SIZE_4K;
         let target = VirtAddr::from(dst);
 
         let mut page_table_ref = ProcessPageTableRef::default();
         page_table_ref.set_external_table(page_table);
         page_table_ref.copy_address_range(VirtAddr::from(addr), copy_size, target);
     }
 
+    pub fn copy_data_to_guest(dst_addr: u64, size: u64, page_table: u64) {
+
+        let source = VirtAddr::from(ALLOCATION_RANGE_VIRT_START);
+
+        let mut page_table_ref = ProcessPageTableRef::default();
+
+        page_table_ref.set_external_table(page_table);
+
+        page_table_ref.copy_address_range_to_guest(VirtAddr::from(dst_addr), size, source);
+    }
 
     pub fn map_4k_page(&self, target: VirtAddr, addr: PhysAddr, flags: ProcessPageFlags) {
         let (_pgd_mapping, pgd_table) = paddr_as_table!(self.process_page_table);

kernel/src/process_runtime/runtime.rs

@@ -2,8 +2,12 @@ use cpuarch::vmsa::VMSA;
 use igvm_defs::PAGE_SIZE_4K;
 use core::ffi::CStr;
 use core::str;
+<<<<<<< HEAD
 use crate::{address::VirtAddr, cpu::{cpuid::{cpuid_table_raw, CpuidResult}, percpu::{this_cpu, this_cpu_unsafe}}, map_paddr, mm::{PerCPUPageMappingGuard, PAGE_SIZE}, paddr_as_slice, process_manager::{process::{ProcessID, TrustedProcess, PROCESS_STORE}, process_memory::allocate_page, process_paging::{GraminePalProtFlags, ProcessPageFlags, ProcessPageTableRef}}, protocols::{errors::SvsmReqError, RequestParams}};
 use crate::process_manager::process_paging::TP_LIBOS_START_VADDR;
+=======
+use crate::{address::VirtAddr, cpu::{cpuid::{cpuid_table_raw, CpuidResult}, percpu::{this_cpu, this_cpu_unsafe}}, map_paddr, mm::{PerCPUPageMappingGuard, PAGE_SIZE}, paddr_as_slice, process_manager::{process::{ProcessID, TrustedProcess, PROCESS_STORE}, process_memory::allocate_page, process_paging::{ProcessPageFlags, ProcessPageTableRef}}, protocols::{errors::SvsmReqError, RequestParams}, vaddr_as_u64_slice};
+>>>>>>> 145f83e (Add result call for Trustlet)
 
 use crate::vaddr_as_slice; 
 use crate::types::PageSize;
@@ -24,6 +28,7 @@ pub trait ProcessRuntime {
     fn pal_svsm_print_info(&mut self) -> bool;
     fn pal_svsm_set_tcb(&mut self) -> bool;
     fn pal_svsm_cpuid(&mut self) -> bool;
+    fn pal_svsm_get_result(&mut self) -> bool;
 }
 
 #[derive(Debug)]
@@ -32,20 +37,31 @@ pub struct PALContext {
     vmsa: &'static mut VMSA,
     string_buf: [u8;256],
     string_pos: usize,
+    result_addr: u64,
+    result_size: u64,
+    guest_page_table: u64,
+    return_value: u64,
 }
 
 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 guest_data = params.r8;
+    let guest_data_size = params.r9;
     let guest_page_table = params.rdx;
+    let (invoke_data, range) = ProcessPageTableRef::copy_data_from_guest(guest_data, guest_data_size, guest_page_table);
+    let invoke_data_struct = vaddr_as_u64_slice!(invoke_data);
 
-    let trustlet = PROCESS_STORE.get(ProcessID(id.try_into().unwrap()));
+    let function_arg = invoke_data_struct[0];
+    let function_arg_size = invoke_data_struct[2];
+
+    let result_addr = invoke_data_struct[1];
+    let result_size = invoke_data_struct[3];
 
-    //log::info!("{:?}", trustlet);
+
+    let trustlet = PROCESS_STORE.get(ProcessID(id.try_into().unwrap()));
 
     // Getting the current processes VMSA
     let vmsa_paddr = trustlet.context.vmsa;
@@ -62,9 +78,13 @@ pub fn invoke_trustlet(params: &mut RequestParams) -> Result<(), SvsmReqError> {
 
     let mut rc = PALContext{
         process: trustlet,
-        vmsa: vmsa,
-        string_buf: string_buf,
-        string_pos: string_pos,
+        vmsa,
+        string_buf,
+        string_pos,
+        result_addr,
+        result_size,
+        guest_page_table,
+        return_value: 1,
     };
 
     // Execution loop of the trustlet
@@ -78,6 +98,12 @@ pub fn invoke_trustlet(params: &mut RequestParams) -> Result<(), SvsmReqError> {
             break;
         }
     }
+<<<<<<< HEAD
+=======
+
+    params.rcx = rc.return_value;
+
+>>>>>>> 145f83e (Add result call for Trustlet)
     Ok(())
 }
 
@@ -126,6 +152,9 @@ impl ProcessRuntime for PALContext  {
             0x4FFFFFF9 => {
                 return self.pal_svsm_mprotect();
             }
+            0x4FFFFFF8 => {
+                return self.pal_svsm_get_result();
+            }
             99 => {
                 let c = vmsa.rbx;
                 log::info!("{}", c);
@@ -159,7 +188,6 @@ impl ProcessRuntime for PALContext  {
     /// * rdx: edx value of the cpuid result
     fn pal_svsm_cpuid(&mut self) -> bool {
         let eax =  self.vmsa.rax as u32;
-        log::info!("eax value: {:#x}",eax);
         let eax_tmp = self.vmsa.rax;
         let ecx_tmp = self.vmsa.rcx;
         // Some cpuid leafs have subleaf (ecx) and some don't
@@ -183,16 +211,26 @@ impl ProcessRuntime for PALContext  {
         self.vmsa.rbx = res.ebx as u64;
         self.vmsa.rcx = res.ecx as u64;
         self.vmsa.rdx = res.edx as u64;
-        log::info!("Returned CPUID({:#x}/{:#x}) as the following: {:#x} {:#x} {:#x} {:#x}",
-        eax_tmp,
-        ecx_tmp,
-        res.eax,
-        res.ebx,
-        res.ecx,
-        res.edx);
         return true;
     }
 
+    /// Inidicated that results are ready
+    ///
+    /// Return:
+    /// Sets the trustlet return value to 0
+    /// Copies the reuslts into the provided buffer
+    fn pal_svsm_get_result(&mut self) -> bool {
+        self.process.context.channel.copy_out(
+            self.result_addr,
+            self.guest_page_table,
+            self.result_size as usize);
+        self.return_value = 0;
+        false
+    }
+
+
+
+
     /// Allocate virtual memory in the trustlet's page table
     /// 
     /// Register arguments: