lesavka/server/src/gadget.rs

// server/src/gadget.rs
use anyhow::{Context, Result};
use std::{
    env,
    fs::{self, OpenOptions},
    io::Write,
    path::Path,
    thread,
    time::Duration,
};
use tracing::{info, trace, warn};

#[derive(Clone)]
pub struct UsbGadget {
    udc_file: &'static str,
}

impl UsbGadget {
    fn sysfs_root() -> String {
        env::var("LESAVKA_GADGET_SYSFS_ROOT").unwrap_or_else(|_| "/sys".to_string())
    }

    fn configfs_root() -> String {
        env::var("LESAVKA_GADGET_CONFIGFS_ROOT")
            .unwrap_or_else(|_| "/sys/kernel/config/usb_gadget".to_string())
    }

    pub fn new(name: &'static str) -> Self {
        Self {
            udc_file: Box::leak(
                format!("{}/{}{}", Self::configfs_root(), name, "/UDC").into_boxed_str(),
            ),
        }
    }

    pub fn state(ctrl: &str) -> anyhow::Result<String> {
        let p = format!("{}/class/udc/{ctrl}/state", Self::sysfs_root());
        Ok(std::fs::read_to_string(p)?.trim().to_owned())
    }

    /*---- helpers ----*/

    /// Find the first controller in /sys/class/udc (e.g. `1000480000.usb`)
    pub fn find_controller() -> Result<String> {
        Ok(fs::read_dir(format!("{}/class/udc", Self::sysfs_root()))?
            .next()
            .transpose()?
            .context("no UDC present")?
            .file_name()
            .to_string_lossy()
            .into_owned())
    }

    /// Busy-loop (≤ `limit_ms`) until `state` matches `wanted`
    fn wait_state(ctrl: &str, wanted: &str, limit_ms: u64) -> Result<()> {
        let path = format!("{}/class/udc/{ctrl}/state", Self::sysfs_root());
        for _ in 0..=limit_ms / 50 {
            let s = fs::read_to_string(&path).unwrap_or_default();
            trace!("⏳ state={s:?}, want={wanted}");
            if s.trim() == wanted {
                return Ok(());
            }
            thread::sleep(Duration::from_millis(50));
        }
        Err(anyhow::anyhow!(
            "UDC never reached '{wanted}' (last = {:?})",
            fs::read_to_string(&path).unwrap_or_default()
        ))
    }

    pub fn wait_state_any(ctrl: &str, limit_ms: u64) -> anyhow::Result<String> {
        let path = format!("{}/class/udc/{ctrl}/state", Self::sysfs_root());
        for _ in 0..=limit_ms / 50 {
            if let Ok(s) = std::fs::read_to_string(&path) {
                let s = s.trim();
                if matches!(s, "configured" | "not attached") {
                    return Ok(s.to_owned());
                }
            }
            std::thread::sleep(std::time::Duration::from_millis(50));
        }
        Err(anyhow::anyhow!(
            "UDC state did not settle within {limit_ms} ms"
        ))
    }

    /// Write `value` (plus “\n”) into a sysfs attribute
    fn write_attr<P: AsRef<Path>>(p: P, value: &str) -> Result<()> {
        OpenOptions::new()
            .write(true)
            .open(p)?
            .write_all(format!("{value}\n").as_bytes())?;
        Ok(())
    }

    // Wait (≤ `limit_ms`) until `/sys/class/udc/<ctrl>` exists again.
    fn wait_udc_present(ctrl: &str, limit_ms: u64) -> Result<()> {
        for _ in 0..=limit_ms / 50 {
            if Path::new(&format!("{}/class/udc/{ctrl}", Self::sysfs_root())).exists() {
                return Ok(());
            }
            thread::sleep(Duration::from_millis(50));
        }
        Err(anyhow::anyhow!(
            "⚠️ UDC {ctrl} did not re-appear within {limit_ms} ms"
        ))
    }

    /// Scan platform devices when /sys/class/udc is empty
    fn probe_platform_udc() -> Result<Option<String>> {
        for entry in fs::read_dir(format!("{}/bus/platform/devices", Self::sysfs_root()))? {
            let p = entry?.file_name().into_string().unwrap();
            if p.ends_with(".usb") {
                return Ok(Some(p));
            }
        }
        Ok(None)
    }

