air_sys_syscall/

device.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

//! Wrappers de la famille `device`.
//!
//! Cf. `docs/specs/layer-0/family-device.md`.
//!
//! Trois sous-systèmes :
//! - **uevent** (netlink) : [`UEventSocket`] (RAII) + [`uevent_socket_open`] ;
//!   [`UEventSocket::read`] reçoit via `recvmsg` et **vérifie l'authenticité**
//!   (`nl_pid == 0`, et `uid == 0` du `SCM_CREDENTIALS` en mode `USERSPACE`)
//!   avant de décoder le message via [`air_sys_types::UEventMessage`].
//! - **evdev** : [`evdev_read_events`] (lecture typée) et les ioctls dédiés
//!   `EVIOC*` (jamais d'ioctl générique, ADR-021 conv. 3).
//! - **sysfs** : aucun wrapper (cf. spec sous-section 3 — c'est la famille `fs`).

use air_sys_types::fd::{AsRawFd, BorrowedFd, FromRawFd, OwnedFd};
use core::num::NonZeroI32;

use air_sys_types::{
    AbsAxis, Errno, EventClock, EventType, InputAbsInfo, InputEvent, InputId, UEventGroups,
    UEventMessage, UEventSocketFlags,
};

#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
compile_error!("air-sys-syscall::device supporte uniquement x86_64 et aarch64 (ADR-014).");

// ─────────────────────────────────────────────────────────────────────────
// Constantes kernel (identiques x86_64 / aarch64 — asm-generic).
// ─────────────────────────────────────────────────────────────────────────

const AF_NETLINK: i32 = 16;
const SOCK_RAW: i32 = 3;
const SOCK_CLOEXEC: i32 = 0x8_0000;
const NETLINK_KOBJECT_UEVENT: i32 = 15;
const SOL_SOCKET: i32 = 1;
const SO_PASSCRED: i32 = 16;
const SCM_CREDENTIALS: i32 = 2;

/// `'E'` — octet de type des ioctls evdev.
const EVIOC_TYPE: u8 = b'E';
/// `_IOC_NONE` / `_IOC_WRITE` / `_IOC_READ` (asm-generic ioctl.h).
const IOC_WRITE: u32 = 1;
const IOC_READ: u32 = 2;
/// Masque des 14 bits de taille d'une requête ioctl.
const IOC_SIZE_MASK: usize = 0x3fff;

// ─────────────────────────────────────────────────────────────────────────
// uevent — socket RAII.
// ─────────────────────────────────────────────────────────────────────────

/// Socket `NETLINK_KOBJECT_UEVENT` recevant les notifications de hotplug.
///
/// Drop ferme le FD via [`OwnedFd`]. `CLOEXEC` est toujours activé.
#[derive(Debug)]
pub struct UEventSocket {
    fd: OwnedFd,
    /// Vrai si le groupe `USERSPACE` est écouté : on exige alors un
    /// `SCM_CREDENTIALS` à `uid == 0` à chaque lecture.
    check_credentials: bool,
}

