GKaszewski/k-os
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(ext4): remove old monolithic ext4.rs superseded by ext4/ directory

Browse Source
This commit is contained in:
Gabriel Kaszewski
2026-10-18 23:30:56 +02:00
parent 9be67e403b
commit 194024bc08
1 changed files with 0 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

345
crates/servers/storage-server/src/fs/ext4.rs
View File

@@ -1,345 +0,0 @@
use port_block_device::{BlockDevice, SectorId};
use crate::filesystem::{DirEntry, FileHandle, FileName, FileSystem};
const SECTOR_SIZE: usize = 512;
const SUPERBLOCK_OFFSET: usize = 1024;
const EXT4_MAGIC: u16 = 0xEF53;
const ROOT_INODE: u32 = 2;
const MAX_OPEN_FILES: usize = 8;
const EXTENT_MAGIC: u16 = 0xF30A;
struct Superblock {
inodes_count: u32,
blocks_count: u32,
block_size: usize,
blocks_per_group: u32,
inodes_per_group: u32,
inode_size: u16,
first_data_block: u32,
}
impl Superblock {
fn parse(data: &[u8]) -> Option<Self> {
if data.len() < 256 { return None; }
let magic = u16::from_le_bytes([data[0x38], data[0x39]]);
if magic != EXT4_MAGIC { return None; }
let log_block_size = u32::from_le_bytes([data[0x18], data[0x19], data[0x1A], data[0x1B]]);
Some(Self {
inodes_count: read_u32(data, 0x00),
blocks_count: read_u32(data, 0x04),
block_size: 1024 << log_block_size,
blocks_per_group: read_u32(data, 0x20),
inodes_per_group: read_u32(data, 0x28),
inode_size: u16::from_le_bytes([data[0x58], data[0x59]]),
first_data_block: read_u32(data, 0x14),
})
}
fn sectors_per_block(&self) -> usize {
self.block_size / SECTOR_SIZE
}
fn inode_block_group(&self, inode: u32) -> u32 {
(inode - 1) / self.inodes_per_group
}
fn inode_index_in_group(&self, inode: u32) -> u32 {
(inode - 1) % self.inodes_per_group
}
}
struct Inode {
mode: u16,
size: u64,
flags: u32,
block_data: [u8; 60],
}
impl Inode {
fn is_dir(&self) -> bool { self.mode & 0xF000 == 0x4000 }
fn is_file(&self) -> bool { self.mode & 0xF000 == 0x8000 }
fn uses_extents(&self) -> bool { self.flags & 0x80000 != 0 }
}
#[derive(Clone, Copy)]
struct Extent {
logical_block: u32,
length: u16,
physical_block: u64,
}
impl Extent {
fn parse(data: &[u8]) -> Self {
let start_hi = u16::from_le_bytes([data[6], data[7]]) as u64;
let start_lo = read_u32(data, 8) as u64;
Self {
logical_block: read_u32(data, 0),
length: u16::from_le_bytes([data[4], data[5]]),
physical_block: (start_hi << 32) | start_lo,
}
}
}
#[derive(Clone, Copy)]
struct OpenFile {
inode_num: u32,
size: usize,
offset: usize,
name: FileName,
first_extent: Extent,
}
pub struct Ext4<B: BlockDevice> {
device: B,
sb: Superblock,
gdt_block: u32,
open_files: [Option<OpenFile>; MAX_OPEN_FILES],
}
impl<B: BlockDevice> Ext4<B> {
pub fn mount(mut device: B) -> Option<Self> {
let mut buf = [0u8; 1024];
// Superblock starts at byte 1024 = sector 2
if !device.read_sector(SectorId::new(2), &mut buf[..512]) { return None; }
if !device.read_sector(SectorId::new(3), &mut buf[512..]) { return None; }
let sb = Superblock::parse(&buf)?;
let gdt_block = sb.first_data_block + 1;
Some(Self {
device,
sb,
gdt_block,
open_files: [const { None }; MAX_OPEN_FILES],
})
}
fn read_block(&mut self, block: u64, buf: &mut [u8]) -> bool {
let start_sector = (block as usize) * self.sb.sectors_per_block();
let spb = self.sb.sectors_per_block();
for i in 0..spb {
let offset = i * SECTOR_SIZE;
if offset + SECTOR_SIZE > buf.len() { break; }
if !self.device.read_sector(
SectorId::new((start_sector + i) as u32),
&mut buf[offset..offset + SECTOR_SIZE],
) {
return false;
}
}
true
}
fn read_inode(&mut self, inode_num: u32) -> Option<Inode> {
let bg = self.sb.inode_block_group(inode_num);
let index = self.sb.inode_index_in_group(inode_num);
// Read block group descriptor
let mut gdt_buf = [0u8; 4096];
self.read_block(self.gdt_block as u64, &mut gdt_buf);
let gd_offset = (bg as usize) * 32;
let inode_table_block = read_u32(&gdt_buf, gd_offset + 8);
// Calculate inode position
let inode_offset = (index as usize) * (self.sb.inode_size as usize);
let block_offset = inode_offset / self.sb.block_size;
let offset_in_block = inode_offset % self.sb.block_size;
let mut block_buf = [0u8; 4096];
self.read_block((inode_table_block + block_offset as u32) as u64, &mut block_buf);
let d = &block_buf[offset_in_block..];
if d.len() < 128 { return None; }
let size_lo = read_u32(d, 0x04) as u64;
let size_hi = read_u32(d, 0x6C) as u64;
let size = size_lo | (size_hi << 32);
let mut block_data = [0u8; 60];
block_data.copy_from_slice(&d[0x28..0x64]);
Some(Inode {
mode: u16::from_le_bytes([d[0x00], d[0x01]]),
size,
flags: read_u32(d, 0x20),
block_data,
})
}
fn read_extents(&self, inode: &Inode) -> Option<Extent> {
if !inode.uses_extents() { return None; }
let hdr = &inode.block_data;
let magic = u16::from_le_bytes([hdr[0], hdr[1]]);
if magic != EXTENT_MAGIC { return None; }
let entries = u16::from_le_bytes([hdr[2], hdr[3]]);
let depth = u16::from_le_bytes([hdr[6], hdr[7]]);
if depth != 0 || entries == 0 { return None; }
Some(Extent::parse(&hdr[12..24]))
}
fn find_in_dir(&mut self, dir_inode: u32, name: &[u8]) -> Option<u32> {
let inode = self.read_inode(dir_inode)?;
if !inode.is_dir() { return None; }
let extent = self.read_extents(&inode)?;
let mut block_buf = [0u8; 4096];
for blk in 0..extent.length as u64 {
self.read_block(extent.physical_block + blk, &mut block_buf);
let mut pos = 0;
while pos + 8 <= self.sb.block_size {
let entry_inode = read_u32(&block_buf, pos);
let rec_len = u16::from_le_bytes([block_buf[pos + 4], block_buf[pos + 5]]) as usize;
let name_len = block_buf[pos + 6] as usize;
if rec_len == 0 { break; }
if entry_inode != 0 && name_len == name.len() {
if &block_buf[pos + 8..pos + 8 + name_len] == name {
return Some(entry_inode);
}
}
pos += rec_len;
}
}
None
}
fn resolve_path(&mut self, path: &[u8]) -> Option<u32> {
let mut current = ROOT_INODE;
for component in path.split(|&b| b == b'/') {
if component.is_empty() { continue; }
current = self.find_in_dir(current, component)?;
}
Some(current)
}
fn alloc_handle(&self) -> Option<FileHandle> {
for i in 0..MAX_OPEN_FILES {
if self.open_files[i].is_none() {
return Some(FileHandle::new(i as u16));
}
}
None
}
}
impl<B: BlockDevice> FileSystem for Ext4<B> {
fn open(&mut self, path: &[u8]) -> Option<FileHandle> {
let inode_num = self.resolve_path(path)?;
let inode = self.read_inode(inode_num)?;
if !inode.is_file() { return None; }
let extent = self.read_extents(&inode)?;
let handle = self.alloc_handle()?;
self.open_files[handle.raw() as usize] = Some(OpenFile {
inode_num,
size: inode.size as usize,
offset: 0,
name: FileName::from_bytes(path),
first_extent: extent,
});
Some(handle)
}
fn read(&mut self, handle: FileHandle, buf: &mut [u8]) -> Option<usize> {
let file = *self.open_files[handle.raw() as usize].as_ref()?;
if file.offset >= file.size { return Some(0); }
let remaining = file.size - file.offset;
let to_read = buf.len().min(remaining);
let bs = self.sb.block_size;
let block_in_extent = file.offset / bs;
let byte_in_block = file.offset % bs;
let mut block_buf = [0u8; 4096];
let phys_block = file.first_extent.physical_block + block_in_extent as u64;
self.read_block(phys_block, &mut block_buf);
let available = bs - byte_in_block;
let chunk = to_read.min(available);
buf[..chunk].copy_from_slice(&block_buf[byte_in_block..byte_in_block + chunk]);
self.open_files[handle.raw() as usize].as_mut().map(|f| f.offset += chunk);
Some(chunk)
}
fn write(&mut self, _handle: FileHandle, _buf: &[u8]) -> Option<usize> {
// Write requires block allocation + inode update + extent modification
// Deferred: needs block bitmap management
None
}
fn close(&mut self, handle: FileHandle) {
self.open_files[handle.raw() as usize] = None;
}
fn list_dir(&mut self, path: &[u8], entries: &mut [DirEntry]) -> Option<usize> {
let dir_inode_num = if path.is_empty() || path == b"/" {
ROOT_INODE
} else {
self.resolve_path(path)?
};
let inode = self.read_inode(dir_inode_num)?;
if !inode.is_dir() { return None; }
let extent = self.read_extents(&inode)?;
let mut block_buf = [0u8; 4096];
let mut count = 0;
for blk in 0..extent.length as u64 {
self.read_block(extent.physical_block + blk, &mut block_buf);
let mut pos = 0;
while pos + 8 <= self.sb.block_size && count < entries.len() {
let entry_inode = read_u32(&block_buf, pos);
let rec_len = u16::from_le_bytes([block_buf[pos + 4], block_buf[pos + 5]]) as usize;
let name_len = block_buf[pos + 6] as usize;
let file_type = block_buf[pos + 7];
if rec_len == 0 { break; }
if entry_inode != 0 && name_len > 0 {
let name = &block_buf[pos + 8..pos + 8 + name_len];
if name != b"." && name != b".." {
let child_size = if file_type == 1 {
self.read_inode(entry_inode)
.map(|i| i.size as usize)
.unwrap_or(0)
} else { 0 };
entries[count] = DirEntry {
name: FileName::from_bytes(name),
size: child_size,
is_dir: file_type == 2,
};
count += 1;
}
}
pos += rec_len;
}
}
Some(count)
}
fn create(&mut self, _path: &[u8]) -> Option<FileHandle> {
// Create requires inode allocation + directory entry insertion
// Deferred: needs inode bitmap management
None
}
fn delete(&mut self, _path: &[u8]) -> bool {
// Delete requires inode deallocation + directory entry removal
false
}
fn file_size(&mut self, handle: FileHandle) -> Option<usize> {
self.open_files[handle.raw() as usize].as_ref().map(|f| f.size)
}
fn mkdir(&mut self, _path: &[u8]) -> bool { false }
}
fn read_u32(data: &[u8], offset: usize) -> u32 {
u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])
}