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/lib.rs

@@ -30,6 +30,7 @@ use std::sync::{Arc, Mutex, MutexGuard};
 use log::error;
 use vm_memory::{
     Address, ByteValued, Bytes, GuestAddress, GuestAddressSpace, GuestMemory, GuestMemoryError,
+    Le16, Le32, Le64,
 };
 
 use self::defs::{
@@ -71,21 +72,23 @@ impl Display for Error {
 impl std::error::Error for Error {}
 
 /// A virtio descriptor constraints with C representation.
+///
+/// All its fields are represented with little-endian ordering.
 #[repr(C)]
 #[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)]
@@ -94,32 +97,32 @@ impl Descriptor {
     #[cfg(any(test, feature = "test-utils"))]
     pub fn new(addr: u64, len: u32, flags: u16, next: u16) -> Self {
         Descriptor {
-            addr,
-            len,
-            flags,
-            next,
+            addr: addr.into(),
+            len: len.into(),
+            flags: flags.into(),
+            next: next.into(),
         }
     }
 
     /// 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.
@@ -385,6 +388,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()?;
 
@@ -400,19 +404,21 @@ where
 }
 
 /// Represents the contents of an element from the used virtqueue ring.
+///
+/// All its fields are represented with little-endian ordering.
 #[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(id),
-            len,
+            id: id.into(),
+            len: len.into(),
         }
     }
 }
@@ -603,7 +609,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.
@@ -613,7 +620,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)
     }
 
@@ -658,6 +665,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)
     }
@@ -806,6 +814,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)
     }
@@ -828,13 +837,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,
         )

crates/virtio-queue/src/mock.rs

@@ -182,17 +182,17 @@ impl<'a, M: GuestMemory> DescriptorTable<'a, M> {
         for (pos, index_value) in indices.iter().copied().enumerate() {
             // Addresses and lens constant for now.
             let mut desc = Descriptor {
-                addr: 0x1000,
-                len: 0x1000,
+                addr: 0x1000.into(),
+                len: 0x1000.into(),
                 ..Descriptor::default()
             };
 
             // It's not the last descriptor in the chain.
             if pos < indices.len() - 1 {
-                desc.flags = VIRTQ_DESC_F_NEXT;
-                desc.next = indices[pos + 1];
+                desc.flags = VIRTQ_DESC_F_NEXT.into();
+                desc.next = indices[pos + 1].into();
             } else {
-                desc.flags = 0;
+                desc.flags = 0.into();
             }
             self.store(index_value, desc);
         }
@@ -344,9 +344,9 @@ impl<'a, M: GuestMemory> MockSplitQueue<'a, M> {
         let indirect_addr = self.alloc_indirect_chain(len);
 
         let mut desc = self.desc_table.load(head_idx);
-        desc.flags = VIRTQ_DESC_F_INDIRECT;
-        desc.addr = indirect_addr.raw_value();
-        desc.len = u32::from(len) * size_of::<Descriptor>() as u32;
+        desc.flags = VIRTQ_DESC_F_INDIRECT.into();
+        desc.addr = indirect_addr.raw_value().into();
+        desc.len = (u32::from(len) * size_of::<Descriptor>() as u32).into();
 
         self.desc_table.store(head_idx, desc);
         self.update_avail_idx(head_idx);