impl UEventSocket {
    /// Vue empruntée du FD sous-jacent.
    #[must_use]
    pub fn as_fd(&self) -> BorrowedFd<'_> {
        use air_sys_types::fd::AsFd;
        self.fd.as_fd()
    }

    /// Consomme et restitue le `OwnedFd`.
    #[must_use]
    pub fn into_fd(self) -> OwnedFd {
        self.fd
    }

    /// Lit un message uevent et le décode en place dans `buffer`.
    ///
    /// Le [`UEventMessage`] retourné **emprunte** `buffer` : il reste valide
    /// tant que le buffer n'est pas réutilisé. Aucune allocation.
    ///
    /// **Authenticité.** Le message est rejeté ([`Errno::EPERM`]) si l'adresse
    /// source n'est pas le kernel (`nl_pid != 0`) ou si, en mode `USERSPACE`,
    /// le crédential `SCM_CREDENTIALS` est absent ou n'a pas `uid == 0`.
    ///
    /// # Errors
    ///
    /// - [`Errno::EPERM`] : message rejeté (source non authentique).
    /// - [`Errno::EAGAIN`] : socket `NONBLOCK`, aucun message disponible.
    /// - [`Errno::EINTR`] : interrompu (remonté tel quel, ADR-021 conv. 2).
    /// - [`Errno::EBADMSG`] : message indécodable (en-tête `libudev` corrompu).
    /// - [`Errno::EMSGSIZE`] : message tronqué (buffer trop petit).
    pub fn read<'b>(&self, buffer: &'b mut [u8]) -> Result<UEventMessage<'b>, Errno> {
        let mut source = SockAddrNl::zeroed();
        let mut cmsg_buf = [0_u8; CMSG_BUFFER_SIZE];

        let mut iov = Iovec {
            iov_base: buffer.as_mut_ptr(),
            iov_len: buffer.len(),
        };
        let mut msg = MsgHdr {
            msg_name: (&raw mut source).cast::<u8>(),
            msg_namelen: SOCKADDR_NL_SIZE,
            msg_iov: &raw mut iov,
            msg_iovlen: 1,
            msg_control: cmsg_buf.as_mut_ptr(),
            msg_controllen: cmsg_buf.len(),
            msg_flags: 0,
        };

        // SAFETY: `recvmsg` lit le `MsgHdr` (pointeurs valides vers `source`,
        // `iov` couvrant `buffer`, `cmsg_buf`) et écrit le message reçu dans
        // `buffer`, l'adresse source dans `source`, les cmsg dans `cmsg_buf`.
        // Toutes les zones sont locales et vivantes pour la durée du syscall.
        let ret = unsafe { raw_syscall_recvmsg(self.fd.as_raw_fd(), &raw mut msg, 0) };
        if ret < 0 {
            return Err(errno_from_negative_syscall_ret(ret));
        }
        let received = usize::try_from(ret).map_err(|_| Errno::EBADMSG)?;
        let controllen = msg.msg_controllen.min(cmsg_buf.len());
        let control = cmsg_buf.get(..controllen).unwrap_or(&[]);

        authenticate_and_decode(
            msg.msg_flags,
            msg.msg_namelen,
            source.nl_pid,
            self.check_credentials,
            control,
            received,
            buffer,
        )
    }
}

/// Valide l'authenticité d'un message uevent reçu puis le décode.
///
/// Extrait du chemin `recvmsg` pour être testable au niveau frontière
/// (« simulateur de syscall ») sans privilège ni vrai hotplug.
fn authenticate_and_decode<'b>(
    msg_flags: i32,
    namelen: u32,
    nl_pid: u32,
    check_credentials: bool,
    control: &[u8],
    received: usize,
    buffer: &'b mut [u8],
) -> Result<UEventMessage<'b>, Errno> {
    if (msg_flags & MSG_TRUNC) != 0 {
        return Err(Errno::EMSGSIZE);
    }
    // Authenticité 1 : l'adresse source doit être le kernel (nl_pid == 0).
    if namelen < SOCKADDR_NL_SIZE || nl_pid != 0 {
        return Err(Errno::EPERM);
    }
    // Authenticité 2 : en mode USERSPACE, exiger SCM_CREDENTIALS uid == 0.
    if check_credentials && credential_uid(control) != Some(0) {
        return Err(Errno::EPERM);
    }
    let received = received.min(buffer.len());
    let payload = buffer.get(..received).unwrap_or(buffer);
    UEventMessage::parse(payload)
}

