virtio-queue: Add helpers for accessing queue information

These helpers are meant to help crate's consumers getting and setting
information about the queue.

Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>

Author: Sebastien Boeuf

crates/virtio-queue/src/lib.rs

@@ -154,6 +154,9 @@ pub trait QueueStateT: for<'a> QueueStateGuard<'a> {
     /// Read the `idx` field from the available ring.
     fn avail_idx<M: GuestMemory>(&self, mem: &M, order: Ordering) -> Result<Wrapping<u16>, Error>;
 
+    /// Read the `idx` field from the used ring.
+    fn used_idx<M: GuestMemory>(&self, mem: &M, order: Ordering) -> Result<Wrapping<u16>, Error>;
+
     /// Put a used descriptor head into the used ring.
     fn add_used<M: GuestMemory>(&mut self, mem: &M, head_index: u16, len: u32)
         -> Result<(), Error>;
@@ -179,6 +182,12 @@ pub trait QueueStateT: for<'a> QueueStateGuard<'a> {
     /// Return the index of the next entry in the available ring.
     fn next_avail(&self) -> u16;
 
+    /// Return the index for the next descriptor in the used ring.
+    fn next_used(&self) -> u16;
+
     /// Set the index of the next entry in the available ring.
     fn set_next_avail(&mut self, next_avail: u16);
+
+    /// Set the index for the next descriptor in the used ring.
+    fn set_next_used(&mut self, next_used: u16);
 }

crates/virtio-queue/src/queue.rs

@@ -197,6 +197,14 @@ impl<M: GuestAddressSpace, S: QueueStateT> Queue<M, S> {
         self.state.avail_idx(self.mem.memory().deref(), order)
     }
 
+    /// Reads the `idx` field from the used ring.
+    ///
+    /// # Arguments
+    /// * `order` - the memory ordering used to access the `idx` field from memory.
+    pub fn used_idx(&self, order: Ordering) -> Result<Wrapping<u16>, Error> {
+        self.state.used_idx(self.mem.memory().deref(), order)
+    }
+
     /// Put a used descriptor head into the used ring.
     ///
     /// # Arguments
@@ -236,20 +244,39 @@ impl<M: GuestAddressSpace, S: QueueStateT> Queue<M, S> {
         self.state.next_avail()
     }
 
+    /// Returns the index for the next descriptor in the used ring.
+    pub fn next_used(&self) -> u16 {
+        self.state.next_used()
+    }
+
     /// Set the index of the next entry in the available ring.
     ///
     /// # Arguments
     /// * `next_avail` - the index of the next available ring entry.
     pub fn set_next_avail(&mut self, next_avail: u16) {
         self.state.set_next_avail(next_avail);
     }
+
+    /// Sets the index for the next descriptor in the used ring.
+    ///
+    /// # Arguments
+    /// * `next_used` - the index of the next used ring entry.
+    pub fn set_next_used(&mut self, next_used: u16) {
+        self.state.set_next_used(next_used);
+    }
 }
 
 impl<M: GuestAddressSpace> Queue<M, QueueState> {
     /// A consuming iterator over all available descriptor chain heads offered by the driver.
     pub fn iter(&mut self) -> Result<AvailIter<'_, M::T>, Error> {
         self.state.iter(self.mem.memory())
     }
+
+    /// Set the queue to "ready", and update desc_table, avail_ring and
+    /// used_ring addresses based on the AccessPlatform handler.
+    pub fn enable(&mut self, set: bool) {
+        self.state.enable(set)
+    }
 }
 
 #[cfg(test)]

crates/virtio-queue/src/state.rs

@@ -149,6 +149,28 @@ impl QueueState {
             .map(Wrapping)
             .map_err(Error::GuestMemory)
     }
+
+    /// Set the queue to "ready", and update desc_table, avail_ring and
+    /// used_ring addresses based on the AccessPlatform handler.
+    pub fn enable(&mut self, set: bool) {
+        self.ready = set;
+
+        if set {
+            // Translate address of descriptor table and vrings.
+            if let Some(access_platform) = &self.access_platform {
+                self.desc_table =
+                    GuestAddress(access_platform.translate(self.desc_table.0, 0).unwrap());
+                self.avail_ring =
+                    GuestAddress(access_platform.translate(self.avail_ring.0, 0).unwrap());
+                self.used_ring =
+                    GuestAddress(access_platform.translate(self.used_ring.0, 0).unwrap());
+            }
+        } else {
+            self.desc_table = GuestAddress(0);
+            self.avail_ring = GuestAddress(0);
+            self.used_ring = GuestAddress(0);
+        }
+    }
 }
 
 impl<'a> QueueStateGuard<'a> for QueueState {
@@ -311,6 +333,14 @@ impl QueueStateT for QueueState {
             .map_err(Error::GuestMemory)
     }
 
+    fn used_idx<M: GuestMemory>(&self, mem: &M, order: Ordering) -> Result<Wrapping<u16>, Error> {
+        let addr = self.used_ring.unchecked_add(2);
+
+        mem.load(addr, order)
+            .map(Wrapping)
+            .map_err(Error::GuestMemory)
+    }
+
     fn add_used<M: GuestMemory>(
         &mut self,
         mem: &M,
@@ -415,7 +445,15 @@ impl QueueStateT for QueueState {
         self.next_avail.0
     }
 
+    fn next_used(&self) -> u16 {
+        self.next_used.0
+    }
+
     fn set_next_avail(&mut self, next_avail: u16) {
         self.next_avail = Wrapping(next_avail);
     }
+
+    fn set_next_used(&mut self, next_used: u16) {
+        self.next_used = Wrapping(next_used);
+    }
 }

crates/virtio-queue/src/state_sync.rs

@@ -107,6 +107,10 @@ impl QueueStateT for QueueStateSync {
         self.lock_state().avail_idx(mem, order)
     }
 
+    fn used_idx<M: GuestMemory>(&self, mem: &M, order: Ordering) -> Result<Wrapping<u16>, Error> {
+        self.lock_state().used_idx(mem, order)
+    }
+
     fn add_used<M: GuestMemory>(
         &mut self,
         mem: &M,
@@ -132,9 +136,17 @@ impl QueueStateT for QueueStateSync {
         self.lock_state().next_avail()
     }
 
+    fn next_used(&self) -> u16 {
+        self.lock_state().next_used()
+    }
+
     fn set_next_avail(&mut self, next_avail: u16) {
         self.lock_state().set_next_avail(next_avail);
     }
+
+    fn set_next_used(&mut self, next_used: u16) {
+        self.lock_state().set_next_used(next_used);
+    }
 }
 
 #[cfg(test)]