Inflight I/O: Implement missing traits

This commit implements the get and set inflight fd members of the
VhostUserSlaveReqHandlerMut trait, which is used to pass inflight
I/O queue tracking regions as memfds.

Fixes #14.

Signed-off-by: Harshavardhan Unnibhavi <[email protected]>

Author: harshanavkis

src/lib.rs

@@ -7,30 +7,33 @@
 #[macro_use]
 extern crate log;
 
-use std::error;
+use libc::c_void;
 use std::fs::File;
-use std::io;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 use std::os::unix::prelude::IntoRawFd;
-use std::result;
 use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
+use std::{error, mem};
+use std::{io, usize};
+use std::{result, u64};
 use vhost::vhost_user::message::{
-    VhostUserConfigFlags, VhostUserMemoryRegion, VhostUserProtocolFeatures,
+    DescStatePacked, DescStateSplit, QueueRegionPacked, QueueRegionSplit, VhostUserConfigFlags,
+    VhostUserInflight, VhostUserMemoryRegion, VhostUserProtocolFeatures,
     VhostUserSingleMemoryRegion, VhostUserVirtioFeatures, VhostUserVringAddrFlags,
     VhostUserVringState,
 };
 use vhost::vhost_user::{
     Error as VhostUserError, Listener, Result as VhostUserResult, SlaveFsCacheReq, SlaveListener,
     VhostUserSlaveReqHandlerMut,
 };
+use virtio_bindings::bindings::virtio_net::VIRTIO_F_RING_PACKED;
 use virtio_bindings::bindings::virtio_ring::VIRTIO_RING_F_EVENT_IDX;
+use virtio_queue::Queue;
 use vm_memory::guest_memory::FileOffset;
 use vm_memory::{
-    GuestAddress, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap, GuestRegionMmap,
+    Address, GuestAddress, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap, GuestRegionMmap,
     MmapRegion,
 };
-use virtio_queue::Queue;
 use vmm_sys_util::eventfd::EventFd;
 
 const MAX_MEM_SLOTS: u64 = 32;
@@ -453,6 +456,9 @@ struct VhostUserHandler<S: VhostUserBackend> {
     atomic_mem: GuestMemoryAtomic<GuestMemoryMmap>,
     vrings: Vec<Arc<RwLock<Vring>>>,
     worker_threads: Vec<thread::JoinHandle<VringWorkerResult<()>>>,
+    inflight_file: Option<File>,
+    inflight_mapping_addr: Option<GuestAddress>,
+    inflight_mmap_size: usize,
 }
 
 impl<S: VhostUserBackend> VhostUserHandler<S> {
@@ -536,6 +542,9 @@ impl<S: VhostUserBackend> VhostUserHandler<S> {
             atomic_mem,
             vrings,
             worker_threads,
+            inflight_file: None,
+            inflight_mapping_addr: None,
+            inflight_mmap_size: 0,
         })
     }
 
@@ -552,6 +561,104 @@ impl<S: VhostUserBackend> VhostUserHandler<S> {
 
         Err(VhostUserHandlerError::MissingMemoryMapping)
     }
+
+    fn get_inflight_queue_size(&mut self, queue_size: u16) -> usize {
+        let queue_region_size;
+        let descr_state_size;
+        let virtio_features = self.get_features().unwrap();
+
+        if virtio_features & (1 << VIRTIO_F_RING_PACKED) == 0 {
+            // Use descriptor and queue states for split virtqueues
+            queue_region_size = mem::size_of::<QueueRegionSplit>();
+            descr_state_size = mem::size_of::<DescStateSplit>();
+        } else {
+            // Use descriptor and queue states for packed virtqueues
+            queue_region_size = mem::size_of::<QueueRegionPacked>();
+            descr_state_size = mem::size_of::<DescStatePacked>();
+        }
+        queue_region_size + descr_state_size * queue_size as usize
+    }
+
+    fn memfd_alloc(&self, mmap_size: usize, inflight_queue_region: &mut i64) -> *mut c_void {
+        let mut ret_val;
+
+        ret_val = unsafe {
+            libc::syscall(
+                libc::SYS_memfd_create,
+                &std::ffi::CString::new("inflight-region").unwrap(),
+                libc::MFD_ALLOW_SEALING,
+            )
+        };
+
+        if ret_val == -1 {
+            return ret_val as *mut c_void;
+        }
+
+        *inflight_queue_region = ret_val;
+
+        ret_val =
+            unsafe { libc::ftruncate(*inflight_queue_region as RawFd, mmap_size as i64) } as i64;
+
+        if ret_val == -1 {
+            return ret_val as *mut c_void;
+        }
+
+        ret_val = unsafe {
+            libc::fcntl(
+                *inflight_queue_region as i32,
+                libc::F_ADD_SEALS,
+                libc::F_SEAL_GROW | libc::F_SEAL_SHRINK | libc::F_SEAL_SEAL,
+            )
+        } as i64;
+
+        if ret_val == -1 {
+            return ret_val as *mut c_void;
+        }
+
+        unsafe {
+            libc::mmap(
+                std::ptr::null_mut(),
+                mmap_size,
+                libc::PROT_READ | libc::PROT_WRITE,
+                libc::MAP_SHARED,
+                *inflight_queue_region as i32,
+                0,
+            )
+        }
+    }
+
+    fn set_desc_num_packed(&mut self, inflight_region: u64, num_queues: u16, queue_size: u16) {
+        let raw_ptr = inflight_region as *mut QueueRegionPacked;
+
+        for i in 0..num_queues {
+            unsafe {
+                let queue_region = raw_ptr.offset(i as isize).as_mut().unwrap();
+                queue_region.desc_num = queue_size;
+            }
+        }
+    }
+
+    fn set_desc_num_split(&mut self, inflight_region: u64, num_queues: u16, queue_size: u16) {
+        let raw_ptr = inflight_region as *mut QueueRegionSplit;
+
+        for i in 0..num_queues {
+            unsafe {
+                let queue_region = raw_ptr.offset(i as isize).as_mut().unwrap();
+                queue_region.desc_num = queue_size;
+            }
+        }
+    }
+
+    fn set_inflight_region_desc_num(&mut self, num_queues: u16, queue_size: u16) {
+        let inflight_region = self.inflight_mapping_addr.unwrap().raw_value();
+
+        let virtio_features = self.get_features().unwrap();
+
+        match virtio_features & (1 << VIRTIO_F_RING_PACKED) {
+            0 => self.set_desc_num_split(inflight_region, num_queues, queue_size),
+            _ => self.set_desc_num_packed(inflight_region, num_queues, queue_size),
+        };
+    }
 }
 
 impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