/// Ouvre un socket uevent lié aux `groups` demandés.
///
/// `CLOEXEC` est **toujours** activé. Si `groups` contient `USERSPACE`,
/// `SO_PASSCRED` est posé afin de vérifier l'identité des émetteurs userspace.
///
/// # Errors
///
/// - [`Errno::EINVAL`] : `groups` vide (rien à écouter).
/// - `EMFILE` / `ENFILE` / `ENOMEM` : limites de ressources.
pub fn uevent_socket_open(
    groups: UEventGroups,
    flags: UEventSocketFlags,
) -> Result<UEventSocket, Errno> {
    if groups.is_empty() {
        return Err(Errno::EINVAL);
    }

    let socket_type = SOCK_RAW | SOCK_CLOEXEC | (flags.bits() & UEventSocketFlags::NONBLOCK.bits());
    // SAFETY: socket(AF_NETLINK, SOCK_RAW|CLOEXEC[|NONBLOCK], proto) ne touche
    // aucune mémoire utilisateur ; retourne un fd ou un errno négatif.
    let ret = unsafe { raw_syscall_socket(AF_NETLINK, socket_type, NETLINK_KOBJECT_UEVENT) };
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    #[allow(clippy::cast_possible_truncation)]
    let raw_fd = ret as i32;
    // SAFETY: le kernel vient de transférer la propriété d'un fd valide ;
    // l'envelopper dans un OwnedFd garantit la fermeture (RAII) même en cas
    // d'erreur ultérieure (bind/setsockopt).
    let fd = unsafe { OwnedFd::from_raw_fd(raw_fd) };

    let check_credentials = groups.contains(UEventGroups::USERSPACE);
    if check_credentials {
        let enable: i32 = 1;
        // SAFETY: setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &enable, 4) lit 4
        // octets à `&enable`. Pas d'écriture utilisateur.
        let ret = unsafe {
            raw_syscall_setsockopt(
                fd.as_raw_fd(),
                SOL_SOCKET,
                SO_PASSCRED,
                (&raw const enable).cast::<u8>(),
                4,
            )
        };
        if ret < 0 {
            return Err(errno_from_negative_syscall_ret(ret));
        }
    }

    let addr = SockAddrNl {
        nl_family: u16::try_from(AF_NETLINK).expect("AF_NETLINK tient en u16"),
        nl_pad: 0,
        nl_pid: 0, // le kernel assigne le port id.
        nl_groups: groups.bits(),
    };
    // SAFETY: bind(fd, &addr, sizeof(sockaddr_nl)) lit 12 octets à `&addr`.
    let ret = unsafe {
        raw_syscall_bind(
            fd.as_raw_fd(),
            (&raw const addr).cast::<u8>(),
            SOCKADDR_NL_SIZE,
        )
    };
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }

    Ok(UEventSocket {
        fd,
        check_credentials,
    })
}

// ─────────────────────────────────────────────────────────────────────────
// uevent — structures kernel internes et parsing des credentials.
// ─────────────────────────────────────────────────────────────────────────

const SOCKADDR_NL_SIZE: u32 = 12;
const MSG_TRUNC: i32 = 0x20;
/// Place pour un `cmsghdr` (16 o) + `struct ucred` (12 o), aligné.
const CMSG_BUFFER_SIZE: usize = 64;

#[repr(C)]
#[derive(Clone, Copy)]
struct SockAddrNl {
    nl_family: u16,
    nl_pad: u16,
    nl_pid: u32,
    nl_groups: u32,
}

impl SockAddrNl {
    const fn zeroed() -> Self {
        Self {
            nl_family: 0,
            nl_pad: 0,
            nl_pid: 0,
            nl_groups: 0,
        }
    }
}

#[repr(C)]
struct Iovec {
    iov_base: *mut u8,
    iov_len: usize,
}

#[repr(C)]
struct MsgHdr {
    msg_name: *mut u8,
    msg_namelen: u32,
    msg_iov: *mut Iovec,
    msg_iovlen: usize,
    msg_control: *mut u8,
    msg_controllen: usize,
    msg_flags: i32,
}

