rust: fs: introduce Type::read_folio

We also allow the creation of regular file inodes. File systems can now
use `read_folio` to expose the file contents via the page cache.

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

Author: wedsonaf

rust/kernel/folio.rs

@@ -61,7 +61,6 @@ impl LockedFolio<'_> {
     /// Callers must ensure that the folio is valid and locked. Additionally, that the
     /// responsibility of unlocking is transferred to the new instance of [`LockedFolio`]. Lastly,
     /// that the returned [`LockedFolio`] doesn't outlive the refcount that keeps it alive.
-    #[allow(dead_code)]
     pub(crate) unsafe fn from_raw(folio: *const bindings::folio) -> Self {
         // SAFETY: The safety requirements ensure that `folio` is valid and will remain valid while
         // the `LockedFolio` instance lives.

rust/kernel/fs.rs

@@ -13,7 +13,10 @@ pub const MAX_LFS_FILESIZE: i64 = bindings::MAX_LFS_FILESIZE;
 pub mod ro {
     use crate::error::{code::*, from_result, to_result, Error, Result};
     use crate::types::{ARef, AlwaysRefCounted, Either, Opaque};
-    use crate::{bindings, init::PinInit, str::CStr, time::Time, try_pin_init, ThisModule};
+    use crate::{
+        bindings, folio::LockedFolio, init::PinInit, str::CStr, time::Time, try_pin_init,
+        ThisModule,
+    };
     use core::{marker::PhantomData, marker::PhantomPinned, mem::ManuallyDrop, pin::Pin, ptr};
     use macros::{pin_data, pinned_drop};
 
@@ -43,6 +46,9 @@ pub mod ro {
 
         /// Returns the inode corresponding to the directory entry with the given name.
         fn lookup(parent: &INode<Self>, name: &[u8]) -> Result<ARef<INode<Self>>>;
+
+        /// Reads the contents of the inode into the given folio.
+        fn read_folio(inode: &INode<Self>, folio: crate::folio::LockedFolio<'_>) -> Result;
     }
 
     /// The types of directory entries reported by [`Type::read_dir`].
@@ -81,6 +87,7 @@ pub mod ro {
         fn from(value: INodeType) -> Self {
             match value {
                 INodeType::Dir => DirEntryType::Dir,
+                INodeType::Reg => DirEntryType::Reg,
             }
         }
     }
@@ -231,6 +238,15 @@ pub mod ro {
                     inode.i_op = &Tables::<T>::DIR_INODE_OPERATIONS;
                     bindings::S_IFDIR
                 }
+                INodeType::Reg => {
+                    // SAFETY: `generic_ro_fops` never changes, it's safe to reference it.
+                    inode.__bindgen_anon_3.i_fop = unsafe { &bindings::generic_ro_fops };
+                    inode.i_data.a_ops = &Tables::<T>::FILE_ADDRESS_SPACE_OPERATIONS;
+
+                    // SAFETY: The `i_mapping` pointer doesn't change and is valid.
+                    unsafe { bindings::mapping_set_large_folios(inode.i_mapping) };
+                    bindings::S_IFREG
+                }
             };
 
             inode.i_mode = (params.mode & 0o777) | u16::try_from(mode)?;
@@ -268,6 +284,9 @@ pub mod ro {
     pub enum INodeType {
         /// Directory type.
         Dir,
+
+        /// Regular file type.
+        Reg,
     }
 
     /// Required inode parameters.
@@ -617,6 +636,55 @@ pub mod ro {
                 },
             }
         }
+
+        const FILE_ADDRESS_SPACE_OPERATIONS: bindings::address_space_operations =
+            bindings::address_space_operations {
+                writepage: None,
+                read_folio: Some(Self::read_folio_callback),
+                writepages: None,
+                dirty_folio: None,
+                readahead: None,
+                write_begin: None,
+                write_end: None,
+                bmap: None,
+                invalidate_folio: None,
+                release_folio: None,
+                free_folio: None,
+                direct_IO: None,
+                migrate_folio: None,
+                launder_folio: None,
+                is_partially_uptodate: None,
+                is_dirty_writeback: None,
+                error_remove_page: None,
+                swap_activate: None,
+                swap_deactivate: None,
+                swap_rw: None,
+            };
+
+        extern "C" fn read_folio_callback(
+            _file: *mut bindings::file,
+            folio: *mut bindings::folio,
+        ) -> i32 {
+            from_result(|| {
+                // SAFETY: All pointers are valid and stable.
+                let inode = unsafe {
+                    &*(*(*folio)
+                        .__bindgen_anon_1
+                        .page
+                        .__bindgen_anon_1
+                        .__bindgen_anon_1
+                        .mapping)
+                        .host
+                        .cast::<INode<T>>()
+                };
+
+                // SAFETY: The C contract guarantees that the folio is valid and locked, with
+                // ownership of the lock transferred to the callee (this function). The folio is
+                // also guaranteed not to outlive this function.
+                T::read_folio(inode, unsafe { LockedFolio::from_raw(folio) })?;
+                Ok(0)
+            })
+        }
     }
 
     /// Kernel module that exposes a single read-only file system implemented by `T`.
