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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use core::mem::{align_of, size_of};

use crate::{
    ByteRepr, IoError, MmapError, Result,
    elf::{ElfLayout, ElfShdr},
    memory::{ImageMemory, VmAddr},
};

#[inline]
pub(crate) fn section_bytes<L, Memory>(memory: &Memory, shdr: &ElfShdr<L>) -> Result<&'static [u8]>
where
    L: ElfLayout,
    Memory: ImageMemory + ?Sized,
{
    section_slice(memory, shdr, shdr.sh_size())
}

#[inline]
pub(crate) fn section_entries<L, T, Memory>(
    memory: &Memory,
    shdr: &ElfShdr<L>,
) -> Result<&'static [T]>
where
    L: ElfLayout,
    T: ByteRepr + 'static,
    Memory: ImageMemory + ?Sized,
{
    let byte_len = entry_bytes::<T>(shdr);
    section_slice(memory, shdr, byte_len)
}

#[inline]
pub(crate) fn section_entries_mut<L, T, Memory>(
    memory: &Memory,
    shdr: &ElfShdr<L>,
) -> Result<&'static mut [T]>
where
    L: ElfLayout,
    T: ByteRepr + 'static,
    Memory: ImageMemory + ?Sized,
{
    let byte_len = entry_bytes::<T>(shdr);
    let count = entry_count::<T>(byte_len);
    if count == 0 {
        return Ok(unsafe {
            core::slice::from_raw_parts_mut(core::ptr::NonNull::dangling().as_ptr(), 0)
        });
    }

    let ptr = section_ptr::<L, T, Memory>(memory, shdr, byte_len)?;
    Ok(unsafe { core::slice::from_raw_parts_mut(ptr, count) })
}

#[inline]
fn section_slice<L, T, Memory>(
    memory: &Memory,
    shdr: &ElfShdr<L>,
    byte_len: usize,
) -> Result<&'static [T]>
where
    L: ElfLayout,
    T: ByteRepr + 'static,
    Memory: ImageMemory + ?Sized,
{
    let count = entry_count::<T>(byte_len);
    if count == 0 {
        return Ok(&[]);
    }

    let ptr = section_ptr::<L, T, Memory>(memory, shdr, byte_len)?;
    Ok(unsafe { core::slice::from_raw_parts(ptr.cast_const(), count) })
}

#[inline]
fn section_ptr<L, T, Memory>(memory: &Memory, shdr: &ElfShdr<L>, byte_len: usize) -> Result<*mut T>
where
    L: ElfLayout,
    T: ByteRepr,
    Memory: ImageMemory + ?Sized,
{
    let ptr = memory
        .host_ptr_range(VmAddr::new(shdr.sh_addr()), byte_len)
        .ok_or(MmapError::HostPointerUnavailable)?;
    if !(ptr.as_ptr() as usize).is_multiple_of(align_of::<T>()) {
        return Err(IoError::ReadBufferNotAligned {
            align: align_of::<T>(),
        }
        .into());
    }
    Ok(ptr.as_ptr().cast())
}

#[inline]
fn entry_bytes<T>(shdr: &ElfShdr<impl ElfLayout>) -> usize {
    let entry_size = size_of::<T>();
    shdr.sh_size()
        .checked_div(entry_size)
        .unwrap_or(0)
        .saturating_mul(entry_size)
}

#[inline]
fn entry_count<T>(byte_len: usize) -> usize {
    let entry_size = size_of::<T>();
    byte_len.checked_div(entry_size).unwrap_or(0)
}