kata-containers/cloud-hypervisor
1
0
Fork 0
mirror of https://github.com/cloud-hypervisor/cloud-hypervisor.git synced 2026-08-05 02:19:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

vmm: Enable HTTP response for PCI device hotplug

Browse Source 
This patch completes the series by connecting the dots between the HTTP
frontend and the device manager backend.

Any request to hotplug a VFIO, disk, fs, pmem, net, or vsock device will
now return a response including the device name and the place of the
device in the PCI topology.

Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>
This commit is contained in:
Sebastien Boeuf
2020-06-11 17:40:27 +02:00
committed by Rob Bradford
parent 3316348d4c
commit 83cd9969df
3 changed files with 60 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
vmm/src/api/http_endpoint.rs
View File

@@ -73,7 +73,6 @@ impl EndpointHandler for VmActionHandler {
body: &Option<Body>, body: &Option<Body>,
) -> std::result::Result<Option<Body>, HttpError> { ) -> std::result::Result<Option<Body>, HttpError> {
use VmAction::*; use VmAction::*;
let response_body: Option<Body> = None;
if let Some(body) = body { if let Some(body) = body {
match self.action { match self.action {
AddDevice(_) => vm_add_device( AddDevice(_) => vm_add_device(
@@ -81,86 +80,84 @@ impl EndpointHandler for VmActionHandler {
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmAddDevice)?, .map_err(HttpError::VmAddDevice),
AddDisk(_) => vm_add_disk( AddDisk(_) => vm_add_disk(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmAddDisk)?, .map_err(HttpError::VmAddDisk),
AddFs(_) => vm_add_fs( AddFs(_) => vm_add_fs(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmAddFs)?, .map_err(HttpError::VmAddFs),
AddPmem(_) => vm_add_pmem( AddPmem(_) => vm_add_pmem(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmAddPmem)?, .map_err(HttpError::VmAddPmem),
AddNet(_) => vm_add_net( AddNet(_) => vm_add_net(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmAddNet)?, .map_err(HttpError::VmAddNet),
AddVsock(_) => vm_add_vsock( AddVsock(_) => vm_add_vsock(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmAddVsock)?, .map_err(HttpError::VmAddVsock),
RemoveDevice(_) => vm_remove_device( RemoveDevice(_) => vm_remove_device(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmRemoveDevice)?, .map_err(HttpError::VmRemoveDevice),
Resize(_) => vm_resize( Resize(_) => vm_resize(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmResize)?, .map_err(HttpError::VmResize),
Restore(_) => vm_restore( Restore(_) => vm_restore(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmRestore)?, .map_err(HttpError::VmRestore),
Snapshot(_) => vm_snapshot( Snapshot(_) => vm_snapshot(
api_notifier, api_notifier,
api_sender, api_sender,
Arc::new(serde_json::from_slice(body.raw())?), Arc::new(serde_json::from_slice(body.raw())?),
) )
.map_err(HttpError::VmSnapshot)?, .map_err(HttpError::VmSnapshot),
_ => return Err(HttpError::BadRequest), _ => Err(HttpError::BadRequest),
}; }
} else { } else {
match self.action { match self.action {
Boot => vm_boot(api_notifier, api_sender).map_err(HttpError::VmBoot)?, Boot => vm_boot(api_notifier, api_sender).map_err(HttpError::VmBoot),
Delete => vm_delete(api_notifier, api_sender).map_err(HttpError::VmDelete)?, Delete => vm_delete(api_notifier, api_sender).map_err(HttpError::VmDelete),
Shutdown => vm_shutdown(api_notifier, api_sender).map_err(HttpError::VmShutdown)?, Shutdown => vm_shutdown(api_notifier, api_sender).map_err(HttpError::VmShutdown),
Reboot => vm_reboot(api_notifier, api_sender).map_err(HttpError::VmReboot)?, Reboot => vm_reboot(api_notifier, api_sender).map_err(HttpError::VmReboot),
Pause => vm_pause(api_notifier, api_sender).map_err(HttpError::VmPause)?, Pause => vm_pause(api_notifier, api_sender).map_err(HttpError::VmPause),
Resume => vm_resume(api_notifier, api_sender).map_err(HttpError::VmResume)?, Resume => vm_resume(api_notifier, api_sender).map_err(HttpError::VmResume),
_ => return Err(HttpError::BadRequest), _ => Err(HttpError::BadRequest),
}; }
} }
Ok(response_body)
} }
} }

79
vmm/src/lib.rs
View File

@@ -177,6 +177,7 @@ impl AsRawFd for EpollContext {
} }
} }
#[derive(Deserialize, Serialize)]
pub struct PciDeviceInfo { pub struct PciDeviceInfo {
pub id: String, pub id: String,
pub bdf: u32, pub bdf: u32,
@@ -461,14 +462,13 @@ impl Vmm {
} }
} }
fn vm_add_device(&mut self, device_cfg: DeviceConfig) -> result::Result<(), VmError> { fn vm_add_device(&mut self, device_cfg: DeviceConfig) -> result::Result<Vec<u8>, VmError> {
if let Some(ref mut vm) = self.vm { if let Some(ref mut vm) = self.vm {
if let Err(e) = vm.add_device(device_cfg) { let info = vm.add_device(device_cfg).map_err(|e| {
error!("Error when adding new device to the VM: {:?}", e); error!("Error when adding new device to the VM: {:?}", e);
Err(e) e
} else { })?;
Ok(()) serde_json::to_vec(&info).map_err(VmError::SerializeJson)
}
} else { } else {
Err(VmError::VmNotRunning) Err(VmError::VmNotRunning)
} }
@@ -487,66 +487,61 @@ impl Vmm {
} }
} }
fn vm_add_disk(&mut self, disk_cfg: DiskConfig) -> result::Result<(), VmError> { fn vm_add_disk(&mut self, disk_cfg: DiskConfig) -> result::Result<Vec<u8>, VmError> {
if let Some(ref mut vm) = self.vm { if let Some(ref mut vm) = self.vm {
if let Err(e) = vm.add_disk(disk_cfg) { let info = vm.add_disk(disk_cfg).map_err(|e| {
error!("Error when adding new disk to the VM: {:?}", e); error!("Error when adding new disk to the VM: {:?}", e);
Err(e) e
} else { })?;
Ok(()) serde_json::to_vec(&info).map_err(VmError::SerializeJson)
}
} else { } else {
Err(VmError::VmNotRunning) Err(VmError::VmNotRunning)
} }
} }
fn vm_add_fs(&mut self, fs_cfg: FsConfig) -> result::Result<(), VmError> { fn vm_add_fs(&mut self, fs_cfg: FsConfig) -> result::Result<Vec<u8>, VmError> {
if let Some(ref mut vm) = self.vm { if let Some(ref mut vm) = self.vm {
if let Err(e) = vm.add_fs(fs_cfg) { let info = vm.add_fs(fs_cfg).map_err(|e| {
error!("Error when adding new fs to the VM: {:?}", e); error!("Error when adding new fs to the VM: {:?}", e);
Err(e) e
} else { })?;
Ok(()) serde_json::to_vec(&info).map_err(VmError::SerializeJson)
}
} else { } else {
Err(VmError::VmNotRunning) Err(VmError::VmNotRunning)
} }
} }
fn vm_add_pmem(&mut self, pmem_cfg: PmemConfig) -> result::Result<(), VmError> { fn vm_add_pmem(&mut self, pmem_cfg: PmemConfig) -> result::Result<Vec<u8>, VmError> {
if let Some(ref mut vm) = self.vm { if let Some(ref mut vm) = self.vm {
if let Err(e) = vm.add_pmem(pmem_cfg) { let info = vm.add_pmem(pmem_cfg).map_err(|e| {
error!("Error when adding new pmem device to the VM: {:?}", e); error!("Error when adding new pmem device to the VM: {:?}", e);
Err(e) e
} else { })?;
Ok(()) serde_json::to_vec(&info).map_err(VmError::SerializeJson)
}
} else { } else {
Err(VmError::VmNotRunning) Err(VmError::VmNotRunning)
} }
} }
fn vm_add_net(&mut self, net_cfg: NetConfig) -> result::Result<(), VmError> { fn vm_add_net(&mut self, net_cfg: NetConfig) -> result::Result<Vec<u8>, VmError> {
if let Some(ref mut vm) = self.vm { if let Some(ref mut vm) = self.vm {
if let Err(e) = vm.add_net(net_cfg) { let info = vm.add_net(net_cfg).map_err(|e| {
error!("Error when adding new network device to the VM: {:?}", e); error!("Error when adding new network device to the VM: {:?}", e);
Err(e) e
} else { })?;
Ok(()) serde_json::to_vec(&info).map_err(VmError::SerializeJson)
}
} else { } else {
Err(VmError::VmNotRunning) Err(VmError::VmNotRunning)
} }
} }
fn vm_add_vsock(&mut self, vsock_cfg: VsockConfig) -> result::Result<(), VmError> { fn vm_add_vsock(&mut self, vsock_cfg: VsockConfig) -> result::Result<Vec<u8>, VmError> {
if let Some(ref mut vm) = self.vm { if let Some(ref mut vm) = self.vm {
if let Err(e) = vm.add_vsock(vsock_cfg) { let info = vm.add_vsock(vsock_cfg).map_err(|e| {
error!("Error when adding new vsock device to the VM: {:?}", e); error!("Error when adding new vsock device to the VM: {:?}", e);
Err(e) e
} else { })?;
Ok(()) serde_json::to_vec(&info).map_err(VmError::SerializeJson)
}
} else { } else {
Err(VmError::VmNotRunning) Err(VmError::VmNotRunning)
} }
@@ -727,7 +722,7 @@ impl Vmm {
let response = self let response = self
.vm_add_device(add_device_data.as_ref().clone()) .vm_add_device(add_device_data.as_ref().clone())
.map_err(ApiError::VmAddDevice) .map_err(ApiError::VmAddDevice)
.map(|_| ApiResponsePayload::Empty); .map(ApiResponsePayload::VmAction);
sender.send(response).map_err(Error::ApiResponseSend)?; sender.send(response).map_err(Error::ApiResponseSend)?;
} }
ApiRequest::VmRemoveDevice(remove_device_data, sender) => { ApiRequest::VmRemoveDevice(remove_device_data, sender) => {
@@ -741,35 +736,35 @@ impl Vmm {
let response = self let response = self
.vm_add_disk(add_disk_data.as_ref().clone()) .vm_add_disk(add_disk_data.as_ref().clone())
.map_err(ApiError::VmAddDisk) .map_err(ApiError::VmAddDisk)
.map(|_| ApiResponsePayload::Empty); .map(ApiResponsePayload::VmAction);
sender.send(response).map_err(Error::ApiResponseSend)?; sender.send(response).map_err(Error::ApiResponseSend)?;
} }
ApiRequest::VmAddFs(add_fs_data, sender) => { ApiRequest::VmAddFs(add_fs_data, sender) => {
let response = self let response = self
.vm_add_fs(add_fs_data.as_ref().clone()) .vm_add_fs(add_fs_data.as_ref().clone())
.map_err(ApiError::VmAddFs) .map_err(ApiError::VmAddFs)
.map(|_| ApiResponsePayload::Empty); .map(ApiResponsePayload::VmAction);
sender.send(response).map_err(Error::ApiResponseSend)?; sender.send(response).map_err(Error::ApiResponseSend)?;
} }
ApiRequest::VmAddPmem(add_pmem_data, sender) => { ApiRequest::VmAddPmem(add_pmem_data, sender) => {
let response = self let response = self
.vm_add_pmem(add_pmem_data.as_ref().clone()) .vm_add_pmem(add_pmem_data.as_ref().clone())
.map_err(ApiError::VmAddPmem) .map_err(ApiError::VmAddPmem)
.map(|_| ApiResponsePayload::Empty); .map(ApiResponsePayload::VmAction);
sender.send(response).map_err(Error::ApiResponseSend)?; sender.send(response).map_err(Error::ApiResponseSend)?;
} }
ApiRequest::VmAddNet(add_net_data, sender) => { ApiRequest::VmAddNet(add_net_data, sender) => {
let response = self let response = self
.vm_add_net(add_net_data.as_ref().clone()) .vm_add_net(add_net_data.as_ref().clone())
.map_err(ApiError::VmAddNet) .map_err(ApiError::VmAddNet)
.map(|_| ApiResponsePayload::Empty); .map(ApiResponsePayload::VmAction);
sender.send(response).map_err(Error::ApiResponseSend)?; sender.send(response).map_err(Error::ApiResponseSend)?;
} }
ApiRequest::VmAddVsock(add_vsock_data, sender) => { ApiRequest::VmAddVsock(add_vsock_data, sender) => {
let response = self let response = self
.vm_add_vsock(add_vsock_data.as_ref().clone()) .vm_add_vsock(add_vsock_data.as_ref().clone())
.map_err(ApiError::VmAddVsock) .map_err(ApiError::VmAddVsock)
.map(|_| ApiResponsePayload::Empty); .map(ApiResponsePayload::VmAction);
sender.send(response).map_err(Error::ApiResponseSend)?; sender.send(response).map_err(Error::ApiResponseSend)?;
} }
} }

3
vmm/src/vm.rs
View File

@@ -209,6 +209,9 @@ pub enum Error {
/// No more that one virtio-vsock device /// No more that one virtio-vsock device
TooManyVsockDevices, TooManyVsockDevices,
/// Failed serializing into JSON
SerializeJson(serde_json::Error),
} }
pub type Result<T> = result::Result<T, Error>; pub type Result<T> = result::Result<T, Error>;