rust: fs: introduce the module_ro_fs macro

This simplifies the declaration of modules that only expose a file
system.

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

Author: wedsonaf

rust/kernel/fs.rs

@@ -11,7 +11,7 @@ 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 core::{marker::PhantomData, marker::PhantomPinned, pin::Pin};
     use macros::{pin_data, pinned_drop};
 
     /// A read-only file system type.
@@ -77,4 +77,58 @@ pub mod ro {
             unsafe { bindings::unregister_filesystem(self.fs.get()) };
         }
     }
+
+    /// Kernel module that exposes a single read-only file system implemented by `T`.
+    #[pin_data]
+    pub struct Module<T: Type + ?Sized> {
+        #[pin]
+        fs_reg: Registration,
+        _p: PhantomData<T>,
+    }
+
+    impl<T: Type + ?Sized + Sync + Send> crate::InPlaceModule for Module<T> {
+        type Init = impl PinInit<Self, Error>;
+        fn init(module: &'static ThisModule) -> Self::Init {
+            try_pin_init!(Self {
+                fs_reg <- Registration::new::<T>(module),
+                _p: PhantomData,
+            })
+        }
+    }
+
+    /// Declares a kernel module that exposes a single file system.
+    ///
+    /// The `type` argument must be a type which implements the [`Type`] trait. Also accepts various
+    /// forms of kernel metadata.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use kernel::prelude::*;
+    /// use kernel::{c_str, fs};
+    ///
+    /// kernel::module_ro_fs! {
+    ///     type: MyFs,
+    ///     name: "myfs",
+    ///     author: "Rust for Linux Contributors",
+    ///     description: "My Rust fs",
+    ///     license: "GPL",
+    /// }
+    ///
+    /// struct MyFs;
+    /// impl fs::ro::Type for MyFs {
+    ///     // ...
+    /// #    const NAME: &'static CStr = c_str!("myfs");
+    /// }
+    /// ```
+    #[macro_export]
+    macro_rules! module_ro_fs {
+        (type: $type:ty, $($f:tt)*) => {
+            type ModuleType = $crate::fs::ro::Module<$type>;
+            $crate::macros::module! {
+                type: ModuleType,
+                $($f)*
+            }
+        }
+    }
 }