Struct EbpfVm 

#[repr(C)]
pub struct EbpfVm<'a, C>
where
    C: ContextObject,
{

    pub host_stack_pointer: *mut u64,
    pub call_depth: u64,
    pub context_object_pointer: &'a mut C,
    pub previous_instruction_meter: u64,
    pub due_insn_count: u64,
    pub stopwatch_numerator: u64,
    pub stopwatch_denominator: u64,
    pub registers: [u64; 12],
    pub program_result: StableResult<u64, EbpfError>,
    pub memory_mapping: MemoryMapping<'a>,
    pub call_frames: Vec<CallFrame>,
    pub loader: Arc<BuiltinProgram<C>>,
    pub register_trace: Vec<[u64; 12]>,
}

A virtual machine to run eBPF programs.

Examples

use solana_sbpf::{
    aligned_memory::AlignedMemory,
    ebpf,
    elf::Executable,
    memory_region::{MemoryMapping, MemoryRegion},
    program::{BuiltinProgram, FunctionRegistry, SBPFVersion},
    verifier::RequisiteVerifier,
    vm::{Config, EbpfVm},
};
use test_utils::TestContextObject;

let prog = &[
    0x07, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // add64 r10, 0
    0x9d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
];
let mem = &mut [
    0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
];

let loader = std::sync::Arc::new(BuiltinProgram::new_mock());
let function_registry = FunctionRegistry::default();
let mut executable = Executable::<TestContextObject>::from_text_bytes(prog, loader.clone(), SBPFVersion::V4, function_registry).unwrap();
executable.verify::<RequisiteVerifier>().unwrap();
let mut context_object = TestContextObject::new(2);
let sbpf_version = executable.get_sbpf_version();

let mut stack = AlignedMemory::<{ebpf::HOST_ALIGN}>::zero_filled(executable.get_config().stack_size());
let stack_len = stack.len();
let mut heap = AlignedMemory::<{ebpf::HOST_ALIGN}>::with_capacity(0);

let regions: Vec<MemoryRegion> = vec![
    executable.get_ro_region(),
    MemoryRegion::new_writable(
        stack.as_slice_mut(),
        ebpf::MM_STACK_START,
    ),
    MemoryRegion::new_writable(heap.as_slice_mut(), ebpf::MM_HEAP_START),
    MemoryRegion::new_writable(mem, ebpf::MM_INPUT_START),
];

let memory_mapping = MemoryMapping::new(regions, executable.get_config(), sbpf_version).unwrap();

let mut vm = EbpfVm::new(loader, sbpf_version, &mut context_object, memory_mapping, stack_len);

let (instruction_count, result) = vm.execute_program(&executable, true);
assert_eq!(instruction_count, 2);
assert_eq!(result.unwrap(), 0);

Fields

host_stack_pointer: *mut u64

Needed to exit from the guest back into the host

call_depth: u64

The current call depth.

Incremented on calls and decremented on exits. It’s used to enforce config.max_call_depth and to know when to terminate execution.

context_object_pointer: &'a mut C

Pointer to ContextObject

previous_instruction_meter: u64

Last return value of instruction_meter.get_remaining()

due_insn_count: u64

Outstanding value to instruction_meter.consume()

stopwatch_numerator: u64

CPU cycles accumulated by the stop watch

stopwatch_denominator: u64

Number of times the stop watch was used

registers: [u64; 12]

Registers inlined

program_result: StableResult<u64, EbpfError>

ProgramResult inlined

memory_mapping: MemoryMapping<'a>

MemoryMapping inlined

call_frames: Vec<CallFrame>

Stack of CallFrames used by the Interpreter

loader: Arc<BuiltinProgram<C>>

Loader built-in program

register_trace: Vec<[u64; 12]>

Collector for the instruction trace

Implementations

impl<'a, C> EbpfVm<'a, C>

where C: ContextObject,

pub fn new( loader: Arc<BuiltinProgram<C>>, sbpf_version: SBPFVersion, context_object: &'a mut C, memory_mapping: MemoryMapping<'a>, stack_len: usize, ) -> EbpfVm<'a, C>

Creates a new virtual machine instance.

pub fn execute_program( &mut self, executable: &Executable<C>, interpreted: bool, ) -> (u64, StableResult<u64, EbpfError>)

Execute the program

If interpreted = false then the JIT compiled executable is used.

pub fn invoke_function( &mut self, function: fn(*mut EbpfVm<'_, C>, u64, u64, u64, u64, u64), )

Invokes a built-in function