@@ -678,6 +746,9 @@ pub mod ro {
     /// #    ) -> Result<kernel::types::ARef<fs::ro::INode<Self>>> {
     /// #        todo!()
     /// #    }
+    /// #    fn read_folio(_: &fs::ro::INode<Self>, _: kernel::folio::LockedFolio<'_>) -> Result {
+    /// #        todo!()
+    /// #    }
     /// }
     /// ```
     #[macro_export]

samples/rust/rust_rofs.rs

@@ -6,7 +6,7 @@ use kernel::fs::ro::{
     DirEntryType, INode, INodeParams, INodeType, NewSuperBlock, SuperBlock, SuperParams,
 };
 use kernel::prelude::*;
-use kernel::{c_str, fs, time::UNIX_EPOCH, types::ARef, types::Either};
+use kernel::{c_str, folio::LockedFolio, fs, time::UNIX_EPOCH, types::ARef, types::Either};
 
 kernel::module_ro_fs! {
     type: RoFs,
@@ -20,23 +20,27 @@ struct Entry {
     name: &'static [u8],
     ino: u64,
     etype: INodeType,
+    contents: &'static [u8],
 }
 
 const ENTRIES: [Entry; 3] = [
     Entry {
         name: b".",
         ino: 1,
         etype: INodeType::Dir,
+        contents: b"",
     },
     Entry {
         name: b"..",
         ino: 1,
         etype: INodeType::Dir,
+        contents: b"",
     },
     Entry {
-        name: b"subdir",
+        name: b"test.txt",
         ino: 2,
-        etype: INodeType::Dir,
+        etype: INodeType::Reg,
+        contents: b"hello\n",
     },
 ];
 
@@ -99,23 +103,48 @@ impl fs::ro::Type for RoFs {
             return Err(ENOENT);
         }
 
-        match name {
-            b"subdir" => match parent.super_block().get_or_create_inode(2)? {
-                Either::Left(existing) => Ok(existing),
-                Either::Right(new) => new.init(INodeParams {
-                    typ: INodeType::Dir,
-                    mode: 0o555,
-                    size: 0,
-                    blocks: 1,
-                    nlink: 2,
-                    uid: 0,
-                    gid: 0,
-                    atime: UNIX_EPOCH,
-                    ctime: UNIX_EPOCH,
-                    mtime: UNIX_EPOCH,
-                }),
-            },
-            _ => Err(ENOENT),
+        for e in &ENTRIES {
+            if name == e.name {
+                return match parent.super_block().get_or_create_inode(e.ino)? {
+                    Either::Left(existing) => Ok(existing),
+                    Either::Right(new) => new.init(INodeParams {
+                        typ: e.etype,
+                        mode: 0o444,
+                        size: e.contents.len().try_into()?,
+                        blocks: 1,
+                        nlink: 1,
+                        uid: 0,
+                        gid: 0,
+                        atime: UNIX_EPOCH,
+                        ctime: UNIX_EPOCH,
+                        mtime: UNIX_EPOCH,
+                    }),
+                };
+            }
         }
+
+        Err(ENOENT)
+    }
+
+    fn read_folio(inode: &INode<Self>, mut folio: LockedFolio<'_>) -> Result {
+        let data = match inode.ino() {
+            2 => ENTRIES[2].contents,
+            _ => return Err(EINVAL),
+        };
+
+        let pos = usize::try_from(folio.pos()).unwrap_or(usize::MAX);
+        let copied = if pos >= data.len() {
+            0
+        } else {
+            let to_copy = core::cmp::min(data.len() - pos, folio.size());
+            folio.write(0, &data[pos..][..to_copy])?;
+            to_copy
+        };
+
+        folio.zero_out(copied, folio.size() - copied)?;
+        folio.mark_uptodate();
+        folio.flush_dcache();
+
+        Ok(())
     }
 }