wiggle things around to use pinned heap reg

Author: awortman-fastly

benchmarks/lucet-benchmarks/src/context.rs

@@ -9,7 +9,7 @@ fn context_init(c: &mut Criterion) {
 
     c.bench_function("context_init", move |b| {
         b.iter(|| {
-            ContextHandle::create_and_init(&mut *stack, f as usize, &[]).unwrap();
+            ContextHandle::create_and_init(&mut *stack, f as usize, &[], std::ptr::null_mut()).unwrap();
         })
     });
 }
@@ -22,7 +22,7 @@ fn context_swap_return(c: &mut Criterion) {
         b.iter_batched(
             || {
                 let mut stack = vec![0u64; 1024].into_boxed_slice();
-                let child = ContextHandle::create_and_init(&mut *stack, f as usize, &[]).unwrap();
+                let child = ContextHandle::create_and_init(&mut *stack, f as usize, &[], std::ptr::null_mut()).unwrap();
                 (stack, child)
             },
             |(stack, mut child)| unsafe {
@@ -45,7 +45,7 @@ fn context_init_swap_return(c: &mut Criterion) {
             |mut stack| {
                 let mut parent = ContextHandle::new();
                 let mut child =
-                    ContextHandle::create_and_init(&mut *stack, f as usize, &[]).unwrap();
+                    ContextHandle::create_and_init(&mut *stack, f as usize, &[], std::ptr::null_mut()).unwrap();
                 unsafe { Context::swap(&mut parent, &mut child) };
                 stack
             },
@@ -333,7 +333,7 @@ fn context_init_swap_return_many_args(c: &mut Criterion) {
             |mut stack| {
                 let mut parent = ContextHandle::new();
                 let mut child =
-                    ContextHandle::create_and_init(&mut *stack, f as usize, &args).unwrap();
+                    ContextHandle::create_and_init(&mut *stack, f as usize, &args, std::ptr::null_mut()).unwrap();
                 unsafe { Context::swap(&mut parent, &mut child) };
                 stack
             },

lucet-runtime/lucet-runtime-internals/src/alloc/tests.rs

@@ -610,6 +610,7 @@ macro_rules! alloc_tests {
                     inst.alloc_mut().stack_u64_mut(),
                     heap_touching_child as usize,
                     &[Val::CPtr(heap_ptr)],
+                    heap_ptr,
                 )
                 .expect("context init succeeds");
                 Context::swap(&mut parent, &mut child);
@@ -659,6 +660,7 @@ macro_rules! alloc_tests {
                     inst.alloc_mut().stack_u64_mut(),
                     stack_pattern_child as usize,
                     &[Val::CPtr(heap_ptr)],
+                    heap_ptr,
                 )
                 .expect("context init succeeds");
                 Context::swap(&mut parent, &mut child);

lucet-runtime/lucet-runtime-internals/src/context/context_asm.S

@@ -118,6 +118,7 @@ _lucet_context_swap:
     mov %r14, (6*8)(%rdi)
     mov %r15, (7*8)(%rdi)
     mov %rsi, (8*8)(%rdi)
+    mov %r8,  (9*8)(%rdi)
 
     movdqu %xmm0, (10*8 + 0*16)(%rdi)
     movdqu %xmm1, (10*8 + 1*16)(%rdi)
@@ -137,6 +138,7 @@ _lucet_context_swap:
     mov (5*8)(%rsi), %r13
     mov (6*8)(%rsi), %r14
     mov (7*8)(%rsi), %r15
+    mov (9*8)(%rsi), %r8
 
     movdqu (10*8 + 0*16)(%rsi), %xmm0
     movdqu (10*8 + 1*16)(%rsi), %xmm1

lucet-runtime/lucet-runtime-internals/src/context/mod.rs

@@ -35,6 +35,7 @@ pub(crate) struct GpRegs {
     r14: u64,
     r15: u64,
     pub(crate) rsi: u64,
+    r8: u64
 }
 
 impl GpRegs {
@@ -49,6 +50,7 @@ impl GpRegs {
             r14: 0,
             r15: 0,
             rsi: 0,
+            r8: 0,
         }
     }
 }
@@ -206,9 +208,10 @@ impl ContextHandle {
         stack: &mut [u64],
         fptr: usize,
         args: &[Val],
+        heap: *mut core::ffi::c_void,
     ) -> Result<ContextHandle, Error> {
         let mut child = ContextHandle::new();
-        Context::init(stack, &mut child, fptr, args)?;
+        Context::init(stack, &mut child, fptr, args, heap)?;
         Ok(child)
     }
 }
@@ -365,6 +368,7 @@ impl Context {
         child: &mut Context,
         fptr: usize,
         args: &[Val],
+        heap: *mut core::ffi::c_void,
     ) -> Result<(), Error> {
         Context::init_with_callback(
             stack,
@@ -373,6 +377,7 @@ impl Context {
             ptr::null_mut(),
             fptr,
             args,
+            heap,
         )
     }
 
@@ -391,6 +396,7 @@ impl Context {
         backstop_data: *mut Instance,
         fptr: usize,
         args: &[Val],
+        heap: *mut core::ffi::c_void,
     ) -> Result<(), Error> {
         if !stack_is_aligned(stack) {
             return Err(Error::UnalignedStack);
@@ -471,6 +477,9 @@ impl Context {
 
         child.gpr.rbp = child as *const Context as u64;
 
+        // testing out heap pinning
+        child.gpr.r15 = heap as u64;
+
         // Read the mask to be restored if we ever need to jump out of a signal handler. If this
         // isn't possible, die.
         signal::pthread_sigmask(

lucet-runtime/lucet-runtime-internals/src/context/tests/c_child.rs

@@ -55,6 +55,7 @@ macro_rules! init_and_swap {
                 &mut *$stack,
                 $fn as usize,
                 &[$( $args ),*],
+                std::ptr::null_mut(),
             ).unwrap()));
 
             child_regs = child;

lucet-runtime/lucet-runtime-internals/src/context/tests/mod.rs

@@ -31,7 +31,7 @@ fn init_rejects_unaligned() {
     let mut stack_unaligned = unsafe { slice::from_raw_parts_mut(ptr, len) };
 
     // now we have the unaligned stack, let's make sure it blows up right
-    let res = ContextHandle::create_and_init(&mut stack_unaligned, dummy as usize, &[]);
+    let res = ContextHandle::create_and_init(&mut stack_unaligned, dummy as usize, &[], std::ptr::null_mut());
 
     if let Err(Error::UnalignedStack) = res {
         assert!(true);

lucet-runtime/lucet-runtime-internals/src/context/tests/rust_child.rs

@@ -51,6 +51,7 @@ macro_rules! init_and_swap {
                 &mut *$stack,
                 $fn as usize,
                 &[$( $args ),*],
+                std::ptr::null_mut(),
             ).unwrap();
             CHILD = Some(child);
 

lucet-runtime/lucet-runtime-internals/src/instance.rs

@@ -843,7 +843,8 @@ impl Instance {
 
         self.entrypoint = Some(func.ptr);
 
-        let mut args_with_vmctx = vec![Val::from(self.alloc.slot().heap)];
+        let heap = self.alloc.slot().heap;
+        let mut args_with_vmctx = vec![Val::from(heap)];
         args_with_vmctx.extend_from_slice(args);
 
         let self_ptr = self as *mut _;
@@ -854,6 +855,7 @@ impl Instance {
             self_ptr,
             func.ptr.as_usize(),
             &args_with_vmctx,
+            heap,
         )?;
 
         // Set up the guest to set itself as terminable, then continue to

lucetc/src/compiler.rs

@@ -253,6 +253,8 @@ impl<'a> Compiler<'a> {
         let isa_builder = cpu_features.isa_builder(target)?;
         flags_builder.enable("enable_verifier").unwrap();
         flags_builder.enable("is_pic").unwrap();
+        flags_builder.enable("enable_pinned_reg");
+        flags_builder.enable("use_pinned_reg_as_heap_base");
         flags_builder.set("opt_level", opt_level.to_flag()).unwrap();
         if canonicalize_nans {
             flags_builder.enable("enable_nan_canonicalization").unwrap();