ext2: directory entry iterator implementation

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

Author: Andy-Python-Programmer

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

@@ -20,6 +20,7 @@
 use core::mem::MaybeUninit;
 
 use alloc::boxed::Box;
+use alloc::string::ToString;
 use alloc::sync::{Arc, Weak};
 
 use crate::fs::cache::CachedINode;
@@ -197,10 +198,12 @@ impl DiskINode {
 
 const_assert_eq!(core::mem::size_of::<DiskINode>(), 128);
 
-struct INode {
+pub struct INode {
     id: usize,
     fs: Weak<Ext2>,
     inode: Box<DiskINode>,
+
+    sref: Weak<INode>,
 }
 
 impl INode {
@@ -238,15 +241,31 @@ impl INode {
             // SAFETY: We have initialized the inode above.
             let inode = unsafe { inode.assume_init() };
 
-            log::debug!("ino_table_index={ino_table_index:?} inode={inode:?}");
+            Some(
+                icache.make_item_cached(CachedINode::new(Arc::new_cyclic(|sref| Self {
+                    inode,
+                    id,
+                    fs: ext2,
 
-            Some(icache.make_item_cached(CachedINode::new(Arc::new(Self {
-                inode,
-                id,
-                fs: ext2,
-            }))))
+                    sref: sref.clone(),
+                }))),
+            )
         }
     }
+
+    pub fn sref(&self) -> Arc<INode> {
+        self.sref.upgrade().unwrap()
+    }
+
+    pub fn make_dir_entry(
+        &self,
+        parent: DirCacheItem,
+        name: &str,
+        entry: &DiskDirEntry,
+    ) -> Option<DirCacheItem> {
+        let inode = self.fs.upgrade()?.find_inode(entry.inode as usize)?;
+        Some(DirEntry::new(parent, inode, name.to_string()))
+    }
 }
 
 impl INodeInterface for INode {
@@ -262,6 +281,72 @@ impl INodeInterface for INode {
             children_len: 0,
         })
     }
+
+    fn dirent(&self, parent: DirCacheItem, index: usize) -> super::Result<Option<DirCacheItem>> {
+        Ok(DirEntryIter::new(parent, self.sref()).nth(index))
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C, packed)]
+pub struct DiskDirEntry {
+    inode: u32,
+    entry_size: u16,
+    name_size: u8,
+    file_type: u8,
+}
+
+pub struct DirEntryIter {
+    parent: DirCacheItem,
+    inode: Arc<INode>,
+    offset: usize,
+}
+
+impl DirEntryIter {
+    pub fn new(parent: DirCacheItem, inode: Arc<INode>) -> Self {
+        Self {
+            parent,
+            inode,
+
+            offset: 0,
+        }
+    }
+}
+
+impl Iterator for DirEntryIter {
+    type Item = DirCacheItem;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let filesystem = self.inode.fs.upgrade()?;
+        let file_size = self.inode.inode.size_lower as usize;
+
+        if self.offset + core::mem::size_of::<DiskDirEntry>() > file_size {
+            return None;
+        }
+
+        let mut entry = Box::<DiskDirEntry>::new_uninit();
+
+        let offset = (self.inode.inode.data_ptr[0] as usize * filesystem.superblock.block_size())
+            + self.offset;
+
+        filesystem.block.device().read(offset, entry.as_bytes_mut());
+
+        // SAFETY: We have initialized the entry above.
+        let entry = unsafe { entry.assume_init() };
+
+        let mut name = Box::<[u8]>::new_uninit_slice(entry.name_size as usize);
+        filesystem.block.device().read(
+            offset + core::mem::size_of::<DiskDirEntry>(),
+            MaybeUninit::slice_as_bytes_mut(&mut name),
+        );
+
+        // SAFETY: We have initialized the name above.
+        let name = unsafe { name.assume_init() };
+        let name = unsafe { core::str::from_utf8_unchecked(&*name) };
+
+        self.offset += entry.entry_size as usize;
+        self.inode.make_dir_entry(self.parent.clone(), name, &entry)
+    }
 }
 
 pub struct Ext2 {

tools/mkimage.sh

@@ -0,0 +1,20 @@
+# XXX: fucking hell andy. you had a reminder to not commit this
+# file. you did. you fucking did. you're a fucking idiot. move
+# this shit to aero.py.
+
+rm -rf disk.img
+
+dd if=/dev/zero bs=1M count=0 seek=512 of=disk.img
+parted -s disk.img mklabel gpt
+parted -s disk.img mkpart primary 2048s 100%
+sudo losetup -Pf --show disk.img > loopback_dev
+sudo mkfs.ext2 `cat loopback_dev`p1
+rm -rf disk_image/
+mkdir disk_image
+sudo mount `cat loopback_dev`p1 disk_image
+sudo cp aero.py disk_image/aero.py
+sync
+sudo umount disk_image/
+sudo losetup -d `cat loopback_dev`
+sync
+rm -rf loopback_dev