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 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(())
     }