src: Fix Clippy reports

Some of these reports were fixed automatically with:

    cargo +nightly clippy --fix --lib -p rbpf

Signed-off-by: Quentin Monnet <qmo@qmon.net>

src/cranelift.rs

@@ -80,10 +80,10 @@ impl CraneliftCompiler {
             jit_builder.symbol(name, (*v) as usize as *const u8);
         }
 
-        let mut module = JITModule::new(jit_builder);
+        let module = JITModule::new(jit_builder);
 
         let registers = (0..11)
-            .map(|i| Variable::new(i))
+            .map(Variable::new)
             .collect::<Vec<_>>()
             .try_into()
             .unwrap();

src/helpers.rs

@@ -16,6 +16,7 @@
 //! value. Hence some helpers have unused arguments, or return a 0 value in all cases, in order to
 //! respect this convention.
 
+#[cfg(feature = "std")]
 use crate::lib::*;
 
 // Helpers associated to kernel helpers
@@ -150,7 +151,7 @@ pub fn gather_bytes (arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) -> u
 pub fn memfrob (ptr: u64, len: u64, unused3: u64, unused4: u64, unused5: u64) -> u64 {
     for i in 0..len {
         unsafe {
-            let mut p = (ptr + i) as *mut u8;
+            let p = (ptr + i) as *mut u8;
             *p ^= 0b101010;
         }
     }

src/insn_builder.rs

@@ -73,7 +73,7 @@ pub trait IntoBytes {
 }
 
 /// General implementation of `IntoBytes` for `Instruction`
-impl<'i, I: Instruction> IntoBytes for &'i I {
+impl<I: Instruction> IntoBytes for &I {
     type Bytes = Vec<u8>;
 
     /// transform immutable reference of `Instruction` into `Vec<u8>` with size of 8
@@ -344,7 +344,7 @@ impl<'i> Move<'i> {
     }
 }
 
-impl<'i> Instruction for Move<'i> {
+impl Instruction for Move<'_> {
     fn opt_code_byte(&self) -> u8 {
         let op_bits = self.op_bits as u8;
         let src_bit = self.src_bit as u8;
@@ -412,7 +412,7 @@ impl<'i> SwapBytes<'i> {
     }
 }
 
-impl<'i> Instruction for SwapBytes<'i> {
+impl Instruction for SwapBytes<'_> {
     fn opt_code_byte(&self) -> u8 {
         self.endian as u8
     }
@@ -453,7 +453,7 @@ impl<'i> Load<'i> {
     }
 }
 
-impl<'i> Instruction for Load<'i> {
+impl Instruction for Load<'_> {
     fn opt_code_byte(&self) -> u8 {
         let size = self.mem_size as u8;
         let addressing = self.addressing as u8;
@@ -486,7 +486,7 @@ impl<'i> Store<'i> {
     }
 }
 
-impl<'i> Instruction for Store<'i> {
+impl Instruction for Store<'_> {
     fn opt_code_byte(&self) -> u8 {
         let size = self.mem_size as u8;
         BPF_MEM | BPF_ST | size | self.source
@@ -539,7 +539,7 @@ impl<'i> Jump<'i> {
     }
 }
 
-impl<'i> Instruction for Jump<'i> {
+impl Instruction for Jump<'_> {
     fn opt_code_byte(&self) -> u8 {
         let cmp: u8 = self.cond as u8;
         let src_bit = self.src_bit as u8;
@@ -599,7 +599,7 @@ impl<'i> FunctionCall<'i> {
     }
 }
 
-impl<'i> Instruction for FunctionCall<'i> {
+impl Instruction for FunctionCall<'_> {
     fn opt_code_byte(&self) -> u8 {
         BPF_CALL | BPF_JMP
     }
@@ -628,7 +628,7 @@ impl<'i> Exit<'i> {
     }
 }
 
-impl<'i> Instruction for Exit<'i> {
+impl Instruction for Exit<'_> {
     fn opt_code_byte(&self) -> u8 {
         BPF_EXIT | BPF_JMP
     }

src/interpreter.rs

@@ -8,8 +8,17 @@
 use ebpf;
 use crate::lib::*;
 
-fn check_mem(addr: u64, len: usize, access_type: &str, insn_ptr: usize,
-             mbuff: &[u8], mem: &[u8], stack: &[u8], allowed_memory: &HashSet<u64>) -> Result<(), Error> {
+#[allow(clippy::too_many_arguments)]
+fn check_mem(
+    addr: u64,
+    len: usize,
+    access_type: &str,
+    insn_ptr: usize,
+    mbuff: &[u8],
+    mem: &[u8],
+    stack: &[u8],
+    allowed_memory: &HashSet<u64>
+) -> Result<(), Error> {
     if let Some(addr_end) = addr.checked_add(len as u64) {
       if mbuff.as_ptr() as u64 <= addr && addr_end <= mbuff.as_ptr() as u64 + mbuff.len() as u64 {
           return Ok(());
@@ -139,7 +148,7 @@ pub fn execute_program(
             // BPF_LDX class
             ebpf::LD_B_REG   => reg[_dst] = unsafe {
                 #[allow(clippy::cast_ptr_alignment)]
-                let x = (reg[_src] as *const u8).wrapping_offset(insn.off as isize) as *const u8;
+                let x = (reg[_src] as *const u8).wrapping_offset(insn.off as isize);
                 check_mem_load(x as u64, 1, insn_ptr)?;
                 x.read_unaligned() as u64
             },

src/jit.rs

@@ -83,7 +83,7 @@ macro_rules! emit_bytes {
         let size = mem::size_of::<$t>() as usize;
         assert!($mem.offset + size <= $mem.contents.len());
         unsafe {
-            let mut ptr = $mem.contents.as_ptr().add($mem.offset) as *mut $t;
+            let ptr = $mem.contents.as_ptr().add($mem.offset) as *mut $t;
             ptr.write_unaligned($data);
         }
         $mem.offset += size;
@@ -276,7 +276,7 @@ impl JitCompiler {
 
     // Load sign-extended immediate into register
     fn emit_load_imm(&self, mem: &mut JitMemory, dst: u8, imm: i64) {
-        if imm >= std::i32::MIN as i64 && imm <= std::i32::MAX as i64 {
+        if imm >= i32::MIN as i64 && imm <= i32::MAX as i64 {
             self.emit_alu64_imm32(mem, 0xc7, 0, dst, imm as i32);
         } else {
             // movabs $imm,dst
@@ -989,7 +989,7 @@ impl<'a> JitMemory<'a> {
     }
 }
 
-impl<'a> Index<usize> for JitMemory<'a> {
+impl Index<usize> for JitMemory<'_> {
     type Output = u8;
 
     fn index(&self, _index: usize) -> &u8 {
@@ -997,13 +997,13 @@ impl<'a> Index<usize> for JitMemory<'a> {
     }
 }
 
-impl<'a> IndexMut<usize> for JitMemory<'a> {
+impl IndexMut<usize> for JitMemory<'_> {
     fn index_mut(&mut self, _index: usize) -> &mut u8 {
         &mut self.contents[_index]
     }
 }
 
-impl<'a> Drop for JitMemory<'a> {
+impl Drop for JitMemory<'_> {
     fn drop(&mut self) {
         unsafe {
             alloc::dealloc(self.contents.as_mut_ptr(), self.layout);
@@ -1011,7 +1011,7 @@ impl<'a> Drop for JitMemory<'a> {
     }
 }
 
-impl<'a> std::fmt::Debug for JitMemory<'a> {
+impl std::fmt::Debug for JitMemory<'_> {
     fn fmt(&self, fmt: &mut Formatter) -> Result<(), FormatterError> {
         fmt.write_str("JIT contents: [")?;
         fmt.write_str(" ] | ")?;

src/lib.rs

@@ -80,7 +80,7 @@ pub mod lib {
     pub use self::core::mem::ManuallyDrop;
     pub use self::core::ptr;
 
-    pub use self::core::{f64, u32, u64};
+    pub use self::core::f64;
 
     #[cfg(feature = "std")]
     pub use std::println;
@@ -353,7 +353,7 @@ impl<'a> EbpfVmMbuff<'a> {
     /// let addrs = Vec::from_iter(start..start+size_of::<MapValue>() as u64);
     /// vm.register_allowed_memory(&addrs);
     /// ```
-    pub fn register_allowed_memory(&mut self, addrs: &[u64]) -> () {
+    pub fn register_allowed_memory(&mut self, addrs: &[u64]) {
         for i in addrs {
             self.allowed_memory.insert(*i);
         }
@@ -547,7 +547,7 @@ impl<'a> EbpfVmMbuff<'a> {
             ))?,
         };
 
-        let mut compiler = CraneliftCompiler::new(self.helpers.clone());
+        let compiler = CraneliftCompiler::new(self.helpers.clone());
         let program = compiler.compile_function(prog)?;
 
         self.cranelift_prog = Some(program);
@@ -899,7 +899,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     /// let addrs = Vec::from_iter(start..start+size_of::<MapValue>() as u64);
     /// vm.register_allowed_memory(&addrs);
     /// ```
-    pub fn register_allowed_memory(&mut self, allowed: &[u64]) -> () {
+    pub fn register_allowed_memory(&mut self, allowed: &[u64]) {
         self.parent.register_allowed_memory(allowed)
     }
 
@@ -1097,7 +1097,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
             ))?,
         };
 
-        let mut compiler = CraneliftCompiler::new(self.parent.helpers.clone());
+        let compiler = CraneliftCompiler::new(self.parent.helpers.clone());
         let program = compiler.compile_function(prog)?;
 
         self.parent.cranelift_prog = Some(program);
@@ -1371,7 +1371,7 @@ impl<'a> EbpfVmRaw<'a> {
     /// let addrs = Vec::from_iter(start..start+size_of::<MapValue>() as u64);
     /// vm.register_allowed_memory(&addrs);
     /// ```
-    pub fn register_allowed_memory(&mut self, allowed: &[u64]) -> () {
+    pub fn register_allowed_memory(&mut self, allowed: &[u64]) {
         self.parent.register_allowed_memory(allowed)
     }
 
@@ -1511,7 +1511,7 @@ impl<'a> EbpfVmRaw<'a> {
             ))?,
         };
 
-        let mut compiler = CraneliftCompiler::new(self.parent.helpers.clone());
+        let compiler = CraneliftCompiler::new(self.parent.helpers.clone());
         let program = compiler.compile_function(prog)?;
 
         self.parent.cranelift_prog = Some(program);
@@ -1751,7 +1751,7 @@ impl<'a> EbpfVmNoData<'a> {
     /// let addrs = Vec::from_iter(start..start+size_of::<MapValue>() as u64);
     /// vm.register_allowed_memory(&addrs);
     /// ```
-    pub fn register_allowed_memory(&mut self, allowed: &[u64]) -> () {
+    pub fn register_allowed_memory(&mut self, allowed: &[u64]) {
         self.parent.register_allowed_memory(allowed)
     }
 

tests/misc.rs

@@ -273,8 +273,8 @@ fn test_vm_mbuff() {
 
     let mbuff = [0u8; 32];
     unsafe {
-        let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
-        let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
+        let data     = mbuff.as_ptr().offset(8)  as *mut u64;
+        let data_end = mbuff.as_ptr().offset(24) as *mut u64;
         data.write_unaligned(mem.as_ptr() as u64);
         data_end.write_unaligned(mem.as_ptr() as u64 + mem.len() as u64);
     }
@@ -300,8 +300,8 @@ fn test_vm_mbuff_with_rust_api() {
 
     let mbuff = [0u8; 32];
     unsafe {
-        let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
-        let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
+        let data     = mbuff.as_ptr().offset(8)  as *mut u64;
+        let data_end = mbuff.as_ptr().offset(24) as *mut u64;
         *data     = mem.as_ptr() as u64;
         *data_end = mem.as_ptr() as u64 + mem.len() as u64;
     }
@@ -327,8 +327,8 @@ fn test_jit_mbuff() {
 
     let mut mbuff = [0u8; 32];
     unsafe {
-        let mut data     = mbuff.as_ptr().offset(8)  as *mut u64;
-        let mut data_end = mbuff.as_ptr().offset(24) as *mut u64;
+        let data     = mbuff.as_ptr().offset(8)  as *mut u64;
+        let data_end = mbuff.as_ptr().offset(24) as *mut u64;
         *data     = mem.as_ptr() as u64;
         *data_end = mem.as_ptr() as u64 + mem.len() as u64;
     }