/// Extrait l'`uid` du premier `SCM_CREDENTIALS` d'un tampon de contrôle.
///
/// Retourne `None` si aucun cmsg `SOL_SOCKET`/`SCM_CREDENTIALS` valide n'est
/// présent. Parsing emprunté, sans allocation, slicing via `get`.
fn credential_uid(control: &[u8]) -> Option<u32> {
    // struct cmsghdr { size_t cmsg_len; int cmsg_level; int cmsg_type; }
    const CMSG_HDR_SIZE: usize = 16;
    // CMSG_ALIGN(sizeof(cmsghdr)) = 16 sur LP64.
    const CMSG_DATA_OFFSET: usize = 16;
    // struct ucred { pid_t pid; uid_t uid; gid_t gid; } — uid à l'offset 4.
    const UCRED_UID_OFFSET: usize = 4;

    let mut offset = 0_usize;
    loop {
        let header_end = offset.checked_add(CMSG_HDR_SIZE)?;
        let header = control.get(offset..header_end)?;
        let len_bytes: [u8; 8] = header.get(0..8)?.try_into().ok()?;
        let level_bytes: [u8; 4] = header.get(8..12)?.try_into().ok()?;
        let type_bytes: [u8; 4] = header.get(12..16)?.try_into().ok()?;
        let cmsg_len = usize::try_from(u64::from_ne_bytes(len_bytes)).ok()?;
        let cmsg_level = i32::from_ne_bytes(level_bytes);
        let cmsg_type = i32::from_ne_bytes(type_bytes);

        if cmsg_len < CMSG_HDR_SIZE {
            return None;
        }
        if cmsg_level == SOL_SOCKET && cmsg_type == SCM_CREDENTIALS {
            let uid_start = offset
                .checked_add(CMSG_DATA_OFFSET)?
                .checked_add(UCRED_UID_OFFSET)?;
            let uid_end = uid_start.checked_add(4)?;
            let uid_bytes: [u8; 4] = control.get(uid_start..uid_end)?.try_into().ok()?;
            return Some(u32::from_ne_bytes(uid_bytes));
        }
        // Avance au prochain cmsg (CMSG_ALIGN(cmsg_len), align 8).
        let aligned = cmsg_len.checked_add(7)? & !7_usize;
        offset = offset.checked_add(aligned)?;
    }
}

// ─────────────────────────────────────────────────────────────────────────
// evdev — lecture typée.
// ─────────────────────────────────────────────────────────────────────────

/// Lit un lot d'événements dans `events`, sans allocation.
///
/// Retourne le nombre d'événements **complets** lus. Sur un FD `NONBLOCK`
/// sans donnée : [`Errno::EAGAIN`].
///
/// # Errors
///
/// - [`Errno::EAGAIN`] : mode non bloquant, rien à lire.
/// - [`Errno::EPROTO`] : le kernel a renvoyé un nombre d'octets non multiple
///   de `size_of::<InputEvent>()` (ne devrait jamais arriver).
/// - [`Errno::EBADF`] : `device` n'est pas un FD valide.
pub fn evdev_read_events(
    device: BorrowedFd<'_>,
    events: &mut [InputEvent],
) -> Result<usize, Errno> {
    let size = core::mem::size_of::<InputEvent>();
    let byte_len = events.len().checked_mul(size).ok_or(Errno::EINVAL)?;
    let ptr = events.as_mut_ptr().cast::<u8>();
    // SAFETY: `read` écrit au plus `byte_len` octets dans `events`,
    // réinterprété en octets. `InputEvent` est `#[repr(C)]` et accepte tout
    // motif binaire. Le buffer est vivant pour la durée du syscall.
    let ret = unsafe { raw_syscall_read(device.as_raw_fd(), ptr as u64, byte_len as u64) };
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    let bytes = usize::try_from(ret).unwrap_or(0);
    let rem = bytes.checked_rem(size).unwrap_or(0);
    if rem != 0 {
        return Err(Errno::EPROTO);
    }
    Ok(bytes.checked_div(size).unwrap_or(0))
}

// ─────────────────────────────────────────────────────────────────────────
// evdev — encodage des requêtes ioctl (_IOC).
// ─────────────────────────────────────────────────────────────────────────

/// Encode une requête ioctl `_IOC(dir, type, nr, size)` (asm-generic).
const fn ioc(dir: u32, ty: u8, nr: u8, size: u32) -> u32 {
    (dir << 30) | (size << 16) | ((ty as u32) << 8) | (nr as u32)
}

