Add read-only xattr support to the API.

Author: 4lDO2

fal-backend-apfs/src/filesystem.rs

@@ -681,4 +681,12 @@ impl<D: fal::DeviceMut> fal::Filesystem<D> for Filesystem<D> {
     fn write(&mut self, _fh: u64, _offset: u64, _buffer: &[u8]) -> Result<u64> {
         unimplemented!()
     }
+    fn get_xattr(&mut self, _inode: &Inode, _name: &[u8]) -> Result<Vec<u8>> {
+        // TODO: This shouldn't be too hard to implement since the xattrs are already stored in th
+        // tree, and used internally (for symlinks).
+        unimplemented!("getting extended attributes")
+    }
+    fn list_xattrs(&mut self, _inode: &Inode) -> Result<Vec<Vec<u8>>> {
+        unimplemented!("listing extended attributes")
+    }
 }

fal-backend-ext4/src/lib.rs

@@ -23,6 +23,7 @@ pub use superblock::Superblock;
 
 use disk::Disk;
 use inode::InodeIoError;
+use xattr::XattrEntry;
 
 pub fn allocate_block_bytes(superblock: &Superblock) -> Box<[u8]> {
     vec![0u8; superblock.block_size() as usize].into_boxed_slice()
@@ -388,6 +389,19 @@ impl<D: fal::DeviceMut> fal::Filesystem<D> for Filesystem<D> {
     fn unlink(&mut self, _parent: u32, _name: &[u8]) -> fal::Result<()> {
         unimplemented!()
     }
+    fn get_xattr(&mut self, inode: &Inode, name: &[u8]) -> fal::Result<Vec<u8>> {
+        match inode.xattrs {
+            Some(ref x) => x.entries.iter().find(|(k, _)| k.name == name).ok_or(fal::Error::NoEntity).map(|(_, v)| v.clone()),
+            None => Err(fal::Error::NoEntity),
+        }
+    }
+    fn list_xattrs(&mut self, inode: &Inode) -> fal::Result<Vec<Vec<u8>>> {
+        // TODO: Support block-based xattrs as well.
+        match inode.xattrs {
+            Some(ref x) => Ok(x.entries.iter().map(|(entry, _)| &entry.name).cloned().collect()),
+            None => Ok(vec! []),
+        }
+    }
 }
 
 pub fn calculate_crc32c(value: u32, bytes: &[u8]) -> u32 {

fal/src/lib.rs

@@ -366,10 +366,11 @@ where
 
     // XXX: Rust's type system doesn't support associated types with lifetimes. If a backend wants
     // to use a concurrent hashmap for storing the file handles, then there won't be a direct
-    // reference, but an RAII guard. Basically all RAII guards store their owner, and to replace the
-    // return type with a guard, an associated type with a lifetime is required. On the other hand,
-    // inodes aren't typically that slow to clone. However with generic associated types, this
-    // problem will likely be easily solved.
+    // reference, but an RAII guard. Basically all RAII guards store their owner as a reference,
+    // and to replace the return type with a guard, an associated type with a lifetime is required.
+    // On the other hand, inodes aren't typically that slow to clone. However with generic associated
+    // types, this problem will likely be easily solved, as Self::InodeStruct can have an
+    // untethered lifetime.
     //
     // https://github.com/rust-lang/rust/issues/44265
     //
@@ -389,6 +390,13 @@ where
     /// entry reaches zero, the inode is deleted and its space is freed. However, if that inode is
     /// still open, it won't be removed until that.
     fn unlink(&mut self, parent: Self::InodeAddr, name: &[u8]) -> Result<()>;
+
+    /// Get a named extended attribute from an inode.
+    fn get_xattr(&mut self, inode: &Self::InodeStruct, name: &[u8]) -> Result<Vec<u8>>;
+
+    /// List the extended attribute names (keys) from an inode.
+    // TODO: Perhaps this double vector should be a null-separated u8 vector instead.
+    fn list_xattrs(&mut self, inode: &Self::InodeStruct) -> Result<Vec<Vec<u8>>>;
 }
 
 #[derive(Debug)]