storage: remove unnecessary vmm related crates

rafs/src/fs.rs

@@ -17,7 +17,7 @@
 use std::any::Any;
 use std::cmp;
 use std::ffi::{CStr, OsStr, OsString};
-use std::io::Result;
+use std::io::{self, Result};
 use std::ops::Deref;
 use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
@@ -28,10 +28,13 @@ use fuse_backend_rs::abi::fuse_abi::Attr;
 use fuse_backend_rs::abi::fuse_abi::{stat64, statvfs64};
 use fuse_backend_rs::api::filesystem::*;
 use fuse_backend_rs::api::BackendFileSystem;
+use fuse_backend_rs::file_buf::FileVolatileSlice;
+use fuse_backend_rs::file_traits::FileReadWriteVolatile;
 use nix::unistd::{getegid, geteuid};
 
 use nydus_api::ConfigV2;
 use nydus_storage::device::{BlobDevice, BlobIoVec, BlobPrefetchRequest};
+use nydus_storage::volatile::{BlobIoRead, BlobIoWrite, VolatileSlice};
 use nydus_storage::{RAFS_DEFAULT_CHUNK_SIZE, RAFS_MAX_CHUNK_SIZE};
 use nydus_utils::{
     div_round_up,
@@ -44,6 +47,71 @@ use crate::metadata::{
 use crate::prefetch::BlobPrefetcher;
 use crate::{RafsError, RafsIoReader, RafsResult};
 
+struct StorageBlobWriter<'a> {
+    inner: &'a mut dyn ZeroCopyWriter,
+}
+
+struct StorageBlobReader<'a> {
+    inner: &'a mut dyn BlobIoRead,
+}
+
+impl BlobIoWrite for StorageBlobWriter<'_> {
+    fn write_from(
+        &mut self,
+        reader: &mut dyn BlobIoRead,
+        size: usize,
+        offset: u64,
+    ) -> io::Result<usize> {
+        let mut adapter = StorageBlobReader { inner: reader };
+        self.inner.write_from(&mut adapter, size, offset)
+    }
+}
+
+impl FileReadWriteVolatile for StorageBlobReader<'_> {
+    fn read_volatile(
+        &mut self,
+        _slice: FileVolatileSlice,
+    ) -> std::result::Result<usize, io::Error> {
+        unimplemented!()
+    }
+
+    fn write_volatile(
+        &mut self,
+        _slice: FileVolatileSlice,
+    ) -> std::result::Result<usize, io::Error> {
+        unimplemented!()
+    }
+
+    fn read_at_volatile(
+        &mut self,
+        slice: FileVolatileSlice,
+        offset: u64,
+    ) -> std::result::Result<usize, io::Error> {
+        let slice = unsafe { VolatileSlice::from_raw_ptr(slice.as_ptr(), slice.len()) };
+        self.inner.read_at_volatile(slice, offset)
+    }
+
+    fn read_vectored_at_volatile(
+        &mut self,
+        buffers: &[FileVolatileSlice],
+        offset: u64,
+    ) -> std::result::Result<usize, io::Error> {
+        let buffers: Vec<VolatileSlice> = buffers
+            .iter()
+            .map(|slice| unsafe { VolatileSlice::from_raw_ptr(slice.as_ptr(), slice.len()) })
+            .collect();
+        self.inner.read_vectored_at_volatile(&buffers, offset)
+    }
+
+    fn write_at_volatile(
+        &mut self,
+        _slice: FileVolatileSlice,
+        _offset: u64,
+    ) -> std::result::Result<usize, io::Error> {
+        unimplemented!()
+    }
+}
+
 /// Type of RAFS fuse handle.
 pub type Handle = u64;
 
