pprof 0.15.0

An internal perf tools for rust programs.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

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 };
    let sp = unsafe { (*ucontext).uc_mcontext.sp };
    Some((UnwindRegsNative::new(regs[30], sp, 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) };
    }
}