虚拟文件系统

Axfs VFS (Virtual File System) 是 Axvisor 操作系统的虚拟文件系统接口层，为上层应用提供统一的文件系统抽象接口。作为 ArceOS 生态系统的核心组件之一，Axfs VFS 采用 Rust 语言编写，充分利用了 Rust 的内存安全特性和高性能优势，为现代操作系统提供了可靠、高效的文件系统基础设施。

Axfs VFS 提供了一套完整的文件系统抽象接口，支持文件和目录的创建、读取、写入、删除等基本操作。其核心特性包括：

• 统一的文件系统接口：通过 VfsOps trait 为不同文件系统提供统一操作接口
• 灵活的节点操作：通过 VfsNodeOps trait 支持文件和目录的细粒度操作
• 类型安全：利用 Rust 的类型系统确保操作的安全性
• 异步友好：接口设计支持异步操作模式
• 权限管理：内置基于 Unix 权限模型的访问控制
• 路径规范化：提供跨平台的路径处理功能

// 核心特性概览
pub trait VfsOps: Send + Sync {
    fn mount(&self, _path: &str, _mount_point: VfsNodeRef) -> VfsResult;
    fn umount(&self) -> VfsResult;
    fn format(&self) -> VfsResult;
    fn statfs(&self) -> VfsResult<FileSystemInfo>;
    fn root_dir(&self) -> VfsNodeRef;
}

pub trait VfsNodeOps: Send + Sync {
    // 文件和目录的通用操作
    fn open(&self) -> VfsResult;
    fn release(&self) -> VfsResult;
    fn get_attr(&self) -> VfsResult<VfsNodeAttr>;
    
    // 文件特有操作
    fn read_at(&self, offset: u64, buf: &mut [u8]) -> VfsResult<usize>;
    fn write_at(&self, offset: u64, buf: &[u8]) -> VfsResult<usize>;
    
    // 目录特有操作
    fn lookup(self: Arc<Self>, path: &str) -> VfsResult<VfsNodeRef>;
    fn create(&self, path: &str, ty: VfsNodeType) -> VfsResult;
}

架构设计

核心设计模式

Trait 对象模式

Axfs VFS 使用 Rust 的 trait 对象实现运行时多态，这种设计模式允许在编译时不确定具体类型的情况下，通过统一的接口调用不同实现的方法。Trait 对象模式在 Axfs VFS 中的应用体现了 Rust 的零成本抽象特性，既提供了高级的多态能力，又保持了运行时性能。

// 文件系统操作接口
pub trait VfsOps: Send + Sync {
    fn root_dir(&self) -> VfsNodeRef;
}

// 节点操作接口
pub trait VfsNodeOps: Send + Sync {
    fn read_at(&self, offset: u64, buf: &mut [u8]) -> VfsResult<usize>;
    fn write_at(&self, offset: u64, buf: &[u8]) -> VfsResult<usize>;
}

// 类型别名简化使用
pub type VfsNodeRef = Arc<dyn VfsNodeOps>;

Arc 引用计数模式

使用 Arc<T> 实现节点的共享所有权是 Axfs VFS 中的关键设计选择。Arc (Atomically Reference Counted) 是 Rust 提供的线程安全引用计数指针，它允许多个所有者共享同一数据，并在最后一个引用离开作用域时自动清理资源。这种模式在文件系统场景中特别有用，因为同一个文件或目录可能被多个进程同时访问。

// 多个引用可以同时访问同一个节点
let file = fs.lookup("/path/to/file")?;
let reader1 = file.clone();
let reader2 = file.clone();

// 安全的并发访问
spawn(move || {
    let mut buf = [0u8; 1024];
    reader1.read_at(0, &mut buf)?;
});

spawn(move || {
    let data = b"Hello, World!";
    reader2.write_at(0, data)?;
});

错误处理模式

统一的错误处理机制是 Axfs VFS 设计中的重要组成部分。通过定义 VfsResult 类型别名和统一的错误传播方式，使得文件系统操作中的错误处理更加一致和可维护。这种模式借鉴了 Rust 的 Result 类型设计理念，强制调用者处理可能的错误情况，从而提高了系统的健壮性。

pub type VfsResult<T = ()> = AxResult<T>;

