ext2: read the BGDT and get the root inode

* read the BGDT (Block Group Descriptor Table)
* get the root inode
* read the inode table for ^^^

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/fs/block/gpt.rs

@@ -1,3 +1,22 @@
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
 use super::BlockDevice;
 use core::mem::MaybeUninit;
 

src/aero_kernel/src/fs/block/mod.rs

@@ -1,3 +1,22 @@
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+
 mod gpt;
 
 use gpt::Gpt;

src/aero_kernel/src/fs/cache.rs

@@ -39,6 +39,8 @@ use spin::Once;
 use crate::fs::inode::{DirEntry, INodeInterface};
 use crate::utils::sync::Mutex;
 
+use super::FileSystem;
+
 pub(super) static INODE_CACHE: Once<Arc<INodeCache>> = Once::new();
 pub(super) static DIR_CACHE: Once<Arc<DirCache>> = Once::new();
 
@@ -291,10 +293,13 @@ impl ops::Deref for CachedINode {
 
 impl Cacheable<INodeCacheKey> for CachedINode {
     fn cache_key(&self) -> INodeCacheKey {
-        (
-            Weak::as_ptr(&self.weak_filesystem().unwrap()) as *const () as usize,
-            self.metadata().unwrap().id,
-        )
+        INodeCacheItem::make_key(self.weak_filesystem().unwrap(), self.metadata().unwrap().id)
+    }
+}
+
+impl INodeCacheItem {
+    pub fn make_key(fs: Weak<dyn FileSystem>, id: usize) -> INodeCacheKey {
+        (Weak::as_ptr(&fs) as *const () as usize, id)
     }
 }
 

src/aero_kernel/src/fs/ext2/mod.rs

@@ -1,6 +1,36 @@
-use alloc::{boxed::Box, sync::Arc};
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
 
-use super::{block::BlockDevice, FileSystem};
+use core::mem::MaybeUninit;
+
+use alloc::boxed::Box;
+use alloc::sync::{Arc, Weak};
+
+use crate::utils::CeilDiv;
+
+use super::block::BlockDevice;
+
+use super::cache;
+use super::cache::{CachedINode, DirCacheItem, INodeCacheItem};
+
+use super::inode::{DirEntry, INodeInterface, Metadata};
+use super::FileSystem;
 
 #[derive(Debug, Copy, Clone)]
 #[repr(C, packed)]
@@ -61,26 +91,223 @@ pub struct SuperBlock {
     pub jnl_blocks: [u32; 17usize],
 }
 
-pub struct Ext2 {}
+impl SuperBlock {
+    const MAGIC: u16 = 0xef53;
+
+    /// Returns the size of a block in bytes.
+    pub fn block_size(&self) -> usize {
+        1024usize << self.log_block_size
+    }
+
+    /// Returns the length of the BGDT.
+    pub fn bgdt_len(&self) -> usize {
+        self.blocks_count.ceil_div(self.blocks_per_group) as usize
+    }
+
+    /// Returns the sector where the BGDT starts.
+    pub fn bgdt_sector(&self) -> usize {
+        // XXX: The block group descriptors are always located in the block immediately
+        // following the superblock.
+        match self.block_size() {
+            1024 => 4,
+            x if x > 1024 => x / 512,
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct GroupDescriptor {
+    pub block_bitmap: u32,
+    pub inode_bitmap: u32,
+    pub inode_table: u32,
+    pub free_blocks_count: u16,
+    pub free_inodes_count: u16,
+    pub used_dirs_count: u16,
+    pub pad: u16,
+    pub reserved: [u8; 12usize],
+}
+
+const_assert_eq!(core::mem::size_of::<GroupDescriptor>(), 32);
+
+pub enum FileType {
+    Fifo,
+    CharDev,
+    Directory,
+    BlockDev,
+    File,
+    Symlink,
+    Socket,
+    Unknown,
+}
+
+impl From<FileType> for super::inode::FileType {
+    fn from(ty: FileType) -> Self {
+        match ty {
+            FileType::Symlink => Self::Symlink,
+            FileType::Directory => Self::Directory,
+            FileType::BlockDev | FileType::CharDev => Self::Device,
+
+            _ => Self::File,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct DiskINode {
+    type_and_perm: u16,
+    pub user_id: u16,
+    pub size_lower: u32,
+    pub last_access: u32,
+    pub creation_time: u32,
+    pub last_modification: u32,
+    pub deletion_time: u32,
+    pub group_id: u16,
+    pub hl_count: u16,
+    pub sector_count: u32,
+    pub flags: u32,
+    pub os_specific: u32,
+    pub data_ptr: [u32; 15],
+    pub gen_number: u32,
+    pub ext_attr_block: u32,
+    pub size_or_acl: u32,
+    pub fragment_address: u32,
+    pub os_specific2: [u8; 12],
+}
+
+impl DiskINode {
+    pub fn file_type(&self) -> FileType {
+        let ty = self.type_and_perm >> 12;
+
+        match ty {
+            0x1 => FileType::Fifo,
+            0x2 => FileType::CharDev,
+            0x4 => FileType::Directory,
+            0x6 => FileType::BlockDev,
+            0x8 => FileType::File,
+            0xa => FileType::Symlink,
+            0xc => FileType::Socket,
+            _ => FileType::Unknown,
+        }
+    }
+}
+
+const_assert_eq!(core::mem::size_of::<DiskINode>(), 128);
+
+struct INode {
+    id: usize,
+    fs: Weak<Ext2>,
+    inode: Box<DiskINode>,
+}
+
+impl INode {
+    pub fn new(ext2: Weak<Ext2>, id: usize) -> Option<INodeCacheItem> {
+        debug_assert!(id != 0);
+
+        let icache = cache::icache();
+
+        // Check if the inode is in the cache.
+        if let Some(inode) = icache.get(INodeCacheItem::make_key(ext2.clone(), id)) {
+            Some(inode)
+        } else {
+            let fs = ext2.upgrade()?;
+
+            let inode_block_group = (id - 1) / fs.superblock.inodes_per_group as usize;
+            let inode_table_idx = (id - 1) % fs.superblock.inodes_per_group as usize;
+
+            let group_descriptor = &fs.bgdt[inode_block_group];
+            let inode_size = core::mem::size_of::<DiskINode>(); // TODO: the inode size can be different
+
+            let table_offset = group_descriptor.inode_table as usize * fs.superblock.block_size();
+            let inode_offset = table_offset + (inode_size * inode_table_idx);
+
+            let mut inode = Box::<DiskINode>::new_uninit();
+            fs.block
+                .device()
+                .read(inode_offset / 512, inode.as_bytes_mut());
+
+            // SAFETY: We have initialized the inode above.
+            let inode = unsafe { inode.assume_init() };
+
+            Some(icache.make_item_cached(CachedINode::new(Arc::new(Self {
+                inode,
+                id,
+                fs: ext2,
+            }))))
+        }
+    }
+}
+
+impl INodeInterface for INode {
+    fn weak_filesystem(&self) -> Option<Weak<dyn FileSystem>> {
+        Some(self.fs.clone())
+    }
+
+    fn metadata(&self) -> super::Result<Metadata> {
+        Ok(Metadata {
+            id: self.id,
+            file_type: self.inode.file_type().into(),
+            size: self.inode.size_lower as _,
+            children_len: 0,
+        })
+    }
+}
+
+pub struct Ext2 {
+    superblock: Box<SuperBlock>,
+    bgdt: Box<[GroupDescriptor]>,
+    block: Arc<BlockDevice>,
+
+    sref: Weak<Self>,
+}
 
 impl Ext2 {
-    pub fn new(device: Arc<BlockDevice>) -> Option<Arc<Self>> {
+    const ROOT_INODE_ID: usize = 2;
+
+    pub fn new(block: Arc<BlockDevice>) -> Option<Arc<Self>> {
         let mut superblock = Box::<SuperBlock>::new_uninit();
-        device.device().read(2, superblock.as_bytes_mut())?;
+        block.device().read(2, superblock.as_bytes_mut())?;
 
         // SAFETY: We have initialized the superblock above.
         let superblock = unsafe { superblock.assume_init() };
 
-        if superblock.magic != 0xef53 {
+        if superblock.magic != SuperBlock::MAGIC {
             return None;
         }
 
-        Some(Arc::new(Self {}))
+        let bgdt_len = superblock.bgdt_len();
+        let mut bgdt = Box::<[GroupDescriptor]>::new_uninit_slice(bgdt_len);
+
+        block.device().read(
+            superblock.bgdt_sector(),
+            MaybeUninit::slice_as_bytes_mut(&mut bgdt),
+        )?;
+
+        // SAFETY: We have initialized the BGD (Block Group Descriptor Table) above.
+        let bgdt = unsafe { bgdt.assume_init() };
+
+        Some(Arc::new_cyclic(|sref| Self {
+            bgdt,
+            superblock,
+            block,
+
+            sref: sref.clone(),
+        }))
+    }
+
+    pub fn find_inode(&self, id: usize) -> Option<INodeCacheItem> {
+        INode::new(self.sref.clone(), id)
     }
 }
 
 impl FileSystem for Ext2 {
-    fn root_dir(&self) -> super::cache::DirCacheItem {
-        todo!()
+    fn root_dir(&self) -> DirCacheItem {
+        let inode = self
+            .find_inode(Ext2::ROOT_INODE_ID)
+            .expect("ext2: invalid filesystem (root inode not found)");
+
+        DirEntry::new_root(inode, String::from("/"))
     }
 }

src/aero_kernel/src/fs/inode.rs

@@ -256,13 +256,7 @@ pub trait INodeInterface: Send + Sync {
 pub struct Metadata {
     pub id: usize,
     pub file_type: FileType,
-
-    /// The total size of the content that the inode holds. Set to `0x00` if
-    /// the inode file type is *not* a file.
     pub size: usize,
-
-    /// The length of the children's map of the inode. Set to `0x00` if the inode
-    /// has no children and if the file type of the inode is *not* a directory.
     pub children_len: usize,
 }
 
@@ -330,15 +324,17 @@ pub enum FileType {
     Directory,
     Device,
     Socket,
+    Symlink,
 }
 
 impl From<FileType> for aero_syscall::SysFileType {
     fn from(file: FileType) -> Self {
         match file {
             FileType::File => aero_syscall::SysFileType::File,
             FileType::Directory => aero_syscall::SysFileType::Directory,
-            FileType::Device => aero_syscall::SysFileType::Device,
+            FileType::Device => aero_syscall::SysFileType::CharDevice, // FIXME: determine if it is a character or block device.
             FileType::Socket => aero_syscall::SysFileType::Socket,
+            FileType::Symlink => aero_syscall::SysFileType::Symlink,
         }
     }
 }

src/aero_syscall/src/lib.rs

@@ -241,10 +241,14 @@ pub fn syscall_as_str(syscall: usize) -> &'static str {
 #[derive(Debug)]
 #[repr(usize)]
 pub enum SysFileType {
-    File,
-    Directory,
-    Device,
-    Socket,
+    Unknown = 0,
+    Fifo = 1,
+    CharDevice = 2,
+    Directory = 4,
+    BlockDevice = 6,
+    File = 8,
+    Symlink = 10,
+    Socket = 12,
 }
 
 #[repr(C, packed)]