air_sys_syscall/io_uring/

cmd.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/.

//! Opération **`URING_CMD`** (opcode 46, **Temps 2d**) : passthrough par lequel
//! io_uring transmet une **commande opaque** au gestionnaire `uring_cmd` du
//! sous-système propriétaire du fichier visé (socket, NVMe, ublk…). C'est
//! l'opération la plus « brute » des Temps 2x : sa sémantique dépend du
//! sous-système cible, pas d'io_uring.
//!
//! Référence normative : `docs/specs/layer-0/io-uring-2d-cmd.md`.
//!
//! Deux niveaux d'exposition :
//! - **Commandes socket typées sûres** (`submit_socket_inq`/`outq`,
//!   `submit_getsockopt`/`setsockopt`) — les quatre `io_uring_socket_op` de 6.12 ;
//! - **Générique** : [`UringCommand`] (`unsafe trait`) + [`IoUring::submit_uring_cmd`]
//!   pour les sous-systèmes typés par leur consommateur (les structures NVMe/ublk
//!   vivent **là où elles sont utilisées**, pas en couche 0), et la forme **brute
//!   `unsafe`** [`IoUring::submit_uring_cmd_raw`] en dernier recours.
//!
//! **Disposition kernel du SQE pour `URING_CMD`** (uapi 6.12) : `cmd_op` en
//! `off` (offset 8) ; pour `getsockopt`/`setsockopt`, `level`/`optname` en `addr`
//! (offset 16, deux `u32`), `optlen` en `splice_fd_in` (offset 44), `optval` en
//! `addr3` (offset 48) ; la **zone `cmd[]`** générique commence à l'offset 48
//! (`addr3`/`__pad2` = 16 octets, étendue à 80 octets avec `SETUP_SQE128`).

use super::owned::OwnedOp;
use super::raw;
use super::{Completion, IoUring, SubmissionToken};
use air_sys_types::Errno;
use air_sys_types::fd::{AsRawFd, BorrowedFd};
use air_sys_types::io_uring::UringCmdFlags;
use air_sys_types::net::SocketOptionLevel;
use alloc::vec::Vec;

/// Une **commande passthrough** d'un sous-système, sérialisable dans la zone
/// `cmd[]` d'`URING_CMD`.
///
/// # Safety
///
/// L'implémenteur garantit que [`encode`](UringCommand::encode) produit une
/// commande **valide** pour le gestionnaire `uring_cmd` du `fd` ciblé, que
/// [`cmd_op`](UringCommand::cmd_op) est l'opération correcte du sous-système, et
/// que tout buffer externe référencé par la commande reste valide jusqu'à la
/// complétion. io_uring ne peut pas vérifier ces invariants (la zone `cmd[]` lui
/// est **opaque**) — d'où le `unsafe trait`.
pub unsafe trait UringCommand {
    /// Type de la valeur interprétée à la complétion.
    type Output;

    /// Opération propre au sous-système (`cmd_op`, posée en `off`).
    fn cmd_op(&self) -> u32;

    /// Taille requise de la zone de commande, en octets (`≤ 16`, ou `≤ 80` si le
    /// ring a `SETUP_SQE128`).
    fn cmd_len(&self) -> usize;

    /// Sérialise la commande dans `out` (de longueur exacte `cmd_len()`).
    fn encode(&self, out: &mut [u8]);

    /// Interprétation typée de la complétion (appelée par le consommateur, qui
    /// conserve une instance de la commande).
    ///
    /// # Errors
    ///
    /// L'[`Errno`] décodé de la complétion, ou toute erreur d'interprétation
    /// propre au sous-système.
    fn interpret(&self, completion: &Completion) -> Result<Self::Output, Errno>;
}

impl IoUring {
    /// Capacité de la zone `cmd[]` en octets : `16` (SQE standard) ou `80` si le
    /// ring a été créé avec `SetupFlags::SQE128`.
    fn cmd_zone_capacity(&self) -> usize {
        self.sq.sqe_size().saturating_sub(raw::CMD_ZONE_OFFSET)
    }

    /// Cœur commun `inq`/`outq` : `URING_CMD` sans buffer, `cmd_op` en `off`.
    /// Complétion via [`Completion::into_result`] (nombre d'octets en file).
    fn submit_socket_queue(
        &mut self,
        sock: BorrowedFd<'_>,
        cmd_op: u32,
    ) -> Result<SubmissionToken, Errno> {
        let fd = sock.as_raw_fd();
        self.submit_op(None, |sqe| {
            sqe.opcode = raw::IORING_OP_URING_CMD;
            sqe.fd = fd;
            sqe.off_or_addr2 = u64::from(cmd_op);
        })
    }

