Add framehow as an unwinder and support perfmaps

Author: Maaarcocr

Cargo.lock

@@ -20,6 +20,10 @@ frame-pointer = []
 _protobuf = []
 prost-codec = ["prost", "prost-derive", "prost-build", "sha2", "_protobuf"]
 protobuf-codec = ["protobuf", "protobuf-codegen", "_protobuf"]
+framehop-unwinder = ["framehop", "memmap2", "object"]
+perfmaps = ["notify-debouncer-mini"]
+large-depth = []
+huge-depth = []
 
 [dependencies]
 backtrace = { version = "0.3" }
@@ -41,6 +45,12 @@ protobuf = { version = ">=3.7.2", optional = true }
 criterion = {version = "0.5", optional = true}
 aligned-vec = "0.6"
 
+# framehop unwinder dependencies
+framehop = { version = "0.13", optional = true }
+memmap2 = { version = "0.5.5", optional = true }
+object = { version = "0.29.0", optional = true }
+notify-debouncer-mini = { version = "0.4.1", optional = true }
+
 [dependencies.symbolic-demangle]
 version = "12.1"
 default-features = false

Cargo.toml

@@ -0,0 +1,169 @@
+use framehop::{
+    CacheNative, MustNotAllocateDuringUnwind, UnwindRegsNative, Unwinder, UnwinderNative,
+};
+use libc::{c_void, ucontext_t};
+use once_cell::sync::Lazy;
+mod shlib;
+
+#[cfg(all(target_arch = "aarch64", target_os = "macos"))]
+fn get_regs_from_context(ucontext: *mut c_void) -> Option<(UnwindRegsNative, u64)> {
+    let ucontext: *mut ucontext_t = ucontext as *mut ucontext_t;
+    if ucontext.is_null() {
+        return None;
+    }
+
+    let thread_state = unsafe {
+        let mcontext = (*ucontext).uc_mcontext;
+        if mcontext.is_null() {
+            return None;
+        } else {
+            (*mcontext).__ss
+        }
+    };
+
+    Some((
+        UnwindRegsNative::new(thread_state.__lr, thread_state.__sp, thread_state.__fp),
+        thread_state.__pc,
+    ))
+}
+
+#[cfg(all(target_arch = "x86_64", target_os = "macos"))]
+fn get_regs_from_context(ucontext: *mut c_void) -> Option<(UnwindRegsNative, u64)> {
+    let ucontext: *mut ucontext_t = ucontext as *mut ucontext_t;
+    if ucontext.is_null() {
+        return None;
+    }
+
+    let thread_state = unsafe {
+        let mcontext = (*ucontext).uc_mcontext;
+        if mcontext.is_null() {
+            return None;
+        } else {
+            (*mcontext).__ss
+        }
+    };
+
+    Some((
+        UnwindRegsNative::new(thread_state.__rip, thread_state.__rsp, thread_state.__rbp),
+        thread_state.__rip,
+    ))
+}
+
+#[cfg(all(target_arch = "aarch64", target_os = "linux"))]
+fn get_regs_from_context(ucontext: *mut c_void) -> Option<(UnwindRegsNative, u64)> {
+    let ucontext: *mut ucontext_t = ucontext as *mut ucontext_t;
+    if ucontext.is_null() {
+        return None;
+    }
+
+    let regs = unsafe { &(*ucontext).uc_mcontext.regs };
+    Some((
+        UnwindRegsNative::new(regs[30], regs[31], regs[29]),
+        regs[30],
+    ))
+}
+
+#[cfg(all(target_arch = "x86_64", target_os = "linux"))]
+fn get_regs_from_context(ucontext: *mut c_void) -> Option<(UnwindRegsNative, u64)> {
+    let ucontext: *mut ucontext_t = ucontext as *mut ucontext_t;
+    if ucontext.is_null() {
+        return None;
+    }
+    let regs = unsafe { &(*ucontext).uc_mcontext.gregs };
+
+    Some((
+        UnwindRegsNative::new(
+            regs[libc::REG_RIP as usize] as u64,
+            regs[libc::REG_RSP as usize] as u64,
+            regs[libc::REG_RBP as usize] as u64,
+        ),
+        regs[libc::REG_RIP as usize] as u64,
+    ))
+}
+
+struct FramehopUnwinder {
+    unwinder: UnwinderNative<Vec<u8>, MustNotAllocateDuringUnwind>,
+    cache: CacheNative<MustNotAllocateDuringUnwind>,
+}
+
+impl FramehopUnwinder {
+    pub fn new() -> Self {
+        let mut unwinder = UnwinderNative::new();
+        for obj in shlib::get_objects() {
+            unwinder.add_module(obj.clone());
+        }
+        let cache = CacheNative::default();
+        FramehopUnwinder { unwinder, cache }
+    }
+
+    pub fn iter_frames<F: FnMut(&Frame) -> bool>(&mut self, ctx: *mut c_void, mut cb: F) {
+        let (regs, pc) = match get_regs_from_context(ctx) {
+            Some(fp) => fp,
+            None => return,
+        };
+
+        let mut closure = |addr| read_stack(addr);
+        let mut iter = self
+            .unwinder
+            .iter_frames(pc, regs, &mut self.cache, &mut closure);
+        while let Ok(Some(frame)) = iter.next() {
+            if !cb(&Frame {
+                ip: frame.address() as usize,
+            }) {
+                break;
+            }
+        }
+    }
+}
+
+fn read_stack(addr: u64) -> Result<u64, ()> {
+    let aligned_addr = addr & !0b111;
+    if crate::addr_validate::validate(aligned_addr as _) {
+        Ok(unsafe { (aligned_addr as *const u64).read() })
+    } else {
+        Err(())
+    }
+}
+
+static mut UNWINDER: Lazy<FramehopUnwinder> = Lazy::new(|| FramehopUnwinder::new());
+#[derive(Clone, Debug)]
+pub struct Frame {
+    pub ip: usize,
+}
+
+extern "C" {
+    fn _Unwind_FindEnclosingFunction(pc: *mut c_void) -> *mut c_void;
+
+}
+
+impl super::Frame for Frame {
+    type S = backtrace::Symbol;
+    fn ip(&self) -> usize {
+        self.ip
+    }
+
+    fn symbol_address(&self) -> *mut c_void {
+        if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
+            self.ip as *mut c_void
+        } else {
+            unsafe { _Unwind_FindEnclosingFunction(self.ip as *mut c_void) }
+        }
+    }
+
+    fn resolve_symbol<F: FnMut(&Self::S)>(&self, cb: F) {
+        backtrace::resolve(self.ip as *mut c_void, cb);
+    }
+}
+
+pub struct Trace;
+
+impl super::Trace for Trace {
+    type Frame = Frame;
+
+    fn trace<F: FnMut(&Self::Frame) -> bool>(ctx: *mut c_void, cb: F)
+    where
+        Self: Sized,
+    {
+        unsafe { UNWINDER.iter_frames(ctx, cb) };
+    }
+}

