transport: enable virtiofs and vhost-user-fs

Bring back virtiofs and vhost-user-fs support so that consumers can use
the latest code to run virtiofs and vhost-user-fs.

Signed-off-by: Peng Tao <[email protected]>

Author: bergwolf

Cargo.toml

@@ -26,23 +26,23 @@ libc = ">=0.2.68"
 log = ">=0.4.6"
 nix = "0.22"
 #ringbahn = { version = "0.0.0-experimental.3", optional = true }
-vmm-sys-util = { version = "0.8", optional = true }
-vm-memory = "0.6"
-#vm-virtio = { git = "https://github.com/cloud-hypervisor/vm-virtio.git", branch = "dragonball", optional = true }
-#vhost = { version = "0.1", optional = true }
+vmm-sys-util = { version = ">=0.8", optional = true }
+vm-memory = { version = "0.6", features = ["backend-atomic"] }
+virtio-queue = { git = "https://github.com/rust-vmm/vm-virtio", rev = "6013dd9", optional = true }
+vhost = { version = "0.2", features = ["vhost-user-slave"], optional = true }
 
 [dev-dependencies]
 futures = { version = "0.3.0", features = ["thread-pool"]}
 stderrlog = "0.4"
-vmm-sys-util = "0.8"
-vm-memory = { version = "0.6", features = ["backend-mmap"] }
+vmm-sys-util = ">=0.8"
+vm-memory = { version = "0.6", features = ["backend-mmap", "backend-atomic"] }
 
 [features]
 default = ["fusedev"]
 #async-io = ["async-trait", "futures", "iou", "ringbahn"]
 fusedev = ["vmm-sys-util"]
-#virtiofs = ["vm-virtio"]
-#vhost-user-fs = ["virtiofs", "vhost-rs/vhost-user-slave"]
+virtiofs = ["virtio-queue"]
+vhost-user-fs = ["virtiofs", "vhost"]
 
 [patch."registry+https://github.com/rust-lang/crates.io-index"]
 #ringbahn = { git = "https://github.com/jiangliu/ringbahn.git", branch = "enhance", optional = true }

Makefile

@@ -2,14 +2,20 @@ current_dir := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
 
 build:
 	cargo build --features="fusedev"
+	cargo build --features="virtiofs"
+	cargo build --features="vhost-user-fs"
 
 check: build
 	cargo fmt -- --check
 	cargo clippy --features="fusedev" -- -Dclippy::all
+	cargo clippy --features="virtiofs" -- -Dclippy::all
+	cargo clippy --features="vhost-user-fs" -- -Dclippy::all
+	cargo test --features="virtiofs" -- --nocapture --skip integration
 	cargo test --features="fusedev" -- --nocapture --skip integration
+	cargo test --features="vhost-user-fs" -- --nocapture --skip integration
 
 smoke: check
 	cargo test --features="fusedev" -- --nocapture
 
 docker-smoke:
-	docker run --rm --privileged -v ${current_dir}:/fuse-rs rust:slim sh -c "apt update;apt install -y make; rustup component add clippy rustfmt; cd /fuse-rs; make smoke"
+	docker run --rm --privileged -v ${current_dir}:/fuse-rs rust:1.52.1 sh -c "rustup component add clippy rustfmt; cd /fuse-rs; make smoke"

src/api/server/mod.rs

@@ -162,6 +162,7 @@ pub trait MetricsHook {
 }
 
 struct SrvContext<'a, F, D: AsyncDrive = AsyncDriver, S: BitmapSlice = ()> {
+    #[allow(dead_code)]
     drive: Option<D>,
     in_header: InHeader,
     context: Context,

src/lib.rs

@@ -50,11 +50,7 @@ extern crate bitflags;
 extern crate libc;
 #[macro_use]
 extern crate log;
-#[cfg(feature = "vhost-user-fs")]
-extern crate vhost;
 extern crate vm_memory;
-#[cfg(feature = "virtiofs")]
-extern crate vm_virtio;
 
 use std::ffi::{CStr, FromBytesWithNulError};
 use std::io::ErrorKind;

src/transport/virtiofs/mod.rs

@@ -42,11 +42,15 @@ use std::cmp;
 use std::collections::VecDeque;
 use std::fmt;
 use std::io::{self, IoSlice, Write};
+use std::ops::Deref;
 use std::ptr::copy_nonoverlapping;
 
-use vm_memory::bitmap::{BitmapSlice, MS};
-use vm_memory::{ByteValued, GuestMemory, GuestMemoryError, VolatileMemoryError, VolatileSlice};
-use vm_virtio::{DescriptorChain, Error as QueueError};
+use virtio_queue::{DescriptorChain, Error as QueueError};
+use vm_memory::bitmap::BitmapSlice;
+use vm_memory::{
+    Address, ByteValued, GuestMemory, GuestMemoryAtomic, GuestMemoryError, GuestMemoryMmap,
+    GuestMemoryRegion, VolatileMemory, VolatileMemoryError, VolatileSlice,
+};
 
 use super::{FileReadWriteVolatile, IoBuffers, Reader};
 
@@ -99,19 +103,14 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 impl std::error::Error for Error {}
 