    /// Soumet `SIOCINQ` (octets disponibles en **lecture**) via `URING_CMD` sur
    /// un socket — l'équivalent `ioctl(SIOCINQ)` **dans le ring**.
    /// `cmd_op = SOCKET_URING_OP_SIOCINQ` (0). Complétion via
    /// [`Completion::into_result`] (nombre d'octets).
    ///
    /// # Errors
    ///
    /// [`Errno::EBUSY`] si la SQ ou le slab sont pleins ; à la complétion,
    /// `ENOTSOCK`/`EINVAL` selon le FD.
    pub fn submit_socket_inq(&mut self, sock: BorrowedFd<'_>) -> Result<SubmissionToken, Errno> {
        self.submit_socket_queue(sock, raw::SOCKET_URING_OP_SIOCINQ)
    }

    /// Soumet `SIOCOUTQ` (octets **en attente d'émission**) via `URING_CMD`.
    /// `cmd_op = SOCKET_URING_OP_SIOCOUTQ` (1). Complétion via
    /// [`Completion::into_result`].
    ///
    /// # Errors
    ///
    /// Voir [`IoUring::submit_socket_inq`].
    pub fn submit_socket_outq(&mut self, sock: BorrowedFd<'_>) -> Result<SubmissionToken, Errno> {
        self.submit_socket_queue(sock, raw::SOCKET_URING_OP_SIOCOUTQ)
    }

    /// Encode `level`/`optname` dans le champ `addr` (offset 16) : `level` en bits
    /// bas, `optname` en bits hauts (deux `u32`, ABI `getsockopt`/`setsockopt`).
    fn level_optname(level: SocketOptionLevel, optname: i32) -> u64 {
        u64::from(level.as_raw().cast_unsigned()) | (u64::from(optname.cast_unsigned()) << 32)
    }

    /// Soumet un **`getsockopt`** via `URING_CMD` (`cmd_op = GETSOCKOPT`, 2). Le
    /// buffer `value` est le **buffer de sortie** (ownership transféré, S1) : le
    /// kernel y écrit l'option. Complétion via
    /// [`Completion::into_buffer_result`] → `(value, longueur effective)`.
    ///
    /// # Errors
    ///
    /// [`Errno::EBUSY`] (SQ/slab plein) ; [`Errno::EINVAL`] si `value.len()`
    /// déborde un `u32` ; à la complétion, `ENOPROTOOPT`/`EINVAL`/`ENOTSOCK`/`EFAULT`.
    pub fn submit_getsockopt(
        &mut self,
        sock: BorrowedFd<'_>,
        level: SocketOptionLevel,
        optname: i32,
        mut value: Vec<u8>,
    ) -> Result<SubmissionToken, Errno> {
        let fd = sock.as_raw_fd();
        let optlen = u32::try_from(value.len()).map_err(|_| Errno::EINVAL)?;
        let optval = value.as_mut_ptr() as u64;
        let level_optname = Self::level_optname(level, optname);
        self.submit_op(Some(OwnedOp::Bytes(value)), |sqe| {
            sqe.opcode = raw::IORING_OP_URING_CMD;
            sqe.fd = fd;
            sqe.off_or_addr2 = u64::from(raw::SOCKET_URING_OP_GETSOCKOPT);
            sqe.addr_or_splice_off_in = level_optname;
            sqe.splice_fd_in_or_file_index = optlen;
            sqe.addr3 = optval;
        })
    }

