Use bitflags for flag fields

Signed-off-by: Maksym Pavlenko <pavlenko.maksym@gmail.com>

Author: mxpv

hv/Cargo.toml

@@ -9,6 +9,8 @@ license-file = "../LICENSE"
 readme = "../README.md"
 
 [dependencies]
+bitflags = "1.2"
+
 hv-sys = { path = "../hv-sys", version = "0.1.0" }
 
 [features]

hv/examples/caps.rs

@@ -1,14 +1,14 @@
 fn main() {
-    hv::vm_create().unwrap();
+    hv::vm_create(hv::VmOptions::default()).unwrap();
 
     println!(
         "Max vCPUs: {}",
-        hv::capability(hv::Capability::VCpuMax).unwrap()
+        hv::capability(hv::Capability::VCPU_MAX).unwrap()
     );
 
     println!(
         "Available address spaces: {}",
-        hv::capability(hv::Capability::AddrSpaceMax).unwrap()
+        hv::capability(hv::Capability::ADDR_SPAC_EMAX).unwrap()
     );
 
     hv::vm_destroy().unwrap();

hv/src/lib.rs

@@ -24,13 +24,12 @@ macro_rules! call {
     }};
 }
 
-/// The type of system capabilities.
-#[repr(u32)]
-#[non_exhaustive]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum Capability {
-    VCpuMax = sys::HV_CAP_VCPUMAX,
-    AddrSpaceMax = sys::HV_CAP_ADDRSPACEMAX,
+bitflags::bitflags! {
+    /// The type of system capabilities.
+    pub struct Capability: u32 {
+        const VCPU_MAX = sys::HV_CAP_VCPUMAX;
+        const ADDR_SPAC_EMAX = sys::HV_CAP_ADDRSPACEMAX;
+    }
 }
 
 /// Type of a user virtual address.
@@ -44,25 +43,42 @@ pub type Space = sys::hv_vm_space_t;
 
 pub const VM_SPACE_DEFAULT: Space = sys::HV_VM_SPACE_DEFAULT;
 
-/// Guest physical memory region permissions.
-#[repr(u32)]
-#[non_exhaustive]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum Memory {
-    Read = sys::HV_MEMORY_READ,
-    Write = sys::HV_MEMORY_WRITE,
-    Exec = sys::HV_MEMORY_EXEC,
+bitflags::bitflags! {
+    /// Guest physical memory region permissions.
+    pub struct Memory: u32 {
+        const READ = sys::HV_MEMORY_READ;
+        const WRITE = sys::HV_MEMORY_WRITE;
+        const EXEC = sys::HV_MEMORY_EXEC;
+    }
+}
+
+bitflags::bitflags! {
+    pub struct VmOptions: u64 {
+        const DEFAULT = sys::HV_VM_DEFAULT as _;
+        const SPECIFY_MITIGATIONS = sys::HV_VM_SPECIFY_MITIGATIONS as _;
+        const MITIGATION_A_ENABLE = sys::HV_VM_MITIGATION_A_ENABLE as _;
+        const MITIGATION_B_ENABLE = sys::HV_VM_MITIGATION_B_ENABLE as _;
+        const MITIGATION_C_ENABLE = sys::HV_VM_MITIGATION_C_ENABLE as _;
+        const MITIGATION_D_ENABLE = sys::HV_VM_MITIGATION_D_ENABLE as _;
+        const MITIGATION_E_ENABLE = sys::HV_VM_MITIGATION_E_ENABLE as _;
+    }
+}
+
+impl Default for VmOptions {
+    fn default() -> Self {
+        VmOptions::DEFAULT
+    }
 }
 
 /// Creates a VM instance for the current process.
