elf_loader 0.17.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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::{
    Error, LinkerError, Result, UnresolvedDependency,
    image::{Module, ModuleSearch, PathTokens, RawDynamic, ScannedDynamic},
    input::ModuleSourceId,
    memory::RegionAccess,
    relocation::RelocationArch,
    tls::TlsResolver,
};
use alloc::boxed::Box;

pub(crate) type LoaderVisitor<'visit> =
    dyn for<'search> FnMut(&'search ModuleSearch) -> Result<bool> + 'visit;
pub(super) type LoaderProvider<'a> =
    dyn for<'visit> Fn(&mut LoaderVisitor<'visit>) -> Result<()> + 'a;

pub(crate) trait DependencySource {
    fn search(&self) -> &ModuleSearch;
    fn source_id(&self) -> ModuleSourceId;
    fn needed_len(&self) -> usize;
    fn needed(&self, index: usize) -> Option<&str>;
}

impl<D: Send + Sync + 'static, Arch: RelocationArch, R: RegionAccess, Tls: TlsResolver<Arch>>
    DependencySource for RawDynamic<D, Arch, R, Tls>
{
    #[inline]
    fn search(&self) -> &ModuleSearch {
        Module::search(&***self).expect("ELF cores always retain filesystem search metadata")
    }

    #[inline]
    fn source_id(&self) -> ModuleSourceId {
        self.state().instance_id().source_id()
    }

    #[inline]
    fn needed_len(&self) -> usize {
        self.needed_libs().len()
    }

    #[inline]
    fn needed(&self, index: usize) -> Option<&str> {
        self.needed_libs().get(index).copied()
    }
}

impl<Arch: RelocationArch> DependencySource for ScannedDynamic<Arch> {
    #[inline]
    fn search(&self) -> &ModuleSearch {
        ScannedDynamic::search(self)
    }

    #[inline]
    fn source_id(&self) -> ModuleSourceId {
        ScannedDynamic::source_id(self)
    }

    #[inline]
    fn needed_len(&self) -> usize {
        self.needed_libs().len()
    }

    #[inline]
    fn needed(&self, index: usize) -> Option<&str> {
        self.needed_lib(index)
    }
}

/// The input being resolved by a [`ResolveRequest`].
pub enum ResolveInput<'a, Root> {
    /// A root supplied directly to a linker load operation.
    Root {
        /// Resolver-specific root input supplied by the caller.
        root: Root,
    },
    /// One `DT_NEEDED` edge of an already scanned module.
    Dependency {
        /// Library name stored in the owner's `DT_NEEDED` entry.
        needed: &'a str,
    },
}

/// A root or dependency resolution request.
pub struct ResolveRequest<'a, Root> {
    input: ResolveInput<'a, Root>,
    search: &'a ModuleSearch,
    tokens: &'a PathTokens,
    loaders: &'a LoaderProvider<'a>,
}

impl<'a, Root> ResolveRequest<'a, Root> {
    #[inline]
    pub(crate) const fn root(
        root: Root,
        search: &'a ModuleSearch,
        tokens: &'a PathTokens,
        loaders: &'a LoaderProvider<'a>,
    ) -> Self {
        Self {
            input: ResolveInput::Root { root },
            search,
            tokens,
            loaders,
        }
    }

    #[inline]
    pub(crate) const fn dependency(
        needed: &'a str,
        search: &'a ModuleSearch,
        tokens: &'a PathTokens,
        loaders: &'a LoaderProvider<'a>,
    ) -> Self {
        Self {
            input: ResolveInput::Dependency { needed },
            search,
            tokens,
            loaders,
        }
    }

    /// Returns the kind-specific input being resolved.
    #[inline]
    pub const fn input(&self) -> &ResolveInput<'a, Root> {
        &self.input
    }

    /// Returns search metadata for the request owner.
    #[inline]
    pub const fn search(&self) -> &'a ModuleSearch {
        self.search
    }

    #[inline]
    pub(crate) const fn tokens(&self) -> &'a PathTokens {
        self.tokens
    }

    /// Visits loaders in direct-to-root order until `visitor` returns `false`.
    #[inline]
    pub fn visit_loaders(
        &self,
        mut visitor: impl for<'search> FnMut(&'search ModuleSearch) -> Result<bool>,
    ) -> Result<()> {
        (self.loaders)(&mut visitor)
    }

    /// Creates the standard not-found error for this request.
    pub fn unresolved(&self) -> Error {
        match self.input() {
            ResolveInput::Root { .. } => LinkerError::RootNotFound.into(),
            ResolveInput::Dependency { needed } => LinkerError::UnresolvedDependency(Box::new(
                UnresolvedDependency::new(self.search.name(), needed),
            ))
            .into(),
        }
    }
}