rust: fs: introduce Type::read_xattr

This allows file system to expose xattrs associated to inodes.

Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>

Author: wedsonaf

rust/bindings/bindings_helper.h

@@ -15,6 +15,7 @@
 #include <linux/refcount.h>
 #include <linux/wait.h>
 #include <linux/sched.h>
+#include <linux/xattr.h>
 
 /* `bindgen` gets confused at certain things. */
 const size_t BINDINGS_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;

rust/kernel/error.rs

@@ -81,6 +81,8 @@ pub mod code {
     declare_err!(EIOCBQUEUED, "iocb queued, will get completion event.");
     declare_err!(ERECALLCONFLICT, "Conflict with recalled state.");
     declare_err!(ENOGRACE, "NFS file lock reclaim refused.");
+    declare_err!(ENODATA, "No data available.");
+    declare_err!(EOPNOTSUPP, "Operation not supported on transport endpoint.");
 }
 
 /// Generic integer kernel error.

rust/kernel/fs.rs

@@ -49,6 +49,14 @@ pub mod ro {
 
         /// Reads the contents of the inode into the given folio.
         fn read_folio(inode: &INode<Self>, folio: crate::folio::LockedFolio<'_>) -> Result;
+
+        /// Reads an xattr.
+        ///
+        /// Returns the number of bytes written to `outbuf`. If it is too small, returns the number
+        /// of bytes needs to hold the attribute.
+        fn read_xattr(_inode: &INode<Self>, _name: &CStr, _outbuf: &mut [u8]) -> Result<usize> {
+            Err(EOPNOTSUPP)
+        }
     }
 
     /// The types of directory entries reported by [`Type::read_dir`].
@@ -417,6 +425,7 @@ pub mod ro {
 
             sb.s_magic = params.magic as _;
             sb.s_op = &Tables::<T>::SUPER_BLOCK;
+            sb.s_xattr = &Tables::<T>::XATTR_HANDLERS[0];
             sb.s_maxbytes = params.maxbytes;
             sb.s_time_gran = params.time_gran;
             sb.s_blocksize_bits = params.blocksize_bits;
@@ -517,6 +526,41 @@ pub mod ro {
             shutdown: None,
         };
 
+        const XATTR_HANDLERS: [*const bindings::xattr_handler; 2] =
+            [&Self::XATTR_HANDLER, ptr::null()];
+
+        const XATTR_HANDLER: bindings::xattr_handler = bindings::xattr_handler {
+            name: ptr::null(),
+            prefix: crate::c_str!("").as_char_ptr(),
+            flags: 0,
+            list: None,
+            get: Some(Self::xattr_get_callback),
+            set: None,
+        };
+
+        unsafe extern "C" fn xattr_get_callback(
+            _handler: *const bindings::xattr_handler,
+            _dentry: *mut bindings::dentry,
+            inode_ptr: *mut bindings::inode,
+            name: *const core::ffi::c_char,
+            buffer: *mut core::ffi::c_void,
+            size: usize,
+        ) -> core::ffi::c_int {
+            from_result(|| {
+                // SAFETY: The C api guarantees that `inode_ptr` is a valid inode.
+                let inode = unsafe { &*inode_ptr.cast::<INode<T>>() };
+
+                // SAFETY: The c api guarantees that `name` is a valid null-terminated string. It
+                // also guarantees that it's valid for the duration of the callback.
+                let name = unsafe { CStr::from_char_ptr(name) };
+
+                // SAFETY: The C api guarantees that `buffer` is at least `size` bytes in length.
+                let buf = unsafe { core::slice::from_raw_parts_mut(buffer.cast(), size) };
+                let len = T::read_xattr(inode, name, buf)?;
+                Ok(len.try_into()?)
+            })
+        }
+
         const DIR_FILE_OPERATIONS: bindings::file_operations = bindings::file_operations {
             owner: ptr::null_mut(),
             llseek: Some(bindings::generic_file_llseek),