rust: fs: introduce more inode types

This patch introduces symlinks, pipes, sockets, char devices and block
devices as types of inodes that can be created by rust file systems.

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

Author: wedsonaf

rust/helpers.c

@@ -227,6 +227,12 @@ void rust_helper_mapping_set_large_folios(struct address_space *mapping)
 }
 EXPORT_SYMBOL_GPL(rust_helper_mapping_set_large_folios);
 
+unsigned int rust_helper_MKDEV(unsigned int major, unsigned int minor)
+{
+	return MKDEV(major, minor);
+}
+EXPORT_SYMBOL_GPL(rust_helper_MKDEV);
+
 /*
  * `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can
  * use it in contexts where Rust expects a `usize` like slice (array) indices.

rust/kernel/fs.rs

@@ -119,8 +119,13 @@ pub mod ro {
     impl From<INodeType> for DirEntryType {
         fn from(value: INodeType) -> Self {
             match value {
+                INodeType::Fifo => DirEntryType::Fifo,
+                INodeType::Chr(_, _) => DirEntryType::Chr,
                 INodeType::Dir => DirEntryType::Dir,
+                INodeType::Blk(_, _) => DirEntryType::Blk,
                 INodeType::Reg => DirEntryType::Reg,
+                INodeType::Lnk => DirEntryType::Lnk,
+                INodeType::Sock => DirEntryType::Sock,
             }
         }
     }
@@ -280,6 +285,46 @@ pub mod ro {
                     unsafe { bindings::mapping_set_large_folios(inode.i_mapping) };
                     bindings::S_IFREG
                 }
+                INodeType::Lnk => {
+                    inode.i_op = &Tables::<T>::LNK_INODE_OPERATIONS;
+                    inode.i_data.a_ops = &Tables::<T>::FILE_ADDRESS_SPACE_OPERATIONS;
+
+                    // SAFETY: `inode` is valid for write as it's a new inode.
+                    unsafe { bindings::inode_nohighmem(inode) };
+                    bindings::S_IFLNK
+                }
+                INodeType::Fifo => {
+                    // SAFETY: `inode` is valid for write as it's a new inode.
+                    unsafe { bindings::init_special_inode(inode, bindings::S_IFIFO as _, 0) };
+                    bindings::S_IFIFO
+                }
+                INodeType::Sock => {
+                    // SAFETY: `inode` is valid for write as it's a new inode.
+                    unsafe { bindings::init_special_inode(inode, bindings::S_IFSOCK as _, 0) };
+                    bindings::S_IFSOCK
+                }
+                INodeType::Chr(major, minor) => {
+                    // SAFETY: `inode` is valid for write as it's a new inode.
+                    unsafe {
+                        bindings::init_special_inode(
+                            inode,
+                            bindings::S_IFCHR as _,
+                            bindings::MKDEV(major, minor & bindings::MINORMASK),
+                        )
+                    };
+                    bindings::S_IFCHR
+                }
+                INodeType::Blk(major, minor) => {
+                    // SAFETY: `inode` is valid for write as it's a new inode.
+                    unsafe {
+                        bindings::init_special_inode(
+                            inode,
+                            bindings::S_IFBLK as _,
+                            bindings::MKDEV(major, minor & bindings::MINORMASK),
+                        )
+                    };
+                    bindings::S_IFBLK
+                }
             };
 
             inode.i_mode = (params.mode & 0o777) | u16::try_from(mode)?;
@@ -315,11 +360,26 @@ pub mod ro {
     /// The type of the inode.
     #[derive(Copy, Clone)]
     pub enum INodeType {
+        /// Named pipe (first-in, first-out) type.
+        Fifo,
+
+        /// Character device type.
+        Chr(u32, u32),
+
         /// Directory type.
         Dir,
 
+        /// Block device type.
+        Blk(u32, u32),
+
         /// Regular file type.
         Reg,
+
+        /// Symbolic link type.
+        Lnk,
+
+        /// Named unix-domain socket type.
+        Sock,
     }
 
     /// Required inode parameters.
@@ -731,6 +791,34 @@ pub mod ro {
             }
         }
 
+        const LNK_INODE_OPERATIONS: bindings::inode_operations = bindings::inode_operations {
+            lookup: None,
+            get_link: Some(bindings::page_get_link),
+            permission: None,
+            get_inode_acl: None,
+            readlink: None,
+            create: None,
+            link: None,
+            unlink: None,
+            symlink: None,
+            mkdir: None,
+            rmdir: None,
+            mknod: None,
+            rename: None,
+            setattr: None,
+            getattr: None,
+            listxattr: None,
+            fiemap: None,
+            update_time: None,
+            atomic_open: None,
+            tmpfile: None,
+            get_acl: None,
+            set_acl: None,
+            fileattr_set: None,
+            fileattr_get: None,
+            get_offset_ctx: None,
+        };
+
         const FILE_ADDRESS_SPACE_OPERATIONS: bindings::address_space_operations =
             bindings::address_space_operations {
                 writepage: None,

samples/rust/rust_rofs.rs

@@ -23,7 +23,7 @@ struct Entry {
     contents: &'static [u8],
 }
 
-const ENTRIES: [Entry; 3] = [
+const ENTRIES: [Entry; 4] = [
     Entry {
         name: b".",
         ino: 1,
@@ -42,6 +42,12 @@ const ENTRIES: [Entry; 3] = [
         etype: INodeType::Reg,
         contents: b"hello\n",
     },
+    Entry {
+        name: b"link.txt",
+        ino: 3,
+        etype: INodeType::Lnk,
+        contents: b"./test.txt",
+    },
 ];
 
 struct RoFs;
@@ -129,6 +135,7 @@ impl fs::ro::Type for RoFs {
     fn read_folio(inode: &INode<Self>, mut folio: LockedFolio<'_>) -> Result {
         let data = match inode.ino() {
             2 => ENTRIES[2].contents,
+            3 => ENTRIES[3].contents,
             _ => return Err(EINVAL),
         };