From 42a9896fe434dbd09bb3bc6733c17d4cb7fcdcc5 Mon Sep 17 00:00:00 2001
From: Rob Bradford <robert.bradford@intel.com>
Date: Fri, 13 Mar 2020 09:38:42 +0000
Subject: [PATCH] vmm: device_manager: Refactor make_virtio_net_devices

Split it into a method that creates a single device which is called by
the multiple device version so this can be used when dynamically adding
a device.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>
---
 vmm/src/device_manager.rs | 120 ++++++++++++++++++++------------------
 1 file changed, 63 insertions(+), 57 deletions(-)

diff --git a/vmm/src/device_manager.rs b/vmm/src/device_manager.rs
index d470b1934..4963973a0 100644
--- a/vmm/src/device_manager.rs
+++ b/vmm/src/device_manager.rs
@@ -1209,69 +1209,75 @@ impl DeviceManager {
         Ok(sock)
     }
 
+    fn make_virtio_net_device(
+        &mut self,
+        net_cfg: &NetConfig,
+    ) -> DeviceManagerResult<(VirtioDeviceArc, bool)> {
+        if net_cfg.vhost_user {
+            let sock = if let Some(sock) = net_cfg.vhost_socket.clone() {
+                sock
+            } else {
+                self.start_net_backend(net_cfg)?
+            };
+            let vu_cfg = VhostUserConfig {
+                sock,
+                num_queues: net_cfg.num_queues,
+                queue_size: net_cfg.queue_size,
+            };
+            let vhost_user_net_device = Arc::new(Mutex::new(
+                vm_virtio::vhost_user::Net::new(net_cfg.mac, vu_cfg)
+                    .map_err(DeviceManagerError::CreateVhostUserNet)?,
+            ));
+            self.migratable_devices
+                .push(Arc::clone(&vhost_user_net_device) as Arc<Mutex<dyn Migratable>>);
+            Ok((
+                Arc::clone(&vhost_user_net_device) as Arc<Mutex<dyn vm_virtio::VirtioDevice>>,
+                net_cfg.iommu,
+            ))
+        } else {
+            let virtio_net_device = if let Some(ref tap_if_name) = net_cfg.tap {
+                Arc::new(Mutex::new(
+                    vm_virtio::Net::new(
+                        Some(tap_if_name),
+                        None,
+                        None,
+                        Some(net_cfg.mac),
+                        net_cfg.iommu,
+                        net_cfg.num_queues,
+                        net_cfg.queue_size,
+                    )
+                    .map_err(DeviceManagerError::CreateVirtioNet)?,
+                ))
+            } else {
+                Arc::new(Mutex::new(
+                    vm_virtio::Net::new(
+                        None,
+                        Some(net_cfg.ip),
+                        Some(net_cfg.mask),
+                        Some(net_cfg.mac),
+                        net_cfg.iommu,
+                        net_cfg.num_queues,
+                        net_cfg.queue_size,
+                    )
+                    .map_err(DeviceManagerError::CreateVirtioNet)?,
+                ))
+            };
+            self.migratable_devices
+                .push(Arc::clone(&virtio_net_device) as Arc<Mutex<dyn Migratable>>);
+            Ok((
+                Arc::clone(&virtio_net_device) as Arc<Mutex<dyn vm_virtio::VirtioDevice>>,
+                net_cfg.iommu,
+            ))
+        }
+    }
+
     /// Add virto-net and vhost-user-net devices
     fn make_virtio_net_devices(&mut self) -> DeviceManagerResult<Vec<(VirtioDeviceArc, bool)>> {
         let mut devices = Vec::new();
         let net_devices = self.config.lock().unwrap().net.clone();
         if let Some(net_list_cfg) = &net_devices {
             for net_cfg in net_list_cfg.iter() {
-                if net_cfg.vhost_user {
-                    let sock = if let Some(sock) = net_cfg.vhost_socket.clone() {
-                        sock
-                    } else {
-                        self.start_net_backend(net_cfg)?
-                    };
-                    let vu_cfg = VhostUserConfig {
-                        sock,
-                        num_queues: net_cfg.num_queues,
-                        queue_size: net_cfg.queue_size,
-                    };
-                    let vhost_user_net_device = Arc::new(Mutex::new(
-                        vm_virtio::vhost_user::Net::new(net_cfg.mac, vu_cfg)
-                            .map_err(DeviceManagerError::CreateVhostUserNet)?,
-                    ));
-                    devices.push((
-                        Arc::clone(&vhost_user_net_device)
-                            as Arc<Mutex<dyn vm_virtio::VirtioDevice>>,
-                        net_cfg.iommu,
-                    ));
-                    self.migratable_devices
-                        .push(Arc::clone(&vhost_user_net_device) as Arc<Mutex<dyn Migratable>>);
-                } else {
-                    let virtio_net_device = if let Some(ref tap_if_name) = net_cfg.tap {
-                        Arc::new(Mutex::new(
-                            vm_virtio::Net::new(
-                                Some(tap_if_name),
-                                None,
-                                None,
-                                Some(net_cfg.mac),
-                                net_cfg.iommu,
-                                net_cfg.num_queues,
-                                net_cfg.queue_size,
-                            )
-                            .map_err(DeviceManagerError::CreateVirtioNet)?,
-                        ))
-                    } else {
-                        Arc::new(Mutex::new(
-                            vm_virtio::Net::new(
-                                None,
-                                Some(net_cfg.ip),
-                                Some(net_cfg.mask),
-                                Some(net_cfg.mac),
-                                net_cfg.iommu,
-                                net_cfg.num_queues,
-                                net_cfg.queue_size,
-                            )
-                            .map_err(DeviceManagerError::CreateVirtioNet)?,
-                        ))
-                    };
-                    devices.push((
-                        Arc::clone(&virtio_net_device) as Arc<Mutex<dyn vm_virtio::VirtioDevice>>,
-                        net_cfg.iommu,
-                    ));
-                    self.migratable_devices
-                        .push(Arc::clone(&virtio_net_device) as Arc<Mutex<dyn Migratable>>);
-                }
+                devices.push(self.make_virtio_net_device(net_cfg)?);
             }
         }