ext2: file creation

* file creation

* block allocation

* inode allocation

* fix wrong offset being set in the page cache

* appending a block to the inode

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

Author: Andy-Python-Programmer

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

@@ -107,7 +107,7 @@ impl Cache<PageCacheKey, CachedPage> {
             return page;
         }
 
-        let page = CachedPage::new(device.clone(), offset);
+        let page = CachedPage::new(device.clone(), cache_offset);
         let device = device.upgrade().expect("page_cache: device dropped");
 
         let aligned_offset = align_down(offset as u64, Size4KiB::SIZE) as usize;
@@ -145,8 +145,10 @@ pub trait CachedAccess: BlockDeviceInterface {
             let data = &page.data_mut()[page_offset..page_offset + size];
             dest[loc..loc + size].copy_from_slice(data);
 
+            core::mem::forget(page);
+
             loc += size;
-            offset += align_down(offset as u64 + Size4KiB::SIZE, Size4KiB::SIZE) as usize;
+            offset = align_down(offset as u64 + Size4KiB::SIZE, Size4KiB::SIZE) as usize;
         }
 
         Some(loc)
@@ -172,8 +174,10 @@ pub trait CachedAccess: BlockDeviceInterface {
                 &buffer[loc..loc + size],
             );
 
+            core::mem::forget(page);
+
             loc += size;
-            offset += align_down(offset as u64 + Size4KiB::SIZE, Size4KiB::SIZE) as usize;
+            offset = align_down(offset as u64 + Size4KiB::SIZE, Size4KiB::SIZE) as usize;
         }
 
         Some(loc)
@@ -305,12 +309,6 @@ impl BlockDeviceInterface for PartitionBlockDevice {
     }
 }
 
-impl CachedAccess for PartitionBlockDevice {
-    fn sref(&self) -> Weak<dyn CachedAccess> {
-        self.sref.clone()
-    }
-}
-
 pub fn launch() -> Result<()> {
     let mut blocks_copy = Vec::<Arc<BlockDevice>>::new();
 

src/aero_kernel/src/fs/ext2/disk.rs

@@ -0,0 +1,187 @@
+use crate::utils::CeilDiv;
+
+use super::FileType;
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C, packed)]
+pub struct SuperBlock {
+    pub inodes_count: u32,
+    pub blocks_count: u32,
+    pub r_blocks_count: u32,
+    pub free_blocks_count: u32,
+    pub free_inodes_count: u32,
+    pub first_data_block: u32,
+    pub log_block_size: u32,
+    pub log_frag_size: u32,
+    pub blocks_per_group: u32,
+    pub frags_per_group: u32,
+    pub inodes_per_group: u32,
+    pub mtime: u32,
+    pub wtime: u32,
+    pub mnt_count: u16,
+    pub max_mnt_count: u16,
+    pub magic: u16,
+    pub state: u16,
+    pub errors: u16,
+    pub minor_rev_level: u16,
+    pub lastcheck: u32,
+    pub checkinterval: u32,
+    pub creator_os: u32,
+    pub rev_level: u32,
+    pub def_resuid: u16,
+    pub def_gid: u16,
+
+    // Extended Superblock fields
+    //
+    // XXX: If version number >= 1, we have to use the ext2 extended superblock as well :)
+    pub first_ino: u32,
+    pub inode_size: u16,
+    pub block_group_nr: u16,
+    pub feature_compat: u32,
+    pub feature_incompat: u32,
+    pub feature_ro_compat: u32,
+    pub uuid: [u64; 2usize],
+    pub volume_name: [u8; 16usize],
+    pub last_mounted: [u64; 8usize],
+    pub compression_info: u32,
+    pub prealloc_blocks: u8,
+    pub prealloc_dir_blocks: u8,
+    pub reserved_gdt_blocks: u16,
+    pub journal_uuid: [u8; 16usize],
+    pub journal_inum: u32,
+    pub journal_dev: u32,
+    pub last_orphan: u32,
+    pub hash_seed: [u32; 4usize],
+    pub def_hash_version: u8,
+    pub jnl_backup_type: u8,
+    pub group_desc_size: u16,
+    pub default_mount_opts: u32,
+    pub first_meta_bg: u32,
+    pub mkfs_time: u32,
+    pub jnl_blocks: [u32; 17usize],
+}
+
+impl SuperBlock {
+    pub const MAGIC: u16 = 0xef53;
+
+    /// Returns the number of entries per block.
+    pub fn entries_per_block(&self) -> usize {
+        self.block_size() / core::mem::size_of::<u32>()
+    }
+
+    /// 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
+    }
+
+    pub fn bgdt_block(&self) -> usize {
+        // XXX: The block group descriptors are always located in the block immediately
+        // following the superblock.
+        let block_size = self.block_size();
+
+        if block_size >= 2048 {
+            block_size
+        } else {
+            block_size * 2
+        }
+    }
+}
+
+#[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);
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C, packed)]
+pub struct DirEntry {
+    pub inode: u32,
+    pub entry_size: u16,
+    pub name_size: u8,
+    pub file_type: u8,
+}
+
+impl DirEntry {
+    pub fn set_name(&mut self, name: &str) {
+        assert!(name.len() < u8::MAX as usize);
+
+        self.name_size = name.len() as u8;
+
+        // SAFETY: Above we have verified that the name will fit in the entry.
+        let name_ptr = unsafe { (self as *mut _ as *mut u8).add(core::mem::size_of::<Self>()) };
+        let name_bytes = unsafe { core::slice::from_raw_parts_mut(name_ptr, name.len()) };
+
+        name_bytes.copy_from_slice(name.as_bytes());
+    }
+
+    pub fn avaliable_size(&self) -> usize {
+        if self.inode == 0 {
+            self.entry_size as usize
+        } else {
+            0
+        }
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        unsafe {
+            core::slice::from_raw_parts(self as *const Self as *const u8, self.entry_size as usize)
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct INode {
+    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 block_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 INode {
+    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::<INode>(), 128);