feat(net): add MRG_RXBUF support to virtio-net device

Now virtio-net device VIRTIO_NET_F_MRG_RXBUF feature which allows it
to write single packet into multiple descriptor chains.
The amount of descriptor chains (also known as heads) is written into
the `virtio_net_hdr_v1` structure which is located at the very begging
of the packet.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

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

@@ -19,7 +19,7 @@ use crate::devices::virtio::gen::virtio_blk::VIRTIO_F_VERSION_1;
 use crate::devices::virtio::gen::virtio_net::{
     virtio_net_hdr_v1, VIRTIO_NET_F_CSUM, VIRTIO_NET_F_GUEST_CSUM, VIRTIO_NET_F_GUEST_TSO4,
     VIRTIO_NET_F_GUEST_TSO6, VIRTIO_NET_F_GUEST_UFO, VIRTIO_NET_F_HOST_TSO4,
-    VIRTIO_NET_F_HOST_TSO6, VIRTIO_NET_F_HOST_UFO, VIRTIO_NET_F_MAC,
+    VIRTIO_NET_F_HOST_TSO6, VIRTIO_NET_F_HOST_UFO, VIRTIO_NET_F_MAC, VIRTIO_NET_F_MRG_RXBUF,
 };
 use crate::devices::virtio::gen::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
 use crate::devices::virtio::iovec::IoVecBuffer;