// 使用 axerrno crate 提供的错误类型
fn read_at(&self, offset: u64, buf: &mut [u8]) -> VfsResult<usize> {
    if offset >= self.size {
        return ax_err!(InvalidInput);
    }
    // 实际读取逻辑
    Ok(bytes_read)
}

核心组件

VfsOps Trait

文件系统级别的操作接口，负责管理整个文件系统的生命周期。VfsOps trait 定义了文件系统级别的操作，包括挂载、卸载、格式化等高级操作。这些操作通常影响整个文件系统，而不是单个文件或目录。通过将这些操作集中在 VfsOps trait 中，Axfs VFS 实现了关注点分离，使得文件系统管理逻辑与节点操作逻辑相互独立。

pub trait VfsOps: Send + Sync {
    /// 挂载文件系统到指定路径
    fn mount(&self, _path: &str, _mount_point: VfsNodeRef) -> VfsResult {
        Ok(())
    }

    /// 卸载文件系统
    fn umount(&self) -> VfsResult {
        Ok(())
    }

    /// 格式化文件系统
    fn format(&self) -> VfsResult {
        ax_err!(Unsupported)
    }

    /// 获取文件系统属性
    fn statfs(&self) -> VfsResult<FileSystemInfo> {
        ax_err!(Unsupported)
    }

    /// 获取根目录节点
    fn root_dir(&self) -> VfsNodeRef;
}

实现要点：

• mount() 和 umount() 管理文件系统的生命周期
• format() 提供文件系统初始化功能
• statfs() 返回文件系统统计信息
• root_dir() 是访问文件系统的入口点

VfsNodeOps Trait

节点级别的操作接口，处理文件和目录的具体操作。VfsNodeOps trait 是 Axfs VFS 中最核心的接口，它定义了文件系统节点（文件和目录）的所有可能操作。这个 trait 的设计充分考虑了文件和目录的不同特性，将操作分为通用操作、文件特有操作和目录特有操作三类。通过这种方式，Axfs VFS 既保证了接口的完整性，又允许不同类型的节点只实现相关的操作，提高了代码的清晰度和可维护性。

pub trait VfsNodeOps: Send + Sync {
    // 通用操作
    fn open(&self) -> VfsResult { Ok(()) }
    fn release(&self) -> VfsResult { Ok(()) }
    fn get_attr(&self) -> VfsResult<VfsNodeAttr> { ax_err!(Unsupported) }

    // 文件操作
    fn read_at(&self, _offset: u64, _buf: &mut [u8]) -> VfsResult<usize> {
        ax_err!(InvalidInput)
    }
    fn write_at(&self, _offset: u64, _buf: &[u8]) -> VfsResult<usize> {
        ax_err!(InvalidInput)
    }
    fn fsync(&self) -> VfsResult { ax_err!(InvalidInput) }
    fn truncate(&self, _size: u64) -> VfsResult { ax_err!(InvalidInput) }

    // 目录操作
    fn parent(&self) -> Option<VfsNodeRef> { None }
    fn lookup(self: Arc<Self>, _path: &str) -> VfsResult<VfsNodeRef> {
        ax_err!(Unsupported)
    }
    fn create(&self, _path: &str, _ty: VfsNodeType) -> VfsResult {
        ax_err!(Unsupported)
    }
    fn remove(&self, _path: &str) -> VfsResult { ax_err!(Unsupported) }
    fn read_dir(&self, _start_idx: usize, _dirents: &mut [VfsDirEntry]) -> VfsResult<usize> {
        ax_err!(Unsupported)
    }
    fn rename(&self, _src_path: &str, _dst_path: &str) -> VfsResult {
        ax_err!(Unsupported)
    }

    // 类型转换
    fn as_any(&self) -> &dyn core::any::Any { unimplemented!() }
}

数据结构

Axfs VFS 定义了一系列核心数据结构来表示文件系统中的各种概念。这些数据结构经过精心设计，既保持了与 Unix 文件系统的兼容性，又充分利用了 Rust 的类型系统优势。每个数据结构都有明确的职责和语义，共同构成了一个完整、一致的文件系统模型。

VfsNodeAttr - 节点属性

VfsNodeAttr 结构体表示文件系统节点的属性信息，类似于 Unix 系统中的 stat 结构。它包含了权限模式、节点类型、文件大小和占用块数等基本信息。这个结构体设计为 Copy 类型，意味着它可以被廉价地复制，这在频繁访问文件属性的场景中非常有用。

