github/kata-containers
1
0
Fork 1
mirror of https://github.com/kata-containers/kata-containers.git synced 2025-04-29 12:14:48 +00:00
Code Issues Projects Releases Wiki Activity

Dragonball: change error name and fix compile error

Browse Source 
Change error name from `StartMicrovm` to `StartMicroVm`,
`StartMicrovmError` to `StartMicroVmError`.

Besides, we fix a compile error in config_manager.

Signed-off-by: Chao Wu <chaowu@linux.alibaba.com>
This commit is contained in:
Chao Wu 2022-07-04 11:37:42 +08:00
parent 38957fe00b
commit dd003ebe0e
10 changed files with 97 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/dragonball/src/api/v1/vmm_action.rs
View File

@ -11,7 +11,7 @@ use std::sync::mpsc::{Receiver, Sender, TryRecvError};
use log::{debug, error, info, warn};
use crate::error::{Result, StartMicrovmError, StopMicrovmError};
use crate::error::{Result, StartMicroVmError, StopMicrovmError};
use crate::event_manager::EventManager;
use crate::vm::{CpuTopology, KernelConfigInfo, VmConfigInfo};
use crate::vmm::Vmm;
@ -310,8 +310,8 @@ impl VmmService {
}
fn start_microvm(&mut self, vmm: &mut Vmm, event_mgr: &mut EventManager) -> VmmRequestResult {
use self::StartMicrovmError::MicroVMAlreadyRunning;
use self::VmmActionError::StartMicrovm;
use self::StartMicroVmError::MicroVMAlreadyRunning;
use self::VmmActionError::StartMicroVm;
let vmm_seccomp_filter = vmm.vmm_seccomp_filter();
let vcpu_seccomp_filter = vmm.vcpu_seccomp_filter();
@ -319,12 +319,12 @@ impl VmmService {
.get_vm_by_id_mut("")
.ok_or(VmmActionError::InvalidVMID)?;
if vm.is_vm_initialized() {
return Err(StartMicrovm(MicroVMAlreadyRunning));
return Err(StartMicroVm(MicroVMAlreadyRunning));
}
vm.start_microvm(event_mgr, vmm_seccomp_filter, vcpu_seccomp_filter)
.map(|_| VmmData::Empty)
.map_err(StartMicrovm)
.map_err(StartMicroVm)
}
fn shutdown_microvm(&mut self, vmm: &mut Vmm) -> VmmRequestResult {
@ -512,7 +512,7 @@ impl VmmService {
let ctx = vm
.create_device_op_context(Some(event_mgr.epoll_manager()))
.map_err(|e| {
if let StartMicrovmError::UpcallNotReady = e {
if let StartMicroVmError::UpcallNotReady = e {
return VmmActionError::UpcallNotReady;
}
VmmActionError::Block(BlockDeviceError::UpdateNotAllowedPostBoot)
@ -573,12 +573,12 @@ impl VmmService {
let ctx = vm
.create_device_op_context(Some(event_mgr.epoll_manager()))
.map_err(|e| {
if let StartMicrovmError::MicroVMAlreadyRunning = e {
if let StartMicroVmError::MicroVMAlreadyRunning = e {
VmmActionError::VirtioNet(VirtioNetDeviceError::UpdateNotAllowedPostBoot)
} else if let StartMicrovmError::UpcallNotReady = e {
} else if let StartMicroVmError::UpcallNotReady = e {
VmmActionError::UpcallNotReady
} else {
VmmActionError::StartMicrovm(e)
VmmActionError::StartMicroVm(e)
}
})?;

2
src/dragonball/src/config_manager.rs
View File

@ -10,6 +10,8 @@ use dbs_device::DeviceIo;
use dbs_utils::rate_limiter::{RateLimiter, TokenBucket};
use serde_derive::{Deserialize, Serialize};
/// Get bucket update for rate limiter.
#[macro_export]
macro_rules! get_bucket_update {
($self:ident, $rate_limiter: ident, $metric: ident) => {{
match &$self.$rate_limiter {

5
src/dragonball/src/device_manager/blk_dev_mgr.rs
View File

@ -20,10 +20,9 @@ use dbs_virtio_devices::block::{aio::Aio, io_uring::IoUring, Block, LocalFile, U
use serde_derive::{Deserialize, Serialize};
use crate::address_space_manager::GuestAddressSpaceImpl;
use crate::config_manager::{
get_bucket_update, ConfigItem, DeviceConfigInfo, RateLimiterConfigInfo,
};
use crate::config_manager::{ConfigItem, DeviceConfigInfo, RateLimiterConfigInfo};
use crate::device_manager::{DeviceManager, DeviceMgrError, DeviceOpContext};
use crate::get_bucket_update;
use crate::vm::KernelConfigInfo;
use super::DbsMmioV2Device;

3
src/dragonball/src/device_manager/fs_dev_mgr.rs
View File

@ -12,11 +12,12 @@ use slog::{error, info};
use crate::address_space_manager::GuestAddressSpaceImpl;
use crate::config_manager::{
get_bucket_update, ConfigItem, DeviceConfigInfo, DeviceConfigInfos, RateLimiterConfigInfo,
ConfigItem, DeviceConfigInfo, DeviceConfigInfos, RateLimiterConfigInfo,
};
use crate::device_manager::{
DbsMmioV2Device, DeviceManager, DeviceMgrError, DeviceOpContext, DeviceVirtioRegionHandler,
};
use crate::get_bucket_update;
use super::DbsVirtioDevice;

28
src/dragonball/src/device_manager/mod.rs
View File

@ -40,7 +40,7 @@ use dbs_upcall::{
use dbs_virtio_devices::vsock::backend::VsockInnerConnector;
use crate::address_space_manager::GuestAddressSpaceImpl;
use crate::error::StartMicrovmError;
use crate::error::StartMicroVmError;
use crate::resource_manager::ResourceManager;
use crate::vm::{KernelConfigInfo, Vm};
use crate::IoManagerCached;
@ -503,7 +503,7 @@ impl DeviceManager {
pub fn create_legacy_devices(
&mut self,
ctx: &mut DeviceOpContext,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
#[cfg(target_arch = "x86_64")]
{
let mut tx = ctx.io_context.begin_tx();
@ -517,7 +517,7 @@ impl DeviceManager {
}
Err(e) => {
ctx.io_context.cancel_tx(tx);
return Err(StartMicrovmError::LegacyDevice(e));
return Err(StartMicroVmError::LegacyDevice(e));
}
}
}
@ -531,10 +531,10 @@ impl DeviceManager {
dmesg_fifo: Option<Box<dyn io::Write + Send>>,
com1_sock_path: Option<String>,
_ctx: &mut DeviceOpContext,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
// Connect serial ports to the console and dmesg_fifo.
self.set_guest_kernel_log_stream(dmesg_fifo)
.map_err(|_| StartMicrovmError::EventFd)?;
.map_err(|_| StartMicroVmError::EventFd)?;
info!(self.logger, "init console path: {:?}", com1_sock_path);
if let Some(path) = com1_sock_path {
@ -542,13 +542,13 @@ impl DeviceManager {
let com1 = legacy_manager.get_com1_serial();
self.con_manager
.create_socket_console(com1, path)
.map_err(StartMicrovmError::DeviceManager)?;
.map_err(StartMicroVmError::DeviceManager)?;
}
} else if let Some(legacy_manager) = self.legacy_manager.as_ref() {
let com1 = legacy_manager.get_com1_serial();
self.con_manager
.create_stdio_console(com1)
.map_err(StartMicrovmError::DeviceManager)?;
.map_err(StartMicroVmError::DeviceManager)?;
}
Ok(())
@ -586,7 +586,7 @@ impl DeviceManager {
com1_sock_path: Option<String>,
dmesg_fifo: Option<Box<dyn io::Write + Send>>,
address_space: Option<&AddressSpace>,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
let mut ctx = DeviceOpContext::new(
Some(epoll_mgr),
self,
@ -601,20 +601,20 @@ impl DeviceManager {
#[cfg(feature = "virtio-blk")]
self.block_manager
.attach_devices(&mut ctx)
.map_err(StartMicrovmError::BlockDeviceError)?;
.map_err(StartMicroVmError::BlockDeviceError)?;
#[cfg(feature = "virtio-fs")]
{
let mut fs_manager = self.fs_manager.lock().unwrap();
fs_manager
.attach_devices(&mut ctx)
.map_err(StartMicrovmError::FsDeviceError)?;
.map_err(StartMicroVmError::FsDeviceError)?;
}
#[cfg(feature = "virtio-net")]
self.virtio_net_manager
.attach_devices(&mut ctx)
.map_err(StartMicrovmError::VirtioNetDeviceError)?;
.map_err(StartMicroVmError::VirtioNetDeviceError)?;
#[cfg(feature = "virtio-vsock")]
self.vsock_manager.attach_devices(&mut ctx)?;
@ -622,15 +622,15 @@ impl DeviceManager {
#[cfg(feature = "virtio-blk")]
self.block_manager
.generate_kernel_boot_args(kernel_config)
.map_err(StartMicrovmError::DeviceManager)?;
.map_err(StartMicroVmError::DeviceManager)?;
ctx.generate_kernel_boot_args(kernel_config)
.map_err(StartMicrovmError::DeviceManager)?;
.map_err(StartMicroVmError::DeviceManager)?;
Ok(())
}
/// Start all registered devices when booting the associated virtual machine.
pub fn start_devices(&mut self) -> std::result::Result<(), StartMicrovmError> {
pub fn start_devices(&mut self) -> std::result::Result<(), StartMicroVmError> {
Ok(())
}

3
src/dragonball/src/device_manager/virtio_net_dev_mgr.rs
View File

@ -18,9 +18,10 @@ use serde_derive::{Deserialize, Serialize};
use crate::address_space_manager::GuestAddressSpaceImpl;
use crate::config_manager::{
get_bucket_update, ConfigItem, DeviceConfigInfo, DeviceConfigInfos, RateLimiterConfigInfo,
ConfigItem, DeviceConfigInfo, DeviceConfigInfos, RateLimiterConfigInfo,
};
use crate::device_manager::{DeviceManager, DeviceMgrError, DeviceOpContext};
use crate::get_bucket_update;
use super::DbsMmioV2Device;

20
src/dragonball/src/device_manager/vsock_dev_mgr.rs
View File

@ -17,7 +17,7 @@ use dbs_virtio_devices::vsock::Vsock;
use dbs_virtio_devices::Error as VirtioError;
use serde_derive::{Deserialize, Serialize};
use super::StartMicrovmError;
use super::StartMicroVmError;
use crate::config_manager::{ConfigItem, DeviceConfigInfo, DeviceConfigInfos};
use crate::device_manager::{DeviceManager, DeviceOpContext};
@ -185,11 +185,11 @@ impl VsockDeviceMgr {
pub fn attach_devices(
&mut self,
ctx: &mut DeviceOpContext,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
let epoll_mgr = ctx
.epoll_mgr
.clone()
.ok_or(StartMicrovmError::CreateVsockDevice(
.ok_or(StartMicroVmError::CreateVsockDevice(
virtio::Error::InvalidInput,
))?;
@ -209,32 +209,32 @@ impl VsockDeviceMgr {
epoll_mgr.clone(),
)
.map_err(VirtioError::VirtioVsockError)
.map_err(StartMicrovmError::CreateVsockDevice)?,
.map_err(StartMicroVmError::CreateVsockDevice)?,
);
if let Some(uds_path) = info.config.uds_path.as_ref() {
let unix_backend = VsockUnixStreamBackend::new(uds_path.clone())
.map_err(VirtioError::VirtioVsockError)
.map_err(StartMicrovmError::CreateVsockDevice)?;
.map_err(StartMicroVmError::CreateVsockDevice)?;
device
.add_backend(Box::new(unix_backend), true)
.map_err(VirtioError::VirtioVsockError)
.map_err(StartMicrovmError::CreateVsockDevice)?;
.map_err(StartMicroVmError::CreateVsockDevice)?;
}
if let Some(tcp_addr) = info.config.tcp_addr.as_ref() {
let tcp_backend = VsockTcpBackend::new(tcp_addr.clone())
.map_err(VirtioError::VirtioVsockError)
.map_err(StartMicrovmError::CreateVsockDevice)?;
.map_err(StartMicroVmError::CreateVsockDevice)?;
device
.add_backend(Box::new(tcp_backend), false)
.map_err(VirtioError::VirtioVsockError)
.map_err(StartMicrovmError::CreateVsockDevice)?;
.map_err(StartMicroVmError::CreateVsockDevice)?;
}
// add inner backend to the the first added vsock device
if let Some(inner_backend) = self.default_inner_backend.take() {
device
.add_backend(Box::new(inner_backend), false)
.map_err(VirtioError::VirtioVsockError)
.map_err(StartMicrovmError::CreateVsockDevice)?;
.map_err(StartMicroVmError::CreateVsockDevice)?;
}
let device = DeviceManager::create_mmio_virtio_device_with_features(
device,
@ -243,7 +243,7 @@ impl VsockDeviceMgr {
info.config.use_shared_irq.unwrap_or(self.use_shared_irq),
info.config.use_generic_irq.unwrap_or(USE_GENERIC_IRQ),
)
.map_err(StartMicrovmError::RegisterVsockDevice)?;
.map_err(StartMicroVmError::RegisterVsockDevice)?;
info.device = Some(device);
}

2
src/dragonball/src/lib.rs
View File

@ -36,7 +36,7 @@ mod event_manager;
mod io_manager;
mod vmm;
pub use self::error::StartMicrovmError;
pub use self::error::StartMicroVmError;
pub use self::io_manager::IoManagerCached;
pub use self::vmm::Vmm;

74
src/dragonball/src/vm/mod.rs
View File

@ -30,7 +30,7 @@ use crate::address_space_manager::{
use crate::api::v1::{InstanceInfo, InstanceState};
use crate::device_manager::console_manager::DmesgWriter;
use crate::device_manager::{DeviceManager, DeviceMgrError, DeviceOpContext};
use crate::error::{LoadInitrdError, Result, StartMicrovmError, StopMicrovmError};
use crate::error::{LoadInitrdError, Result, StartMicroVmError, StopMicrovmError};
use crate::event_manager::EventManager;
use crate::kvm_context::KvmContext;
use crate::resource_manager::ResourceManager;
@ -357,7 +357,7 @@ impl Vm {
pub fn create_device_op_context(
&mut self,
epoll_mgr: Option<EpollManager>,
) -> std::result::Result<DeviceOpContext, StartMicrovmError> {
) -> std::result::Result<DeviceOpContext, StartMicroVmError> {
if !self.is_vm_initialized() {
Ok(DeviceOpContext::create_boot_ctx(self, epoll_mgr))
} else {
@ -365,9 +365,9 @@ impl Vm {
}
}
pub(crate) fn check_health(&self) -> std::result::Result<(), StartMicrovmError> {
pub(crate) fn check_health(&self) -> std::result::Result<(), StartMicroVmError> {
if self.kernel_config.is_none() {
return Err(StartMicrovmError::MissingKernelConfig);
return Err(StartMicroVmError::MissingKernelConfig);
}
Ok(())
}
@ -432,25 +432,25 @@ impl Vm {
pub(crate) fn init_devices(
&mut self,
epoll_manager: EpollManager,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
info!(self.logger, "VM: initializing devices ...");
let com1_sock_path = self.vm_config.serial_path.clone();
let kernel_config = self
.kernel_config
.as_mut()
.ok_or(StartMicrovmError::MissingKernelConfig)?;
.ok_or(StartMicroVmError::MissingKernelConfig)?;
info!(self.logger, "VM: create interrupt manager");
self.device_manager
.create_interrupt_manager()
.map_err(StartMicrovmError::DeviceManager)?;
.map_err(StartMicroVmError::DeviceManager)?;
info!(self.logger, "VM: create devices");
let vm_as =
self.address_space
.get_vm_as()
.ok_or(StartMicrovmError::AddressManagerError(
.ok_or(StartMicroVmError::AddressManagerError(
AddressManagerError::GuestMemoryNotInitialized,
))?;
self.device_manager.create_devices(
@ -501,7 +501,7 @@ impl Vm {
Box::new(DmesgWriter::new(&self.logger))
}
pub(crate) fn init_guest_memory(&mut self) -> std::result::Result<(), StartMicrovmError> {
pub(crate) fn init_guest_memory(&mut self) -> std::result::Result<(), StartMicroVmError> {
info!(self.logger, "VM: initializing guest memory...");
// We are not allowing reinitialization of vm guest memory.
if self.address_space.is_initialized() {
@ -512,7 +512,7 @@ impl Vm {
let mem_size = (self.vm_config.mem_size_mib as u64) << 20;
let reserve_memory_bytes = self.vm_config.reserve_memory_bytes;
if reserve_memory_bytes > (mem_size >> 1) as u64 {
return Err(StartMicrovmError::ConfigureInvalid(String::from(
return Err(StartMicroVmError::ConfigureInvalid(String::from(
"invalid reserve_memory_bytes",
)));
}
@ -553,11 +553,11 @@ impl Vm {
);
let mut address_space_param = AddressSpaceMgrBuilder::new(&mem_type, &mem_file_path)
.map_err(StartMicrovmError::AddressManagerError)?;
.map_err(StartMicroVmError::AddressManagerError)?;
address_space_param.set_kvm_vm_fd(self.vm_fd.clone());
self.address_space
.create_address_space(&self.resource_manager, &numa_regions, address_space_param)
.map_err(StartMicrovmError::AddressManagerError)?;
.map_err(StartMicroVmError::AddressManagerError)?;
info!(self.logger, "VM: initializing guest memory done");
Ok(())
@ -566,18 +566,18 @@ impl Vm {
fn init_configure_system(
&mut self,
vm_as: &GuestAddressSpaceImpl,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
let vm_memory = vm_as.memory();
let kernel_config = self
.kernel_config
.as_ref()
.ok_or(StartMicrovmError::MissingKernelConfig)?;
.ok_or(StartMicroVmError::MissingKernelConfig)?;
//let cmdline = kernel_config.cmdline.clone();
let initrd: Option<InitrdConfig> = match kernel_config.initrd_file() {
Some(f) => {
let initrd_file = f.try_clone();
if initrd_file.is_err() {
return Err(StartMicrovmError::InitrdLoader(
return Err(StartMicroVmError::InitrdLoader(
LoadInitrdError::ReadInitrd(io::Error::from(io::ErrorKind::InvalidData)),
));
}
@ -638,12 +638,12 @@ impl Vm {
fn load_kernel(
&mut self,
vm_memory: &GuestMemoryImpl,
) -> std::result::Result<KernelLoaderResult, StartMicrovmError> {
) -> std::result::Result<KernelLoaderResult, StartMicroVmError> {
// This is the easy way out of consuming the value of the kernel_cmdline.
let kernel_config = self
.kernel_config
.as_mut()
.ok_or(StartMicrovmError::MissingKernelConfig)?;
.ok_or(StartMicroVmError::MissingKernelConfig)?;
let high_mem_addr = GuestAddress(dbs_boot::get_kernel_start());
#[cfg(target_arch = "x86_64")]
@ -653,7 +653,7 @@ impl Vm {
kernel_config.kernel_file_mut(),
Some(high_mem_addr),
)
.map_err(StartMicrovmError::KernelLoader);
.map_err(StartMicroVmError::KernelLoader);
#[cfg(target_arch = "aarch64")]
return linux_loader::loader::pe::PE::load(
@ -662,7 +662,7 @@ impl Vm {
kernel_config.kernel_file_mut(),
Some(high_mem_addr),
)
.map_err(StartMicrovmError::KernelLoader);
.map_err(StartMicroVmError::KernelLoader);
}
/// Set up the initial microVM state and start the vCPU threads.
@ -674,10 +674,10 @@ impl Vm {
event_mgr: &mut EventManager,
vmm_seccomp_filter: BpfProgram,
vcpu_seccomp_filter: BpfProgram,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
info!(self.logger, "VM: received instance start command");
if self.is_vm_initialized() {
return Err(StartMicrovmError::MicroVMAlreadyRunning);
return Err(StartMicroVmError::MicroVMAlreadyRunning);
}
let request_ts = TimestampUs::default();
@ -697,12 +697,12 @@ impl Vm {
let vm_as = self
.vm_as()
.cloned()
.ok_or(StartMicrovmError::AddressManagerError(
.ok_or(StartMicroVmError::AddressManagerError(
AddressManagerError::GuestMemoryNotInitialized,
))?;
self.init_vcpu_manager(vm_as.clone(), vcpu_seccomp_filter)
.map_err(StartMicrovmError::Vcpu)?;
.map_err(StartMicroVmError::Vcpu)?;
self.init_microvm(event_mgr.epoll_manager(), vm_as.clone(), request_ts)?;
self.init_configure_system(&vm_as)?;
self.init_upcall()?;
@ -712,9 +712,9 @@ impl Vm {
info!(self.logger, "VM: start vcpus");
self.vcpu_manager()
.map_err(StartMicrovmError::Vcpu)?
.map_err(StartMicroVmError::Vcpu)?
.start_boot_vcpus(vmm_seccomp_filter)
.map_err(StartMicrovmError::Vcpu)?;
.map_err(StartMicroVmError::Vcpu)?;
// Use expect() to crash if the other thread poisoned this lock.
self.shared_info
@ -730,29 +730,29 @@ impl Vm {
#[cfg(feature = "hotplug")]
impl Vm {
/// initialize upcall client for guest os
fn new_upcall(&mut self) -> std::result::Result<(), StartMicrovmError> {
fn new_upcall(&mut self) -> std::result::Result<(), StartMicroVmError> {
// get vsock inner connector for upcall
let inner_connector = self
.device_manager
.get_vsock_inner_connector()
.ok_or(StartMicrovmError::UpcallMissVsock)?;
.ok_or(StartMicroVmError::UpcallMissVsock)?;
let mut upcall_client = UpcallClient::new(
inner_connector,
self.epoll_manager.clone(),
DevMgrService::default(),
)
.map_err(StartMicrovmError::UpcallInitError)?;
.map_err(StartMicroVmError::UpcallInitError)?;
upcall_client
.connect()
.map_err(StartMicrovmError::UpcallConnectError)?;
.map_err(StartMicroVmError::UpcallConnectError)?;
self.upcall_client = Some(Arc::new(upcall_client));
info!(self.logger, "upcall client init success");
Ok(())
}
fn init_upcall(&mut self) -> std::result::Result<(), StartMicrovmError> {
fn init_upcall(&mut self) -> std::result::Result<(), StartMicroVmError> {
info!(self.logger, "VM upcall init");
if let Err(e) = self.new_upcall() {
info!(
@ -762,7 +762,7 @@ impl Vm {
Err(e)
} else {
self.vcpu_manager()
.map_err(StartMicrovmError::Vcpu)?
.map_err(StartMicroVmError::Vcpu)?
.set_upcall_channel(self.upcall_client().clone());
Ok(())
}
@ -776,27 +776,27 @@ impl Vm {
fn create_device_hotplug_context(
&self,
epoll_mgr: Option<EpollManager>,
) -> std::result::Result<DeviceOpContext, StartMicrovmError> {
) -> std::result::Result<DeviceOpContext, StartMicroVmError> {
if self.upcall_client().is_none() {
Err(StartMicrovmError::UpcallMissVsock)
Err(StartMicroVmError::UpcallMissVsock)
} else if self.is_upcall_client_ready() {
Ok(DeviceOpContext::create_hotplug_ctx(self, epoll_mgr))
} else {
Err(StartMicrovmError::UpcallNotReady)
Err(StartMicroVmError::UpcallNotReady)
}
}
}
#[cfg(not(feature = "hotplug"))]
impl Vm {
fn init_upcall(&mut self) -> std::result::Result<(), StartMicrovmError> {
fn init_upcall(&mut self) -> std::result::Result<(), StartMicroVmError> {
Ok(())
}
fn create_device_hotplug_context(
&self,
_epoll_mgr: Option<EpollManager>,
) -> std::result::Result<DeviceOpContext, StartMicrovmError> {
Err(StartMicrovmError::MicroVMAlreadyRunning)
) -> std::result::Result<DeviceOpContext, StartMicroVmError> {
Err(StartMicroVmError::MicroVMAlreadyRunning)
}
}

36
src/dragonball/src/vm/x86_64.rs
View File

@ -20,7 +20,7 @@ use slog::info;
use vm_memory::{Address, Bytes, GuestAddress, GuestAddressSpace, GuestMemory};
use crate::address_space_manager::{GuestAddressSpaceImpl, GuestMemoryImpl};
use crate::error::{Error, Result, StartMicrovmError};
use crate::error::{Error, Result, StartMicroVmError};
use crate::event_manager::EventManager;
use crate::vm::{Vm, VmError};
@ -183,7 +183,7 @@ impl Vm {
epoll_mgr: EpollManager,
vm_as: GuestAddressSpaceImpl,
request_ts: TimestampUs,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
info!(self.logger, "VM: start initializing microvm ...");
self.init_tss()?;
@ -195,9 +195,9 @@ impl Vm {
let reset_event_fd = self.device_manager.get_reset_eventfd().unwrap();
self.vcpu_manager()
.map_err(StartMicrovmError::Vcpu)?
.map_err(StartMicroVmError::Vcpu)?
.set_reset_event_fd(reset_event_fd)
.map_err(StartMicrovmError::Vcpu)?;
.map_err(StartMicroVmError::Vcpu)?;
if self.vm_config.cpu_pm == "on" {
// TODO: add cpu_pm support. issue #4590.
@ -207,9 +207,9 @@ impl Vm {
let vm_memory = vm_as.memory();
let kernel_loader_result = self.load_kernel(vm_memory.deref())?;
self.vcpu_manager()
.map_err(StartMicrovmError::Vcpu)?
.map_err(StartMicroVmError::Vcpu)?
.create_boot_vcpus(request_ts, kernel_loader_result.kernel_load)
.map_err(StartMicrovmError::Vcpu)?;
.map_err(StartMicroVmError::Vcpu)?;
info!(self.logger, "VM: initializing microvm done");
Ok(())
@ -224,10 +224,10 @@ impl Vm {
vm_memory: &GuestMemoryImpl,
cmdline: &Cmdline,
initrd: Option<InitrdConfig>,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
let cmdline_addr = GuestAddress(dbs_boot::layout::CMDLINE_START);
linux_loader::loader::load_cmdline(vm_memory, cmdline_addr, cmdline)
.map_err(StartMicrovmError::LoadCommandline)?;
.map_err(StartMicroVmError::LoadCommandline)?;
configure_system(
vm_memory,
@ -239,27 +239,27 @@ impl Vm {
self.vm_config.max_vcpu_count,
self.vm_config.reserve_memory_bytes,
)
.map_err(StartMicrovmError::ConfigureSystem)
.map_err(StartMicroVmError::ConfigureSystem)
}
/// Initializes the guest memory.
pub(crate) fn init_tss(&mut self) -> std::result::Result<(), StartMicrovmError> {
pub(crate) fn init_tss(&mut self) -> std::result::Result<(), StartMicroVmError> {
self.vm_fd
.set_tss_address(dbs_boot::layout::KVM_TSS_ADDRESS.try_into().unwrap())
.map_err(|e| StartMicrovmError::ConfigureVm(VmError::VmSetup(e)))
.map_err(|e| StartMicroVmError::ConfigureVm(VmError::VmSetup(e)))
}
/// Creates the irq chip and an in-kernel device model for the PIT.
pub(crate) fn setup_interrupt_controller(
&mut self,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
self.vm_fd
.create_irq_chip()
.map_err(|e| StartMicrovmError::ConfigureVm(VmError::VmSetup(e)))
.map_err(|e| StartMicroVmError::ConfigureVm(VmError::VmSetup(e)))
}
/// Creates an in-kernel device model for the PIT.
pub(crate) fn create_pit(&self) -> std::result::Result<(), StartMicrovmError> {
pub(crate) fn create_pit(&self) -> std::result::Result<(), StartMicroVmError> {
info!(self.logger, "VM: create pit");
// We need to enable the emulation of a dummy speaker port stub so that writing to port 0x61
// (i.e. KVM_SPEAKER_BASE_ADDRESS) does not trigger an exit to user space.
@ -272,20 +272,20 @@ impl Vm {
// correct amount of memory from our pointer, and we verify the return result.
self.vm_fd
.create_pit2(pit_config)
.map_err(|e| StartMicrovmError::ConfigureVm(VmError::VmSetup(e)))
.map_err(|e| StartMicroVmError::ConfigureVm(VmError::VmSetup(e)))
}
pub(crate) fn register_events(
&mut self,
event_mgr: &mut EventManager,
) -> std::result::Result<(), StartMicrovmError> {
) -> std::result::Result<(), StartMicroVmError> {
let reset_evt = self
.device_manager
.get_reset_eventfd()
.map_err(StartMicrovmError::DeviceManager)?;
.map_err(StartMicroVmError::DeviceManager)?;
event_mgr
.register_exit_eventfd(&reset_evt)
.map_err(|_| StartMicrovmError::RegisterEvent)?;
.map_err(|_| StartMicroVmError::RegisterEvent)?;
self.reset_eventfd = Some(reset_evt);
Ok(())