    /// Soumet un **`setsockopt`** via `URING_CMD` (`cmd_op = SETSOCKOPT`, 3). Le
    /// buffer `value` (octets, Principe 3) est **déplacé dans le slot** (le kernel
    /// le lit jusqu'à la complétion). Complétion via [`Completion::completed`].
    ///
    /// # Errors
    ///
    /// [`Errno::EBUSY`] (SQ/slab plein) ; [`Errno::EINVAL`] si `value.len()`
    /// déborde un `u32` ; à la complétion, `ENOPROTOOPT`/`EINVAL`/`ENOTSOCK`/`EFAULT`.
    pub fn submit_setsockopt(
        &mut self,
        sock: BorrowedFd<'_>,
        level: SocketOptionLevel,
        optname: i32,
        value: Vec<u8>,
    ) -> Result<SubmissionToken, Errno> {
        let fd = sock.as_raw_fd();
        let optlen = u32::try_from(value.len()).map_err(|_| Errno::EINVAL)?;
        let optval = value.as_ptr() as u64;
        let level_optname = Self::level_optname(level, optname);
        self.submit_op(Some(OwnedOp::Bytes(value)), |sqe| {
            sqe.opcode = raw::IORING_OP_URING_CMD;
            sqe.fd = fd;
            sqe.off_or_addr2 = u64::from(raw::SOCKET_URING_OP_SETSOCKOPT);
            sqe.addr_or_splice_off_in = level_optname;
            sqe.splice_fd_in_or_file_index = optlen;
            sqe.addr3 = optval;
        })
    }

    /// Écrit les champs nommés (`opcode`/`fd`/`cmd_op`/`op_flags`) puis sérialise
    /// `cmd_bytes` dans la **zone `cmd[]`** (offset 48), via le pointeur brut du
    /// slot (dont la provenance couvre tout le SQE, y compris l'extension
    /// `SQE128`). Cœur commun du générique et du brut.
    fn submit_cmd_zone(
        &mut self,
        fd: i32,
        cmd_op: u32,
        op_flags: u32,
        cmd_bytes: &[u8],
    ) -> Result<SubmissionToken, Errno> {
        self.submit_filled(None, |sqe_ptr| {
            {
                // SAFETY: `sqe_ptr` pointe un slot SQE valide et exclusivement
                // détenu ; le `&mut` ne vit que cette portée (avant l'écriture
                // brute de `cmd[]` ci-dessous — pas d'aliasing simultané).
                let sqe = unsafe { &mut *sqe_ptr };
                sqe.opcode = raw::IORING_OP_URING_CMD;
                sqe.fd = fd;
                sqe.off_or_addr2 = u64::from(cmd_op);
                sqe.op_flags = op_flags;
            }
            // SAFETY: `cmd_bytes.len() ≤ cmd_zone_capacity()` (validé par les
            // appelants) ⇒ `[48, 48 + len)` est **dans** le slot (`sqe_size`
            // octets). La provenance de `sqe_ptr` couvre tout le slot (cf.
            // `SubmissionRing::prepare`). `cmd_bytes` (source) et la zone (dest)
            // ne se chevauchent pas (buffer local vs mmap).
            unsafe {
                let zone = sqe_ptr.cast::<u8>().add(raw::CMD_ZONE_OFFSET);
                core::ptr::copy_nonoverlapping(cmd_bytes.as_ptr(), zone, cmd_bytes.len());
            }
        })
    }

    /// Soumet une commande passthrough **typée** ([`UringCommand`]) sur `fd`. La
    /// commande est **sérialisée** dans la zone `cmd[]` (la complétion sera
    /// interprétée par le consommateur via [`UringCommand::interpret`]).
    ///
    /// Vérifie `cmd.cmd_len() ≤ 16` (ou `≤ 80` si le ring a `SQE128`) **en amont**
    /// (Principe 4) — **pas de troncature silencieuse**.
    ///
    /// # Errors
    ///
    /// [`Errno::EINVAL`] si `cmd.cmd_len()` dépasse la capacité de la zone `cmd[]`
    /// du ring ; [`Errno::EBUSY`] si la SQ ou le slab sont pleins.
    pub fn submit_uring_cmd<C: UringCommand>(
        &mut self,
        fd: BorrowedFd<'_>,
        cmd: C,
    ) -> Result<SubmissionToken, Errno> {
        let len = cmd.cmd_len();
        if len > self.cmd_zone_capacity() {
            return Err(Errno::EINVAL);
        }
        // Zone maximale 6.12 (80 octets avec SQE128) ; sérialisation sur la pile.
        let mut buffer = [0u8; 80];
        // `len ≤ cmd_zone_capacity() ≤ 80` ⇒ tranche valide.
        let scratch = buffer.get_mut(..len).ok_or(Errno::EINVAL)?;
        cmd.encode(scratch);
        let fd = fd.as_raw_fd();
        let cmd_op = cmd.cmd_op();
        self.submit_cmd_zone(fd, cmd_op, 0, &buffer[..len])
    }

