ESTALE / StaleNetworkFileHandle Root Cause Analysis

┌─────────────────────────────────────────────────────────────┐
│                      Buck2 / 用户进程                        │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ FUSE syscall
┌─────────────────────────────────────────────────────────────┐
│                      OverlayFs (UnionFS)                     │
│   ┌─────────────┬─────────────┬─────────────────────────┐   │
│   │ Upper Layer │  CL Layer   │      Lower Layer        │   │
│   │ (Passthrough)│(Passthrough)│      (Dicfuse)          │   │
│   └─────────────┴─────────────┴─────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
   local disk          local disk             Mega 后端 API
  (upper_dir)           (cl_dir)            (tree/blob fetch)

                                 ┌──────────────────────────┐
                                 │  Dicfuse 后台刷新目录     │
                                 │  (TTL=5s 触发)           │
                                 └───────────┬──────────────┘
                                             │
                    ┌────────────────────────▼────────────────────────┐
                    │  文件 inode/btime 发生变化                        │
                    │  (后端更新、内容变化等)                            │
                    └────────────────────────┬────────────────────────┘
                                             │
    ┌────────────────────────────────────────▼────────────────────────────────────┐
    │  Passthrough 层 FileHandle 缓存仍持有旧的 (inode, btime) → handle 映射        │
    └────────────────────────────────────────┬────────────────────────────────────┘
                                             │
                    ┌────────────────────────▼────────────────────────┐
                    │  用户进程请求 open() → 使用缓存的旧 handle          │
                    │  → open_by_handle_at() 返回 ESTALE               │
                    └────────────────────────┬────────────────────────┘
                                             │
                              ┌──────────────▼──────────────┐
                              │  错误向上传播，I/O 失败       │
                              └─────────────────────────────┘

pub fn open(&self, flags: libc::c_int) -> io::Result<File> {
    let ret = unsafe {
        open_by_handle_at(self.mount_fd.as_fd().as_raw_fd(),
                          self.handle.handle.wrapper.as_fam_struct_ptr(),
                          flags)
    };
    if ret >= 0 { Ok(File::from_raw_fd(ret)) } else {
        let e = io::Error::last_os_error();
        error!("open_by_handle_at failed error {e:?}");
        Err(e)  // ❌ 直接返回错误，无 ESTALE 特殊处理
    }
}

#[derive(Debug, Hash, Eq, PartialEq)]
struct FileUniqueKey(u64, statx_timestamp);  // (inode, btime)

// open_file_and_handle()
let st = statx::statx(&path_file, None)?;
let key = FileUniqueKey(st.st.st_ino, st.btime.unwrap());
if let Some(h) = cache.get(&key).await { ... }  // 命中缓存则复用 handle

match self.stat64(req).await {
    Ok(v) => Ok(Some(v)),
    Err(e) => match e.raw_os_error() {
        Some(raw) if raw == libc::ENOENT
            || raw == libc::ENAMETOOLONG
            || raw == libc::ESTALE => Ok(None),  // ✓ stat 路径: ESTALE → None
        _ => Err(e),
    },
}
// ❌ open 路径无类似处理

let ttl = self.dir_sync_ttl();  // 默认 5 秒

// Fast path: already loaded and still fresh.
if let Some(dir) = self.dirs.get(&parent_user_path) {
    if dir.loaded && !dir_needs_refresh(&dir, ttl) {
        return Ok(());
    }
}
// → 超过 TTL 则触发远程刷新，可能导致 inode/btime 变化

// If a file changed, invalidate cached content so reads refetch lazily.
if !is_dir {
    let _ = self.remove_file_by_node(child_inode);  // 仅清除内容缓存
}
// ❌ 未通知 Passthrough 层清除 file handle 缓存

dicfuse_dir_sync_ttl_secs = "5"
antares_dicfuse_dir_sync_ttl_secs = "5"

fn get_repo_targets(file_name: &str, repo_path: &Path) -> anyhow::Result<Targets> {
    const MAX_ATTEMPTS: usize = 2;  // 最多重试 2 次

    for attempt in 1..=MAX_ATTEMPTS {
        // ... run buck2 targets ...
        if status.success() {
            return Targets::from_file(&jsonl_path);
        }
        if attempt < MAX_ATTEMPTS {
            std::thread::sleep(std::time::Duration::from_secs(1));  // 重试间隔 1 秒
        }
    }
    Err(anyhow!("buck2 targets failed after {MAX_ATTEMPTS} attempts"))
}

.arg("-uz")  // -u: unmount, -z: lazy unmount

dicfuse_dir_sync_ttl_secs = "30"
antares_dicfuse_dir_sync_ttl_secs = "60"

pub fn open(&self, flags: libc::c_int) -> io::Result<File> {
    let ret = unsafe { open_by_handle_at(...) };
    if ret >= 0 {
        Ok(File::from_raw_fd(ret))
    } else {
        let e = io::Error::last_os_error();
        if e.raw_os_error() == Some(libc::ESTALE) {
            // 新增: 清除缓存并重试
            self.invalidate_handle_cache();
            return self.open_via_path_fallback(flags);
        }
        Err(e)
    }
}

// 在 dir refresh 逻辑中
if file_changed {
    self.remove_file_by_node(child_inode);
    // 新增: 通知 Passthrough 层
    passthrough_layer.invalidate_handle_for_inode(child_inode);
}

PassthroughArgs {
    root_dir: &self.upper_dir,
    mapping: None::<String>,
    use_file_handle: false,  // 新增: 禁用 open_by_handle_at
}