Struct solana_rbpf::EbpfVmFixedMbuff

source ·

pub struct EbpfVmFixedMbuff<'a> { /* private fields */ }

Expand description

A virtual machine to run eBPF program. This kind of VM is used for programs expecting to work on a metadata buffer containing pointers to packet data, but it internally handles the buffer so as to save the effort to manually handle the metadata buffer for the user.

This struct implements a static internal buffer that is passed to the program. The user has to indicate the offset values at which the eBPF program expects to find the start and the end of packet data in the buffer. On calling the execute_program() or execute_program_jit() functions, the struct automatically updates the addresses in this static buffer, at the appointed offsets, for the start and the end of the packet data the program is called upon.

Examples

This was compiled with clang from the following program, in C:

#include <linux/bpf.h>
#include "path/to/linux/samples/bpf/bpf_helpers.h"

SEC(".classifier")
int classifier(struct __sk_buff *skb)
{
  void *data = (void *)(long)skb->data;
  void *data_end = (void *)(long)skb->data_end;

  // Check program is long enough.
  if (data + 5 > data_end)
    return 0;

  return *((char *)data + 5);
}

Some small modifications have been brought to have it work, see comments.

let prog = &[
    0xb7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r0, 0
    // Here opcode 0x61 had to be replace by 0x79 so as to load a 8-bytes long address.
    // Also, offset 0x4c had to be replace with e.g. 0x40 so as to prevent the two pointers
    // from overlapping in the buffer.
    0x79, 0x12, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // load pointer to mem from r1[0x40] to r2
    0x07, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, // add r2, 5
    // Here opcode 0x61 had to be replace by 0x79 so as to load a 8-bytes long address.
    0x79, 0x11, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, // load ptr to mem_end from r1[0x50] to r1
    0x2d, 0x12, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, // if r2 > r1 skip 3 instructions
    0x71, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // load r2 (= *(mem + 5)) into r0
    0x67, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, // r0 >>= 56
    0xc7, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, // r0 <<= 56 (arsh) extend byte sign to u64
    0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // exit
];
let mem1 = &mut [
    0xaa, 0xbb, 0x11, 0x22, 0xcc, 0xdd
];
let mem2 = &mut [
    0xaa, 0xbb, 0x11, 0x22, 0xcc, 0x27
];

// Instantiate a VM. Note that we provide the start and end offsets for mem pointers.
let mut vm = solana_rbpf::EbpfVmFixedMbuff::new(Some(prog), 0x40, 0x50).unwrap();

// Provide only a reference to the packet data. We do not manage the metadata buffer.
let res = vm.execute_program(mem1).unwrap();
assert_eq!(res, 0xffffffffffffffdd);

let res = vm.execute_program(mem2).unwrap();
assert_eq!(res, 0x27);

Struct solana_rbpf::EbpfVmFixedMbuff

Implementations

impl<'a> EbpfVmFixedMbuff<'a>

pub fn new( prog: Option<&'a [u8]>, data_offset: usize, data_end_offset: usize) -> Result<EbpfVmFixedMbuff<'a>, Error>

pub fn set_program( &mut self, prog: &'a [u8], data_offset: usize, data_end_offset: usize) -> Result<(), Error>

pub fn set_verifier(&mut self, verifier: Verifier) -> Result<(), Error>

pub fn set_max_instruction_count(&mut self, count: u64) -> Result<(), Error>

pub fn get_last_instruction_count(&self) -> u64

pub fn register_helper( &mut self, key: u32, function: HelperFunction) -> Result<(), Error>

pub fn register_helper_ex( &mut self, name: &str, verifier: Option<HelperVerifier>, function: HelperFunction) -> Result<(), Error>

pub fn execute_program(&mut self, mem: &mut [u8]) -> Result<u64, Error>

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

pub unsafe fn execute_program_jit( &mut self, mem: &'a mut [u8]) -> Result<u64, Error>

Auto Trait Implementations

impl<'a> RefUnwindSafe for EbpfVmFixedMbuff<'a>

impl<'a> Send for EbpfVmFixedMbuff<'a>

impl<'a> Sync for EbpfVmFixedMbuff<'a>

impl<'a> Unpin for EbpfVmFixedMbuff<'a>

impl<'a> UnwindSafe for EbpfVmFixedMbuff<'a>

Blanket Implementations

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

pub fn new(
prog: Option<&'a [u8]>,
data_offset: usize,
data_end_offset: usize
) -> Result<EbpfVmFixedMbuff<'a>, Error>

pub fn set_program(
&mut self,
prog: &'a [u8],
data_offset: usize,
data_end_offset: usize
) -> Result<(), Error>

pub fn register_helper(
&mut self,
key: u32,
function: HelperFunction
) -> Result<(), Error>

pub fn register_helper_ex(
&mut self,
name: &str,
verifier: Option<HelperVerifier>,
function: HelperFunction
) -> Result<(), Error>

pub unsafe fn execute_program_jit(
&mut self,
mem: &'a mut [u8]
) -> Result<u64, Error>

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,