@@ -741,7 +809,8 @@ impl FileSystem for Rafs {
             assert_ne!(io_vec.size(), 0);
 
             // Avoid copying `desc`
-            let r = self.device.read_to(w, io_vec)?;
+            let mut storage_writer = StorageBlobWriter { inner: w };
+            let r = self.device.read_to(&mut storage_writer, io_vec)?;
             result += r;
             recorder.mark_success(r);
             if r as u64 != io_vec.size() {

rafs/src/prefetch.rs

@@ -573,13 +573,13 @@ impl BlobPrefetcher {
 mod tests {
     use std::io::Read;
 
-    use fuse_backend_rs::file_buf::FileVolatileSlice;
     use nydus_storage::backend::{BackendContext, BackendResult, BlobReader};
     use nydus_storage::cache::state::ChunkMap;
     use nydus_storage::cache::BlobCache;
     use nydus_storage::device::{
         BlobChunkInfo, BlobInfo, BlobIoDesc, BlobIoVec, BlobPrefetchRequest,
     };
+    use nydus_storage::volatile::VolatileSlice as FileVolatileSlice;
     use nydus_storage::{StorageError, StorageResult};
     use nydus_utils::crypt::{Cipher, CipherContext};
     use nydus_utils::metrics::BackendMetrics;

storage/Cargo.toml

@@ -47,8 +47,6 @@ tokio = { version = "1.19.0", features = [
     "time",
 ] }
 url = { version = "2.1.1", optional = true }
-vm-memory = { workspace = true }
-fuse-backend-rs = { workspace = true }
 gpt = { version = "3.1.0", optional = true }
 
 nydus-api = { version = "0.4.1", path = "../api" }
@@ -64,7 +62,7 @@ rand = { version = "0.8" }
 futures = "0.3"
 http = "1.4.0"
 hyper-util = { version = "0.1.19", features = ["server"] }
-vmm-sys-util = { workspace = true }
+tempfile = "3"
 tar = "0.4.40"
 regex = "1.7.0"
 toml = "0.5"

storage/src/backend/localdisk.rs

@@ -12,13 +12,13 @@ use std::os::unix::io::AsRawFd;
 use std::path::Path;
 use std::sync::{Arc, RwLock};
 
-use fuse_backend_rs::file_buf::FileVolatileSlice;
 use nix::sys::uio;
 use nydus_api::LocalDiskConfig;
 use nydus_utils::metrics::BackendMetrics;
 
 use crate::backend::{BackendError, BackendResult, BlobBackend, BlobReader};
 use crate::utils::{readv, MemSliceCursor};
+use crate::volatile::VolatileSlice as FileVolatileSlice;
 
 type LocalDiskResult<T> = std::result::Result<T, LocalDiskError>;
 

storage/src/backend/localfs.rs

@@ -12,14 +12,14 @@ use std::os::unix::io::AsRawFd;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock};
 
-use fuse_backend_rs::file_buf::FileVolatileSlice;
 use nix::sys::uio;
 
 use nydus_api::LocalFsConfig;
 use nydus_utils::metrics::BackendMetrics;
 
 use crate::backend::{BackendError, BackendResult, BlobBackend, BlobReader};
 use crate::utils::{readv, MemSliceCursor};
+use crate::volatile::VolatileSlice as FileVolatileSlice;
 
 type LocalFsResult<T> = std::result::Result<T, LocalFsError>;
 
@@ -215,10 +215,11 @@ impl Drop for LocalFs {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::test::TempPath;
     use std::fs;
     use std::io::Write;
     use std::os::unix::io::{FromRawFd, IntoRawFd};
-    use vmm_sys_util::{tempdir::TempDir, tempfile::TempFile};
+    use tempfile::{NamedTempFile as TempFile, TempDir};
 
     fn new_localfs(
         dir: &Path,

storage/src/backend/mod.rs

@@ -20,10 +20,10 @@ use std::thread::sleep;
 use std::time::SystemTime;
 use std::{sync::Arc, time::Duration};
 
-use fuse_backend_rs::file_buf::FileVolatileSlice;
 use nydus_utils::metrics::{BackendMetrics, ERROR_HOLDER};
 
 use crate::utils::{alloc_buf, copyv};
+use crate::volatile::VolatileSlice as FileVolatileSlice;
 use crate::StorageError;
 
 #[cfg(any(

storage/src/cache/cachedfile.rs

@@ -20,14 +20,15 @@ use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use fuse_backend_rs::file_buf::FileVolatileSlice;
 use nix::sys::uio;
 use nydus_utils::compress::Decoder;
 use nydus_utils::crypt::{self, Cipher, CipherContext};
 use nydus_utils::metrics::{BlobcacheMetrics, Metric};
 use nydus_utils::{compress, digest, round_up_usize, DelayType, Delayer, FileRangeReader};
 use tokio::runtime::Runtime;
 
+use crate::volatile::VolatileSlice as FileVolatileSlice;
+
 use crate::backend::BlobReader;
 use crate::cache::state::ChunkMap;
 use crate::cache::worker::{AsyncPrefetchConfig, AsyncPrefetchMessage, AsyncWorkerMgr};
@@ -2121,8 +2122,9 @@ mod tests {
     #[test]
     fn test_entries_count_metric_increment() {
         use crate::cache::state::{BlobStateMap, IndexedChunkMap};
+        use crate::test::TempPath;
         use std::sync::Arc;
-        use vmm_sys_util::tempdir::TempDir;
+        use tempfile::TempDir;
 
         // Create temporary directory and metrics
         let tmpdir = TempDir::new().unwrap();

storage/src/cache/dedup/db.rs

@@ -227,7 +227,8 @@ impl CasDb {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use vmm_sys_util::tempdir::TempDir;
+    use crate::test::TempPath;
+    use tempfile::TempDir;
 
     #[test]
     fn test_cas_blob() {

storage/src/cache/dedup/mod.rs

@@ -222,10 +222,10 @@ impl CasMgr {
 mod tests {
     use super::*;
     use crate::device::BlobFeatures;
-    use crate::test::MockChunkInfo;
+    use crate::test::{MockChunkInfo, TempPath};
     use crate::RAFS_DEFAULT_CHUNK_SIZE;
     use std::io::{Read, Seek, SeekFrom, Write};
-    use vmm_sys_util::tempfile::TempFile;
+    use tempfile::NamedTempFile as TempFile;
 
     #[test]
     fn test_cas_error_display() {

storage/src/cache/dummycache.rs

@@ -22,7 +22,6 @@ use std::io::Result;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
-use fuse_backend_rs::file_buf::FileVolatileSlice;
 use nydus_api::CacheConfigV2;
 use nydus_utils::crypt::{Algorithm, Cipher, CipherContext};
 use nydus_utils::{compress, digest};
@@ -34,6 +33,7 @@ use crate::device::{
     BlobChunkInfo, BlobFeatures, BlobInfo, BlobIoDesc, BlobIoVec, BlobPrefetchRequest,
 };
 use crate::utils::{alloc_buf, copyv};
+use crate::volatile::VolatileSlice as FileVolatileSlice;
 use crate::{StorageError, StorageResult};
 
 struct DummyCache {
@@ -250,9 +250,10 @@ impl Drop for DummyCacheMgr {
 mod tests {
     use std::fs::OpenOptions;
 
+    use crate::test::TempPath;
     use nydus_api::ConfigV2;
     use nydus_utils::metrics::BackendMetrics;
-    use vmm_sys_util::tempdir::TempDir;
+    use tempfile::TempDir;
 
     use crate::{
         cache::state::IndexedChunkMap,

storage/src/cache/filecache/mod.rs

@@ -406,9 +406,9 @@ impl FileCacheEntry {
 
 #[cfg(test)]
 pub mod blob_cache_tests {
+    use crate::test::TempPath;
     use nydus_api::FileCacheConfig;
-    use vmm_sys_util::tempdir::TempDir;
-    use vmm_sys_util::tempfile::TempFile;
+    use tempfile::{NamedTempFile as TempFile, TempDir};
 
     #[test]
     fn test_blob_cache_config() {
@@ -908,10 +908,10 @@ mod tests {
     #[test]
     fn test_filecache_config_work_dir_file_path_is_invalid() {
         use nydus_api::FileCacheConfig;
-        use vmm_sys_util::tempfile::TempFile;
+        use tempfile::NamedTempFile as TempFile;
 
         let tmp_file = TempFile::new().unwrap();
-        let file_path = tmp_file.as_path().to_path_buf();
+        let file_path = tmp_file.path().to_path_buf();
         let config = FileCacheConfig {
             work_dir: file_path.to_str().unwrap().to_owned(),
             ..Default::default()

storage/src/cache/mod.rs

@@ -21,7 +21,6 @@ use std::io::Result;
 use std::sync::Arc;
 use std::time::Instant;
 
-use fuse_backend_rs::file_buf::FileVolatileSlice;
 use nydus_utils::compress::zlib_random::ZranDecoder;
 use nydus_utils::crypt::{self, Cipher, CipherContext};
 use nydus_utils::{compress, digest};
@@ -33,6 +32,7 @@ use crate::device::{
 };
 use crate::meta::BlobCompressionContextInfo;
 use crate::utils::{alloc_buf, check_crc, check_hash};
+use crate::volatile::VolatileSlice as FileVolatileSlice;
 use crate::{StorageResult, RAFS_MAX_CHUNK_SIZE};
 
 mod cachedfile;

storage/src/cache/state/blob_state_map.rs

@@ -372,10 +372,10 @@ pub(crate) mod tests {
     use std::thread;
     use std::time::Instant;
 
+    use crate::test::TempPath;
     use nydus_utils::digest::Algorithm::Blake3;
     use nydus_utils::digest::{Algorithm, RafsDigest};
-    use vmm_sys_util::tempdir::TempDir;
-    use vmm_sys_util::tempfile::TempFile;
+    use tempfile::{NamedTempFile as TempFile, TempDir};
 
     use super::*;
     use crate::cache::state::DigestedChunkMap;

storage/src/cache/state/indexed_chunk_map.rs

@@ -138,12 +138,12 @@ mod tests {
     use std::fs::OpenOptions;
     use std::io::Write;
     use std::sync::atomic::Ordering;
-    use vmm_sys_util::tempdir::TempDir;
+    use tempfile::TempDir;
 
     use super::super::persist_map::*;
     use super::*;
     use crate::device::v5::BlobV5ChunkInfo;
-    use crate::test::MockChunkInfo;
+    use crate::test::{MockChunkInfo, TempPath};
 
     #[test]
     fn test_indexed_new_invalid_file_size() {

storage/src/cache/state/range_map.rs

@@ -121,7 +121,8 @@ mod tests {
     use std::thread;
     use std::time::Instant;
 
-    use vmm_sys_util::tempdir::TempDir;
+    use crate::test::TempPath;
+    use tempfile::TempDir;
 
     use super::super::BlobStateMap;
     use super::*;

storage/src/cache/worker.rs

@@ -424,7 +424,8 @@ impl AsyncWorkerMgr {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use vmm_sys_util::tempdir::TempDir;
+    use crate::test::TempPath;
+    use tempfile::TempDir;
 
     #[test]
     fn test_worker_mgr_new() {