Merge pull request #16 from Gaelan/unbreak

Minimally fix breakage from upstream changes.

Author: slp

Cargo.toml

@@ -12,5 +12,5 @@ log = ">=0.4.6"
 vhost = { git = "https://github.com/rust-vmm/vhost", features = ["vhost-user-slave"] }
 virtio-bindings = "0.1.0"
 vm-memory = {version = ">=0.2.0", features = ["backend-mmap", "backend-atomic"]}
-vm-virtio = { git = "https://github.com/rust-vmm/vm-virtio" }
+virtio-queue = { git = "https://github.com/rust-vmm/vm-virtio" }
 vmm-sys-util = ">=0.3.1"

src/lib.rs

@@ -11,6 +11,7 @@ use std::error;
 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;
@@ -29,7 +30,7 @@ use vm_memory::{
     GuestAddress, GuestAddressSpace, GuestMemoryAtomic, GuestMemoryMmap, GuestRegionMmap,
     MmapRegion,
 };
-use vm_virtio::Queue;
+use virtio_queue::Queue;
 use vmm_sys_util::eventfd::EventFd;
 
 const MAX_MEM_SLOTS: u64 = 32;
@@ -618,17 +619,16 @@ impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
     fn set_mem_table(
         &mut self,
         ctx: &[VhostUserMemoryRegion],
-        fds: &[RawFd],
+        files: Vec<File>,
     ) -> VhostUserResult<()> {
         // We need to create tuple of ranges from the list of VhostUserMemoryRegion
         // that we get from the caller.
         let mut regions: Vec<(GuestAddress, usize, Option<FileOffset>)> = Vec::new();
         let mut mappings: Vec<AddrMapping> = Vec::new();
 
-        for (idx, region) in ctx.iter().enumerate() {
+        for (region, file) in ctx.iter().zip(files) {
             let g_addr = GuestAddress(region.guest_phys_addr);
             let len = region.memory_size as usize;
-            let file = unsafe { File::from_raw_fd(fds[idx]) };
             let f_off = FileOffset::new(file, region.mmap_offset);
 
             regions.push((g_addr, len, Some(f_off)));
@@ -764,17 +764,17 @@ impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
         Ok(VhostUserVringState::new(index, u32::from(next_avail)))
     }
 
-    fn set_vring_kick(&mut self, index: u8, fd: Option<RawFd>) -> VhostUserResult<()> {
+    fn set_vring_kick(&mut self, index: u8, file: Option<File>) -> VhostUserResult<()> {
         if index as usize >= self.num_queues {
             return Err(VhostUserError::InvalidParam);
         }
 
-        if let Some(kick) = self.vrings[index as usize].write().unwrap().kick.take() {
-            // Close file descriptor set by previous operations.
-            let _ = unsafe { libc::close(kick.as_raw_fd()) };
-        }
+        // SAFETY: EventFd requires that it has sole ownership of its fd. So
+        // does File, so this is safe.
+        // Ideally, we'd have a generic way to refer to a uniquely-owned fd,
+        // such as that proposed by Rust RFC #3128.
         self.vrings[index as usize].write().unwrap().kick =
-            fd.map(|x| unsafe { EventFd::from_raw_fd(x) });
+            file.map(|f| unsafe { EventFd::from_raw_fd(f.into_raw_fd()) });
 
         // Quote from vhost-user specification:
         // Client must start ring upon receiving a kick (that is, detecting
@@ -802,32 +802,26 @@ impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
         Ok(())
     }
 
-    fn set_vring_call(&mut self, index: u8, fd: Option<RawFd>) -> VhostUserResult<()> {
+    fn set_vring_call(&mut self, index: u8, file: Option<File>) -> VhostUserResult<()> {
         if index as usize >= self.num_queues {
             return Err(VhostUserError::InvalidParam);
         }
 
-        if let Some(call) = self.vrings[index as usize].write().unwrap().call.take() {
-            // Close file descriptor set by previous operations.
-            let _ = unsafe { libc::close(call.as_raw_fd()) };
-        }
+        // SAFETY: see comment in set_vring_kick()
         self.vrings[index as usize].write().unwrap().call =
-            fd.map(|x| unsafe { EventFd::from_raw_fd(x) });
+            file.map(|f| unsafe { EventFd::from_raw_fd(f.into_raw_fd()) });
 
         Ok(())
     }
 
-    fn set_vring_err(&mut self, index: u8, fd: Option<RawFd>) -> VhostUserResult<()> {
+    fn set_vring_err(&mut self, index: u8, file: Option<File>) -> VhostUserResult<()> {
         if index as usize >= self.num_queues {
             return Err(VhostUserError::InvalidParam);
         }
 
-        if let Some(err) = self.vrings[index as usize].write().unwrap().err.take() {
-            // Close file descriptor set by previous operations.
-            let _ = unsafe { libc::close(err.as_raw_fd()) };
-        }
+        // SAFETY: see comment in set_vring_kick()
         self.vrings[index as usize].write().unwrap().err =
-            fd.map(|x| unsafe { EventFd::from_raw_fd(x) });
+            file.map(|f| unsafe { EventFd::from_raw_fd(f.into_raw_fd()) });
 
         Ok(())
     }
@@ -887,9 +881,8 @@ impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
     fn add_mem_region(
         &mut self,
         region: &VhostUserSingleMemoryRegion,
-        fd: RawFd,
+        file: File,
     ) -> VhostUserResult<()> {
-        let file = unsafe { File::from_raw_fd(fd) };
         let mmap_region = MmapRegion::from_file(
             FileOffset::new(file, region.mmap_offset),
             region.memory_size as usize,
@@ -952,6 +945,20 @@ impl<S: VhostUserBackend> VhostUserSlaveReqHandlerMut for VhostUserHandler<S> {
 
         Ok(())
     }
+
+    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)
+    }
+
+    fn set_inflight_fd(&mut self, _inflight: &vhost::vhost_user::message::VhostUserInflight, _file: File) -> VhostUserResult<()> {
+        Err(VhostUserError::InvalidOperation)
+    }
 }
 
 impl<S: VhostUserBackend> Drop for VhostUserHandler<S> {