Bump all native programs up a level

Don't categorize programs by a single backend.

programs/bpf_loader/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "solana-bpfloader"
+version = "0.12.0"
+description = "Solana BPF Loader"
+authors = ["Solana Maintainers <maintainers@solana.com>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[features]
+bpf_c = []
+bpf_rust = []
+
+[dependencies]
+bincode = "1.1.2"
+byteorder = "1.3.1"
+elf = "0.0.10"
+libc = "0.2.49"
+log = "0.4.2"
+solana_rbpf = "=0.1.10"
+serde = "1.0.89"
+solana-logger = { path = "../../logger", version = "0.12.0" }
+solana-sdk = { path = "../../sdk", version = "0.12.0" }
+
+[build-dependencies]
+walkdir = "2"
+
+[lib]
+name = "solana_bpf_loader"
+crate-type = ["lib", "cdylib"]
+
+[[bench]]
+name = "bpf_loader"
+

programs/bpf_loader/benches/bpf_loader.rs

@@ -0,0 +1,131 @@
+#![feature(test)]
+#![cfg(feature = "bpf_c")]
+extern crate byteorder;
+extern crate solana_bpf_loader;
+extern crate solana_rbpf;
+extern crate test;
+
+use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
+use solana_rbpf::EbpfVmRaw;
+use std::env;
+use std::fs::File;
+use std::io::Error;
+use std::io::Read;
+use std::mem;
+use std::path::PathBuf;
+use test::Bencher;
+
+/// BPF program file extension
+const PLATFORM_FILE_EXTENSION_BPF: &str = "so";
+/// Create a BPF program file name
+fn create_bpf_path(name: &str) -> PathBuf {
+    let mut pathbuf = {
+        let current_exe = env::current_exe().unwrap();
+        PathBuf::from(current_exe.parent().unwrap().parent().unwrap())
+    };
+    pathbuf.push("bpf/");
+    pathbuf.push(name);
+    pathbuf.set_extension(PLATFORM_FILE_EXTENSION_BPF);
+    pathbuf
+}
+
+fn empty_check(_prog: &[u8]) -> Result<(), Error> {
+    Ok(())
+}
+
+const ARMSTRONG_LIMIT: u64 = 500;
+const ARMSTRONG_EXPECTED: u64 = 5;
+
+#[bench]
+fn bench_program_load_elf(bencher: &mut Bencher) {
+    let mut file = File::open(create_bpf_path("bench_alu")).expect("file open failed");
+    let mut elf = Vec::new();
+    file.read_to_end(&mut elf).unwrap();
+
+    let mut vm = EbpfVmRaw::new(None).unwrap();
+    vm.set_verifier(empty_check).unwrap();
+
+    bencher.iter(|| {
+        vm.set_elf(&elf).unwrap();
+    });
+}
+
+#[bench]
+fn bench_program_verify(bencher: &mut Bencher) {
+    let mut file = File::open(create_bpf_path("bench_alu")).expect("file open failed");
+    let mut elf = Vec::new();
+    file.read_to_end(&mut elf).unwrap();
+
+    let mut vm = EbpfVmRaw::new(None).unwrap();
+    vm.set_verifier(empty_check).unwrap();
+    vm.set_elf(&elf).unwrap();
+
+    bencher.iter(|| {
+        vm.set_verifier(solana_bpf_loader::bpf_verifier::check)
+            .unwrap();
+    });
+}
+
+#[bench]
+fn bench_program_alu(bencher: &mut Bencher) {
+    let ns_per_s = 1000000000;
+    let one_million = 1000000;
+    let mut inner_iter = vec![];
+    inner_iter
+        .write_u64::<LittleEndian>(ARMSTRONG_LIMIT)
+        .unwrap();
+    inner_iter.write_u64::<LittleEndian>(0).unwrap();
+
+    let mut file = File::open(create_bpf_path("bench_alu")).expect("file open failed");
+    let mut elf = Vec::new();
+    file.read_to_end(&mut elf).unwrap();
+    let mut vm = solana_bpf_loader::create_vm(&elf).unwrap();
+
+    println!("Interpreted:");
+    assert_eq!(
+        1, /*true*/
+        vm.execute_program(&mut inner_iter).unwrap()
+    );
+    assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
+    assert_eq!(
+        ARMSTRONG_EXPECTED,
+        LittleEndian::read_u64(&inner_iter[mem::size_of::<u64>()..])
+    );
+
+    bencher.iter(|| {
+        vm.execute_program(&mut inner_iter).unwrap();
+    });
+    let instructions = vm.get_last_instruction_count();
+    let summary = bencher.bench(|_bencher| {}).unwrap();
+    println!("  {:?} instructions", instructions);
+    println!("  {:?} ns/iter median", summary.median as u64);
+    assert!(0f64 != summary.median);
+    let mips = (instructions * (ns_per_s / summary.median as u64)) / one_million;
+    println!("  {:?} MIPS", mips);
+    println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_interpreted_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
+
+    println!("JIT to native:");
+    vm.jit_compile().unwrap();
+    unsafe {
+        assert_eq!(
+            1, /*true*/
+            vm.execute_program_jit(&mut inner_iter).unwrap()
+        );
+    }
+    assert_eq!(ARMSTRONG_LIMIT, LittleEndian::read_u64(&inner_iter));
+    assert_eq!(
+        ARMSTRONG_EXPECTED,
+        LittleEndian::read_u64(&inner_iter[mem::size_of::<u64>()..])
+    );
+
+    bencher.iter(|| unsafe {
+        vm.execute_program_jit(&mut inner_iter).unwrap();
+    });
+    let summary = bencher.bench(|_bencher| {}).unwrap();
+    println!("  {:?} instructions", instructions);
+    println!("  {:?} ns/iter median", summary.median as u64);
+    assert!(0f64 != summary.median);
+    let mips = (instructions * (ns_per_s / summary.median as u64)) / one_million;
+    println!("  {:?} MIPS", mips);
+    println!("{{ \"type\": \"bench\", \"name\": \"bench_program_alu_jit_to_native_mips\", \"median\": {:?}, \"deviation\": 0 }}", mips);
+}

programs/bpf_loader/build.rs

@@ -0,0 +1,109 @@
+extern crate walkdir;
+
+use std::env;
+use std::path::Path;
+use std::process::Command;
+use walkdir::WalkDir;
+
+fn rerun_if_changed(files: &[&str], directories: &[&str]) {
+    let mut all_files: Vec<_> = files.iter().map(|f| f.to_string()).collect();
+
+    for directory in directories {
+        let files_in_directory: Vec<_> = WalkDir::new(directory)
+            .into_iter()
+            .map(|entry| entry.unwrap())
+            .filter(|entry| entry.file_type().is_file())
+            .map(|f| f.path().to_str().unwrap().to_owned())
+            .collect();
+        all_files.extend_from_slice(&files_in_directory[..]);
+    }
+
+    for file in all_files {
+        if !Path::new(&file).is_file() {
+            panic!("{} is not a file", file);
+        }
+        println!("cargo:rerun-if-changed={}", file);
+    }
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let bpf_c = !env::var("CARGO_FEATURE_BPF_C").is_err();
+    if bpf_c {
+        let out_dir = "OUT_DIR=../../../target/".to_string()
+            + &env::var("PROFILE").unwrap()
+            + &"/bpf".to_string();
+
+        rerun_if_changed(
+            &[
+                "../../../sdk/bpf/bpf.ld",
+                "../../../sdk/bpf/bpf.mk",
+                "../../bpf/c/makefile",
+            ],
+            &[
+                "../../../sdk/bpf/inc",
+                "../../../sdk/bpf/scripts",
+                "../../bpf/c/src",
+            ],
+        );
+
+        println!("cargo:warning=(not a warning) Compiling C-based BPF programs");
+        let status = Command::new("make")
+            .current_dir("../../bpf/c")
+            .arg("programs")
+            .arg(&out_dir)
+            .status()
+            .expect("Failed to build C-based BPF programs");
+        assert!(status.success());
+    }
+
+    let bpf_rust = !env::var("CARGO_FEATURE_BPF_RUST").is_err();
+    if bpf_rust {
+        let install_dir =
+            "../../../../target/".to_string() + &env::var("PROFILE").unwrap() + &"/bpf".to_string();
+
+        if !Path::new(
+            "../../bpf/rust/noop/target/bpfel-unknown-unknown/release/solana_bpf_rust_noop.so",
+        )
+        .is_file()
+        {
+            // Cannot build Rust BPF programs as part of main build because
+            // to build it requires calling Cargo with different parameters which
+            // would deadlock due to recursive cargo calls
+            panic!(
+                "solana_bpf_rust_noop.so not found, you must manually run \
+                 `build.sh` in programs/bpf/rust/noop to build it"
+            );
+        }
+
+        rerun_if_changed(
+            &[
+                "../../bpf/rust/noop/bpf.ld",
+                "../../bpf/rust/noop/build.sh",
+                "../../bpf/rust/noop/Cargo.toml",
+                "../../bpf/rust/noop/target/bpfel-unknown-unknown/release/solana_bpf_rust_noop.so",
+            ],
+            &["../../bpf/rust/noop/src"],
+        );
+
+        println!(
+            "cargo:warning=(not a warning) Installing Rust-based BPF program: solana_bpf_rust_noop"
+        );
+        let status = Command::new("mkdir")
+            .current_dir("../../bpf/rust/noop")
+            .arg("-p")
+            .arg(&install_dir)
+            .status()
+            .expect("Unable to create BPF install directory");
+        assert!(status.success());
+
+        let status = Command::new("cp")
+            .current_dir("../../bpf/rust/noop")
+            .arg("target/bpfel-unknown-unknown/release/solana_bpf_rust_noop.so")
+            .arg(&install_dir)
+            .status()
+            .expect("Failed to copy solana_rust_bpf_noop.so to install directory");
+        assert!(status.success());
+    }
+}

programs/bpf_loader/src/bpf_verifier.rs

@@ -0,0 +1,324 @@
+use solana_rbpf::ebpf;
+use std::io::{Error, ErrorKind};
+
+fn reject<S: AsRef<str>>(msg: S) -> Result<(), Error> {
+    let full_msg = format!("[Verifier] Error: {}", msg.as_ref());
+    Err(Error::new(ErrorKind::Other, full_msg))
+}
+
+fn check_prog_len(prog: &[u8]) -> Result<(), Error> {
+    if prog.len() % ebpf::INSN_SIZE != 0 {
+        reject(format!(
+            "eBPF program length must be a multiple of {:?} octets",
+            ebpf::INSN_SIZE
+        ))?;
+    }
+    if prog.len() > ebpf::PROG_MAX_SIZE {
+        reject(format!(
+            "eBPF program length limited to {:?}, here {:?}",
+            ebpf::PROG_MAX_INSNS,
+            prog.len() / ebpf::INSN_SIZE
+        ))?;
+    }
+
+    if prog.is_empty() {
+        reject("No program set, call prog_set() to load one".to_string())?;
+    }
+
+    // TODO BPF program may deterministically exit even if the last
+    // instruction in the block is not an exit (might be earlier and jumped to)
+    // TODO need to validate more intelligently
+    // let last_insn = ebpf::get_insn(prog, (prog.len() / ebpf::INSN_SIZE) - 1);
+    // if last_insn.opc != ebpf::EXIT {
+    //     reject("program does not end with “EXIT” instruction".to_string())?;
+    // }
+
+    Ok(())
+}
+
+fn check_imm_nonzero(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), Error> {
+    if insn.imm == 0 {
+        reject(format!("division by 0 (insn #{:?})", insn_ptr))?;
+    }
+
+    Ok(())
+}
+
+fn check_imm_endian(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), Error> {
+    match insn.imm {
+        16 | 32 | 64 => Ok(()),
+        _ => reject(format!(
+            "unsupported argument for LE/BE (insn #{:?})",
+            insn_ptr
+        )),
+    }
+}
+
+fn check_load_dw(prog: &[u8], insn_ptr: usize) -> Result<(), Error> {
+    // We know we can reach next insn since we enforce an EXIT insn at the end of program, while
+    // this function should be called only for LD_DW insn, that cannot be last in program.
+    let next_insn = ebpf::get_insn(prog, insn_ptr + 1);
+    if next_insn.opc != 0 {
+        reject(format!(
+            "incomplete LD_DW instruction (insn #{:?})",
+            insn_ptr
+        ))?;
+    }
+
+    Ok(())
+}
+
+fn check_jmp_offset(prog: &[u8], insn_ptr: usize) -> Result<(), Error> {
+    let insn = ebpf::get_insn(prog, insn_ptr);
+    if insn.off == -1 {
+        reject(format!("infinite loop (insn #{:?})", insn_ptr))?;
+    }
+
+    let dst_insn_ptr = insn_ptr as isize + 1 + insn.off as isize;
+    if dst_insn_ptr < 0 || dst_insn_ptr as usize >= (prog.len() / ebpf::INSN_SIZE) {
+        reject(format!(
+            "jump out of code to #{:?} (insn #{:?})",
+            dst_insn_ptr, insn_ptr
+        ))?;
+    }
+
+    let dst_insn = ebpf::get_insn(prog, dst_insn_ptr as usize);
+    if dst_insn.opc == 0 {
+        reject(format!(
+            "jump to middle of LD_DW at #{:?} (insn #{:?})",
+            dst_insn_ptr, insn_ptr
+        ))?;
+    }
+
+    Ok(())
+}
+
+fn check_registers(insn: &ebpf::Insn, store: bool, insn_ptr: usize) -> Result<(), Error> {
+    if insn.src > 10 {
+        reject(format!("invalid source register (insn #{:?})", insn_ptr))?;
+    }
+
+    match (insn.dst, store) {
+        (0...9, _) | (10, true) => Ok(()),
+        (10, false) => reject(format!(
+            "cannot write into register r10 (insn #{:?})",
+            insn_ptr
+        )),
+        (_, _) => reject(format!(
+            "invalid destination register (insn #{:?})",
+            insn_ptr
+        )),
+    }
+}
+
+pub fn check(prog: &[u8]) -> Result<(), Error> {
+    check_prog_len(prog)?;
+
+    let mut insn_ptr: usize = 0;
+    while insn_ptr * ebpf::INSN_SIZE < prog.len() {
+        let insn = ebpf::get_insn(prog, insn_ptr);
+        let mut store = false;
+
+        match insn.opc {
+            // BPF_LD class
+            ebpf::LD_ABS_B => {}
+            ebpf::LD_ABS_H => {}
+            ebpf::LD_ABS_W => {}
+            ebpf::LD_ABS_DW => {}
+            ebpf::LD_IND_B => {}
+            ebpf::LD_IND_H => {}
+            ebpf::LD_IND_W => {}
+            ebpf::LD_IND_DW => {}
+
+            ebpf::LD_DW_IMM => {
+                store = true;
+                check_load_dw(prog, insn_ptr)?;
+                insn_ptr += 1;
+            }
+
+            // BPF_LDX class
+            ebpf::LD_B_REG => {}
+            ebpf::LD_H_REG => {}
+            ebpf::LD_W_REG => {}
+            ebpf::LD_DW_REG => {}
+
+            // BPF_ST class
+            ebpf::ST_B_IMM => store = true,
+            ebpf::ST_H_IMM => store = true,
+            ebpf::ST_W_IMM => store = true,
+            ebpf::ST_DW_IMM => store = true,
+
+            // BPF_STX class
+            ebpf::ST_B_REG => store = true,
+            ebpf::ST_H_REG => store = true,
+            ebpf::ST_W_REG => store = true,
+            ebpf::ST_DW_REG => store = true,
+            ebpf::ST_W_XADD => {
+                unimplemented!();
+            }
+            ebpf::ST_DW_XADD => {
+                unimplemented!();
+            }
+
+            // BPF_ALU class
+            ebpf::ADD32_IMM => {}
+            ebpf::ADD32_REG => {}
+            ebpf::SUB32_IMM => {}
+            ebpf::SUB32_REG => {}
+            ebpf::MUL32_IMM => {}
+            ebpf::MUL32_REG => {}
+            ebpf::DIV32_IMM => {
+                check_imm_nonzero(&insn, insn_ptr)?;
+            }
+            ebpf::DIV32_REG => {}
+            ebpf::OR32_IMM => {}
+            ebpf::OR32_REG => {}
+            ebpf::AND32_IMM => {}
+            ebpf::AND32_REG => {}
+            ebpf::LSH32_IMM => {}
+            ebpf::LSH32_REG => {}
+            ebpf::RSH32_IMM => {}
+            ebpf::RSH32_REG => {}
+            ebpf::NEG32 => {}
+            ebpf::MOD32_IMM => {
+                check_imm_nonzero(&insn, insn_ptr)?;
+            }
+            ebpf::MOD32_REG => {}
+            ebpf::XOR32_IMM => {}
+            ebpf::XOR32_REG => {}
+            ebpf::MOV32_IMM => {}
+            ebpf::MOV32_REG => {}
+            ebpf::ARSH32_IMM => {}
+            ebpf::ARSH32_REG => {}
+            ebpf::LE => {
+                check_imm_endian(&insn, insn_ptr)?;
+            }
+            ebpf::BE => {
+                check_imm_endian(&insn, insn_ptr)?;
+            }
+
+            // BPF_ALU64 class
+            ebpf::ADD64_IMM => {}
+            ebpf::ADD64_REG => {}
+            ebpf::SUB64_IMM => {}
+            ebpf::SUB64_REG => {}
+            ebpf::MUL64_IMM => {
+                check_imm_nonzero(&insn, insn_ptr)?;
+            }
+            ebpf::MUL64_REG => {}
+            ebpf::DIV64_IMM => {
+                check_imm_nonzero(&insn, insn_ptr)?;
+            }
+            ebpf::DIV64_REG => {}
+            ebpf::OR64_IMM => {}
+            ebpf::OR64_REG => {}
+            ebpf::AND64_IMM => {}
+            ebpf::AND64_REG => {}
+            ebpf::LSH64_IMM => {}
+            ebpf::LSH64_REG => {}
+            ebpf::RSH64_IMM => {}
+            ebpf::RSH64_REG => {}
+            ebpf::NEG64 => {}
+            ebpf::MOD64_IMM => {}
+            ebpf::MOD64_REG => {}
+            ebpf::XOR64_IMM => {}
+            ebpf::XOR64_REG => {}
+            ebpf::MOV64_IMM => {}
+            ebpf::MOV64_REG => {}
+            ebpf::ARSH64_IMM => {}
+            ebpf::ARSH64_REG => {}
+
+            // BPF_JMP class
+            ebpf::JA => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JEQ_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JEQ_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JGT_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JGT_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JGE_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JGE_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JLT_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JLT_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JLE_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JLE_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSET_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSET_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JNE_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JNE_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSGT_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSGT_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSGE_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSGE_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSLT_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSLT_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSLE_IMM => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::JSLE_REG => {
+                check_jmp_offset(prog, insn_ptr)?;
+            }
+            ebpf::CALL_IMM => {}
+            ebpf::CALL_REG => {}
+            ebpf::EXIT => {}
+
+            _ => {
+                reject(format!(
+                    "unknown eBPF opcode {:#2x} (insn #{:?})",
+                    insn.opc, insn_ptr
+                ))?;
+            }
+        }
+
+        check_registers(&insn, store, insn_ptr)?;
+
+        insn_ptr += 1;
+    }
+
+    // insn_ptr should now be equal to number of instructions.
+    if insn_ptr != prog.len() / ebpf::INSN_SIZE {
+        reject(format!("jumped out of code to #{:?}", insn_ptr))?;
+    }
+
+    Ok(())
+}

programs/bpf_loader/src/lib.rs

@@ -0,0 +1,277 @@
+pub mod bpf_verifier;
+
+use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
+use libc::c_char;
+use log::*;
+use solana_rbpf::{EbpfVmRaw, MemoryRegion};
+use solana_sdk::account::KeyedAccount;
+use solana_sdk::loader_instruction::LoaderInstruction;
+use solana_sdk::native_program::ProgramError;
+use solana_sdk::pubkey::Pubkey;
+use solana_sdk::solana_entrypoint;
+use std::ffi::CStr;
+use std::io::prelude::*;
+use std::io::{Error, ErrorKind};
+use std::mem;
+
+// TODO use rbpf's disassemble
+#[allow(dead_code)]
+fn dump_program(key: &Pubkey, prog: &[u8]) {
+    let mut eight_bytes: Vec<u8> = Vec::new();
+    info!("BPF Program: {:?}", key);
+    for i in prog.iter() {
+        if eight_bytes.len() >= 7 {
+            info!("{:02X?}", eight_bytes);
+            eight_bytes.clear();
+        } else {
+            eight_bytes.push(i.clone());
+        }
+    }
+}
+
+pub fn helper_abort_verify(
+    _arg1: u64,
+    _arg2: u64,
+    _arg3: u64,
+    _arg4: u64,
+    _arg5: u64,
+    _ro_regions: &[MemoryRegion],
+    _rw_regions: &[MemoryRegion],
+) -> Result<(()), Error> {
+    Err(Error::new(
+        ErrorKind::Other,
+        "Error: BPF program called abort()!",
+    ))
+}
+
+pub fn helper_abort(_arg1: u64, _arg2: u64, _arg3: u64, _arg4: u64, _arg5: u64) -> u64 {
+    // Never called because its verify function always returns an error
+    0
+}
+
+pub fn helper_sol_panic_verify(
+    _arg1: u64,
+    _arg2: u64,
+    _arg3: u64,
+    _arg4: u64,
+    _arg5: u64,
+    _ro_regions: &[MemoryRegion],
+    _rw_regions: &[MemoryRegion],
+) -> Result<(()), Error> {
+    Err(Error::new(ErrorKind::Other, "Error: BPF program Panic!"))
+}
+
+pub fn helper_sol_panic(_arg1: u64, _arg2: u64, _arg3: u64, _arg4: u64, _arg5: u64) -> u64 {
+    // Never called because its verify function always returns an error
+    0
+}
+
+pub fn helper_sol_log_verify(
+    addr: u64,
+    _arg2: u64,
+    _arg3: u64,
+    _arg4: u64,
+    _arg5: u64,
+    ro_regions: &[MemoryRegion],
+    _rw_regions: &[MemoryRegion],
+) -> Result<(()), Error> {
+    for region in ro_regions.iter() {
+        if region.addr <= addr && (addr as u64) < region.addr + region.len {
+            let c_buf: *const c_char = addr as *const c_char;
+            let max_size = region.addr + region.len - addr;
+            unsafe {
+                for i in 0..max_size {
+                    if std::ptr::read(c_buf.offset(i as isize)) == 0 {
+                        return Ok(());
+                    }
+                }
+            }
+            return Err(Error::new(ErrorKind::Other, "Error, Unterminated string"));
+        }
+    }
+    Err(Error::new(
+        ErrorKind::Other,
+        "Error: Load segfault, bad string pointer",
+    ))
+}
+
+pub fn helper_sol_log(addr: u64, _arg2: u64, _arg3: u64, _arg4: u64, _arg5: u64) -> u64 {
+    let c_buf: *const c_char = addr as *const c_char;
+    let c_str: &CStr = unsafe { CStr::from_ptr(c_buf) };
+    match c_str.to_str() {
+        Ok(slice) => info!("sol_log: {:?}", slice),
+        Err(e) => warn!("Error: Cannot print invalid string: {}", e),
+    };
+    0
+}
+
+pub fn helper_sol_log_u64(arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) -> u64 {
+    info!(
+        "sol_log_u64: {:#x}, {:#x}, {:#x}, {:#x}, {:#x}",
+        arg1, arg2, arg3, arg4, arg5
+    );
+    0
+}
+
+pub fn create_vm(prog: &[u8]) -> Result<EbpfVmRaw, Error> {
+    let mut vm = EbpfVmRaw::new(None)?;
+    vm.set_verifier(bpf_verifier::check)?;
+    vm.set_max_instruction_count(36000)?; // TODO 36000 is a wag, need to tune
+    vm.set_elf(&prog)?;
+    vm.register_helper_ex("abort", Some(helper_abort_verify), helper_abort)?;
+    vm.register_helper_ex("sol_panic", Some(helper_sol_panic_verify), helper_sol_panic)?;
+    vm.register_helper_ex(
+        "sol_panic_",
+        Some(helper_sol_panic_verify),
+        helper_sol_panic,
+    )?;
+    vm.register_helper_ex("sol_log", Some(helper_sol_log_verify), helper_sol_log)?;
+    vm.register_helper_ex("sol_log_", Some(helper_sol_log_verify), helper_sol_log)?;
+    vm.register_helper_ex("sol_log_64", None, helper_sol_log_u64)?;
+    vm.register_helper_ex("sol_log_64_", None, helper_sol_log_u64)?;
+    Ok(vm)
+}
+
+fn serialize_parameters(
+    program_id: &Pubkey,
+    keyed_accounts: &mut [KeyedAccount],
+    data: &[u8],
+    tick_height: u64,
+) -> Vec<u8> {
+    assert_eq!(32, mem::size_of::<Pubkey>());
+
+    let mut v: Vec<u8> = Vec::new();
+    v.write_u64::<LittleEndian>(keyed_accounts.len() as u64)
+        .unwrap();
+    for info in keyed_accounts.iter_mut() {
+        v.write_u64::<LittleEndian>(info.signer_key().is_some() as u64)
+            .unwrap();
+        v.write_all(info.unsigned_key().as_ref()).unwrap();
+        v.write_u64::<LittleEndian>(info.account.tokens).unwrap();
+        v.write_u64::<LittleEndian>(info.account.userdata.len() as u64)
+            .unwrap();
+        v.write_all(&info.account.userdata).unwrap();
+        v.write_all(info.account.owner.as_ref()).unwrap();
+    }
+    v.write_u64::<LittleEndian>(data.len() as u64).unwrap();
+    v.write_all(data).unwrap();
+    v.write_u64::<LittleEndian>(tick_height).unwrap();
+    v.write_all(program_id.as_ref()).unwrap();
+    v
+}
+
+fn deserialize_parameters(keyed_accounts: &mut [KeyedAccount], buffer: &[u8]) {
+    assert_eq!(32, mem::size_of::<Pubkey>());
+
+    let mut start = mem::size_of::<u64>();
+    for info in keyed_accounts.iter_mut() {
+        start += mem::size_of::<u64>(); // skip signer_key boolean
+        start += mem::size_of::<Pubkey>(); // skip pubkey
+        info.account.tokens = LittleEndian::read_u64(&buffer[start..]);
+
+        start += mem::size_of::<u64>() // skip tokens
+                  + mem::size_of::<u64>(); // skip length tag
+        let end = start + info.account.userdata.len();
+        info.account.userdata.clone_from_slice(&buffer[start..end]);
+
+        start += info.account.userdata.len() // skip userdata
+                  + mem::size_of::<Pubkey>(); // skip owner
+    }
+}
+
+solana_entrypoint!(entrypoint);
+fn entrypoint(
+    program_id: &Pubkey,
+    keyed_accounts: &mut [KeyedAccount],
+    tx_data: &[u8],
+    tick_height: u64,
+) -> Result<(), ProgramError> {
+    solana_logger::setup();
+
+    if keyed_accounts[0].account.executable {
+        let (progs, params) = keyed_accounts.split_at_mut(1);
+        let prog = &progs[0].account.userdata;
+        info!("Call BPF program");
+        //dump_program(keyed_accounts[0].key, prog);
+        let mut vm = match create_vm(prog) {
+            Ok(vm) => vm,
+            Err(e) => {
+                warn!("Failed to create BPF VM: {}", e);
+                return Err(ProgramError::GenericError);
+            }
+        };
+        let mut v = serialize_parameters(program_id, params, &tx_data, tick_height);
+        match vm.execute_program(v.as_mut_slice()) {
+            Ok(status) => {
+                if 0 == status {
+                    warn!("BPF program failed: {}", status);
+                    return Err(ProgramError::GenericError);
+                }
+            }
+            Err(e) => {
+                warn!("BPF VM failed to run program: {}", e);
+                return Err(ProgramError::GenericError);
+            }
+        }
+        deserialize_parameters(params, &v);
+        info!(
+            "BPF program executed {} instructions",
+            vm.get_last_instruction_count()
+        );
+    } else if let Ok(instruction) = bincode::deserialize(tx_data) {
+        if keyed_accounts[0].signer_key().is_none() {
+            warn!("key[0] did not sign the transaction");
+            return Err(ProgramError::GenericError);
+        }
+        match instruction {
+            LoaderInstruction::Write { offset, bytes } => {
+                let offset = offset as usize;
+                let len = bytes.len();
+                debug!("Write: offset={} length={}", offset, len);
+                if keyed_accounts[0].account.userdata.len() < offset + len {
+                    warn!(
+                        "Write overflow: {} < {}",
+                        keyed_accounts[0].account.userdata.len(),
+                        offset + len
+                    );
+                    return Err(ProgramError::GenericError);
+                }
+                keyed_accounts[0].account.userdata[offset..offset + len].copy_from_slice(&bytes);
+            }
+            LoaderInstruction::Finalize => {
+                keyed_accounts[0].account.executable = true;
+                info!(
+                    "Finalize: account {:?}",
+                    keyed_accounts[0].signer_key().unwrap()
+                );
+            }
+        }
+    } else {
+        warn!("Invalid program transaction: {:?}", tx_data);
+        return Err(ProgramError::GenericError);
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "Error: Execution exceeded maximum number of instructions")]
+    fn test_non_terminating_program() {
+        #[rustfmt::skip]
+        let prog = &[
+            0x07, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // r6 + 1
+            0x05, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, // goto -2
+            0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // exit
+        ];
+        let input = &mut [0x00];
+
+        let mut vm = EbpfVmRaw::new(None).unwrap();
+        vm.set_verifier(bpf_verifier::check).unwrap();
+        vm.set_max_instruction_count(10).unwrap();
+        vm.set_program(prog).unwrap();
+        vm.execute_program(input).unwrap();
+    }
+}