elf_loader 0.16.0

A no_std-friendly ELF loader and runtime linker for Rust.
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

use crate::{
    Result,
    memory::{RegionAccess, VmAddr, VmOffset},
    os::{MapFlags, ProtFlags},
    segment::ElfSegments,
};
use alloc::vec::Vec;

/// Information about a file mapping within a segment
///
/// This structure describes how a portion of a file is mapped
/// into a memory segment.
#[derive(Debug)]
pub(crate) struct FileMapInfo {
    /// Start offset within the segment
    pub(crate) start: usize,
    /// Size of the file data in bytes
    pub(crate) filesz: usize,
    /// Offset within the file
    pub(crate) offset: usize,
}

/// A page-aligned memory protection change applied after mapping.
#[derive(Clone, Copy, Debug)]
pub(crate) struct MemoryProtection {
    /// Runtime address of the protected range.
    addr: VmAddr,
    /// Unrounded protected range length.
    len: usize,
    /// Page size used to round the protected range.
    page_size: usize,
    /// Protection flags to apply.
    prot: ProtFlags,
}

impl MemoryProtection {
    #[inline]
    pub(crate) const fn new(addr: VmAddr, len: usize, page_size: usize, prot: ProtFlags) -> Self {
        Self {
            addr,
            len,
            page_size,
            prot,
        }
    }

    #[inline]
    pub(crate) fn apply<R: RegionAccess>(&self, segments: &ElfSegments<R>) -> Result<()> {
        let start = self.addr.rounddown(self.page_size);
        let end = (self.addr + VmOffset::new(self.len)).roundup(self.page_size);
        let len = end
            .checked_offset_from(start)
            .expect("protection range end precedes its start")
            .get();
        segments.mprotect(start, len, self.prot)
    }
}

/// An ELF segment in memory
///
/// This structure represents a loaded ELF segment with all the
/// information needed to manage its memory mapping, protection,
/// and data content.
pub(crate) struct ElfSegment {
    /// Module-relative offset of the segment.
    pub(crate) offset: VmOffset,
    /// Memory protection flags for the segment
    pub(crate) prot: ProtFlags,
    /// Memory mapping flags for the segment
    pub(crate) flags: MapFlags,
    /// Total length of the segment in bytes
    pub(crate) len: usize,
    /// Page size used to align this segment.
    pub(crate) page_size: usize,
    /// Size of zero-filled area at the end of the segment
    pub(crate) zero_size: usize,
    /// Size of content (non-zero) area in the segment
    pub(crate) content_size: usize,
    /// Information about file mappings within this segment
    pub(crate) map_info: Vec<FileMapInfo>,
    /// Indicates if data needs to be copied manually
    pub(crate) need_copy: bool,
    /// Indicates if this segment comes from a relocatable object
    pub(crate) from_relocatable: bool,
}