feat: init macos passthrough

Signed-off-by: akitaSummer <644171127@qq.com>

Author: akitaSummer

Cargo.toml

@@ -47,6 +47,8 @@ tokio-uring = { version = "0.4.0", optional = true }
 tokio-test = "0.4.2"
 vmm-sys-util = "0.11"
 vm-memory = { version = "0.10", features = ["backend-mmap", "backend-bitmap"] }
+[target.'cfg(target_os = "macos")'.dev-dependencies]
+tempfile = "3.2.0"
 
 [features]
 default = ["fusedev"]

src/lib.rs

@@ -117,7 +117,7 @@ pub type Result<T> = ::std::result::Result<T, Error>;
 pub mod abi;
 pub mod api;
 
-#[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
+// #[cfg(all(any(feature = "fusedev", feature = "virtiofs"), target_os = "linux"))]
 pub mod passthrough;
 pub mod transport;
 

src/passthrough/inode_store.rs

@@ -4,19 +4,25 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
+#[cfg(target_os = "linux")]
 use super::file_handle::FileHandle;
+#[cfg(target_os = "macos")]
+use super::stat::Stat;
+#[cfg(target_os = "linux")]
 use super::statx::StatExt;
-use super::{Inode, InodeData, InodeHandle};
+use super::{InoT, Inode, InodeData, InodeHandle};
 
 #[derive(Clone, Copy, Default, PartialOrd, Ord, PartialEq, Eq, Debug)]
 /// Identify an inode in `PassthroughFs` by `InodeId`.
 pub struct InodeId {
-    pub ino: libc::ino64_t,
+    pub ino: InoT,
     pub dev: libc::dev_t,
+    #[cfg(target_os = "linux")]
     pub mnt: u64,
 }
 
 impl InodeId {
+    #[cfg(target_os = "linux")]
     #[inline]
     pub(super) fn from_stat(st: &StatExt) -> Self {
         InodeId {
@@ -25,12 +31,22 @@ impl InodeId {
             mnt: st.mnt_id,
         }
     }
+
+    #[cfg(target_os = "macos")]
+    #[inline]
+    pub(super) fn from_stat(st: &Stat) -> Self {
+        InodeId {
+            ino: st.st.st_ino,
+            dev: st.st.st_dev,
+        }
+    }
 }
 
 #[derive(Default)]
 pub struct InodeStore {
     data: BTreeMap<Inode, Arc<InodeData>>,
     by_id: BTreeMap<InodeId, Inode>,
+    #[cfg(target_os = "linux")]
     by_handle: BTreeMap<Arc<FileHandle>, Inode>,
 }
 
@@ -41,6 +57,7 @@ impl InodeStore {
     /// will get lost.
     pub fn insert(&mut self, data: Arc<InodeData>) {
         self.by_id.insert(data.id, data.inode);
+        #[cfg(target_os = "linux")]
         if let InodeHandle::Handle(handle) = &data.handle {
             self.by_handle
                 .insert(handle.file_handle().clone(), data.inode);
@@ -59,6 +76,7 @@ impl InodeStore {
         }
 
         if let Some(data) = data.as_ref() {
+            #[cfg(target_os = "linux")]
             if let InodeHandle::Handle(handle) = &data.handle {
                 self.by_handle.remove(handle.file_handle());
             }
@@ -69,6 +87,7 @@ impl InodeStore {
 
     pub fn clear(&mut self) {
         self.data.clear();
+        #[cfg(target_os = "linux")]
         self.by_handle.clear();
         self.by_id.clear();
     }
@@ -82,6 +101,7 @@ impl InodeStore {
         self.get(inode)
     }
 
+    #[cfg(target_os = "linux")]
     pub fn get_by_handle(&self, handle: &FileHandle) -> Option<&Arc<InodeData>> {
         let inode = self.inode_by_handle(handle)?;
         self.get(inode)
@@ -91,6 +111,7 @@ impl InodeStore {
         self.by_id.get(id)
     }
 
+    #[cfg(target_os = "linux")]
     pub fn inode_by_handle(&self, handle: &FileHandle) -> Option<&Inode> {
         self.by_handle.get(handle)
     }
@@ -105,8 +126,13 @@ mod test {
     use std::mem::MaybeUninit;
     use std::os::unix::io::AsRawFd;
     use std::sync::atomic::Ordering;
+    #[cfg(target_os = "macos")]
+    use tempfile::Builder;
+    #[cfg(target_os = "linux")]
     use vmm_sys_util::tempfile::TempFile;
 
+    use stat::stat;
+
     impl PartialEq for InodeData {
         fn eq(&self, other: &Self) -> bool {
             if self.inode != other.inode
@@ -117,16 +143,26 @@ mod test {
                 return false;
             }
 
+            #[cfg(target_os = "linux")]
             match (&self.handle, &other.handle) {
                 (InodeHandle::File(f1), InodeHandle::File(f2)) => f1.as_raw_fd() == f2.as_raw_fd(),
                 (InodeHandle::Handle(h1), InodeHandle::Handle(h2)) => {
                     h1.file_handle() == h2.file_handle()
                 }
                 _ => false,
             }
+
+            #[cfg(target_os = "macos")]
+            match (&self.handle, &other.handle) {
+                (InodeHandle::File(f1, _), InodeHandle::File(f2, _)) => {
+                    f1.as_raw_fd() == f2.as_raw_fd()
+                }
+                _ => false,
+            }
         }
     }
 
+    #[cfg(target_os = "linux")]
     fn stat_fd(fd: &impl AsRawFd) -> io::Result<libc::stat64> {
         let mut st = MaybeUninit::<libc::stat64>::zeroed();
         let null_path = unsafe { CStr::from_bytes_with_nul_unchecked(b"\0") };
@@ -148,6 +184,7 @@ mod test {
         }
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn test_inode_store() {
         let mut m = InodeStore::default();
@@ -214,4 +251,65 @@ mod test {
         assert!(m.get(&inode2).is_none());
         assert!(m.get_by_id(&id2).is_none());
     }
+
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn test_inode_store() {
+        let mut m = InodeStore::default();
+        let tmpfile1 = Builder::new().tempfile().unwrap();
+        let tmpfile2 = Builder::new().tempfile().unwrap();
+
+        let inode1: Inode = 3;
+        let inode2: Inode = 4;
+        let inode_stat1 = stat(tmpfile1.as_file()).unwrap();
+        let inode_stat2 = stat(tmpfile2.as_file()).unwrap();
+        let id1 = InodeId::from_stat(&inode_stat1);
+        let id2 = InodeId::from_stat(&inode_stat2);
+        let cstr1 = CString::new(tmpfile1.path().to_string_lossy().to_string()).unwrap();
+        let cstr2 = CString::new(tmpfile2.path().to_string_lossy().to_string()).unwrap();
+        let file_or_handle1 = InodeHandle::File(tmpfile1.into_file(), cstr1);
+        let file_or_handle2 = InodeHandle::File(tmpfile2.into_file(), cstr2);
+        let data1 = InodeData::new(inode1, file_or_handle1, 2, id1, inode_stat1.st.st_mode);
+        let data2 = InodeData::new(inode2, file_or_handle2, 2, id2, inode_stat2.st.st_mode);
+        let data1 = Arc::new(data1);
+        let data2 = Arc::new(data2);
+
+        m.insert(data1.clone());
+
+        // get not present key, expect none
+        assert!(m.get(&1).is_none());
+
+        // get just inserted value by key, by id, by handle
+        assert!(m.get_by_id(&InodeId::default()).is_none());
+        assert_eq!(m.get(&inode1).unwrap(), &data1);
+        assert_eq!(m.get_by_id(&id1).unwrap(), &data1);
+
+        // insert another value, and check again
+        m.insert(data2.clone());
+        assert!(m.get(&1).is_none());
+        assert!(m.get_by_id(&InodeId::default()).is_none());
+        assert_eq!(m.get(&inode1).unwrap(), &data1);
+        assert_eq!(m.get_by_id(&id1).unwrap(), &data1);
+        assert_eq!(m.get(&inode2).unwrap(), &data2);
+        assert_eq!(m.get_by_id(&id2).unwrap(), &data2);
+
+        // remove non-present key
+        assert!(m.remove(&1, false).is_none());
+
+        // remove present key, return its value
+        assert_eq!(m.remove(&inode1, false).unwrap(), data1.clone());
+        assert!(m.get(&inode1).is_none());
+        assert!(m.get_by_id(&id1).is_none());
+        assert_eq!(m.get(&inode2).unwrap(), &data2);
+        assert_eq!(m.get_by_id(&id2).unwrap(), &data2);
+
+        // clear the map
+        m.clear();
+        assert!(m.get(&1).is_none());
+        assert!(m.get_by_id(&InodeId::default()).is_none());
+        assert!(m.get(&inode1).is_none());
+        assert!(m.get_by_id(&id1).is_none());
+        assert!(m.get(&inode2).is_none());
+        assert!(m.get_by_id(&id2).is_none());
+    }
 }

src/passthrough/sync_io.rs renamed to src/passthrough/linux_sync_io.rs

@@ -0,0 +1,41 @@
+// Copyright (C) 2020 Alibaba Cloud. All rights reserved.
+// Copyright 2019 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE-BSD-3-Clause file.
+
+//! Fuse passthrough file system, mirroring an existing FS hierarchy.
+
+use std::ffi::{CStr, CString};
+use std::fs::File;
+use std::io;
+use std::mem::{self, size_of, ManuallyDrop, MaybeUninit};
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::time::Duration;
+
+use super::*;
+use crate::abi::fuse_abi::{CreateIn, Opcode, FOPEN_IN_KILL_SUIDGID};
+#[cfg(any(feature = "vhost-user-fs", feature = "virtiofs"))]
+use crate::abi::virtio_fs;
+use crate::api::filesystem::{
+    Context, DirEntry, Entry, FileSystem, FsOptions, GetxattrReply, ListxattrReply, OpenOptions,
+    SetattrValid, ZeroCopyReader, ZeroCopyWriter,
+};
+use crate::bytes_to_cstr;
+#[cfg(any(feature = "vhost-user-fs", feature = "virtiofs"))]
+use crate::transport::FsCacheReqHandler;
+
+impl<S: BitmapSlice + Send + Sync> PassthroughFs<S> {}
+
+impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
+    type Inode = Inode;
+    type Handle = Handle;
+
+    fn lookup(&self, _ctx: &Context, parent: Self::Inode, name: &CStr) -> io::Result<Entry> {
+        if name.to_bytes_with_nul().contains(&SLASH_ASCII) {
+            return Err(einval());
+        }
+        self.do_lookup(parent, name)
+    }
+}