#[derive(Debug, Clone, Copy)]
pub struct VfsNodeAttr {
    mode: VfsNodePerm,    // 权限模式
    ty: VfsNodeType,      // 节点类型
    size: u64,            // 文件大小
    blocks: u64,          // 占用块数
}

VfsNodePerm - 权限管理

VfsNodePerm 使用 Rust 的 bitflags crate 实现了基于 Unix 权限模型的权限管理系统。它支持传统的用户、组和其他三类权限，每类包含读、写、执行三种权限。这种设计不仅与 Unix 系统保持兼容，还提供了类型安全的权限操作方法，避免了传统 C 语言中容易出现的位操作错误。

bitflags::bitflags! {
    pub struct VfsNodePerm: u16 {
        const OWNER_READ = 0o400;
        const OWNER_WRITE = 0o200;
        const OWNER_EXEC = 0o100;
        const GROUP_READ = 0o40;
        const GROUP_WRITE = 0o20;
        const GROUP_EXEC = 0o10;
        const OTHER_READ = 0o4;
        const OTHER_WRITE = 0o2;
        const OTHER_EXEC = 0o1;
    }
}

VfsNodeType - 节点类型

VfsNodeType 枚举定义了文件系统支持的所有节点类型，包括普通文件、目录、字符设备、块设备、命名管道、符号链接和套接字。这个枚举使用 repr(u8) 属性，确保每个类型都有明确的数值表示，便于与底层系统交互。同时，它提供了丰富的辅助方法，如 is_file()、is_dir() 等，使类型检查更加直观和安全。

#[repr(u8)]
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum VfsNodeType {
    Fifo = 0o1,           // 命名管道
    CharDevice = 0o2,     // 字符设备
    Dir = 0o4,            // 目录
    BlockDevice = 0o6,    // 块设备
    File = 0o10,          // 普通文件
    SymLink = 0o12,       // 符号链接
    Socket = 0o14,        // 套接字
}

4. 路径管理模块

路径管理是文件系统中的重要组成部分，Axfs VFS 提供了强大的路径规范化功能。路径规范化处理能够将包含相对路径、冗余分隔符等复杂路径转换为标准形式，这对于文件系统的安全性和一致性至关重要。Axfs VFS 的路径处理模块不仅支持 Unix 风格的路径，还考虑了跨平台兼容性，为上层应用提供了统一的路径操作接口。

pub fn canonicalize(path: &str) -> String {
    let mut buf = String::new();
    let is_absolute = path.starts_with('/');
    
    for part in path.split('/') {
        match part {
            "" | "." => continue,
            ".." => {
                // 处理上级目录
                while !buf.is_empty() {
                    if buf == "/" { break; }
                    let c = buf.pop().unwrap();
                    if c == '/' { break; }
                }
            }
            _ => {
                // 添加路径组件
                if !buf.is_empty() && !buf.ends_with('/') {
                    buf.push('/');
                }
                buf.push_str(part);
            }
        }
    }
    
    if is_absolute && buf.is_empty() {
        buf.push('/');
    }
    buf
}

API 接口详解

Axfs VFS 提供了丰富的 API 接口，涵盖了文件系统的所有核心功能。这些接口设计遵循 Rust 的最佳实践，既保证了易用性，又确保了安全性。每个接口都有明确的语义和错误处理机制，使得开发者可以轻松地构建可靠的文件系统应用。

文件系统操作接口

文件系统操作接口主要涉及文件系统的生命周期管理，包括挂载、卸载、格式化等操作。这些操作通常需要管理员权限，并且会影响整个文件系统的状态。Axfs VFS 通过 VfsOps trait 提供了这些高级操作的统一接口。

挂载操作

挂载操作是将文件系统集成到系统目录树中的过程。Axfs VFS 的挂载接口设计得非常灵活，支持将文件系统挂载到任意目录路径。挂载过程包括路径验证、挂载点检查、资源分配等多个步骤，确保挂载操作的安全性和可靠性。

impl MyFileSystem {
    fn mount(&self, path: &str, mount_point: VfsNodeRef) -> VfsResult {
        // 1. 验证挂载路径
        if !path.starts_with('/') {
            return ax_err!(InvalidInput);
        }
        
        // 2. 检查挂载点是否存在
        if mount_point.get_attr()?.is_file() {
            return ax_err!(NotADirectory);
        }
        
        // 3. 执行挂载逻辑
        self.mount_points.lock().insert(path.to_string(), mount_point);
        
        // 4. 初始化文件系统
        self.initialize()?;
        
        Ok(())
    }
}