/// ioctl evdev à taille fixe écrivant dans `out` (`_IOR('E', nr, T)`).
fn evdev_ioctl_read_struct(
    device: BorrowedFd<'_>,
    nr: u8,
    out: *mut u8,
    size: u32,
) -> Result<(), Errno> {
    let request = ioc(IOC_READ, EVIOC_TYPE, nr, size);
    // SAFETY: ioctl(fd, _IOR('E',nr,T), out) écrit `size` octets à `out`
    // (buffer fourni par l'appelant, dimensionné pour T) ou retourne un
    // errno. Aucune lecture de mémoire non initialisée côté Air.
    let ret = unsafe { raw_syscall_ioctl(device.as_raw_fd(), u64::from(request), out as u64) };
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    Ok(())
}

/// ioctl evdev remplissant un buffer de taille variable (`EVIOCG{NAME,…}`).
///
/// Retourne la tranche effectivement remplie. La taille encodée est plafonnée
/// au masque 14 bits des requêtes ioctl.
fn evdev_ioctl_read_buffer<'b>(
    device: BorrowedFd<'_>,
    nr: u8,
    buffer: &'b mut [u8],
) -> Result<&'b [u8], Errno> {
    let capped = buffer.len().min(IOC_SIZE_MASK);
    let size = u32::try_from(capped).expect("capped ≤ 0x3fff tient en u32");
    let request = ioc(IOC_READ, EVIOC_TYPE, nr, size);
    let ptr = buffer.as_mut_ptr();
    // SAFETY: ioctl écrit au plus `size` octets à `ptr` (buffer appelant) et
    // retourne le nombre d'octets écrits, ou un errno.
    let ret = unsafe { raw_syscall_ioctl(device.as_raw_fd(), u64::from(request), ptr as u64) };
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    let written = usize::try_from(ret).unwrap_or(0).min(buffer.len());
    Ok(buffer.get(..written).unwrap_or(buffer))
}

/// ioctl evdev écrivant une valeur scalaire vers le kernel (`_IOW`).
fn evdev_ioctl_write(device: BorrowedFd<'_>, nr: u8, size: u32, arg: u64) -> Result<(), Errno> {
    let request = ioc(IOC_WRITE, EVIOC_TYPE, nr, size);
    // SAFETY: ioctl(fd, _IOW('E',nr,T), arg). Selon `nr`, `arg` est soit une
    // valeur entière (grab/release/revoke), soit un pointeur vers une zone
    // lisible de `size` octets (set_clock). Dans les deux cas l'appelant a
    // garanti la validité ; aucune écriture côté Air.
    let ret = unsafe { raw_syscall_ioctl(device.as_raw_fd(), u64::from(request), arg) };
    if ret < 0 {
        return Err(errno_from_negative_syscall_ret(ret));
    }
    Ok(())
}

// ─────────────────────────────────────────────────────────────────────────
// evdev — identité et description.
// ─────────────────────────────────────────────────────────────────────────

/// `EVIOCGVERSION` — version du protocole evdev du driver.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_driver_version(device: BorrowedFd<'_>) -> Result<u32, Errno> {
    let mut version: i32 = 0;
    evdev_ioctl_read_struct(device, 0x01, (&raw mut version).cast::<u8>(), 4)?;
    #[allow(clippy::cast_sign_loss)]
    Ok(version as u32)
}

/// `EVIOCGID` — identifiant bus/vendor/product/version.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_device_id(device: BorrowedFd<'_>) -> Result<InputId, Errno> {
    let mut id = InputId::default();
    let size = u32::try_from(core::mem::size_of::<InputId>()).expect("input_id tient en u32");
    evdev_ioctl_read_struct(device, 0x02, (&raw mut id).cast::<u8>(), size)?;
    Ok(id)
}

/// `EVIOCGNAME(len)` — nom du périphérique (octets, possiblement non-UTF-8).
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_name<'b>(device: BorrowedFd<'_>, buffer: &'b mut [u8]) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(device, 0x06, buffer)
}