    /*---- public API ----*/

    /// Hard-reset the gadget → identical to a physical cable re-plug
    #[cfg(coverage)]
    pub fn cycle(&self) -> Result<()> {
        self.cycle_internal(env::var("LESAVKA_GADGET_FORCE_CYCLE").is_ok())
    }

    #[cfg(coverage)]
    pub fn cycle_forced(&self) -> Result<()> {
        self.cycle_internal(true)
    }

    #[cfg(coverage)]
    fn cycle_internal(&self, force_cycle: bool) -> Result<()> {
        let ctrl = Self::find_controller().or_else(|_| {
            Self::probe_platform_udc()?.ok_or_else(|| anyhow::anyhow!("no UDC present"))
        })?;

        if !force_cycle {
            match Self::state(&ctrl) {
                Ok(state)
                    if matches!(
                        state.as_str(),
                        "configured" | "addressed" | "default" | "suspended" | "unknown"
                    ) =>
                {
                    return Ok(());
                }
                Err(_) => return Ok(()),
                _ => {}
            }
        }

        let _ = Self::write_attr(self.udc_file, "");
        let _ = Self::wait_state_any(&ctrl, 3_000);
        let _ = Self::rebind_driver(&ctrl);
        let _ = Self::wait_udc_present(&ctrl, 3_000);
        Self::write_attr(self.udc_file, &ctrl)?;
        let _ = Self::wait_state_any(&ctrl, 6_000);
        Ok(())
    }

    #[cfg(not(coverage))]
    pub fn cycle(&self) -> Result<()> {
        self.cycle_internal(env::var("LESAVKA_GADGET_FORCE_CYCLE").is_ok())
    }

    #[cfg(not(coverage))]
    pub fn cycle_forced(&self) -> Result<()> {
        self.cycle_internal(true)
    }

    #[cfg(not(coverage))]
    fn cycle_internal(&self, force_cycle: bool) -> Result<()> {
        /* 0 - ensure we *know* the controller even after a previous crash */
        let ctrl = Self::find_controller().or_else(|_| {
            Self::probe_platform_udc()?.ok_or_else(|| anyhow::anyhow!("no UDC present"))
        })?;
        match Self::state(&ctrl) {
            Ok(state)
                if !force_cycle
                    && matches!(
                        state.as_str(),
                        "configured" | "addressed" | "default" | "suspended"
                    ) =>
            {
                warn!(
                    "🔒 refusing gadget cycle while host attached (state={state}); set LESAVKA_GADGET_FORCE_CYCLE=1 to override"
                );
                return Ok(());
            }
            Ok(state) if !force_cycle && state == "unknown" => {
                warn!(
                    "🔒 refusing gadget cycle with unknown UDC state; set LESAVKA_GADGET_FORCE_CYCLE=1 to override"
                );
                return Ok(());
            }
            Err(_) if !force_cycle => {
                warn!(
                    "🔒 refusing gadget cycle without UDC state; set LESAVKA_GADGET_FORCE_CYCLE=1 to override"
                );
                return Ok(());
            }
            _ => {}
        }

        /* 1 - detach gadget */
        info!("🔌 detaching gadget from {ctrl}");
        // a) drop pull-ups (if the controller offers the switch)
        let sc = format!("{}/class/udc/{ctrl}/soft_connect", Self::sysfs_root());
        let _ = Self::write_attr(&sc, "0"); // ignore errors - not all HW has it

        // b) clear the UDC attribute; the kernel may transiently answer EBUSY
        for attempt in 1..=10 {
            match Self::write_attr(self.udc_file, "") {
                Ok(_) => break,
                Err(err)
                    if {
                        // only swallow EBUSY
                        err.downcast_ref::<std::io::Error>()
                            .and_then(|io| io.raw_os_error())
                            == Some(libc::EBUSY)
                            && attempt < 10
                    } =>
                {
                    trace!("⏳ UDC busy (attempt {attempt}/10) - retrying…");
                    thread::sleep(Duration::from_millis(100));
                }
                Err(err) => return Err(err),
            }
        }
        Self::wait_state(&ctrl, "not attached", 3_000)?;

        /* 2 - reset driver */
        Self::rebind_driver(&ctrl)?;

        /* 3 - wait UDC node to re-appear */
        Self::wait_udc_present(&ctrl, 3_000)?;

        /* 4 - re-attach + pull-up */
        info!("🔌 re-attaching gadget to {ctrl}");
        Self::write_attr(self.udc_file, &ctrl)?;
        if Path::new(&sc).exists() {
            // try to set the pull-up; ignore if the kernel rejects it
            match Self::write_attr(&sc, "1") {
                Err(err) => {
                    // only swallow specific errno values
                    if let Some(io) = err.downcast_ref::<std::io::Error>() {
                        match io.raw_os_error() {
                            // EINVAL | EPERM | ENOENT
                            Some(libc::EINVAL) | Some(libc::EPERM) | Some(libc::ENOENT) => {
                                warn!("⚠️ soft_connect unsupported ({io}); continuing");
                            }
                            _ => return Err(err), // propagate all other errors
                        }
                    } else {
                        return Err(err); // non-IO errors: propagate
                    }
                }
                Ok(_) => { /* success */ }
            }
        }

        /* 5 - wait for host (but tolerate sleep) */
        Self::wait_state(&ctrl, "configured", 6_000).or_else(|e| {
            // If the host is physically absent (sleep / KVM paused)
            // we allow 'not attached' and continue - we can still
            // accept keyboard/mouse data and the host will enumerate
            // later without another reset.
            let last = fs::read_to_string(format!("{}/class/udc/{ctrl}/state", Self::sysfs_root()))
                .unwrap_or_default();
            if last.trim() == "not attached" {
                warn!("⚠️ host did not enumerate within 6 s - continuing (state = {last:?})");
                Ok(())
            } else {
                Err(e)
            }
        })?;

        info!("✅ USB-gadget cycle complete");
        Ok(())
    }

