rust: fs: introduce Type::fill_super

This allows a file system to initialise superblocks, which allows them
to be mounted, though they are still empty.

Some scaffolding code is added to create an empty directory as the root.
It will be replaced by proper inode creation in a subsequent patch in
this series.

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

Author: wedsonaf

rust/bindings/bindings_helper.h

@@ -9,6 +9,7 @@
 #include <kunit/test.h>
 #include <linux/errname.h>
 #include <linux/fs.h>
+#include <linux/fs_context.h>
 #include <linux/slab.h>
 #include <linux/refcount.h>
 #include <linux/wait.h>
@@ -21,3 +22,7 @@ const gfp_t BINDINGS___GFP_ZERO = __GFP_ZERO;
 
 const slab_flags_t BINDINGS_SLAB_RECLAIM_ACCOUNT = SLAB_RECLAIM_ACCOUNT;
 const slab_flags_t BINDINGS_SLAB_MEM_SPREAD = SLAB_MEM_SPREAD;
+
+const unsigned long BINDINGS_SB_RDONLY = SB_RDONLY;
+
+const loff_t BINDINGS_MAX_LFS_FILESIZE = MAX_LFS_FILESIZE;

rust/bindings/lib.rs

@@ -54,3 +54,7 @@ pub const __GFP_ZERO: gfp_t = BINDINGS___GFP_ZERO;
 
 pub const SLAB_RECLAIM_ACCOUNT: slab_flags_t = BINDINGS_SLAB_RECLAIM_ACCOUNT;
 pub const SLAB_MEM_SPREAD: slab_flags_t = BINDINGS_SLAB_MEM_SPREAD;
+
+pub const SB_RDONLY: core::ffi::c_ulong = BINDINGS_SB_RDONLY;
+
+pub const MAX_LFS_FILESIZE: loff_t = BINDINGS_MAX_LFS_FILESIZE;

rust/kernel/fs.rs

@@ -6,9 +6,12 @@
 //!
 //! C headers: [`include/linux/fs.h`](../../include/linux/fs.h)
 
