Struct linux_kvm::VirtualCpu

pub struct VirtualCpu<'a> { /* private fields */ }

A virtual CPU belonging to a VirtualMachine.

Implementations

impl<'a> VirtualCpu<'a>

pub fn get_regs(&self) -> Result<kvm_regs>

Get the architecture-specific representation of the current register values of this vCPU.

pub fn set_regs(&self, new: &kvm_regs) -> Result<()>

Set the architecture-specific representation of the current register values of this vCPU.

pub fn to_runner(self) -> Result<VirtualCpuRunner<'a>>

Wrap this CPU into an object that has the necessary extra state to run it.

This encapsulates the step of using mmap on the VCPU file descriptor to establish a shared memory space with the KVM subsystem, so failure here represents failure of either that mmap operation or the ioctl call to discover its parameters.

Examples found in repository

examples/kvm-vm-setup.rs (line 46)

fn run() -> linux_io::result::Result<()> {
    let kvm = Kvm::open()?;
    println!("opened KVM subsystem: {:?}", &kvm);
    let version = kvm.get_api_version()?;
    if version != 12 {
        eprintln!("unsupported KVM API version {}", version);
        return Err(linux_io::result::Error::new(25));
    }
    let mut vm = kvm.create_vm()?;
    println!("created a VM: {:?}", &vm);

    let mut mem = MemoryRegion::new(0x1000)?;
    println!("created a memory region: {:?}", &mem);

    {
        let mem_data = mem.as_mut_slice();

        #[cfg(target_arch = "x86_64")]
        {
            // "UD2" explicitly-undefined instruction
            mem_data[0] = 0x0f;
            mem_data[1] = 0x0b;
        }

        #[cfg(target_arch = "aarch64")]
        {
            // "udf" explicitly-undefined instruction
            mem_data[0] = 0x01;
            mem_data[1] = 0x00;
            mem_data[2] = 0x00;
            mem_data[3] = 0x00;
        }
    }

    vm.set_guest_memory_region(0, KVM_MEM_READONLY, 0x1000, &mut mem)?;
    println!("registered the memory region with the VM");

    let cpu = vm.create_vcpu(0)?;
    println!("created a VCPU: {:?}", &cpu);
    let mut runner = cpu.to_runner()?;
    println!("created a VCPU runner: {:?}", &runner);
    runner.with_raw_run_state(|state| println!("run state: {:?}", &state));

    runner.modify_regs(|regs| {
        #[cfg(target_arch = "x86_64")]
        {
            regs.rip = 0x1000;
        }
        #[cfg(target_arch = "aarch64")]
        {
            regs.regs.pc = 0x1000;
        }
    })?;
    println!("set initial register values");

    #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
    {
        runner.run_raw()?;
        runner.with_raw_run_state(|state| println!("run state after running: {:?}", &state));
        let regs = runner.get_regs()?;
        println!("registers after running: {:?}", &regs)
    }

    Ok(())
}

Trait Implementations

impl<'a> Debug for VirtualCpu<'a>

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

Formats the value using the given formatter.