vmresources: json describe net devices

Signed-off-by: Adrian Catangiu <acatan@amazon.com>

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

@@ -24,6 +24,7 @@ use rate_limiter::{BucketUpdate, RateLimiter, TokenType};
 #[cfg(not(test))]
 use std::io;
 use std::io::{Read, Write};
+use std::net::Ipv4Addr;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
@@ -217,9 +218,31 @@ impl Net {
         self.guest_mac.as_ref()
     }
 
-    /// Provides a mutable reference to the `MmdsNetworkStack`.
-    pub fn mmds_ns_mut(&mut self) -> Option<&mut MmdsNetworkStack> {
-        self.mmds_ns.as_mut()
+    /// Provides the host IFACE name of this net device.
+    pub fn iface_name(&self) -> String {
+        self.tap.if_name_as_str().to_string()
+    }
+
+    /// Says if this device supports MMDS.
+    pub fn mmds_enabled(&self) -> bool {
+        self.mmds_ns.is_some()
+    }
+
+    /// Sets MMDS endpoint IPv4 address, if the device supports MMDS.
+    pub fn set_mmds_ipv4_addr(&mut self, ipv4_addr: Ipv4Addr) {
+        if let Some(mmds_ns) = self.mmds_ns.as_mut() {
+            mmds_ns.set_ipv4_addr(ipv4_addr);
+        }
+    }
+
+    /// Provides a reference to the configured RX rate limiter.
+    pub fn rx_rate_limiter(&self) -> &RateLimiter {
+        &self.rx_rate_limiter
+    }
+
+    /// Provides a reference to the configured TX rate limiter.
+    pub fn tx_rate_limiter(&self) -> &RateLimiter {
+        &self.tx_rate_limiter
     }
 
     fn signal_used_queue(&mut self) -> result::Result<(), DeviceError> {

src/devices/src/virtio/net/persist.rs

@@ -58,7 +58,7 @@ impl Persist<'_> for Net {
     fn save(&self) -> Self::State {
         NetState {
             id: self.id().clone(),
-            tap_if_name: self.tap.if_name_as_str().to_string(),
+            tap_if_name: self.iface_name(),
             rx_rate_limiter_state: self.rx_rate_limiter.save(),
             tx_rate_limiter_state: self.tx_rate_limiter.save(),
             mmds_ns: self.mmds_ns.as_ref().map(|mmds| mmds.save()),
@@ -146,7 +146,7 @@ mod tests {
 
             // Save some fields that we want to check later.
             id = net.id.clone();
-            tap_if_name = net.tap.if_name_as_str().to_string();
+            tap_if_name = net.iface_name();
             allow_mmds_requests = net.mmds_ns.is_some();
             virtio_state = VirtioDeviceState::from_device(&net);
         }
@@ -171,7 +171,7 @@ mod tests {
 
             // Test that net specific fields are the same.
             assert_eq!(&restored_net.id, &id);
-            assert_eq!(&restored_net.tap.if_name_as_str(), &tap_if_name);
+            assert_eq!(&restored_net.iface_name(), &tap_if_name);
             assert_eq!(restored_net.mmds_ns.is_some(), allow_mmds_requests);
             assert_eq!(restored_net.rx_rate_limiter, RateLimiter::default());
             assert_eq!(restored_net.tx_rate_limiter, RateLimiter::default());

src/vmm/src/resources.rs

@@ -162,7 +162,6 @@ impl VmResources {
 
         // TODO: go through net devices and check for mmds addr
         let mmds_config: Option<MmdsConfig> = None;
-        let net_devices: Vec<NetworkInterfaceConfig> = vec![];
         let vsock_device: Option<VsockDeviceConfig> = None;
         let vmm_config = VmmConfig {
             balloon_device: self.balloon.get_config().ok(),
@@ -172,7 +171,7 @@ impl VmResources {
             machine_config: Some(self.vm_config.clone()),
             metrics: None,
             mmds_config,
-            net_devices,
+            net_devices: self.net_builder.configs(),
             vsock_device,
         };
         serde_json::to_string(&vmm_config).unwrap()
@@ -313,9 +312,10 @@ impl VmResources {
             // Update `Net` device `MmdsNetworkStack` IPv4 address.
             match &self.mmds_config {
                 Some(cfg) => cfg.ipv4_addr().map_or((), |ipv4_addr| {
-                    if let Some(mmds_ns) = net_device.lock().expect("Poisoned lock").mmds_ns_mut() {
-                        mmds_ns.set_ipv4_addr(ipv4_addr);
-                    };
+                    net_device
+                        .lock()
+                        .expect("Poisoned lock")
+                        .set_mmds_ipv4_addr(ipv4_addr);
                 }),
                 None => (),
             };
@@ -338,9 +338,10 @@ impl VmResources {
 
         // Update existing built network device `MmdsNetworkStack` IPv4 address.
         for net_device in self.net_builder.iter_mut() {
-            if let Some(mmds_ns) = net_device.lock().expect("Poisoned lock").mmds_ns_mut() {
-                mmds_ns.set_ipv4_addr(ipv4_addr)
-            }
+            net_device
+                .lock()
+                .expect("Poisoned lock")
+                .set_mmds_ipv4_addr(ipv4_addr);
         }
 
         self.mmds_config = Some(config);

src/vmm/src/vmm_config/net.rs

@@ -13,6 +13,7 @@ use devices::virtio::Net;
 use utils::net::mac::MacAddr;
 
 use serde::{Deserialize, Serialize};
+use std::ops::Deref;
 
 /// This struct represents the strongly typed equivalent of the json body from net iface
 /// related requests.
@@ -38,6 +39,21 @@ pub struct NetworkInterfaceConfig {
     pub allow_mmds_requests: bool,
 }
 
+impl From<&Net> for NetworkInterfaceConfig {
+    fn from(net: &Net) -> Self {
+        let rx_rl: RateLimiterConfig = net.rx_rate_limiter().into();
+        let tx_rl: RateLimiterConfig = net.tx_rate_limiter().into();
+        NetworkInterfaceConfig {
+            iface_id: net.id().clone(),
+            host_dev_name: net.iface_name(),
+            guest_mac: net.guest_mac().copied(),
+            rx_rate_limiter: rx_rl.into_option(),
+            tx_rate_limiter: tx_rl.into_option(),
+            allow_mmds_requests: net.mmds_enabled(),
+        }
+    }
+}
+
 // Serde does not allow specifying a default value for a field
 // that is not required. The workaround is to specify a function
 // that returns the value.
@@ -190,6 +206,15 @@ impl NetBuilder {
         )
         .map_err(NetworkInterfaceError::CreateNetworkDevice)
     }
+
+    /// Returns a vec with the structures used to configure the net devices.
+    pub fn configs(&self) -> Vec<NetworkInterfaceConfig> {
+        let mut ret = vec![];
+        for net in &self.net_devices {
+            ret.push(NetworkInterfaceConfig::from(net.lock().unwrap().deref()));
+        }
+        ret
+    }
 }
 
 #[cfg(test)]
@@ -213,8 +238,8 @@ mod tests {
             iface_id: String::from(id),
             host_dev_name: String::from(name),
             guest_mac: Some(MacAddr::parse_str(mac).unwrap()),
-            rx_rate_limiter: Some(RateLimiterConfig::default()),
-            tx_rate_limiter: Some(RateLimiterConfig::default()),
+            rx_rate_limiter: RateLimiterConfig::default().into_option(),
+            tx_rate_limiter: RateLimiterConfig::default().into_option(),
             allow_mmds_requests: false,
         }
     }
@@ -353,11 +378,19 @@ mod tests {
         let host_dev_name = "dev";
         let guest_mac = "01:23:45:67:89:0b";
 
-        let net_if = create_netif(net_id, host_dev_name, guest_mac);
+        let net_if_cfg = create_netif(net_id, host_dev_name, guest_mac);
         assert_eq!(
-            net_if.guest_mac.unwrap(),
+            net_if_cfg.guest_mac.unwrap(),
             MacAddr::parse_str(guest_mac).unwrap()
         );
-        assert_eq!(net_if.allow_mmds_requests, false);
+        assert_eq!(net_if_cfg.allow_mmds_requests, false);
+
+        let mut net_builder = NetBuilder::new();
+        assert!(net_builder.build(net_if_cfg.clone()).is_ok());
+        assert_eq!(net_builder.net_devices.len(), 1);
+
+        let configs = net_builder.configs();
+        assert_eq!(configs.len(), 1);
+        assert_eq!(configs.first().unwrap(), &net_if_cfg);
     }
 }