stackpulse 0.2.0

Linux perf_event stack sampling with native unwinding, symbolization, and compact spooling
Documentation 
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

use framehop::Unwinder;
use rustc_hash::FxHashSet;

use super::{elf_loader, elf_types};
use crate::native_module::ElfSectionCache;
use crate::spool::ModuleUpdate;

type UnwindPolicy = framehop::MayAllocateDuringUnwind;
pub(super) type NativeUnwinder = framehop::UnwinderNative<elf_types::ElfSectionData, UnwindPolicy>;
pub(super) type NativeCache = framehop::CacheNative<UnwindPolicy>;

#[derive(Default)]
pub(super) struct ProcessUnwinder {
    pub(super) unwinder: NativeUnwinder,
    pub(super) cache: NativeCache,
    refreshed_uncovered_pages: FxHashSet<u64>,
    elf_sections: ElfSectionCache,
}

impl Clone for ProcessUnwinder {
    fn clone(&self) -> Self {
        Self {
            unwinder: self.unwinder.clone(),
            cache: NativeCache::default(),
            refreshed_uncovered_pages: FxHashSet::default(),
            elf_sections: self.elf_sections.clone(),
        }
    }
}

impl ProcessUnwinder {
    pub(super) fn apply_module_update(&mut self, update: &ModuleUpdate) {
        for module in &update.retired {
            self.unwinder.remove_module(module.start);
        }
        for activation in &update.active {
            if let Some(source_id) = activation.source_module_id {
                self.elf_sections.reuse(source_id, activation.module.id);
            }
        }
        for activation in &update.active {
            let module = &activation.module;
            if module.is_kernel {
                continue;
            }
            if !update.mapping_changed
                && activation.source_module_id.is_none()
                && self.elf_sections.contains(module.id)
            {
                continue;
            }
            let start = module.start;
            let Some((module_info, section_info)) = self.elf_sections.module_info(module) else {
                continue;
            };
            if let Some(module) =
                elf_loader::module_to_framehop_with_section_info(&module_info, &section_info)
            {
                self.unwinder.remove_module(start);
                self.unwinder.add_module(module);
            }
        }
        for module in &update.retired {
            self.elf_sections.remove(module.id);
        }
        for source_id in update
            .active
            .iter()
            .filter_map(|activation| activation.source_module_id)
        {
            self.elf_sections.remove(source_id);
        }
        if update.mapping_changed {
            self.refreshed_uncovered_pages.clear();
        }
    }

    pub(super) fn should_refresh_for_uncovered_pc(&mut self, pc: u64) -> bool {
        self.refreshed_uncovered_pages.insert(refresh_page(pc))
    }
}

fn refresh_page(pc: u64) -> u64 {
    let page_size = crate::elf::system_page_size();
    pc - pc % page_size
}