Integrate rate limiting with virtio network device servicing

Use two RateLimiter objects, one for ingress one egress, to account and limit
both bytes/s and ops/s when servicing the virtio network devices virtqueues.

Signed-off-by: Adrian Catangiu <[email protected]>

Author: acatangiu

api_server/src/http_service.rs

@@ -986,6 +986,8 @@ mod tests {
             state: DeviceState::Attached,
             host_dev_name: String::from("foo"),
             guest_mac: Some(MacAddr::parse_str("12:34:56:78:9a:BC").unwrap()),
+            rx_rate_limiter: None,
+            tx_rate_limiter: None,
         };
 
         match netif.into_parsed_request("bar") {

api_server/src/request/sync/net.rs

@@ -2,7 +2,8 @@ use std::result;
 
 use futures::sync::oneshot;
 
-use super::{DeviceState, SyncRequest};
+use super::{DeviceState, RateLimiter, SyncRequest};
+
 use net_util::MacAddr;
 use request::ParsedRequest;
 
@@ -15,6 +16,10 @@ pub struct NetworkInterfaceBody {
     pub host_dev_name: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub guest_mac: Option<MacAddr>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rx_rate_limiter: Option<RateLimiter>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tx_rate_limiter: Option<RateLimiter>,
 }
 
 impl NetworkInterfaceBody {
@@ -45,6 +50,8 @@ mod tests {
             state: DeviceState::Attached,
             host_dev_name: String::from("bar"),
             guest_mac: Some(MacAddr::parse_str("12:34:56:78:9A:BC").unwrap()),
+            rx_rate_limiter: None,
+            tx_rate_limiter: None,
         };
 
         assert!(netif.clone().into_parsed_request("bar").is_err());
@@ -67,14 +74,24 @@ mod tests {
             state: DeviceState::Attached,
             host_dev_name: String::from("bar"),
             guest_mac: Some(MacAddr::parse_str("12:34:56:78:9A:BC").unwrap()),
+            rx_rate_limiter: Some(RateLimiter::default()),
+            tx_rate_limiter: Some(RateLimiter::default()),
         };
 
         // This is the json encoding of the netif variable.
         let jstr = r#"{
             "iface_id": "foo",
             "host_dev_name": "bar",
             "state": "Attached",
-            "guest_mac": "12:34:56:78:9A:bc"
+            "guest_mac": "12:34:56:78:9A:bc",
+            "rx_rate_limiter": {
+                "bandwidth": { "size": 0, "refill_time": 0 },
+                "ops": { "size": 0, "refill_time": 0 }
+            },
+            "tx_rate_limiter": {
+                "bandwidth": { "size": 0, "refill_time": 0 },
+                "ops": { "size": 0, "refill_time": 0 }
+            }
         }"#;
 
         let x = serde_json::from_str(jstr).expect("deserialization failed.");
@@ -84,7 +101,7 @@ mod tests {
         let z = serde_json::from_str(y.as_ref()).expect("deserialization (2) failed.");
         assert_eq!(x, z);
 
-        // Check that guest_mac is truly optional.
+        // Check that guest_mac and rate limiters are truly optional.
         let jstr_no_mac = r#"{
             "iface_id": "foo",
             "host_dev_name": "bar",

devices/src/virtio/block.rs

@@ -404,7 +404,7 @@ impl Block {
         mut disk_image: File,
         is_disk_read_only: bool,
         epoll_config: EpollConfig,
-        rate_limiter: RateLimiter,
+        rate_limiter: Option<RateLimiter>,
     ) -> SysResult<Block> {
         let disk_size = disk_image.seek(SeekFrom::End(0))? as u64;
         if disk_size % SECTOR_SIZE != 0 {
@@ -428,7 +428,7 @@ impl Block {
             acked_features: 0u64,
             config_space: build_config_space(disk_size),
             epoll_config,
-            rate_limiter: Some(rate_limiter),
+            rate_limiter,
         })
     }
 }
@@ -570,8 +570,7 @@ impl VirtioDevice for Block {
                 interrupt_status: status,
                 interrupt_evt,
                 queue_evt,
-                // safe to .take().unwrap() since activate is only called once
-                rate_limiter: self.rate_limiter.take().unwrap(),
+                rate_limiter: self.rate_limiter.take().unwrap_or_default(),
                 disk_image_id,
             };
             let rate_limiter_rawfd = handler.rate_limiter.as_raw_fd();
@@ -653,7 +652,7 @@ mod tests {
             // rate limiting enabled but with a high operation rate (10 million ops/s)
             let rate_limiter = RateLimiter::new(0, 0, 100000, 10).unwrap();
             DummyBlock {
-                block: Block::new(f, false, epoll_config, rate_limiter).unwrap(),
+                block: Block::new(f, false, epoll_config, Some(rate_limiter)).unwrap(),
                 epoll_raw_fd,
                 _receiver,
             }