pmhuj4vri/src/vfs.rs

use alloc::{vec::Vec, string::String, rc::{Rc, Weak}};
use core::cell::RefCell;
use core::mem::size_of;
use core;
use core::fmt::Debug;
use core::any::Any;

/// Interface for FS to read & write
///     TODO: use std::io::{Read, Write}
pub trait Device {
    fn read_at(&mut self, offset: usize, buf: &mut [u8]) -> Option<usize>;
    fn write_at(&mut self, offset: usize, buf: &[u8]) -> Option<usize>;
}

/// Abstract operations on a inode.
pub trait INode: Debug + Any {
    fn open(&mut self, flags: u32) -> Result<()>;
    fn close(&mut self) -> Result<()>;
    fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize>;
    fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize>;
    fn info(&self) -> Result<FileInfo>;
    fn sync(&mut self) -> Result<()>;
//    fn name_file(&mut self) -> Result<()>;
//    fn reclaim(&mut self) -> Result<()>;
    fn resize(&mut self, len: usize) -> Result<()>;
    fn create(&mut self, name: &str, type_: FileType) -> Result<INodePtr>;
    fn unlink(&mut self, name: &str) -> Result<()>;
    /// user of the vfs api should call borrow_mut by itself
    fn link(&mut self, name: &str, other:&mut INode) -> Result<()>;
    // fn lookup(&self, path: &str) -> Result<INodePtr>;
    /// lookup with only one layer
    fn find(&self, name: &str) -> Result<INodePtr>;
    /// like list()[id]
    /// only get one item in list, often faster than list
    fn get_entry(&self,id: usize) -> Result<String>;
//    fn io_ctrl(&mut self, op: u32, data: &[u8]) -> Result<()>;
    fn fs(&self) -> Weak<FileSystem>;
    /// this is used to implement dynamics cast
    /// simply return self in the implement of the function
    fn as_any_ref(&self) -> &Any;
    /// this is used to implement dynamics cast
    /// simply return self in the implement of the function
    fn as_any_mut(&mut self) -> &mut Any;
}

impl INode{
    pub fn downcast_ref<T:INode>(&self) -> Option<&T> {
        self.as_any_ref().downcast_ref::<T>()
    }
    pub fn downcast_mut<T:INode>(&mut self) -> Option<&mut T> {
        self.as_any_mut().downcast_mut::<T>()
    }
    pub fn list(&self) -> Result<Vec<String>> {
        let info=self.info().unwrap();
        assert_eq!(info.type_, FileType::Dir);
        Ok((0..info.size).map(|i|{
            self.get_entry(i).unwrap()
        }).collect())
    }
    pub fn lookup(&self, path: &str) -> Result<INodePtr> {
        if(self.info().unwrap().type_ != FileType::Dir){
            return Err(())
        }
        let mut result=self.find(".").unwrap();
        let mut rest_path=path;
        while rest_path != "" {
            if(result.borrow().info().unwrap().type_ != FileType::Dir){
                return Err(())
            }
            let mut name;
            match rest_path.find('/') {
                None => {name=rest_path; rest_path=""},
                Some(pos) => {name=&rest_path[0..pos]; rest_path=&rest_path[pos + 1..]},
            };
            let found=result.borrow().find(name);
            match found {
                Err(_) => return Err(()),
                Ok(inode) => result=inode,
            };
        }
        Ok(result)
    }
}

#[derive(Debug, Eq, PartialEq)]
pub struct FileInfo {
    // Note: for normal file size is the actuate file size
    // for directory this is count of dirent.
    pub size: usize,
    pub mode: u32,
    pub type_: FileType,
    pub blocks: usize,
    // Note: different from linux, "." and ".." count in nlinks
    // this is same as original ucore.
    pub nlinks: usize,
}

#[derive(Debug, Eq, PartialEq)]
pub enum FileType {
    File, Dir,
}

#[derive(Debug)]
pub struct FsInfo {
    pub max_file_size: usize,
}

pub type Result<T> = core::result::Result<T, ()>;

/// Abstract filesystem
pub trait FileSystem {
    fn sync(&self) -> Result<()>;
    fn root_inode(&self) -> INodePtr;
    fn info(&self) -> &'static FsInfo;
//    fn unmount(&self) -> Result<()>;
//    fn cleanup(&self);
}

pub type INodePtr = Rc<RefCell<INode>>;