sOS0x00

pub unsafe trait UserCopyable: Copy {}
impl_user_copyable_for_primitives! { u8, i32, ... }
// 这个marker trait限制了拷贝只能操作纯数据类型，编译器会阻止开发者尝试将包含内核指针、互斥锁等复杂结构的类型拷贝给用户态，从根源上消除了内核对象泄漏的安全隐患

pub struct Smalloc<T: AddressTranslator<()>> {
    pub memory: RegionList, // 可用物理内存段列表
    pub res: RegionList,    // 已占用/保留内存段列表
    // ...
    /// 维护两个列表以跟踪可用和已占用的内存区域，确保分配和释放操作的正确性，分配逻辑：遍历 memory 列表，从中减去 res 列表中的区域，找到空隙进行分配，自我生长，当用于存储列表的数组满时，递归调用自己分配更大的内存来扩容列表本身，解决了内核早期元数据存储空间不足的问题
}

struct InodeId(u64, u64)  // (文件系统ID, inode编号)

bitflags! {
    const O_RDONLY    = 0b000;  // 只读
    const O_WRONLY    = 0b001;  // 只写
    const O_RDWR      = 0b010;  // 读写
    const O_CREAT     = 0o100;  // 创建文件
    const O_TRUNC     = 0o1000; // 截断文件
    // ...
}

enum FileType {
    File,           // 普通文件
    Directory,      // 目录
    Symlink,        // 符号链接
    BlockDevice,    // 块设备
    CharDevice,     // 字符设备
    Fifo,           // 命名管道
    Socket,         // 套接字
}

trait BlockDevice {
    async fn read(&self, block_id: u64, buf: &mut [u8]) -> Result<()>;
    async fn write(&self, block_id: u64, buf: &[u8]) -> Result<()>;
    fn block_size(&self) -> usize;
    async fn sync(&self) -> Result<()>;
}

impl RamdiskBlkDev {
    fn new(region: PhysMemoryRegion, base: VA) -> Result<Self> {
        // 将物理内存映射到内核虚拟地址空间
        kern_addr_spc.map_normal(region, ...);
        // 直接内存访问,无需实际 I/O
    }
}

pub struct BlockBuffer {
    dev: Box<dyn BlockDevice>,
    block_size: usize,
}

async fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<()> {
    // 1. 计算涉及的块范围
    let start_block = offset / block_size;
    let end_block = (offset + len - 1) / block_size;
    
    // 2. 读取所有涉及的块到临时缓冲区
    let mut temp_buf = vec![0; num_blocks * block_size];
    self.dev.read(start_block, &mut temp_buf).await?;
    
    // 3. 提取所需字节
    buf.copy_from_slice(&temp_buf[start_offset..end_offset]);
}

trait Filesystem {
    async fn root_inode(&self) -> Result<Arc<dyn Inode>>;
    fn id(&self) -> u64;
    async fn sync(&self) -> Result<()>;
}

trait Inode {
    fn id(&self) -> InodeId;
    async fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize>;
    async fn write_at(&self, offset: u64, buf: &[u8]) -> Result<usize>;
    async fn lookup(&self, name: &str) -> Result<Arc<dyn Inode>>;
    async fn create(&self, name: &str, ...) -> Result<Arc<dyn Inode>>;
    async fn readdir(&self, start_offset: u64) -> Result<Box<dyn DirStream>>;
}

pub struct Fat32Filesystem {
    dev: BlockBuffer,              // 底层块设备
    bpb: BiosParameterBlock,       // 启动参数块(元数据)
    fat: Fat,                      // 文件分配表
    id: u64,                       // 文件系统实例ID
    this: Weak<Self>,              // 弱引用,避免循环引用
}

struct Sector(u32);   // 扇区号
struct Cluster(u32);  // 簇号

impl Cluster {
    fn from_high_low(high: u16, low: u16) -> Self {
        // FAT32 目录项存储为两个 16 位字段
        Cluster((high as u32) << 16 | low as u32)
    }
}

async fn new(dev: BlockBuffer, id: u64) -> Result<Arc<Self>> {
    // 1. 读取启动扇区,解析 BPB
    let bpb = BiosParameterBlock::new(&dev).await?;
    
    // 2. 读取主 FAT 表
    let fat = Fat::read_fat(&dev, &bpb, 0).await?;
    
    // 3. 验证所有 FAT 副本一致性
    for fat_num in 1..bpb.num_fats {
        let other_fat = Fat::read_fat(&dev, &bpb, fat_num).await?;
        if other_fat != fat {
            return Err(FsError::InvalidFs.into());
        }
    }
    
    // 4. 使用 Arc::new_cyclic 解决循环引用
    Ok(Arc::new_cyclic(|weak| Self { this: weak.clone(), ... }))
}

trait Fat32Operations {
    async fn read_sector(&self, sector: Sector, offset: usize, buf: &mut [u8]) 
        -> Result<usize>;
    fn cluster_to_sectors(&self, cluster: Cluster) 
        -> Result<impl Iterator<Item = Sector>>;
    fn iter_clusters(&self, root: Cluster) 
        -> impl Iterator<Item = Result<Cluster>>;
}

async fn read_sector(&self, sector: Sector, offset: usize, buf: &mut [u8]) 
    -> Result<usize> 
{
    let bytes_left = sector_size - offset;
    let read_sz = min(buf.len(), bytes_left);
    
    // 转换为字节偏移并读取
    self.dev.read_at(
        self.bpb.sector_offset(sector) + offset as u64,
        &mut buf[..read_sz]
    ).await?;
}

trait Driver {
    fn name(&self) -> &'static str;
    fn as_interrupt_manager(self: Arc<Self>) -> Option<...>;
    fn as_filesystem_driver(self: Arc<Self>) -> Option<...>;
}

trait CharDriver {
    fn get_device(&self, minor: u64) -> Option<Arc<dyn OpenableDevice>>;
}

trait OpenableDevice {
    fn open(&self, flags: OpenFlags) -> Result<Arc<OpenFile>>;
}

pub struct DriverManager {
    active_drivers: Vec<Arc<dyn Driver>>,
    char_drivers: BTreeMap<u64, Arc<dyn CharDriver>>,  // major -> driver
}

fn register_char_driver(&mut self, major: u64, driver: Arc<dyn CharDriver>) 
    -> Result<()> 
{
    match self.char_drivers.entry(major) {
        Entry::Vacant(e) => { e.insert(driver); Ok(()) }
        Entry::Occupied(_) => Err(KernelError::InUse),
    }
}

struct ConsoleDev {}

impl OpenableDevice for ConsoleDev {
    fn open(&self, flags: OpenFlags) -> Result<Arc<OpenFile>> {
        // 1. 获取实际控制台设备描述符
        let char_dev_desc = match *CONSOLE.lock_save_irq() {
            ConsoleState::Device(_, desc) => desc,
            _ => return Err(FsError::NoDevice.into()),
        };
        
        // 2. 查找对应的字符驱动
        let driver = DM.lock_save_irq()
            .find_char_driver(char_dev_desc.major)
            .ok_or(FsError::NoDevice)?;
        
        // 3. 打开具体设备
        driver.get_device(char_dev_desc.minor)?.open(flags)
    }
}

impl OpenableDevice for TtyDev {
    fn open(&self, _args: OpenFlags) -> Result<Arc<OpenFile>> {
        // 返回当前进程的控制终端(通常是 fd 0)
        current_task().fd_table.lock_save_irq().get(Fd(0))
    }
}