Enum hypervisor::ProtectionType

pub enum ProtectionType {
    Unprotected,
    Protected,
    ProtectedWithCustomFirmware,
    ProtectedWithoutFirmware,
    UnprotectedWithFirmware,
}

Whether the VM should be run in protected mode or not.

Variants

Unprotected

The VM should be run in the unprotected mode, where the host has access to its memory.

Protected

The VM should be run in protected mode, so the host cannot access its memory directly. It should be booted via the protected VM firmware, so that it can access its secrets.

ProtectedWithCustomFirmware

The VM should be run in protected mode, so the host cannot access its memory directly. It should be booted via a custom VM firmware, useful for debugging and testing.

ProtectedWithoutFirmware

The VM should be run in protected mode, but booted directly without pVM firmware. The host will still be unable to access the VM memory, but it won’t be given any secrets.

UnprotectedWithFirmware

The VM should be run in unprotected mode, but with the same memory layout as protected mode, protected VM firmware loaded, and simulating protected mode as much as possible. This is useful for debugging the protected VM firmware and other protected mode issues.

Implementations

impl ProtectionType

pub fn isolates_memory(&self) -> bool

Returns whether the hypervisor will prevent us from accessing the VM’s memory.

pub fn needs_firmware_loaded(&self) -> bool

Returns whether the VMM needs to load the pVM firmware.

pub fn runs_firmware(&self) -> bool

Returns whether the VM runs a pVM firmware.

Trait Implementations

impl Clone for ProtectionType

fn clone(&self) -> ProtectionType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProtectionType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProtectionType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProtectionType

fn eq(&self, other: &ProtectionType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProtectionType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ProtectionType

impl Eq for ProtectionType

impl StructuralPartialEq for ProtectionType