src/backtrace/framehop_unwinder.rs

@@ -0,0 +1,78 @@
+use std::path::PathBuf;
+
+use findshlibs::{SharedLibrary, TargetSharedLibrary};
+use framehop::{Module, ModuleSectionInfo};
+use memmap2::Mmap;
+use object::{Object, ObjectSection};
+use once_cell::sync::Lazy;
+
+static OBJECTS: Lazy<Vec<Module<Vec<u8>>>> = Lazy::new(find_objects);
+
+pub fn get_objects() -> &'static [Module<Vec<u8>>] {
+    &OBJECTS
+}
+
+pub struct ObjectInfo<'f>(object::File<'f>);
+
+impl<'file, D> ModuleSectionInfo<D> for ObjectInfo<'file>
+where
+    D: From<&'file [u8]>,
+{
+    fn base_svma(&self) -> u64 {
+        if let Some(section) = self.0.section_by_name("__TEXT") {
+            // in mach-o addresses are relative to __TEXT
+            section.address()
+        } else {
+            self.0.relative_address_base()
+        }
+    }
+
+    fn section_svma_range(&mut self, name: &[u8]) -> Option<std::ops::Range<u64>> {
+        if let Some(section) = self.0.section_by_name_bytes(name) {
+            let start = section.address();
+            let end = start + section.size();
+            Some(start..end)
+        } else {
+            None
+        }
+    }
+
+    fn section_data(&mut self, name: &[u8]) -> Option<D> {
+        if let Some(section) = self.0.section_by_name_bytes(name) {
+            let data = section.data().ok()?;
+            Some(D::from(data))
+        } else {
+            None
+        }
+    }
+}
+
+fn open_mmap(path: &PathBuf) -> Option<Mmap> {
+    let file = std::fs::File::open(path).ok()?;
+    let mmap = unsafe { Mmap::map(&file) }.ok()?;
+    Some(mmap)
+}
+
+fn find_objects() -> Vec<Module<Vec<u8>>> {
+    let mut objects = Vec::new();
+    // objects
+    TargetSharedLibrary::each(|shlib| {
+        let path = PathBuf::from(shlib.name());
+        let base_avma = shlib.actual_load_addr().0 as u64;
+        let avma_range = base_avma..base_avma + shlib.len() as u64;
+        if let Some(mmap) = open_mmap(&path) {
+            if let Ok(obj) = object::File::parse(&*mmap) {
+                let section_info = ObjectInfo(obj);
+
+                objects.push(Module::new(
+                    path.to_string_lossy().to_string(),
+                    avma_range,
+                    base_avma,
+                    section_info,
+                ));
+            }
+        }
+    });
+
+    objects
+}

