1 // Copyright 2020 The ChromiumOS Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // TODO(b/237714823): Currently, only kvm is enabled for this test once LUCI can run windows.
6 #![cfg(any(target_os = "android", target_os = "linux"))]
7 #![cfg(target_arch = "x86_64")]
8
9 use std::arch::x86_64::_rdtsc;
10
11 use hypervisor::*;
12 use vm_memory::GuestAddress;
13 use vm_memory::GuestMemory;
14
15 macro_rules! assert_wrapping_close {
16 ($value:expr, $expected: expr, $threshold: expr, $type: expr) => {
17 let e = $expected;
18 let v = $value;
19 let wrapping_diff = std::cmp::min(v.wrapping_sub(e), e.wrapping_sub(v));
20 assert!(
21 wrapping_diff < $threshold,
22 "{} value {} too far from {}",
23 $type,
24 $value,
25 $expected
26 );
27 };
28 }
29
30 #[test]
31 #[cfg(any(target_os = "android", target_os = "linux"))]
test_kvm_tsc_offsets()32 fn test_kvm_tsc_offsets() {
33 use hypervisor::kvm::*;
34 test_tsc_offsets(|guest_mem| {
35 let kvm = Kvm::new().expect("failed to create kvm");
36 let vm = KvmVm::new(&kvm, guest_mem, Default::default()).expect("failed to create vm");
37 (kvm, vm)
38 });
39 }
40
41 #[test]
42 #[cfg(all(windows, feature = "haxm"))]
test_haxm_tsc_offsets()43 fn test_haxm_tsc_offsets() {
44 use hypervisor::haxm::*;
45 test_tsc_offsets(|guest_mem| {
46 let haxm = Haxm::new().expect("failed to create haxm");
47 let vm = HaxmVm::new(&haxm, guest_mem).expect("failed to create vm");
48 (haxm, vm)
49 });
50 }
51
52 #[test]
53 #[cfg(feature = "gvm")]
test_gvm_tsc_offsets()54 fn test_gvm_tsc_offsets() {
55 use hypervisor::gvm::*;
56 test_tsc_offsets(|guest_mem| {
57 let gvm = Gvm::new().expect("failed to create gvm");
58 let vm = GvmVm::new(&gvm, guest_mem).expect("failed to create vm");
59 (gvm, vm)
60 });
61 }
62
63 #[test]
64 #[cfg(all(windows, feature = "whpx"))]
test_whpx_tsc_offsets()65 fn test_whpx_tsc_offsets() {
66 use hypervisor::whpx::*;
67 if !Whpx::is_enabled() {
68 return;
69 }
70 test_tsc_offsets(|guest_mem| {
71 let whpx = Whpx::new().expect("failed to create whpx");
72 let vm =
73 WhpxVm::new(&whpx, 1, guest_mem, CpuId::new(0), false).expect("failed to create vm");
74 (whpx, vm)
75 });
76 }
77
test_tsc_offsets<CreateVm, HypervisorT, VmT>(create_vm: CreateVm) where CreateVm: FnOnce(GuestMemory) -> (HypervisorT, VmT), HypervisorT: Hypervisor, VmT: VmX86_64,78 fn test_tsc_offsets<CreateVm, HypervisorT, VmT>(create_vm: CreateVm)
79 where
80 CreateVm: FnOnce(GuestMemory) -> (HypervisorT, VmT),
81 HypervisorT: Hypervisor,
82 VmT: VmX86_64,
83 {
84 // We're in real mode, so we need to do two memory operations to get a 64 bit value into
85 // memory.
86 /*
87 0x0000000000000000: 0F 31 rdtsc
88 0x0000000000000002: 67 66 89 51 04 mov dword ptr [ecx + 4], edx
89 0x0000000000000007: 67 66 89 01 mov dword ptr [ecx], eax
90 0x000000000000000b: F4 hlt
91 */
92
93 let code: [u8; 12] = [
94 0x0f, 0x31, 0x67, 0x66, 0x89, 0x51, 0x04, 0x67, 0x66, 0x89, 0x01, 0xf4,
95 ];
96 let mem_size = 0x4000;
97 let load_addr = GuestAddress(0x1000);
98
99 let guest_mem =
100 GuestMemory::new(&[(GuestAddress(0), mem_size)]).expect("failed to create guest mem");
101 guest_mem
102 .write_at_addr(&code[..], load_addr)
103 .expect("failed to write to guest memory");
104
105 let mem_clone = guest_mem.clone();
106
107 let (_, vm) = create_vm(guest_mem);
108 let mut vcpu = vm.create_vcpu(0).expect("new vcpu failed");
109 let mut vcpu_sregs = vcpu.get_sregs().expect("get sregs failed");
110 vcpu_sregs.cs.base = 0;
111 vcpu_sregs.cs.selector = 0;
112
113 vcpu.set_sregs(&vcpu_sregs).expect("set sregs failed");
114
115 // basic case, we set MSR to 0
116 // SAFETY: trivially safe
117 let tsc_now = unsafe { _rdtsc() };
118 test_tsc_offset_run(
119 &mut vcpu,
120 &mem_clone,
121 load_addr,
122 Some(0),
123 None,
124 u64::MAX - tsc_now + 1,
125 0,
126 );
127 // set offset to 0
128 // SAFETY: trivially safe
129 let tsc_now = unsafe { _rdtsc() };
130 test_tsc_offset_run(&mut vcpu, &mem_clone, load_addr, None, Some(0), 0, tsc_now);
131 // some moderately sized offset
132 // SAFETY: trivially safe
133 let tsc_now = unsafe { _rdtsc() };
134 let ten_seconds = 2_500_000_000 * 10;
135 test_tsc_offset_run(
136 &mut vcpu,
137 &mem_clone,
138 load_addr,
139 None,
140 Some(ten_seconds),
141 ten_seconds,
142 tsc_now + ten_seconds,
143 );
144 // set offset to u64::MAX - tsc_now + 1
145 // SAFETY: trivially safe
146 let tsc_now = unsafe { _rdtsc() };
147 test_tsc_offset_run(
148 &mut vcpu,
149 &mem_clone,
150 load_addr,
151 None,
152 Some(u64::MAX - tsc_now + 1),
153 u64::MAX - tsc_now + 1,
154 0,
155 );
156 }
157
test_tsc_offset_run( vcpu: &mut Box<dyn hypervisor::VcpuX86_64>, mem_clone: &GuestMemory, load_addr: GuestAddress, set_msr: Option<u64>, set_offset: Option<u64>, expected_get_offset: u64, expected_rdtsc: u64, )158 fn test_tsc_offset_run(
159 vcpu: &mut Box<dyn hypervisor::VcpuX86_64>,
160 mem_clone: &GuestMemory,
161 load_addr: GuestAddress,
162 set_msr: Option<u64>,
163 set_offset: Option<u64>,
164 expected_get_offset: u64,
165 expected_rdtsc: u64,
166 ) {
167 // typical TSC frequency is like 2.5GHz so if we say the threshold is within 100ms then our
168 // threshold is 250_000_000
169 let threshold = 250_000_000;
170
171 let vcpu_regs = Regs {
172 rip: load_addr.offset(),
173 rflags: 2,
174 rcx: 0x3000,
175 ..Default::default()
176 };
177 vcpu.set_regs(&vcpu_regs).expect("set regs failed");
178
179 if let Some(value) = set_msr {
180 vcpu.set_msr(0x00000010, value)
181 .expect("set_msr should not fail");
182 }
183
184 if let Some(offset) = set_offset {
185 vcpu.set_tsc_offset(offset)
186 .expect("set offset should not fail");
187 }
188
189 loop {
190 match vcpu.run().expect("run failed") {
191 VcpuExit::Hlt => {
192 break;
193 }
194 // Continue on external interrupt or signal
195 VcpuExit::Intr => continue,
196 r => panic!("unexpected exit reason: {:?}", r),
197 }
198 }
199
200 assert_wrapping_close!(
201 mem_clone
202 .read_obj_from_addr::<u64>(GuestAddress(0x3000))
203 .expect("guest mem read should be ok"),
204 expected_rdtsc,
205 threshold,
206 "rdtsc written to memory"
207 );
208
209 assert_wrapping_close!(
210 vcpu.get_tsc_offset().expect("get offset should not fail"),
211 expected_get_offset,
212 threshold,
213 "tsc offset"
214 );
215 }
216