simplify unwinding implementation by using Faulted state

This state already had the context information we needed to initiate unwinding, so we didn't need to
add an extra field on our `Context`, or preemptively overwrite the guest context in the signal handler

Author: acfoltzer

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

@@ -125,7 +125,6 @@ pub struct Context {
     backstop_callback: *const unsafe extern "C" fn(*mut Instance),
     backstop_data: *mut Instance,
     sigset: signal::SigSet,
-    pub(crate) stop_addr: Option<u64>,
 }
 
 impl Context {
@@ -140,7 +139,6 @@ impl Context {
             backstop_callback: Context::default_backstop_callback as *const _,
             backstop_data: ptr::null_mut(),
             sigset: signal::SigSet::empty(),
-            stop_addr: None,
         }
     }
 }

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

@@ -1077,20 +1077,21 @@ impl Instance {
                     Ok(_) => lucet_bail!("resume with forced unwind returned normally"),
                 }
             }
-            State::Faulted { .. } => {
+            State::Faulted { context, .. } => {
+                #[unwind(allowed)]
+                extern "C" fn initiate_unwind() {
+                    panic!(TerminationDetails::ForcedUnwind);
+                }
+
+                // set up the guest context as it was when the fault was raised
+                context.as_ptr().save_to_context(&mut self.ctx);
+
+                // get the instruction pointer when the fault was raised
+                let guest_addr = context.as_ptr().get_ip();
+
                 // if we should unwind by returning into the guest to cause a fault, do so with the redzone
                 // available in case the guest was at or close to overflowing.
                 self.with_redzone_stack(|inst| {
-                    #[unwind(allowed)]
-                    extern "C" fn initiate_unwind() {
-                        panic!(TerminationDetails::ForcedUnwind);
-                    }
-
-                    let guest_addr = inst
-                        .ctx
-                        .stop_addr
-                        .expect("guest that stopped in guest code has an address it stopped at");
-
                     // set up the faulting instruction pointer as the return address for `initiate_unwind`;
                     // extremely unsafe, doesn't handle any edge cases yet
                     //
@@ -1148,22 +1149,19 @@ impl Instance {
                     inst.push(initiate_unwind as u64)
                         .expect("stack has available space");
 
-                    inst.state = State::Ready;
-
                     match inst.swap_and_return() {
                         Ok(_) => panic!("forced unwinding shouldn't return normally"),
                         Err(Error::RuntimeTerminated(TerminationDetails::ForcedUnwind)) => (),
                         Err(e) => panic!("unexpected error: {}", e),
                     }
 
                     // we've unwound the stack, so we know there are no longer any host frames.
-                    // inst.hostcall_count = 0;
-                    inst.ctx.stop_addr = None;
+                    debug_assert_eq!(inst.hostcall_count, 0);
 
                     Ok(())
                 })
             }
-            st => panic!("should never do forced unwinding in this state: {}", st),
+            st => lucet_bail!("should never do forced unwinding in this state: {}", st),
         }
     }
 }

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

@@ -196,7 +196,7 @@ extern "C" fn handle_signal(signum: c_int, siginfo_ptr: *mut siginfo_t, ucontext
         let trapcode = inst.module.lookup_trapcode(rip);
 
         let behavior = (inst.signal_handler)(inst, &trapcode, signum, siginfo_ptr, ucontext_ptr);
-        let switch_to_host = match behavior {
+        match behavior {
             SignalBehavior::Continue => {
                 // return to the guest context without making any modifications to the instance
                 false

lucet-runtime/lucet-runtime-internals/src/sysdeps/linux.rs

@@ -76,7 +76,7 @@ impl UContext {
         }
     }
 
-    pub fn as_ptr(&mut self) -> UContextPtr {
+    pub fn as_ptr(&self) -> UContextPtr {
         UContextPtr::new(&self.context as *const _ as *const _)
     }
 }