/// `EVIOCGPHYS(len)` — emplacement physique (topologie).
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_physical_location<'b>(
    device: BorrowedFd<'_>,
    buffer: &'b mut [u8],
) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(device, 0x07, buffer)
}

/// `EVIOCGUNIQ(len)` — identifiant unique (souvent vide).
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_unique_id<'b>(
    device: BorrowedFd<'_>,
    buffer: &'b mut [u8],
) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(device, 0x08, buffer)
}

// ─────────────────────────────────────────────────────────────────────────
// evdev — capacités.
// ─────────────────────────────────────────────────────────────────────────

/// `EVIOCGBIT(event_type, len)` — bitmap des codes supportés. `event_type =
/// None` interroge les **types** supportés (`EVIOCGBIT(0, len)`).
///
/// # Errors
///
/// - [`Errno::EINVAL`] : `event_type` hors de la plage `EV_*` adressable.
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_supported_codes<'b>(
    device: BorrowedFd<'_>,
    event_type: Option<EventType>,
    bitmap: &'b mut [u8],
) -> Result<&'b [u8], Errno> {
    let ev = match event_type {
        Some(ty) => u8::try_from(ty.to_raw()).map_err(|_| Errno::EINVAL)?,
        None => 0,
    };
    // EVIOCGBIT(ev, len) → nr = 0x20 + ev (ev ≤ EV_MAX = 0x1f).
    let nr = 0x20_u8.checked_add(ev).ok_or(Errno::EINVAL)?;
    evdev_ioctl_read_buffer(device, nr, bitmap)
}

/// `EVIOCGPROP(len)` — propriétés du périphérique (`INPUT_PROP_*`).
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_properties<'b>(
    device: BorrowedFd<'_>,
    bitmap: &'b mut [u8],
) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(device, 0x09, bitmap)
}

/// `EVIOCGABS(axis)` — plage et état d'un axe absolu.
///
/// # Errors
///
/// - [`Errno::EINVAL`] : `axis` hors de la plage `ABS_*` adressable.
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_abs_info(device: BorrowedFd<'_>, axis: AbsAxis) -> Result<InputAbsInfo, Errno> {
    let abs = u8::try_from(axis.to_raw()).map_err(|_| Errno::EINVAL)?;
    // EVIOCGABS(abs) → nr = 0x40 + abs (abs ≤ ABS_MAX = 0x3f).
    let nr = 0x40_u8.checked_add(abs).ok_or(Errno::EINVAL)?;
    let mut info = InputAbsInfo::default();
    let size =
        u32::try_from(core::mem::size_of::<InputAbsInfo>()).expect("input_absinfo tient en u32");
    evdev_ioctl_read_struct(device, nr, (&raw mut info).cast::<u8>(), size)?;
    Ok(info)
}

// ─────────────────────────────────────────────────────────────────────────
// evdev — état courant.
// ─────────────────────────────────────────────────────────────────────────

/// `EVIOCGKEY(len)` — état actuel (enfoncé/relâché) de toutes les touches.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_key_state<'b>(d: BorrowedFd<'_>, bitmap: &'b mut [u8]) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(d, 0x18, bitmap)
}

/// `EVIOCGLED(len)` — état des LED.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_led_state<'b>(d: BorrowedFd<'_>, bitmap: &'b mut [u8]) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(d, 0x19, bitmap)
}

/// `EVIOCGSND(len)` — état des sorties son.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_sound_state<'b>(d: BorrowedFd<'_>, bitmap: &'b mut [u8]) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(d, 0x1a, bitmap)
}

/// `EVIOCGSW(len)` — état des interrupteurs (capot, jack...).
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_switch_state<'b>(d: BorrowedFd<'_>, bitmap: &'b mut [u8]) -> Result<&'b [u8], Errno> {
    evdev_ioctl_read_buffer(d, 0x1b, bitmap)
}

// ─────────────────────────────────────────────────────────────────────────
// evdev — contrôle exclusif et horloge.
// ─────────────────────────────────────────────────────────────────────────

