queue: Add support for big-endian arches

According to the virtio specification, on non-legacy devices the
values in the virtqueue are represented in little-endian, no matter
the host nor the guest actual endianess.

If needed, fix the endianess of values that have been read from memory
or will be written to it. The methods "from_le" and "to_le" are a
no-op on little-endian machines, so this shouldn't have a performance
impact on those.

Fixes #117

Signed-off-by: Sergio Lopez <slp@redhat.com>

Author: slp

crates/virtio-queue/src/descriptor.rs

@@ -10,7 +10,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
-use vm_memory::{ByteValued, GuestAddress};
+use vm_memory::{ByteValued, GuestAddress, Le16, Le32, Le64};
 
 use crate::defs::{VIRTQ_DESC_F_INDIRECT, VIRTQ_DESC_F_NEXT, VIRTQ_DESC_F_WRITE};
 
@@ -19,38 +19,38 @@ use crate::defs::{VIRTQ_DESC_F_INDIRECT, VIRTQ_DESC_F_NEXT, VIRTQ_DESC_F_WRITE};
 #[derive(Default, Clone, Copy, Debug)]
 pub struct Descriptor {
     /// Guest physical address of device specific data
-    addr: u64,
+    addr: Le64,
 
     /// Length of device specific data
-    len: u32,
+    len: Le32,
 
     /// Includes next, write, and indirect bits
-    flags: u16,
+    flags: Le16,
 
     /// Index into the descriptor table of the next descriptor if flags has the next bit set
-    next: u16,
+    next: Le16,
 }
 
 #[allow(clippy::len_without_is_empty)]
 impl Descriptor {
     /// Return the guest physical address of descriptor buffer.
     pub fn addr(&self) -> GuestAddress {
-        GuestAddress(self.addr)
+        GuestAddress(self.addr.into())
     }
 
     /// Return the length of descriptor buffer.
     pub fn len(&self) -> u32 {
-        self.len
+        self.len.into()
     }
 
     /// Return the flags for this descriptor, including next, write and indirect bits.
     pub fn flags(&self) -> u16 {
-        self.flags
+        self.flags.into()
     }
 
     /// Return the value stored in the `next` field of the descriptor.
     pub fn next(&self) -> u16 {
-        self.next
+        self.next.into()
     }
 
     /// Check whether this descriptor refers to a buffer containing an indirect descriptor table.
@@ -77,31 +77,31 @@ impl Descriptor {
     /// Creates a new descriptor
     pub fn new(addr: u64, len: u32, flags: u16, next: u16) -> Self {
         Descriptor {
-            addr: addr.to_le(),
-            len: len.to_le(),
-            flags: flags.to_le(),
-            next: next.to_le(),
+            addr: addr.into(),
+            len: len.into(),
+            flags: flags.into(),
+            next: next.into(),
         }
     }
 
     /// Set the guest physical address of descriptor buffer
     pub fn set_addr(&mut self, addr: u64) {
-        self.addr = addr.to_le();
+        self.addr = addr.into();
     }
 
     /// Set the length of descriptor buffer.
     pub fn set_len(&mut self, len: u32) {
-        self.len = len.to_le();
+        self.len = len.into();
     }
 
     /// Set the flags for this descriptor.
     pub fn set_flags(&mut self, flags: u16) {
-        self.flags = flags.to_le();
+        self.flags = flags.into();
     }
 
     /// Set the value stored in the `next` field of the descriptor.
     pub fn set_next(&mut self, next: u16) {
-        self.next = next.to_le();
+        self.next = next.into();
     }
 }
 
@@ -111,16 +111,16 @@ unsafe impl ByteValued for Descriptor {}
 #[repr(C)]
 #[derive(Clone, Copy, Default, Debug)]
 pub struct VirtqUsedElem {
-    id: u32,
-    len: u32,
+    id: Le32,
+    len: Le32,
 }
 
 impl VirtqUsedElem {
     /// Create a new `VirtqUsedElem` instance.
-    pub fn new(id: u16, len: u32) -> Self {
+    pub fn new(id: u32, len: u32) -> Self {
         VirtqUsedElem {
-            id: u32::from_le(id as u32),
-            len: len.to_le(),
+            id: id.into(),
+            len: len.into(),
         }
     }
 }
@@ -130,12 +130,12 @@ impl VirtqUsedElem {
 impl VirtqUsedElem {
     /// Get id field of the used descriptor.
     pub fn id(&self) -> u32 {
-        u32::from_le(self.id)
+        self.id.into()
     }
 
     /// Get length field of the used descriptor.
     pub fn len(&self) -> u32 {
-        u32::from_le(self.len)
+        self.len.into()
     }
 }
 

crates/virtio-queue/src/iterator.rs

@@ -86,6 +86,7 @@ where
         let head_index: u16 = self
             .mem
             .load(addr, Ordering::Acquire)
+            .map(u16::from_le)
             .map_err(|_| error!("Failed to read from memory {:x}", addr.raw_value()))
             .ok()?;
 

crates/virtio-queue/src/state.rs

@@ -78,7 +78,8 @@ impl QueueState {
         let offset = VIRTQ_USED_RING_HEADER_SIZE + elem_sz;
         let addr = self.used_ring.unchecked_add(offset);
 
-        mem.store(val, addr, order).map_err(Error::GuestMemory)
+        mem.store(u16::to_le(val), addr, order)
+            .map_err(Error::GuestMemory)
     }
 
     // Set the value of the `flags` field of the used ring, applying the specified ordering.
@@ -88,7 +89,7 @@ impl QueueState {
         val: u16,
         order: Ordering,
     ) -> Result<(), Error> {
-        mem.store(val, self.used_ring, order)
+        mem.store(u16::to_le(val), self.used_ring, order)
             .map_err(Error::GuestMemory)
     }
 
@@ -133,6 +134,7 @@ impl QueueState {
         let used_event_addr = self.avail_ring.unchecked_add(offset);
 
         mem.load(used_event_addr, order)
+            .map(u16::from_le)
             .map(Wrapping)
             .map_err(Error::GuestMemory)
     }
@@ -281,6 +283,7 @@ impl QueueStateT for QueueState {
         let addr = self.avail_ring.unchecked_add(2);
 
         mem.load(addr, order)
+            .map(u16::from_le)
             .map(Wrapping)
             .map_err(Error::GuestMemory)
     }
@@ -303,13 +306,13 @@ impl QueueStateT for QueueState {
         let elem_sz = next_used_index * VIRTQ_USED_ELEMENT_SIZE;
         let offset = VIRTQ_USED_RING_HEADER_SIZE + elem_sz;
         let addr = self.used_ring.unchecked_add(offset);
-        mem.write_obj(VirtqUsedElem::new(head_index, len), addr)
+        mem.write_obj(VirtqUsedElem::new(head_index.into(), len), addr)
             .map_err(Error::GuestMemory)?;
 
         self.next_used += Wrapping(1);
 
         mem.store(
-            self.next_used.0,
+            u16::to_le(self.next_used.0),
             self.used_ring.unchecked_add(2),
             Ordering::Release,
         )