astrid-runtime/astrid · error

FUSE service parent process is not alive

Error message

FUSE service parent process is not alive

What it means

The FUSE service helper process checks that its parent (the mounting client process) is still alive before proceeding with the mount (binding the control listener and starting the filesystem session). If the parent PID no longer exists, the helper bails out instead of serving an orphaned mount. This prevents a leaked FUSE mount whose controller has died.

Solutions

1. Re-run the mount operation so a live parent spawns a fresh FUSE service process.
2. Check whether the parent process (the CLI/daemon performing the mount) crashed and fix its startup error before retrying.
3. Reduce work done by the parent between spawning the helper and the mount, or ensure the parent waits for the helper's ready signal.
4. Inspect supervisor/timeout settings (systemd, docker) that may be killing the parent mid-launch.
5. If PID reuse is suspected in long-lived containers, use the parent token handshake rather than assuming a stale PID.

Example fix

// before: parent dies during startup, helper bails
spawn_helper(...);
heavy_init(); // may exit; helper sees dead parent
// after: finish init before spawning, or keep parent alive until ready
heavy_init();
spawn_helper(...);
wait_for_helper_ready();

if !parent_is_alive(&parent) {
    // refresh spawn / abort before calling run
}
fn parent_is_alive(parent: &StorageProviderParentLifetimeV1) -> bool {
    unsafe { libc::kill(parent.pid as i32, 0) == 0 }
}

fn parent_alive(pid: u32) -> bool {
    std::process::Command::new("kill").arg("-0").arg(pid.to_string()).status().map(|s| s.success()).unwrap_or(false)
}

match service.run().await {
    Err(e) if e.to_string().contains("parent process is not alive") => restart_mount_with_live_parent(),
    Err(e) => return Err(e),
    Ok(v) => Ok(v),
}

When it happens

Trigger: `run_launch` (invoked by the service `run` loop) calls `parent_is_alive(&launch.parent)` right after opening control/resource/callback paths and it returns false — the parent process identified by `launch.parent.pid` has exited between spawn and the liveness check.

Common situations: The mounting CLI was killed or crashed while the FUSE helper was starting; the parent exited due to an earlier error while the helper was still initializing; PID reuse in containers makes the check race; slow startup (network mounts) gives the parent time to be terminated by a supervisor.

Related errors

• detached FUSE service did not retain its control endpoint
• detached FUSE service exceeded the startup response size
• FSKit service parent process is not alive
• FUSE callback path is not the kernel lease endpoint
• FUSE callback probe correlation mismatch

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

Appendix: source

Thrown at crates/astrid-storage-provider-fuse/src/service.rs:61

}

async fn run_launch(launch: StorageProviderServiceLaunchV1) -> Result<()> {
    if launch.schema != STORAGE_FILESYSTEM_SERVICE_LAUNCH_SCHEMA_V1 {
        bail!("unsupported FUSE service launch schema {}", launch.schema);
    }
    validate_launch(&launch)?;
    let challenge = storage_provider_service_ready_challenge(
        &launch.parent.token,
        STORAGE_FILESYSTEM_SERVICE_READY_SCHEMA_V1,
        crate::PROVIDER_NAME,
        launch.lease.mount_id.as_uuid(),
        &launch.control_path,
        &launch.lease.resource_path,
        &launch.lease.callback_path,
    )
    .map_err(|error| anyhow::anyhow!(error))?;
    if !parent_is_alive(&launch.parent) {
        bail!("FUSE service parent process is not alive");
    }
    probe_callback(&launch).await?;
    let listener = bind_control_listener(&launch.control_path)?;
    let mut session = match filesystem::start_session(launch.lease.clone(), &launch.mountpoint) {
        Ok(session) => Some(session),
        Err(error) => {
            let _ = std::fs::remove_file(&launch.control_path);
            return Err(error);
        },
    };
    let ready = StorageProviderServiceReadyV1 {
        schema: STORAGE_FILESYSTEM_SERVICE_READY_SCHEMA_V1,
        provider: crate::PROVIDER_NAME.to_owned(),
        mount_id: launch.lease.mount_id.as_uuid(),
        control_path: launch.control_path.clone(),
        challenge,
    };
    let mut stdout = std::io::stdout().lock();

View on GitHub (pinned to affd8760f4)