jit: Enable JIT without "std" feature

Add a new "alloc" feature that indicates that the crate importing
rbpf has an implementation of the GlobalAlloc trait. Memory protection
is ignored in the "no_std" environment.

Signed-off-by: Nate Sweet <[email protected]>

Author: nathanjsweet

Cargo.toml

@@ -35,6 +35,10 @@ combine = { version = "4.6", default-features = false }
 libc = { version = "0.2", optional = true }
 time = { version = "0.2", optional = true }
 
+# Optional Dependencies for using alloc
+no-std-compat = {version = "0.4.1", optional = true }
+
+
 # Optional Dependencies for the CraneLift JIT
 cranelift-codegen = { version = "0.99", optional = true }
 cranelift-frontend = { version = "0.99", optional = true }
@@ -52,6 +56,7 @@ hex = "0.4.3"
 [features]
 default = ["std"]
 std = ["dep:time", "dep:libc", "combine/std"]
+alloc = ["dep:no-std-compat"]
 cranelift = [
     "dep:cranelift-codegen",
     "dep:cranelift-frontend",

README.md

@@ -568,7 +568,7 @@ get more information and examples on how to use it.
 
 ## Build features
 
-### `no_std`
+### `std`
 
 The `rbpf` crate has a Cargo feature named "std" that is enabled by default. To
 use `rbpf` in `no_std` environments this feature needs to be disabled. To do
@@ -581,15 +581,22 @@ rbpf = { version = "0.3.0", default-features = false }
 ```
 
 Note that when using this crate in `no_std` environments, the `jit` module
-isn't available. This is because it depends on functions provided by `libc`
-(`libc::posix_memalign()`, `libc::mprotect()`) which aren't available on
-`no_std`.
+isn't available, unless the `alloc` feature is turned on. This is because 
+it depends on allocation being memory aligned and a memory protection function 
+provided by `libc` (`libc::mprotect()`) which isn't available on `no_std`.
 
 The `assembler` module is available, albeit with reduced debugging features. It
 depends on the `combine` crate providing parser combinators. Under `no_std`
 this crate only provides simple parsers which generate less descriptive error
 messages.
 
+### `alloc`
+
+The `rbpf` crate has a Cargoe featured named "alloc" that is not enabled by
+default. `std` must be turned off and is mutually exclusive with alloc.
+When `alloc` is turned on the library importing rbpf must provide an 
+implementation of the [`GlobalAlloc` trait](https://doc.rust-lang.org/beta/std/alloc/trait.GlobalAlloc.html).
+
 ## Feedback welcome!
 
 This is the author's first try at writing Rust code. He learned a lot in the

src/jit.rs

@@ -1010,6 +1010,8 @@ pub struct JitMemory<'a> {
     contents: &'a mut [u8],
     #[cfg(feature = "std")]
     layout: std::alloc::Layout,
+    #[cfg(feature = "alloc")]
+    layout: core::alloc::Layout,
     offset: usize,
 }
 
@@ -1055,7 +1057,45 @@ impl<'a> JitMemory<'a> {
         Ok(mem)
     }
 
-    #[cfg(not(feature = "std"))]
+    #[cfg(feature = "alloc")]
+    pub fn new(
+        prog: &[u8],
+        helpers: &HashMap<u32, ebpf::Helper>,
+        use_mbuff: bool,
+        update_data_ptr: bool,
+    ) -> Result<JitMemory<'a>, Error> {
+        let layout;
+
+        // Allocate the appropriately sized memory.
+        let contents = unsafe {
+            // Create a layout with the proper size and alignment.
+            let size = NUM_PAGES * PAGE_SIZE;
+            layout = core::alloc::Layout::from_size_align_unchecked(size, PAGE_SIZE);
+
+            // Allocate the region of memory.
+            let ptr = alloc::alloc::alloc(layout);
+            if ptr.is_null() {
+                return Err(Error::new(ErrorKind::Other, "Out of memory"));
+            }
+
+            // Convert to a slice.
+            no_std_compat::slice::from_raw_parts_mut(ptr, size)
+        };
+
+        let mut mem = JitMemory {
+            contents,
+            layout,
+            offset: 0,
+        };
+
+        let mut jit = JitCompiler::new();
+        jit.jit_compile(&mut mem, prog, use_mbuff, update_data_ptr, helpers)?;
+        jit.resolve_jumps(&mut mem)?;
+
+        Ok(mem)
+    }
+
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     pub fn new(
         prog: &[u8],
         executable_memory: &'a mut [u8],
@@ -1108,11 +1148,14 @@ impl IndexMut<usize> for JitMemory<'_> {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl Drop for JitMemory<'_> {
     fn drop(&mut self) {
         unsafe {
+            #[cfg(feature = "std")]
             std::alloc::dealloc(self.contents.as_mut_ptr(), self.layout);
+            #[cfg(feature = "alloc")]
+            alloc::alloc::dealloc(self.contents.as_mut_ptr(), self.layout);
         }
     }
 }

src/lib.rs

@@ -13,6 +13,9 @@
 // Configures the crate to be `no_std` when `std` feature is disabled.
 #![cfg_attr(not(feature = "std"), no_std)]
 
+#[cfg(all(feature = "std", feature = "alloc"))]
+compile_error!("feature \"std\" and feature \"alloc\" cannot be enabled at the same time");
+
 extern crate byteorder;
 extern crate combine;
 extern crate log;
@@ -510,11 +513,11 @@ impl<'a> EbpfVmMbuff<'a> {
                 "Error: No program set, call prog_set() to load one",
             ))?,
         };
-        #[cfg(feature = "std")]
+        #[cfg(any(feature = "std", feature = "alloc"))]
         {
             self.jit = Some(jit::JitMemory::new(prog, &self.helpers, true, false)?);
         }
-        #[cfg(not(feature = "std"))]
+        #[cfg(not(any(feature = "std", feature = "alloc")))]
         {
             let exec_memory = match self.custom_exec_memory.take() {
                 Some(memory) => memory,
@@ -1141,11 +1144,11 @@ impl<'a> EbpfVmFixedMbuff<'a> {
                 "Error: No program set, call prog_set() to load one",
             ))?,
         };
-        #[cfg(feature = "std")]
+        #[cfg(any(feature = "std", feature = "alloc"))]
         {
             self.parent.jit = Some(jit::JitMemory::new(prog, &self.parent.helpers, true, true)?);
         }
-        #[cfg(not(feature = "std"))]
+        #[cfg(not(any(feature = "std", feature = "alloc")))]
         {
             let exec_memory = match self.parent.custom_exec_memory.take() {
                 Some(memory) => memory,
@@ -1661,7 +1664,7 @@ impl<'a> EbpfVmRaw<'a> {
                 "Error: No program set, call prog_set() to load one",
             ))?,
         };
-        #[cfg(feature = "std")]
+        #[cfg(any(feature = "std", feature = "alloc"))]
         {
             self.parent.jit = Some(jit::JitMemory::new(
                 prog,
@@ -1670,7 +1673,7 @@ impl<'a> EbpfVmRaw<'a> {
                 false,
             )?);
         }
-        #[cfg(not(feature = "std"))]
+        #[cfg(not(any(feature = "std", feature = "alloc")))]
         {
             let exec_memory = match self.parent.custom_exec_memory.take() {
                 Some(memory) => memory,