    /// Soumet une commande passthrough **brute** — échappatoire de dernier recours
    /// pour un sous-système non encore typé.
    ///
    /// # Safety
    ///
    /// L'appelant garantit que :
    /// 1. `cmd_data` est une commande **valide** pour le gestionnaire `uring_cmd`
    ///    du `fd` ciblé (contenu opaque pour io_uring) ;
    /// 2. tout buffer **référencé** par `cmd_data` reste valide **jusqu'à la
    ///    complétion** (la façade ne le maintient pas en vie) ;
    /// 3. `cmd_data.len() ≤ 16` (ou `≤ 80` si le ring a `SetupFlags::SQE128`) —
    ///    sinon `Err(EINVAL)` est rendu sans rien soumettre.
    ///
    /// # Errors
    ///
    /// [`Errno::EINVAL`] si `cmd_data.len()` dépasse la capacité de la zone
    /// `cmd[]` ; [`Errno::EBUSY`] si la SQ ou le slab sont pleins.
    pub unsafe fn submit_uring_cmd_raw(
        &mut self,
        fd: BorrowedFd<'_>,
        cmd_op: u32,
        cmd_data: &[u8],
        flags: UringCmdFlags,
    ) -> Result<SubmissionToken, Errno> {
        if cmd_data.len() > self.cmd_zone_capacity() {
            return Err(Errno::EINVAL);
        }
        let fd = fd.as_raw_fd();
        let op_flags = if flags.contains(UringCmdFlags::FIXED) {
            raw::IORING_URING_CMD_FIXED
        } else {
            0
        };
        self.submit_cmd_zone(fd, cmd_op, op_flags, cmd_data)
    }
}

// ───────────────────────────────────────────────────────────────────────────
// Tests
// ───────────────────────────────────────────────────────────────────────────
//
// Intégration (kernel 6.12 réel : socket loopback) en `#[cfg_attr(miri, ignore)]`
// (Miri ne modélise pas `io_uring_enter`). La sérialisation `encode` (bornée
// dans `cmd[]`) est testée **sous Miri** (logique pure, sans ring).

#[cfg(test)]
mod tests {
    use super::*;
    use crate::io_uring::{IoUringBuilder, SetupFlags};
    use crate::test_support::sfd;
    use air_sys_types::fd::AsFd;
    use core::num::NonZeroU32;
    use std::io::Write;

    // SOL_SOCKET / SO_* (valeurs uapi, cf. `family-net`).
    const SO_REUSEADDR: i32 = 2;
    const SO_RCVBUF: i32 = 8;

    fn ring8() -> IoUring {
        IoUring::new(NonZeroU32::new(16).expect("16 ≠ 0")).expect("io_uring_setup 6.12")
    }

    fn ring_sqe128() -> IoUring {
        IoUringBuilder::new(NonZeroU32::new(16).expect("16 ≠ 0"))
            .with_flags(SetupFlags::SQE128)
            .build()
            .expect("io_uring_setup SQE128 6.12")
    }

    fn tcp_pair() -> (std::net::TcpStream, std::net::TcpStream) {
        let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind loopback");
        let addr = listener.local_addr().expect("local_addr");
        let client = std::net::TcpStream::connect(addr).expect("connect loopback");
        let (server, _) = listener.accept().expect("accept loopback");
        (client, server)
    }

    fn complete_one(ring: &mut IoUring, expected: SubmissionToken) -> Completion {
        ring.submit_and_wait(1).expect("submit_and_wait");
        let c = ring.wait_completion().expect("wait_completion");
        assert_eq!(c.token(), expected, "user_data round-trip");
        c
    }

    /// Commande passthrough de test, sérialisée comme un motif `[op, i, i, …]`.
    #[derive(Clone, Copy)]
    struct TestCmd {
        op: u32,
        len: usize,
    }

    // SAFETY (test): `encode` écrit exactement `len` octets ; cette commande
    // n'est utilisée qu'avec un `cmd_op` **inconnu** du gestionnaire socket
    // (rejeté proprement) ou sous Miri (pas de soumission réelle).
    unsafe impl UringCommand for TestCmd {
        type Output = i32;
        fn cmd_op(&self) -> u32 {
            self.op
        }
        fn cmd_len(&self) -> usize {
            self.len
        }
        fn encode(&self, out: &mut [u8]) {
            for (i, byte) in out.iter_mut().enumerate() {
                // Motif déterministe borné (troncature volontaire sur 8 bits).
                *byte = u8::try_from(i & 0xFF).unwrap_or(0);
            }
        }
        fn interpret(&self, completion: &Completion) -> Result<i32, Errno> {
            // `completed()` décode le signe de `res` ; on rend la valeur brute.
            completion.completed().map(|()| completion.raw_result())
        }
    }

