Struct Executable 

pub struct Executable<C: ContextObject> { /* private fields */ }

Elf loader/relocator

Implementations

impl<C: ContextObject> Executable<C>

pub fn get_config(&self) -> &Config

Get the configuration settings

pub fn get_sbpf_version(&self) -> SBPFVersion

Get the executable sbpf_version

pub fn get_text_bytes(&self) -> (u64, &[u8])

Get the .text section virtual address and bytes

pub fn get_ro_section(&self) -> &[u8]

Get the concatenated read-only sections (including the text section)

pub fn get_ro_region(&self) -> MemoryRegion

Get a memory region that can be used to access the merged readonly section

pub fn get_entrypoint_instruction_offset(&self) -> usize

Get the entry point offset into the text section

pub fn get_loader(&self) -> &Arc<BuiltinProgram<C>>

Get the loader built-in program

pub fn get_compiled_program(&self) -> Option<Arc<JitProgram>>

Get the JIT compiled program

This function will not block the calling thread even if there is a concurrent ongoing call to Self::jit_compile.

pub fn verify<V: Verifier>(&self) -> Result<(), EbpfError>

Verify the executable

pub fn jit_compile(&self) -> Result<(), EbpfError>

JIT compile the executable

This function does not ensure fully sequentially consistent execution ordering between calls to it and related calls such as Self::get_compiled_program or Self::take_compiled_program.

This means that there can be some non-trivial interactions in ordering between calls to this function and a get_compiled_program: concurrent calls to get_compiled_program will return the previous compiled program or None for the duration of the compilation process and is only guaranteed to start returning the newly compiled JitProgram after this function returns.

pub fn take_compiled_program(&self) -> Option<Arc<JitProgram>>

Remove the compiled program.

Note that the results can be unpredictable in presence of concurrent ongoing calls to Self::jit_compile: based on exact execution ordering this function may take out the previous program (or None) that shorly afterwards gets replaced by a compiled program.

pub fn get_function_registry(&self) -> &FunctionRegistry<usize>

Get the function registry

pub fn new_from_text_bytes( text_bytes: &[u8], loader: Arc<BuiltinProgram<C>>, sbpf_version: SBPFVersion, function_registry: FunctionRegistry<usize>, ) -> Result<Self, ElfError>

Create from raw text section bytes (list of instructions)

pub fn load( bytes: &[u8], loader: Arc<BuiltinProgram<C>>, ) -> Result<Self, ElfError>

Fully loads an ELF

pub fn load_with_strict_parser( bytes: &[u8], loader: Arc<BuiltinProgram<C>>, ) -> Result<Self, ElfParserError>

Loads an ELF without relocation

pub fn mem_size(&self) -> usize

Calculate the total memory size of the executable

pub fn validate(elf: &Elf64<'_>, elf_bytes: &[u8]) -> Result<(), ElfError>

Validates the ELF

pub fn parse_ro_sections<'a, S: IntoIterator<Item = (Option<&'a [u8]>, &'a Elf64Shdr)>>( config: &Config, sections: S, elf_bytes: &[u8], ) -> Result<Section, ElfError>

Parses and concatenates the readonly data sections

impl<C: ContextObject> Executable<C>

Static constructors for Executable

pub fn from_elf( elf_bytes: &[u8], loader: Arc<BuiltinProgram<C>>, ) -> Result<Self, EbpfError>

Creates an executable from an ELF file

pub fn from_text_bytes( text_bytes: &[u8], loader: Arc<BuiltinProgram<C>>, sbpf_version: SBPFVersion, function_registry: FunctionRegistry<usize>, ) -> Result<Self, EbpfError>

Creates an executable from machine code

Trait Implementations

impl<C: Debug + ContextObject> Debug for Executable<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: PartialEq + ContextObject> PartialEq for Executable<C>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.