Merge pull request #192 from Freax13/feature/xf

Freax13 · web-flow · commit 80e5437e935f · 2025-08-30T13:07:32.000+02:00
implement #XF handler
diff --git a/tee/kernel/src/exception.rs b/tee/kernel/src/exception.rs
@@ -25,7 +25,7 @@ use x86_64::{
     },
     structures::{
         gdt::{Descriptor, DescriptorFlags, GlobalDescriptorTable, SegmentSelector},
-        idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode},
+        idt::{ExceptionVector, InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode},
         paging::Page,
         tss::TaskStateSegment,
     },
@@ -154,6 +154,8 @@ pub fn load_idt() {
         idt.general_protection_fault
             .set_handler_fn(general_protection_fault_handler);
         idt.page_fault.set_handler_fn(page_fault_handler);
+        idt.simd_floating_point
+            .set_handler_fn(simd_floating_point_handler);
         idt[TLB_VECTOR].set_handler_fn(tlb_shootdown_handler);
         idt[TIMER_VECTOR].set_handler_fn(timer_handler);
 
@@ -178,12 +180,13 @@ extern "x86-interrupt" fn divide_error_handler(frame: InterruptStackFrame) {
         // Userspace code path:
         "swapgs",
         // Store the error code.
-        "mov byte ptr gs:[{VECTOR_OFFSET}], 0x0",
+        "mov byte ptr gs:[{VECTOR_OFFSET}], {VECTOR}",
         // Jump to the userspace exit point.
         "jmp {exception_entry}",
 
         kernel_divide_error_handler = sym kernel_divide_error_handler,
         VECTOR_OFFSET = const offset_of!(PerCpu, vector),
+        VECTOR = const ExceptionVector::Division as u8,
         exception_entry = sym exception_entry,
     );
 }
@@ -206,7 +209,7 @@ extern "x86-interrupt" fn page_fault_handler(
         // Userspace code path:
         "swapgs",
         // Store the error code.
-        "mov byte ptr gs:[{VECTOR_OFFSET}], 0xe",
+        "mov byte ptr gs:[{VECTOR_OFFSET}], {VECTOR}",
         "pop qword ptr gs:[{ERROR_CODE_OFFSET}]",
         // Jump to the userspace exit point.
         "jmp {exception_entry}",
@@ -257,6 +260,7 @@ extern "x86-interrupt" fn page_fault_handler(
 
         kernel_page_fault_handler = sym kernel_page_fault_handler,
         VECTOR_OFFSET = const offset_of!(PerCpu, vector),
+        VECTOR = const ExceptionVector::Page as u8,
         ERROR_CODE_OFFSET = const offset_of!(PerCpu, error_code),
         exception_entry = sym exception_entry,
     );
@@ -309,13 +313,14 @@ extern "x86-interrupt" fn general_protection_fault_handler(
         // Userspace code path:
         "swapgs",
         // Store the error code.
-        "mov byte ptr gs:[{VECTOR_OFFSET}], 0xd",
+        "mov byte ptr gs:[{VECTOR_OFFSET}], {VECTOR}",
         "pop qword ptr gs:[{ERROR_CODE_OFFSET}]",
         // Jump to the userspace exit point.
         "jmp {exception_entry}",
 
         kernel_general_protection_fault_handler = sym kernel_general_protection_fault_handler,
         VECTOR_OFFSET = const offset_of!(PerCpu, vector),
+        VECTOR = const ExceptionVector::GeneralProtection as u8,
         ERROR_CODE_OFFSET = const offset_of!(PerCpu, error_code),
         exception_entry = sym exception_entry,
     );
@@ -328,23 +333,50 @@ extern "x86-interrupt" fn kernel_general_protection_fault_handler(
     panic!("general protection fault {frame:x?} {code:x?}");
 }
 
+#[unsafe(naked)]
+extern "x86-interrupt" fn simd_floating_point_handler(frame: InterruptStackFrame) {
+    naked_asm!(
+        "cld",
+        // Check whether the exception happened in userspace.
+        "test word ptr [rsp+8], 3",
+        "je {kernel_simd_floating_point_handler}",
+
+        // Userspace code path:
+        "swapgs",
+        // Store the error code.
+        "mov byte ptr gs:[{VECTOR_OFFSET}], {VECTOR}",
+        // Jump to the userspace exit point.
+        "jmp {exception_entry}",
+
+        kernel_simd_floating_point_handler = sym kernel_simd_floating_point_handler,
+        VECTOR_OFFSET = const offset_of!(PerCpu, vector),
+        VECTOR = const ExceptionVector::SimdFloatingPoint as u8,
+        exception_entry = sym exception_entry,
+    );
+}
+
+extern "x86-interrupt" fn kernel_simd_floating_point_handler(frame: InterruptStackFrame) {
+    panic!("simd floating point exception {frame:x?}");
+}
+
 #[unsafe(naked)]
 extern "x86-interrupt" fn invalid_opcode_handler(frame: InterruptStackFrame) {
     naked_asm!(
         "cld",
         // Check whether the exception happened in userspace.
-        "test word ptr [rsp+16], 3",
+        "test word ptr [rsp+8], 3",
         "je {kernel_invalid_opcode_handler}",
 
         // Userspace code path:
         "swapgs",
         // Store the error code.
-        "mov byte ptr gs:[{VECTOR_OFFSET}], 0x6",
+        "mov byte ptr gs:[{VECTOR_OFFSET}], {VECTOR}",
         // Jump to the userspace exit point.
         "jmp {exception_entry}",
 
         kernel_invalid_opcode_handler = sym kernel_invalid_opcode_handler,
         VECTOR_OFFSET = const offset_of!(PerCpu, vector),
+        VECTOR = const ExceptionVector::InvalidOpcode as u8,
         exception_entry = sym exception_entry,
     );
 }
@@ -422,13 +454,13 @@ extern "x86-interrupt" fn timer_handler(frame: InterruptStackFrame) {
         // Userspace code path:
         "swapgs",
         // Store the error code.
-        "mov byte ptr gs:[{VECTOR_OFFSET}], {TIMER_VECTOR}",
+        "mov byte ptr gs:[{VECTOR_OFFSET}], {VECTOR}",
         // Jump to the userspace exit point.
         "jmp {interrupt_entry}",
 
         kernel_timer_handler = sym kernel_timer_handler,
         VECTOR_OFFSET = const offset_of!(PerCpu, vector),
-        TIMER_VECTOR = const TIMER_VECTOR,
+        VECTOR = const TIMER_VECTOR,
         interrupt_entry = sym interrupt_entry,
     );
 }
