minidump-unwind

A library for unwinding and producing stack traces from minidump files. This crate provides APIs for producing symbolicated stack traces for the threads in a minidump. The primary entrypoint is the walk_stack function.

If you want lower-level access to the minidump's contents, use the minidump crate.

If you want higher-level functionality build on top of this crate, see minidump-processor.

Example Usage

```rust use minidump::{ Minidump, MinidumpException, MinidumpMiscInfo, MinidumpModuleList, MinidumpSystemInfo, UnifiedMemoryList }; use minidumpunwind::{CallStack, httpsymbolsupplier, Symbolizer, SystemInfo, walkstack};

[tokio::main]

async fn main() { // Read the minidump let dump = Minidump::read_path("../testdata/test.dmp").unwrap();

// Configure the symbolizer and processor
let symbols_urls = vec![String::from("https://symbols.totallyrealwebsite.org")];
let symbols_paths = vec![];
let mut symbols_cache = std::env::temp_dir();
symbols_cache.push("minidump-cache");
let symbols_tmp = std::env::temp_dir();
let timeout = std::time::Duration::from_secs(1000);

// Specify a symbol supplier (here we're using the most powerful one, the http supplier)
let provider = Symbolizer::new(http_symbol_supplier(
    symbols_paths,
    symbols_urls,
    symbols_cache,
    symbols_tmp,
    timeout,
));

let system_info: MinidumpSystemInfo = dump.get_stream().unwrap();
let misc_info: Option<MinidumpMiscInfo> = dump.get_stream().ok();
let modules: MinidumpModuleList = dump.get_stream().unwrap();
let exception: MinidumpException = dump.get_stream().unwrap();
let exception_context = exception.context(&system_info, misc_info.as_ref()).unwrap();
let memory_list = dump.get_stream().map(UnifiedMemoryList::Memory)
    .or_else(|_| dump.get_stream().map(UnifiedMemoryList::Memory64))
    .unwrap();

let stack_memory = memory_list.memory_at_address(exception_context.get_stack_pointer());

let mut stack = CallStack::with_context(exception_context.into_owned());

walk_stack(
    (),
    &mut stack,
    stack_memory,
    &modules,
    &SystemInfo {
        os: system_info.os,
        os_version: None,
        os_build: None,
        cpu: system_info.cpu,
        cpu_info: system_info.cpu_info().map(|info| info.into_owned()),
        cpu_microcode_version: None,
        cpu_count: 1,
    },
    &provider,
).await;

for frame in stack.frames {
    println!("{:?}", frame);
}

} ```