    /// helper: unbind + 300 ms reset + bind
    #[cfg(coverage)]
    fn rebind_driver(ctrl: &str) -> Result<()> {
        for drv in ["dwc2", "dwc3"] {
            let root = format!("{}/bus/platform/drivers/{drv}", Self::sysfs_root());
            if !Path::new(&root).exists() {
                continue;
            }
            Self::write_attr(format!("{root}/unbind"), ctrl)?;
            Self::write_attr(format!("{root}/bind"), ctrl)?;
            return Ok(());
        }
        Err(anyhow::anyhow!("no dwc2/dwc3 driver nodes found"))
    }

    #[cfg(not(coverage))]
    fn rebind_driver(ctrl: &str) -> Result<()> {
        let cand = ["dwc2", "dwc3"];
        for drv in cand {
            let root = format!("{}/bus/platform/drivers/{drv}", Self::sysfs_root());
            if !Path::new(&root).exists() {
                continue;
            }

            /*----------- unbind ------------------------------------------------*/
            info!("🔧 unbinding UDC driver ({drv})");
            for attempt in 1..=20 {
                match Self::write_attr(format!("{root}/unbind"), ctrl) {
                    Ok(_) => break,
                    Err(err) if attempt < 20 && Self::is_still_detaching(&err) => {
                        trace!("unbind in-progress (#{attempt}) - waiting…");
                        thread::sleep(Duration::from_millis(100));
                    }
                    Err(err) => return Err(err).context("UDC unbind failed irrecoverably"),
                }
            }
            thread::sleep(Duration::from_millis(150)); // let the core quiesce

            /*----------- bind --------------------------------------------------*/
            info!("🔧 binding   UDC driver ({drv})");
            for attempt in 1..=20 {
                match Self::write_attr(format!("{root}/bind"), ctrl) {
                    Ok(_) => return Ok(()), // success 🎉
                    Err(err) if attempt < 20 && Self::is_still_detaching(&err) => {
                        trace!("bind busy (#{attempt}) - retrying…");
                        thread::sleep(Duration::from_millis(100));
                    }
                    Err(err) => return Err(err).context("UDC bind failed irrecoverably"),
                }
            }
        }
        Err(anyhow::anyhow!("no dwc2/dwc3 driver nodes found"))
    }

    fn is_still_detaching(err: &anyhow::Error) -> bool {
        err.downcast_ref::<std::io::Error>()
            .and_then(|io| io.raw_os_error())
            .map_or(false, |code| {
                matches!(code, libc::EBUSY | libc::ENOENT | libc::ENODEV)
            })
    }
}