-pub fn vm_create() -> Result<(), Error> {
-    call!(sys::hv_vm_create(0))
+pub fn vm_create(options: VmOptions) -> Result<(), Error> {
+    call!(sys::hv_vm_create(options.bits))
 }
 
 /// Gets the value of capabilities of the system.
 pub fn capability(cap: Capability) -> Result<u64, Error> {
     let mut out = 0_u64;
-    call!(sys::hv_capability(cap as sys::hv_capability_t, &mut out))?;
+    call!(sys::hv_capability(cap.bits as u64, &mut out))?;
     Ok(out)
 }
 
@@ -92,12 +108,7 @@ pub fn vm_space_destroy(asid: Space) -> Result<(), Error> {
 /// * `size` - Size in bytes of the region to be mapped.
 /// * `flags` - READ, WRITE and EXECUTE permissions of the region
 pub fn vm_map(uva: UVAddr, gpa: GPAddr, size: u64, flags: Memory) -> Result<(), Error> {
-    call!(sys::hv_vm_map(
-        uva,
-        gpa,
-        size,
-        flags as sys::hv_memory_flags_t
-    ))
+    call!(sys::hv_vm_map(uva, gpa, size, flags.bits.into()))
 }
 
 /// Unmaps a region in the guest physical address space of the VM
@@ -116,11 +127,7 @@ pub fn vm_unmap(gpa: GPAddr, size: u64) -> Result<(), Error> {
 /// * `size` - Size in bytes of the region to be modified.
 /// * `flags` - New READ, WRITE and EXECUTE permissions of the region.
 pub fn vm_protect(gpa: GPAddr, size: u64, flags: Memory) -> Result<(), Error> {
-    call!(sys::hv_vm_protect(
-        gpa,
-        size,
-        flags as sys::hv_memory_flags_t
-    ))
+    call!(sys::hv_vm_protect(gpa, size, flags.bits.into()))
 }
 
 /// Maps a region in the virtual address space of the current task
@@ -145,7 +152,7 @@ pub fn vm_map_space(
         uva,
         gpa,
         size,
-        flags as sys::hv_memory_flags_t
+        flags.bits.into()
     ))
 }
 
@@ -169,12 +176,7 @@ pub fn vm_unmap_space(asid: Space, gpa: GPAddr, size: u64) -> Result<(), Error>
 /// * `flags` - New READ, WRITE and EXECUTE permissions of the region.
 #[cfg(feature = "hv_10_15")]
 pub fn vm_protect_space(asid: Space, gpa: GPAddr, size: u64, flags: Memory) -> Result<(), Error> {
-    call!(sys::hv_vm_protect_space(
-        asid,
-        gpa,
-        size,
-        flags as sys::hv_memory_flags_t
-    ))
+    call!(sys::hv_vm_protect_space(asid, gpa, size, flags.bits.into()))
 }
 
 /// Synchronizes guest TSC across all vCPUs.

hv/src/vcpu.rs

@@ -1,7 +1,7 @@
 use std::ffi::c_void;
 use std::mem;
 
-use crate::{call, sys, vmx, x86, Error, Space};
+use crate::{call, sys, Error, Space};
 
 /// Represents a single virtual CPU.
 ///
@@ -81,7 +81,9 @@ impl Drop for Vcpu {
     }
 }
 
