use std::mem::size_of;
use crate::error::{MinixError, Result};
pub const BLOCK_SIZE: usize = 1024;
pub const MINIX_NAME_LENGTH: usize = 14;
pub const MINIX_SUPER_MAGIC: u16 = 0x137F;
pub const ROOT_INODE_NUMBER: u16 = 1;
pub const DIRECT_ZONE_COUNT: usize = 7;
pub const INDIRECT_ENTRY_COUNT: usize = BLOCK_SIZE / size_of::<u16>();
pub const DISK_INODE_SIZE: usize = 32;
pub const DISK_SUPER_BLOCK_SIZE: usize = 20;
pub const DIRECTORY_ENTRY_SIZE: usize = 16;
pub const INODES_PER_BLOCK: usize = BLOCK_SIZE / DISK_INODE_SIZE;
pub const MAX_LOGICAL_BLOCKS: usize =
DIRECT_ZONE_COUNT + INDIRECT_ENTRY_COUNT + INDIRECT_ENTRY_COUNT * INDIRECT_ENTRY_COUNT;
pub const MAX_FILE_SIZE: u32 = (MAX_LOGICAL_BLOCKS * BLOCK_SIZE) as u32;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum InodeType {
Regular,
Directory,
Fifo,
BlockDevice,
CharacterDevice,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct InodeModeFlags(pub u16);
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(transparent)]
pub struct InodeMode(pub u16);
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub struct DiskSuperBlock {
pub inode_count: u16,
pub zone_count: u16,
pub inode_bitmap_block_count: u16,
pub zone_bitmap_block_count: u16,
pub first_data_zone: u16,
pub log_zone_size: u16,
pub max_file_size: u32,
pub magic: u16,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub struct DiskInode {
pub mode: InodeMode,
pub user_id: u16,
pub size: u32,
pub modification_time: u32,
pub group_id: u8,
pub link_count: u8,
pub direct_zones: [u16; DIRECT_ZONE_COUNT],
pub single_indirect_zone: u16,
pub double_indirect_zone: u16,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub struct DiskDirectoryEntry {
pub inode_number: u16,
pub name: [u8; MINIX_NAME_LENGTH],
}
impl InodeModeFlags {
pub const MASK: u16 = 0o007777;
}
impl InodeMode {
pub const TYPE_MASK: u16 = 0o170000;
pub const FLAGS_MASK: u16 = InodeModeFlags::MASK;
pub const fn regular(permissions: u16) -> Self {
Self(0o100000 | (permissions & Self::FLAGS_MASK))
}
pub const fn directory(permissions: u16) -> Self {
Self(0o040000 | (permissions & Self::FLAGS_MASK))
}
pub const fn file_type(self) -> Option<InodeType> {
match self.0 & Self::TYPE_MASK {
0o100000 => Some(InodeType::Regular),
0o040000 => Some(InodeType::Directory),
0o010000 => Some(InodeType::Fifo),
0o060000 => Some(InodeType::BlockDevice),
0o020000 => Some(InodeType::CharacterDevice),
_ => None,
}
}
pub const fn flags(self) -> InodeModeFlags {
InodeModeFlags(self.0 & Self::FLAGS_MASK)
}
}
impl DiskSuperBlock {
pub fn decode(block: &[u8; BLOCK_SIZE]) -> Result<Self> {
let bytes = &block[..DISK_SUPER_BLOCK_SIZE];
Ok(Self {
inode_count: read_u16(bytes, 0)?,
zone_count: read_u16(bytes, 2)?,
inode_bitmap_block_count: read_u16(bytes, 4)?,
zone_bitmap_block_count: read_u16(bytes, 6)?,
first_data_zone: read_u16(bytes, 8)?,
log_zone_size: read_u16(bytes, 10)?,
max_file_size: read_u32(bytes, 12)?,
magic: read_u16(bytes, 16)?,
})
}
pub fn encode(self, block: &mut [u8; BLOCK_SIZE]) {
write_u16(block, 0, self.inode_count);
write_u16(block, 2, self.zone_count);
write_u16(block, 4, self.inode_bitmap_block_count);
write_u16(block, 6, self.zone_bitmap_block_count);
write_u16(block, 8, self.first_data_zone);
write_u16(block, 10, self.log_zone_size);
write_u32(block, 12, self.max_file_size);
write_u16(block, 16, self.magic);
}
}
impl DiskInode {
pub const fn zeroed() -> Self {
Self {
mode: InodeMode(0),
user_id: 0,
size: 0,
modification_time: 0,
group_id: 0,
link_count: 0,
direct_zones: [0; DIRECT_ZONE_COUNT],
single_indirect_zone: 0,
double_indirect_zone: 0,
}
}
pub const fn is_zeroed(&self) -> bool {
self.mode.0 == 0
&& self.user_id == 0
&& self.size == 0
&& self.modification_time == 0
&& self.group_id == 0
&& self.link_count == 0
&& self.direct_zones[0] == 0
&& self.direct_zones[1] == 0
&& self.direct_zones[2] == 0
&& self.direct_zones[3] == 0
&& self.direct_zones[4] == 0
&& self.direct_zones[5] == 0
&& self.direct_zones[6] == 0
&& self.single_indirect_zone == 0
&& self.double_indirect_zone == 0
}
pub fn decode(bytes: &[u8]) -> Result<Self> {
if bytes.len() < DISK_INODE_SIZE {
return Err(MinixError::Corrupt(
"inode slot is shorter than the Minix inode size".into(),
));
}
Ok(Self {
mode: InodeMode(read_u16(bytes, 0)?),
user_id: read_u16(bytes, 2)?,
size: read_u32(bytes, 4)?,
modification_time: read_u32(bytes, 8)?,
group_id: bytes[12],
link_count: bytes[13],
direct_zones: [
read_u16(bytes, 14)?,
read_u16(bytes, 16)?,
read_u16(bytes, 18)?,
read_u16(bytes, 20)?,
read_u16(bytes, 22)?,
read_u16(bytes, 24)?,
read_u16(bytes, 26)?,
],
single_indirect_zone: read_u16(bytes, 28)?,
double_indirect_zone: read_u16(bytes, 30)?,
})
}
pub fn encode(self, bytes: &mut [u8]) {
write_u16(bytes, 0, self.mode.0);
write_u16(bytes, 2, self.user_id);
write_u32(bytes, 4, self.size);
write_u32(bytes, 8, self.modification_time);
bytes[12] = self.group_id;
bytes[13] = self.link_count;
write_u16(bytes, 14, self.direct_zones[0]);
write_u16(bytes, 16, self.direct_zones[1]);
write_u16(bytes, 18, self.direct_zones[2]);
write_u16(bytes, 20, self.direct_zones[3]);
write_u16(bytes, 22, self.direct_zones[4]);
write_u16(bytes, 24, self.direct_zones[5]);
write_u16(bytes, 26, self.direct_zones[6]);
write_u16(bytes, 28, self.single_indirect_zone);
write_u16(bytes, 30, self.double_indirect_zone);
}
}
impl DiskDirectoryEntry {
pub const fn empty() -> Self {
Self {
inode_number: 0,
name: [0; MINIX_NAME_LENGTH],
}
}
pub fn new(name: &str, inode_number: u16) -> Result<Self> {
if name.len() > MINIX_NAME_LENGTH {
return Err(MinixError::NameTooLong {
name: name.into(),
max_bytes: MINIX_NAME_LENGTH,
});
}
let mut bytes = [0_u8; MINIX_NAME_LENGTH];
bytes[..name.len()].copy_from_slice(name.as_bytes());
Ok(Self {
inode_number,
name: bytes,
})
}
pub fn decode(bytes: &[u8]) -> Result<Self> {
if bytes.len() < DIRECTORY_ENTRY_SIZE {
return Err(MinixError::Corrupt(
"directory entry slot is shorter than the Minix directory-entry size".into(),
));
}
let mut name = [0_u8; MINIX_NAME_LENGTH];
name.copy_from_slice(&bytes[2..DIRECTORY_ENTRY_SIZE]);
Ok(Self {
inode_number: read_u16(bytes, 0)?,
name,
})
}
pub fn encode(self, bytes: &mut [u8]) {
write_u16(bytes, 0, self.inode_number);
bytes[2..DIRECTORY_ENTRY_SIZE].copy_from_slice(&self.name);
}
pub fn name(&self) -> Result<String> {
let len = self
.name
.iter()
.position(|byte| *byte == 0)
.unwrap_or(MINIX_NAME_LENGTH);
let raw = &self.name[..len];
let value = std::str::from_utf8(raw).map_err(|_| {
MinixError::Corrupt("directory entry contains non-UTF-8 file-name bytes".into())
})?;
Ok(value.into())
}
}
fn read_u16(bytes: &[u8], offset: usize) -> Result<u16> {
let slice = bytes.get(offset..offset + 2).ok_or_else(|| {
MinixError::Corrupt("truncated little-endian u16 field in on-disk structure".into())
})?;
Ok(u16::from_le_bytes([slice[0], slice[1]]))
}
fn read_u32(bytes: &[u8], offset: usize) -> Result<u32> {
let slice = bytes.get(offset..offset + 4).ok_or_else(|| {
MinixError::Corrupt("truncated little-endian u32 field in on-disk structure".into())
})?;
Ok(u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]))
}
fn write_u16(bytes: &mut [u8], offset: usize, value: u16) {
bytes[offset..offset + 2].copy_from_slice(&value.to_le_bytes());
}
fn write_u32(bytes: &mut [u8], offset: usize, value: u32) {
bytes[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
}
#[cfg(test)]
mod tests {
use std::mem::size_of;
use super::*;
#[test]
fn disk_inode_size_matches_minix_layout() {
assert_eq!(size_of::<DiskInode>(), DISK_INODE_SIZE);
}
#[test]
fn disk_super_block_size_matches_minix_layout() {
assert_eq!(size_of::<DiskSuperBlock>(), DISK_SUPER_BLOCK_SIZE);
}
#[test]
fn directory_entry_size_matches_minix_layout() {
assert_eq!(size_of::<DiskDirectoryEntry>(), DIRECTORY_ENTRY_SIZE);
}
#[test]
fn directory_entry_rejects_long_names() {
let error = DiskDirectoryEntry::new("123456789012345", 1).unwrap_err();
assert!(matches!(error, MinixError::NameTooLong { .. }));
}
}