1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
// Copyright 2017 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
use kvm::*;
use kvm_sys::kvm_regs;
use sys_util::{GuestAddress, GuestMemory, MemoryMapping, SharedMemory};
#[test]
fn test_run() {
/*
0000 268A07 mov al,[es:bx]
0003 0401 add al,0x1
0005 268807 mov [es:bx],al
0008 F4 hlt
*/
let code = [0x26, 0x8a, 0x07, 0x04, 0x01, 0x26, 0x88, 0x07, 0xf4];
let mem_size = 0x2000;
let load_addr = GuestAddress(0x1000);
let guest_mem = GuestMemory::new(&[]).unwrap();
let mut mem = SharedMemory::anon().expect("failed to create shared memory");
mem.set_size(mem_size)
.expect("failed to set shared memory size");
let mmap =
MemoryMapping::from_fd(&mem, mem_size as usize).expect("failed to create memory mapping");
mmap.write_slice(&code[..], load_addr.offset() as usize)
.expect("Writing code to memory failed.");
let kvm = Kvm::new().expect("new kvm failed");
let mut vm = Vm::new(&kvm, guest_mem).expect("new vm failed");
let vcpu = Vcpu::new(0, &kvm, &vm).expect("new vcpu failed");
let mut vcpu_sregs = vcpu.get_sregs().expect("get sregs failed");
vcpu_sregs.cs.base = 0;
vcpu_sregs.cs.selector = 0;
vcpu_sregs.es.base = 0x3000;
vcpu_sregs.es.selector = 0;
vcpu.set_sregs(&vcpu_sregs).expect("set sregs failed");
let mut vcpu_regs: kvm_regs = unsafe { std::mem::zeroed() };
vcpu_regs.rip = load_addr.offset() as u64;
vcpu_regs.rflags = 2;
vcpu_regs.rax = 0x66;
vcpu_regs.rbx = 0;
vcpu.set_regs(&vcpu_regs).expect("set regs failed");
vm.add_mmio_memory(
GuestAddress(0),
MemoryMapping::from_fd(&mem, mem_size as usize).expect("failed to create memory mapping"),
false,
false,
)
.expect("failed to register memory");
// Give some read only memory for the test code to read from and force a vcpu exit when it reads
// from it.
let mut mem_ro = SharedMemory::anon().expect("failed to create shared memory");
mem_ro
.set_size(0x1000)
.expect("failed to set shared memory size");
let mmap_ro = MemoryMapping::from_fd(&mem_ro, 0x1000).expect("failed to create memory mapping");
mmap_ro
.write_obj(vcpu_regs.rax as u8, 0)
.expect("failed writing data to ro memory");
vm.add_mmio_memory(
GuestAddress(vcpu_sregs.es.base),
MemoryMapping::from_fd(&mem_ro, 0x1000).expect("failed to create memory mapping"),
true,
false,
)
.expect("failed to register memory");
// Ensure we get exactly 1 exit from attempting to write to read only memory.
let mut exits = 0;
let runnable_vcpu = vcpu.to_runnable(None).unwrap();
loop {
match runnable_vcpu.run().expect("run failed") {
VcpuExit::Hlt => break,
VcpuExit::MmioWrite {
address,
size: 1,
data,
} => {
assert_eq!(address, vcpu_sregs.es.base);
assert_eq!(data[0] as u64, vcpu_regs.rax + 1);
exits += 1;
}
r => panic!("unexpected exit reason: {:?}", r),
}
}
// Check that exactly 1 attempt to write to read only memory was made, and that the memory is
// unchanged after that attempt.
assert_eq!(exits, 1);
assert_eq!(
mmap_ro
.read_obj::<u8>(0)
.expect("failed to read data from ro memory"),
vcpu_regs.rax as u8
);
}
|