Struct EbpfVm 

pub struct EbpfVm<'a, C>
where
    C: ContextObject,
{
    pub host_stack_pointer: *mut u64,
    pub call_depth: u64,
    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 loader: Arc<BuiltinProgram<C>>,
    pub register_trace: Vec<[u64; 12]>,
    /* private fields */
}

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::{CallFrame, Config, EbpfVm, ExecutionMode},
};
use test_utils::TestContextObject;

let prog = &[
    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // add64 r0, 0
    0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
];
let mut mem: [u8; _] = [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(&mut stack, ebpf::MM_STACK_START),
    MemoryRegion::new(&mut heap, ebpf::MM_HEAP_START),
    MemoryRegion::new(&raw mut mem, ebpf::MM_INPUT_START),
];
;
context_object.memory_mapping = unsafe {
    MemoryMapping::new(regions, executable.get_config(), sbpf_version).unwrap()
};

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

let mut call_frames = vec![CallFrame::default(); executable.get_config().max_call_depth];
let (instruction_count, result) = vm.execute_program(
    &executable,
    &mut ExecutionMode::Interpreted,
    &mut call_frames,
);
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.

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

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, stack_len: usize, ) -> EbpfVm<'a, C>

Creates a new virtual machine instance.

pub fn execute_program( &mut self, executable: &Executable<C>, mode: &mut ExecutionMode, call_frames: &mut [CallFrame], ) -> (u64, StableResult<u64, EbpfError>)

Execute the program

Use mode parameter to request a specific execution type. This function will write back the execution mode used back to the reference passed in.

It is required to provide call_frames when executing in interpreted mode. call_frames must be large enough to hold the executable config’s max_call_depth frames.

Returns the instruction meter count (CUs) and the execution result of the program.

pub fn invoke_function( &mut self, function: fn(EncryptedHostAddressToEbpfVm<C>, u64, u64, u64, u64, u64), )

Invokes a built-in function

pub fn context(&mut self) -> &mut C

Get a reference to the context object referenced by this EbpfVm.