    // ── Sérialisation `encode` bornée (pure ; tourne sous Miri) ───────────────

    #[test]
    fn uring_command_encode_is_bounded() {
        // Reproduit la sérialisation de `submit_uring_cmd` sans ring (Miri-safe).
        let cmd = TestCmd { op: 7, len: 32 };
        let mut buffer = [0xFFu8; 80];
        let scratch = buffer.get_mut(..cmd.cmd_len()).expect("len ≤ 80");
        cmd.encode(scratch);
        // Les `len` premiers octets suivent le motif ; le reste reste intact.
        assert_eq!(buffer[0], 0);
        assert_eq!(buffer[31], 31);
        assert_eq!(buffer[32], 0xFF, "au-delà de cmd_len : non écrit");
        assert_eq!(cmd.cmd_op(), 7);
    }

    // ── Validation amont SQE128 (pure pour le refus ; ring requis) ────────────

    #[test]
    #[cfg_attr(miri, ignore = "io_uring_setup non supporté par Miri")]
    fn uring_cmd_over_16_refused_without_sqe128() {
        let (client, _server) = tcp_pair();
        let mut ring = ring8(); // SQE standard (16 o de cmd[])
        let cmd = TestCmd { op: 99, len: 32 };
        // Générique typé : > 16 o sans SQE128 ⇒ EINVAL en amont.
        assert_eq!(
            ring.submit_uring_cmd(sfd(&client), cmd).unwrap_err(),
            Errno::EINVAL
        );
        // Brut : idem.
        let data = [0u8; 32];
        // SAFETY (test): cmd_op inconnu, aucun buffer référencé ; on attend EINVAL
        // (refus en amont, rien n'est soumis).
        let err =
            unsafe { ring.submit_uring_cmd_raw(sfd(&client), 99, &data, UringCmdFlags::empty()) }
                .unwrap_err();
        assert_eq!(err, Errno::EINVAL);
    }

    #[test]
    #[cfg_attr(miri, ignore = "io_uring_setup non supporté par Miri")]
    fn uring_cmd_over_16_accepted_with_sqe128() {
        let (client, _server) = tcp_pair();
        let mut ring = ring_sqe128(); // 80 o de cmd[]
        let cmd = TestCmd { op: 99, len: 32 }; // `Copy` : reste utilisable après submit
        // Accepté par la façade (pas d'EINVAL amont) ⇒ jeton.
        let tok = ring
            .submit_uring_cmd(sfd(&client), cmd)
            .expect("submit_uring_cmd accepté avec SQE128");
        // La soumission/encodage SQE128 aboutit ; le gestionnaire socket rejette
        // un cmd_op inconnu (EOPNOTSUPP/EINVAL) — c'est une **complétion**, pas
        // un crash : preuve que le SQE 128 o est bien placé et lu.
        let completion = complete_one(&mut ring, tok);
        // L'interprétation typée du consommateur (trait `UringCommand`) décode la
        // même complétion : ici un rejet (cmd_op inconnu).
        let via_interpret = cmd.interpret(&completion);
        let via_result = completion.into_result();
        assert!(via_interpret.is_err(), "interpret : cmd_op inconnu rejeté");
        assert!(via_result.is_err(), "into_result : {via_result:?}");
    }

    #[test]
    #[cfg_attr(miri, ignore = "io_uring_setup non supporté par Miri")]
    fn uring_cmd_len_exceeding_capacity_refused() {
        let (client, _server) = tcp_pair();
        let mut ring = ring_sqe128();
        // 81 o > 80 (capacité SQE128) ⇒ EINVAL même avec SQE128.
        let cmd = TestCmd { op: 99, len: 81 };
        assert_eq!(
            ring.submit_uring_cmd(sfd(&client), cmd).unwrap_err(),
            Errno::EINVAL
        );
    }

    // ── Intégration socket : inq / outq / getsockopt / setsockopt ─────────────

