astrid-runtime/astrid · error

detached FUSE stderr drain failed

Error message

detached FUSE stderr drain failed: {error}

What it means

During a detached FUSE mount handoff, a background task drains the child process's stderr while the parent waits for the sink handoff. If that drain task itself returns an error (Err(error)), the parent kills the child, waits for its exit status, and throws this error wrapping both the drain failure and the child's exit status.

Solutions

  1. Read the attached 'detached FUSE service status' context to see the child's exit code and diagnose why it died
  2. Run the FUSE mount command manually to observe its stderr output directly
  3. Check that the FUSE binary/daemon version matches what the parent expects
  4. Inspect system logs (journalctl/dmesg) for FUSE kernel or permission errors

Example fix

// before: opaque drain failure
Err(anyhow::anyhow!("detached FUSE stderr drain failed: {error}"))
// after: also capture partial stderr for diagnosis
Err(anyhow::anyhow!("detached FUSE stderr drain failed: {error}")
    .context(format!("drained stderr: {partial}"))
    .context(format!("detached FUSE service status: {status:?}")))
Defensive patterns

Strategy: try-catch

Validate before calling

// ensure /dev/fuse is usable before spawning
if !std::path::Path::new("/dev/fuse").exists() {
    return Err("FUSE kernel device unavailable");
}

Try / catch

match result {
    Ok(status) => status,
    Err(e) => {
        log::error!("{}", e); // includes drain error + child status context
        // retry once after cleaning stale registry state
    }
}

Prevention

When it happens

Trigger: Calling the detached FUSE mount flow and the spawned child writes malformed/unexpected output to stderr, or the stderr-drain task fails while reading/parsing the child's stderr during the sink handoff window.

Common situations: The FUSE daemon crashed or was killed mid-handoff and printed a panic to stderr; the stderr pipe was closed prematurely; the handoff protocol version mismatch causes the parent to misinterpret stderr content.

Understand the failure class

Background: "This is a bug, please report it": internal invariant violations, unreachable panics, and SNH errors explained — this error's family across 47 libraries.

Related errors

AI-assisted analysis of astrid-runtime/astrid@affd8760f4 (2026-09-09). Data as JSON: /api/errors/ca8f9866623069d5. Report an issue: GitHub.

Appendix: source

Thrown at crates/astrid-storage-provider-fuse/src/main.rs:630

    });
    let startup = read_service_startup(&mut child, launch, control_path).await;
    match startup {
        Ok(ready) => {
            match tokio::time::timeout(Duration::from_secs(1), &mut stderr_task).await {
                Ok(Ok(Ok(_))) => require_service_running_after_handoff(&mut child)
                    .await
                    .map(|()| ready),
                Ok(Ok(Err(error))) => {
                    let _ = child.kill().await;
                    let status = child.wait().await;
                    Err(anyhow::Error::new(error)
                        .context("read detached FUSE stderr during sink handoff")
                        .context(format!("detached FUSE service status: {status:?}")))
                },
                Ok(Err(error)) => {
                    let _ = child.kill().await;
                    let status = child.wait().await;
                    Err(anyhow::anyhow!("detached FUSE stderr drain failed: {error}")
                        .context(format!("detached FUSE service status: {status:?}")))
                },
                Err(_) => {
                    stderr_task.abort();
                    let _ = child.kill().await;
                    let status = child.wait().await;
                    Err(anyhow::anyhow!("detached FUSE stderr sink handoff timed out")
                        .context(format!("detached FUSE service status: {status:?}")))
                },
            }
        },
        Err(error) => {
            let _ = child.kill().await;
            let status = child.wait().await;
            let stderr = match stderr_task.await {
                Ok(Ok(bytes)) => bounded_stderr_snippet(&bytes),
                Ok(Err(_)) | Err(_) => String::new(),
            };

View on GitHub (pinned to affd8760f4)