/// `EVIOCGRAB` (argument `1`) — capture exclusive du périphérique.
///
/// # Errors
///
/// - [`Errno::EBUSY`] : un autre client détient déjà la capture.
pub fn evdev_grab(device: BorrowedFd<'_>) -> Result<(), Errno> {
    evdev_ioctl_write(device, 0x90, 4, 1)
}

/// `EVIOCGRAB` (pointeur nul) — relâche la capture exclusive.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_release(device: BorrowedFd<'_>) -> Result<(), Errno> {
    evdev_ioctl_write(device, 0x90, 4, 0)
}

/// `EVIOCREVOKE` — révoque définitivement l'accès à ce FD (irréversible).
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_revoke(device: BorrowedFd<'_>) -> Result<(), Errno> {
    evdev_ioctl_write(device, 0x91, 4, 0)
}

/// `EVIOCSCLOCKID` — choisit l'horloge des horodatages des événements.
///
/// # Errors
///
/// - [`Errno::ENOTTY`] : `device` n'est pas un periphérique evdev.
pub fn evdev_set_clock(device: BorrowedFd<'_>, clock: EventClock) -> Result<(), Errno> {
    let clockid: i32 = clock.to_clockid();
    evdev_ioctl_write(device, 0xa0, 4, (&raw const clockid) as u64)
}