diff --git a/tee/kernel/src/user/syscall/cpu_state.rs b/tee/kernel/src/user/syscall/cpu_state.rs
@@ -18,6 +18,7 @@ use x86_64::{
     registers::{
         control::Cr2,
         model_specific::{LStar, SFMask},
+        mxcsr::MxCsr,
         rflags::RFlags,
         xcontrol::{XCr0, XCr0Flags},
     },
@@ -157,6 +158,37 @@ impl CpuState {
                         code,
                     })
                 }
+                0x13 => {
+                    let mxcsr = self.xsave_area.mxcsr();
+                    let error = if mxcsr.contains(MxCsr::INVALID_OPERATION)
+                        && !mxcsr.contains(MxCsr::INVALID_OPERATION_MASK)
+                    {
+                        SimdFloatingPointError::InvalidOperation
+                    } else if mxcsr.contains(MxCsr::DENORMAL)
+                        && !mxcsr.contains(MxCsr::DENORMAL_MASK)
+                    {
+                        SimdFloatingPointError::Denormal
+                    } else if mxcsr.contains(MxCsr::DIVIDE_BY_ZERO)
+                        && !mxcsr.contains(MxCsr::DIVIDE_BY_ZERO_MASK)
+                    {
+                        SimdFloatingPointError::DivideByZero
+                    } else if mxcsr.contains(MxCsr::OVERFLOW)
+                        && !mxcsr.contains(MxCsr::OVERFLOW_MASK)
+                    {
+                        SimdFloatingPointError::Overflow
+                    } else if mxcsr.contains(MxCsr::UNDERFLOW)
+                        && !mxcsr.contains(MxCsr::UNDERFLOW_MASK)
+                    {
+                        SimdFloatingPointError::Underflow
+                    } else if mxcsr.contains(MxCsr::PRECISION)
+                        && !mxcsr.contains(MxCsr::PRECISION_MASK)
+                    {
+                        SimdFloatingPointError::Precision
+                    } else {
+                        unreachable!()
+                    };
+                    Exit::SimdFloatingPoint(error)
+                }
                 TIMER_VECTOR => Exit::Timer,
                 0x80 => {
                     let no = self.registers.rax as u32;
@@ -649,6 +681,7 @@ pub enum Exit {
     InvalidOpcode,
     GeneralProtectionFault,
     PageFault(PageFaultExit),
+    SimdFloatingPoint(SimdFloatingPointError),
     Timer,
 }
 
@@ -658,6 +691,16 @@ pub struct PageFaultExit {
     pub code: PageFaultErrorCode,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum SimdFloatingPointError {
+    InvalidOperation,
+    Denormal,
+    DivideByZero,
+    Overflow,
+    Underflow,
+    Precision,
+}
+
 #[derive(Clone)]
 struct XSaveArea {
     data: Vec<u8>,
@@ -701,6 +744,11 @@ impl XSaveArea {
             _xrstor64(self.data.as_ptr(), rs_mask.bits());
         }
     }
+
+    fn mxcsr(&self) -> MxCsr {
+        let fxsave = from_bytes::<FXSave>(&self.data[..512]);
+        MxCsr::from_bits_retain(fxsave.mxcsr)
+    }
 }
 
 /// The first 512 bytes used by the xsave instructions.
diff --git a/tee/kernel/src/user/thread.rs b/tee/kernel/src/user/thread.rs
@@ -49,7 +49,7 @@ use crate::{
                 FileMode, Nice, Pointer, PtraceEvent, Rusage, Signal, TimerId, Timespec, UserDesc,
                 WStatus,
             },
-            cpu_state::{CpuState, Exit, PageFaultExit},
+            cpu_state::{CpuState, Exit, PageFaultExit, SimdFloatingPointError},
         },
     },
 };
