2024 edition cargo fmt

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

Diff for: fuzz/fuzz_targets/host_call.rs

@@ -19,8 +19,8 @@ limitations under the License.
 use std::sync::{Mutex, OnceLock};
 
 use hyperlight_host::func::{ParameterValue, ReturnType};
-use hyperlight_host::sandbox::uninitialized::GuestBinary;
 use hyperlight_host::sandbox::SandboxConfiguration;
+use hyperlight_host::sandbox::uninitialized::GuestBinary;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{HyperlightError, MultiUseSandbox, UninitializedSandbox};

Diff for: fuzz/fuzz_targets/host_print.rs

@@ -8,7 +8,7 @@ use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{MultiUseSandbox, UninitializedSandbox};
 use hyperlight_testing::simple_guest_for_fuzzing_as_string;
-use libfuzzer_sys::{fuzz_target, Corpus};
+use libfuzzer_sys::{Corpus, fuzz_target};
 
 static SANDBOX: OnceLock<Mutex<MultiUseSandbox>> = OnceLock::new();
 

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/function_call.rs

@@ -17,18 +17,18 @@ limitations under the License.
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 
-use anyhow::{bail, Error, Result};
-use flatbuffers::{size_prefixed_root, WIPOffset};
+use anyhow::{Error, Result, bail};
+use flatbuffers::{WIPOffset, size_prefixed_root};
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use super::function_types::{ParameterValue, ReturnType};
 use crate::flatbuffers::hyperlight::generated::{
-    hlbool, hlboolArgs, hldouble, hldoubleArgs, hlfloat, hlfloatArgs, hlint, hlintArgs, hllong,
-    hllongArgs, hlstring, hlstringArgs, hluint, hluintArgs, hlulong, hlulongArgs, hlvecbytes,
-    hlvecbytesArgs, FunctionCall as FbFunctionCall, FunctionCallArgs as FbFunctionCallArgs,
+    FunctionCall as FbFunctionCall, FunctionCallArgs as FbFunctionCallArgs,
     FunctionCallType as FbFunctionCallType, Parameter, ParameterArgs,
-    ParameterValue as FbParameterValue,
+    ParameterValue as FbParameterValue, hlbool, hlboolArgs, hldouble, hldoubleArgs, hlfloat,
+    hlfloatArgs, hlint, hlintArgs, hllong, hllongArgs, hlstring, hlstringArgs, hluint, hluintArgs,
+    hlulong, hlulongArgs, hlvecbytes, hlvecbytesArgs,
 };
 
 /// The type of function call.

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/function_types.rs

@@ -17,18 +17,18 @@ limitations under the License.
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 
-use anyhow::{anyhow, bail, Error, Result};
+use anyhow::{Error, Result, anyhow, bail};
 use flatbuffers::size_prefixed_root;
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use crate::flatbuffers::hyperlight::generated::{
-    hlbool, hlboolArgs, hldouble, hldoubleArgs, hlfloat, hlfloatArgs, hlint, hlintArgs, hllong,
-    hllongArgs, hlsizeprefixedbuffer, hlsizeprefixedbufferArgs, hlstring, hlstringArgs, hluint,
-    hluintArgs, hlulong, hlulongArgs, hlvoid, hlvoidArgs,
     FunctionCallResult as FbFunctionCallResult, FunctionCallResultArgs as FbFunctionCallResultArgs,
     Parameter, ParameterType as FbParameterType, ParameterValue as FbParameterValue,
-    ReturnType as FbReturnType, ReturnValue as FbReturnValue,
+    ReturnType as FbReturnType, ReturnValue as FbReturnValue, hlbool, hlboolArgs, hldouble,
+    hldoubleArgs, hlfloat, hlfloatArgs, hlint, hlintArgs, hllong, hllongArgs, hlsizeprefixedbuffer,
+    hlsizeprefixedbufferArgs, hlstring, hlstringArgs, hluint, hluintArgs, hlulong, hlulongArgs,
+    hlvoid, hlvoidArgs,
 };
 
 /// Supported parameter types with values for function calling.

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/guest_error.rs