-impl<'a, M: GuestMemory> Reader<'a, M> {
+impl<'a> Reader<'a> {
     /// Construct a new Reader wrapper over `desc_chain`.
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new(mem: &'a M, desc_chain: DescriptorChain<'a, M>) -> Result<Reader<'a, MS<'a, M>>> {
+    pub fn new(
+        mem: &'a GuestMemoryMmap,
+        desc_chain: DescriptorChain<GuestMemoryAtomic<GuestMemoryMmap>>,
+    ) -> Result<Reader<'a>> {
         let mut total_len: usize = 0;
-        let chain = if desc_chain.is_indirect() {
-            desc_chain
-                .new_from_indirect()
-                .map_err(Error::ConvertIndirectDescriptor)?
-        } else {
-            desc_chain
-        };
-        let buffers = chain
+        let buffers = desc_chain
             .readable()
             .map(|desc| {
                 // Verify that summing the descriptor sizes does not overflow.
@@ -121,10 +120,19 @@ impl<'a, M: GuestMemory> Reader<'a, M> {
                     .checked_add(desc.len() as usize)
                     .ok_or(Error::DescriptorChainOverflow)?;
 
-                mem.get_slice(desc.addr(), desc.len() as usize)
-                    .map_err(Error::GuestMemoryError)
+                let region = mem
+                    .find_region(desc.addr())
+                    .ok_or(Error::FindMemoryRegion)?;
+                let offset = desc
+                    .addr()
+                    .checked_sub(region.start_addr().raw_value())
+                    .unwrap();
+                region
+                    .deref()
+                    .get_slice(offset.raw_value() as usize, desc.len() as usize)
+                    .map_err(Error::VolatileMemoryError)
             })
-            .collect::<Result<VecDeque<VolatileSlice<'a, MS<M>>>>>()?;
+            .collect::<Result<VecDeque<VolatileSlice<'a>>>>()?;
 
         Ok(Reader {
             buffers: IoBuffers {
@@ -147,19 +155,14 @@ pub struct Writer<'a, S = ()> {
     buffers: IoBuffers<'a, S>,
 }
 
-impl<'a, M: GuestMemory> Writer<'a, M> {
+impl<'a> Writer<'a> {
     /// Construct a new Writer wrapper over `desc_chain`.
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new(mem: &'a M, desc_chain: DescriptorChain<'a, M>) -> Result<Writer<'a, MS<'a, M>>> {
+    pub fn new(
+        mem: &'a GuestMemoryMmap,
+        desc_chain: DescriptorChain<GuestMemoryAtomic<GuestMemoryMmap>>,
+    ) -> Result<Writer<'a>> {
         let mut total_len: usize = 0;
-        let chain = if desc_chain.is_indirect() {
-            desc_chain
-                .new_from_indirect()
-                .map_err(Error::ConvertIndirectDescriptor)?
-        } else {
-            desc_chain
-        };
-        let buffers = chain
+        let buffers = desc_chain
             .writable()
             .map(|desc| {
                 // Verify that summing the descriptor sizes does not overflow.
@@ -169,10 +172,19 @@ impl<'a, M: GuestMemory> Writer<'a, M> {
                     .checked_add(desc.len() as usize)
                     .ok_or(Error::DescriptorChainOverflow)?;
 
-                mem.get_slice(desc.addr(), desc.len() as usize)
-                    .map_err(Error::GuestMemoryError)
+                let region = mem
+                    .find_region(desc.addr())
+                    .ok_or(Error::FindMemoryRegion)?;
+                let offset = desc
+                    .addr()
+                    .checked_sub(region.start_addr().raw_value())
+                    .unwrap();
+                region
+                    .deref()
+                    .get_slice(offset.raw_value() as usize, desc.len() as usize)
+                    .map_err(Error::VolatileMemoryError)
             })
-            .collect::<Result<VecDeque<VolatileSlice<'a, MS<M>>>>>()?;
+            .collect::<Result<VecDeque<VolatileSlice<'a>>>>()?;
 
         Ok(Writer {
             buffers: IoBuffers {
@@ -437,7 +449,9 @@ mod async_io {
     }
 }
 
-#[cfg(test)]
+/// Disabled since vm-virtio doesn't export any DescriptorChain constructors.
+/// Should re-enable once it does.
+#[cfg(testff)]
 mod tests {
     use super::*;
     use std::io::{Read, Seek, SeekFrom, Write};
@@ -472,7 +486,7 @@ mod tests {
         mut buffers_start_addr: GuestAddress,
         descriptors: Vec<(DescriptorType, u32)>,
         spaces_between_regions: u32,
-    ) -> Result<DescriptorChain<GuestMemoryMmap>> {
+    ) -> Result<DescriptorChain<GuestMemoryAtomic<GuestMemoryMmap>>> {
         let descriptors_len = descriptors.len();
         for (index, (type_, size)) in descriptors.into_iter().enumerate() {
             let mut flags = 0;
@@ -504,7 +518,7 @@ mod tests {
             );
         }
 
-        DescriptorChain::checked_new(memory, descriptor_array_addr, 0x100, 0)
+        DescriptorChain::<&GuestMemoryMmap>::new(memory, descriptor_array_addr, 0x100, 0)
             .ok_or(Error::InvalidChain)
     }
 

tests/example/mod.rs

@@ -2,5 +2,5 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(feature = "fusedev")]
+#[cfg(all(feature = "fusedev", not(feature = "virtiofs")))]
 pub(crate) mod passthroughfs;

tests/smoke.rs

@@ -3,13 +3,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#[cfg(feature = "fusedev")]
+#[cfg(all(feature = "fusedev", not(feature = "virtiofs")))]
 #[macro_use]
 extern crate log;
 
 mod example;
 
-#[cfg(feature = "fusedev")]
+#[cfg(all(feature = "fusedev", not(feature = "virtiofs")))]
 mod fusedev_tests {
     extern crate stderrlog;