@@ -297,6 +297,26 @@ impl Thread {
                                 self.queue_signal_or_die(sig_info);
                             }
                             Exit::PageFault(page_fault) => self.handle_page_fault(page_fault),
+                            Exit::SimdFloatingPoint(error) => {
+                                let code = match error {
+                                    SimdFloatingPointError::InvalidOperation => {
+                                        SigInfoCode::FPE_FLTINV
+                                    }
+                                    SimdFloatingPointError::Denormal => SigInfoCode::FPE_FLTUND,
+                                    SimdFloatingPointError::DivideByZero => SigInfoCode::FPE_FLTDIV,
+                                    SimdFloatingPointError::Overflow => SigInfoCode::FPE_FLTOVF,
+                                    SimdFloatingPointError::Underflow => SigInfoCode::FPE_FLTUND,
+                                    SimdFloatingPointError::Precision => SigInfoCode::FPE_FLTRES,
+                                };
+                                let sig_info = SigInfo {
+                                    signal: Signal::FPE,
+                                    code,
+                                    fields: SigFields::SigFault(SigFault {
+                                        addr: self.cpu_state.lock().faulting_instruction(),
+                                    }),
+                                };
+                                self.queue_signal_or_die(sig_info);
+                            }
                             Exit::Timer => {
                                 // Handle the timer interrupt.
                                 time::expire_timers();
@@ -567,6 +587,7 @@ impl Thread {
                     | Exit::InvalidOpcode
                     | Exit::GeneralProtectionFault
                     | Exit::PageFault(_)
+                    | Exit::SimdFloatingPoint(_)
                     | Exit::Timer => writeln!(write, "{:indent$}{exit:?}", "")?,
                 }
             } else {
@@ -1305,6 +1326,11 @@ impl SigInfoCode {
     pub const SEGV_ACCERR: Self = Self(2);
     pub const ILL_ILLOPN: Self = Self(2);
     pub const BUS_ADRERR: Self = Self(2);
+    pub const FPE_FLTDIV: Self = Self(3);
+    pub const FPE_FLTOVF: Self = Self(4);
+    pub const FPE_FLTUND: Self = Self(5);
+    pub const FPE_FLTRES: Self = Self(6);
+    pub const FPE_FLTINV: Self = Self(7);
     pub const KERNEL: Self = Self(0x80);
     pub const TIMER: Self = Self(-2);
     pub const TKILL: Self = Self(-6);
