dsg/cloud-hypervisor
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

build: treewide: fmt for edition 2024

Browse source 
`cargo +nightly fmt`

Signed-off-by: Philipp Schuster <philipp.schuster@cyberus-technology.de>
On-behalf-of: SAP philipp.schuster@sap.com
This commit is contained in:
Philipp Schuster 2025-08-12 12:59:23 +02:00 • committed by Bo Chen
parent 061351d82d
commit 363273111a
121 changed files with 781 additions and 663 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.rustfmt.toml
View file

@ -1,4 +1,4 @@
edition = "2021" edition = "2024"
group_imports="StdExternalCrate" group_imports="StdExternalCrate"
imports_granularity="Module" imports_granularity="Module"

2
arch/src/aarch64/mod.rs
View file

@ -15,7 +15,7 @@ use std::sync::{Arc, Mutex};
use hypervisor::arch::aarch64::gic::Vgic; use hypervisor::arch::aarch64::gic::Vgic;
use hypervisor::arch::aarch64::regs::MPIDR_EL1; use hypervisor::arch::aarch64::regs::MPIDR_EL1;
use log::{log_enabled, Level}; use log::{Level, log_enabled};
use thiserror::Error; use thiserror::Error;
use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic}; use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};

19
arch/src/lib.rs
View file

@ -81,9 +81,9 @@ pub mod aarch64;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
pub use aarch64::{ pub use aarch64::{
arch_memory_regions, configure_system, configure_vcpu, fdt::DeviceInfoForFdt, _NSIG, EntryPoint, arch_memory_regions, configure_system, configure_vcpu,
get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE, fdt::DeviceInfoForFdt, get_host_cpu_phys_bits, initramfs_load_addr, layout,
layout::IRQ_BASE, uefi, EntryPoint, _NSIG, layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi,
}; };
/// Module for riscv64 related functionality. /// Module for riscv64 related functionality.
@ -92,9 +92,9 @@ pub mod riscv64;
#[cfg(target_arch = "riscv64")] #[cfg(target_arch = "riscv64")]
pub use riscv64::{ pub use riscv64::{
arch_memory_regions, configure_system, configure_vcpu, fdt::DeviceInfoForFdt, _NSIG, EntryPoint, arch_memory_regions, configure_system, configure_vcpu,
get_host_cpu_phys_bits, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE, fdt::DeviceInfoForFdt, get_host_cpu_phys_bits, initramfs_load_addr, layout,
layout::IRQ_BASE, uefi, EntryPoint, _NSIG, layout::CMDLINE_MAX_SIZE, layout::IRQ_BASE, uefi,
}; };
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
@ -102,10 +102,9 @@ pub mod x86_64;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub use x86_64::{ pub use x86_64::{
arch_memory_regions, configure_system, configure_vcpu, generate_common_cpuid, _NSIG, CpuidConfig, CpuidFeatureEntry, EntryPoint, arch_memory_regions, configure_system,
generate_ram_ranges, get_host_cpu_phys_bits, initramfs_load_addr, layout, configure_vcpu, generate_common_cpuid, generate_ram_ranges, get_host_cpu_phys_bits,
layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START, regs, CpuidConfig, CpuidFeatureEntry, initramfs_load_addr, layout, layout::CMDLINE_MAX_SIZE, layout::CMDLINE_START, regs,
EntryPoint, _NSIG,
}; };
/// Safe wrapper for `sysconf(_SC_PAGESIZE)`. /// Safe wrapper for `sysconf(_SC_PAGESIZE)`.

2
arch/src/riscv64/mod.rs
View file

@ -15,7 +15,7 @@ use std::fmt::Debug;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use hypervisor::arch::riscv64::aia::Vaia; use hypervisor::arch::riscv64::aia::Vaia;
use log::{log_enabled, Level}; use log::{Level, log_enabled};
use thiserror::Error; use thiserror::Error;
use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic}; use vm_memory::{Address, GuestAddress, GuestMemory, GuestMemoryAtomic};

12
arch/src/x86_64/mod.rs
View file

