From dd003ebe0e690e85cf7d68e05a7e4dc782237f35 Mon Sep 17 00:00:00 2001 From: Chao Wu Date: Mon, 4 Jul 2022 11:37:42 +0800 Subject: [PATCH] Dragonball: change error name and fix compile error Change error name from `StartMicrovm` to `StartMicroVm`, `StartMicrovmError` to `StartMicroVmError`. Besides, we fix a compile error in config_manager. Signed-off-by: Chao Wu --- src/dragonball/src/api/v1/vmm_action.rs | 18 ++--- src/dragonball/src/config_manager.rs | 2 + .../src/device_manager/blk_dev_mgr.rs | 5 +- .../src/device_manager/fs_dev_mgr.rs | 3 +- src/dragonball/src/device_manager/mod.rs | 28 +++---- .../src/device_manager/virtio_net_dev_mgr.rs | 3 +- .../src/device_manager/vsock_dev_mgr.rs | 20 ++--- src/dragonball/src/lib.rs | 2 +- src/dragonball/src/vm/mod.rs | 74 +++++++++---------- src/dragonball/src/vm/x86_64.rs | 36 ++++----- 10 files changed, 97 insertions(+), 94 deletions(-) diff --git a/src/dragonball/src/api/v1/vmm_action.rs b/src/dragonball/src/api/v1/vmm_action.rs index 2e284d79ba..6dedbfc28e 100644 --- a/src/dragonball/src/api/v1/vmm_action.rs +++ b/src/dragonball/src/api/v1/vmm_action.rs @@ -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) } })?; diff --git a/src/dragonball/src/config_manager.rs b/src/dragonball/src/config_manager.rs index a80fd14c72..f855be1266 100644 --- a/src/dragonball/src/config_manager.rs +++ b/src/dragonball/src/config_manager.rs @@ -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 { diff --git a/src/dragonball/src/device_manager/blk_dev_mgr.rs b/src/dragonball/src/device_manager/blk_dev_mgr.rs index a624f68db6..0d35c4f95f 100644 --- a/src/dragonball/src/device_manager/blk_dev_mgr.rs +++ b/src/dragonball/src/device_manager/blk_dev_mgr.rs @@ -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; diff --git a/src/dragonball/src/device_manager/fs_dev_mgr.rs b/src/dragonball/src/device_manager/fs_dev_mgr.rs index c8fb553667..d699dcbde5 100644 --- a/src/dragonball/src/device_manager/fs_dev_mgr.rs +++ b/src/dragonball/src/device_manager/fs_dev_mgr.rs @@ -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; diff --git a/src/dragonball/src/device_manager/mod.rs b/src/dragonball/src/device_manager/mod.rs index 3cb0477e3d..53a1e2df92 100644 --- a/src/dragonball/src/device_manager/mod.rs +++ b/src/dragonball/src/device_manager/mod.rs @@ -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>, com1_sock_path: Option, _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, dmesg_fifo: Option>, 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(()) } diff --git a/src/dragonball/src/device_manager/virtio_net_dev_mgr.rs b/src/dragonball/src/device_manager/virtio_net_dev_mgr.rs index 65f29fbcd0..3e81f29487 100644 --- a/src/dragonball/src/device_manager/virtio_net_dev_mgr.rs +++ b/src/dragonball/src/device_manager/virtio_net_dev_mgr.rs @@ -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; diff --git a/src/dragonball/src/device_manager/vsock_dev_mgr.rs b/src/dragonball/src/device_manager/vsock_dev_mgr.rs index cec58d7de1..5e49bbfb37 100644 --- a/src/dragonball/src/device_manager/vsock_dev_mgr.rs +++ b/src/dragonball/src/device_manager/vsock_dev_mgr.rs @@ -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); } diff --git a/src/dragonball/src/lib.rs b/src/dragonball/src/lib.rs index bd58159ac2..7371e8213a 100644 --- a/src/dragonball/src/lib.rs +++ b/src/dragonball/src/lib.rs @@ -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; diff --git a/src/dragonball/src/vm/mod.rs b/src/dragonball/src/vm/mod.rs index 4063b77708..8c3cb21c97 100644 --- a/src/dragonball/src/vm/mod.rs +++ b/src/dragonball/src/vm/mod.rs @@ -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, - ) -> std::result::Result { + ) -> std::result::Result { 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 = 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 { + ) -> std::result::Result { // 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, - ) -> std::result::Result { + ) -> std::result::Result { 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, - ) -> std::result::Result { - Err(StartMicrovmError::MicroVMAlreadyRunning) + ) -> std::result::Result { + Err(StartMicroVmError::MicroVMAlreadyRunning) } } diff --git a/src/dragonball/src/vm/x86_64.rs b/src/dragonball/src/vm/x86_64.rs index 6bd74acc09..3fcebdc20f 100644 --- a/src/dragonball/src/vm/x86_64.rs +++ b/src/dragonball/src/vm/x86_64.rs @@ -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, - ) -> 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(())