Use custom backtrace formatting for Fuchsia

Author: cramertj

Cargo.toml

@@ -40,8 +40,10 @@ winapi = { version = "0.3.3", optional = true }
 goblin = { version = "0.0.24", optional = true, default-features = false, features = ['pe32', 'pe64'] }
 [target.'cfg(target_os = "macos")'.dependencies]
 goblin = { version = "0.0.24", optional = true, default-features = false, features = ['mach32', 'mach64'] }
-[target.'cfg(not(any(target_os = "macos", windows)))'.dependencies]
+[target.'cfg(not(any(target_os = "fuchsia", target_os = "macos", windows)))'.dependencies]
 goblin = { version = "0.0.24", optional = true, default-features = false, features = ['elf32', 'elf64'] }
+[target.'cfg(target_os = "fuchsia")'.dependencies]
+fuchsia_backtrace = "0.1"
 
 # Each feature controls the two phases of finding a backtrace: getting a
 # backtrace and then resolving instruction pointers to symbols. The default

src/capture.rs

@@ -120,7 +120,7 @@ cfg_if::cfg_if! {
 
         impl BacktraceSymbolImpl {
             fn from_symbol(symbol: &Symbol) -> Self {
-                BacktraceSymbol {
+                BacktraceSymbolImpl {
                     name: symbol.name().map(|m| m.as_bytes().to_vec()),
                     addr: symbol.addr().map(|a| a as usize),
                     filename: symbol.filename().map(|m| m.to_owned()),
@@ -129,13 +129,13 @@ cfg_if::cfg_if! {
             }
 
             fn name(&self) -> Option<&[u8]> {
-                self.name.as_ref().map(|x| x.deref())
+                self.name.as_ref().map(|x| &**x)
             }
             fn addr(&self) -> Option<usize> {
                 self.addr
             }
             fn filename(&self) -> Option<&Path> {
-                self.filename.as_ref().map(|x| x.deref())
+                self.filename.as_ref().map(|x| &**x)
             }
             fn lineno(&self) -> Option<u32> {
                 self.lineno
@@ -373,69 +373,19 @@ impl BacktraceSymbol {
     }
 }
 
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "fuchsia")] {
+        mod fuchsia_backtrace_fmt;
+        use fuchsia_backtrace_fmt::fmt_backtrace;
+    } else {
+        mod default_backtrace_fmt;
+        use default_backtrace_fmt::fmt_backtrace;
+    }
+}
+
 impl fmt::Debug for Backtrace {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "stack backtrace:")?;
-
-        let iter = if fmt.alternate() {
-            self.frames.iter()
-        } else {
-            self.frames[self.actual_start_index..].iter()
-        };
-
-        for (idx, frame) in iter.enumerate() {
-            // To reduce TCB size in Sgx enclave, we do not want to implement symbol resolution functionality.
-            // Rather, we can print the offset of the address here, which could be later mapped to
-            // correct function.
-            let ip: *mut c_void;
-            #[cfg(target_env = "sgx")]
-            {
-                ip = usize::wrapping_sub(
-                    frame.ip() as _,
-                    std::os::fortanix_sgx::mem::image_base() as _,
-                ) as _;
-            }
-            #[cfg(not(target_env = "sgx"))]
-            {
-                ip = frame.ip();
-            }
-
-            write!(fmt, "\n{:4}: ", idx)?;
-
-            let symbols = match frame.symbols {
-                Some(ref s) => s,
-                None => {
-                    write!(fmt, "<unresolved> ({:?})", ip)?;
-                    continue;
-                }
-            };
-            if symbols.len() == 0 {
-                write!(fmt, "<no info> ({:?})", ip)?;
-                continue;
-            }
-
-            for (idx, symbol) in symbols.iter().enumerate() {
-                if idx != 0 {
-                    write!(fmt, "\n      ")?;
-                }
-
-                if let Some(name) = symbol.name() {
-                    write!(fmt, "{}", name)?;
-                } else {
-                    write!(fmt, "<unknown>")?;
-                }
-
-                if idx == 0 {
-                    write!(fmt, " ({:?})", ip)?;
-                }
-
-                if let (Some(file), Some(line)) = (symbol.filename(), symbol.lineno()) {
-                    write!(fmt, "\n             at {}:{}", file.display(), line)?;
-                }
-            }
-        }
-
-        Ok(())
+        fmt_backtrace(self, fmt)
     }
 }
 

