rust: fs: add registration/unregistration of ro file systems

This is just the basics of registering a filesystem and automatically
unregistering when the registration instance is dropped (e.g., when it
goes out of scope).

File systems registered this way are visible in `/proc/filesystems` but
cannot be mounted yet because `init_fs_context` fails.

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

Author: wedsonaf

rust/bindings/bindings_helper.h

@@ -8,6 +8,7 @@
 
 #include <kunit/test.h>
 #include <linux/errname.h>
+#include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/refcount.h>
 #include <linux/wait.h>

rust/kernel/error.rs

@@ -320,8 +320,6 @@ pub(crate) fn from_err_ptr<T>(ptr: *mut T) -> Result<*mut T> {
 ///     })
 /// }
 /// ```
-// TODO: Remove `dead_code` marker once an in-kernel client is available.
-#[allow(dead_code)]
 pub(crate) fn from_result<T, F>(f: F) -> T
 where
     T: From<i16>,

rust/kernel/fs.rs

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! A kernel file system.
+//!
+//! This module allows Rust code to register new kernel file systems.
+//!
+//! C headers: [`include/linux/fs.h`](../../include/linux/fs.h)
+
+/// Read-only file systems.
+pub mod ro {
+    use crate::error::{code::*, from_result, to_result, Error};
+    use crate::types::Opaque;
+    use crate::{bindings, init::PinInit, str::CStr, try_pin_init, ThisModule};
+    use core::{marker::PhantomPinned, pin::Pin};
+    use macros::{pin_data, pinned_drop};
+
+    /// A read-only file system type.
+    pub trait Type {
+        /// The name of the file system type.
+        const NAME: &'static CStr;
+    }
+
+    /// A registration of a read-only file system.
+    #[pin_data(PinnedDrop)]
+    pub struct Registration {
+        #[pin]
+        fs: Opaque<bindings::file_system_type>,
+        #[pin]
+        _pin: PhantomPinned,
+    }
+
+    // SAFETY: `Registration` doesn't provide any `&self` methods, so it is safe to pass references
+    // to it around.
+    unsafe impl Sync for Registration {}
+
+    // SAFETY: Both registration and unregistration are implemented in C and safe to be performed
+    // from any thread, so `Registration` is `Send`.
+    unsafe impl Send for Registration {}
+
+    impl Registration {
+        /// Creates the initialiser of a new file system registration.
+        pub fn new<T: Type + ?Sized>(module: &'static ThisModule) -> impl PinInit<Self, Error> {
+            try_pin_init!(Self {
+                _pin: PhantomPinned,
+                fs <- Opaque::try_ffi_init(|fs_ptr| {
+                    // SAFETY: `pin_init_from_closure` guarantees that `fs_ptr` is valid for write.
+                    let fs = unsafe { &mut *fs_ptr };
+                    *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.kill_sb = Some(Self::kill_sb_callback);
+                    fs.fs_flags = 0;
+
+                    // SAFETY: Pointers stored in `fs` are static so will live for as long as the
+                    // registration is active (it is undone in `drop`).
+                    to_result(unsafe { bindings::register_filesystem(fs_ptr) })
+                }),
+            })
+        }
+
+        unsafe extern "C" fn init_fs_context_callback(
+            _fc_ptr: *mut bindings::fs_context,
+        ) -> core::ffi::c_int {
+            from_result(|| Err(ENOTSUPP))
+        }
+
+        unsafe extern "C" fn kill_sb_callback(_sb_ptr: *mut bindings::super_block) {}
+    }
+
+    #[pinned_drop]
+    impl PinnedDrop for Registration {
+        fn drop(self: Pin<&mut Self>) {
+            // SAFETY: If an instance of `Self` has been successfully created, a call to
+            // `register_filesystem` has necessarily succeeded. So it's ok to call
+            // `unregister_filesystem` on the previously registered fs.
+            unsafe { bindings::unregister_filesystem(self.fs.get()) };
+        }
+    }
+}

rust/kernel/lib.rs

@@ -34,6 +34,7 @@ extern crate self as kernel;
 mod allocator;
 mod build_assert;
 pub mod error;
+pub mod fs;
 pub mod init;
 pub mod ioctl;
 #[cfg(CONFIG_KUNIT)]