[fmt/clippy] fixing ci

danbugs · danbugs · commit 62405019eebe · 2025-02-18T21:56:25.000Z
Signed-off-by: danbugs &lt;danilochiarlone@gmail.com&gt;
diff --git a/src/hyperlight_guest/src/entrypoint.rs b/src/hyperlight_guest/src/entrypoint.rs
@@ -22,16 +22,16 @@ use hyperlight_common::mem::{HyperlightPEB, RunMode};
 use log::LevelFilter;
 use spin::Once;
 
+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::idtr::load_idt;
 use crate::{
     __security_cookie, HEAP_ALLOCATOR, MIN_STACK_ADDRESS, OS_PAGE_SIZE, OUTB_PTR,
     OUTB_PTR_WITH_CONTEXT, P_PEB, RUNNING_MODE,
 };
-use crate::gdt::load_gdt;
-use crate::idtr::load_idt;
 
 #[inline(never)]
 pub fn halt() {
diff --git a/src/hyperlight_guest/src/gdt.rs b/src/hyperlight_guest/src/gdt.rs
@@ -48,10 +48,8 @@ impl GdtEntry {
 static mut GDT: [GdtEntry; 3] = [
     // Null descriptor
     GdtEntry::new(0, 0, 0, 0),
-
     // Kernel Code Segment (0x08)
     GdtEntry::new(0, 0, 0x9A, 0xA),
-
     // Kernel Data Segment (0x10)
     GdtEntry::new(0, 0, 0x92, 0xC),
 ];
@@ -87,4 +85,3 @@ pub unsafe fn load_gdt() {
     options(nostack, preserves_flags)
     );
 }
-
diff --git a/src/hyperlight_guest/src/idt.rs b/src/hyperlight_guest/src/idt.rs
@@ -15,29 +15,30 @@ limitations under the License.
 */
 
 use crate::interrupt_entry::{
-    _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};
+    _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,
+};
 
 // An entry in the Interrupt Descriptor Table (IDT)
 // For reference, see: https://wiki.osdev.org/Interrupt_Descriptor_Table#Structure_on_x86-64
 #[repr(C, align(16))]
 pub(crate) struct IdtEntry {
-    offset_low: u16,  // Lower 16 bits of handler address
-    selector: u16,    // code segment selector in GDT
-    ist: u8,          // Interrupt Stack Table offset
-    type_attr: u8,    // Gate type and flags
-    offset_mid: u16,  // Middle 16 bits of handler address
-    offset_high: u32, // High 32 bits of handler address
-    zero: u32,        // Reserved (always 0)
+    offset_low: u16,                  // Lower 16 bits of handler address
+    selector: u16,                    // code segment selector in GDT
+    interrupt_stack_table_offset: u8, // Interrupt Stack Table offset
+    type_attr: u8,                    // Gate type and flags
+    offset_mid: u16,                  // Middle 16 bits of handler address
+    offset_high: u32,                 // High 32 bits of handler address
+    zero: u32,                        // Reserved (always 0)
 }
 
 impl IdtEntry {
     fn new(handler: u64) -> Self {
         Self {
             offset_low: (handler & 0xFFFF) as u16,
-            selector: 0x08,                             // Kernel Code Segment
-            ist: 0,                                     // No IST used
+            selector: 0x08,                  // Kernel Code Segment
+            interrupt_stack_table_offset: 0, // No interrupt stack table used
             type_attr: 0x8E,
             // 0x8E = 10001110b
             // 1 00 0 1110
@@ -53,38 +54,38 @@ impl IdtEntry {
     }
 }
 
-
 // The IDT is an array of 256 IDT entries
 // (for reference, see: https://wiki.osdev.org/Interrupt_Descriptor_Table#Structure_on_x86-64)
 pub(crate) static mut IDT: [IdtEntry; 256] = unsafe { core::mem::zeroed() };
 
 pub(crate) fn init_idt() {
-    set_idt_entry(0, _do_excp0);    // Divide by zero
-    set_idt_entry(1, _do_excp1);    // Debug
-    set_idt_entry(2, _do_excp2);    // Non-maskable interrupt
-    set_idt_entry(3, _do_excp3);    // Breakpoint
-    set_idt_entry(4, _do_excp4);    // Overflow
-    set_idt_entry(5, _do_excp5);    // Bound Range Exceeded
-    set_idt_entry(6, _do_excp6);    // Invalid Opcode
-    set_idt_entry(7, _do_excp7);    // Device Not Available
-    set_idt_entry(8, _do_excp8);    // Double Fault
-    set_idt_entry(9, _do_excp9);    // Coprocessor Segment Overrun
-    set_idt_entry(10, _do_excp10);  // Invalid TSS
-    set_idt_entry(11, _do_excp11);  // Segment Not Present
-    set_idt_entry(12, _do_excp12);  // Stack-Segment Fault
-    set_idt_entry(13, _do_excp13);  // General Protection Fault
-    set_idt_entry(14, _do_excp14);  // Page Fault
-    set_idt_entry(15, _do_excp15);  // Reserved
-    set_idt_entry(16, _do_excp16);  // x87 Floating-Point Exception
-    set_idt_entry(17, _do_excp17);  // Alignment Check
-    set_idt_entry(18, _do_excp18);  // Machine Check
-    set_idt_entry(19, _do_excp19);  // SIMD Floating-Point Exception
-    set_idt_entry(20, _do_excp20);  // Virtualization Exception
-    set_idt_entry(30, _do_excp30);  // Security Exception
+    set_idt_entry(0, _do_excp0); // Divide by zero
+    set_idt_entry(1, _do_excp1); // Debug
+    set_idt_entry(2, _do_excp2); // Non-maskable interrupt
+    set_idt_entry(3, _do_excp3); // Breakpoint
+    set_idt_entry(4, _do_excp4); // Overflow
+    set_idt_entry(5, _do_excp5); // Bound Range Exceeded
+    set_idt_entry(6, _do_excp6); // Invalid Opcode
+    set_idt_entry(7, _do_excp7); // Device Not Available
+    set_idt_entry(8, _do_excp8); // Double Fault
+    set_idt_entry(9, _do_excp9); // Coprocessor Segment Overrun
+    set_idt_entry(10, _do_excp10); // Invalid TSS
+    set_idt_entry(11, _do_excp11); // Segment Not Present
+    set_idt_entry(12, _do_excp12); // Stack-Segment Fault
+    set_idt_entry(13, _do_excp13); // General Protection Fault
+    set_idt_entry(14, _do_excp14); // Page Fault
+    set_idt_entry(15, _do_excp15); // Reserved
+    set_idt_entry(16, _do_excp16); // x87 Floating-Point Exception
+    set_idt_entry(17, _do_excp17); // Alignment Check
+    set_idt_entry(18, _do_excp18); // Machine Check
+    set_idt_entry(19, _do_excp19); // SIMD Floating-Point Exception
+    set_idt_entry(20, _do_excp20); // Virtualization Exception
+    set_idt_entry(30, _do_excp30); // Security Exception
 }
 
 fn set_idt_entry(index: usize, handler: unsafe extern "sysv64" fn()) {
     let handler_addr = handler as *const () as u64;
-    unsafe { IDT[index] = IdtEntry::new(handler_addr); }
+    unsafe {
+        IDT[index] = IdtEntry::new(handler_addr);
+    }
 }
-
diff --git a/src/hyperlight_guest/src/idtr.rs b/src/hyperlight_guest/src/idtr.rs
@@ -1,4 +1,5 @@
 use core::ptr::addr_of;
+
 use crate::idt::{init_idt, IdtEntry, IDT};
 
 #[repr(C, packed)]
diff --git a/src/hyperlight_guest/src/interrupt_entry.rs b/src/hyperlight_guest/src/interrupt_entry.rs
@@ -18,6 +18,7 @@ limitations under the License.
 // https://github.com/nanvix/nanvix/tree/dev/src/kernel/src/hal/arch/x86
 
 use core::arch::global_asm;
+
 use crate::interrupt_handlers::hl_exception_handler;
 
 extern "sysv64" {
@@ -66,7 +67,6 @@ macro_rules! context_save {
             "    push r13\n",
             "    push r14\n",
             "    push r15\n",
-
             // Save segment registers
             "    mov rax, ds\n",
             "    push rax\n",
@@ -92,7 +92,6 @@ macro_rules! context_restore {
             "    mov es, rax\n",
             "    pop rax\n",
             "    mov ds, rax\n",
-
             // Restore general-purpose registers
             "    pop r15\n",
             "    pop r14\n",
@@ -168,12 +167,18 @@ macro_rules! generate_exceptions {
 macro_rules! generate_excp {
     ($num:expr) => {
         concat!(
-            ".global _do_excp", stringify!($num), "\n",
-            "_do_excp", stringify!($num), ":\n",
+            ".global _do_excp",
+            stringify!($num),
+            "\n",
+            "_do_excp",
+            stringify!($num),
+            ":\n",
             context_save!(),
             // In SysV ABI, the second argument is passed in rsi
             // rsi is the exception number.
-            "    mov rsi, ", stringify!($num), "\n",
+            "    mov rsi, ",
+            stringify!($num),
+            "\n",
             // In SysV ABI, the third argument is passed in rdx
             // rdx is only used for pagefault exception and
             // contains the address that caused the pagefault.
@@ -183,16 +188,22 @@ macro_rules! generate_excp {
     };
     ($num:expr, pusherrcode) => {
         concat!(
-            ".global _do_excp", stringify!($num), "\n",
-            "_do_excp", stringify!($num), ":\n",
+            ".global _do_excp",
+            stringify!($num),
+            "\n",
+            "_do_excp",
+            stringify!($num),
+            ":\n",
             // Some exceptions push an error code onto the stack.
             // For the ones that don't, we push a 0 to keep the
             // stack aligned.
             "   push 0\n",
             context_save!(),
             // In SysV ABI, the second argument is passed in rsi
             // rsi is the exception number.
-            "    mov rsi, ", stringify!($num), "\n",
+            "    mov rsi, ",
+            stringify!($num),
+            "\n",
             // In SysV ABI, the third argument is passed in rdx
             // rdx is only used for pagefault exception and
             // contains the address that caused the pagefault.
@@ -202,10 +213,16 @@ macro_rules! generate_excp {
     };
     ($num:expr, pagefault) => {
         concat!(
-            ".global _do_excp", stringify!($num), "\n",
-            "_do_excp", stringify!($num), ":\n",
+            ".global _do_excp",
+            stringify!($num),
+            "\n",
+            "_do_excp",
+            stringify!($num),
+            ":\n",
             context_save!(),
-            "    mov rsi, ", stringify!($num), "\n",
+            "    mov rsi, ",
+            stringify!($num),
+            "\n",
             // In a page fault exception, the cr2 register
             // contains the address that caused the page fault.
             "    mov rdx, cr2\n",
diff --git a/src/hyperlight_guest/src/interrupt_handlers.rs b/src/hyperlight_guest/src/interrupt_handlers.rs
@@ -19,7 +19,11 @@ limitations under the License.
 
 /// Exception handler
 #[no_mangle]
-pub extern "sysv64" fn hl_exception_handler(stack_pointer: u64, exception_number: u64, page_fault_address: u64) {
+pub extern "sysv64" fn hl_exception_handler(
+    stack_pointer: u64,
+    exception_number: u64,
+    page_fault_address: u64,
+) {
     panic!(
         "EXCEPTION: {:#x}\n\
             Page Fault Address: {:#x}\n\
diff --git a/src/hyperlight_guest/src/lib.rs b/src/hyperlight_guest/src/lib.rs
@@ -50,12 +50,12 @@ pub mod setjmp;
 
 pub mod chkstk;
 pub mod error;
-pub mod logging;
-pub mod interrupt_entry;
-pub mod interrupt_handlers;
+pub mod gdt;
 pub mod idt;
 pub mod idtr;
-pub mod gdt;
+pub mod interrupt_entry;
+pub mod interrupt_handlers;
+pub mod logging;
 
 // Unresolved symbols
 ///cbindgen:ignore
diff --git a/src/hyperlight_host/src/func/guest_dispatch.rs b/src/hyperlight_host/src/func/guest_dispatch.rs
@@ -160,7 +160,7 @@ mod tests {
                 None,
                 None,
             )
-                .unwrap();
+            .unwrap();
 
             make_get_pid_syscall_func.register(&mut usbox, "MakeGetpidSyscall")?;
 
@@ -196,7 +196,7 @@ mod tests {
                 None,
                 None,
             )
-                .unwrap();
+            .unwrap();
 
             make_get_pid_syscall_func.register_with_extra_allowed_syscalls(
                 &mut usbox,
@@ -228,7 +228,7 @@ mod tests {
                 None,
                 None,
             )
-                .unwrap()
+            .unwrap()
         };
 
         // test_function0
@@ -345,7 +345,7 @@ mod tests {
             // just use the built-in host print function
             None,
         )
-            .unwrap();
+        .unwrap();
         test_call_guest_function_by_name(u_sbox);
     }
 
@@ -365,7 +365,7 @@ mod tests {
             Some(crate::SandboxRunOptions::RunInProcess(true)),
             None,
         )
-            .unwrap();
+        .unwrap();
         test_call_guest_function_by_name(u_sbox);
     }
 
@@ -378,7 +378,7 @@ mod tests {
             Some(crate::SandboxRunOptions::RunInProcess(false)),
             None,
         )
-            .unwrap();
+        .unwrap();
         test_call_guest_function_by_name(u_sbox);
     }
 
@@ -444,7 +444,7 @@ mod tests {
             None,
             None,
         )
-            .unwrap();
+        .unwrap();
 
         // Make this host call run for 5 seconds
 
@@ -489,7 +489,7 @@ mod tests {
             None,
             None,
         )
-            .unwrap();
+        .unwrap();
 
         let mut multi_use_sandbox: MultiUseSandbox = usbox.evolve(Noop::default()).unwrap();
 
@@ -506,7 +506,10 @@ mod tests {
                 // msg should indicate we got an invalid opcode exception
                 assert!(msg.contains("EXCEPTION: 0x6"));
             }
-            e => panic!("Expected HyperlightError::GuestExecutionError but got {:?}", e),
+            e => panic!(
+                "Expected HyperlightError::GuestExecutionError but got {:?}",
+                e
+            ),
         }
     }
 }
diff --git a/src/tests/rust_guests/simpleguest/src/main.rs b/src/tests/rust_guests/simpleguest/src/main.rs
@@ -638,7 +638,9 @@ fn log_message(function_call: &FunctionCall) -> Result<Vec<u8>> {
 }
 
 fn trigger_exception(_: &FunctionCall) -> Result<Vec<u8>> {
-    unsafe { core::arch::asm!("ud2"); } // trigger an undefined instruction exception
+    unsafe {
+        core::arch::asm!("ud2");
+    } // trigger an undefined instruction exception
     Ok(get_flatbuffer_result_from_void())
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`use core::ptr::addr_of;`
	`2`	`+`
`2`	`3`	`use crate::idt::{init_idt, IdtEntry, IDT};`
`3`	`4`
`4`	`5`	`#[repr(C, packed)]`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ mod tests {`
`160`	`160`	`None,`
`161`	`161`	`None,`
`162`	`162`	`)`
`163`		`- .unwrap();`
	`163`	`+ .unwrap();`
`164`	`164`
`165`	`165`	`make_get_pid_syscall_func.register(&mut usbox, "MakeGetpidSyscall")?;`
`166`	`166`
`@@ -196,7 +196,7 @@ mod tests {`
`196`	`196`	`None,`
`197`	`197`	`None,`
`198`	`198`	`)`
`199`		`- .unwrap();`
	`199`	`+ .unwrap();`
`200`	`200`
`201`	`201`	`make_get_pid_syscall_func.register_with_extra_allowed_syscalls(`
`202`	`202`	`&mut usbox,`
`@@ -228,7 +228,7 @@ mod tests {`
`228`	`228`	`None,`
`229`	`229`	`None,`
`230`	`230`	`)`
`231`		`- .unwrap()`
	`231`	`+ .unwrap()`
`232`	`232`	`};`
`233`	`233`
`234`	`234`	`// test_function0`
`@@ -345,7 +345,7 @@ mod tests {`
`345`	`345`	`// just use the built-in host print function`
`346`	`346`	`None,`
`347`	`347`	`)`
`348`		`- .unwrap();`
	`348`	`+ .unwrap();`
`349`	`349`	`test_call_guest_function_by_name(u_sbox);`
`350`	`350`	`}`
`351`	`351`
`@@ -365,7 +365,7 @@ mod tests {`
`365`	`365`	`Some(crate::SandboxRunOptions::RunInProcess(true)),`
`366`	`366`	`None,`
`367`	`367`	`)`
`368`		`- .unwrap();`
	`368`	`+ .unwrap();`
`369`	`369`	`test_call_guest_function_by_name(u_sbox);`
`370`	`370`	`}`
`371`	`371`
`@@ -378,7 +378,7 @@ mod tests {`
`378`	`378`	`Some(crate::SandboxRunOptions::RunInProcess(false)),`
`379`	`379`	`None,`
`380`	`380`	`)`
`381`		`- .unwrap();`
	`381`	`+ .unwrap();`
`382`	`382`	`test_call_guest_function_by_name(u_sbox);`
`383`	`383`	`}`
`384`	`384`
`@@ -444,7 +444,7 @@ mod tests {`
`444`	`444`	`None,`
`445`	`445`	`None,`
`446`	`446`	`)`
`447`		`- .unwrap();`
	`447`	`+ .unwrap();`
`448`	`448`
`449`	`449`	`// Make this host call run for 5 seconds`
`450`	`450`
`@@ -489,7 +489,7 @@ mod tests {`
`489`	`489`	`None,`
`490`	`490`	`None,`
`491`	`491`	`)`
`492`		`- .unwrap();`
	`492`	`+ .unwrap();`
`493`	`493`
`494`	`494`	`let mut multi_use_sandbox: MultiUseSandbox = usbox.evolve(Noop::default()).unwrap();`
`495`	`495`
`@@ -506,7 +506,10 @@ mod tests {`
`506`	`506`	`// msg should indicate we got an invalid opcode exception`
`507`	`507`	`assert!(msg.contains("EXCEPTION: 0x6"));`
`508`	`508`	`}`
`509`		`- e => panic!("Expected HyperlightError::GuestExecutionError but got {:?}", e),`
	`509`	`+ e => panic!(`
	`510`	`+ "Expected HyperlightError::GuestExecutionError but got {:?}",`
	`511`	`+ e`
	`512`	`+ ),`
`510`	`513`	`}`
`511`	`514`	`}`
`512`	`515`	`}`
Original file line number	Diff line number	Diff line change
`@@ -638,7 +638,9 @@ fn log_message(function_call: &FunctionCall) -> Result<Vec<u8>> {`
`638`	`638`	`}`
`639`	`639`
`640`	`640`	`fn trigger_exception(_: &FunctionCall) -> Result<Vec<u8>> {`
`641`		`- unsafe { core::arch::asm!("ud2"); } // trigger an undefined instruction exception`
	`641`	`+ unsafe {`
	`642`	`+ core::arch::asm!("ud2");`
	`643`	`+ } // trigger an undefined instruction exception`
`642`	`644`	`Ok(get_flatbuffer_result_from_void())`
`643`	`645`	`}`
`644`	`646`