Update bitfield usage and remove wrapper methods per review feedback

Co-authored-by: sangho2 <3938640+sangho2@users.noreply.github.com>

Author: Copilot

litebox_platform_lvbs/src/mshv/hvcall.rs

@@ -129,8 +129,8 @@ pub fn init() -> Result<(), HypervError> {
     debug_serial_println!("HV_X64_MSR_SIMP: {:#x}", rdmsr(HV_X64_MSR_SIMP));
 
     let mut sint = HvSynicSint::new();
-    sint.set_vector_u64(u64::from(HYPERVISOR_CALLBACK_VECTOR));
-    sint.set_auto_eoi_flag();
+    sint.set_vector((HYPERVISOR_CALLBACK_VECTOR as u8).into());
+    sint.set_auto_eoi(true);
 
     wrmsr(HV_X64_MSR_SINT0, sint.as_uint64());
     if get_core_id() == 0 {

litebox_platform_lvbs/src/mshv/hvcall_vp.rs

@@ -142,33 +142,33 @@ fn hv_vtl_populate_vp_context(input: &mut HvEnableVpVtl, tss: u64, rip: u64, rsp
     // We only support 64-bit long mode for now, so most of the segment register fields are ignored.
     input.vp_context.cs.selector = SegmentSelector::new(1, PrivilegeLevel::Ring0).0;
     input.vp_context.cs.set_attributes(
-        SegmentRegisterAttributeFlags::ACCESSED.bits()
-            | SegmentRegisterAttributeFlags::WRITABLE.bits()
-            | SegmentRegisterAttributeFlags::EXECUTABLE.bits()
-            | SegmentRegisterAttributeFlags::USER_SEGMENT.bits()
-            | SegmentRegisterAttributeFlags::PRESENT.bits()
-            | SegmentRegisterAttributeFlags::AVAILABLE.bits()
-            | SegmentRegisterAttributeFlags::LONG_MODE.bits(),
+        SegmentRegisterAttributeFlags::ACCESSED
+            | SegmentRegisterAttributeFlags::WRITABLE
+            | SegmentRegisterAttributeFlags::EXECUTABLE
+            | SegmentRegisterAttributeFlags::USER_SEGMENT
+            | SegmentRegisterAttributeFlags::PRESENT
+            | SegmentRegisterAttributeFlags::AVAILABLE
+            | SegmentRegisterAttributeFlags::LONG_MODE,
     );
 
     input.vp_context.ss.selector = SegmentSelector::new(2, PrivilegeLevel::Ring0).0;
     input.vp_context.ss.set_attributes(
-        SegmentRegisterAttributeFlags::ACCESSED.bits()
-            | SegmentRegisterAttributeFlags::WRITABLE.bits()
-            | SegmentRegisterAttributeFlags::USER_SEGMENT.bits()
-            | SegmentRegisterAttributeFlags::PRESENT.bits()
-            | SegmentRegisterAttributeFlags::AVAILABLE.bits(),
+        SegmentRegisterAttributeFlags::ACCESSED
+            | SegmentRegisterAttributeFlags::WRITABLE
+            | SegmentRegisterAttributeFlags::USER_SEGMENT
+            | SegmentRegisterAttributeFlags::PRESENT
+            | SegmentRegisterAttributeFlags::AVAILABLE,
     );
 
     input.vp_context.tr.selector = SegmentSelector::new(3, PrivilegeLevel::Ring0).0;
     input.vp_context.tr.base = tss;
     input.vp_context.tr.limit =
         u32::try_from(core::mem::size_of::<TaskStateSegment>()).unwrap() - 1;
     input.vp_context.tr.set_attributes(
-        SegmentRegisterAttributeFlags::ACCESSED.bits()
-            | SegmentRegisterAttributeFlags::WRITABLE.bits()
-            | SegmentRegisterAttributeFlags::EXECUTABLE.bits()
-            | SegmentRegisterAttributeFlags::PRESENT.bits(),
+        SegmentRegisterAttributeFlags::ACCESSED
+            | SegmentRegisterAttributeFlags::WRITABLE
+            | SegmentRegisterAttributeFlags::EXECUTABLE
+            | SegmentRegisterAttributeFlags::PRESENT,
     );
 }
 

litebox_platform_lvbs/src/mshv/mod.rs

@@ -142,7 +142,7 @@ bitflags::bitflags! {
 }
 
 bitflags::bitflags! {
-    #[derive(Debug, PartialEq)]
+    #[derive(Debug, PartialEq, Clone, Copy, Default)]
     pub struct SegmentRegisterAttributeFlags: u16 {
         const ACCESSED = 1 << 0;
         const WRITABLE = 1 << 1;
@@ -166,13 +166,7 @@ pub struct HvX64SegmentRegister {
     pub base: u64,
     pub limit: u32,
     pub selector: u16,
-
-    _attributes: u16,
-    // union of
-    // segment_type: 4, non_system_segment: 1,
-    // descriptor_privilege_level: 2, present: 1,
-    // reserved: 4, available: 1, _long: 1,
-    // _default: 1, granularity: 1
+    pub attributes: SegmentRegisterAttributeFlags,
 }
 
 impl HvX64SegmentRegister {
@@ -183,9 +177,12 @@ impl HvX64SegmentRegister {
         }
     }
 
-    #[expect(clippy::used_underscore_binding)]
-    pub fn set_attributes(&mut self, attrs: u16) {
-        self._attributes = attrs;
+    pub fn set_attributes(&mut self, attrs: SegmentRegisterAttributeFlags) {
+        self.attributes = attrs;
+    }
+
+    pub fn get_attributes(&self) -> SegmentRegisterAttributeFlags {
+        self.attributes
     }
 }
 
@@ -259,11 +256,6 @@ impl HvInputVtl {
     pub fn target_vtl_value(&self) -> u8 {
         self.target_vtl() as u8
     }
-
-    /// Sets the target VTL from a u8 value
-    pub fn set_target_vtl_value(&mut self, target_vtl: u8) {
-        self.set_target_vtl(target_vtl.into());
-    }
 }
 
 #[derive(Default, Clone, Copy)]
@@ -390,13 +382,6 @@ pub struct HvNestedEnlightenmentsControlFeatures {
     __: B31,
 }
 
-impl HvNestedEnlightenmentsControlFeatures {
-    /// Set direct hypercall flag from u32 (for compatibility)
-    pub fn set_direct_hypercall_u32(&mut self, direct_hypercall: u32) {
-        self.set_direct_hypercall(direct_hypercall != 0);
-    }
-}
-
 #[bitfield]
 #[derive(Clone, Copy, Default)]
 #[repr(C)]
@@ -406,13 +391,6 @@ pub struct HvNestedEnlightenmentsControlHypercallControls {
     __: B31,
 }
 
-impl HvNestedEnlightenmentsControlHypercallControls {
-    /// Set inter partition comm flag from u32 (for compatibility)
-    pub fn set_inter_partition_comm_u32(&mut self, inter_partition_comm: u32) {
-        self.set_inter_partition_comm(inter_partition_comm != 0);
-    }
-}
-
 #[expect(non_snake_case)]
 #[derive(Default, Clone, Copy)]
 #[repr(C, packed)]
@@ -523,16 +501,6 @@ impl HvRegisterVsmVpSecureVtlConfig {
     pub fn as_u64(&self) -> u64 {
         u64::from_le_bytes(self.into_bytes())
     }
-
-    /// Enable MBEC (for compatibility)
-    pub fn set_mbec_enabled_flag(&mut self) {
-        self.set_mbec_enabled(true);
-    }
-
-    /// Enable TLB locked (for compatibility)
-    pub fn set_tlb_locked_flag(&mut self) {
-        self.set_tlb_locked(true);
-    }
 }
 
 #[bitfield]
@@ -565,11 +533,6 @@ impl HvRegisterVsmPartitionConfig {
         Self::from_bytes(value.to_le_bytes())
     }
 
-    /// Set the default VTL protection mask from a u64 value
-    pub fn set_default_vtl_protection_mask_value(&mut self, mask: u64) {
-        self.set_default_vtl_protection_mask((mask as u8).into());
-    }
-
     /// Get the default VTL protection mask as a u64 value
     pub fn default_vtl_protection_mask_value(&self) -> u64 {
         self.default_vtl_protection_mask() as u64
@@ -756,26 +719,6 @@ impl HvSynicSint {
     pub fn as_uint64(&self) -> u64 {
         u64::from_le_bytes(self.into_bytes())
     }
-
-    /// Set vector from u64 (for compatibility)
-    pub fn set_vector_u64(&mut self, vector: u64) {
-        self.set_vector((vector as u8).into());
-    }
-
-    /// Set masked flag (for compatibility)
-    pub fn set_masked_flag(&mut self) {
-        self.set_masked(true);
-    }
-
-    /// Set auto_eoi flag (for compatibility)
-    pub fn set_auto_eoi_flag(&mut self) {
-        self.set_auto_eoi(true);
-    }
-
-    /// Set polling flag (for compatibility)
-    pub fn set_polling_flag(&mut self) {
-        self.set_polling(true);
-    }
 }
 
 #[derive(Default, Clone, Copy)]
@@ -868,31 +811,6 @@ impl HvPendingExceptionEvent {
     pub fn as_u64(&self) -> u64 {
         u64::from_le_bytes(self.into_bytes())
     }
-
-    /// Set event pending flag (for compatibility)
-    pub fn set_event_pending_flag(&mut self) {
-        self.set_event_pending(true);
-    }
-
-    /// Set event type from u64 (for compatibility)
-    pub fn set_event_type_u64(&mut self, event_type: u64) {
-        self.set_event_type((event_type as u8).into());
-    }
-
-    /// Set deliver error code flag (for compatibility)
-    pub fn set_deliver_error_code_flag(&mut self) {
-        self.set_deliver_error_code(true);
-    }
-
-    /// Set vector from u64 (for compatibility)
-    pub fn set_vector_u64(&mut self, vector: u64) {
-        self.set_vector((vector as u16).into());
-    }
-
-    /// Set error code from u64 (for compatibility)
-    pub fn set_error_code_u64(&mut self, error_code: u64) {
-        self.set_error_code((error_code as u32).into());
-    }
 }
 
 #[cfg(test)]
@@ -914,7 +832,7 @@ mod tests {
 
         // Test individual field manipulation
         let mut vtl = HvInputVtl::new();
-        vtl.set_target_vtl_value(10);
+        vtl.set_target_vtl(10_u8.into());
         vtl.set_use_target_vtl(true);
         assert_eq!(vtl.target_vtl_value(), 10);
         assert_eq!(vtl.use_target_vtl(), true);
@@ -949,7 +867,7 @@ mod tests {
         assert_eq!(config.intercept_page(), true);
 
         // Test the 4-bit protection mask field
-        config.set_default_vtl_protection_mask_value(0b1010);
+        config.set_default_vtl_protection_mask((0b1010_u8).into());
         assert_eq!(config.default_vtl_protection_mask_value(), 0b1010);
 
         // Test size - should be 8 bytes (64 bits)
@@ -991,12 +909,12 @@ mod tests {
         features.set_direct_hypercall(true);
         assert_eq!(features.direct_hypercall(), true);
 
-        // Test compatibility method
+        // Test direct method
         let mut features2 = HvNestedEnlightenmentsControlFeatures::new();
-        features2.set_direct_hypercall_u32(1);
+        features2.set_direct_hypercall(true);
         assert_eq!(features2.direct_hypercall(), true);
 
-        features2.set_direct_hypercall_u32(0);
+        features2.set_direct_hypercall(false);
         assert_eq!(features2.direct_hypercall(), false);
 
         // Test size - should be 4 bytes (32 bits)
@@ -1017,12 +935,12 @@ mod tests {
         controls.set_inter_partition_comm(true);
         assert_eq!(controls.inter_partition_comm(), true);
 
-        // Test compatibility method
+        // Test direct method
         let mut controls2 = HvNestedEnlightenmentsControlHypercallControls::new();
-        controls2.set_inter_partition_comm_u32(1);
+        controls2.set_inter_partition_comm(true);
         assert_eq!(controls2.inter_partition_comm(), true);
 
-        controls2.set_inter_partition_comm_u32(0);
+        controls2.set_inter_partition_comm(false);
         assert_eq!(controls2.inter_partition_comm(), false);
 
         // Test size - should be 4 bytes (32 bits)
@@ -1046,12 +964,12 @@ mod tests {
         config.set_tlb_locked(true);
         assert_eq!(config.tlb_locked(), true);
 
-        // Test compatibility methods
+        // Test direct methods
         let mut config2 = HvRegisterVsmVpSecureVtlConfig::new();
-        config2.set_mbec_enabled_flag();
+        config2.set_mbec_enabled(true);
         assert_eq!(config2.mbec_enabled(), true);
 
-        config2.set_tlb_locked_flag();
+        config2.set_tlb_locked(true);
         assert_eq!(config2.tlb_locked(), true);
 
         // Test size - should be 8 bytes (64 bits)
@@ -1088,18 +1006,18 @@ mod tests {
         sint.set_polling(true);
         assert_eq!(sint.polling(), true);
 
-        // Test compatibility methods
+        // Test direct methods
         let mut sint2 = HvSynicSint::new();
-        sint2.set_vector_u64(0xf3);
+        sint2.set_vector((0xf3_u8).into());
         assert_eq!(sint2.vector() as u8, 0xf3);
 
-        sint2.set_masked_flag();
+        sint2.set_masked(true);
         assert_eq!(sint2.masked(), true);
 
-        sint2.set_auto_eoi_flag();
+        sint2.set_auto_eoi(true);
         assert_eq!(sint2.auto_eoi(), true);
 
-        sint2.set_polling_flag();
+        sint2.set_polling(true);
         assert_eq!(sint2.polling(), true);
 
         // Test size - should be 8 bytes (64 bits)
@@ -1140,21 +1058,21 @@ mod tests {
         exception.set_error_code(0x87654321_u32.into());  // 32 bits
         assert_eq!(exception.error_code() as u32, 0x87654321);
 
-        // Test compatibility methods
+        // Test direct methods
         let mut exception2 = HvPendingExceptionEvent::new();
-        exception2.set_event_pending_flag();
+        exception2.set_event_pending(true);
         assert_eq!(exception2.event_pending(), true);
 
-        exception2.set_deliver_error_code_flag();
+        exception2.set_deliver_error_code(true);
         assert_eq!(exception2.deliver_error_code(), true);
 
-        exception2.set_event_type_u64(7);
+        exception2.set_event_type((7_u8).into());
         assert_eq!(exception2.event_type() as u8, 7);
 
-        exception2.set_vector_u64(0xabcd);
+        exception2.set_vector((0xabcd_u16).into());
         assert_eq!(exception2.vector() as u16, 0xabcd);
 
-        exception2.set_error_code_u64(0x12345678);
+        exception2.set_error_code((0x12345678_u32).into());
         assert_eq!(exception2.error_code() as u32, 0x12345678);
 
         // Test size - should be 8 bytes (64 bits)

litebox_platform_lvbs/src/mshv/vsm.rs

@@ -167,8 +167,8 @@ pub fn mshv_vsm_secure_config_vtl0() -> Result<i64, Errno> {
     debug_serial_println!("VSM: Secure VTL0 configuration");
 
     let mut config = HvRegisterVsmVpSecureVtlConfig::new();
-    config.set_mbec_enabled_flag();
-    config.set_tlb_locked_flag();
+    config.set_mbec_enabled(true);
+    config.set_tlb_locked(true);
 
     hvcall_set_vp_registers(HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL0, config.as_u64())
         .map_err(|_| Errno::EFAULT)?;
@@ -181,7 +181,7 @@ pub fn mshv_vsm_configure_partition() -> Result<i64, Errno> {
     debug_serial_println!("VSM: Configure partition");
 
     let mut config = HvRegisterVsmPartitionConfig::new();
-    config.set_default_vtl_protection_mask_value(HvPageProtFlags::HV_PAGE_FULL_ACCESS.bits().into());
+    config.set_default_vtl_protection_mask((HvPageProtFlags::HV_PAGE_FULL_ACCESS.bits() as u8).into());
     config.set_enable_vtl_protection(true);
 
     hvcall_set_vp_registers(HV_REGISTER_VSM_PARTITION_CONFIG, config.as_u64())

litebox_platform_lvbs/src/mshv/vsm_intercept.rs

@@ -147,13 +147,11 @@ fn advance_vtl0_rip(int_msg_hdr: &HvInterceptMessageHeader) -> Result<u64, Hyper
 #[inline]
 fn raise_vtl0_gp_fault() -> Result<u64, HypervCallError> {
     let mut exception = HvPendingExceptionEvent::new();
-    exception.set_event_pending_flag();
-    exception.set_event_type_u64(0);
-    exception.set_deliver_error_code_flag();
-    exception.set_vector_u64(u64::from(
-        x86_64::structures::idt::ExceptionVector::GeneralProtection as u8,
-    ));
-    exception.set_error_code_u64(0);
+    exception.set_event_pending(true);
+    exception.set_event_type(0_u8.into());
+    exception.set_deliver_error_code(true);
+    exception.set_vector((x86_64::structures::idt::ExceptionVector::GeneralProtection as u8 as u16).into());
+    exception.set_error_code(0_u32.into());
 
     hvcall_set_vp_vtl0_registers(HV_REGISTER_PENDING_EVENT0, exception.as_u64())
 }