Week 3

// ==================== 1. 启动阶段：注册而非挂载 ====================
// api/src/vfs/mod.rs — mount_all()
pub fn mount_all() -> LinuxResult<()> {
    let fs = FS_CONTEXT.lock();

    // 必需文件系统 — 立即挂载（启动必须可用）
    mount_at(&fs, "/dev", dev::new_devfs())?;       // 设备文件系统
    mount_at(&fs, "/dev/shm", tmp::MemoryFs::new())?; // 共享内存
    mount_at(&fs, "/tmp", tmp::MemoryFs::new())?;    // 临时文件
    mount_at(&fs, "/sys", tmp::MemoryFs::new())?;    // sysfs（占位）
    drop(fs);

    // 可选文件系统 — 仅注册工厂函数到注册表，不调用 new_procfs()
    // 此时没有任何 procfs 数据结构被分配
    lazy_mount::register("/proc", || proc::new_procfs());
    // 日志输出: [lazy-mount] registered procfs at /proc (will mount on first access)
    Ok(())
}

// ==================== 2. 注册表核心数据结构 ====================
// api/src/vfs/mod.rs — lazy_mount 模块
enum State {
    Pending(Box<dyn FnOnce() -> Filesystem + Send>), // 持有构造函数
    Initialized,                                      // 已挂载，构造函数已消费
}

struct Entry {
    mount_point: String,  // 如 "/proc"
    state: State,
}

static REGISTRY: Mutex<Vec<Entry>> = Mutex::new(Vec::new());

// 注册：将条目推入 Vec，去重
pub fn register(mount_point: &str,
    factory: impl FnOnce() -> Filesystem + Send + 'static) {
    let mut reg = REGISTRY.lock();
    if reg.iter().any(|e| e.mount_point == mount_point) { return; }
    reg.push(Entry {
        mount_point: String::from(mount_point),
        state: State::Pending(Box::new(factory)),
    });
}

// 取出：前缀匹配 + 原子状态转换，保证只调用一次
pub fn take_pending_for(path: &str) -> Option<(String, Filesystem)> {
    let mut reg = REGISTRY.lock();
    for entry in reg.iter_mut() {
        // 匹配: path == "/proc" 或 path 以 "/proc/" 开头
        if path == entry.mount_point || path.starts_with(&format!("{}/", entry.mount_point)) {
            if let State::Pending(_) = &entry.state {
                let old = core::mem::replace(&mut entry.state, State::Initialized);
                if let State::Pending(factory) = old {
                    let mp = entry.mount_point.clone();
                    drop(reg);           // 释放锁后再调用工厂函数
                    return Some((mp, factory()));
                }
            }
            return None;  // 已经是 Initialized
        }
    }
    None
}

// ==================== 3. 触发层：路径解析前主动检查 ====================
// api/src/file/fs.rs — with_fs_lazy()
pub fn with_fs_lazy<R>(dirfd: c_int, path: &str,
    f: impl Fn(&mut FsContext) -> AxResult<R>,
) -> AxResult<R> {
    // 幂等检查：若 path 匹配 "/proc" 前缀且还未挂载 → 挂载
    //           若已挂载或不匹配 → 直接跳过（一次 lock + 遍历）
    crate::vfs::try_lazy_mount(path);
    with_fs(dirfd, &f)  // 正常执行文件系统操作
}

// ==================== 4. 实际挂载逻辑 ====================
// api/src/vfs/mod.rs — try_lazy_mount()
pub fn try_lazy_mount(path: &str) -> bool {
    if let Some((mount_point, fs)) = lazy_mount::take_pending_for(path) {
        let fsc = FS_CONTEXT.lock();
        match mount_at(&fsc, &mount_point, fs) {
            Ok(()) => {
                // 日志: [lazy-mount] mounted filesystem at /proc
                //        (triggered by access to /proc/meminfo)
                true
            }
            Err(e) => { warn!("failed to mount: {e:?}"); false }
        }
    } else {
        false  // 无匹配或已挂载
    }
}

// ==================== 5. 系统调用接入点 ====================
// sys_openat: open("/proc/meminfo") 触发懒挂载
with_fs_lazy(dirfd, &path, |fs| options.open(fs, &path))

// sys_readlinkat: readlink("/proc/self/exe") 触发懒挂载
with_fs_lazy(dirfd, &path, |fs| fs.resolve_no_follow(&path))

// sys_chdir / sys_statfs: 直接调用 try_lazy_mount(&path)
crate::vfs::try_lazy_mount(&path);
let entry = FS_CONTEXT.lock().resolve(&path)?;