feat(virtio): split add_used() into 2 separate methods

`Queue::add_used()` method first writes a Descriptor head in the used
descriptor ring buffer and then advances the index of this buffer to
let the guest know we used one or more Descriptors.

Carve out each one of these steps in their own function so that we can
add multiple descriptors in the used ring and advance the index only
once we finish handling descriptors in one step.

This will be useful when, in later commits, we will implement
VIRTIO_NET_F_RX_MRGBUF for the RX queue of the network device.

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

Author: ShadowCurse

src/vmm/src/devices/virtio/queue.rs

@@ -574,8 +574,16 @@ impl Queue {
         self.next_avail -= Wrapping(1);
     }
 
-    /// Puts an available descriptor head into the used ring for use by the guest.
-    pub fn add_used(&mut self, desc_index: u16, len: u32) -> Result<(), QueueError> {
+    /// Write used element into used_ring ring.
+    /// - [`ring_index_offset`] is an offset added to
+    /// the current [`self.next_used`] to obtain actual index
+    /// into used_ring.
+    pub fn write_used_element(
+        &mut self,
+        ring_index_offset: u16,
+        desc_index: u16,
+        len: u32,
+    ) -> Result<(), QueueError> {
         if self.actual_size() <= desc_index {
             error!(
                 "attempted to add out of bounds descriptor to used ring: {}",
@@ -584,7 +592,7 @@ impl Queue {
             return Err(QueueError::DescIndexOutOfBounds(desc_index));
         }
 
-        let next_used = self.next_used.0 % self.actual_size();
+        let next_used = (self.next_used + Wrapping(ring_index_offset)).0 % self.actual_size();
         let used_element = UsedElement {
             id: u32::from(desc_index),
             len,
@@ -594,14 +602,24 @@ impl Queue {
         unsafe {
             self.used_ring_ring_set(usize::from(next_used), used_element);
         }
+        Ok(())
+    }
 
-        self.num_added += Wrapping(1);
-        self.next_used += Wrapping(1);
+    /// Advance queue and used ring by `n` elements.
+    pub fn advance_used_ring(&mut self, n: u16) {
+        self.num_added += Wrapping(n);
+        self.next_used += Wrapping(n);
 
         // This fence ensures all descriptor writes are visible before the index update is.
         fence(Ordering::Release);
 
         self.used_ring_idx_set(self.next_used.0);
+    }
+
+    /// Puts an available descriptor head into the used ring for use by the guest.
+    pub fn add_used(&mut self, desc_index: u16, len: u32) -> Result<(), QueueError> {
+        self.write_used_element(0, desc_index, len)?;
+        self.advance_used_ring(1);
         Ok(())
     }