@@ -22,7 +22,7 @@ use alloc::vec::Vec;
 use anyhow::{Error, Result};
 use flatbuffers::size_prefixed_root;
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use crate::flatbuffers::hyperlight::generated::{
     ErrorCode as FbErrorCode, GuestError as FbGuestError, GuestErrorArgs,

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/guest_log_data.rs

@@ -17,10 +17,10 @@ limitations under the License.
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 
-use anyhow::{anyhow, Error, Result};
+use anyhow::{Error, Result, anyhow};
 use flatbuffers::size_prefixed_root;
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use super::guest_log_level::LogLevel;
 use crate::flatbuffers::hyperlight::generated::{

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/guest_log_level.rs

@@ -14,11 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use anyhow::{bail, Error, Result};
+use anyhow::{Error, Result, bail};
 use log::Level;
 use strum::EnumIter;
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use crate::flatbuffers::hyperlight::generated::LogLevel as FbLogLevel;
 

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/host_function_definition.rs

@@ -17,10 +17,10 @@ limitations under the License.
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 
-use anyhow::{anyhow, Error, Result};
+use anyhow::{Error, Result, anyhow};
 use flatbuffers::{FlatBufferBuilder, WIPOffset};
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use super::function_types::{ParameterType, ReturnType};
 use crate::flatbuffers::hyperlight::generated::{

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/host_function_details.rs

@@ -17,9 +17,9 @@ limitations under the License.
 use alloc::vec::Vec;
 
 use anyhow::{Error, Result};
-use flatbuffers::{size_prefixed_root, WIPOffset};
+use flatbuffers::{WIPOffset, size_prefixed_root};
 #[cfg(feature = "tracing")]
-use tracing::{instrument, Span};
+use tracing::{Span, instrument};
 
 use super::host_function_definition::HostFunctionDefinition;
 use crate::flatbuffers::hyperlight::generated::{

Diff for: src/hyperlight_common/src/flatbuffer_wrappers/util.rs

@@ -19,15 +19,15 @@ use alloc::vec::Vec;
 use flatbuffers::FlatBufferBuilder;
 
 use crate::flatbuffers::hyperlight::generated::{
-    hlbool as Fbhlbool, hlboolArgs as FbhlboolArgs, hldouble as Fbhldouble,
-    hldoubleArgs as FbhldoubleArgs, hlfloat as Fbhlfloat, hlfloatArgs as FbhlfloatArgs,
-    hlint as Fbhlint, hlintArgs as FbhlintArgs, hllong as Fbhllong, hllongArgs as FbhllongArgs,
-    hlsizeprefixedbuffer as Fbhlsizeprefixedbuffer,
+    FunctionCallResult as FbFunctionCallResult, FunctionCallResultArgs as FbFunctionCallResultArgs,
+    ReturnValue as FbReturnValue, hlbool as Fbhlbool, hlboolArgs as FbhlboolArgs,
+    hldouble as Fbhldouble, hldoubleArgs as FbhldoubleArgs, hlfloat as Fbhlfloat,
+    hlfloatArgs as FbhlfloatArgs, hlint as Fbhlint, hlintArgs as FbhlintArgs, hllong as Fbhllong,
+    hllongArgs as FbhllongArgs, hlsizeprefixedbuffer as Fbhlsizeprefixedbuffer,
     hlsizeprefixedbufferArgs as FbhlsizeprefixedbufferArgs, hlstring as Fbhlstring,
     hlstringArgs as FbhlstringArgs, hluint as Fbhluint, hluintArgs as FbhluintArgs,
     hlulong as Fbhlulong, hlulongArgs as FbhlulongArgs, hlvoid as Fbhlvoid,
-    hlvoidArgs as FbhlvoidArgs, FunctionCallResult as FbFunctionCallResult,
-    FunctionCallResultArgs as FbFunctionCallResultArgs, ReturnValue as FbReturnValue,
+    hlvoidArgs as FbhlvoidArgs,
 };
 
 /// Flatbuffer-encodes the given value

Diff for: src/hyperlight_guest/src/entrypoint.rs

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 use core::arch::asm;
-use core::ffi::{c_char, c_void, CStr};
+use core::ffi::{CStr, c_char, c_void};
 use core::ptr::copy_nonoverlapping;
 
 use hyperlight_common::mem::{HyperlightPEB, RunMode};
@@ -26,7 +26,7 @@ use crate::gdt::load_gdt;
 use crate::guest_error::reset_error;
 use crate::guest_function_call::dispatch_function;
 use crate::guest_logger::init_logger;
-use crate::host_function_call::{outb, OutBAction};
+use crate::host_function_call::{OutBAction, outb};
 use crate::idtr::load_idt;
 use crate::{
     __security_cookie, HEAP_ALLOCATOR, MIN_STACK_ADDRESS, OS_PAGE_SIZE, OUTB_PTR,

Diff for: src/hyperlight_guest/src/guest_error.rs

@@ -16,14 +16,14 @@ limitations under the License.
 
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
-use core::ffi::{c_char, CStr};
+use core::ffi::{CStr, c_char};
 
 use hyperlight_common::flatbuffer_wrappers::guest_error::{ErrorCode, GuestError};
 use log::error;
 
-use crate::entrypoint::halt;
-use crate::host_function_call::{outb, OutBAction};
 use crate::P_PEB;
+use crate::entrypoint::halt;
+use crate::host_function_call::{OutBAction, outb};
 
 pub(crate) fn write_error(error_code: ErrorCode, message: Option<&str>) {
     let guest_error = GuestError::new(

Diff for: src/hyperlight_guest/src/guest_function_call.rs

@@ -21,12 +21,12 @@ use hyperlight_common::flatbuffer_wrappers::function_call::{FunctionCall, Functi
 use hyperlight_common::flatbuffer_wrappers::function_types::ParameterType;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 
+use crate::REGISTERED_GUEST_FUNCTIONS;
 use crate::entrypoint::halt;
 use crate::error::{HyperlightGuestError, Result};
 use crate::guest_error::{reset_error, set_error};
 use crate::shared_input_data::try_pop_shared_input_data_into;
 use crate::shared_output_data::push_shared_output_data;
-use crate::REGISTERED_GUEST_FUNCTIONS;
 
 type GuestFunc = fn(&FunctionCall) -> Result<Vec<u8>>;
 

Diff for: src/hyperlight_guest/src/host_functions.rs

@@ -24,8 +24,8 @@ use hyperlight_common::flatbuffer_wrappers::function_types::ParameterType;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::flatbuffer_wrappers::host_function_details::HostFunctionDetails;
 
-use crate::error::{HyperlightGuestError, Result};
 use crate::P_PEB;
+use crate::error::{HyperlightGuestError, Result};
 
 pub(crate) fn validate_host_function_call(function_call: &FunctionCall) -> Result<()> {
     // get host function details

Diff for: src/hyperlight_guest/src/idt.rs

@@ -15,9 +15,9 @@ limitations under the License.
 */
 
 use crate::interrupt_entry::{
-    _do_excp0, _do_excp1, _do_excp10, _do_excp11, _do_excp12, _do_excp13, _do_excp14, _do_excp15,
-    _do_excp16, _do_excp17, _do_excp18, _do_excp19, _do_excp2, _do_excp20, _do_excp3, _do_excp30,
-    _do_excp4, _do_excp5, _do_excp6, _do_excp7, _do_excp8, _do_excp9,
+    _do_excp0, _do_excp1, _do_excp2, _do_excp3, _do_excp4, _do_excp5, _do_excp6, _do_excp7,
+    _do_excp8, _do_excp9, _do_excp10, _do_excp11, _do_excp12, _do_excp13, _do_excp14, _do_excp15,
+    _do_excp16, _do_excp17, _do_excp18, _do_excp19, _do_excp20, _do_excp30,
 };
 
 // An entry in the Interrupt Descriptor Table (IDT)

Diff for: src/hyperlight_guest/src/idtr.rs

@@ -1,6 +1,6 @@
 use core::ptr::addr_of;
 
-use crate::idt::{init_idt, IdtEntry, IDT};
+use crate::idt::{IDT, IdtEntry, init_idt};
 
 #[repr(C, packed)]
 pub struct Idtr {

Diff for: src/hyperlight_guest/src/lib.rs

@@ -19,14 +19,14 @@ limitations under the License.
 use alloc::string::ToString;
 use core::hint::unreachable_unchecked;
 use core::ptr::copy_nonoverlapping;
-use spin::Mutex;
 
 use buddy_system_allocator::LockedHeap;
 use guest_function_register::GuestFunctionRegister;
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 use hyperlight_common::mem::{HyperlightPEB, RunMode};
+use spin::Mutex;
 
-use crate::host_function_call::{outb, OutBAction};
+use crate::host_function_call::{OutBAction, outb};
 extern crate alloc;
 
 // Modules

Diff for: src/hyperlight_guest/src/logging.rs

@@ -20,7 +20,7 @@ use alloc::vec::Vec;
 use hyperlight_common::flatbuffer_wrappers::guest_log_data::GuestLogData;
 use hyperlight_common::flatbuffer_wrappers::guest_log_level::LogLevel;
 
-use crate::host_function_call::{outb, OutBAction};
+use crate::host_function_call::{OutBAction, outb};
 use crate::shared_output_data::push_shared_output_data;
 
 fn write_log_data(

Diff for: src/hyperlight_guest/src/print.rs

@@ -16,11 +16,11 @@ limitations under the License.
 
 use alloc::string::String;
 use alloc::vec::Vec;
-use core::ffi::{c_char, CStr};
+use core::ffi::{CStr, c_char};
 use core::mem;
-use spin::Mutex;
 
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
+use spin::Mutex;
 
 use crate::host_function_call::call_host_function;
 

Diff for: src/hyperlight_guest/src/shared_input_data.rs

@@ -21,8 +21,8 @@ use core::slice::from_raw_parts_mut;
 
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 
-use crate::error::{HyperlightGuestError, Result};
 use crate::P_PEB;
+use crate::error::{HyperlightGuestError, Result};
 
 // Pops the top element from the shared input data buffer and returns it as a T
 pub fn try_pop_shared_input_data_into<T>() -> Result<T>

Diff for: src/hyperlight_guest/src/shared_output_data.rs

@@ -21,8 +21,8 @@ use core::slice::from_raw_parts_mut;
 
 use hyperlight_common::flatbuffer_wrappers::guest_error::ErrorCode;
 
-use crate::error::{HyperlightGuestError, Result};
 use crate::P_PEB;
+use crate::error::{HyperlightGuestError, Result};
 
 pub fn push_shared_output_data(data: Vec<u8>) -> Result<()> {
     let peb_ptr = unsafe { P_PEB.unwrap() };

Diff for: src/hyperlight_guest_capi/src/dispatch.rs

@@ -1,7 +1,7 @@
 use alloc::boxed::Box;
 use alloc::slice;
 use alloc::vec::Vec;
-use core::ffi::{c_char, CStr};
+use core::ffi::{CStr, c_char};
 use core::mem;
 
 use hyperlight_common::flatbuffer_wrappers::function_call::FunctionCall;
@@ -11,7 +11,6 @@ use hyperlight_guest::error::{HyperlightGuestError, Result};
 use hyperlight_guest::guest_function_definition::GuestFunctionDefinition;
 use hyperlight_guest::guest_function_register::GuestFunctionRegister;
 use hyperlight_guest::host_function_call::call_host_function;
-
 use spin::Mutex;
 
 use crate::types::{FfiFunctionCall, FfiVec};

Diff for: src/hyperlight_guest_capi/src/flatbuffer.rs

@@ -1,5 +1,5 @@
 use alloc::boxed::Box;
-use core::ffi::{c_char, CStr};
+use core::ffi::{CStr, c_char};
 
 use hyperlight_common::flatbuffer_wrappers::util::get_flatbuffer_result;
 use hyperlight_guest::host_function_call::get_host_return_value;

Diff for: src/hyperlight_guest_capi/src/types/function_call.rs

@@ -3,7 +3,7 @@ use alloc::ffi::CString;
 use alloc::slice;
 use alloc::string::String;
 use alloc::vec::Vec;
-use core::ffi::{c_char, CStr};
+use core::ffi::{CStr, c_char};
 
 use hyperlight_common::flatbuffer_wrappers::function_call::FunctionCall;
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};

Diff for: src/hyperlight_guest_capi/src/types/parameter.rs

@@ -1,5 +1,5 @@
 use alloc::ffi::CString;
-use core::ffi::{c_char, CStr};
+use core::ffi::{CStr, c_char};
 
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterType, ParameterValue};
 use hyperlight_guest::error::Result;

Diff for: src/hyperlight_host/benches/benchmarks.rs

@@ -16,13 +16,13 @@ limitations under the License.
 
 use std::sync::{Arc, Mutex};
 
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
+use hyperlight_host::GuestBinary;
 use hyperlight_host::func::HostFunction2;
 use hyperlight_host::sandbox::{MultiUseSandbox, UninitializedSandbox};
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
-use hyperlight_host::GuestBinary;
 use hyperlight_testing::simple_guest_as_string;
 
 fn create_uninit_sandbox() -> UninitializedSandbox {

Diff for: src/hyperlight_host/examples/func_ctx/main.rs

@@ -19,7 +19,7 @@ use hyperlight_host::func::call_ctx::MultiUseGuestCallContext;
 use hyperlight_host::sandbox::{MultiUseSandbox, UninitializedSandbox};
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
-use hyperlight_host::{new_error, GuestBinary, Result};
+use hyperlight_host::{GuestBinary, Result, new_error};
 use hyperlight_testing::simple_guest_as_string;
 
 fn main() {

Diff for: src/hyperlight_host/examples/guest-debugging/main.rs

@@ -19,9 +19,9 @@ use std::thread;
 
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
 use hyperlight_host::func::HostFunction0;
+use hyperlight_host::sandbox::SandboxConfiguration;
 #[cfg(gdb)]
 use hyperlight_host::sandbox::config::DebugInfo;
-use hyperlight_host::sandbox::SandboxConfiguration;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
 use hyperlight_host::{MultiUseSandbox, UninitializedSandbox};
@@ -89,7 +89,7 @@ mod tests {
     use std::process::{Command, Stdio};
     use std::time::Duration;
 
-    use hyperlight_host::{new_error, Result};
+    use hyperlight_host::{Result, new_error};
     use io::{BufReader, BufWriter, Read, Write};
 
     use super::*;

Diff for: src/hyperlight_host/examples/metrics/main.rs

@@ -16,13 +16,13 @@ limitations under the License.
 
 extern crate hyperlight_host;
 use std::sync::{Arc, Mutex};
-use std::thread::{spawn, JoinHandle};
+use std::thread::{JoinHandle, spawn};
 
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
 use hyperlight_host::sandbox::uninitialized::UninitializedSandbox;
 use hyperlight_host::sandbox_state::sandbox::EvolvableSandbox;
 use hyperlight_host::sandbox_state::transition::Noop;
-use hyperlight_host::{set_metrics_registry, GuestBinary, MultiUseSandbox, Result};
+use hyperlight_host::{GuestBinary, MultiUseSandbox, Result, set_metrics_registry};
 use hyperlight_testing::simple_guest_as_string;
 use lazy_static::lazy_static;
 use prometheus::Registry;