@ -14,7 +14,7 @@ mod mptable;
pub mod regs; pub mod regs;
use std::mem; use std::mem;
use hypervisor::arch::x86::{CpuIdEntry, CPUID_FLAG_VALID_INDEX}; use hypervisor::arch::x86::{CPUID_FLAG_VALID_INDEX, CpuIdEntry};
use hypervisor::{CpuVendor, HypervisorCpuError, HypervisorError}; use hypervisor::{CpuVendor, HypervisorCpuError, HypervisorError};
use linux_loader::loader::bootparam::{boot_params, setup_header}; use linux_loader::loader::bootparam::{boot_params, setup_header};
use linux_loader::loader::elf::start_info::{ use linux_loader::loader::elf::start_info::{
@ -525,9 +525,13 @@ impl CpuidFeatureEntry {
error!( error!(
"Detected incompatible CPUID entry: leaf={:#02x} (subleaf={:#02x}), register='{:?}', \ "Detected incompatible CPUID entry: leaf={:#02x} (subleaf={:#02x}), register='{:?}', \
compatible_check='{:?}', source VM feature='{:#04x}', destination VM feature'{:#04x}'.", compatible_check='{:?}', source VM feature='{:#04x}', destination VM feature'{:#04x}'.",
entry.function, entry.index, entry.feature_reg, entry.function,
entry.compatible_check, src_vm_feature, dest_vm_feature entry.index,
); entry.feature_reg,
entry.compatible_check,
src_vm_feature,
dest_vm_feature
);
compatible = false; compatible = false;
} }

2
arch/src/x86_64/mptable.rs
View file

@ -12,9 +12,9 @@ use thiserror::Error;
use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError}; use vm_memory::{Address, ByteValued, Bytes, GuestAddress, GuestMemory, GuestMemoryError};
use super::MAX_SUPPORTED_CPUS_LEGACY; use super::MAX_SUPPORTED_CPUS_LEGACY;
use crate::GuestMemoryMmap;
use crate::layout::{APIC_START, HIGH_RAM_START, IOAPIC_START}; use crate::layout::{APIC_START, HIGH_RAM_START, IOAPIC_START};
use crate::x86_64::{get_x2apic_id, mpspec}; use crate::x86_64::{get_x2apic_id, mpspec};
use crate::GuestMemoryMmap;
// This is a workaround to the Rust enforcement specifying that any implementation of a foreign // This is a workaround to the Rust enforcement specifying that any implementation of a foreign
// trait (in this case `ByteValued`) where: // trait (in this case `ByteValued`) where:

2
arch/src/x86_64/smbios.rs
View file

@ -12,8 +12,8 @@ use thiserror::Error;
use uuid::Uuid; use uuid::Uuid;
use vm_memory::{Address, ByteValued, Bytes, GuestAddress}; use vm_memory::{Address, ByteValued, Bytes, GuestAddress};
use crate::layout::SMBIOS_START;
use crate::GuestMemoryMmap; use crate::GuestMemoryMmap;
use crate::layout::SMBIOS_START;
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum Error { pub enum Error {

2
block/src/fixed_vhd.rs
View file

@ -6,8 +6,8 @@ use std::fs::File;
use std::io::{Read, Seek, SeekFrom, Write}; use std::io::{Read, Seek, SeekFrom, Write};
use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::io::{AsRawFd, RawFd};
use crate::vhd::VhdFooter;
use crate::BlockBackend; use crate::BlockBackend;
use crate::vhd::VhdFooter;
#[derive(Debug)] #[derive(Debug)]
pub struct FixedVhd { pub struct FixedVhd {

2
block/src/fixed_vhd_sync.rs
View file

@ -7,12 +7,12 @@ use std::os::unix::io::{AsRawFd, RawFd};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::BlockBackend;
use crate::async_io::{ use crate::async_io::{
AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult, AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
}; };
use crate::fixed_vhd::FixedVhd; use crate::fixed_vhd::FixedVhd;
use crate::raw_sync::RawFileSync; use crate::raw_sync::RawFileSync;
use crate::BlockBackend;
pub struct FixedVhdDiskSync(FixedVhd); pub struct FixedVhdDiskSync(FixedVhd);

6
block/src/lib.rs
View file

@ -31,7 +31,7 @@ pub mod vhd;
pub mod vhdx; pub mod vhdx;
pub mod vhdx_sync; pub mod vhdx_sync;
use std::alloc::{alloc_zeroed, dealloc, Layout}; use std::alloc::{Layout, alloc_zeroed, dealloc};
use std::collections::VecDeque; use std::collections::VecDeque;
use std::fmt::Debug; use std::fmt::Debug;
use std::fs::File; use std::fs::File;
@ -44,8 +44,8 @@ use std::time::Instant;
use std::{cmp, result}; use std::{cmp, result};
#[cfg(feature = "io_uring")] #[cfg(feature = "io_uring")]
use io_uring::{opcode, IoUring, Probe}; use io_uring::{IoUring, Probe, opcode};
use libc::{ioctl, S_IFBLK, S_IFMT}; use libc::{S_IFBLK, S_IFMT, ioctl};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use smallvec::SmallVec; use smallvec::SmallVec;
use thiserror::Error; use thiserror::Error;

2
block/src/qcow/mod.rs
View file

@ -24,11 +24,11 @@ use vmm_sys_util::file_traits::{FileSetLen, FileSync};
use vmm_sys_util::seek_hole::SeekHole; use vmm_sys_util::seek_hole::SeekHole;
use vmm_sys_util::write_zeroes::{PunchHole, WriteZeroesAt}; use vmm_sys_util::write_zeroes::{PunchHole, WriteZeroesAt};
use crate::BlockBackend;
use crate::qcow::qcow_raw_file::QcowRawFile; use crate::qcow::qcow_raw_file::QcowRawFile;
pub use crate::qcow::raw_file::RawFile; pub use crate::qcow::raw_file::RawFile;
use crate::qcow::refcount::RefCount; use crate::qcow::refcount::RefCount;
use crate::qcow::vec_cache::{CacheMap, Cacheable, VecCache}; use crate::qcow::vec_cache::{CacheMap, Cacheable, VecCache};
use crate::BlockBackend;
/// Nesting depth limit for disk formats that can open other disk files. /// Nesting depth limit for disk formats that can open other disk files.
const MAX_NESTING_DEPTH: u32 = 10; const MAX_NESTING_DEPTH: u32 = 10;

2
block/src/qcow/raw_file.rs
View file

@ -8,7 +8,7 @@
// //
// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
use std::alloc::{alloc_zeroed, dealloc, Layout}; use std::alloc::{Layout, alloc_zeroed, dealloc};
use std::fs::{File, Metadata}; use std::fs::{File, Metadata};
use std::io::{self, Read, Seek, SeekFrom, Write}; use std::io::{self, Read, Seek, SeekFrom, Write};
use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::io::{AsRawFd, RawFd};

2
block/src/qcow/vec_cache.rs
View file

@ -4,8 +4,8 @@
// //
// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
use std::collections::hash_map::IterMut;
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::hash_map::IterMut;
use std::io; use std::io;
use std::ops::{Index, IndexMut}; use std::ops::{Index, IndexMut};
use std::slice::SliceIndex; use std::slice::SliceIndex;

2
block/src/qcow_sync.rs
View file

@ -9,11 +9,11 @@ use std::os::fd::AsRawFd;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::AsyncAdaptor;
use crate::async_io::{ use crate::async_io::{
AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult, AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
}; };
use crate::qcow::{QcowFile, RawFile, Result as QcowResult}; use crate::qcow::{QcowFile, RawFile, Result as QcowResult};
use crate::AsyncAdaptor;
pub struct QcowDiskSync { pub struct QcowDiskSync {
qcow_file: QcowFile, qcow_file: QcowFile,

2
block/src/raw_async.rs
View file

@ -6,7 +6,7 @@ use std::fs::File;
use std::io::{Error, Seek, SeekFrom}; use std::io::{Error, Seek, SeekFrom};
use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::io::{AsRawFd, RawFd};
use io_uring::{opcode, types, IoUring}; use io_uring::{IoUring, opcode, types};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::async_io::{ use crate::async_io::{

2
block/src/raw_async_aio.rs
View file

@ -12,10 +12,10 @@ use std::os::unix::io::{AsRawFd, RawFd};
use vmm_sys_util::aio; use vmm_sys_util::aio;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::DiskTopology;
use crate::async_io::{ use crate::async_io::{
AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult, AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
}; };
use crate::DiskTopology;
pub struct RawFileDiskAio { pub struct RawFileDiskAio {
file: File, file: File,

2
block/src/raw_sync.rs
View file

@ -9,10 +9,10 @@ use std::os::unix::io::{AsRawFd, RawFd};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::DiskTopology;
use crate::async_io::{ use crate::async_io::{
AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult, AsyncIo, AsyncIoError, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
}; };
use crate::DiskTopology;
pub struct RawFileDiskSync { pub struct RawFileDiskSync {
file: File, file: File,

4
block/src/vhd.rs
View file

@ -5,7 +5,7 @@
use std::fs::File; use std::fs::File;
use std::io::{Seek, SeekFrom}; use std::io::{Seek, SeekFrom};
use crate::{read_aligned_block_size, DiskTopology}; use crate::{DiskTopology, read_aligned_block_size};
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub struct VhdFooter { pub struct VhdFooter {
@ -123,7 +123,7 @@ mod tests {
use vmm_sys_util::tempfile::TempFile; use vmm_sys_util::tempfile::TempFile;
use super::{is_fixed_vhd, VhdFooter}; use super::{VhdFooter, is_fixed_vhd};
fn valid_fixed_vhd_footer() -> Vec<u8> { fn valid_fixed_vhd_footer() -> Vec<u8> {
vec![ vec![

2
block/src/vhdx/mod.rs
View file

@ -12,11 +12,11 @@ use remain::sorted;
use thiserror::Error; use thiserror::Error;
use uuid::Uuid; use uuid::Uuid;
use crate::BlockBackend;
use crate::vhdx::vhdx_bat::{BatEntry, VhdxBatError}; use crate::vhdx::vhdx_bat::{BatEntry, VhdxBatError};
use crate::vhdx::vhdx_header::{RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError}; use crate::vhdx::vhdx_header::{RegionInfo, RegionTableEntry, VhdxHeader, VhdxHeaderError};
use crate::vhdx::vhdx_io::VhdxIoError; use crate::vhdx::vhdx_io::VhdxIoError;
use crate::vhdx::vhdx_metadata::{DiskSpec, VhdxMetadataError}; use crate::vhdx::vhdx_metadata::{DiskSpec, VhdxMetadataError};
use crate::BlockBackend;
mod vhdx_bat; mod vhdx_bat;
mod vhdx_header; mod vhdx_header;

4
block/src/vhdx/vhdx_io.rs
View file

@ -35,9 +35,7 @@ pub enum VhdxIoError {
pub type Result<T> = std::result::Result<T, VhdxIoError>; pub type Result<T> = std::result::Result<T, VhdxIoError>;
macro_rules! align { macro_rules! align {
($n:expr, $align:expr) => {{ ($n:expr, $align:expr) => {{ $n.div_ceil($align) * $align }};
$n.div_ceil($align) * $align
}};
} }
#[derive(Default)] #[derive(Default)]

2
block/src/vhdx_sync.rs
View file

@ -8,11 +8,11 @@ use std::os::fd::AsRawFd;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::AsyncAdaptor;
use crate::async_io::{ use crate::async_io::{
AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult, AsyncIo, AsyncIoResult, BorrowedDiskFd, DiskFile, DiskFileError, DiskFileResult,
}; };
use crate::vhdx::{Result as VhdxResult, Vhdx}; use crate::vhdx::{Result as VhdxResult, Vhdx};
use crate::AsyncAdaptor;
pub struct VhdxDiskSync { pub struct VhdxDiskSync {
vhdx_file: Vhdx, vhdx_file: Vhdx,

4
devices/src/acpi.rs
View file

@ -8,9 +8,9 @@ use std::sync::{Arc, Barrier};
use std::thread; use std::thread;
use std::time::Instant; use std::time::Instant;
use acpi_tables::{aml, Aml, AmlSink}; use acpi_tables::{Aml, AmlSink, aml};
use vm_device::interrupt::InterruptSourceGroup;
use vm_device::BusDevice; use vm_device::BusDevice;
use vm_device::interrupt::InterruptSourceGroup;
use vm_memory::GuestAddress; use vm_memory::GuestAddress;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;

2
devices/src/gic.rs
View file

@ -9,8 +9,8 @@ use std::sync::{Arc, Mutex};
use anyhow::anyhow; use anyhow::anyhow;
use arch::layout; use arch::layout;
use hypervisor::arch::aarch64::gic::{GicState, Vgic, VgicConfig};
use hypervisor::CpuState; use hypervisor::CpuState;
use hypervisor::arch::aarch64::gic::{GicState, Vgic, VgicConfig};
use vm_device::interrupt::{ use vm_device::interrupt::{
InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup, InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
LegacyIrqSourceConfig, MsiIrqGroupConfig, LegacyIrqSourceConfig, MsiIrqGroupConfig,

2
devices/src/ioapic.rs
View file

@ -14,11 +14,11 @@ use std::sync::{Arc, Barrier};
use byteorder::{ByteOrder, LittleEndian}; use byteorder::{ByteOrder, LittleEndian};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use vm_device::BusDevice;
use vm_device::interrupt::{ use vm_device::interrupt::{
InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup, InterruptIndex, InterruptManager, InterruptSourceConfig, InterruptSourceGroup,
MsiIrqGroupConfig, MsiIrqSourceConfig, MsiIrqGroupConfig, MsiIrqSourceConfig,
}; };
use vm_device::BusDevice;
use vm_memory::GuestAddress; use vm_memory::GuestAddress;
use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable}; use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;

6
devices/src/ivshmem.rs
View file

@ -12,9 +12,9 @@ use std::sync::{Arc, Barrier, Mutex};
use anyhow::anyhow; use anyhow::anyhow;
use byteorder::{ByteOrder, LittleEndian}; use byteorder::{ByteOrder, LittleEndian};
use pci::{ use pci::{
BarReprogrammingParams, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, BarReprogrammingParams, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable,
PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass, PciBarRegionType, PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType,
PCI_CONFIGURATION_ID, PciSubclass,
}; };
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;

2
devices/src/legacy/cmos.rs
View file

@ -12,7 +12,7 @@ use std::{mem, thread};
// https://github.com/rust-lang/libc/issues/1848 // https://github.com/rust-lang/libc/issues/1848
#[cfg_attr(target_env = "musl", allow(deprecated))] #[cfg_attr(target_env = "musl", allow(deprecated))]
use libc::time_t; use libc::time_t;
use libc::{clock_gettime, gmtime_r, timespec, tm, CLOCK_REALTIME}; use libc::{CLOCK_REALTIME, clock_gettime, gmtime_r, timespec, tm};
use vm_device::BusDevice; use vm_device::BusDevice;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;

6
devices/src/legacy/fw_cfg.rs
View file

@ -20,6 +20,7 @@ use std::{
}; };
use acpi_tables::rsdp::Rsdp; use acpi_tables::rsdp::Rsdp;
use arch::RegionType;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use arch::aarch64::layout::{ use arch::aarch64::layout::{
MEM_32BIT_DEVICES_START, MEM_32BIT_RESERVED_START, RAM_64BIT_START, RAM_START as HIGH_RAM_START, MEM_32BIT_DEVICES_START, MEM_32BIT_RESERVED_START, RAM_64BIT_START, RAM_START as HIGH_RAM_START,
@ -29,7 +30,6 @@ use arch::layout::{
EBDA_START, HIGH_RAM_START, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START, EBDA_START, HIGH_RAM_START, MEM_32BIT_DEVICES_SIZE, MEM_32BIT_DEVICES_START,
MEM_32BIT_RESERVED_START, PCI_MMCONFIG_SIZE, PCI_MMCONFIG_START, RAM_64BIT_START, MEM_32BIT_RESERVED_START, PCI_MMCONFIG_SIZE, PCI_MMCONFIG_START, RAM_64BIT_START,
}; };
use arch::RegionType;
use bitfield_struct::bitfield; use bitfield_struct::bitfield;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use linux_loader::bootparam::boot_params; use linux_loader::bootparam::boot_params;
@ -752,7 +752,9 @@ impl BusDevice for FwCfg {
data.copy_from_slice(&addr_lo.to_be_bytes()); data.copy_from_slice(&addr_lo.to_be_bytes());
} }
_ => { _ => {
debug!("fw_cfg: read from unknown port {port:#x}: {size:#x} bytes and offset {offset:#x}."); debug!(
"fw_cfg: read from unknown port {port:#x}: {size:#x} bytes and offset {offset:#x}."
);
} }
}; };
} }

10
devices/src/legacy/gpio_pl061.rs
View file

@ -12,8 +12,8 @@ use std::{io, result};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
use vm_device::interrupt::InterruptSourceGroup;
use vm_device::BusDevice; use vm_device::BusDevice;
use vm_device::interrupt::InterruptSourceGroup;
use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable}; use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
use crate::{read_le_u32, write_le_u32}; use crate::{read_le_u32, write_le_u32};
@ -28,10 +28,10 @@ const GPIORIE: u64 = 0x414; // Raw Interrupt Status Register
const GPIOMIS: u64 = 0x418; // Masked Interrupt Status Register const GPIOMIS: u64 = 0x418; // Masked Interrupt Status Register
const GPIOIC: u64 = 0x41c; // Interrupt Clear Register const GPIOIC: u64 = 0x41c; // Interrupt Clear Register
const GPIOAFSEL: u64 = 0x420; // Mode Control Select Register const GPIOAFSEL: u64 = 0x420; // Mode Control Select Register
// From 0x424 to 0xFDC => reserved space. // From 0x424 to 0xFDC => reserved space.
// From 0xFE0 to 0xFFC => Peripheral and PrimeCell Identification Registers which are Read Only registers. // From 0xFE0 to 0xFFC => Peripheral and PrimeCell Identification Registers which are Read Only registers.
// These registers can conceptually be treated as a 32-bit register, and PartNumber[11:0] is used to identify the peripheral. // These registers can conceptually be treated as a 32-bit register, and PartNumber[11:0] is used to identify the peripheral.
// We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array. // We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array.
const GPIO_ID: [u8; 8] = [0x61, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1]; const GPIO_ID: [u8; 8] = [0x61, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1];
// ID Margins // ID Margins
const GPIO_ID_LOW: u64 = 0xfe0; const GPIO_ID_LOW: u64 = 0xfe0;

10
devices/src/legacy/rtc_pl031.rs
View file

@ -31,11 +31,11 @@ const RTCIMSC: u64 = 0x10; // Interrupt Mask Set or Clear Register.
const RTCRIS: u64 = 0x14; // Raw Interrupt Status. const RTCRIS: u64 = 0x14; // Raw Interrupt Status.
const RTCMIS: u64 = 0x18; // Masked Interrupt Status. const RTCMIS: u64 = 0x18; // Masked Interrupt Status.
const RTCICR: u64 = 0x1c; // Interrupt Clear Register. const RTCICR: u64 = 0x1c; // Interrupt Clear Register.
// From 0x020 to 0xFDC => reserved space. // From 0x020 to 0xFDC => reserved space.
// From 0xFE0 to 0x1000 => Peripheral and PrimeCell Identification Registers which are Read Only registers. // From 0xFE0 to 0x1000 => Peripheral and PrimeCell Identification Registers which are Read Only registers.
// AMBA standard devices have CIDs (Cell IDs) and PIDs (Peripheral IDs). The linux kernel will look for these in order to assert the identity // AMBA standard devices have CIDs (Cell IDs) and PIDs (Peripheral IDs). The linux kernel will look for these in order to assert the identity
// of these devices (i.e look at the `amba_device_try_add` function). // of these devices (i.e look at the `amba_device_try_add` function).
// We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array. // We are putting the expected values (look at 'Reset value' column from above mentioned document) in an array.
const PL031_ID: [u8; 8] = [0x31, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1]; const PL031_ID: [u8; 8] = [0x31, 0x10, 0x14, 0x00, 0x0d, 0xf0, 0x05, 0xb1];
// We are only interested in the margins. // We are only interested in the margins.
const AMBA_ID_LOW: u64 = 0xFE0; const AMBA_ID_LOW: u64 = 0xFE0;

2
devices/src/legacy/serial.rs
View file

@ -10,8 +10,8 @@ use std::sync::{Arc, Barrier};
use std::{io, result}; use std::{io, result};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use vm_device::interrupt::InterruptSourceGroup;
use vm_device::BusDevice; use vm_device::BusDevice;
use vm_device::interrupt::InterruptSourceGroup;
use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable}; use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
use vmm_sys_util::errno::Result; use vmm_sys_util::errno::Result;

2
devices/src/legacy/uart_pl011.rs
View file

@ -13,8 +13,8 @@ use std::{io, result};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
use vm_device::interrupt::InterruptSourceGroup;
use vm_device::BusDevice; use vm_device::BusDevice;
use vm_device::interrupt::InterruptSourceGroup;
use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable}; use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
use crate::{read_le_u32, write_le_u32}; use crate::{read_le_u32, write_le_u32};

2
devices/src/lib.rs
View file

@ -37,7 +37,7 @@ pub mod tpm;
pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice}; pub use self::acpi::{AcpiGedDevice, AcpiPmTimerDevice, AcpiShutdownDevice};
#[cfg(feature = "ivshmem")] #[cfg(feature = "ivshmem")]
pub use self::ivshmem::IvshmemDevice; pub use self::ivshmem::IvshmemDevice;
pub use self::pvpanic::{PvPanicDevice, PVPANIC_DEVICE_MMIO_SIZE}; pub use self::pvpanic::{PVPANIC_DEVICE_MMIO_SIZE, PvPanicDevice};
bitflags! { bitflags! {
pub struct AcpiNotificationFlags: u8 { pub struct AcpiNotificationFlags: u8 {

2
devices/src/pvmemcontrol.rs
View file

@ -520,7 +520,7 @@ impl PvmemcontrolBusDevice {
ret_value: get_page_size().into(), ret_value: get_page_size().into(),
arg0: MAJOR_VERSION.into(), arg0: MAJOR_VERSION.into(),
arg1: MINOR_VERSION.into(), arg1: MINOR_VERSION.into(),
}) });
} }
FunctionCode::Dontneed => self.madvise(addr, length, libc::MADV_DONTNEED), FunctionCode::Dontneed => self.madvise(addr, length, libc::MADV_DONTNEED),
FunctionCode::Remove => self.madvise(addr, length, libc::MADV_REMOVE), FunctionCode::Remove => self.madvise(addr, length, libc::MADV_REMOVE),

6
devices/src/pvpanic.rs
View file

@ -9,9 +9,9 @@ use std::sync::{Arc, Barrier, Mutex};
use anyhow::anyhow; use anyhow::anyhow;
use pci::{ use pci::{
BarReprogrammingParams, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, BarReprogrammingParams, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable,
PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType, PciSubclass, PciBarRegionType, PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciHeaderType,
PCI_CONFIGURATION_ID, PciSubclass,
}; };
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;

2
devices/src/tpm.rs
View file

@ -12,8 +12,8 @@ use arch::aarch64::layout::{TPM_SIZE, TPM_START};
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use arch::x86_64::layout::{TPM_SIZE, TPM_START}; use arch::x86_64::layout::{TPM_SIZE, TPM_START};
use thiserror::Error; use thiserror::Error;
use tpm::emulator::{BackendCmd, Emulator};
use tpm::TPM_CRB_BUFFER_MAX; use tpm::TPM_CRB_BUFFER_MAX;
use tpm::emulator::{BackendCmd, Emulator};
use vm_device::BusDevice; use vm_device::BusDevice;
#[derive(Error, Debug)] #[derive(Error, Debug)]

2
hypervisor/src/arch/x86/emulator/instructions/mod.rs
View file

@ -7,8 +7,8 @@
use iced_x86::*; use iced_x86::*;
use crate::arch::emulator::{EmulationError, PlatformEmulator, PlatformError}; use crate::arch::emulator::{EmulationError, PlatformEmulator, PlatformError};
use crate::arch::x86::emulator::CpuStateManager;
use crate::arch::x86::Exception; use crate::arch::x86::Exception;
use crate::arch::x86::emulator::CpuStateManager;
pub mod cmp; pub mod cmp;
pub mod mov; pub mod mov;

10
hypervisor/src/arch/x86/emulator/mod.rs
View file

@ -7,13 +7,13 @@
use anyhow::Context; use anyhow::Context;
use iced_x86::*; use iced_x86::*;
use crate::StandardRegisters;
use crate::arch::emulator::{EmulationError, EmulationResult, PlatformEmulator, PlatformError}; use crate::arch::emulator::{EmulationError, EmulationResult, PlatformEmulator, PlatformError};
use crate::arch::x86::emulator::instructions::*; use crate::arch::x86::emulator::instructions::*;
use crate::arch::x86::regs::{CR0_PE, EFER_LMA}; use crate::arch::x86::regs::{CR0_PE, EFER_LMA};
use crate::arch::x86::{ use crate::arch::x86::{
segment_type_expand_down, segment_type_ro, Exception, SegmentRegister, SpecialRegisters, Exception, SegmentRegister, SpecialRegisters, segment_type_expand_down, segment_type_ro,
}; };
use crate::StandardRegisters;
#[macro_use] #[macro_use]
mod instructions; mod instructions;
@ -254,7 +254,7 @@ impl CpuStateManager for EmulatorCpuState {
return Err(PlatformError::InvalidRegister(anyhow!( return Err(PlatformError::InvalidRegister(anyhow!(
"read_reg invalid GPR {:?}", "read_reg invalid GPR {:?}",
r r
))) )));
} }
}; };
@ -375,7 +375,7 @@ impl CpuStateManager for EmulatorCpuState {
return Err(PlatformError::InvalidRegister(anyhow!( return Err(PlatformError::InvalidRegister(anyhow!(
"write_reg invalid register {:?}", "write_reg invalid register {:?}",
reg reg
))) )));
} }
} }
@ -660,9 +660,9 @@ mod mock_vmm {
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use super::*; use super::*;
use crate::StandardRegisters;
use crate::arch::x86::emulator::EmulatorCpuState as CpuState; use crate::arch::x86::emulator::EmulatorCpuState as CpuState;
use crate::arch::x86::gdt::{gdt_entry, segment_from_gdt}; use crate::arch::x86::gdt::{gdt_entry, segment_from_gdt};
use crate::StandardRegisters;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct MockVmm { pub struct MockVmm {

8
hypervisor/src/cpu.rs
View file

@ -17,14 +17,14 @@ use thiserror::Error;
#[cfg(not(target_arch = "riscv64"))] #[cfg(not(target_arch = "riscv64"))]
use vm_memory::GuestAddress; use vm_memory::GuestAddress;
#[cfg(target_arch = "x86_64")]
use crate::arch::x86::{CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters};
#[cfg(feature = "tdx")]
use crate::kvm::{TdxExitDetails, TdxExitStatus};
#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))] #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
use crate::RegList; use crate::RegList;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use crate::VcpuInit; use crate::VcpuInit;
#[cfg(target_arch = "x86_64")]
use crate::arch::x86::{CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters};
#[cfg(feature = "tdx")]
use crate::kvm::{TdxExitDetails, TdxExitStatus};
use crate::{CpuState, MpState, StandardRegisters}; use crate::{CpuState, MpState, StandardRegisters};
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]

2
hypervisor/src/hypervisor.rs
View file

@ -13,6 +13,7 @@ use std::sync::Arc;
use thiserror::Error; use thiserror::Error;
use crate::HypervisorType;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use crate::arch::x86::CpuIdEntry; use crate::arch::x86::CpuIdEntry;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
@ -20,7 +21,6 @@ use crate::cpu::CpuVendor;
#[cfg(feature = "tdx")] #[cfg(feature = "tdx")]
use crate::kvm::TdxCapabilities; use crate::kvm::TdxCapabilities;
use crate::vm::Vm; use crate::vm::Vm;
use crate::HypervisorType;
#[derive(Error, Debug)] #[derive(Error, Debug)]
pub enum HypervisorError { pub enum HypervisorError {

2
hypervisor/src/kvm/aarch64/gic/dist_regs.rs
View file

@ -6,7 +6,7 @@ use kvm_ioctls::DeviceFd;
use crate::arch::aarch64::gic::{Error, Result}; use crate::arch::aarch64::gic::{Error, Result};
use crate::device::HypervisorDeviceError; use crate::device::HypervisorDeviceError;
use crate::kvm::kvm_bindings::{ use crate::kvm::kvm_bindings::{
kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_DIST_REGS, KVM_DEV_ARM_VGIC_GRP_NR_IRQS, KVM_DEV_ARM_VGIC_GRP_DIST_REGS, KVM_DEV_ARM_VGIC_GRP_NR_IRQS, kvm_device_attr,
}; };
/* /*

3
hypervisor/src/kvm/aarch64/gic/icc_regs.rs
View file

@ -7,10 +7,11 @@ use kvm_ioctls::DeviceFd;
use crate::arch::aarch64::gic::{Error, Result}; use crate::arch::aarch64::gic::{Error, Result};
use crate::device::HypervisorDeviceError; use crate::device::HypervisorDeviceError;
use crate::kvm::kvm_bindings::{ use crate::kvm::kvm_bindings::{
kvm_device_attr, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS, KVM_REG_ARM64_SYSREG_CRM_MASK, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS, KVM_REG_ARM64_SYSREG_CRM_MASK,
KVM_REG_ARM64_SYSREG_CRM_SHIFT, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_CRN_SHIFT, KVM_REG_ARM64_SYSREG_CRM_SHIFT, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_CRN_SHIFT,
KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT, KVM_REG_ARM64_SYSREG_OP1_MASK, KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT, KVM_REG_ARM64_SYSREG_OP1_MASK,
KVM_REG_ARM64_SYSREG_OP1_SHIFT, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM64_SYSREG_OP2_SHIFT, KVM_REG_ARM64_SYSREG_OP1_SHIFT, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM64_SYSREG_OP2_SHIFT,
kvm_device_attr,
}; };
const KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT: u32 = 32; const KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT: u32 = 32;

12
hypervisor/src/kvm/aarch64/gic/redist_regs.rs
View file

@ -4,15 +4,15 @@
use kvm_ioctls::DeviceFd; use kvm_ioctls::DeviceFd;
use crate::CpuState;
use crate::arch::aarch64::gic::{Error, Result}; use crate::arch::aarch64::gic::{Error, Result};
use crate::device::HypervisorDeviceError; use crate::device::HypervisorDeviceError;
use crate::kvm::kvm_bindings::{
kvm_device_attr, kvm_one_reg, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS, KVM_REG_ARM64,
KVM_REG_ARM64_SYSREG, KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT,
KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM64_SYSREG_OP2_SHIFT, KVM_REG_SIZE_U64,
};
use crate::kvm::VcpuKvmState; use crate::kvm::VcpuKvmState;
use crate::CpuState; use crate::kvm::kvm_bindings::{
KVM_DEV_ARM_VGIC_GRP_REDIST_REGS, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG,
KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_OP0_SHIFT, KVM_REG_ARM64_SYSREG_OP2_MASK,
KVM_REG_ARM64_SYSREG_OP2_SHIFT, KVM_REG_SIZE_U64, kvm_device_attr, kvm_one_reg,
};
// Relevant redistributor registers that we want to save/restore. // Relevant redistributor registers that we want to save/restore.
const GICR_CTLR: u32 = 0x0000; const GICR_CTLR: u32 = 0x0000;

4
hypervisor/src/kvm/aarch64/mod.rs
View file

@ -11,8 +11,8 @@
pub mod gic; pub mod gic;
use kvm_bindings::{ use kvm_bindings::{
kvm_mp_state, kvm_one_reg, kvm_regs, KVM_REG_ARM_COPROC_MASK, KVM_REG_ARM_CORE, KVM_REG_ARM_COPROC_MASK, KVM_REG_ARM_CORE, KVM_REG_SIZE_MASK, KVM_REG_SIZE_U32,
KVM_REG_SIZE_MASK, KVM_REG_SIZE_U32, KVM_REG_SIZE_U64, KVM_REG_SIZE_U64, kvm_mp_state, kvm_one_reg, kvm_regs,
}; };
pub use kvm_ioctls::{Cap, Kvm}; pub use kvm_ioctls::{Cap, Kvm};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};

49
hypervisor/src/kvm/mod.rs
View file

@ -29,7 +29,7 @@ use vmm_sys_util::eventfd::EventFd;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use crate::aarch64::gic::KvmGicV3Its; use crate::aarch64::gic::KvmGicV3Its;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
pub use crate::aarch64::{check_required_kvm_extensions, is_system_register, VcpuKvmState}; pub use crate::aarch64::{VcpuKvmState, check_required_kvm_extensions, is_system_register};
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use crate::arch::aarch64::gic::{Vgic, VgicConfig}; use crate::arch::aarch64::gic::{Vgic, VgicConfig};
#[cfg(target_arch = "riscv64")] #[cfg(target_arch = "riscv64")]
@ -40,36 +40,37 @@ use crate::arm64_core_reg_id;
use crate::riscv64::aia::KvmAiaImsics; use crate::riscv64::aia::KvmAiaImsics;
#[cfg(target_arch = "riscv64")] #[cfg(target_arch = "riscv64")]
pub use crate::riscv64::{ pub use crate::riscv64::{
aia::AiaImsicsState as AiaState, check_required_kvm_extensions, is_non_core_register, VcpuKvmState, aia::AiaImsicsState as AiaState, check_required_kvm_extensions,
VcpuKvmState, is_non_core_register,
}; };
#[cfg(target_arch = "riscv64")] #[cfg(target_arch = "riscv64")]
use crate::riscv64_reg_id; use crate::riscv64_reg_id;
use crate::vm::{self, InterruptSourceConfig, VmOps}; use crate::vm::{self, InterruptSourceConfig, VmOps};
use crate::{cpu, hypervisor, HypervisorType}; use crate::{HypervisorType, cpu, hypervisor};
// x86_64 dependencies // x86_64 dependencies
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub mod x86_64; pub mod x86_64;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use kvm_bindings::{ use kvm_bindings::{
kvm_enable_cap, kvm_msr_entry, MsrList, KVM_CAP_HYPERV_SYNIC, KVM_CAP_SPLIT_IRQCHIP, KVM_CAP_HYPERV_SYNIC, KVM_CAP_SPLIT_IRQCHIP, KVM_CAP_X2APIC_API, KVM_GUESTDBG_USE_HW_BP,
KVM_CAP_X2APIC_API, KVM_GUESTDBG_USE_HW_BP, KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK, KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK, KVM_X2APIC_API_USE_32BIT_IDS, MsrList, kvm_enable_cap,
KVM_X2APIC_API_USE_32BIT_IDS, kvm_msr_entry,
}; };
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use x86_64::check_required_kvm_extensions; use x86_64::check_required_kvm_extensions;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub use x86_64::{CpuId, ExtendedControlRegisters, MsrEntries, VcpuKvmState}; pub use x86_64::{CpuId, ExtendedControlRegisters, MsrEntries, VcpuKvmState};
#[cfg(target_arch = "x86_64")]
use crate::arch::x86::{
CpuIdEntry, FpuState, LapicState, MsrEntry, SpecialRegisters, XsaveState, NUM_IOAPIC_PINS,
};
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use crate::ClockData; use crate::ClockData;
#[cfg(target_arch = "x86_64")]
use crate::arch::x86::{
CpuIdEntry, FpuState, LapicState, MsrEntry, NUM_IOAPIC_PINS, SpecialRegisters, XsaveState,
};
use crate::{ use crate::{
CpuState, IoEventAddress, IrqRoutingEntry, MpState, StandardRegisters, UserMemoryRegion, CpuState, IoEventAddress, IrqRoutingEntry, MpState, StandardRegisters,
USER_MEMORY_REGION_LOG_DIRTY, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_WRITE, USER_MEMORY_REGION_LOG_DIRTY, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_WRITE,
UserMemoryRegion,
}; };
// aarch64 dependencies // aarch64 dependencies
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
@ -86,23 +87,23 @@ use std::mem;
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
pub use kvm_bindings::kvm_vcpu_events as VcpuEvents; pub use kvm_bindings::kvm_vcpu_events as VcpuEvents;
pub use kvm_bindings::{ pub use kvm_bindings::{
kvm_clock_data, kvm_create_device, kvm_create_device as CreateDevice,
kvm_device_attr as DeviceAttr, kvm_device_type_KVM_DEV_TYPE_VFIO, kvm_guest_debug,
kvm_irq_routing, kvm_irq_routing_entry, kvm_mp_state, kvm_run, kvm_userspace_memory_region,
KVM_GUESTDBG_ENABLE, KVM_GUESTDBG_SINGLESTEP, KVM_IRQ_ROUTING_IRQCHIP, KVM_IRQ_ROUTING_MSI, KVM_GUESTDBG_ENABLE, KVM_GUESTDBG_SINGLESTEP, KVM_IRQ_ROUTING_IRQCHIP, KVM_IRQ_ROUTING_MSI,
KVM_MEM_LOG_DIRTY_PAGES, KVM_MEM_READONLY, KVM_MSI_VALID_DEVID, KVM_MEM_LOG_DIRTY_PAGES, KVM_MEM_READONLY, KVM_MSI_VALID_DEVID, kvm_clock_data,
kvm_create_device, kvm_create_device as CreateDevice, kvm_device_attr as DeviceAttr,
kvm_device_type_KVM_DEV_TYPE_VFIO, kvm_guest_debug, kvm_irq_routing, kvm_irq_routing_entry,
kvm_mp_state, kvm_run, kvm_userspace_memory_region,
}; };
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use kvm_bindings::{ use kvm_bindings::{
kvm_regs, user_pt_regs, KVM_GUESTDBG_USE_HW, KVM_NR_SPSR, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG, KVM_GUESTDBG_USE_HW, KVM_NR_SPSR, KVM_REG_ARM_CORE, KVM_REG_ARM64, KVM_REG_ARM64_SYSREG,
KVM_REG_ARM64_SYSREG_CRM_MASK, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_OP0_MASK, KVM_REG_ARM64_SYSREG_CRM_MASK, KVM_REG_ARM64_SYSREG_CRN_MASK, KVM_REG_ARM64_SYSREG_OP0_MASK,
KVM_REG_ARM64_SYSREG_OP1_MASK, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_ARM_CORE, KVM_REG_ARM64_SYSREG_OP1_MASK, KVM_REG_ARM64_SYSREG_OP2_MASK, KVM_REG_SIZE_U32,
KVM_REG_SIZE_U128, KVM_REG_SIZE_U32, KVM_REG_SIZE_U64, KVM_REG_SIZE_U64, KVM_REG_SIZE_U128, kvm_regs, user_pt_regs,
}; };
#[cfg(target_arch = "riscv64")] #[cfg(target_arch = "riscv64")]
use kvm_bindings::{kvm_riscv_core, KVM_REG_RISCV_CORE}; use kvm_bindings::{KVM_REG_RISCV_CORE, kvm_riscv_core};
#[cfg(feature = "tdx")] #[cfg(feature = "tdx")]
use kvm_bindings::{kvm_run__bindgen_ty_1, KVMIO}; use kvm_bindings::{KVMIO, kvm_run__bindgen_ty_1};
pub use kvm_ioctls::{Cap, Kvm, VcpuExit}; pub use kvm_ioctls::{Cap, Kvm, VcpuExit};
use thiserror::Error; use thiserror::Error;
use vfio_ioctls::VfioDeviceFd; use vfio_ioctls::VfioDeviceFd;
@ -112,10 +113,10 @@ use vmm_sys_util::ioctl_io_nr;
use vmm_sys_util::{ioctl::ioctl_with_val, ioctl_iowr_nr}; use vmm_sys_util::{ioctl::ioctl_with_val, ioctl_iowr_nr};
pub use {kvm_bindings, kvm_ioctls}; pub use {kvm_bindings, kvm_ioctls};
#[cfg(target_arch = "aarch64")]
use crate::arch::aarch64::regs;
#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))] #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
use crate::RegList; use crate::RegList;
#[cfg(target_arch = "aarch64")]
use crate::arch::aarch64::regs;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
ioctl_io_nr!(KVM_NMI, kvm_bindings::KVMIO, 0x9a); ioctl_io_nr!(KVM_NMI, kvm_bindings::KVMIO, 0x9a);
@ -2866,7 +2867,7 @@ impl cpu::Vcpu for KvmVcpu {
/// Return the list of initial MSR entries for a VCPU /// Return the list of initial MSR entries for a VCPU
/// ///
fn boot_msr_entries(&self) -> Vec<MsrEntry> { fn boot_msr_entries(&self) -> Vec<MsrEntry> {
use crate::arch::x86::{msr_index, MTRR_ENABLE, MTRR_MEM_TYPE_WB}; use crate::arch::x86::{MTRR_ENABLE, MTRR_MEM_TYPE_WB, msr_index};
[ [
msr!(msr_index::MSR_IA32_SYSENTER_CS), msr!(msr_index::MSR_IA32_SYSENTER_CS),

2
hypervisor/src/kvm/riscv64/aia.rs
View file

@ -7,10 +7,10 @@ use std::any::Any;
use kvm_ioctls::DeviceFd; use kvm_ioctls::DeviceFd;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::Vm;
use crate::arch::riscv64::aia::{Error, Result, Vaia, VaiaConfig}; use crate::arch::riscv64::aia::{Error, Result, Vaia, VaiaConfig};
use crate::device::HypervisorDeviceError; use crate::device::HypervisorDeviceError;
use crate::kvm::KvmVm; use crate::kvm::KvmVm;
use crate::Vm;
pub struct KvmAiaImsics { pub struct KvmAiaImsics {
/// The KVM device for the Aia /// The KVM device for the Aia

4
hypervisor/src/kvm/riscv64/mod.rs
View file

@ -5,8 +5,8 @@
pub mod aia; pub mod aia;
use kvm_bindings::{ use kvm_bindings::{
kvm_mp_state, kvm_one_reg, kvm_riscv_core, KVM_REG_RISCV_CORE, KVM_REG_RISCV_TYPE_MASK, KVM_REG_RISCV_CORE, KVM_REG_RISCV_TYPE_MASK, KVM_REG_SIZE_MASK, KVM_REG_SIZE_U64, kvm_mp_state,
KVM_REG_SIZE_MASK, KVM_REG_SIZE_U64, kvm_one_reg, kvm_riscv_core,
}; };
pub use kvm_ioctls::{Cap, Kvm}; pub use kvm_ioctls::{Cap, Kvm};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};

11
hypervisor/src/kvm/x86_64/mod.rs
View file

@ -13,18 +13,17 @@ use serde::{Deserialize, Serialize};
/// Export generically-named wrappers of kvm-bindings for Unix-based platforms /// Export generically-named wrappers of kvm-bindings for Unix-based platforms
/// ///
pub use { pub use {
kvm_bindings::kvm_cpuid_entry2, kvm_bindings::kvm_dtable, kvm_bindings::kvm_fpu, kvm_bindings::CpuId, kvm_bindings::KVM_CPUID_FLAG_SIGNIFCANT_INDEX, kvm_bindings::MsrList,
kvm_bindings::kvm_lapic_state, kvm_bindings::kvm_mp_state as MpState, kvm_bindings::Msrs as MsrEntries, kvm_bindings::kvm_cpuid_entry2, kvm_bindings::kvm_dtable,
kvm_bindings::kvm_fpu, kvm_bindings::kvm_lapic_state, kvm_bindings::kvm_mp_state as MpState,
kvm_bindings::kvm_msr_entry, kvm_bindings::kvm_regs, kvm_bindings::kvm_segment, kvm_bindings::kvm_msr_entry, kvm_bindings::kvm_regs, kvm_bindings::kvm_segment,
kvm_bindings::kvm_sregs, kvm_bindings::kvm_vcpu_events as VcpuEvents, kvm_bindings::kvm_sregs, kvm_bindings::kvm_vcpu_events as VcpuEvents,
kvm_bindings::kvm_xcrs as ExtendedControlRegisters, kvm_bindings::kvm_xsave, kvm_bindings::kvm_xcrs as ExtendedControlRegisters, kvm_bindings::kvm_xsave,
kvm_bindings::CpuId, kvm_bindings::MsrList, kvm_bindings::Msrs as MsrEntries,
kvm_bindings::KVM_CPUID_FLAG_SIGNIFCANT_INDEX,
}; };
use crate::arch::x86::{ use crate::arch::x86::{
CpuIdEntry, DescriptorTable, FpuState, LapicState, MsrEntry, SegmentRegister, SpecialRegisters, CPUID_FLAG_VALID_INDEX, CpuIdEntry, DescriptorTable, FpuState, LapicState, MsrEntry,
XsaveState, CPUID_FLAG_VALID_INDEX, SegmentRegister, SpecialRegisters, XsaveState,
}; };
use crate::kvm::{Cap, Kvm, KvmError, KvmResult}; use crate::kvm::{Cap, Kvm, KvmError, KvmResult};

2
hypervisor/src/lib.rs
View file

@ -61,7 +61,7 @@ pub use device::HypervisorDeviceError;
#[cfg(all(feature = "kvm", target_arch = "aarch64"))] #[cfg(all(feature = "kvm", target_arch = "aarch64"))]
pub use kvm::aarch64; pub use kvm::aarch64;
#[cfg(all(feature = "kvm", target_arch = "riscv64"))] #[cfg(all(feature = "kvm", target_arch = "riscv64"))]
pub use kvm::{riscv64, AiaState}; pub use kvm::{AiaState, riscv64};
pub use vm::{ pub use vm::{
DataMatch, HypervisorVmError, InterruptSourceConfig, LegacyIrqSourceConfig, MsiIrqSourceConfig, DataMatch, HypervisorVmError, InterruptSourceConfig, LegacyIrqSourceConfig, MsiIrqSourceConfig,
Vm, VmOps, Vm, VmOps,

22
hypervisor/src/mshv/mod.rs
View file

@ -14,7 +14,7 @@ use arc_swap::ArcSwap;
use mshv_bindings::*; use mshv_bindings::*;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use mshv_ioctls::InterruptRequest; use mshv_ioctls::InterruptRequest;
use mshv_ioctls::{set_registers_64, Mshv, NoDatamatch, VcpuFd, VmFd, VmType}; use mshv_ioctls::{Mshv, NoDatamatch, VcpuFd, VmFd, VmType, set_registers_64};
use vfio_ioctls::VfioDeviceFd; use vfio_ioctls::VfioDeviceFd;
use vm::DataMatch; use vm::DataMatch;
#[cfg(feature = "sev_snp")] #[cfg(feature = "sev_snp")]
@ -32,7 +32,7 @@ use crate::arch::x86::emulator::Emulator;
use crate::mshv::aarch64::emulator; use crate::mshv::aarch64::emulator;
use crate::mshv::emulator::MshvEmulatorContext; use crate::mshv::emulator::MshvEmulatorContext;
use crate::vm::{self, InterruptSourceConfig, VmOps}; use crate::vm::{self, InterruptSourceConfig, VmOps};
use crate::{cpu, hypervisor, vec_with_array_field, HypervisorType}; use crate::{HypervisorType, cpu, hypervisor, vec_with_array_field};
#[cfg(feature = "sev_snp")] #[cfg(feature = "sev_snp")]
mod snp_constants; mod snp_constants;
// x86_64 dependencies // x86_64 dependencies
@ -45,10 +45,10 @@ use std::os::unix::io::AsRawFd;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use std::sync::Mutex; use std::sync::Mutex;
#[cfg(target_arch = "aarch64")]
use aarch64::gic::{MshvGicV2M, BASE_SPI_IRQ};
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
pub use aarch64::VcpuMshvState; pub use aarch64::VcpuMshvState;
#[cfg(target_arch = "aarch64")]
use aarch64::gic::{BASE_SPI_IRQ, MshvGicV2M};
#[cfg(feature = "sev_snp")] #[cfg(feature = "sev_snp")]
use igvm_defs::IGVM_VHS_SNP_ID_BLOCK; use igvm_defs::IGVM_VHS_SNP_ID_BLOCK;
#[cfg(feature = "sev_snp")] #[cfg(feature = "sev_snp")]
@ -57,7 +57,7 @@ use vmm_sys_util::eventfd::EventFd;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub use x86_64::*; pub use x86_64::*;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub use x86_64::{emulator, VcpuMshvState}; pub use x86_64::{VcpuMshvState, emulator};
/// ///
/// Export generically-named wrappers of mshv-bindings for Unix-based platforms /// Export generically-named wrappers of mshv-bindings for Unix-based platforms
/// ///
@ -66,18 +66,18 @@ pub use {
mshv_bindings::mshv_device_attr as DeviceAttr, mshv_ioctls, mshv_ioctls::DeviceFd, mshv_bindings::mshv_device_attr as DeviceAttr, mshv_ioctls, mshv_ioctls::DeviceFd,
}; };
#[cfg(target_arch = "x86_64")]
use crate::ClockData;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use crate::arch::aarch64::gic::{Vgic, VgicConfig}; use crate::arch::aarch64::gic::{Vgic, VgicConfig};
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use crate::arch::aarch64::regs; use crate::arch::aarch64::regs;
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use crate::arch::x86::{CpuIdEntry, FpuState, MsrEntry}; use crate::arch::x86::{CpuIdEntry, FpuState, MsrEntry};
#[cfg(target_arch = "x86_64")]
use crate::ClockData;
use crate::{ use crate::{
CpuState, IoEventAddress, IrqRoutingEntry, MpState, UserMemoryRegion, CpuState, IoEventAddress, IrqRoutingEntry, MpState, USER_MEMORY_REGION_ADJUSTABLE,
USER_MEMORY_REGION_ADJUSTABLE, USER_MEMORY_REGION_EXECUTE, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_EXECUTE, USER_MEMORY_REGION_READ, USER_MEMORY_REGION_WRITE,
USER_MEMORY_REGION_WRITE, UserMemoryRegion,
}; };
pub const PAGE_SHIFT: usize = 12; pub const PAGE_SHIFT: usize = 12;
@ -1512,7 +1512,7 @@ impl cpu::Vcpu for MshvVcpu {
/// Return the list of initial MSR entries for a VCPU /// Return the list of initial MSR entries for a VCPU
/// ///
fn boot_msr_entries(&self) -> Vec<MsrEntry> { fn boot_msr_entries(&self) -> Vec<MsrEntry> {
use crate::arch::x86::{msr_index, MTRR_ENABLE, MTRR_MEM_TYPE_WB}; use crate::arch::x86::{MTRR_ENABLE, MTRR_MEM_TYPE_WB, msr_index};
[ [
msr!(msr_index::MSR_IA32_SYSENTER_CS), msr!(msr_index::MSR_IA32_SYSENTER_CS),

34
hypervisor/src/mshv/x86_64/mod.rs
View file

@ -21,16 +21,16 @@ pub mod emulator;
/// Export generically-named wrappers of mshv_bindings for Unix-based platforms /// Export generically-named wrappers of mshv_bindings for Unix-based platforms
/// ///
pub use { pub use {
mshv_bindings::hv_cpuid_entry, mshv_bindings::mshv_user_mem_region as MemoryRegion, mshv_bindings::AllVpStateComponents, mshv_bindings::CpuId, mshv_bindings::DebugRegisters,
mshv_bindings::msr_entry, mshv_bindings::AllVpStateComponents, mshv_bindings::CpuId, mshv_bindings::FloatingPointUnit, mshv_bindings::LapicState as MshvLapicState,
mshv_bindings::DebugRegisters, mshv_bindings::FloatingPointUnit, mshv_bindings::MiscRegs as MiscRegisters, mshv_bindings::MsrList,
mshv_bindings::LapicState as MshvLapicState, mshv_bindings::MiscRegs as MiscRegisters, mshv_bindings::Msrs as MsrEntries, mshv_bindings::Msrs,
mshv_bindings::MsrList, mshv_bindings::Msrs as MsrEntries, mshv_bindings::Msrs,
mshv_bindings::SegmentRegister as MshvSegmentRegister, mshv_bindings::SegmentRegister as MshvSegmentRegister,
mshv_bindings::SpecialRegisters as MshvSpecialRegisters, mshv_bindings::SpecialRegisters as MshvSpecialRegisters,
mshv_bindings::StandardRegisters as MshvStandardRegisters, mshv_bindings::SuspendRegisters, mshv_bindings::StandardRegisters as MshvStandardRegisters, mshv_bindings::SuspendRegisters,
mshv_bindings::TableRegister, mshv_bindings::VcpuEvents, mshv_bindings::XSave as Xsave, mshv_bindings::TableRegister, mshv_bindings::VcpuEvents, mshv_bindings::XSave as Xsave,
mshv_bindings::Xcrs as ExtendedControlRegisters, mshv_bindings::Xcrs as ExtendedControlRegisters, mshv_bindings::hv_cpuid_entry,
mshv_bindings::mshv_user_mem_region as MemoryRegion, mshv_bindings::msr_entry,
}; };
#[derive(Clone, Serialize, Deserialize)] #[derive(Clone, Serialize, Deserialize)]
@ -60,16 +60,18 @@ impl fmt::Display for VcpuMshvState {
msr_entries[i][1] = entry.data; msr_entries[i][1] = entry.data;
msr_entries[i][0] = entry.index as u64; msr_entries[i][0] = entry.index as u64;
} }
write!(f, "Number of MSRs: {}: MSRs: {:#010X?}, -- VCPU Events: {:?} -- Standard registers: {:?} Special Registers: {:?} ---- Floating Point Unit: {:?} --- Extended Control Register: {:?} --- DBG: {:?} --- VP States: {:?}", write!(
msr_entries.len(), f,
msr_entries, "Number of MSRs: {}: MSRs: {:#010X?}, -- VCPU Events: {:?} -- Standard registers: {:?} Special Registers: {:?} ---- Floating Point Unit: {:?} --- Extended Control Register: {:?} --- DBG: {:?} --- VP States: {:?}",
self.vcpu_events, msr_entries.len(),
self.regs, msr_entries,
self.sregs, self.vcpu_events,
self.fpu, self.regs,
self.xcrs, self.sregs,
self.dbg, self.fpu,
self.vp_states, self.xcrs,
self.dbg,
self.vp_states,
) )
} }
} }

4
hypervisor/src/vm.rs
View file

@ -20,6 +20,8 @@ use igvm_defs::IGVM_VHS_SNP_ID_BLOCK;
use thiserror::Error; use thiserror::Error;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
#[cfg(target_arch = "x86_64")]
use crate::ClockData;
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
use crate::arch::aarch64::gic::{Vgic, VgicConfig}; use crate::arch::aarch64::gic::{Vgic, VgicConfig};
#[cfg(target_arch = "riscv64")] #[cfg(target_arch = "riscv64")]
@ -27,8 +29,6 @@ use crate::arch::riscv64::aia::{Vaia, VaiaConfig};
#[cfg(feature = "tdx")] #[cfg(feature = "tdx")]
use crate::arch::x86::CpuIdEntry; use crate::arch::x86::CpuIdEntry;
use crate::cpu::Vcpu; use crate::cpu::Vcpu;
#[cfg(target_arch = "x86_64")]
use crate::ClockData;
use crate::{IoEventAddress, IrqRoutingEntry, UserMemoryRegion}; use crate::{IoEventAddress, IrqRoutingEntry, UserMemoryRegion};
/// ///

12
net_util/src/lib.rs
View file

@ -23,18 +23,18 @@ use std::{io, mem, net};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
use virtio_bindings::virtio_net::{ use virtio_bindings::virtio_net::{
virtio_net_hdr_v1, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX, VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN, VIRTIO_NET_F_GUEST_CSUM,
VIRTIO_NET_F_GUEST_CSUM, VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_TSO4, VIRTIO_NET_F_GUEST_ECN, VIRTIO_NET_F_GUEST_TSO4, VIRTIO_NET_F_GUEST_TSO6,
VIRTIO_NET_F_GUEST_TSO6, VIRTIO_NET_F_GUEST_UFO, VIRTIO_NET_F_MAC, VIRTIO_NET_F_MQ, VIRTIO_NET_F_GUEST_UFO, VIRTIO_NET_F_MAC, VIRTIO_NET_F_MQ, virtio_net_hdr_v1,
}; };
use vm_memory::bitmap::AtomicBitmap;
use vm_memory::ByteValued; use vm_memory::ByteValued;
use vm_memory::bitmap::AtomicBitmap;
type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>; type GuestMemoryMmap = vm_memory::GuestMemoryMmap<AtomicBitmap>;
pub use ctrl_queue::{CtrlQueue, Error as CtrlQueueError}; pub use ctrl_queue::{CtrlQueue, Error as CtrlQueueError};
pub use mac::{MacAddr, MAC_ADDR_LEN}; pub use mac::{MAC_ADDR_LEN, MacAddr};
pub use open_tap::{open_tap, Error as OpenTapError}; pub use open_tap::{Error as OpenTapError, open_tap};
pub use queue_pair::{NetCounters, NetQueuePair, NetQueuePairError, RxVirtio, TxVirtio}; pub use queue_pair::{NetCounters, NetQueuePair, NetQueuePairError, RxVirtio, TxVirtio};
pub use tap::{Error as TapError, Tap}; pub use tap::{Error as TapError, Tap};

2
net_util/src/open_tap.rs
View file

@ -8,7 +8,7 @@ use std::{fs, io};
use thiserror::Error; use thiserror::Error;
use super::{vnet_hdr_len, MacAddr, Tap, TapError}; use super::{MacAddr, Tap, TapError, vnet_hdr_len};
#[derive(Error, Debug)] #[derive(Error, Debug)]
pub enum Error { pub enum Error {

4
net_util/src/queue_pair.rs
View file

@ -5,8 +5,8 @@
use std::io; use std::io;
use std::num::Wrapping; use std::num::Wrapping;
use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::io::{AsRawFd, RawFd};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc; use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use rate_limiter::{RateLimiter, TokenType}; use rate_limiter::{RateLimiter, TokenType};
use thiserror::Error; use thiserror::Error;
@ -15,7 +15,7 @@ use vm_memory::bitmap::Bitmap;
use vm_memory::{Bytes, GuestMemory}; use vm_memory::{Bytes, GuestMemory};
use vm_virtio::{AccessPlatform, Translatable}; use vm_virtio::{AccessPlatform, Translatable};
use super::{register_listener, unregister_listener, vnet_hdr_len, Tap}; use super::{Tap, register_listener, unregister_listener, vnet_hdr_len};
#[derive(Clone)] #[derive(Clone)]
pub struct TxVirtio { pub struct TxVirtio {

24
net_util/src/tap.rs
View file

@ -15,8 +15,8 @@ use thiserror::Error;
use vmm_sys_util::ioctl::{ioctl_with_mut_ref, ioctl_with_ref, ioctl_with_val}; use vmm_sys_util::ioctl::{ioctl_with_mut_ref, ioctl_with_ref, ioctl_with_val};
use super::{ use super::{
create_inet_socket, create_sockaddr, create_unix_socket, vnet_hdr_len, Error as NetUtilError, Error as NetUtilError, MacAddr, create_inet_socket, create_sockaddr, create_unix_socket,
MacAddr, vnet_hdr_len,
}; };
use crate::mac::MAC_ADDR_LEN; use crate::mac::MAC_ADDR_LEN;
@ -551,7 +551,7 @@ impl AsRawFd for Tap {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::net::Ipv4Addr; use std::net::Ipv4Addr;
use std::sync::{mpsc, LazyLock, Mutex}; use std::sync::{LazyLock, Mutex, mpsc};
use std::time::Duration; use std::time::Duration;
use std::{str, thread}; use std::{str, thread};
@ -860,15 +860,17 @@ mod tests {
// We use a separate thread to wait for the test packet because the API exposed by pnet is // We use a separate thread to wait for the test packet because the API exposed by pnet is
// blocking. This thread will be killed when the main thread exits. // blocking. This thread will be killed when the main thread exits.
let _handle = thread::spawn(move || loop { let _handle = thread::spawn(move || {
let buf = rx.next().unwrap(); loop {
let p = ParsedPkt::new(buf); let buf = rx.next().unwrap();
p.print(); let p = ParsedPkt::new(buf);
p.print();
if let Some(ref udp) = p.udp { if let Some(ref udp) = p.udp {
if payload == udp.payload() { if payload == udp.payload() {
channel_tx.send(true).unwrap(); channel_tx.send(true).unwrap();
break; break;
}
} }
} }
}); });

2
pci/src/bus.rs
View file

@ -13,11 +13,11 @@ use byteorder::{ByteOrder, LittleEndian};
use thiserror::Error; use thiserror::Error;
use vm_device::{Bus, BusDevice, BusDeviceSync}; use vm_device::{Bus, BusDevice, BusDeviceSync};
use crate::PciBarConfiguration;
use crate::configuration::{ use crate::configuration::{
PciBarRegionType, PciBridgeSubclass, PciClassCode, PciConfiguration, PciHeaderType, PciBarRegionType, PciBridgeSubclass, PciClassCode, PciConfiguration, PciHeaderType,
}; };
use crate::device::{BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice}; use crate::device::{BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice};
use crate::PciBarConfiguration;
const VENDOR_ID_INTEL: u16 = 0x8086; const VENDOR_ID_INTEL: u16 = 0x8086;
const DEVICE_ID_INTEL_VIRT_PCIE_HOST: u16 = 0x0d57; const DEVICE_ID_INTEL_VIRT_PCIE_HOST: u16 = 0x0d57;

2
pci/src/device.rs
View file

@ -12,8 +12,8 @@ use thiserror::Error;
use vm_allocator::{AddressAllocator, SystemAllocator}; use vm_allocator::{AddressAllocator, SystemAllocator};
use vm_device::Resource; use vm_device::Resource;
use crate::configuration::{self, PciBarRegionType};
use crate::PciBarConfiguration; use crate::PciBarConfiguration;
use crate::configuration::{self, PciBarRegionType};
#[derive(Error, Debug)] #[derive(Error, Debug)]
pub enum Error { pub enum Error {

12
pci/src/lib.rs
View file

@ -24,16 +24,16 @@ use serde::de::Visitor;
pub use self::bus::{PciBus, PciConfigIo, PciConfigMmio, PciRoot, PciRootError}; pub use self::bus::{PciBus, PciConfigIo, PciConfigMmio, PciRoot, PciRootError};
pub use self::configuration::{ pub use self::configuration::{
PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciCapability, PciCapabilityId, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciCapability,
PciClassCode, PciConfiguration, PciExpressCapabilityId, PciHeaderType, PciMassStorageSubclass, PciCapabilityId, PciClassCode, PciConfiguration, PciExpressCapabilityId, PciHeaderType,
PciNetworkControllerSubclass, PciProgrammingInterface, PciSerialBusSubClass, PciSubclass, PciMassStorageSubclass, PciNetworkControllerSubclass, PciProgrammingInterface,
PCI_CONFIGURATION_ID, PciSerialBusSubClass, PciSubclass,
}; };
pub use self::device::{ pub use self::device::{
BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice, BarReprogrammingParams, DeviceRelocation, Error as PciDeviceError, PciDevice,
}; };
pub use self::msi::{msi_num_enabled_vectors, MsiCap, MsiConfig}; pub use self::msi::{MsiCap, MsiConfig, msi_num_enabled_vectors};
pub use self::msix::{MsixCap, MsixConfig, MsixTableEntry, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE}; pub use self::msix::{MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, MsixCap, MsixConfig, MsixTableEntry};
pub use self::vfio::{MmioRegion, VfioDmaMapping, VfioPciDevice, VfioPciError}; pub use self::vfio::{MmioRegion, VfioDmaMapping, VfioPciDevice, VfioPciError};
pub use self::vfio_user::{VfioUserDmaMapping, VfioUserPciDevice, VfioUserPciDeviceError}; pub use self::vfio_user::{VfioUserDmaMapping, VfioUserPciDevice, VfioUserPciDeviceError};

23
pci/src/vfio.rs
View file

@ -14,7 +14,7 @@ use std::sync::{Arc, Barrier, Mutex};
use anyhow::anyhow; use anyhow::anyhow;
use byteorder::{ByteOrder, LittleEndian}; use byteorder::{ByteOrder, LittleEndian};
use hypervisor::HypervisorVmError; use hypervisor::HypervisorVmError;
use libc::{sysconf, _SC_PAGESIZE}; use libc::{_SC_PAGESIZE, sysconf};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
use vfio_bindings::bindings::vfio::*; use vfio_bindings::bindings::vfio::*;
@ -34,13 +34,13 @@ use vm_memory::{Address, GuestAddress, GuestAddressSpace, GuestMemory, GuestUsiz
use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable}; use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::msi::{MsiConfigState, MSI_CONFIG_ID}; use crate::msi::{MSI_CONFIG_ID, MsiConfigState};
use crate::msix::MsixConfigState; use crate::msix::MsixConfigState;
use crate::{ use crate::{
msi_num_enabled_vectors, BarReprogrammingParams, MsiCap, MsiConfig, MsixCap, MsixConfig, BarReprogrammingParams, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, MsiCap, MsiConfig, MsixCap,
PciBarConfiguration, PciBarPrefetchable, PciBarRegionType, PciBdf, PciCapabilityId, MsixConfig, PCI_CONFIGURATION_ID, PciBarConfiguration, PciBarPrefetchable, PciBarRegionType,
PciClassCode, PciConfiguration, PciDevice, PciDeviceError, PciExpressCapabilityId, PciBdf, PciCapabilityId, PciClassCode, PciConfiguration, PciDevice, PciDeviceError,
PciHeaderType, PciSubclass, MSIX_CONFIG_ID, MSIX_TABLE_ENTRY_SIZE, PCI_CONFIGURATION_ID, PciExpressCapabilityId, PciHeaderType, PciSubclass, msi_num_enabled_vectors,
}; };
pub(crate) const VFIO_COMMON_ID: &str = "vfio_common"; pub(crate) const VFIO_COMMON_ID: &str = "vfio_common";
@ -1664,9 +1664,8 @@ impl VfioPciDevice {
if !is_page_size_aligned(area.size) || !is_page_size_aligned(area.offset) { if !is_page_size_aligned(area.size) || !is_page_size_aligned(area.offset) {
warn!( warn!(
"Could not mmap sparse area that is not page size aligned (offset = 0x{:x}, size = 0x{:x})", "Could not mmap sparse area that is not page size aligned (offset = 0x{:x}, size = 0x{:x})",
area.offset, area.offset, area.size,
area.size, );
);
return Ok(()); return Ok(());
} }
@ -2040,9 +2039,9 @@ impl<M: GuestAddressSpace + Sync + Send> ExternalDmaMapping for VfioDmaMapping<M
match mem.get_host_address(guest_addr) { match mem.get_host_address(guest_addr) {
Ok(t) => t as u64, Ok(t) => t as u64,
Err(e) => { Err(e) => {
return Err(io::Error::other( return Err(io::Error::other(format!(
format!("unable to retrieve user address for gpa 0x{gpa:x} from guest memory region: {e}") "unable to retrieve user address for gpa 0x{gpa:x} from guest memory region: {e}"
)); )));
} }
} }
} else if self.mmio_regions.lock().unwrap().check_range(gpa, size) { } else if self.mmio_regions.lock().unwrap().check_range(gpa, size) {

2
pci/src/vfio_user.rs
View file

@ -24,7 +24,7 @@ use vm_memory::{
use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable}; use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottable, Transportable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::vfio::{UserMemoryRegion, Vfio, VfioCommon, VfioError, VFIO_COMMON_ID}; use crate::vfio::{UserMemoryRegion, VFIO_COMMON_ID, Vfio, VfioCommon, VfioError};
use crate::{ use crate::{
BarReprogrammingParams, PciBarConfiguration, PciBdf, PciDevice, PciDeviceError, PciSubclass, BarReprogrammingParams, PciBarConfiguration, PciBdf, PciDevice, PciDeviceError, PciSubclass,
VfioPciError, VfioPciError,

2
performance-metrics/src/main.rs
View file

@ -9,8 +9,8 @@ extern crate test_infra;
mod performance_tests; mod performance_tests;
use std::process::Command; use std::process::Command;
use std::sync::mpsc::channel;
use std::sync::Arc; use std::sync::Arc;
use std::sync::mpsc::channel;
use std::time::Duration; use std::time::Duration;
use std::{env, fmt, thread}; use std::{env, fmt, thread};

2
performance-metrics/src/performance_tests.rs
View file

@ -12,7 +12,7 @@ use std::{fs, thread};
use test_infra::{Error as InfraError, *}; use test_infra::{Error as InfraError, *};
use thiserror::Error; use thiserror::Error;
use crate::{mean, ImageFormat, PerformanceTestControl, PerformanceTestOverrides}; use crate::{ImageFormat, PerformanceTestControl, PerformanceTestOverrides, mean};
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub const FOCAL_IMAGE_NAME: &str = "focal-server-cloudimg-amd64-custom-20210609-0.raw"; pub const FOCAL_IMAGE_NAME: &str = "focal-server-cloudimg-amd64-custom-20210609-0.raw";

2
rate_limiter/src/group.rs
View file

@ -306,7 +306,7 @@ pub(crate) mod tests {
use super::RateLimiterGroupHandle; use super::RateLimiterGroupHandle;
use crate::group::RateLimiterGroup; use crate::group::RateLimiterGroup;
use crate::{TokenBucket, TokenType, REFILL_TIMER_INTERVAL_MS}; use crate::{REFILL_TIMER_INTERVAL_MS, TokenBucket, TokenType};
impl RateLimiterGroupHandle { impl RateLimiterGroupHandle {
fn bandwidth(&self) -> Option<TokenBucket> { fn bandwidth(&self) -> Option<TokenBucket> {

4
rate_limiter/src/lib.rs
View file

@ -48,8 +48,8 @@ extern crate log;
use std::io; use std::io;
use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::io::{AsRawFd, RawFd};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Mutex; use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use thiserror::Error; use thiserror::Error;
@ -470,7 +470,7 @@ impl RateLimiter {
std::io::ErrorKind::WouldBlock => { std::io::ErrorKind::WouldBlock => {
return Err(Error::SpuriousRateLimiterEvent( return Err(Error::SpuriousRateLimiterEvent(
"Rate limiter event handler called without a present timer", "Rate limiter event handler called without a present timer",
)) ));
} }
_ => return Err(Error::TimerFdWaitError(err)), _ => return Err(Error::TimerFdWaitError(err)),
} }

2
serial_buffer/src/lib.rs
View file

@ -5,8 +5,8 @@
use std::collections::VecDeque; use std::collections::VecDeque;
use std::io::Write; use std::io::Write;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc; use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
const MAX_BUFFER_SIZE: usize = 1 << 20; const MAX_BUFFER_SIZE: usize = 1 << 20;

8
src/bin/ch-remote.rs
View file

@ -13,8 +13,8 @@ use std::os::unix::net::UnixStream;
use std::process; use std::process;
use api_client::{ use api_client::{
simple_api_command, simple_api_command_with_fds, simple_api_full_command, Error as ApiClientError, simple_api_command, simple_api_command_with_fds,
Error as ApiClientError, simple_api_full_command,
}; };
use clap::{Arg, ArgAction, ArgMatches, Command}; use clap::{Arg, ArgAction, ArgMatches, Command};
use log::error; use log::error;
@ -1128,7 +1128,9 @@ fn main() {
process::exit(1); process::exit(1);
} }
_ => { _ => {
error!("Please either provide the api-socket option or dbus-service-name and dbus-object-path options"); error!(
"Please either provide the api-socket option or dbus-service-name and dbus-object-path options"
);
process::exit(1); process::exit(1);
} }
}; };

10
src/main.rs
View file

@ -8,22 +8,22 @@ mod test_util;
use std::fs::File; use std::fs::File;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use std::sync::mpsc::channel;
use std::sync::Mutex; use std::sync::Mutex;
use std::sync::mpsc::channel;
use std::{env, io}; use std::{env, io};
use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command}; use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command};
use event_monitor::event; use event_monitor::event;
use libc::EFD_NONBLOCK; use libc::EFD_NONBLOCK;
use log::{error, warn, LevelFilter}; use log::{LevelFilter, error, warn};
use option_parser::OptionParser; use option_parser::OptionParser;
use seccompiler::SeccompAction; use seccompiler::SeccompAction;
use signal_hook::consts::SIGSYS; use signal_hook::consts::SIGSYS;
use thiserror::Error; use thiserror::Error;
#[cfg(feature = "dbus_api")]
use vmm::api::dbus::{dbus_api_graceful_shutdown, DBusApiOptions};
use vmm::api::http::http_api_graceful_shutdown;
use vmm::api::ApiAction; use vmm::api::ApiAction;
#[cfg(feature = "dbus_api")]
use vmm::api::dbus::{DBusApiOptions, dbus_api_graceful_shutdown};
use vmm::api::http::http_api_graceful_shutdown;
use vmm::config::{RestoreConfig, VmParams}; use vmm::config::{RestoreConfig, VmParams};
use vmm::landlock::{Landlock, LandlockError}; use vmm::landlock::{Landlock, LandlockError};
use vmm::vm_config; use vmm::vm_config;

27
test_infra/src/lib.rs
View file

@ -1118,10 +1118,12 @@ impl Guest {
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
// Write something to vsock from the host // Write something to vsock from the host
assert!(exec_host_command_status(&format!( assert!(
"echo -e \"CONNECT 16\\nHelloWorld!\" | socat - UNIX-CONNECT:{socket}" exec_host_command_status(&format!(
)) "echo -e \"CONNECT 16\\nHelloWorld!\" | socat - UNIX-CONNECT:{socket}"
.success()); ))
.success()
);
// Wait for the thread to terminate. // Wait for the thread to terminate.
listen_socat.join().unwrap(); listen_socat.join().unwrap();
@ -1134,10 +1136,11 @@ impl Guest {
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub fn check_nvidia_gpu(&self) { pub fn check_nvidia_gpu(&self) {
assert!(self assert!(
.ssh_command("nvidia-smi") self.ssh_command("nvidia-smi")
.unwrap() .unwrap()
.contains("NVIDIA L40S")); .contains("NVIDIA L40S")
);
} }
pub fn reboot_linux(&self, current_reboot_count: u32, custom_timeout: Option<i32>) { pub fn reboot_linux(&self, current_reboot_count: u32, custom_timeout: Option<i32>) {
@ -1334,11 +1337,9 @@ impl<'a> GuestCommand<'a> {
if pipesize >= PIPE_SIZE && pipesize1 >= PIPE_SIZE { if pipesize >= PIPE_SIZE && pipesize1 >= PIPE_SIZE {
Ok(child) Ok(child)
} else { } else {
Err(std::io::Error::other( Err(std::io::Error::other(format!(
format!( "resizing pipe w/ 'fnctl' failed: stdout pipesize {pipesize}, stderr pipesize {pipesize1}"
"resizing pipe w/ 'fnctl' failed: stdout pipesize {pipesize}, stderr pipesize {pipesize1}" )))
),
))
} }
} else { } else {
// The caller should call .wait() on the returned child // The caller should call .wait() on the returned child

312
tests/integration.rs
View file

@ -20,7 +20,7 @@ use std::path::PathBuf;
use std::process::{Child, Command, Stdio}; use std::process::{Child, Command, Stdio};
use std::string::String; use std::string::String;
use std::sync::mpsc::Receiver; use std::sync::mpsc::Receiver;
use std::sync::{mpsc, Mutex}; use std::sync::{Mutex, mpsc};
use std::time::Duration; use std::time::Duration;
use std::{fs, io, thread}; use std::{fs, io, thread};
@ -719,10 +719,12 @@ fn setup_ovs_dpdk() {
assert!(exec_host_command_status("service openvswitch-switch restart").success()); assert!(exec_host_command_status("service openvswitch-switch restart").success());
// Create OVS-DPDK bridge and ports // Create OVS-DPDK bridge and ports
assert!(exec_host_command_status( assert!(
"ovs-vsctl add-br ovsbr0 -- set bridge ovsbr0 datapath_type=netdev", exec_host_command_status(
) "ovs-vsctl add-br ovsbr0 -- set bridge ovsbr0 datapath_type=netdev",
.success()); )
.success()
);
assert!(exec_host_command_status("ovs-vsctl add-port ovsbr0 vhost-user1 -- set Interface vhost-user1 type=dpdkvhostuserclient options:vhost-server-path=/tmp/dpdkvhostclient1").success()); assert!(exec_host_command_status("ovs-vsctl add-port ovsbr0 vhost-user1 -- set Interface vhost-user1 type=dpdkvhostuserclient options:vhost-server-path=/tmp/dpdkvhostclient1").success());
assert!(exec_host_command_status("ovs-vsctl add-port ovsbr0 vhost-user2 -- set Interface vhost-user2 type=dpdkvhostuserclient options:vhost-server-path=/tmp/dpdkvhostclient2").success()); assert!(exec_host_command_status("ovs-vsctl add-port ovsbr0 vhost-user2 -- set Interface vhost-user2 type=dpdkvhostuserclient options:vhost-server-path=/tmp/dpdkvhostclient2").success());
assert!(exec_host_command_status("ip link set up dev ovsbr0").success()); assert!(exec_host_command_status("ip link set up dev ovsbr0").success());
@ -1658,8 +1660,10 @@ fn _test_virtio_fs(
"{{\"id\":\"myfs0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}" "{{\"id\":\"myfs0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
))); )));
} else { } else {
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}")
);
} }
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
@ -1739,8 +1743,10 @@ fn _test_virtio_fs(
"{{\"id\":\"myfs0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}" "{{\"id\":\"myfs0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
))); )));
} else { } else {
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"myfs0\",\"bdf\":\"0000:00:06.0\"}")
);
} }
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
@ -1894,8 +1900,10 @@ fn _test_virtio_vsock(hotplug: bool) {
Some(format!("cid=3,socket={socket},id=test0").as_str()), Some(format!("cid=3,socket={socket},id=test0").as_str()),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
);
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
// Check adding a second one fails // Check adding a second one fails
assert!(!remote_command( assert!(!remote_command(
@ -2112,18 +2120,20 @@ fn get_counters(api_socket: &str) -> Counters {
fn pty_read(mut pty: std::fs::File) -> Receiver<String> { fn pty_read(mut pty: std::fs::File) -> Receiver<String> {
let (tx, rx) = mpsc::channel::<String>(); let (tx, rx) = mpsc::channel::<String>();
thread::spawn(move || loop { thread::spawn(move || {
thread::sleep(std::time::Duration::new(1, 0)); loop {
let mut buf = [0; 512]; thread::sleep(std::time::Duration::new(1, 0));
match pty.read(&mut buf) { let mut buf = [0; 512];
Ok(_bytes) => { match pty.read(&mut buf) {
let output = std::str::from_utf8(&buf).unwrap().to_string(); Ok(_bytes) => {
match tx.send(output) { let output = std::str::from_utf8(&buf).unwrap().to_string();
Ok(_) => (), match tx.send(output) {
Err(_) => break, Ok(_) => (),
Err(_) => break,
}
} }
Err(_) => break,
} }
Err(_) => break,
} }
}); });
rx rx
@ -2257,9 +2267,11 @@ fn _test_virtio_iommu(acpi: bool) {
guest.wait_vm_boot(None).unwrap(); guest.wait_vm_boot(None).unwrap();
// Verify the virtio-iommu device is present. // Verify the virtio-iommu device is present.
assert!(guest assert!(
.does_device_vendor_pair_match("0x1057", "0x1af4") guest
.unwrap_or_default()); .does_device_vendor_pair_match("0x1057", "0x1af4")
.unwrap_or_default()
);
// On AArch64, if the guest system boots from FDT, the behavior of IOMMU is a bit // On AArch64, if the guest system boots from FDT, the behavior of IOMMU is a bit
// different with ACPI. // different with ACPI.
@ -2319,9 +2331,11 @@ fn get_reboot_count(guest: &Guest) -> u32 {
fn enable_guest_watchdog(guest: &Guest, watchdog_sec: u32) { fn enable_guest_watchdog(guest: &Guest, watchdog_sec: u32) {
// Check for PCI device // Check for PCI device
assert!(guest assert!(
.does_device_vendor_pair_match("0x1063", "0x1af4") guest
.unwrap_or_default()); .does_device_vendor_pair_match("0x1063", "0x1af4")
.unwrap_or_default()
);
// Enable systemd watchdog // Enable systemd watchdog
guest guest
@ -2335,9 +2349,11 @@ fn enable_guest_watchdog(guest: &Guest, watchdog_sec: u32) {
fn make_guest_panic(guest: &Guest) { fn make_guest_panic(guest: &Guest) {
// Check for pvpanic device // Check for pvpanic device
assert!(guest assert!(
.does_device_vendor_pair_match("0x0011", "0x1b36") guest
.unwrap_or_default()); .does_device_vendor_pair_match("0x0011", "0x1b36")
.unwrap_or_default()
);
// Trigger guest a panic // Trigger guest a panic
guest.ssh_command("screen -dmS reboot sh -c \"sleep 5; echo s | tee /proc/sysrq-trigger; echo c | sudo tee /proc/sysrq-trigger\"").unwrap(); guest.ssh_command("screen -dmS reboot sh -c \"sleep 5; echo s | tee /proc/sysrq-trigger; echo c | sudo tee /proc/sysrq-trigger\"").unwrap();
@ -2974,13 +2990,17 @@ mod common_parallel {
), ),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test0\",\"bdf\":\"0001:00:01.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test0\",\"bdf\":\"0001:00:01.0\"}")
);
// Check IOMMU setup // Check IOMMU setup
assert!(guest assert!(
.does_device_vendor_pair_match("0x1057", "0x1af4") guest
.unwrap_or_default()); .does_device_vendor_pair_match("0x1057", "0x1af4")
.unwrap_or_default()
);
assert_eq!( assert_eq!(
guest guest
.ssh_command("ls /sys/kernel/iommu_groups/0/devices") .ssh_command("ls /sys/kernel/iommu_groups/0/devices")
@ -4429,9 +4449,11 @@ mod common_parallel {
let r = std::panic::catch_unwind(|| { let r = std::panic::catch_unwind(|| {
guest.wait_vm_boot(None).unwrap(); guest.wait_vm_boot(None).unwrap();
assert!(guest assert!(
.does_device_vendor_pair_match("0x1043", "0x1af4") guest
.unwrap_or_default()); .does_device_vendor_pair_match("0x1043", "0x1af4")
.unwrap_or_default()
);
guest.ssh_command(&cmd).unwrap(); guest.ssh_command(&cmd).unwrap();
}); });
@ -5407,8 +5429,10 @@ mod common_parallel {
), ),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
);
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
@ -5454,8 +5478,10 @@ mod common_parallel {
), ),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
);
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
@ -5953,8 +5979,10 @@ mod common_parallel {
"{{\"id\":\"test0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}" "{{\"id\":\"test0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
))); )));
} else { } else {
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:06.0\"}")
);
} }
// Check that /dev/pmem0 exists and the block size is 128M // Check that /dev/pmem0 exists and the block size is 128M
@ -6084,8 +6112,10 @@ mod common_parallel {
"{{\"id\":\"test0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}" "{{\"id\":\"test0\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
))); )));
} else { } else {
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:05.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test0\",\"bdf\":\"0000:00:05.0\"}")
);
} }
thread::sleep(std::time::Duration::new(5, 0)); thread::sleep(std::time::Duration::new(5, 0));
@ -6128,8 +6158,10 @@ mod common_parallel {
"{{\"id\":\"test1\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}" "{{\"id\":\"test1\",\"bdf\":\"{pci_segment:04x}:00:01.0\"}}"
))); )));
} else { } else {
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"test1\",\"bdf\":\"0000:00:05.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"test1\",\"bdf\":\"0000:00:05.0\"}")
);
} }
thread::sleep(std::time::Duration::new(5, 0)); thread::sleep(std::time::Duration::new(5, 0));
@ -6566,15 +6598,19 @@ mod common_parallel {
let phy_net = "eth0"; let phy_net = "eth0";
// Create a macvtap interface for the guest VM to use // Create a macvtap interface for the guest VM to use
assert!(exec_host_command_status(&format!( assert!(
"sudo ip link add link {phy_net} name {guest_macvtap_name} type macvtap mod bridge" exec_host_command_status(&format!(
)) "sudo ip link add link {phy_net} name {guest_macvtap_name} type macvtap mod bridge"
.success()); ))
assert!(exec_host_command_status(&format!( .success()
"sudo ip link set {} address {} up", );
guest_macvtap_name, guest.network.guest_mac assert!(
)) exec_host_command_status(&format!(
.success()); "sudo ip link set {} address {} up",
guest_macvtap_name, guest.network.guest_mac
))
.success()
);
assert!( assert!(
exec_host_command_status(&format!("sudo ip link show {guest_macvtap_name}")).success() exec_host_command_status(&format!("sudo ip link show {guest_macvtap_name}")).success()
); );
@ -6593,16 +6629,20 @@ mod common_parallel {
// Create a macvtap on the same physical net interface for // Create a macvtap on the same physical net interface for
// the host machine to use // the host machine to use
assert!(exec_host_command_status(&format!( assert!(
"sudo ip link add link {phy_net} name {host_macvtap_name} type macvtap mod bridge" exec_host_command_status(&format!(
)) "sudo ip link add link {phy_net} name {host_macvtap_name} type macvtap mod bridge"
.success()); ))
.success()
);
// Use default mask "255.255.255.0" // Use default mask "255.255.255.0"
assert!(exec_host_command_status(&format!( assert!(
"sudo ip address add {}/24 dev {}", exec_host_command_status(&format!(
guest.network.host_ip, host_macvtap_name "sudo ip address add {}/24 dev {}",
)) guest.network.host_ip, host_macvtap_name
.success()); ))
.success()
);
assert!( assert!(
exec_host_command_status(&format!("sudo ip link set dev {host_macvtap_name} up")) exec_host_command_status(&format!("sudo ip link set dev {host_macvtap_name} up"))
.success() .success()
@ -6638,11 +6678,15 @@ mod common_parallel {
remote_command_w_output(&api_socket, "add-net", Some(&net_params)); remote_command_w_output(&api_socket, "add-net", Some(&net_params));
assert!(cmd_success); assert!(cmd_success);
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"_net2\",\"bdf\":\"0000:00:05.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"_net2\",\"bdf\":\"0000:00:05.0\"}")
);
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"_net0\",\"bdf\":\"0000:00:05.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"_net0\",\"bdf\":\"0000:00:05.0\"}")
);
} }
// The functional connectivity provided by the virtio-net device // The functional connectivity provided by the virtio-net device
@ -6818,21 +6862,27 @@ mod common_parallel {
fn setup_spdk_nvme(nvme_dir: &std::path::Path) -> Child { fn setup_spdk_nvme(nvme_dir: &std::path::Path) -> Child {
cleanup_spdk_nvme(); cleanup_spdk_nvme();
assert!(exec_host_command_status(&format!( assert!(
"mkdir -p {}", exec_host_command_status(&format!(
nvme_dir.join("nvme-vfio-user").to_str().unwrap() "mkdir -p {}",
)) nvme_dir.join("nvme-vfio-user").to_str().unwrap()
.success()); ))
assert!(exec_host_command_status(&format!( .success()
"truncate {} -s 128M", );
nvme_dir.join("test-disk.raw").to_str().unwrap() assert!(
)) exec_host_command_status(&format!(
.success()); "truncate {} -s 128M",
assert!(exec_host_command_status(&format!( nvme_dir.join("test-disk.raw").to_str().unwrap()
"mkfs.ext4 {}", ))
nvme_dir.join("test-disk.raw").to_str().unwrap() .success()
)) );
.success()); assert!(
exec_host_command_status(&format!(
"mkfs.ext4 {}",
nvme_dir.join("test-disk.raw").to_str().unwrap()
))
.success()
);
// Start the SPDK nvmf_tgt daemon to present NVMe device as a VFIO user device // Start the SPDK nvmf_tgt daemon to present NVMe device as a VFIO user device
let child = Command::new("/usr/local/bin/spdk-nvme/nvmf_tgt") let child = Command::new("/usr/local/bin/spdk-nvme/nvmf_tgt")
@ -6846,11 +6896,13 @@ mod common_parallel {
3, 3,
std::time::Duration::new(5, 0), std::time::Duration::new(5, 0),
)); ));
assert!(exec_host_command_status(&format!( assert!(
"/usr/local/bin/spdk-nvme/rpc.py bdev_aio_create {} test 512", exec_host_command_status(&format!(
nvme_dir.join("test-disk.raw").to_str().unwrap() "/usr/local/bin/spdk-nvme/rpc.py bdev_aio_create {} test 512",
)) nvme_dir.join("test-disk.raw").to_str().unwrap()
.success()); ))
.success()
);
assert!(exec_host_command_status( assert!(exec_host_command_status(
"/usr/local/bin/spdk-nvme/rpc.py nvmf_create_subsystem nqn.2019-07.io.spdk:cnode -a -s test" "/usr/local/bin/spdk-nvme/rpc.py nvmf_create_subsystem nqn.2019-07.io.spdk:cnode -a -s test"
) )
@ -6911,8 +6963,10 @@ mod common_parallel {
)), )),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"vfio_user0\",\"bdf\":\"0000:00:05.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"vfio_user0\",\"bdf\":\"0000:00:05.0\"}")
);
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
@ -7017,15 +7071,19 @@ mod common_parallel {
Some("id=myvdpa0,path=/dev/vhost-vdpa-1,num_queues=1,pci_segment=1,iommu=on"), Some("id=myvdpa0,path=/dev/vhost-vdpa-1,num_queues=1,pci_segment=1,iommu=on"),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"myvdpa0\",\"bdf\":\"0001:00:01.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"myvdpa0\",\"bdf\":\"0001:00:01.0\"}")
);
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
// Check IOMMU setup // Check IOMMU setup
assert!(guest assert!(
.does_device_vendor_pair_match("0x1057", "0x1af4") guest
.unwrap_or_default()); .does_device_vendor_pair_match("0x1057", "0x1af4")
.unwrap_or_default()
);
assert_eq!( assert_eq!(
guest guest
.ssh_command("ls /sys/kernel/iommu_groups/0/devices") .ssh_command("ls /sys/kernel/iommu_groups/0/devices")
@ -7419,7 +7477,7 @@ mod ivshmem {
use std::fs::remove_dir_all; use std::fs::remove_dir_all;
use std::process::Command; use std::process::Command;
use test_infra::{handle_child_output, kill_child, Guest, GuestCommand, UbuntuDiskConfig}; use test_infra::{Guest, GuestCommand, UbuntuDiskConfig, handle_child_output, kill_child};
use crate::*; use crate::*;
@ -9404,8 +9462,10 @@ mod windows {
Some(format!("path={disk},readonly=off").as_str()), Some(format!("path={disk},readonly=off").as_str()),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains(format!("\"id\":\"{disk_id}\"").as_str())); String::from_utf8_lossy(&cmd_output)
.contains(format!("\"id\":\"{disk_id}\"").as_str())
);
thread::sleep(std::time::Duration::new(5, 0)); thread::sleep(std::time::Duration::new(5, 0));
// Online disk devices // Online disk devices
windows_guest.disks_set_rw(); windows_guest.disks_set_rw();
@ -9615,8 +9675,10 @@ mod vfio {
Some(format!("id=vfio0,path={NVIDIA_VFIO_DEVICE}").as_str()), Some(format!("id=vfio0,path={NVIDIA_VFIO_DEVICE}").as_str()),
); );
assert!(cmd_success); assert!(cmd_success);
assert!(String::from_utf8_lossy(&cmd_output) assert!(
.contains("{\"id\":\"vfio0\",\"bdf\":\"0000:00:06.0\"}")); String::from_utf8_lossy(&cmd_output)
.contains("{\"id\":\"vfio0\",\"bdf\":\"0000:00:06.0\"}")
);
thread::sleep(std::time::Duration::new(10, 0)); thread::sleep(std::time::Duration::new(10, 0));
@ -9694,10 +9756,12 @@ mod vfio {
let r = std::panic::catch_unwind(|| { let r = std::panic::catch_unwind(|| {
guest.wait_vm_boot(None).unwrap(); guest.wait_vm_boot(None).unwrap();
assert!(guest assert!(
.ssh_command("sudo dmesg") guest
.unwrap() .ssh_command("sudo dmesg")
.contains("input address: 42 bits")); .unwrap()
.contains("input address: 42 bits")
);
}); });
let _ = child.kill(); let _ = child.kill();
@ -9818,13 +9882,13 @@ mod live_migration {
let _ = dest_vm.kill(); let _ = dest_vm.kill();
let dest_output = dest_vm.wait_with_output().unwrap(); let dest_output = dest_vm.wait_with_output().unwrap();
eprintln!( eprintln!(
"\n\n==== Start 'destination_vm' stdout ====\n\n{}\n\n==== End 'destination_vm' stdout ====", "\n\n==== Start 'destination_vm' stdout ====\n\n{}\n\n==== End 'destination_vm' stdout ====",
String::from_utf8_lossy(&dest_output.stdout) String::from_utf8_lossy(&dest_output.stdout)
); );
eprintln!( eprintln!(
"\n\n==== Start 'destination_vm' stderr ====\n\n{}\n\n==== End 'destination_vm' stderr ====", "\n\n==== Start 'destination_vm' stderr ====\n\n{}\n\n==== End 'destination_vm' stderr ====",
String::from_utf8_lossy(&dest_output.stderr) String::from_utf8_lossy(&dest_output.stderr)
); );
if let Some(ovs_vm) = ovs_vm { if let Some(ovs_vm) = ovs_vm {
let mut ovs_vm = ovs_vm; let mut ovs_vm = ovs_vm;
@ -11382,11 +11446,13 @@ mod rate_limiter {
String::from(test_img_dir.as_path().join("blk.img").to_str().unwrap()); String::from(test_img_dir.as_path().join("blk.img").to_str().unwrap());
// Create the test block image // Create the test block image
assert!(exec_host_command_output(&format!( assert!(
"dd if=/dev/zero of={blk_rate_limiter_test_img} bs=1M count=1024" exec_host_command_output(&format!(
)) "dd if=/dev/zero of={blk_rate_limiter_test_img} bs=1M count=1024"
.status ))
.success()); .status
.success()
);
let test_blk_params = if bandwidth { let test_blk_params = if bandwidth {
format!( format!(
@ -11491,11 +11557,13 @@ mod rate_limiter {
.unwrap(), .unwrap(),
); );
assert!(exec_host_command_output(&format!( assert!(
"dd if=/dev/zero of={test_img_path} bs=1M count=1024" exec_host_command_output(&format!(
)) "dd if=/dev/zero of={test_img_path} bs=1M count=1024"
.status ))
.success()); .status
.success()
);
disk_args.push(format!( disk_args.push(format!(
"path={test_img_path},num_queues={num_queues},rate_limit_group=group0" "path={test_img_path},num_queues={num_queues},rate_limit_group=group0"

4
vhost_user_block/src/lib.rs
View file

@ -19,13 +19,13 @@ use std::time::Instant;
use std::{convert, io, process, result}; use std::{convert, io, process, result};
use block::qcow::{self, ImageType, QcowFile}; use block::qcow::{self, ImageType, QcowFile};
use block::{build_serial, Request, VirtioBlockConfig}; use block::{Request, VirtioBlockConfig, build_serial};
use libc::EFD_NONBLOCK; use libc::EFD_NONBLOCK;
use log::*; use log::*;
use option_parser::{OptionParser, OptionParserError, Toggle}; use option_parser::{OptionParser, OptionParserError, Toggle};
use thiserror::Error; use thiserror::Error;
use vhost::vhost_user::message::*;
use vhost::vhost_user::Listener; use vhost::vhost_user::Listener;
use vhost::vhost_user::message::*;
use vhost_user_backend::bitmap::BitmapMmapRegion; use vhost_user_backend::bitmap::BitmapMmapRegion;
use vhost_user_backend::{VhostUserBackendMut, VhostUserDaemon, VringRwLock, VringState, VringT}; use vhost_user_backend::{VhostUserBackendMut, VhostUserDaemon, VringRwLock, VringState, VringT};
use virtio_bindings::virtio_blk::*; use virtio_bindings::virtio_blk::*;

4
vhost_user_net/src/lib.rs
View file

@ -15,12 +15,12 @@ use std::{io, process};
use libc::EFD_NONBLOCK; use libc::EFD_NONBLOCK;
use log::*; use log::*;
use net_util::{ use net_util::{
open_tap, MacAddr, NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TxVirtio, MacAddr, NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TxVirtio, open_tap,
}; };
use option_parser::{OptionParser, OptionParserError, Toggle}; use option_parser::{OptionParser, OptionParserError, Toggle};
use thiserror::Error; use thiserror::Error;
use vhost::vhost_user::message::*;
use vhost::vhost_user::Listener; use vhost::vhost_user::Listener;
use vhost::vhost_user::message::*;
use vhost_user_backend::bitmap::BitmapMmapRegion; use vhost_user_backend::bitmap::BitmapMmapRegion;
use vhost_user_backend::{VhostUserBackendMut, VhostUserDaemon, VringRwLock, VringT}; use vhost_user_backend::{VhostUserBackendMut, VhostUserDaemon, VringRwLock, VringT};
use virtio_bindings::virtio_config::{VIRTIO_F_NOTIFY_ON_EMPTY, VIRTIO_F_VERSION_1}; use virtio_bindings::virtio_config::{VIRTIO_F_NOTIFY_ON_EMPTY, VIRTIO_F_VERSION_1};

18
virtio-devices/src/balloon.rs
View file

@ -37,9 +37,9 @@ use vmm_sys_util::eventfd::EventFd;
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;
use crate::{ use crate::{
ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, GuestMemoryMmap, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt, VirtioInterruptType, GuestMemoryMmap, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1, VirtioInterrupt, VirtioInterruptType,
}; };
const QUEUE_SIZE: u16 = 128; const QUEUE_SIZE: u16 = 128;
@ -575,12 +575,12 @@ impl VirtioDevice for Balloon {
let data_len = data.len() as u64; let data_len = data.len() as u64;
if offset + data_len > config_len { if offset + data_len > config_len {
error!( error!(
"Out-of-bound access to configuration: config_len = {} offset = {:x} length = {} for {}", "Out-of-bound access to configuration: config_len = {} offset = {:x} length = {} for {}",
config_len, config_len,
offset, offset,
data_len, data_len,
self.device_type() self.device_type()
); );
return; return;
} }

12
virtio-devices/src/block.rs
View file

@ -19,12 +19,12 @@ use std::{io, result};
use anyhow::anyhow; use anyhow::anyhow;
use block::async_io::{AsyncIo, AsyncIoError, DiskFile}; use block::async_io::{AsyncIo, AsyncIoError, DiskFile};
use block::fcntl::{get_lock_state, LockError, LockType}; use block::fcntl::{LockError, LockType, get_lock_state};
use block::{ use block::{
build_serial, fcntl, ExecuteAsync, ExecuteError, Request, RequestType, VirtioBlockConfig, ExecuteAsync, ExecuteError, Request, RequestType, VirtioBlockConfig, build_serial, fcntl,
}; };
use rate_limiter::group::{RateLimiterGroup, RateLimiterGroupHandle};
use rate_limiter::TokenType; use rate_limiter::TokenType;
use rate_limiter::group::{RateLimiterGroup, RateLimiterGroupHandle};
use seccompiler::SeccompAction; use seccompiler::SeccompAction;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
@ -38,9 +38,9 @@ use vm_virtio::AccessPlatform;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterruptType, EpollHelperHandler, Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType,
EPOLL_HELPER_EVENT_LAST, VirtioInterruptType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

6
virtio-devices/src/console.rs
View file

@ -22,9 +22,9 @@ use vm_virtio::{AccessPlatform, Translatable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, Error as DeviceError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterruptType, EPOLL_HELPER_EVENT_LAST, Error as DeviceError, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice,
VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1, VirtioDeviceType, VirtioInterruptType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

4
virtio-devices/src/iommu.rs
View file

@ -24,8 +24,8 @@ use vm_virtio::AccessPlatform;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, Error as DeviceError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_VERSION_1, Error as DeviceError, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

4
virtio-devices/src/lib.rs
View file

@ -51,10 +51,10 @@ pub use self::device::{
VirtioSharedMemoryList, VirtioSharedMemoryList,
}; };
pub use self::epoll_helper::{ pub use self::epoll_helper::{
EpollHelper, EpollHelperError, EpollHelperHandler, EPOLL_HELPER_EVENT_LAST, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
}; };
pub use self::iommu::{AccessPlatformMapping, Iommu, IommuMapping}; pub use self::iommu::{AccessPlatformMapping, Iommu, IommuMapping};
pub use self::mem::{BlocksState, Mem, VirtioMemMappingSource, VIRTIO_MEM_ALIGN_SIZE}; pub use self::mem::{BlocksState, Mem, VIRTIO_MEM_ALIGN_SIZE, VirtioMemMappingSource};
pub use self::net::{Net, NetCtrlEpollHandler}; pub use self::net::{Net, NetCtrlEpollHandler};
pub use self::pmem::Pmem; pub use self::pmem::Pmem;
pub use self::rng::Rng; pub use self::rng::Rng;

8
virtio-devices/src/mem.rs
View file

@ -18,7 +18,7 @@ use std::collections::BTreeMap;
use std::mem::size_of; use std::mem::size_of;
use std::os::unix::io::{AsRawFd, RawFd}; use std::os::unix::io::{AsRawFd, RawFd};
use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicBool;
use std::sync::{mpsc, Arc, Barrier, Mutex}; use std::sync::{Arc, Barrier, Mutex, mpsc};
use std::{io, result}; use std::{io, result};
use anyhow::anyhow; use anyhow::anyhow;
@ -36,9 +36,9 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, EpollHelperHandler, Error as DeviceError, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice,
VIRTIO_F_VERSION_1, VirtioDeviceType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

10
virtio-devices/src/net.rs
View file

@ -18,8 +18,8 @@ use anyhow::anyhow;
#[cfg(not(fuzzing))] #[cfg(not(fuzzing))]
use net_util::virtio_features_to_tap_offload; use net_util::virtio_features_to_tap_offload;
use net_util::{ use net_util::{
build_net_config_space, build_net_config_space_with_mq, open_tap, CtrlQueue, MacAddr, CtrlQueue, MacAddr, NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TapError, TxVirtio,
NetCounters, NetQueuePair, OpenTapError, RxVirtio, Tap, TapError, TxVirtio, VirtioNetConfig, VirtioNetConfig, build_net_config_space, build_net_config_space_with_mq, open_tap,
}; };
use seccompiler::SeccompAction; use seccompiler::SeccompAction;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -34,9 +34,9 @@ use vm_virtio::AccessPlatform;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
Error as DeviceError, RateLimiterConfig, VirtioCommon, VirtioDevice, VirtioDeviceType, EpollHelperHandler, Error as DeviceError, RateLimiterConfig, VirtioCommon, VirtioDevice,
VirtioInterruptType, EPOLL_HELPER_EVENT_LAST, VirtioDeviceType, VirtioInterruptType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

6
virtio-devices/src/pmem.rs
View file

@ -28,9 +28,9 @@ use vm_virtio::{AccessPlatform, Translatable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, EpollHelperHandler, Error as DeviceError, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

6
virtio-devices/src/rng.rs
View file

@ -21,9 +21,9 @@ use vm_virtio::{AccessPlatform, Translatable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, EpollHelperHandler, Error as DeviceError, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1,
VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

16
virtio-devices/src/seccomp_filters.rs
View file

@ -53,13 +53,15 @@ const VFIO_IOMMU_UNMAP_DMA: u64 = 0x3b72;
#[cfg(feature = "sev_snp")] #[cfg(feature = "sev_snp")]
fn mshv_sev_snp_ioctl_seccomp_rule() -> SeccompRule { fn mshv_sev_snp_ioctl_seccomp_rule() -> SeccompRule {
and![Cond::new( and![
1, Cond::new(
ArgLen::Dword, 1,
Eq, ArgLen::Dword,
mshv_ioctls::MSHV_MODIFY_GPA_HOST_ACCESS() Eq,
) mshv_ioctls::MSHV_MODIFY_GPA_HOST_ACCESS()
.unwrap()] )
.unwrap()
]
} }
#[cfg(feature = "sev_snp")] #[cfg(feature = "sev_snp")]

6
virtio-devices/src/thread_helper.rs
View file

@ -6,12 +6,12 @@
use std::panic::AssertUnwindSafe; use std::panic::AssertUnwindSafe;
use std::thread::{self, JoinHandle}; use std::thread::{self, JoinHandle};
use seccompiler::{apply_filter, SeccompAction}; use seccompiler::{SeccompAction, apply_filter};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::epoll_helper::EpollHelperError;
use crate::seccomp_filters::{get_seccomp_filter, Thread};
use crate::ActivateError; use crate::ActivateError;
use crate::epoll_helper::EpollHelperError;
use crate::seccomp_filters::{Thread, get_seccomp_filter};
pub(crate) fn spawn_virtio_thread<F>( pub(crate) fn spawn_virtio_thread<F>(
name: &str, name: &str,

2
virtio-devices/src/transport/mod.rs
View file

@ -5,7 +5,7 @@
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
mod pci_common_config; mod pci_common_config;
mod pci_device; mod pci_device;
pub use pci_common_config::{VirtioPciCommonConfig, VIRTIO_PCI_COMMON_CONFIG_ID}; pub use pci_common_config::{VIRTIO_PCI_COMMON_CONFIG_ID, VirtioPciCommonConfig};
pub use pci_device::{VirtioPciDevice, VirtioPciDeviceActivator, VirtioPciDeviceError}; pub use pci_device::{VirtioPciDevice, VirtioPciDeviceActivator, VirtioPciDeviceError};
pub trait VirtioTransport { pub trait VirtioTransport {

10
virtio-devices/src/transport/pci_device.rs
View file

@ -35,11 +35,11 @@ use vm_virtio::AccessPlatform;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::pci_common_config::VirtioPciCommonConfigState; use super::pci_common_config::VirtioPciCommonConfigState;
use crate::transport::{VirtioPciCommonConfig, VirtioTransport, VIRTIO_PCI_COMMON_CONFIG_ID}; use crate::transport::{VIRTIO_PCI_COMMON_CONFIG_ID, VirtioPciCommonConfig, VirtioTransport};
use crate::{ use crate::{
ActivateResult, GuestMemoryMmap, VirtioDevice, VirtioDeviceType, VirtioInterrupt, ActivateResult, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FAILED,
VirtioInterruptType, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FAILED, DEVICE_FEATURES_OK, DEVICE_INIT, GuestMemoryMmap, VirtioDevice, VirtioDeviceType,
DEVICE_FEATURES_OK, DEVICE_INIT, VirtioInterrupt, VirtioInterruptType,
}; };
/// Vector value used to disable MSI for a queue. /// Vector value used to disable MSI for a queue.
@ -973,7 +973,7 @@ impl PciDevice for VirtioPciDevice {
settings_bar_addr = Some(GuestAddress(base)); settings_bar_addr = Some(GuestAddress(base));
use_64bit_bar = match type_ { use_64bit_bar = match type_ {
PciBarType::Io => { PciBarType::Io => {
return Err(PciDeviceError::InvalidResource(resource)) return Err(PciDeviceError::InvalidResource(resource));
} }
PciBarType::Mmio32 => false, PciBarType::Mmio32 => false,
PciBarType::Mmio64 => true, PciBarType::Mmio64 => true,

8
virtio-devices/src/vdpa.rs
View file

@ -12,9 +12,9 @@ use anyhow::anyhow;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
use vhost::vdpa::{VhostVdpa, VhostVdpaIovaRange}; use vhost::vdpa::{VhostVdpa, VhostVdpaIovaRange};
use vhost::vhost_kern::VhostKernFeatures;
use vhost::vhost_kern::vdpa::VhostKernVdpa; use vhost::vhost_kern::vdpa::VhostKernVdpa;
use vhost::vhost_kern::vhost_binding::VHOST_BACKEND_F_SUSPEND; use vhost::vhost_kern::vhost_binding::VHOST_BACKEND_F_SUSPEND;
use vhost::vhost_kern::VhostKernFeatures;
use vhost::{VhostBackend, VringConfigData}; use vhost::{VhostBackend, VringConfigData};
use virtio_queue::desc::RawDescriptor; use virtio_queue::desc::RawDescriptor;
use virtio_queue::{Queue, QueueT}; use virtio_queue::{Queue, QueueT};
@ -25,9 +25,9 @@ use vm_virtio::{AccessPlatform, Translatable};
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use crate::{ use crate::{
ActivateError, ActivateResult, GuestMemoryMmap, VirtioCommon, VirtioDevice, VirtioInterrupt, ActivateError, ActivateResult, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK,
VirtioInterruptType, DEVICE_ACKNOWLEDGE, DEVICE_DRIVER, DEVICE_DRIVER_OK, DEVICE_FEATURES_OK, DEVICE_FEATURES_OK, GuestMemoryMmap, VIRTIO_F_IOMMU_PLATFORM, VirtioCommon, VirtioDevice,
VIRTIO_F_IOMMU_PLATFORM, VirtioInterrupt, VirtioInterruptType,
}; };
#[derive(Error, Debug)] #[derive(Error, Debug)]

14
virtio-devices/src/vhost_user/blk.rs
View file

@ -9,8 +9,8 @@ use block::VirtioBlockConfig;
use seccompiler::SeccompAction; use seccompiler::SeccompAction;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use vhost::vhost_user::message::{ use vhost::vhost_user::message::{
VhostUserConfigFlags, VhostUserProtocolFeatures, VhostUserVirtioFeatures, VHOST_USER_CONFIG_OFFSET, VhostUserConfigFlags, VhostUserProtocolFeatures,
VHOST_USER_CONFIG_OFFSET, VhostUserVirtioFeatures,
}; };
use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler}; use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
use virtio_bindings::virtio_blk::{ use virtio_bindings::virtio_blk::{
@ -26,11 +26,11 @@ use vmm_sys_util::eventfd::EventFd;
use super::super::{ActivateResult, VirtioCommon, VirtioDevice, VirtioDeviceType}; use super::super::{ActivateResult, VirtioCommon, VirtioDevice, VirtioDeviceType};
use super::vu_common_ctrl::{VhostUserConfig, VhostUserHandle}; use super::vu_common_ctrl::{VhostUserConfig, VhostUserHandle};
use super::{Error, Result, DEFAULT_VIRTIO_FEATURES}; use super::{DEFAULT_VIRTIO_FEATURES, Error, Result};
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;
use crate::vhost_user::VhostUserCommon; use crate::vhost_user::VhostUserCommon;
use crate::{GuestMemoryMmap, GuestRegionMmap, VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM}; use crate::{GuestMemoryMmap, GuestRegionMmap, VIRTIO_F_IOMMU_PLATFORM, VirtioInterrupt};
const DEFAULT_QUEUE_NUMBER: usize = 1; const DEFAULT_QUEUE_NUMBER: usize = 1;
@ -134,8 +134,10 @@ impl Blk {
}; };
if num_queues > backend_num_queues { if num_queues > backend_num_queues {
error!("vhost-user-blk requested too many queues ({}) since the backend only supports {}\n", error!(
num_queues, backend_num_queues); "vhost-user-blk requested too many queues ({}) since the backend only supports {}\n",
num_queues, backend_num_queues
);
return Err(Error::BadQueueNum); return Err(Error::BadQueueNum);
} }

14
virtio-devices/src/vhost_user/fs.rs
View file

@ -7,7 +7,7 @@ use std::{result, thread};
use seccompiler::SeccompAction; use seccompiler::SeccompAction;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use serde_with::{serde_as, Bytes}; use serde_with::{Bytes, serde_as};
use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures}; use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler}; use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontend, VhostUserFrontendReqHandler};
use virtio_queue::Queue; use virtio_queue::Queue;
@ -18,13 +18,13 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::vu_common_ctrl::VhostUserHandle; use super::vu_common_ctrl::VhostUserHandle;
use super::{Error, Result, DEFAULT_VIRTIO_FEATURES}; use super::{DEFAULT_VIRTIO_FEATURES, Error, Result};
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;
use crate::vhost_user::VhostUserCommon; use crate::vhost_user::VhostUserCommon;
use crate::{ use crate::{
ActivateResult, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioCommon, VirtioDevice, ActivateResult, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VIRTIO_F_IOMMU_PLATFORM,
VirtioDeviceType, VirtioInterrupt, VirtioSharedMemoryList, VIRTIO_F_IOMMU_PLATFORM, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt, VirtioSharedMemoryList,
}; };
const NUM_QUEUE_OFFSET: usize = 1; const NUM_QUEUE_OFFSET: usize = 1;
@ -148,9 +148,9 @@ impl Fs {
if num_queues > backend_num_queues { if num_queues > backend_num_queues {
error!( error!(
"vhost-user-fs requested too many queues ({}) since the backend only supports {}\n", "vhost-user-fs requested too many queues ({}) since the backend only supports {}\n",
num_queues, backend_num_queues num_queues, backend_num_queues
); );
return Err(Error::BadQueueNum); return Err(Error::BadQueueNum);
} }

10
virtio-devices/src/vhost_user/mod.rs
View file

@ -10,11 +10,11 @@ use std::sync::{Arc, Barrier, Mutex};
use anyhow::anyhow; use anyhow::anyhow;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use thiserror::Error; use thiserror::Error;
use vhost::Error as VhostError;
use vhost::vhost_user::message::{ use vhost::vhost_user::message::{
VhostUserInflight, VhostUserProtocolFeatures, VhostUserVirtioFeatures, VhostUserInflight, VhostUserProtocolFeatures, VhostUserVirtioFeatures,
}; };
use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontendReqHandler}; use vhost::vhost_user::{FrontendReqHandler, VhostUserFrontendReqHandler};
use vhost::Error as VhostError;
use virtio_queue::{Error as QueueError, Queue}; use virtio_queue::{Error as QueueError, Queue};
use vm_memory::mmap::MmapRegionError; use vm_memory::mmap::MmapRegionError;
use vm_memory::{Address, Error as MmapError, GuestAddressSpace, GuestMemory, GuestMemoryAtomic}; use vm_memory::{Address, Error as MmapError, GuestAddressSpace, GuestMemory, GuestMemoryAtomic};
@ -24,10 +24,10 @@ use vmm_sys_util::eventfd::EventFd;
use vu_common_ctrl::VhostUserHandle; use vu_common_ctrl::VhostUserHandle;
use crate::{ use crate::{
ActivateError, EpollHelper, EpollHelperError, EpollHelperHandler, GuestMemoryMmap, ActivateError, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
GuestRegionMmap, VirtioInterrupt, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_IN_ORDER, GuestMemoryMmap, GuestRegionMmap, VIRTIO_F_IN_ORDER, VIRTIO_F_NOTIFICATION_DATA,
VIRTIO_F_NOTIFICATION_DATA, VIRTIO_F_ORDER_PLATFORM, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_ORDER_PLATFORM, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_RING_INDIRECT_DESC,
VIRTIO_F_RING_INDIRECT_DESC, VIRTIO_F_VERSION_1, VIRTIO_F_VERSION_1, VirtioInterrupt,
}; };
pub mod blk; pub mod blk;

14
virtio-devices/src/vhost_user/net.rs
View file

@ -5,7 +5,7 @@ use std::sync::atomic::AtomicBool;
use std::sync::{Arc, Barrier, Mutex}; use std::sync::{Arc, Barrier, Mutex};
use std::{result, thread}; use std::{result, thread};
use net_util::{build_net_config_space, CtrlQueue, MacAddr, VirtioNetConfig}; use net_util::{CtrlQueue, MacAddr, VirtioNetConfig, build_net_config_space};
use seccompiler::SeccompAction; use seccompiler::SeccompAction;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures}; use vhost::vhost_user::message::{VhostUserProtocolFeatures, VhostUserVirtioFeatures};
@ -28,9 +28,9 @@ use crate::thread_helper::spawn_virtio_thread;
use crate::vhost_user::vu_common_ctrl::{VhostUserConfig, VhostUserHandle}; use crate::vhost_user::vu_common_ctrl::{VhostUserConfig, VhostUserHandle};
use crate::vhost_user::{Error, Result, VhostUserCommon}; use crate::vhost_user::{Error, Result, VhostUserCommon};
use crate::{ use crate::{
ActivateResult, GuestMemoryMmap, GuestRegionMmap, NetCtrlEpollHandler, VirtioCommon, ActivateResult, GuestMemoryMmap, GuestRegionMmap, NetCtrlEpollHandler, VIRTIO_F_IOMMU_PLATFORM,
VirtioDevice, VirtioDeviceType, VirtioInterrupt, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType,
VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_VERSION_1, VirtioInterrupt,
}; };
const DEFAULT_QUEUE_NUMBER: usize = 2; const DEFAULT_QUEUE_NUMBER: usize = 2;
@ -168,8 +168,10 @@ impl Net {
}; };
if num_queues > backend_num_queues { if num_queues > backend_num_queues {
error!("vhost-user-net requested too many queues ({}) since the backend only supports {}\n", error!(
num_queues, backend_num_queues); "vhost-user-net requested too many queues ({}) since the backend only supports {}\n",
num_queues, backend_num_queues
);
return Err(Error::BadQueueNum); return Err(Error::BadQueueNum);
} }

8
virtio-devices/src/vhost_user/vu_common_ctrl.rs
View file

@ -5,8 +5,8 @@ use std::ffi;
use std::fs::File; use std::fs::File;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd}; use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use std::os::unix::net::UnixListener; use std::os::unix::net::UnixListener;
use std::sync::atomic::Ordering;
use std::sync::Arc; use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::thread::sleep; use std::thread::sleep;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
@ -29,8 +29,8 @@ use vmm_sys_util::eventfd::EventFd;
use super::{Error, Result}; use super::{Error, Result};
use crate::vhost_user::Inflight; use crate::vhost_user::Inflight;
use crate::{ use crate::{
get_host_address_range, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioInterrupt, GuestMemoryMmap, GuestRegionMmap, MmapRegion, VirtioInterrupt, VirtioInterruptType,
VirtioInterruptType, get_host_address_range,
}; };
// Size of a dirty page for vhost-user. // Size of a dirty page for vhost-user.
@ -399,7 +399,7 @@ impl VhostUserHandle {
acked_features: 0, acked_features: 0,
vrings_info: None, vrings_info: None,
queue_indexes: Vec::new(), queue_indexes: Vec::new(),
}) });
} }
Err(e) => e, Err(e) => e,
}; };

20
virtio-devices/src/vsock/csm/connection.rs
View file

@ -89,7 +89,7 @@ use super::super::defs::uapi;
use super::super::packet::VsockPacket; use super::super::packet::VsockPacket;
use super::super::{Result as VsockResult, VsockChannel, VsockEpollListener, VsockError}; use super::super::{Result as VsockResult, VsockChannel, VsockEpollListener, VsockError};
use super::txbuf::TxBuf; use super::txbuf::TxBuf;
use super::{defs, ConnState, Error, PendingRx, PendingRxSet, Result}; use super::{ConnState, Error, PendingRx, PendingRxSet, Result, defs};
/// A self-managing connection object, that handles communication between a guest-side AF_VSOCK /// A self-managing connection object, that handles communication between a guest-side AF_VSOCK
/// socket and a host-side `Read + Write + AsRawFd` stream. /// socket and a host-side `Read + Write + AsRawFd` stream.
@ -1158,10 +1158,11 @@ mod tests {
// When there's data in the TX buffer, the connection should ask to be notified when it // When there's data in the TX buffer, the connection should ask to be notified when it
// can write to its backing stream. // can write to its backing stream.
assert!(ctx assert!(
.conn ctx.conn
.get_polled_evset() .get_polled_evset()
.contains(epoll::Events::EPOLLOUT)); .contains(epoll::Events::EPOLLOUT)
);
assert_eq!(ctx.conn.tx_buf.len(), data.len()); assert_eq!(ctx.conn.tx_buf.len(), data.len());
// Unlock the write stream and notify the connection it can now write its buffered // Unlock the write stream and notify the connection it can now write its buffered
@ -1212,10 +1213,11 @@ mod tests {
stream.write_state = StreamState::Closed; stream.write_state = StreamState::Closed;
ctx.set_stream(stream); ctx.set_stream(stream);
assert!(ctx assert!(
.conn ctx.conn
.get_polled_evset() .get_polled_evset()
.contains(epoll::Events::EPOLLOUT)); .contains(epoll::Events::EPOLLOUT)
);
ctx.notify_epollout(); ctx.notify_epollout();
assert_eq!(ctx.conn.state, ConnState::Killed); assert_eq!(ctx.conn.state, ConnState::Killed);
} }

2
virtio-devices/src/vsock/csm/txbuf.rs
View file

@ -5,7 +5,7 @@
use std::io::Write; use std::io::Write;
use std::num::Wrapping; use std::num::Wrapping;
use super::{defs, Error, Result}; use super::{Error, Result, defs};
/// A simple ring-buffer implementation, used by vsock connections to buffer TX (guest -> host) /// A simple ring-buffer implementation, used by vsock connections to buffer TX (guest -> host)
/// data. Memory for this buffer is allocated lazily, since buffering will only be needed when /// data. Memory for this buffer is allocated lazily, since buffering will only be needed when

8
virtio-devices/src/vsock/device.rs
View file

@ -47,10 +47,10 @@ use super::{VsockBackend, VsockPacket};
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;
use crate::{ use crate::{
ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, Error as DeviceError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError, EpollHelperHandler,
GuestMemoryMmap, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt, Error as DeviceError, GuestMemoryMmap, VIRTIO_F_IN_ORDER, VIRTIO_F_IOMMU_PLATFORM,
VirtioInterruptType, EPOLL_HELPER_EVENT_LAST, VIRTIO_F_IN_ORDER, VIRTIO_F_IOMMU_PLATFORM, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice, VirtioDeviceType, VirtioInterrupt,
VIRTIO_F_VERSION_1, VirtioInterruptType,
}; };
const QUEUE_SIZE: u16 = 256; const QUEUE_SIZE: u16 = 256;

2
virtio-devices/src/vsock/mod.rs
View file

@ -172,7 +172,7 @@ pub mod tests {
use vm_virtio::queue::testing::VirtQueue as GuestQ; use vm_virtio::queue::testing::VirtQueue as GuestQ;
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::device::{VsockEpollHandler, RX_QUEUE_EVENT, TX_QUEUE_EVENT}; use super::device::{RX_QUEUE_EVENT, TX_QUEUE_EVENT, VsockEpollHandler};
use super::packet::VSOCK_PKT_HDR_SIZE; use super::packet::VSOCK_PKT_HDR_SIZE;
use super::*; use super::*;
use crate::device::{VirtioInterrupt, VirtioInterruptType}; use crate::device::{VirtioInterrupt, VirtioInterruptType};

4
virtio-devices/src/vsock/packet.rs
View file

@ -24,7 +24,7 @@ use virtio_queue::DescriptorChain;
use vm_memory::{Address, GuestMemory}; use vm_memory::{Address, GuestMemory};
use vm_virtio::{AccessPlatform, Translatable}; use vm_virtio::{AccessPlatform, Translatable};
use super::{defs, Result, VsockError}; use super::{Result, VsockError, defs};
use crate::get_host_address_range; use crate::get_host_address_range;
// The vsock packet header is defined by the C struct: // The vsock packet header is defined by the C struct:
@ -427,8 +427,8 @@ mod tests {
use super::super::tests::TestContext; use super::super::tests::TestContext;
use super::*; use super::*;
use crate::vsock::defs::MAX_PKT_BUF_SIZE;
use crate::GuestMemoryMmap; use crate::GuestMemoryMmap;
use crate::vsock::defs::MAX_PKT_BUF_SIZE;
macro_rules! create_context { macro_rules! create_context {
($test_ctx:ident, $handler_ctx:ident) => { ($test_ctx:ident, $handler_ctx:ident) => {

2
virtio-devices/src/vsock/unix/mod.rs
View file

@ -13,9 +13,9 @@ mod muxer;
mod muxer_killq; mod muxer_killq;
mod muxer_rxq; mod muxer_rxq;
pub use Error as VsockUnixError;
pub use muxer::VsockMuxer as VsockUnixBackend; pub use muxer::VsockMuxer as VsockUnixBackend;
use thiserror::Error; use thiserror::Error;
pub use Error as VsockUnixError;
mod defs { mod defs {
/// Maximum number of established connections that we can handle. /// Maximum number of established connections that we can handle.

2
virtio-devices/src/vsock/unix/muxer.rs
View file

@ -52,7 +52,7 @@ use super::super::{
}; };
use super::muxer_killq::MuxerKillQ; use super::muxer_killq::MuxerKillQ;
use super::muxer_rxq::MuxerRxQ; use super::muxer_rxq::MuxerRxQ;
use super::{defs, Error, MuxerConnection, Result}; use super::{Error, MuxerConnection, Result, defs};
/// A unique identifier of a `MuxerConnection` object. Connections are stored in a hash map, /// A unique identifier of a `MuxerConnection` object. Connections are stored in a hash map,
/// keyed by a `ConnMapKey` object. /// keyed by a `ConnMapKey` object.

2
virtio-devices/src/vsock/unix/muxer_killq.rs
View file

@ -29,7 +29,7 @@ use std::collections::{HashMap, VecDeque};
use std::time::Instant; use std::time::Instant;
use super::muxer::ConnMapKey; use super::muxer::ConnMapKey;
use super::{defs, MuxerConnection}; use super::{MuxerConnection, defs};
/// A kill queue item, holding the connection key and the scheduled time for termination. /// A kill queue item, holding the connection key and the scheduled time for termination.
/// ///

2
virtio-devices/src/vsock/unix/muxer_rxq.rs
View file

@ -20,7 +20,7 @@ use std::collections::{HashMap, VecDeque};
use super::super::VsockChannel; use super::super::VsockChannel;
use super::muxer::{ConnMapKey, MuxerRx}; use super::muxer::{ConnMapKey, MuxerRx};
use super::{defs, MuxerConnection}; use super::{MuxerConnection, defs};
/// The muxer RX queue. /// The muxer RX queue.
/// ///

6
virtio-devices/src/watchdog.rs
View file

@ -23,9 +23,9 @@ use vm_migration::{Migratable, MigratableError, Pausable, Snapshot, Snapshottabl
use vmm_sys_util::eventfd::EventFd; use vmm_sys_util::eventfd::EventFd;
use super::{ use super::{
ActivateError, ActivateResult, EpollHelper, EpollHelperError, EpollHelperHandler, ActivateError, ActivateResult, EPOLL_HELPER_EVENT_LAST, EpollHelper, EpollHelperError,
Error as DeviceError, VirtioCommon, VirtioDevice, VirtioDeviceType, EPOLL_HELPER_EVENT_LAST, EpollHelperHandler, Error as DeviceError, VIRTIO_F_VERSION_1, VirtioCommon, VirtioDevice,
VIRTIO_F_VERSION_1, VirtioDeviceType,
}; };
use crate::seccomp_filters::Thread; use crate::seccomp_filters::Thread;
use crate::thread_helper::spawn_virtio_thread; use crate::thread_helper::spawn_virtio_thread;

Some files were not shown because too many files have changed in this diff Show more