mirror of
https://chromium.googlesource.com/crosvm/crosvm
synced 2024-11-25 13:23:08 +00:00
aecf9a4dee
In Rust 2018 edition, `extern crate` is no longer required for importing
from other crates. Instead of writing:
extern crate dep;
use dep::Thing;
we write:
use dep::Thing;
In this approach, macros are imported individually from the declaring
crate rather than through #[macro_use]. Before:
#[macro_use]
extern crate sys_util;
After:
use sys_util::{debug, error};
The only place that `extern crate` continues to be required is in
importing the compiler's proc_macro API into a procedural macro crate.
This will hopefully be fixed in a future Rust release.
extern crate proc_macro;
TEST=cargo check
TEST=cargo check --all-features
TEST=cargo check --target aarch64-unknown-linux-gnu
TEST=local kokoro
Change-Id: I0b43768c0d81f2a250b1959fb97ba35cbac56293
Reviewed-on: https://chromium-review.googlesource.com/1565302
Commit-Ready: David Tolnay <dtolnay@chromium.org>
Commit-Ready: ChromeOS CL Exonerator Bot <chromiumos-cl-exonerator@appspot.gserviceaccount.com>
Tested-by: David Tolnay <dtolnay@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: David Tolnay <dtolnay@chromium.org>
102 lines
3.5 KiB
Rust
102 lines
3.5 KiB
Rust
// 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::new(None).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_device_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::new(None).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_device_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;
|
|
|
|
loop {
|
|
match 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
|
|
);
|
|
}
|