    #[test]
    #[cfg_attr(miri, ignore = "syscall io_uring non supporté par Miri")]
    fn socket_inq_reports_queued_bytes() {
        let (mut client, server) = tcp_pair();
        let payload = b"abcd1234";
        client.write_all(payload).expect("write");
        client.flush().expect("flush");
        // Laisse le loopback livrer les octets dans la file de réception (≫ µs).
        std::thread::sleep(std::time::Duration::from_millis(20));
        let mut ring = ring8();
        let tok = ring.submit_socket_inq(sfd(&server)).expect("submit inq");
        let observed = complete_one(&mut ring, tok).into_result().expect("inq ok");
        assert_eq!(observed, i32::try_from(payload.len()).unwrap());
    }

    #[test]
    #[cfg_attr(miri, ignore = "syscall io_uring non supporté par Miri")]
    fn uring_cmd_raw_submits_with_and_without_fixed() {
        let (client, _server) = tcp_pair();
        let mut ring = ring8();
        let data = [0u8; 8]; // ≤ 16 o : tient dans un SQE standard
        // Sans FIXED (op_flags = 0) : soumission acceptée, cmd_op inconnu rejeté.
        // SAFETY (test): cmd_op inconnu, aucun buffer externe référencé.
        let tok =
            unsafe { ring.submit_uring_cmd_raw(sfd(&client), 99, &data, UringCmdFlags::empty()) }
                .expect("submit_uring_cmd_raw");
        assert!(complete_one(&mut ring, tok).into_result().is_err());
        // Avec FIXED (op_flags = IORING_URING_CMD_FIXED) : couvre la branche du
        // drapeau ; le kernel rejette (pas de buffer enregistré) → complétion.
        // SAFETY (test): idem ; FIXED sans buffer enregistré ⇒ erreur de complétion.
        let tok =
            unsafe { ring.submit_uring_cmd_raw(sfd(&client), 99, &data, UringCmdFlags::FIXED) }
                .expect("submit_uring_cmd_raw FIXED");
        assert!(complete_one(&mut ring, tok).into_result().is_err());
    }

    #[test]
    #[cfg_attr(miri, ignore = "syscall io_uring non supporté par Miri")]
    fn socket_outq_completes_nonnegative() {
        let (client, _server) = tcp_pair();
        let mut ring = ring8();
        let tok = ring.submit_socket_outq(sfd(&client)).expect("submit outq");
        let bytes = complete_one(&mut ring, tok).into_result().expect("outq ok");
        assert!(bytes >= 0, "octets en file d'émission ≥ 0");
    }

    #[test]
    #[cfg_attr(miri, ignore = "syscall io_uring non supporté par Miri")]
    fn getsockopt_so_rcvbuf_matches_sync() {
        let (_client, server) = tcp_pair();
        let mut ring = ring8();
        let tok = ring
            .submit_getsockopt(
                sfd(&server),
                SocketOptionLevel::Socket,
                SO_RCVBUF,
                vec![0u8; 4],
            )
            .expect("submit getsockopt");
        let (value, len) = complete_one(&mut ring, tok)
            .into_buffer_result()
            .expect("getsockopt ok");
        assert_eq!(len, 4, "SO_RCVBUF rend un i32");
        let via_uring = i32::from_ne_bytes(value[..4].try_into().expect("4 octets"));
        // Même option lue par le getter synchrone de `family-net` : valeurs égales.
        let via_sync = crate::net::get_so_rcvbuf(sfd(&server)).expect("get sync");
        assert_eq!(
            u32::try_from(via_uring).unwrap_or(0),
            via_sync,
            "getsockopt cohérent"
        );
        assert!(via_uring > 0);
    }

    #[test]
    #[cfg_attr(miri, ignore = "syscall io_uring non supporté par Miri")]
    fn setsockopt_so_reuseaddr_round_trip() {
        // Socket frais non lié (REUSEADDR se règle avant bind).
        let sock = crate::net::socket(
            air_sys_types::net::SocketDomain::Ipv4,
            air_sys_types::net::SocketType::Stream,
            0,
        )
        .expect("socket");
        let mut ring = ring8();
        let tok = ring
            .submit_setsockopt(
                sock.as_fd(),
                SocketOptionLevel::Socket,
                SO_REUSEADDR,
                1_i32.to_ne_bytes().to_vec(),
            )
            .expect("submit setsockopt");
        complete_one(&mut ring, tok)
            .completed()
            .expect("setsockopt ok");
        // Vérification croisée via le getter synchrone de `family-net`.
        assert!(
            crate::net::get_so_reuseaddr(sock.as_fd()).expect("get_so_reuseaddr"),
            "REUSEADDR activé via io_uring"
        );
    }
}