ref(event_manger): pass the event_manager to an Option

As only devices that are implemented in VMM / Device Model
need an event manager in order to handle guest-to-host
notifications, this commit only does so in these situations:

- The thread responsible for running the event manager run
loop is only created for this type of devices
- The event manager object is only created for this type of
devices

Signed-off-by: joaopeixoto13 <[email protected]>

src/virtio/src/block/virtio/device.rs

@@ -48,7 +48,7 @@ impl VirtioDeviceT for VirtioBlock {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.
@@ -67,7 +67,7 @@ impl VirtioDeviceT for VirtioBlock {
         let common_device = VirtioDeviceCommon::new(config, device_model, virtio_cfg).unwrap();
 
         // Create a remote endpoint object, that allows interacting with the VM EventManager from a different thread.
-        let remote_endpoint = event_manager.lock().unwrap().remote_endpoint();
+        let remote_endpoint = event_manager.unwrap().lock().unwrap().remote_endpoint();
 
         // Create the block device.
         let block = Arc::new(Mutex::new(VirtioBlock {

src/virtio/src/device.rs

@@ -287,7 +287,7 @@ pub trait VirtioDeviceT {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>>;
 

src/virtio/src/fs/vhost_user/device.rs

@@ -39,7 +39,7 @@ impl VirtioDeviceT for VhostUserFs {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        _event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        _event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.

src/virtio/src/net/vhost/device.rs

@@ -49,7 +49,7 @@ impl VirtioDeviceT for VhostNet {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        _event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        _event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.

src/virtio/src/net/virtio/device.rs

@@ -45,7 +45,7 @@ impl VirtioDeviceT for VirtioNet {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.
@@ -64,7 +64,7 @@ impl VirtioDeviceT for VirtioNet {
         let common_device = VirtioDeviceCommon::new(config, device_model, virtio_cfg).unwrap();
 
         // Create a remote endpoint object, that allows interacting with the VM EventManager from a different thread.
-        let remote_endpoint = event_manager.lock().unwrap().remote_endpoint();
+        let remote_endpoint = event_manager.unwrap().lock().unwrap().remote_endpoint();
 
         // Create the net device.
         let net = Arc::new(Mutex::new(VirtioNet {

src/virtio/src/vsock/vhost/device.rs

@@ -44,7 +44,7 @@ impl VirtioDeviceT for VhostVsockDevice {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        _event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        _event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.

src/virtio/src/vsock/vhost_user/device.rs

@@ -38,7 +38,7 @@ impl VirtioDeviceT for VhostUserVsock {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        _event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        _event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.

src/virtio/src/vsock/virtio/device.rs

@@ -33,7 +33,7 @@ impl VirtioDeviceT for VirtioVsock {
     fn new(
         config: &DeviceConfig,
         device_manager: Arc<Mutex<IoManager>>,
-        event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+        event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
         device_model: Arc<Mutex<BaoDeviceModel>>,
     ) -> Result<Arc<Mutex<Self>>> {
         // Extract the generic features and queues.
@@ -52,7 +52,7 @@ impl VirtioDeviceT for VirtioVsock {
         let common_device = VirtioDeviceCommon::new(config, device_model, virtio_cfg).unwrap();
 
         // Create a remote endpoint object, that allows interacting with the VM EventManager from a different thread.
-        let remote_endpoint = event_manager.lock().unwrap().remote_endpoint();
+        let remote_endpoint = event_manager.unwrap().lock().unwrap().remote_endpoint();
 
         // Create the vsock device.
         let vsock = Arc::new(Mutex::new(VirtioVsock {

src/vmm/src/vm.rs

@@ -29,7 +29,7 @@ pub struct Vm {
     device_model: Arc<Mutex<BaoDeviceModel>>,
     devices: Vec<VirtioDeviceType>,
     device_manager: Arc<Mutex<IoManager>>,
-    event_manager: Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>,
+    pub event_manager: Option<Arc<Mutex<EventManager<Arc<Mutex<dyn MutEventSubscriber + Send>>>>>>,
 }
 
 impl Vm {
@@ -47,11 +47,15 @@ impl Vm {
         // Create the device manager.
         let device_manager = Arc::new(Mutex::new(IoManager::new()));
 
-        // Create the event manager.
-        let event_manager = Arc::new(Mutex::new(
-            EventManager::<Arc<Mutex<dyn MutEventSubscriber + Send>>>::new()
-                .map_err(Error::EventManager)?,
-        ));
+        // Create the event manager if the data plane is virtio.
+        let event_manager = if config.data_plane == "virtio" {
+            Some(Arc::new(Mutex::new(
+                EventManager::<Arc<Mutex<dyn MutEventSubscriber + Send>>>::new()
+                    .map_err(Error::EventManager)?,
+            )))
+        } else {
+            None
+        };
 
         // Create the VM.
         let mut vm = Vm {
@@ -239,7 +243,13 @@ impl Vm {
     /// device.
     pub fn run_event_manager(self: Arc<Self>) {
         loop {
-            self.event_manager.lock().unwrap().run().unwrap();
+            self.event_manager
+                .as_ref()
+                .unwrap()
+                .lock()
+                .unwrap()
+                .run()
+                .unwrap();
         }
     }
 }

src/vmm/src/vmm.rs

@@ -79,15 +79,17 @@ impl Vmm {
             );
 
             // Create a new vCPU/thread to run the VM event manager.
-            let vm_evm = vm.clone();
-            self.vcpus.lock().unwrap().push(
-                Builder::new()
-                    .name(format!("vm_{}_evm", vm_evm.id))
-                    .spawn(move || {
-                        vm_evm.run_event_manager();
-                    })
-                    .unwrap(),
-            );
+            if vm.event_manager.is_some() {
+                let vm_evm = vm.clone();
+                self.vcpus.lock().unwrap().push(
+                    Builder::new()
+                        .name(format!("vm_{}_evm", vm_evm.id))
+                        .spawn(move || {
+                            vm_evm.run_event_manager();
+                        })
+                        .unwrap(),
+                );
+            }
         }
         Ok(())
     }