+/// Maximum size of an inode.
+pub const MAX_LFS_FILESIZE: i64 = bindings::MAX_LFS_FILESIZE;
+
 /// Read-only file systems.
 pub mod ro {
-    use crate::error::{code::*, from_result, to_result, Error};
+    use crate::error::{code::*, from_result, to_result, Error, Result};
     use crate::types::Opaque;
     use crate::{bindings, init::PinInit, str::CStr, try_pin_init, ThisModule};
     use core::{marker::PhantomData, marker::PhantomPinned, pin::Pin};
@@ -18,6 +21,9 @@ pub mod ro {
     pub trait Type {
         /// The name of the file system type.
         const NAME: &'static CStr;
+
+        /// Initialises a super block for this file system type.
+        fn fill_super(sb: NewSuperBlock<'_, Self>) -> Result<&SuperBlock<Self>>;
     }
 
     /// A registration of a read-only file system.
@@ -48,7 +54,7 @@ pub mod ro {
                     *fs = bindings::file_system_type::default();
                     fs.owner = module.0;
                     fs.name = T::NAME.as_char_ptr();
-                    fs.init_fs_context = Some(Self::init_fs_context_callback);
+                    fs.init_fs_context = Some(Self::init_fs_context_callback::<T>);
                     fs.kill_sb = Some(Self::kill_sb_callback);
                     fs.fs_flags = 0;
 
@@ -59,13 +65,22 @@ pub mod ro {
             })
         }
 
-        unsafe extern "C" fn init_fs_context_callback(
-            _fc_ptr: *mut bindings::fs_context,
+        unsafe extern "C" fn init_fs_context_callback<T: Type + ?Sized>(
+            fc_ptr: *mut bindings::fs_context,
         ) -> core::ffi::c_int {
-            from_result(|| Err(ENOTSUPP))
+            from_result(|| {
+                // SAFETY: The C callback API guarantees that `fc_ptr` is valid.
+                let fc = unsafe { &mut *fc_ptr };
+                fc.ops = &Tables::<T>::CONTEXT;
+                Ok(0)
+            })
         }
 
-        unsafe extern "C" fn kill_sb_callback(_sb_ptr: *mut bindings::super_block) {}
+        unsafe extern "C" fn kill_sb_callback(sb_ptr: *mut bindings::super_block) {
+            // SAFETY: In `get_tree_callback` we always call `get_tree_nodev`, so `kill_anon_super`
+            // is the appropriate function to call for cleanup.
+            unsafe { bindings::kill_anon_super(sb_ptr) };
+        }
     }
 
     #[pinned_drop]
@@ -78,6 +93,178 @@ pub mod ro {
         }
     }
 
+    /// A file system super block.
+    ///
+    /// Wraps the kernel's `struct super_block`.
+    #[repr(transparent)]
+    pub struct SuperBlock<T: Type + ?Sized>(Opaque<bindings::super_block>, PhantomData<T>);
+
+    /// Required superblock parameters.
+    ///
+    /// This is used in [`NewSuperBlock::init`].
+    pub struct SuperParams {
+        /// The magic number of the superblock.
+        pub magic: u32,
+
+        /// The size of a block in powers of 2 (i.e., for a value of `n`, the size is `2^n`).
+        pub blocksize_bits: u8,
+
+        /// Maximum size of a file.
+        ///
+        /// The maximum allowed value is [`super::MAX_LFS_FILESIZE`].
+        pub maxbytes: i64,
+
+        /// Granularity of c/m/atime in ns (cannot be worse than a second).
+        pub time_gran: u32,
+    }
+
+    /// A superblock that is still being initialised.
+    ///
+    /// # Invariants
+    ///
+    /// The superblock is a newly-created one and this is the only active pointer to it.
+    pub struct NewSuperBlock<'a, T: Type + ?Sized> {
+        sb: &'a mut SuperBlock<T>,
+
+        // This also forces `'a` to be invariant.
+        _p: PhantomData<&'a mut &'a ()>,
+    }
+
+    impl<'a, T: Type + ?Sized> NewSuperBlock<'a, T> {
+        /// Creates a new instance of [`NewSuperBlock`].
+        ///
+        /// # Safety
+        ///
+        /// `sb` must point to a newly-created superblock and it must be the only active pointer to
+        /// it.
+        unsafe fn new(sb: *mut bindings::super_block) -> Self {
+            // INVARIANT: The invariants are satisfied by the safety requirements of this function.
+            Self {
+                // SAFETY: The safety requirements ensure that `sb` is valid for read and write.
+                sb: unsafe { &mut *sb.cast() },
+                _p: PhantomData,
+            }
+        }
+
+        /// Initialises the superblock.
+        pub fn init(self, params: &SuperParams) -> Result<&'a SuperBlock<T>> {
+            // SAFETY: Since this is a new super block, we hold the only reference to it.
+            let sb = unsafe { &mut *self.sb.0.get() };
+
+            sb.s_magic = params.magic as _;
+            sb.s_op = &Tables::<T>::SUPER_BLOCK;
+            sb.s_maxbytes = params.maxbytes;
+            sb.s_time_gran = params.time_gran;
+            sb.s_blocksize_bits = params.blocksize_bits;
+            sb.s_blocksize = 1;
+            if sb.s_blocksize.leading_zeros() < params.blocksize_bits.into() {
+                return Err(EINVAL);
+            }
+            sb.s_blocksize = 1 << sb.s_blocksize_bits;
+            sb.s_flags |= bindings::SB_RDONLY;
+
+            // The following is scaffolding code that will be removed in a subsequent patch. It is
+            // needed to build a root dentry, otherwise core code will BUG().
+            let inode = unsafe { bindings::new_inode(sb) };
+            if inode.is_null() {
+                return Err(ENOMEM);
+            }
+
+            // SAFETY: `inode` is valid for write.
+            unsafe { bindings::set_nlink(inode, 2) };
+
+            {
+                // SAFETY: This is a newly-created inode. No other references to it exist, so it is
+                // safe to mutably dereference it.
+                let inode = unsafe { &mut *inode };
+                inode.i_ino = 1;
+                inode.i_mode = (bindings::S_IFDIR | 0o755) as _;
+
+                // SAFETY: `simple_dir_operations` never changes, it's safe to reference it.
+                inode.__bindgen_anon_3.i_fop = unsafe { &bindings::simple_dir_operations };
+
+                // SAFETY: `simple_dir_inode_operations` never changes, it's safe to reference it.
+                inode.i_op = unsafe { &bindings::simple_dir_inode_operations };
+            }
+
+            // SAFETY: `d_make_root` requires that `inode` be valid and referenced, which is the
+            // case for this call.
+            //
+            // It takes over the inode, even on failure, so we don't need to clean it up.
+            let dentry = unsafe { bindings::d_make_root(inode) };
+            if dentry.is_null() {
+                return Err(ENOMEM);
+            }
+
+            sb.s_root = dentry;
+
+            Ok(self.sb)
+        }
+    }
+
+    struct Tables<T: Type + ?Sized>(T);
+    impl<T: Type + ?Sized> Tables<T> {
+        const CONTEXT: bindings::fs_context_operations = bindings::fs_context_operations {
+            free: None,
+            parse_param: None,
+            get_tree: Some(Self::get_tree_callback),
+            reconfigure: None,
+            parse_monolithic: None,
+            dup: None,
+        };
+
+        unsafe extern "C" fn get_tree_callback(fc: *mut bindings::fs_context) -> core::ffi::c_int {
+            // SAFETY: `fc` is valid per the callback contract. `fill_super_callback` also has
+            // the right type and is a valid callback.
+            unsafe { bindings::get_tree_nodev(fc, Some(Self::fill_super_callback)) }
+        }
+
+        unsafe extern "C" fn fill_super_callback(
+            sb_ptr: *mut bindings::super_block,
+            _fc: *mut bindings::fs_context,
+        ) -> core::ffi::c_int {
+            from_result(|| {
+                // SAFETY: The callback contract guarantees that `sb_ptr` is a unique pointer to a
+                // newly-created superblock.
+                let newsb = unsafe { NewSuperBlock::new(sb_ptr) };
+                T::fill_super(newsb)?;
+                Ok(0)
+            })
+        }
+
+        const SUPER_BLOCK: bindings::super_operations = bindings::super_operations {
+            alloc_inode: None,
+            destroy_inode: None,
+            free_inode: None,
+            dirty_inode: None,
+            write_inode: None,
+            drop_inode: None,
+            evict_inode: None,
+            put_super: None,
+            sync_fs: None,
+            freeze_super: None,
+            freeze_fs: None,
+            thaw_super: None,
+            unfreeze_fs: None,
+            statfs: None,
+            remount_fs: None,
+            umount_begin: None,
+            show_options: None,
+            show_devname: None,
+            show_path: None,
+            show_stats: None,
+            #[cfg(CONFIG_QUOTA)]
+            quota_read: None,
+            #[cfg(CONFIG_QUOTA)]
+            quota_write: None,
+            #[cfg(CONFIG_QUOTA)]
+            get_dquots: None,
+            nr_cached_objects: None,
+            free_cached_objects: None,
+            shutdown: None,
+        };
+    }
+
     /// Kernel module that exposes a single read-only file system implemented by `T`.
     #[pin_data]
     pub struct Module<T: Type + ?Sized> {
@@ -119,6 +306,11 @@ pub mod ro {
     /// impl fs::ro::Type for MyFs {
     ///     // ...
     /// #    const NAME: &'static CStr = c_str!("myfs");
+    /// #    fn fill_super(
+    /// #        _: fs::ro::NewSuperBlock<'_, Self>
+    /// #    ) -> Result<&fs::ro::SuperBlock<Self>> {
+    /// #        todo!()
+    /// #    }
     /// }
     /// ```
     #[macro_export]

samples/rust/rust_rofs.rs

@@ -2,6 +2,7 @@
 
 //! Rust read-only file system sample.
 
+use kernel::fs::ro::{NewSuperBlock, SuperBlock, SuperParams};
 use kernel::prelude::*;
 use kernel::{c_str, fs};
 
@@ -16,4 +17,13 @@ kernel::module_ro_fs! {
 struct RoFs;
 impl fs::ro::Type for RoFs {
     const NAME: &'static CStr = c_str!("rust-fs");
+
+    fn fill_super(sb: NewSuperBlock<'_, Self>) -> Result<&SuperBlock<Self>> {
+        sb.init(&SuperParams {
+            magic: 0x52555354,
+            blocksize_bits: 12,
+            maxbytes: fs::MAX_LFS_FILESIZE,
+            time_gran: 1,
+        })
+    }
 }