Clippy updates

Signed-off-by: James Sturtevant <[email protected]>

Author: jsturtevant

fuzz/fuzz_targets/host_call.rs

@@ -57,21 +57,18 @@ fuzz_target!(
         sandbox.restore(&snapshot).unwrap();
 
         host_func_params.insert(0, ParameterValue::String(host_func_name));
-        match sandbox.call_type_erased_guest_function_by_name("FuzzHostFunc", host_func_return, host_func_params) {
-            Err(e) => {
-                match e {
-                    // the following are expected errors and occur frequently since
-                    // we are randomly generating the function name and parameters
-                    // to call with.
-                    HyperlightError::HostFunctionNotFound(_) => {}
-                    HyperlightError::UnexpectedNoOfArguments(_, _) => {},
-                    HyperlightError::ParameterValueConversionFailure(_, _) => {},
+        if let Err(e) = sandbox.call_type_erased_guest_function_by_name("FuzzHostFunc", host_func_return, host_func_params) {
+            match e {
+                // the following are expected errors and occur frequently since
+                // we are randomly generating the function name and parameters
+                // to call with.
+                HyperlightError::HostFunctionNotFound(_) => {}
+                HyperlightError::UnexpectedNoOfArguments(_, _) => {},
+                HyperlightError::ParameterValueConversionFailure(_, _) => {},
 
-                    // any other error should be reported
-                    _ => panic!("Guest Aborted with Unexpected Error: {:?}", e),
-                }
+                // any other error should be reported
+                _ => panic!("Guest Aborted with Unexpected Error: {:?}", e),
             }
-            _ => {}
         }
     }
 );

src/hyperlight_host/examples/guest-debugging/main.rs

@@ -20,7 +20,6 @@ use hyperlight_host::sandbox::SandboxConfiguration;
 #[cfg(gdb)]
 use hyperlight_host::sandbox::config::DebugInfo;
 use hyperlight_host::{MultiUseSandbox, UninitializedSandbox};
-use serial_test::serial;
 
 /// Build a sandbox configuration that enables GDB debugging when the `gdb` feature is enabled.
 fn get_sandbox_cfg() -> Option<SandboxConfiguration> {
@@ -74,10 +73,7 @@ fn main() -> hyperlight_host::Result<()> {
 
     // Call guest function
     multi_use_sandbox_dbg
-        .call::<()>(
-            "UseSSE2Registers",
-             (),
-        )
+        .call::<()>("UseSSE2Registers", ())
         .unwrap();
 
     let message =
@@ -115,23 +111,24 @@ mod tests {
     use super::*;
 
     fn write_cmds_file(cmd_file_path: &str, cmd: &str) -> io::Result<()> {
-
         let file = File::create(cmd_file_path)?;
         let mut writer = BufWriter::new(file);
 
         // write from string to file
-        writer.write_all(
-            cmd.as_bytes(),
-        )?;
+        writer.write_all(cmd.as_bytes())?;
 
         writer.flush()
     }
 
-    fn run_guest_and_gdb(cmd_file_path: &str, out_file_path: &str, cmd: &str, checker: fn(String) -> bool) -> Result<()> {
+    fn run_guest_and_gdb(
+        cmd_file_path: &str,
+        out_file_path: &str,
+        cmd: &str,
+        checker: fn(String) -> bool,
+    ) -> Result<()> {
         // write gdb commands to file
 
-        write_cmds_file(&cmd_file_path, cmd)
-            .expect("Failed to write gdb commands to file");
+        write_cmds_file(&cmd_file_path, cmd).expect("Failed to write gdb commands to file");
 
         #[cfg(mshv2)] // mshv3 is a default feature is mutually exclusive with the mshv2 feature
         let features = "gdb,mshv2";
@@ -242,7 +239,7 @@ mod tests {
         let cmd_file_path = format!("{out_dir}/gdb-commands.txt");
 
         let cmd = format!(
-                "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
+            "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
                 target remote :8080
 
                 set pagination off
@@ -262,9 +259,9 @@ mod tests {
                 set logging off
                 quit
             "
-            );
+        );
 
-        let checker = |contents: String| {contents.contains("Stopped at hyperlight_main breakpoint")};
+        let checker = |contents: String| contents.contains("Stopped at hyperlight_main breakpoint");
 
         let result = run_guest_and_gdb(&cmd_file_path, &out_file_path, &cmd, checker);
 
@@ -284,7 +281,7 @@ mod tests {
         let cmd_file_path = format!("{out_dir}/gdb-sse--commands.txt");
 
         let cmd = format!(
-                "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
+            "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
                 target remote :8080
 
                 set pagination off
@@ -308,9 +305,9 @@ mod tests {
                 set logging off
                 quit
             "
-            );
+        );
 
-        let checker = |contents: String| {contents.contains("$2 = [1.20000005, 0, 0, 0]")};
+        let checker = |contents: String| contents.contains("$2 = [1.20000005, 0, 0, 0]");
         let result = run_guest_and_gdb(&cmd_file_path, &out_file_path, &cmd, checker);
 
         // cleanup

src/hyperlight_host/src/hypervisor/gdb/kvm_debug.rs

@@ -200,7 +200,7 @@ impl GuestDebug for KvmDebug {
             Ok(fpu) => {
                 // Convert KVM XMM registers ([u8; 16] x 16) to [u128; 16]
                 regs.xmm = fpu.xmm.map(u128::from_le_bytes);
-            },
+            }
             Err(e) => {
                 log::warn!("Failed to read FPU state for XMM registers: {:?}", e);
             }
@@ -265,10 +265,8 @@ impl GuestDebug for KvmDebug {
             .map_err(|e| new_error!("Could not write guest registers: {:?}", e))?;
 
         // load existing values and replace the xmm registers
-        let mut fpu =  match vcpu_fd.get_fpu() {
-            Ok(fpu) => {
-                fpu
-            },
+        let mut fpu = match vcpu_fd.get_fpu() {
+            Ok(fpu) => fpu,
             Err(e) => {
                 return Err(new_error!("Could not write guest registers: {:?}", e));
             }
@@ -277,20 +275,24 @@ impl GuestDebug for KvmDebug {
         // Convert XMM registers from [u128; 16] (our internal representation)
         // to [[u8; 16]; 16] (KVM FPU representation) using little-endian byte order.
         fpu.xmm = regs.xmm.map(u128::to_le_bytes);
-        vcpu_fd.set_fpu(&fpu).map_err(|e| new_error!("Could not write guest registers: {:?}", e))?;
+        vcpu_fd
+            .set_fpu(&fpu)
+            .map_err(|e| new_error!("Could not write guest registers: {:?}", e))?;
 
         // Update MXCSR using XSAVE region entry 6 (MXCSR) if available.
         let mut xsave = match vcpu_fd.get_xsave() {
-            Ok(xsave) => {
-               xsave
-            }
+            Ok(xsave) => xsave,
             Err(e) => {
                 return Err(new_error!("Could not write guest registers: {:?}", e));
             }
         };
 
         xsave.region[6] = regs.mxcsr;
-        unsafe { vcpu_fd.set_xsave(&xsave).map_err(|e| new_error!("Could not write guest registers: {:?}", e))? };
+        unsafe {
+            vcpu_fd
+                .set_xsave(&xsave)
+                .map_err(|e| new_error!("Could not write guest registers: {:?}", e))?
+        };
 
         Ok(())
     }

src/tests/rust_guests/simpleguest/src/main.rs

@@ -792,7 +792,7 @@ fn use_sse2_registers(_: &FunctionCall) -> Result<Vec<u8>> {
     unsafe {
         let val: f32 = 1.2f32;
         core::arch::asm!("movss xmm1, DWORD PTR [{0}]", in(reg) &val);
-    } 
+    }
     Ok(get_flatbuffer_result(()))
 }
 
@@ -1491,8 +1491,6 @@ pub extern "C" fn hyperlight_main() {
     register_function(use_sse2_registers);
 }
 
-
-
 #[hyperlight_guest_tracing::trace_function]
 fn send_message_to_host_method(
     method_name: &str,

src/trace_dump/main.rs

@@ -120,10 +120,8 @@ fn dump_trace_record(
     // With the exception of `> halt`, which decreases the indent (because `> entrypoint` does not
     // have a corresponding `< entrypoint`)
     let msg = if msg.starts_with('>') {
-        if msg == "> halt" {
-            if *indent > 0 {
-                *indent -= 1;
-            }
+        if msg == "> halt" && *indent > 0 {
+            *indent -= 1;
         }
         let indent_str = "  ".repeat(*indent as usize);
         let msg = format!("{}{}", indent_str, &msg);
@@ -174,7 +172,7 @@ impl<T: Default> TraceTrie<T> {
         let mut node = self;
         for frame in trace {
             f(&mut node.value);
-            node = (*node).children.entry(*frame).or_insert(Self::new())
+            node = node.children.entry(*frame).or_insert(Self::new())
         }
         f(&mut node.value);
     }
@@ -185,7 +183,7 @@ struct SymbolCache {
     symbol_cache: HashMap<u64, Option<(String, Option<u32>)>>,
 }
 impl SymbolCache {
-    fn resolve_symbol<'c>(&'c mut self, addr: u64) -> &'c Option<(String, Option<u32>)> {
+    fn resolve_symbol(&mut self, addr: u64) -> &Option<(String, Option<u32>)> {
         self.symbol_cache.entry(addr).or_insert_with(|| {
             let frame = &self.loader.find_frames(addr).ok()?.next().ok()??;
             let function = frame.function.as_ref()?;
@@ -382,7 +380,7 @@ impl<R: RenderContext> ViewParams<R> {
             bar_start: width / 4.0,
             bar_height: 12.0,
             bar_leading: 4.0,
-            bar_brush: bar_brush,
+            bar_brush,
         }
     }
 }
@@ -391,7 +389,7 @@ struct BarRenderer<'r> {
     state: &'r mut State,
     now: Duration,
 }
-impl<'r, 'a, 's> RenderWrapper for BarRenderer<'r> {
+impl<'a, 's> RenderWrapper for BarRenderer<'_> {
     fn render<R: RenderContext>(&mut self, ctx: &mut R, wd: u64, ht: u64) -> Option<()> {
         let v = ViewParams::new(ctx, ht, wd);
         draw_bg(ctx, &v);
@@ -422,7 +420,7 @@ impl<'r, 'a, 's> RenderWrapper for BarRenderer<'r> {
                 &v,
                 false,
                 (3 + i) as u64,
-                (&mut self.state.symbol_cache).format_symbol(**site),
+                self.state.symbol_cache.format_symbol(**site),
                 **size,
                 self.state.total,
             )?;
@@ -488,7 +486,7 @@ fn draw_flame<R: RenderContext>(
     }
     Some(())
 }
-impl<'r, 'a, 's> RenderWrapper for FlameRenderer<'r> {
+impl<'a, 's> RenderWrapper for FlameRenderer<'_> {
     fn render<R: RenderContext>(&mut self, ctx: &mut R, wd: u64, ht: u64) -> Option<()> {
         let mut v = ViewParams::new(ctx, ht, wd);
         v.bar_start = v.width / 8.0;
@@ -745,7 +743,7 @@ fn spawn_render_thread(
         let mut bar_ffmpeg = ffmpeg_for(&out_dir, Visualisation::Bar, interval.0)?;
         let mut flame_ffmpeg = ffmpeg_for(&out_dir, Visualisation::Flame, interval.0)?;
         let mut job_state = State {
-            inf: inf,
+            inf,
             symbol_cache: SymbolCache {
                 loader,
                 symbol_cache: HashMap::new(),
@@ -801,9 +799,9 @@ fn main() {
     };
     let inf = File::open(args[2].clone()).expect("could not open trace file");
     let state = State {
-        inf: inf,
+        inf,
         symbol_cache: SymbolCache {
-            loader: loader,
+            loader,
             symbol_cache: HashMap::new(),
         },
         start_time: None,
@@ -854,7 +852,6 @@ fn plot_mem(args: Vec<String>, mut state: State) {
         Some(()) => (),
         None => {
             eprintln!("i/o error encountered");
-            ()
         }
     }
     eprintln!("max total memory used is {}", state.max_total);