feat(queue): split internals of add_used into 2 separate methods

Split `add_used` internals into 2 new functions: `write_used_element`
and `advance_used_ring`. This will be used in next commits to optimize
RX path of net device.

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

Author: ShadowCurse

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

@@ -574,8 +574,13 @@ 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.
+    pub fn write_used_element(
+        &mut self,
+        ring_index: 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 +589,7 @@ impl Queue {
             return Err(QueueError::DescIndexOutOfBounds(desc_index));
         }
 
-        let next_used = self.next_used.0 % self.actual_size();
+        let next_used = ring_index % self.actual_size();
         let used_element = UsedElement {
             id: u32::from(desc_index),
             len,
@@ -594,14 +599,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(self.next_used.0, desc_index, len)?;
+        self.advance_used_ring(1);
         Ok(())
     }