Struct VirtualCpu

Source

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

Expand description

A virtual CPU belonging to a VirtualMachine.

Implementations§

Source §

impl<'a> VirtualCpu<'a>

Source

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

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

Source

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

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

Source

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)

7fn run() -> linux_io::result::Result<()> {
8    let kvm = Kvm::open()?;
9    println!("opened KVM subsystem: {:?}", &kvm);
10    let version = kvm.get_api_version()?;
11    if version != 12 {
12        eprintln!("unsupported KVM API version {}", version);
13        return Err(linux_io::result::Error::new(25));
14    }
15    let mut vm = kvm.create_vm()?;
16    println!("created a VM: {:?}", &vm);
17
18    let mut mem = MemoryRegion::new(0x1000)?;
19    println!("created a memory region: {:?}", &mem);
20
21    {
22        let mem_data = mem.as_mut_slice();
23
24        #[cfg(target_arch = "x86_64")]
25        {
26            // "UD2" explicitly-undefined instruction
27            mem_data[0] = 0x0f;
28            mem_data[1] = 0x0b;
29        }
30
31        #[cfg(target_arch = "aarch64")]
32        {
33            // "udf" explicitly-undefined instruction
34            mem_data[0] = 0x01;
35            mem_data[1] = 0x00;
36            mem_data[2] = 0x00;
37            mem_data[3] = 0x00;
38        }
39    }
40
41    vm.set_guest_memory_region(0, KVM_MEM_READONLY, 0x1000, &mut mem)?;
42    println!("registered the memory region with the VM");
43
44    let cpu = vm.create_vcpu(0)?;
45    println!("created a VCPU: {:?}", &cpu);
46    let mut runner = cpu.to_runner()?;
47    println!("created a VCPU runner: {:?}", &runner);
48    runner.with_raw_run_state(|state| println!("run state: {:?}", &state));
49
50    runner.modify_regs(|regs| {
51        #[cfg(target_arch = "x86_64")]
52        {
53            regs.rip = 0x1000;
54        }
55        #[cfg(target_arch = "aarch64")]
56        {
57            regs.regs.pc = 0x1000;
58        }
59    })?;
60    println!("set initial register values");
61
62    #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
63    {
64        runner.run_raw()?;
65        runner.with_raw_run_state(|state| println!("run state after running: {:?}", &state));
66        let regs = runner.get_regs()?;
67        println!("registers after running: {:?}", &regs)
68    }
69
70    Ok(())
71}