add rudimentary backtrace support, still needs to be cleaned up

Author: acfoltzer

Cargo.lock

@@ -13,6 +13,7 @@ edition = "2018"
 lucet-module = { path = "../../lucet-module", version = "0.5.0" }
 lucet-runtime-macros = { path = "../lucet-runtime-macros", version = "0.5.0" }
 
+backtrace = "0.3"
 bitflags = "1.0"
 bincode = "1.1.4"
 byteorder = "1.3"

lucet-runtime/lucet-runtime-internals/Cargo.toml

@@ -295,6 +295,10 @@ pub mod lucet_result {
                                     .map(|CTerminationDetails { details }| *details)
                                     .unwrap_or(ptr::null_mut()),
                             },
+                            TerminationDetails::ForcedUnwind => lucet_terminated {
+                                reason: lucet_terminated_reason::ForcedUnwind,
+                                provided: std::ptr::null_mut(),
+                            },
                             TerminationDetails::Remote => lucet_terminated {
                                 reason: lucet_terminated_reason::Remote,
                                 provided: std::ptr::null_mut(),
@@ -352,6 +356,7 @@ pub mod lucet_result {
         YieldTypeMismatch,
         BorrowError,
         Provided,
+        ForcedUnwind,
         Remote,
     }
 

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

@@ -15,6 +15,7 @@ use crate::module::{self, FunctionHandle, FunctionPointer, Global, GlobalValue,
 use crate::region::RegionInternal;
 use crate::val::{UntypedRetVal, Val};
 use crate::WASM_PAGE_SIZE;
+use backtrace::Backtrace;
 use libc::{c_void, pthread_self, siginfo_t, uintptr_t};
 use lucet_module::InstanceRuntimeData;
 use memoffset::offset_of;
@@ -984,6 +985,7 @@ impl Instance {
                 mut details,
                 siginfo,
                 context,
+                full_backtrace,
             } => {
                 // Sandbox is no longer runnable. It's unsafe to determine all error details in the signal
                 // handler, so we fill in extra details here.
@@ -994,11 +996,15 @@ impl Instance {
                     .module
                     .addr_details(details.rip_addr as *const c_void)?;
 
+                details.backtrace = Some(self.module.resolve_and_trim(&full_backtrace));
+                // dbg!(&details.backtrace);
+
                 // fill the state back in with the updated details in case fatal handlers need it
                 self.state = State::Faulted {
                     details: details.clone(),
                     siginfo,
                     context,
+                    full_backtrace,
                 };
 
                 if details.fatal {
@@ -1180,6 +1186,8 @@ pub struct FaultDetails {
     pub rip_addr: uintptr_t,
     /// Extra information about the instruction pointer's location, if available.
     pub rip_addr_details: Option<module::AddrDetails>,
+    /// Backtrace of the frames from the guest stack, if available.
+    pub backtrace: Option<Backtrace>,
 }
 
 impl std::fmt::Display for FaultDetails {
@@ -1240,6 +1248,8 @@ pub enum TerminationDetails {
     BorrowError(&'static str),
     /// Calls to `lucet_hostcall_terminate` provide a payload for use by the embedder.
     Provided(Box<dyn Any + 'static>),
+    /// Returned when the stack is forced to unwind on instance reset or drop.
+    ForcedUnwind,
     Remote,
 }
 
@@ -1291,6 +1301,7 @@ impl std::fmt::Debug for TerminationDetails {
             TerminationDetails::YieldTypeMismatch => write!(f, "YieldTypeMismatch"),
             TerminationDetails::Provided(_) => write!(f, "Provided(Any)"),
             TerminationDetails::Remote => write!(f, "Remote"),
+            TerminationDetails::ForcedUnwind => write!(f, "ForcedUnwind"),
         }
     }
 }

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

@@ -5,6 +5,7 @@ use crate::instance::{
     HOST_CTX,
 };
 use crate::sysdeps::UContextPtr;
+use backtrace::Backtrace;
 use lazy_static::lazy_static;
 use libc::{c_int, c_void, siginfo_t, SIGBUS, SIGSEGV};
 use lucet_module::TrapCode;
@@ -90,7 +91,7 @@ impl Instance {
             Ok(res) => res,
             Err(e) => match e.downcast::<TerminationDetails>() {
                 Ok(details) => {
-                    self.state = State::Terminated { details: *details };
+                    self.state = State::Terminating { details: *details };
                     Ok(())
                 }
                 Err(e) => {
@@ -196,7 +197,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);
-        match behavior {
+        let switch_to_host = match behavior {
             SignalBehavior::Continue => {
                 // return to the guest context without making any modifications to the instance
                 false
@@ -245,9 +246,11 @@ extern "C" fn handle_signal(signum: c_int, siginfo_ptr: *mut siginfo_t, ucontext
                             // Details set to `None` here: have to wait until `verify_trap_safety` to
                             // fill in these details, because access may not be signal safe.
                             rip_addr_details: None,
+                            backtrace: None,
                         },
                         siginfo,
                         context: ctx.into(),
+                        full_backtrace: Backtrace::new_unresolved(),
                     };
                 };
 
@@ -259,12 +262,6 @@ extern "C" fn handle_signal(signum: c_int, siginfo_ptr: *mut siginfo_t, ucontext
         if switch_to_host {
             // we must disable termination so no KillSwitch may fire in host code.
             inst.kill_state.disable_termination();
-
-            // use the ucontext to fill in the fields of the guest context; we can't use
-            // `Context::swap()` here because then we'd swap back to the signal handler instead of
-            // the point in the guest that caused the fault
-            ctx.save_to_context(&mut inst.ctx);
-            inst.ctx.stop_addr = Some(rip as u64);
         }
 
         switch_to_host

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

@@ -1,6 +1,7 @@
 use crate::instance::siginfo_ext::SiginfoExt;
 use crate::instance::{FaultDetails, TerminationDetails, YieldedVal};
 use crate::sysdeps::UContext;
+use backtrace::Backtrace;
 use libc::{SIGBUS, SIGSEGV};
 use std::any::Any;
 use std::ffi::{CStr, CString};
@@ -26,6 +27,7 @@ pub enum State {
         details: FaultDetails,
         siginfo: libc::siginfo_t,
         context: UContext,
+        full_backtrace: Backtrace,
     },
 
     /// The instance is in the process of terminating.

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

@@ -11,6 +11,7 @@ pub use lucet_module::{
 
 use crate::alloc::Limits;
 use crate::error::Error;
+use backtrace::Backtrace;
 use libc::c_void;
 
 /// Details about a program address.
@@ -64,6 +65,8 @@ pub trait ModuleInternal: Send + Sync {
 
     fn addr_details(&self, addr: *const c_void) -> Result<Option<AddrDetails>, Error>;
 
+    fn resolve_and_trim(&self, full_bt: &Backtrace) -> Backtrace;
+
     fn get_signature(&self, fn_id: FunctionIndex) -> &Signature;
 
     fn function_handle_from_ptr(&self, ptr: FunctionPointer) -> FunctionHandle {

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

@@ -1,5 +1,6 @@
 use crate::error::Error;
 use crate::module::{AddrDetails, GlobalSpec, HeapSpec, Module, ModuleInternal, TableElement};
+use backtrace::{Backtrace, BacktraceFrame};
 use libc::c_void;
 use libloading::Library;
 use lucet_module::{
@@ -303,6 +304,50 @@ impl ModuleInternal for DlModule {
     fn get_signature(&self, fn_id: FunctionIndex) -> &Signature {
         self.module.module_data.get_signature(fn_id)
     }
+
+    fn resolve_and_trim(&self, full_bt: &Backtrace) -> Backtrace {
+        let mut bt = full_bt.clone();
+        bt.resolve();
+        let trimmed_frames = bt
+            .frames()
+            .iter()
+            .filter(|fr| match self.addr_details(fr.ip()) {
+                // if we can look up addr details, and it's in module code, keep the frame
+                Ok(Some(details)) => details.in_module_code,
+                _ => false,
+            })
+            // // skip everything until the entry to the signal handler
+            // .skip_while(|fr| {
+            //     fr.symbols()
+            //         .iter()
+            //         .find(|sym| {
+            //             sym.name().map_or(false, |sn| {
+            //                 let name = format!("{}", sn);
+            //                 name.starts_with(
+            //                     "lucet_runtime_internals::instance::signals::handle_signal",
+            //                 ) && !name.contains("closure")
+            //             })
+            //         })
+            //         .is_none()
+            // })
+            // // drop the handle_signal frame
+            // .skip(1)
+            // // take all frames between handle_signal and Context::swap
+            // .take_while(|fr| {
+            //     fr.symbols()
+            //         .iter()
+            //         .find(|sym| {
+            //             sym.name().map_or(false, |sn| {
+            //                 format!("{}", sn)
+            //                     .starts_with("lucet_runtime_internals::context::Context::swap")
+            //             })
+            //         })
+            //         .is_none()
+            // })
+            .cloned()
+            .collect::<Vec<BacktraceFrame>>();
+        trimmed_frames.into()
+    }
 }
 
 // TODO: PR to nix or libloading?

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

@@ -1,5 +1,6 @@
 use crate::error::Error;
 use crate::module::{AddrDetails, GlobalSpec, HeapSpec, Module, ModuleInternal, TableElement};
+use backtrace::Backtrace;
 use libc::c_void;
 use lucet_module::owned::{
     OwnedExportFunction, OwnedFunctionMetadata, OwnedGlobalSpec, OwnedImportFunction,
@@ -319,6 +320,14 @@ impl ModuleInternal for MockModule {
         Ok(None)
     }
 
+    fn resolve_and_trim(&self, full_bt: &Backtrace) -> Backtrace {
+        // for a mock module, just resolve since we can't differentiate between hostcall code and
+        // mock module functions
+        let mut bt = full_bt.clone();
+        bt.resolve();
+        bt
+    }
+
     fn get_signature(&self, fn_id: FunctionIndex) -> &Signature {
         self.module_data.get_signature(fn_id)
     }