// ─────────────────────────────────────────────────────────────────────────
// asm! wrappers x86_64 / aarch64.
// ─────────────────────────────────────────────────────────────────────────

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn raw_syscall_socket(domain: i32, ty: i32, protocol: i32) -> i64 {
    let ret: i64;
    // SAFETY: SYS_socket (x86_64 = 41). Pas d'accès mémoire utilisateur.
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 41_i64,
            in("rdi") i64::from(domain),
            in("rsi") i64::from(ty),
            in("rdx") i64::from(protocol),
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack, preserves_flags, readonly),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
#[inline]
unsafe fn raw_syscall_socket(domain: i32, ty: i32, protocol: i32) -> i64 {
    let ret: i64;
    // SAFETY: SYS_socket (aarch64 = 198).
    unsafe {
        core::arch::asm!(
            "svc 0",
            in("x8") 198_i64,
            inout("x0") i64::from(domain) => ret,
            in("x1") i64::from(ty),
            in("x2") i64::from(protocol),
            options(nostack, preserves_flags, readonly),
        );
    }
    ret
}

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn raw_syscall_bind(fd: i32, address: *const u8, addrlen: u32) -> i64 {
    let ret: i64;
    // SAFETY: SYS_bind (x86_64 = 49). Le kernel lit `addrlen` octets à
    // `address` ; pas d'écriture utilisateur.
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 49_i64,
            in("rdi") i64::from(fd),
            in("rsi") address as u64,
            in("rdx") u64::from(addrlen),
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack, preserves_flags, readonly),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
#[inline]
unsafe fn raw_syscall_bind(fd: i32, address: *const u8, addrlen: u32) -> i64 {
    let ret: i64;
    // SAFETY: SYS_bind (aarch64 = 200).
    unsafe {
        core::arch::asm!(
            "svc 0",
            in("x8") 200_i64,
            inout("x0") i64::from(fd) => ret,
            in("x1") address as u64,
            in("x2") u64::from(addrlen),
            options(nostack, preserves_flags, readonly),
        );
    }
    ret
}

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn raw_syscall_setsockopt(
    fd: i32,
    level: i32,
    optname: i32,
    optval: *const u8,
    optlen: u32,
) -> i64 {
    let ret: i64;
    // SAFETY: SYS_setsockopt (x86_64 = 54). Le kernel lit `optlen` octets à
    // `optval`. Pas d'écriture utilisateur.
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 54_i64,
            in("rdi") i64::from(fd),
            in("rsi") i64::from(level),
            in("rdx") i64::from(optname),
            in("r10") optval as u64,
            in("r8") u64::from(optlen),
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack, preserves_flags, readonly),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
#[inline]
unsafe fn raw_syscall_setsockopt(
    fd: i32,
    level: i32,
    optname: i32,
    optval: *const u8,
    optlen: u32,
) -> i64 {
    let ret: i64;
    // SAFETY: SYS_setsockopt (aarch64 = 208).
    unsafe {
        core::arch::asm!(
            "svc 0",
            in("x8") 208_i64,
            inout("x0") i64::from(fd) => ret,
            in("x1") i64::from(level),
            in("x2") i64::from(optname),
            in("x3") optval as u64,
            in("x4") u64::from(optlen),
            options(nostack, preserves_flags, readonly),
        );
    }
    ret
}

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn raw_syscall_recvmsg(fd: i32, msg: *mut MsgHdr, flags: i32) -> i64 {
    let ret: i64;
    // SAFETY: SYS_recvmsg (x86_64 = 47). Le kernel lit/écrit le `msghdr` à
    // `msg` et écrit dans les buffers qu'il référence (iov, control, name).
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 47_i64,
            in("rdi") i64::from(fd),
            in("rsi") msg as u64,
            in("rdx") i64::from(flags),
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack, preserves_flags),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
#[inline]
unsafe fn raw_syscall_recvmsg(fd: i32, msg: *mut MsgHdr, flags: i32) -> i64 {
    let ret: i64;
    // SAFETY: SYS_recvmsg (aarch64 = 212).
    unsafe {
        core::arch::asm!(
            "svc 0",
            in("x8") 212_i64,
            inout("x0") i64::from(fd) => ret,
            in("x1") msg as u64,
            in("x2") i64::from(flags),
            options(nostack, preserves_flags),
        );
    }
    ret
}

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn raw_syscall_read(fd: i32, buffer: u64, count: u64) -> i64 {
    let ret: i64;
    // SAFETY: SYS_read (x86_64 = 0). Le kernel écrit au plus `count` octets à
    // `buffer` (zone valide garantie par l'appelant).
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 0_i64,
            in("rdi") i64::from(fd),
            in("rsi") buffer,
            in("rdx") count,
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack, preserves_flags),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
#[inline]
unsafe fn raw_syscall_read(fd: i32, buffer: u64, count: u64) -> i64 {
    let ret: i64;
    // SAFETY: SYS_read (aarch64 = 63).
    unsafe {
        core::arch::asm!(
            "svc 0",
            in("x8") 63_i64,
            inout("x0") i64::from(fd) => ret,
            in("x1") buffer,
            in("x2") count,
            options(nostack, preserves_flags),
        );
    }
    ret
}

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn raw_syscall_ioctl(fd: i32, request: u64, arg: u64) -> i64 {
    let ret: i64;
    // SAFETY: SYS_ioctl (x86_64 = 16). L'effet mémoire dépend de `request` ;
    // chaque appelant a justifié la validité de `arg` pour sa requête.
    unsafe {
        core::arch::asm!(
            "syscall",
            in("rax") 16_i64,
            in("rdi") i64::from(fd),
            in("rsi") request,
            in("rdx") arg,
            lateout("rax") ret,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack, preserves_flags),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
#[inline]
unsafe fn raw_syscall_ioctl(fd: i32, request: u64, arg: u64) -> i64 {
    let ret: i64;
    // SAFETY: SYS_ioctl (aarch64 = 29).
    unsafe {
        core::arch::asm!(
            "svc 0",
            in("x8") 29_i64,
            inout("x0") i64::from(fd) => ret,
            in("x1") request,
            in("x2") arg,
            options(nostack, preserves_flags),
        );
    }
    ret
}

// ─────────────────────────────────────────────────────────────────────────
// errno helper.
// ─────────────────────────────────────────────────────────────────────────

fn errno_from_negative_syscall_ret(ret: i64) -> Errno {
    debug_assert!(ret < 0 && ret > -4096);
    #[allow(clippy::cast_possible_truncation)]
    let raw = ret.wrapping_neg() as i32;
    let nz = NonZeroI32::new(raw).expect("errno strictement positif par construction");
    Errno::from_nonzero(nz)
}

#[cfg(test)]
mod tests;