src/capture/default_backtrace_fmt.rs

@@ -0,0 +1,67 @@
+use crate::Backtrace;
+use std::ffi::c_void;
+use std::fmt;
+
+pub(super) fn fmt_backtrace(bt: &Backtrace, fmt: &mut fmt::Formatter) -> fmt::Result {
+    write!(fmt, "stack backtrace:")?;
+
+    let iter = if fmt.alternate() {
+        bt.frames.iter()
+    } else {
+        bt.frames[bt.actual_start_index..].iter()
+    };
+
+    for (idx, frame) in iter.enumerate() {
+        // To reduce TCB size in Sgx enclave, we do not want to implement symbol resolution functionality.
+        // Rather, we can print the offset of the address here, which could be later mapped to
+        // correct function.
+        let ip: *mut c_void;
+        #[cfg(target_env = "sgx")]
+        {
+            ip = usize::wrapping_sub(
+                frame.ip() as _,
+                std::os::fortanix_sgx::mem::image_base() as _,
+            ) as _;
+        }
+        #[cfg(not(target_env = "sgx"))]
+        {
+            ip = frame.ip();
+        }
+
+        write!(fmt, "\n{:4}: ", idx)?;
+
+        let symbols = match frame.symbols {
+            Some(ref s) => s,
+            None => {
+                write!(fmt, "<unresolved> ({:?})", ip)?;
+                continue;
+            }
+        };
+        if symbols.len() == 0 {
+            write!(fmt, "<no info> ({:?})", ip)?;
+            continue;
+        }
+
+        for (idx, symbol) in symbols.iter().enumerate() {
+            if idx != 0 {
+                write!(fmt, "\n      ")?;
+            }
+
+            if let Some(name) = symbol.name() {
+                write!(fmt, "{}", name)?;
+            } else {
+                write!(fmt, "<unknown>")?;
+            }
+
+            if idx == 0 {
+                write!(fmt, " ({:?})", ip)?;
+            }
+
+            if let (Some(file), Some(line)) = (symbol.filename(), symbol.lineno()) {
+                write!(fmt, "\n             at {}:{}", file.display(), line)?;
+            }
+        }
+    }
+
+    Ok(())
+}

src/capture/fuchsia_backtrace_fmt.rs

@@ -0,0 +1,30 @@
+use crate::Backtrace;
+use libc::c_void;
+use std::fmt;
+
+pub(super) fn fmt_backtrace(bt: &Backtrace, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fmt.write_str("stack backtrace:\n")?;
+
+    // Print the DSO context to tell the logger where our libs are loaded into memory.
+    let mut dso_cx = vec![];
+    fuchsia_backtrace::print_dso_context(&mut dso_cx).map_err(|_| fmt::Error)?;
+    if let Ok(s) = std::string::String::from_utf8(dso_cx) {
+        fmt.write_str(&s)?;
+    }
+
+    let iter = if fmt.alternate() {
+        bt.frames.iter()
+    } else {
+        bt.frames[bt.actual_start_index..].iter()
+    };
+
+    // Print the addresses of the backtrace frames
+    for (idx, frame) in iter.enumerate() {
+        let ip: *mut c_void = frame.ip();
+        fmt.write_str("{{{bt:")?;
+        write!(fmt, "{}:{:?}", idx, ip)?;
+        fmt.write_str("}}}\n")?;
+    }
+
+    Ok(())
+}