src/backtrace/framehop_unwinder/shlib.rs

@@ -55,7 +55,7 @@ pub trait Trace {
         target_arch = "riscv64",
         target_arch = "loongarch64"
     ),
-    feature = "frame-pointer"
+    any(feature = "frame-pointer", feature = "framehop-unwinder")
 )))]
 mod backtrace_rs;
 #[cfg(not(all(
@@ -65,7 +65,7 @@ mod backtrace_rs;
         target_arch = "riscv64",
         target_arch = "loongarch64"
     ),
-    feature = "frame-pointer"
+    any(feature = "frame-pointer", feature = "framehop-unwinder")
 )))]
 pub use backtrace_rs::Trace as TraceImpl;
 
@@ -89,3 +89,17 @@ pub mod frame_pointer;
     feature = "frame-pointer"
 ))]
 pub use frame_pointer::Trace as TraceImpl;
+
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64",),
+    any(target_os = "linux", target_os = "macos",),
+    feature = "framehop-unwinder"
+))]
+pub mod framehop_unwinder;
+
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64",),
+    any(target_os = "linux", target_os = "macos",),
+    feature = "framehop-unwinder"
+))]
+pub use framehop_unwinder::Trace as TraceImpl;

src/backtrace/mod.rs

@@ -13,6 +13,24 @@ use symbolic_demangle::demangle;
 use crate::backtrace::{Frame, Trace, TraceImpl};
 use crate::{MAX_DEPTH, MAX_THREAD_NAME};
 
+#[cfg(feature = "perfmaps")]
+fn resolve_in_perfmap(ip: usize) -> Option<Symbol> {
+    use crate::perfmap::get_resolver;
+
+    if let Ok(Some(perf_map_resolver)) = get_resolver() {
+        if let Some(symbol) = perf_map_resolver.resolve(ip as _) {
+            return Some(Symbol::from(symbol));
+        }
+    }
+
+    None
+}
+
+#[cfg(not(feature = "perfmaps"))]
+fn resolve_in_perfmap(_ip: usize) -> Option<Symbol> {
+    None
+}
+
 #[derive(Clone)]
 pub struct UnresolvedFrames {
     pub frames: SmallVec<[<TraceImpl as Trace>::Frame; MAX_DEPTH]>,
@@ -192,10 +210,14 @@ impl From<UnresolvedFrames> for Frames {
         while let Some(frame) = frame_iter.next() {
             let mut symbols: Vec<Symbol> = Vec::new();
 
-            frame.resolve_symbol(|symbol| {
-                let symbol = Symbol::from(symbol);
-                symbols.push(symbol);
-            });
+            if let Some(perfmap_symbol) = resolve_in_perfmap(frame.ip()) {
+                symbols.push(perfmap_symbol);
+            } else {
+                frame.resolve_symbol(|symbol| {
+                    let symbol = Symbol::from(symbol);
+                    symbols.push(symbol);
+                });
+            }
 
             if symbols.iter().any(|symbol| {
                 // macOS prepends an underscore even with `#[no_mangle]`

src/frames.rs

@@ -40,6 +40,13 @@
 //! [README.md](https://github.com/tikv/pprof-rs/blob/master/README.md)
 
 /// Define the MAX supported stack depth. TODO: make this variable mutable.
+#[cfg(feature = "large-depth")]
+pub const MAX_DEPTH: usize = 1024;
+
+#[cfg(all(feature = "huge-depth", not(feature = "large-depth")))]
+pub const MAX_DEPTH: usize = 512;
+
+#[cfg(not(any(feature = "large-depth", feature = "huge-depth")))]
 pub const MAX_DEPTH: usize = 128;
 
 /// Define the MAX supported thread name length. TODO: make this variable mutable.
@@ -51,6 +58,8 @@ mod backtrace;
 mod collector;
 mod error;
 mod frames;
+#[cfg(feature = "perfmaps")]
+mod perfmap;
 mod profiler;
 mod report;
 mod timer;
@@ -87,3 +96,6 @@ pub mod protos {
 
 #[cfg(feature = "criterion")]
 pub mod criterion;
+
+#[cfg(feature = "perfmaps")]
+pub use perfmap::init_perfmap_resolver;