-impl x86::VcpuExt for Vcpu {
+use crate::x86;
+
+impl x86::VCpuX86Ext for Vcpu {
     /// Returns the current value of an architectural x86 register of a vCPU.
     fn read_register(&self, reg: x86::Reg) -> Result<u64, Error> {
         let mut value = 0_u64;
@@ -122,40 +124,50 @@ impl x86::VcpuExt for Vcpu {
     }
 }
 
-impl vmx::VcpuExt for Vcpu {
+use crate::vmx;
+
+impl vmx::VCpuVmxExt for Vcpu {
     /// Returns the current value of a VMCS field of a vCPU.
-    fn read_vmcs(&self, field: u32) -> Result<u64, Error> {
+    fn read_vmcs(&self, field: vmx::Vmcs) -> Result<u64, Error> {
         let mut out = 0_u64;
-        call!(sys::hv_vmx_vcpu_read_vmcs(self.0, field, &mut out))?;
+        call!(sys::hv_vmx_vcpu_read_vmcs(self.0, field as u32, &mut out))?;
         Ok(out)
     }
 
     /// Set the value of a VMCS field of a vCPU.
-    fn write_vmcs(&self, field: u32, value: u64) -> Result<(), Error> {
-        call!(sys::hv_vmx_vcpu_write_vmcs(self.0, field, value))
+    fn write_vmcs(&self, field: vmx::Vmcs, value: u64) -> Result<(), Error> {
+        call!(sys::hv_vmx_vcpu_write_vmcs(self.0, field as u32, value))
     }
 
     /// Returns the current value of a shadow VMCS field of a vCPU.
     #[cfg(feature = "hv_10_15")]
-    fn read_shadow_vmcs(&self, field: u32) -> Result<u64, Error> {
+    fn read_shadow_vmcs(&self, field: vmx::Vmcs) -> Result<u64, Error> {
         let mut out = 0_u64;
-        call!(sys::hv_vmx_vcpu_read_shadow_vmcs(self.0, field, &mut out))?;
+        call!(sys::hv_vmx_vcpu_read_shadow_vmcs(
+            self.0,
+            field as u32,
+            &mut out
+        ))?;
         Ok(out)
     }
 
     /// Set the value of a shadow VMCS field of a vCPU.
     #[cfg(feature = "hv_10_15")]
-    fn write_shadow_vmcs(&self, field: u32, value: u64) -> Result<(), Error> {
-        call!(sys::hv_vmx_vcpu_write_shadow_vmcs(self.0, field, value))
+    fn write_shadow_vmcs(&self, field: vmx::Vmcs, value: u64) -> Result<(), Error> {
+        call!(sys::hv_vmx_vcpu_write_shadow_vmcs(
+            self.0,
+            field as u32,
+            value
+        ))
     }
 
     /// Set the access permissions of a shadow VMCS field of a vCPU.
     #[cfg(feature = "hv_10_15")]
-    fn set_shadow_access(&self, field: u32, flags: crate::vmx::ShadowFlags) -> Result<(), Error> {
+    fn set_shadow_access(&self, field: vmx::Vmcs, flags: vmx::ShadowFlags) -> Result<(), Error> {
         call!(sys::hv_vmx_vcpu_set_shadow_access(
             self.0,
-            field,
-            flags as sys::hv_shadow_flags_t
+            field as u32,
+            flags.bits() as u64
         ))
     }
 }

hv/src/vmx.rs

@@ -2,8 +2,6 @@
 
 use crate::{call, sys, Error};
 
-pub type Capacility = sys::hv_vmx_capability_t;
-
 /// Enum type of VMX cabability fields
 #[repr(u32)]
 #[non_exhaustive]
@@ -24,39 +22,39 @@ pub enum Capability {
 }
 
 /// Returns the VMX capabilities of the host processor.
-pub fn read_capability(field: Capacility) -> Result<u64, Error> {
+pub fn read_capability(field: Capability) -> Result<u64, Error> {
     let mut out = 0_u64;
-    call!(sys::hv_vmx_read_capability(field, &mut out))?;
+    call!(sys::hv_vmx_read_capability(field as u32, &mut out))?;
     Ok(out)
 }
 
-#[cfg(feature = "hv_10_15")]
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum ShadowFlags {
-    None = sys::HV_SHADOW_VMCS_NONE,
-    Read = sys::HV_SHADOW_VMCS_READ,
-    Write = sys::HV_SHADOW_VMCS_WRITE,
+bitflags::bitflags! {
+    #[cfg(feature = "hv_10_15")]
+    pub struct ShadowFlags: u32 {
+        const NONE = sys::HV_SHADOW_VMCS_NONE;
+        const READ = sys::HV_SHADOW_VMCS_READ;
+        const WRITE = sys::HV_SHADOW_VMCS_WRITE;
+    }
 }
 
-pub trait VcpuExt {
+pub trait VCpuVmxExt {
     /// Returns the current value of a VMCS field of a vCPU.
-    fn read_vmcs(&self, field: u32) -> Result<u64, Error>;
+    fn read_vmcs(&self, field: Vmcs) -> Result<u64, Error>;
 
     /// Set the value of a VMCS field of a vCPU.
-    fn write_vmcs(&self, field: u32, value: u64) -> Result<(), Error>;
+    fn write_vmcs(&self, field: Vmcs, value: u64) -> Result<(), Error>;
 
     /// Returns the current value of a shadow VMCS field of a vCPU.
     #[cfg(feature = "hv_10_15")]
-    fn read_shadow_vmcs(&self, field: u32) -> Result<u64, Error>;
+    fn read_shadow_vmcs(&self, field: Vmcs) -> Result<u64, Error>;
 
     /// Set the value of a shadow VMCS field of a vCPU.
     #[cfg(feature = "hv_10_15")]
-    fn write_shadow_vmcs(&self, field: u32, value: u64) -> Result<(), Error>;
+    fn write_shadow_vmcs(&self, field: Vmcs, value: u64) -> Result<(), Error>;
 
     /// Set the access permissions of a shadow VMCS field of a vCPU.
     #[cfg(feature = "hv_10_15")]
-    fn set_shadow_access(&self, field: u32, flags: ShadowFlags) -> Result<(), Error>;
+    fn set_shadow_access(&self, field: Vmcs, flags: ShadowFlags) -> Result<(), Error>;
 }
 
 /// Virtual Machine Control Structure (VMCS) Field IDs.

hv/src/x86.rs

@@ -3,7 +3,7 @@
 use crate::{sys, Error};
 
 /// x86 specific routines for vCPU.
-pub trait VcpuExt {
+pub trait VCpuX86Ext {
     /// Returns the current value of an architectural x86 register of a vCPU.
     fn read_register(&self, reg: Reg) -> Result<u64, Error>;