rbpf 0.4.1

Virtual machine and JIT compiler for eBPF programs
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

// Copyright Microsoft Corporation
// SPDX-License-Identifier: (Apache-2.0 OR MIT)

// Path: examples/rbpf_plugin.rs
use std::io::Read;

// Helper function used by https://github.com/Alan-Jowett/bpf_conformance/blob/main/tests/call_unwind_fail.data
fn _unwind(a: u64, _b: u64, _c: u64, _d: u64, _e: u64) -> u64 {
    a
}

// This is a plugin for the bpf_conformance test suite (https://github.com/Alan-Jowett/bpf_conformance)
// It accepts a single argument, the memory contents to pass to the VM.
// It reads the program from stdin.
fn main() {
    let mut args: Vec<String> = std::env::args().collect();
    #[cfg_attr(not(feature = "std"), allow(unused_mut))] // in no_std, jit variable isn't mutated
    let mut jit: bool = false;
    let mut cranelift: bool = false;
    let mut program_text = String::new();
    let mut memory_text = String::new();

    args.remove(0);

    // Memory is always the first argument.
    if !args.is_empty() {
        memory_text = args[0].clone();
        // Strip whitespace
        memory_text.retain(|c| !c.is_whitespace());
        args.remove(0);
    }

    // Process the rest of the arguments.
    while !args.is_empty() {
        match args[0].as_str() {
            "--help" => {
                println!("Usage: rbpf_plugin [memory] < program");
                return;
            }
            "--jit" => {
                #[cfg(any(windows, not(feature = "std")))]
                {
                    println!("JIT not supported");
                    return;
                }
                #[cfg(all(not(windows), feature = "std"))]
                {
                    jit = true;
                }
            }
            "--cranelift" => {
                cranelift = true;

                #[cfg(not(feature = "cranelift"))]
                {
                    let _ = cranelift;
                    println!("Cranelift is not enabled");
                    return;
                }
            }
            "--program" => {
                if args.len() < 2 {
                    println!("Missing argument to --program");
                    return;
                }
                args.remove(0);
                if !args.is_empty() {
                    program_text = args[0].clone();
                    args.remove(0);
                }
            }
            _ => panic!("Unknown argument {}", args[0]),
        }
        args.remove(0);
    }

    if program_text.is_empty() {
        // Read program text from stdin
        std::io::stdin().read_to_string(&mut program_text).unwrap();
    }

    // Strip whitespace
    program_text.retain(|c| !c.is_whitespace());

    // Convert program from hex to bytecode
    let bytecode = hex::decode(program_text).unwrap();

    // Convert memory from hex to bytes
    let mut memory: Vec<u8> = hex::decode(memory_text).unwrap();

    // Create rbpf vm
    let mut vm = rbpf::EbpfVmRaw::new(Some(&bytecode)).unwrap();

    // Register the helper function used by call_unwind_fail.data test.
    vm.register_helper(5, _unwind).unwrap();

    let result: u64;
    if jit {
        #[cfg(any(windows, not(feature = "std")))]
        {
            println!("JIT not supported");
            return;
        }
        #[cfg(all(not(windows), feature = "std"))]
        {
            unsafe {
                vm.jit_compile().unwrap();
                result = vm.execute_program_jit(&mut memory).unwrap();
            }
        }
    } else if cranelift {
        #[cfg(not(feature = "cranelift"))]
        {
            println!("Cranelift is not enabled");
            return;
        }
        #[cfg(feature = "cranelift")]
        {
            vm.cranelift_compile().unwrap();
            result = vm.execute_program_cranelift(&mut memory).unwrap();
        }
    } else {
        result = vm.execute_program(&mut memory).unwrap();
    }
    println!("{result:x}");
}