@@ -948,16 +1055,73 @@ impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
 
     fn get_inflight_fd(
         &mut self,
-        _inflight: &vhost::vhost_user::message::VhostUserInflight,
-    ) -> VhostUserResult<(vhost::vhost_user::message::VhostUserInflight, File)> {
-        // Assume the backend hasn't negotiated the inflight feature; it
-        // wouldn't be correct for the backend to do so, as we don't (yet)
-        // provide a way for it to handle such requests.
-        Err(VhostUserError::InvalidOperation)
+        inflight: &VhostUserInflight,
+    ) -> VhostUserResult<(VhostUserInflight, File)> {
+        let ret_val = -1;
+        // Total size of the inflight queue region
+        let mut total_mmap_size =
+            self.get_inflight_queue_size(inflight.queue_size) * inflight.num_queues as usize;
+
+        // Create a memfd region to hold the queues for inflight I/O tracking
+        let mut inflight_fd = -1;
+        let mmap_ptr = self.memfd_alloc(total_mmap_size, &mut inflight_fd);
+
+        self.inflight_file = Some(unsafe { File::from_raw_fd(inflight_fd as i32) });
+
+        if mmap_ptr == ret_val as *mut c_void {
+            self.inflight_mapping_addr = None;
+            total_mmap_size = 0;
+        } else {
+            unsafe { libc::memset(mmap_ptr, 0, total_mmap_size) };
+            self.inflight_mapping_addr = Some(GuestAddress::new(mmap_ptr as u64));
+        }
+        self.inflight_mmap_size = total_mmap_size;
+
+        Ok((
+            VhostUserInflight {
+                mmap_size: total_mmap_size as u64,
+                mmap_offset: 0,
+                num_queues: inflight.num_queues,
+                queue_size: inflight.queue_size,
+            },
+            unsafe { File::from_raw_fd(inflight_fd as RawFd) },
+        ))
     }
 
-    fn set_inflight_fd(&mut self, _inflight: &vhost::vhost_user::message::VhostUserInflight, _file: File) -> VhostUserResult<()> {
-        Err(VhostUserError::InvalidOperation)
+    fn set_inflight_fd(&mut self, inflight: &VhostUserInflight, file: File) -> VhostUserResult<()> {
+        // Need to unmap any previously mmaped regions as closing the
+        // associated file doesn't unmap it automatically
+        // TODO: Handle error
+        unsafe {
+            libc::munmap(
+                self.inflight_mapping_addr.unwrap().raw_value() as *mut c_void,
+                self.inflight_mmap_size,
+            )
+        };
+
+        let inflight_fd = file.as_raw_fd();
+
+        self.inflight_file = Some(file);
+        let mmap_size = inflight.mmap_size;
+        let mmap_offset = inflight.mmap_offset;
+
+        let mmap_ptr = unsafe {
+            libc::mmap(
+                std::ptr::null_mut::<c_void>(),
+                mmap_size as usize,
+                libc::PROT_READ | libc::PROT_WRITE,
+                libc::MAP_SHARED,
+                inflight_fd,
+                mmap_offset as i64,
+            )
+        };
+
+        self.inflight_mapping_addr = Some(GuestAddress::new(mmap_ptr as u64));
+        self.inflight_mmap_size = mmap_size as usize;
+
+        self.set_inflight_region_desc_num(inflight.num_queues, inflight.queue_size);
+
+        Ok(())
     }
 }