Implement enclave memory management

sgx_trts/Cargo.toml

@@ -39,3 +39,7 @@ hyper = ["sgx_types/hyper"]
 sgx_types = { path = "../sgx_types" }
 sgx_crypto_sys = { path = "../sgx_crypto/sgx_crypto_sys" }
 sgx_tlibc_sys = { path = "../sgx_libc/sgx_tlibc_sys" }
+intrusive-collections = "0.9.5"
+buddy_system_allocator = "0.9.0"
+spin = "0.9.4"
+bitflags = "1.3"

sgx_trts/src/arch.rs

@@ -37,12 +37,24 @@ macro_rules! is_page_aligned {
     };
 }
 
+macro_rules! round_to {
+    ($num:expr, $align:expr) => {
+        ($num + $align - 1) & (!($align - 1))
+    };
+}
+
 macro_rules! round_to_page {
     ($num:expr) => {
         ($num + crate::arch::SE_PAGE_SIZE - 1) & (!(crate::arch::SE_PAGE_SIZE - 1))
     };
 }
 
+macro_rules! trim_to {
+    ($num:expr, $align:expr) => {
+        $num & (!($align - 1))
+    };
+}
+
 macro_rules! trim_to_page {
     ($num:expr) => {
         $num & (!(crate::arch::SE_PAGE_SIZE - 1))
@@ -670,8 +682,8 @@ impl From<PageType> for SecinfoFlags {
 impl From<PageInfo> for SecinfoFlags {
     fn from(data: PageInfo) -> SecinfoFlags {
         let typ = data.typ as u64;
-        let flags = data.flags.bits() as u64;
-        SecinfoFlags::from_bits_truncate((typ << 8) | flags)
+        let prot = data.prot.bits() as u64;
+        SecinfoFlags::from_bits_truncate((typ << 8) | prot)
     }
 }
 

sgx_trts/src/call/ocall.rs

@@ -34,11 +34,13 @@ pub enum OCallIndex {
     TrimCommit,
     Modpr,
     Mprotect,
+    Alloc,
+    Modify,
 }
 
 impl OCallIndex {
     pub fn is_builtin_index(index: i32) -> bool {
-        (-5..=-2).contains(&index)
+        (-7..=-2).contains(&index)
     }
 
     pub fn is_builtin(&self) -> bool {
@@ -62,6 +64,8 @@ impl TryFrom<i32> for OCallIndex {
             -3 => Ok(OCallIndex::TrimCommit),
             -4 => Ok(OCallIndex::Modpr),
             -5 => Ok(OCallIndex::Mprotect),
+            -6 => Ok(OCallIndex::Alloc),
+            -7 => Ok(OCallIndex::Modify),
             _ => Err(u8::try_from(256_u16).unwrap_err()),
         }
     }
@@ -76,6 +80,8 @@ impl From<OCallIndex> for i32 {
             OCallIndex::TrimCommit => -3,
             OCallIndex::Modpr => -4,
             OCallIndex::Mprotect => -5,
+            OCallIndex::Alloc => -6,
+            OCallIndex::Modify => -7,
         }
     }
 }

sgx_trts/src/edmm/epc.rs

@@ -34,10 +34,13 @@ impl_enum! {
     }
 }
 
+// ProtFlags may have richer meaning compared to ProtFlags
+// ProtFlags and AllocFlags are confused to developer
+// PageInfo->flags should change to PageInfo->prot
 impl_bitflags! {
     #[repr(C)]
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-    pub struct PageFlags: u8 {
+    pub struct ProtFlags: u8 {
         const NONE     = 0x00;
         const R        = 0x01;
         const W        = 0x02;
@@ -51,7 +54,13 @@ impl_bitflags! {
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub struct PageInfo {
     pub typ: PageType,
-    pub flags: PageFlags,
+    pub prot: ProtFlags,
+}
+
+impl Into<u32> for PageInfo {
+    fn into(self) -> u32 {
+        (Into::<u8>::into(self.typ) as u32) << 8 | (self.prot.bits() as u32)
+    }
 }
 
 unsafe impl ContiguousMemory for PageInfo {}
@@ -106,7 +115,7 @@ impl PageRange {
     pub(crate) fn modify(&self) -> SgxResult {
         for page in self.iter() {
             let _ = page.modpe();
-            if !page.info.flags.contains(PageFlags::W | PageFlags::X) {
+            if !page.info.prot.contains(ProtFlags::W | ProtFlags::X) {
                 page.accept()?;
             }
         }

sgx_trts/src/edmm/mem.rs

@@ -26,7 +26,7 @@ cfg_if! {
 #[cfg(not(any(feature = "sim", feature = "hyper")))]
 mod hw {
     use crate::arch::{self, Layout};
-    use crate::edmm::epc::{PageFlags, PageInfo, PageRange, PageType};
+    use crate::edmm::epc::{PageInfo, PageRange, PageType, ProtFlags};
     use crate::edmm::layout::LayoutTable;
     use crate::edmm::perm;
     use crate::edmm::trim;
@@ -47,7 +47,7 @@ mod hw {
                 count,
                 PageInfo {
                     typ: PageType::Reg,
-                    flags: PageFlags::R | PageFlags::W | PageFlags::PENDING,
+                    prot: ProtFlags::R | ProtFlags::W | ProtFlags::PENDING,
                 },
             )?;
             if (attr.attr & arch::PAGE_DIR_GROW_DOWN) == 0 {
@@ -74,7 +74,7 @@ mod hw {
             count,
             PageInfo {
                 typ: PageType::Trim,
-                flags: PageFlags::MODIFIED,
+                prot: ProtFlags::MODIFIED,
             },
         )?;
         pages.accept_forward()?;
@@ -96,7 +96,7 @@ mod hw {
             count,
             PageInfo {
                 typ: PageType::Reg,
-                flags: PageFlags::R | PageFlags::W | PageFlags::PENDING,
+                prot: ProtFlags::R | ProtFlags::W | ProtFlags::PENDING,
             },
         )?;
         pages.accept_forward()?;
@@ -131,7 +131,7 @@ mod hw {
                         count,
                         PageInfo {
                             typ: PageType::Trim,
-                            flags: PageFlags::MODIFIED,
+                            prot: ProtFlags::MODIFIED,
                         },
                     )?;
                     pages.accept_forward()?;
@@ -196,7 +196,7 @@ mod hw {
             count,
             PageInfo {
                 typ: PageType::Reg,
-                flags: PageFlags::PR | PageFlags::from_bits_truncate(perm),
+                prot: ProtFlags::PR | ProtFlags::from_bits_truncate(perm),
             },
         )?;
 

sgx_trts/src/edmm/mod.rs

@@ -24,6 +24,6 @@ pub(crate) mod tcs;
 #[cfg(not(any(feature = "sim", feature = "hyper")))]
 pub(crate) mod trim;
 
-pub use epc::{PageFlags, PageInfo, PageRange, PageType};
+pub use epc::{PageInfo, PageRange, PageType, ProtFlags};
 pub use mem::{apply_epc_pages, trim_epc_pages};
 pub use perm::{modpr_ocall, mprotect_ocall};

sgx_trts/src/edmm/perm.rs

@@ -27,6 +27,8 @@ cfg_if! {
 mod hw {
     use crate::arch::SE_PAGE_SHIFT;
     use crate::call::{ocall, OCallIndex, OcAlloc};
+    use crate::edmm::{PageInfo, PageType};
+    use crate::emm::flags::AllocFlags;
     use alloc::boxed::Box;
     use core::convert::Into;
     use sgx_types::error::{SgxResult, SgxStatus};
@@ -67,6 +69,74 @@ mod hw {
 
         ocall(OCallIndex::Mprotect, Some(change.as_mut()))
     }
+
+    // In keeping with Intel SDK, here we use the name page_properties,
+    // but page_type: PageType is more appropriate
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug, Default)]
+    struct EmmAllocOcall {
+        retval: i32,
+        addr: usize,
+        size: usize,
+        page_properties: u32,
+        alloc_flags: u32,
+    }
+
+    /// FIXME: fake alloc
+    pub fn alloc_ocall(
+        addr: usize,
+        length: usize,
+        page_type: PageType,
+        alloc_flags: AllocFlags,
+    ) -> SgxResult {
+        let mut change = Box::try_new_in(
+            EmmAllocOcall {
+                retval: 0, // not sure
+                addr,
+                size: length,
+                page_properties: Into::<u8>::into(page_type) as u32,
+                alloc_flags: alloc_flags.bits(),
+            },
+            OcAlloc,
+        )
+        .map_err(|_| SgxStatus::OutOfMemory)?;
+
+        ocall(OCallIndex::Alloc, Some(change.as_mut()))
+    }
+
+    // In keeping with Intel SDK, here we use the name flags_from (si_flags),
+    // but we rename si_flags to page_info, here info_from: PageInfo is more appropriate
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug, Default)]
+    struct EmmModifyOcall {
+        retval: i32,
+        addr: usize,
+        size: usize,
+        flags_from: u32,
+        flags_to: u32,
+    }
+
+    /// FIXME: fake modify
+    pub fn modify_ocall(
+        addr: usize,
+        length: usize,
+        info_from: PageInfo,
+        info_to: PageInfo,
+    ) -> SgxResult {
+        let mut change = Box::try_new_in(
+            EmmModifyOcall {
+                retval: 0,
+                addr,
+                size: length,
+                flags_from: Into::<u32>::into(info_from),
+                flags_to: Into::<u32>::into(info_to),
+            },
+            OcAlloc,
+        )
+        .map_err(|_| SgxStatus::OutOfMemory)?;
+
+        ocall(OCallIndex::Modify, Some(change.as_mut()))
+    }
 }
 
 #[cfg(any(feature = "sim", feature = "hyper"))]

sgx_trts/src/edmm/tcs.rs

@@ -63,7 +63,7 @@ pub fn mktcs(mk_tcs: NonNull<MkTcs>) -> SgxResult {
 #[cfg(not(any(feature = "sim", feature = "hyper")))]
 mod hw {
     use crate::arch::{self, Layout, Tcs};
-    use crate::edmm::epc::{Page, PageFlags, PageInfo, PageType};
+    use crate::edmm::epc::{Page, PageInfo, PageType, ProtFlags};
     use crate::enclave::MmLayout;
     use crate::tcs::list;
     use core::ptr;
@@ -123,7 +123,7 @@ mod hw {
             tcs.as_ptr() as usize,
             PageInfo {
                 typ: PageType::Tcs,
-                flags: PageFlags::MODIFIED,
+                prot: ProtFlags::MODIFIED,
             },
         )?;
         page.accept()?;
@@ -175,7 +175,7 @@ mod hw {
                 tcs.as_ptr() as usize,
                 PageInfo {
                     typ: PageType::Trim,
-                    flags: PageFlags::MODIFIED,
+                    prot: ProtFlags::MODIFIED,
                 },
             )?;
             page.accept()?;

sgx_trts/src/emm/alloc.rs

@@ -0,0 +1,31 @@
+use core::alloc::{AllocError, Allocator, Layout};
+use core::ptr::NonNull;
+
+/// alloc layout memory from Reserve region
+#[derive(Clone)]
+pub struct ResAlloc;
+
+unsafe impl Allocator for ResAlloc {
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        todo!()
+    }
+
+    #[inline]
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        todo!()
+    }
+}
+
+#[derive(Clone)]
+pub struct StaticAlloc;
+
+unsafe impl Allocator for StaticAlloc {
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        todo!()
+    }
+
+    #[inline]
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        todo!()
+    }
+}