卸载操作

卸载操作是从系统目录树中移除文件系统的过程。这是一个需要谨慎执行的操作，因为卸载时必须确保没有进程正在使用该文件系统。Axfs VFS 的卸载接口包含了完整的检查流程，包括打开文件计数检查、缓存数据同步、资源清理等步骤，确保卸载操作的安全性和数据完整性。

fn umount(&self) -> VfsResult {
    // 1. 检查是否有正在使用的文件
    if self.open_files_count() > 0 {
        return ax_err!(Busy);
    }
    
    // 2. 同步缓存数据
    self.sync_all()?;
    
    // 3. 清理资源
    self.cleanup()?;
    
    Ok(())
}

节点操作接口

节点操作接口是 Axfs VFS 的核心，提供了对文件和目录进行细粒度操作的能力。这些接口通过 VfsNodeOps trait 定义，涵盖了文件和目录的所有基本操作。节点操作接口的设计充分考虑了不同类型节点的特性，提供了类型安全的操作方法，并确保了在多线程环境下的安全性。

文件读取

文件读取是文件系统中最基本也是最重要的操作之一。Axfs VFS 提供了基于偏移量的随机读取接口，支持从文件的任意位置开始读取指定长度的数据。这种设计既支持顺序读取，也支持随机访问，满足了不同应用场景的需求。读取操作包含了完整的参数验证、边界检查和性能优化，确保操作的安全性和效率。

fn read_at(&self, offset: u64, buf: &mut [u8]) -> VfsResult<usize> {
    // 1. 参数验证
    if offset >= self.size {
        return Ok(0); // EOF
    }
    
    // 2. 计算实际读取长度
    let to_read = core::cmp::min(buf.len(), (self.size - offset) as usize);
    
    // 3. 执行读取操作
    let data = self.data.lock();
    let read_end = offset as usize + to_read;
    buf[..to_read].copy_from_slice(&data[offset as usize..read_end]);
    
    // 4. 更新访问时间
    self.update_access_time();
    
    Ok(to_read)
}

文件写入

文件写入操作允许应用程序向文件中写入数据。Axfs VFS 提供了基于偏移量的写入接口，支持在文件的任意位置进行写入操作。写入接口包含了权限检查、空间扩展、数据写入和属性更新等完整流程，确保写入操作的安全性和数据一致性。特别是在需要扩展文件大小时，系统会自动处理空间分配，简化了上层应用的开发。

fn write_at(&self, offset: u64, buf: &[u8]) -> VfsResult<usize> {
    // 1. 检查写入权限
    if !self.is_writable() {
        return ax_err!(PermissionDenied);
    }
    
    // 2. 扩展文件空间（如果需要）
    let write_end = offset + buf.len() as u64;
    if write_end > self.size {
        self.resize(write_end)?;
    }
    
    // 3. 执行写入操作
    let mut data = self.data.lock();
    let start = offset as usize;
    let end = start + buf.len();
    data[start..end].copy_from_slice(buf);
    
    // 4. 更新修改时间和大小
    self.update_modify_time();
    self.size = write_end;
    
    Ok(buf.len())
}

目录遍历

目录遍历是访问目录内容的基本操作。Axfs VFS 提供了基于索引的目录条目读取接口，支持分批读取目录内容，这对于包含大量文件的目录特别有用。目录遍历接口设计得非常灵活，支持从任意位置开始读取，并且能够处理各种边界情况，如空目录、索引超出范围等。

fn read_dir(&self, start_idx: usize, dirents: &mut [VfsDirEntry]) -> VfsResult<usize> {
    // 1. 获取目录条目
    let entries = self.entries.lock();
    
    // 2. 检查起始索引
    if start_idx >= entries.len() {
        return Ok(0);
    }
    
    // 3. 填充目录条目
    let mut count = 0;
    for (i, entry) in entries.iter().skip(start_idx).enumerate() {
        if i >= dirents.len() {
            break;
        }
        
        dirents[i] = VfsDirEntry::new(&entry.name, entry.ty);
        count += 1;
    }
    
    Ok(count)
}