elfcore 2.0.2

elfcore is a crate to create ELF core dumps for processes on Linux.
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
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! A Rust helper library with machine-specific code for ELF core dump files.

#[cfg(target_os = "linux")]
use super::linux::ptrace;
#[cfg(target_os = "linux")]
use crate::{elf::NT_PRFPREG, CoreError};
#[cfg(target_os = "linux")]
use nix::unistd::Pid;

#[cfg(target_arch = "x86_64")]
mod x86_64;
#[cfg(target_arch = "x86_64")]
pub use x86_64::elf_gregset_t;

#[cfg(target_arch = "aarch64")]
mod aarch64;
#[cfg(target_arch = "aarch64")]
pub use aarch64::elf_gregset_t;

/// Contains SSE registers on amd64, NEON on arm64,
/// XSAVE state on amd64, etc
#[derive(Debug)]
pub struct ArchComponentState {
    /// Name
    pub name: &'static str,
    /// Note type
    pub note_type: u32,
    /// Note name
    pub note_name: &'static [u8],
    /// Data
    pub data: Vec<u8>,
}

pub(crate) trait Arch {
    const EM_ELF_MACHINE: u16;

    #[cfg(target_os = "linux")]
    fn new(pid: Pid) -> Result<Box<Self>, CoreError>;
    #[allow(dead_code)]
    fn name() -> &'static str;
    fn greg_set(&self) -> elf_gregset_t;
    fn components(&self) -> &Vec<ArchComponentState>;
}

/// Describes CPU state
#[derive(Debug)]
pub struct ArchState {
    /// GP registers.
    pub gpr_state: Vec<u64>,

    /// Contains SSE registers on amd64, NEON on arm64,
    /// XSAVE state on amd64, etc
    pub components: Vec<ArchComponentState>,
}

impl Arch for ArchState {
    #[cfg(target_arch = "x86_64")]
    const EM_ELF_MACHINE: u16 = x86_64::EM_X86_64;
    #[cfg(target_arch = "aarch64")]
    const EM_ELF_MACHINE: u16 = aarch64::EM_AARCH64;

    #[cfg(target_os = "linux")]
    fn new(pid: Pid) -> Result<Box<Self>, CoreError> {
        tracing::debug!("Getting GP registers for #{pid}");
        let gpr_state = ptrace::get_gp_reg_set(pid)?;

        let mut components = vec![ArchComponentState {
            name: "Floating point",
            note_type: NT_PRFPREG,
            note_name: b"CORE",
            data: ptrace::get_fp_reg_set(pid)?,
        }];

        tracing::debug!("Getting extended register state for #{pid}");

        let ext_state = {
            #[cfg(target_arch = "x86_64")]
            {
                x86_64::get_arch_components(pid)
            }
            #[cfg(target_arch = "aarch64")]
            {
                aarch64::get_arch_components(pid)
            }
        };
        if let Ok(state) = ext_state {
            components.extend(state);
        } else {
            // XSAVE might be disabled, etc
            tracing::debug!("No extended register state for #{pid} is present");
        }

        Ok(Box::new(ArchState {
            gpr_state,
            components,
        }))
    }

    fn name() -> &'static str {
        #[cfg(target_arch = "x86_64")]
        {
            "x86_64"
        }

        #[cfg(target_arch = "aarch64")]
        {
            "aarch64"
        }
    }

    fn greg_set(&self) -> elf_gregset_t {
        #[cfg(target_arch = "x86_64")]
        {
            x86_64::get_gpr_set(&self.gpr_state)
        }

        #[cfg(target_arch = "aarch64")]
        {
            aarch64::get_gpr_set(&self.gpr_state)
        }
    }

    fn components(&self) -> &Vec<ArchComponentState> {
        &self.components
    }
}