@@ -149,6 +149,7 @@ impl Net {
             | 1 << VIRTIO_NET_F_HOST_TSO6
             | 1 << VIRTIO_NET_F_HOST_UFO
             | 1 << VIRTIO_F_VERSION_1
+            | 1 << VIRTIO_NET_F_MRG_RXBUF
             | 1 << VIRTIO_RING_F_EVENT_IDX;
 
         let mut config_space = ConfigSpace::default();
@@ -659,7 +660,11 @@ impl Net {
     }
 
     fn read_tap(&mut self) -> std::io::Result<usize> {
-        self.tap.read_iovec(self.rx_buffer.one_chain_mut_slice())
+        if self.has_feature(u64::from(VIRTIO_NET_F_MRG_RXBUF)) {
+            self.tap.read_iovec(self.rx_buffer.all_chains_mut_slice())
+        } else {
+            self.tap.read_iovec(self.rx_buffer.one_chain_mut_slice())
+        }
     }
 
     /// Process a single RX queue event.
@@ -891,8 +896,8 @@ pub mod tests {
     use crate::devices::virtio::net::rx_buffer::ChainInfo;
     use crate::devices::virtio::net::test_utils::test::TestHelper;
     use crate::devices::virtio::net::test_utils::{
-        default_net, if_index, inject_tap_tx_frame, set_mac, NetEvent, NetQueue,
-        TapTrafficSimulator,
+        default_net, if_index, inject_tap_tx_frame, mock_frame_set_num_buffers, set_mac, NetEvent,
+        NetQueue, TapTrafficSimulator,
     };
     use crate::devices::virtio::net::NET_QUEUE_SIZES;
     use crate::devices::virtio::queue::VIRTQ_DESC_F_WRITE;
@@ -1077,10 +1082,9 @@ pub mod tests {
         assert_eq!(th.rxq.used.idx.get(), 0);
     }
 
-    #[test]
-    fn test_rx_read_only_descriptor() {
-        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
-        let mut th = TestHelper::get_default(&mem);
+    fn rx_read_only_descriptor(mut th: TestHelper) {
+        // let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        // let mut th = TestHelper::get_default(&mem);
         th.activate_net();
 
         th.add_desc_chain(
@@ -1099,9 +1103,22 @@ pub mod tests {
     }
 
     #[test]
-    fn test_rx_partial_write() {
+    fn test_rx_read_only_descriptor() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let th = TestHelper::get_default(&mem);
+        rx_read_only_descriptor(th);
+    }
+
+    #[test]
+    fn test_rx_read_only_descriptor_mrg_buf() {
         let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
         let mut th = TestHelper::get_default(&mem);
+        // VIRTIO_NET_F_MRG_RXBUF is not enabled by default
+        th.net().acked_features = 1 << VIRTIO_NET_F_MRG_RXBUF;
+        rx_read_only_descriptor(th);
+    }
+
+    fn rx_partial_write(mut th: TestHelper) {
         th.activate_net();
 
         // The descriptor chain is created so that the last descriptor doesn't fit in the
@@ -1123,9 +1140,22 @@ pub mod tests {
     }
 
     #[test]
-    fn test_rx_retry() {
+    fn test_rx_partial_write() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let th = TestHelper::get_default(&mem);
+        rx_partial_write(th);
+    }
+
+    #[test]
+    fn test_rx_partial_write_mrg_buf() {
         let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
         let mut th = TestHelper::get_default(&mem);
+        // VIRTIO_NET_F_MRG_RXBUF is not enabled by default
+        th.net().acked_features = 1 << VIRTIO_NET_F_MRG_RXBUF;
+        rx_partial_write(th);
+    }
+
+    fn rx_retry(mut th: TestHelper) {
         th.activate_net();
 
         // Even though too short descriptor chains are also
@@ -1175,9 +1205,22 @@ pub mod tests {
     }
 
     #[test]
-    fn test_rx_complex_desc_chain() {
+    fn test_rx_retry() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let th = TestHelper::get_default(&mem);
+        rx_retry(th);
+    }
+
+    #[test]
+    fn test_rx_retry_mrg_buf() {
         let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
         let mut th = TestHelper::get_default(&mem);
+        // VIRTIO_NET_F_MRG_RXBUF is not enabled by default
+        th.net().acked_features = 1 << VIRTIO_NET_F_MRG_RXBUF;
+        rx_retry(th);
+    }
+
+    fn rx_complex_desc_chain(mut th: TestHelper) {
         th.activate_net();
 
         // Create a valid Rx avail descriptor chain with multiple descriptors.
@@ -1214,9 +1257,22 @@ pub mod tests {
     }
 
     #[test]
-    fn test_rx_multiple_frames() {
+    fn test_rx_complex_desc_chain() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let th = TestHelper::get_default(&mem);
+        rx_complex_desc_chain(th);
+    }
+
+    #[test]
+    fn test_rx_complex_desc_chain_mrg_buf() {
         let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
         let mut th = TestHelper::get_default(&mem);
+        // VIRTIO_NET_F_MRG_RXBUF is not enabled by default
+        th.net().acked_features = 1 << VIRTIO_NET_F_MRG_RXBUF;
+        rx_complex_desc_chain(th);
+    }
+
+    fn rx_multiple_frames(mut th: TestHelper) {
         th.activate_net();
 
         // Create 2 valid Rx avail descriptor chains. Each one has enough space to fit the
@@ -1257,6 +1313,67 @@ pub mod tests {
         th.rxq.dtable[3].check_data(&[0; 500]);
     }
 
+    #[test]
+    fn test_rx_multiple_frames() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let th = TestHelper::get_default(&mem);
+        rx_multiple_frames(th);
+    }
+
+    #[test]
+    fn test_rx_multiple_frames_mrg_buf() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let mut th = TestHelper::get_default(&mem);
+        // VIRTIO_NET_F_MRG_RXBUF is not enabled by default
+        th.net().acked_features = 1 << VIRTIO_NET_F_MRG_RXBUF;
+        rx_multiple_frames(th);
+    }
+
+    #[test]
+    fn test_rx_multiple_frames_mrg() {
+        let mem = single_region_mem(2 * MAX_BUFFER_SIZE);
+        let mut th = TestHelper::get_default(&mem);
+
+        // VIRTIO_NET_F_MRG_RXBUF is not enabled by default
+        th.net().acked_features = 1 << VIRTIO_NET_F_MRG_RXBUF;
+
+        th.activate_net();
+
+        // Create 2 valid avail descriptor chains. We will send
+        // one packet that shuld be split amound these 2 chains.
+        th.add_desc_chain(
+            NetQueue::Rx,
+            0,
+            &[(0, 100, VIRTQ_DESC_F_WRITE), (1, 100, VIRTQ_DESC_F_WRITE)],
+        );
+        th.add_desc_chain(
+            NetQueue::Rx,
+            1000,
+            &[(2, 100, VIRTQ_DESC_F_WRITE), (3, 100, VIRTQ_DESC_F_WRITE)],
+        );
+        // Inject frame into tap and run epoll.
+        let mut frame = inject_tap_tx_frame(&th.net(), 400);
+        mock_frame_set_num_buffers(&mut frame, 2);
+        check_metric_after_block!(
+            th.net().metrics.rx_packets_count,
+            1,
+            th.event_manager.run_with_timeout(100).unwrap()
+        );
+
+        // Check that the frame wasn't deferred.
+        assert!(!th.net().rx_deferred_frame);
+        // Check that the used queue has advanced.
+        assert_eq!(th.rxq.used.idx.get(), 2);
+        assert!(&th.net().irq_trigger.has_pending_irq(IrqType::Vring));
+        // Check that the frame was written successfully into both descriptor chains.
+        th.rxq.check_used_elem(0, 0, 200);
+        th.rxq.check_used_elem(1, 2, 200);
+        th.rxq.dtable[0].check_data(&frame[0..100]);
+        th.rxq.dtable[1].check_data(&frame[100..200]);
+        th.rxq.dtable[2].check_data(&frame[200..300]);
+        th.rxq.dtable[3].check_data(&frame[300..400]);
+    }
+
     #[test]
     fn test_tx_missing_queue_signal() {
         let mem = single_region_mem(2 * MAX_BUFFER_SIZE);