use vm_memory::{ByteValued, GuestAddress, Le16, Le32, Le64};
use virtio_bindings::bindings::virtio_ring::{
VRING_DESC_F_INDIRECT, VRING_DESC_F_NEXT, VRING_DESC_F_WRITE,
};
#[repr(C)]
#[derive(Default, Clone, Copy, Debug)]
pub struct Descriptor {
addr: Le64,
len: Le32,
flags: Le16,
next: Le16,
}
#[allow(clippy::len_without_is_empty)]
impl Descriptor {
pub fn addr(&self) -> GuestAddress {
GuestAddress(self.addr.into())
}
pub fn len(&self) -> u32 {
self.len.into()
}
pub fn flags(&self) -> u16 {
self.flags.into()
}
pub fn next(&self) -> u16 {
self.next.into()
}
pub fn refers_to_indirect_table(&self) -> bool {
self.flags() & VRING_DESC_F_INDIRECT as u16 != 0
}
pub fn has_next(&self) -> bool {
self.flags() & VRING_DESC_F_NEXT as u16 != 0
}
pub fn is_write_only(&self) -> bool {
self.flags() & VRING_DESC_F_WRITE as u16 != 0
}
}
#[cfg(any(test, feature = "test-utils"))]
impl Descriptor {
pub fn new(addr: u64, len: u32, flags: u16, next: u16) -> Self {
Descriptor {
addr: addr.into(),
len: len.into(),
flags: flags.into(),
next: next.into(),
}
}
pub fn set_addr(&mut self, addr: u64) {
self.addr = addr.into();
}
pub fn set_len(&mut self, len: u32) {
self.len = len.into();
}
pub fn set_flags(&mut self, flags: u16) {
self.flags = flags.into();
}
pub fn set_next(&mut self, next: u16) {
self.next = next.into();
}
}
unsafe impl ByteValued for Descriptor {}
#[repr(C)]
#[derive(Clone, Copy, Default, Debug)]
pub struct VirtqUsedElem {
id: Le32,
len: Le32,
}
impl VirtqUsedElem {
pub(crate) fn new(id: u32, len: u32) -> Self {
VirtqUsedElem {
id: id.into(),
len: len.into(),
}
}
}
#[cfg(any(test, feature = "test-utils"))]
#[allow(clippy::len_without_is_empty)]
impl VirtqUsedElem {
pub fn id(&self) -> u32 {
self.id.into()
}
pub fn len(&self) -> u32 {
self.len.into()
}
}
unsafe impl ByteValued for VirtqUsedElem {}
#[cfg(test)]
mod tests {
use super::*;
use memoffset::offset_of;
use std::mem::{align_of, size_of};
#[test]
fn test_descriptor_offset() {
assert_eq!(size_of::<Descriptor>(), 16);
assert_eq!(offset_of!(Descriptor, addr), 0);
assert_eq!(offset_of!(Descriptor, len), 8);
assert_eq!(offset_of!(Descriptor, flags), 12);
assert_eq!(offset_of!(Descriptor, next), 14);
assert!(align_of::<Descriptor>() <= 16);
}
#[test]
fn test_descriptor_getter_setter() {
let mut desc = Descriptor::new(0, 0, 0, 0);
desc.set_addr(0x1000);
assert_eq!(desc.addr(), GuestAddress(0x1000));
desc.set_len(0x2000);
assert_eq!(desc.len(), 0x2000);
desc.set_flags(VRING_DESC_F_NEXT as u16);
assert_eq!(desc.flags(), VRING_DESC_F_NEXT as u16);
assert!(desc.has_next());
assert!(!desc.is_write_only());
assert!(!desc.refers_to_indirect_table());
desc.set_flags(VRING_DESC_F_WRITE as u16);
assert_eq!(desc.flags(), VRING_DESC_F_WRITE as u16);
assert!(!desc.has_next());
assert!(desc.is_write_only());
assert!(!desc.refers_to_indirect_table());
desc.set_flags(VRING_DESC_F_INDIRECT as u16);
assert_eq!(desc.flags(), VRING_DESC_F_INDIRECT as u16);
assert!(!desc.has_next());
assert!(!desc.is_write_only());
assert!(desc.refers_to_indirect_table());
desc.set_next(3);
assert_eq!(desc.next(), 3);
}
#[test]
fn test_descriptor_copy() {
let e1 = Descriptor::new(1, 2, VRING_DESC_F_NEXT as u16, 3);
let mut e2 = Descriptor::default();
e2.as_mut_slice().copy_from_slice(e1.as_slice());
assert_eq!(e1.addr(), e2.addr());
assert_eq!(e1.len(), e2.len());
assert_eq!(e1.flags(), e2.flags());
assert_eq!(e1.next(), e2.next());
}
#[test]
fn test_used_elem_offset() {
assert_eq!(offset_of!(VirtqUsedElem, id), 0);
assert_eq!(offset_of!(VirtqUsedElem, len), 4);
assert_eq!(size_of::<VirtqUsedElem>(), 8);
}
#[test]
fn test_used_elem_copy() {
let e1 = VirtqUsedElem::new(3, 15);
let mut e2 = VirtqUsedElem::new(0, 0);
e2.as_mut_slice().copy_from_slice(e1.as_slice());
assert_eq!(e1.id, e2.id);
assert_eq!(e1.len, e2.len);
}
}