Struct IoUring 

pub struct IoUring { /* private fields */ }

Anneau io_uring : FD + mmaps (SQ/CQ/SQE) + slab d’opérations en vol (S1) + capabilities négociées.

Send mais pas Sync (ADR-022, Décision 6) : un reactor par thread. Pour le multi-thread, voir shared. L’invariant de sûreté (S1/S2) : tant qu’une opération est en vol, son buffer vit dans le slot du slab et le ring ne peut être détruit sans quiescence — aucune écriture kernel ne tombe sur de la mémoire libérée.

Implementations

impl IoUring

pub fn submit_accept_multishot( &mut self, listener: BorrowedFd<'_>, flags: AcceptFlags, ) -> Result<MultishotToken, Errno>

ACCEPT (13) + IORING_ACCEPT_MULTISHOT : un seul SQE accepte en continu — chaque connexion produit une complétion portant le FD accepté (Completion::accepted_fd), CQE_F_MORE maintenu jusqu’à la terminale (ex. listener fermé). O_CLOEXEC posé d’office.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_accept_multishot_direct( &mut self, listener: BorrowedFd<'_>, flags: AcceptFlags, ) -> Result<MultishotToken, Errno>

Variante descripteurs directs : chaque connexion atterrit dans un slot auto-alloué de la FixedFdTable (Temps 3a, FixedSlotTarget::Alloc). Le slot choisi est rendu dans cqe->res (Completion::allocated_slot). Pour les serveurs à fort taux de connexions (pas de FD ordinaire).

Le kernel rejette SOCK_CLOEXEC sur un descripteur direct : non posé (le O_CLOEXEC est appliqué à fixed_fd_install).

Errors

Voir IoUring::submit_accept_multishot.

pub fn submit_receive_multishot( &mut self, sock: BorrowedFd<'_>, group: &ProvidedBufferRing, flags: MessageFlags, ) -> Result<MultishotToken, Errno>

RECV (27) + IORING_RECV_MULTISHOT sur les buffers de group (IOSQE_BUFFER_SELECT) : chaque arrivée de données prend un buffer du groupe et produit une complétion. Complétion via Completion::into_provided_buffer.

Pénurie de buffers : si le groupe est vide à l’arrivée de données, la complétion porte -ENOBUFS et TERMINE le multishot (pas de F_MORE) — à distinguer d’une erreur réseau. L’application réapprovisionne puis resoumet.

Errors

[Errno::EBUSY] si la SQ/le slab sont pleins.

pub fn submit_read_multishot( &mut self, fd: BorrowedFd<'_>, group: &ProvidedBufferRing, offset: Option<u64>, ) -> Result<MultishotToken, Errno>

READ_MULTISHOT (49) sur les buffers de group : flux de lectures, chaque arrivée prenant un buffer du groupe. Même sémantique de pénurie -ENOBUFS terminante que IoUring::submit_receive_multishot. L’opcode dédié implique le multishot (pas de drapeau d’op séparé).

Errors

Voir IoUring::submit_receive_multishot.

pub fn submit_poll_multishot( &mut self, fd: BorrowedFd<'_>, events: PollEvents, ) -> Result<MultishotToken, Errno>

POLL_ADD (6) + IORING_POLL_ADD_MULTI : chaque transition d’état du FD vers les events surveillés produit une complétion (Completion::into_poll_result), F_MORE maintenu. Edge-triggered (la surface validée ne porte pas d’option level-triggered).

Errors

[Errno::EBUSY] si la SQ/le slab sont pleins.

pub fn submit_timeout_multishot( &mut self, interval: Duration, flags: TimeoutFlags, ) -> Result<MultishotToken, Errno>

TIMEOUT (11) + IORING_TIMEOUT_MULTISHOT : émet une complétion à intervalle régulier (timer répétitif) jusqu’à annulation — battement périodique dans le reactor sans resoumettre à chaque tick. Le __kernel_timespec est gardé en vie dans le slot (vivant jusqu’à la terminale).

Errors

[Errno::EBUSY] si la SQ/le slab sont pleins.

pub fn cancel_multishot(&mut self, token: MultishotToken) -> Result<(), Errno>

Annule un multishot en vol, en ciblant son token. La complétion terminale (sans F_MORE, souvent -ECANCELED) libère le slot ; les CQE tardifs éventuels sont filtrés par la génération (S1).

Utilise l’annulation synchrone par jeton (IORING_REGISTER_SYNC_CANCEL, CancelTarget::Token) — cohérente avec un retour Result<()> (pas de CQE d’annulation supplémentaire à drainer ; la terminale du multishot suffit). submit_cancel (Temps 2c) reste disponible pour les annulations groupées.

Errors

[Errno::ENOENT] si le multishot s’est déjà terminé (rien à annuler) ; autres erreurs de io_uring_register.

impl IoUring

pub fn submit_message_ring_data_to( &mut self, target: &RingHandle, res: i32, user_data: u64, flags: MessageRingFlags, ) -> Result<SubmissionToken, Errno>

msg_ring (Temps 2c, MSG_DATA) ciblant un pair par sa RingHandle (FD), pour réveiller/transmettre une donnée vers un ring d’un autre thread (modèle thread-per-core / RingPool). Variante de IoUring::submit_message_ring_data (qui prend une &IoUring, même contexte).

Errors

[Errno::EBUSY] si la SQ/le slab sont pleins ; à la complétion, EBADF si le ring cible n’existe plus.

impl IoUring

pub fn submit_nop_with_result( &mut self, injected: i32, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_NOP (0) injectant un résultat (res = injected) via IORING_NOP_INJECT_RESULT. Précieux pour exercer les chemins d’erreur des accesseurs sans provoquer de vraie erreur kernel. Complétion via Completion::into_result.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_timeout( &mut self, spec: TimeoutSpec, flags: TimeoutFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_TIMEOUT (11) : échéance temporelle et/ou seuil de complétions. res == -ETIME à l’expiration (succès si TimeoutFlags::ETIME_SUCCESS). Complétion via Completion::completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_timeout_remove( &mut self, target: SubmissionToken, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_TIMEOUT_REMOVE (12) : annule un timeout en vol désigné par son jeton. Complétion via completed (ENOENT si la cible est inconnue/déjà déclenchée).

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_timeout_update( &mut self, target: SubmissionToken, spec: TimeoutSpec, flags: TimeoutFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_TIMEOUT_REMOVE + IORING_TIMEOUT_UPDATE (12) : re-arme un timeout en vol avec un nouveau spec. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_cancel( &mut self, target: CancelTarget<'_>, flags: CancelFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_ASYNC_CANCEL (14) : variante asynchrone (dans le flux) du sync_cancel du Temps 1. La complétion de l’op annulée arrive en -ECANCELED, son slot S1 (et son buffer) restitué normalement. Complétion via into_result (= nombre d’opérations annulées ; -ENOENT si rien ne correspond, -EALREADY si déjà en cours).

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_poll_add( &mut self, fd: BorrowedFd<'_>, events: PollEvents, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_POLL_ADD (6) : surveille fd pour events (mono- coup ; multishot/level-triggered au Temps 3d). Complétion via Completion::into_poll_result.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_poll_remove( &mut self, target: SubmissionToken, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_POLL_REMOVE (7) : retire un poll en vol désigné par son jeton. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_poll_update( &mut self, target: SubmissionToken, events: PollEvents, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_POLL_REMOVE + IORING_POLL_UPDATE_EVENTS (7) : modifie les événements surveillés d’un poll en vol. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_epoll_ctl( &mut self, epfd: BorrowedFd<'_>, op: EpollOp, fd: BorrowedFd<'_>, event: EpollEvent, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_EPOLL_CTL (29) : add/mod/del sur un set epoll, en asynchrone. L’epoll_event est gardé en vie dans le slot (lu par le kernel). Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_waitid( &mut self, target: WaitTarget<'_>, options: WaitOptions, info: Box<SignalInfo>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_WAITID (50) : récolte la fin d’un enfant sans bloquer le reactor. Le kernel remplit info (siginfo_t, déplacé dans le slot). Complétion via Completion::into_waitid_result.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_message_ring_data( &mut self, target: &IoUring, res: i32, user_data: u64, flags: MessageRingFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_MSG_RING (40, MSG_DATA) : poste un CQE (res + user_data arbitraires) dans le ring cible — notification inter- reactor très légère. Complétion (côté émetteur) via completed ; côté cible, un CQE apparaît dans sa CQ.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_futex_wait( &mut self, region: &MmapRegion, offset: usize, expected: u64, mask: u64, flags: FutexFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FUTEX_WAIT (51) : attend que le mot futex à offset dans region soit réveillé (ou -EAGAIN si sa valeur ≠ expected à l’armement). mask est le bitset futex (bits surveillés). La région est gardée vivante par le slot S1. Complétion via Completion::completed.

Errors

[Errno::EINVAL] si offset est hors bornes, non aligné sur 4, ou si la région n’est pas lisible (cf. MmapRegion::futex_word) ; [Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_futex_wake( &mut self, region: &MmapRegion, offset: usize, nr: u64, mask: u64, flags: FutexFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FUTEX_WAKE (52) : réveille jusqu’à nr waiters sur le mot futex à offset dans region (filtrés par mask). Complétion via Completion::into_result (nombre de waiters réveillés).

Errors

[Errno::EINVAL] si offset est invalide (cf. MmapRegion::futex_word) ; [Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_futex_waitv( &mut self, waiters: Vec<FutexWaiter>, flags: FutexFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FUTEX_WAITV (53) : attend sur plusieurs mots futex à la fois (réveil dès qu’un se déclenche). Chaque FutexWaiter désigne une région + offset, sa valeur attendue. Le tableau de futex_waitv et toutes les gardes de vivacité sont garés dans le slot S1. Complétion via Completion::completed.

Note ABI. struct futex_waitv du kernel ne porte pas de masque par-attendu (champs { val, uaddr, flags, __reserved }) : FutexWaiter n’expose donc pas de masque (un champ silencieusement ignoré serait un footgun, cf. ADR-032). Pour une attente masquée, utiliser IoUring::submit_futex_wait (mono-attente, qui garde mask).

Errors

[Errno::EINVAL] si waiters est vide, dépasse FUTEX_WAITV_MAX (128), ou si un offset est invalide ; [Errno::EBUSY] si la SQ ou le slab sont pleins.

impl IoUring

pub fn submit_socket_inq( &mut self, sock: BorrowedFd<'_>, ) -> Result<SubmissionToken, Errno>

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_outq( &mut self, sock: BorrowedFd<'_>, ) -> Result<SubmissionToken, Errno>

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_getsockopt( &mut self, sock: BorrowedFd<'_>, level: SocketOptionLevel, optname: i32, value: Vec<u8>, ) -> Result<SubmissionToken, Errno>

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_setsockopt( &mut self, sock: BorrowedFd<'_>, level: SocketOptionLevel, optname: i32, value: Vec<u8>, ) -> Result<SubmissionToken, Errno>

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_uring_cmd<C: UringCommand>( &mut self, fd: BorrowedFd<'_>, cmd: C, ) -> Result<SubmissionToken, Errno>

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 unsafe fn submit_uring_cmd_raw( &mut self, fd: BorrowedFd<'_>, cmd_op: u32, cmd_data: &[u8], flags: UringCmdFlags, ) -> Result<SubmissionToken, Errno>

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.

impl IoUring

pub fn submit_read( &mut self, fd: BorrowedFd<'_>, buffer: Vec<u8>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_READ (22). Le buffer est déplacé dans le slot ; sa longueur logique borne le nombre d’octets lus. À la complétion, Completion::into_buffer_result le restitue avec le compte d’octets.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins (avant tout syscall) ; [Errno::EINVAL] si buffer.len() déborde un u32.

pub fn submit_write( &mut self, fd: BorrowedFd<'_>, buffer: Vec<u8>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_WRITE (23) : écrit buffer.len() octets du buffer (déplacé dans le slot). Complétion via into_buffer_result.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si buffer.len() déborde un u32.

pub fn submit_readv( &mut self, fd: BorrowedFd<'_>, buffers: Vec<Vec<u8>>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_READV (1). Le tableau d’iovec est construit en interne et garé dans le slot avec les buffers possédés. Complétion via Completion::into_vectored_result.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si le nombre de buffers dépasse IOV_MAX (1024).

pub fn submit_writev( &mut self, fd: BorrowedFd<'_>, buffers: Vec<Vec<u8>>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_WRITEV (2). Voir IoUring::submit_readv.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si le nombre de buffers dépasse IOV_MAX.

pub fn submit_fsync( &mut self, fd: BorrowedFd<'_>, flags: FsyncFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FSYNC (3). FsyncFlags::DATASYNC ⇒ sémantique fdatasync. Complétion via Completion::completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_sync_file_range( &mut self, fd: BorrowedFd<'_>, offset: u64, nbytes: u64, flags: SyncFileRangeFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SYNC_FILE_RANGE (8). Complétion via completed.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si nbytes déborde un u32 (champ len du SQE).

pub fn submit_fallocate( &mut self, fd: BorrowedFd<'_>, mode: FallocateMode, offset: i64, length: i64, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FALLOCATE (17). Valide en amont length > 0 et l’absence de débordement offset + length (Principe 4). Complétion via completed.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si length ≤ 0, offset < 0, ou offset + length déborde un i64.

pub fn submit_ftruncate( &mut self, fd: BorrowedFd<'_>, length: u64, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FTRUNCATE (55) : redimensionne à length octets. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_openat2( &mut self, dirfd: DirFd<'_>, path: CString, how: OpenHow, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_OPENAT2 (28). Le chemin et la struct open_how (lus de façon asynchrone) sont gardés en vie dans le slot. O_CLOEXEC est ajouté d’office (cohérent avec le wrapper synchrone). Complétion via Completion::opened_fd.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_close(&mut self, fd: OwnedFd) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_CLOSE (19). Consomme l’OwnedFd (déplacé dans le slot) : il ne peut plus être réutilisé ⇒ pas de double close. Le FD n’est effectivement fermé qu’à l’exécution kernel. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_statx( &mut self, dirfd: DirFd<'_>, path: CString, flags: StatxFlags, mask: StatxMask, out: Box<Statx>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_STATX (21). Le kernel écrit la structure dans out (gardé en vie avec le chemin). Complétion via Completion::into_statx.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_fadvise( &mut self, fd: BorrowedFd<'_>, offset: u64, length: u64, advice: FadviseAdvice, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FADVISE (24) : conseil d’accès posix_fadvise. Complétion via completed.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si length déborde un u32 (champ len du SQE en 6.12).

pub fn submit_madvise( &mut self, region: &MmapRegion, range: Range<usize>, advice: MadviseAdvice, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_MADVISE (25) : conseil kernel sur le pattern d’accès à un sous-range d’une MmapRegion partageable. La région doit rester mappée jusqu’à la complétion : le slot S1 retient une garde de vivacité (MmapRegion::liveness_handle) — munmap ne peut donc pas survenir tant que l’op est en vol (sûreté par construction, cf. family-mem-mmap-region.md). Complétion via Completion::completed.

range est validé en amont (Principe 4) contre les bornes de la région : pas de plage brute, pas d’API unsafe.

Errors

[Errno::EINVAL] si range est mal formé (start > end) ou déborde la région (range.end > region.len()), ou si la longueur déborde un u32 ; [Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_splice( &mut self, fd_in: BorrowedFd<'_>, offset_in: Option<u64>, fd_out: BorrowedFd<'_>, offset_out: Option<u64>, length: u32, flags: SpliceFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SPLICE (30). Au moins un des deux FDs est un pipe. Les offsets None valent « position courante / FD non seekable ». Complétion via Completion::into_result (octets transférés).

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_tee( &mut self, fd_in: BorrowedFd<'_>, fd_out: BorrowedFd<'_>, length: u32, flags: SpliceFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_TEE (33) : duplique entre deux pipes sans consommer la source. Complétion via into_result (octets transférés).

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_mkdirat( &mut self, dirfd: DirFd<'_>, path: CString, mode: Mode, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_MKDIRAT (37). Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_unlinkat( &mut self, dirfd: DirFd<'_>, path: CString, flags: UnlinkFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_UNLINKAT (36). UnlinkFlags::REMOVEDIR supprime un répertoire. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_renameat( &mut self, old_dirfd: DirFd<'_>, old_path: CString, new_dirfd: DirFd<'_>, new_path: CString, flags: RenameFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_RENAMEAT (35, sémantique renameat2). Les deux chemins sont gardés en vie dans le slot. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_linkat( &mut self, old_dirfd: DirFd<'_>, old_path: CString, new_dirfd: DirFd<'_>, new_path: CString, flags: LinkFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_LINKAT (39). Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_symlinkat( &mut self, target: CString, new_dirfd: DirFd<'_>, link_path: CString, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SYMLINKAT (38) : crée link_path pointant vers target. Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_setxattr( &mut self, path: CString, name: CString, value: Vec<u8>, flags: XattrFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SETXATTR (42). name, value et path sont gardés en vie dans le slot. Complétion via completed.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si value.len() déborde un u32.

pub fn submit_getxattr( &mut self, path: CString, name: CString, value: Vec<u8>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_GETXATTR (44). value sert de buffer de sortie. Complétion via Completion::into_xattr_result.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si value.len() déborde un u32.

pub fn submit_fsetxattr( &mut self, fd: BorrowedFd<'_>, name: CString, value: Vec<u8>, flags: XattrFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FSETXATTR (41) : variante par FD. Complétion via completed.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si value.len() déborde un u32.

pub fn submit_fgetxattr( &mut self, fd: BorrowedFd<'_>, name: CString, value: Vec<u8>, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_FGETXATTR (43) : variante par FD. Complétion via into_xattr_result.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si value.len() déborde un u32.

impl IoUring

pub fn link_chain(&mut self) -> LinkedChainBuilder<'_>

Démarre la construction d’une chaîne liée (mode staging).

Les submit_* appelés via le builder sont mis en attente (slot S1 réservé + SQE écrit, lien posé sur le prédécesseur) sans publier la queue ; LinkedChainBuilder::submit publie la chaîne entière en une fois.

impl IoUring

pub fn submit_accept( &mut self, listener: BorrowedFd<'_>, flags: AcceptFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_ACCEPT (13) sans capturer l’adresse pair. CLOEXEC est ajouté d’office. Complétion via Completion::accepted_fd.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_accept_with_peer( &mut self, listener: BorrowedFd<'_>, flags: AcceptFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_ACCEPT (13) en capturant l’adresse pair dans un stockage possédé du slot. Complétion via Completion::into_accept_result.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_connect( &mut self, sock: BorrowedFd<'_>, address: SocketAddr, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_CONNECT (16). L’adresse est sérialisée et déplacée dans le slot. Complétion via Completion::completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_socket( &mut self, domain: SocketDomain, ty: SocketType, protocol: i32, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SOCKET (45). SOCK_CLOEXEC est ajouté d’office. Complétion via Completion::into_socket_fd.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_bind( &mut self, sock: BorrowedFd<'_>, address: SocketAddr, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_BIND (56, kernel ≥ 6.11). Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_listen( &mut self, sock: BorrowedFd<'_>, backlog: u32, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_LISTEN (57, kernel ≥ 6.11). Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_send( &mut self, sock: BorrowedFd<'_>, buffer: Vec<u8>, flags: MessageFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SEND (26). MSG_NOSIGNAL ajouté par défaut. Buffer déplacé dans le slot ; complétion via Completion::into_buffer_result.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si buffer.len() déborde un u32.

pub fn submit_receive( &mut self, sock: BorrowedFd<'_>, buffer: Vec<u8>, flags: MessageFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_RECV (27). Buffer déplacé dans le slot ; complétion via into_buffer_result. socket_has_pending_data() (CQE_F_SOCK_NONEMPTY) indique s’il reste des données à lire.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si buffer.len() déborde un u32.

pub fn submit_send_message( &mut self, sock: BorrowedFd<'_>, request: OwnedSendMessage, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SENDMSG (9) : envoi vectorisé + passage de FD (SCM_RIGHTS). MSG_NOSIGNAL par défaut. Tout l’état est déplacé dans le slot. Complétion via Completion::into_result (octets).

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_receive_message( &mut self, sock: BorrowedFd<'_>, request: OwnedReceiveMessage, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_RECVMSG (10) : réception vectorisée + réception de FD (SCM_RIGHTS). MSG_CMSG_CLOEXEC par défaut (FD reçus CLOEXEC). Complétion via Completion::into_receive_message_result.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_send_zero_copy( &mut self, sock: BorrowedFd<'_>, buffer: Vec<u8>, flags: MessageFlags, zero_copy: ZeroCopyFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SEND_ZC (47). Deux complétions (§4.1) : résultat (F_MORE, into_result) puis NOTIF (into_zero_copy_buffer). Le buffer reste vivant jusqu’au NOTIF. MSG_NOSIGNAL par défaut.

Errors

[Errno::EBUSY] (SQ/slab plein) ; [Errno::EINVAL] si buffer.len() déborde un u32.

pub fn submit_send_message_zero_copy( &mut self, sock: BorrowedFd<'_>, request: OwnedSendMessage, zero_copy: ZeroCopyFlags, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SENDMSG_ZC (48) : sendmsg zero-copy (vectorisé + FD passing). Deux complétions (§4.1). MSG_NOSIGNAL par défaut.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

pub fn submit_shutdown( &mut self, sock: BorrowedFd<'_>, how: ShutdownMode, ) -> Result<SubmissionToken, Errno>

Soumet un IORING_OP_SHUTDOWN (34). Complétion via completed.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins.

impl IoUring

pub fn submit_receive_provided( &mut self, sock: BorrowedFd<'_>, group: &ProvidedBufferRing, flags: MessageFlags, bundle: bool, ) -> Result<SubmissionToken, Errno>

IORING_OP_RECV (27) avec sélection automatique de buffer dans group (IOSQE_BUFFER_SELECT). Aucun buffer n’est attaché au slot S1. bundle active IORING_RECVSEND_BUNDLE (plusieurs buffers en un recv). Pénurie ⇒ complétion -ENOBUFS.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins ; à la complétion, -ENOBUFS si le groupe est vide.

pub fn submit_read_provided( &mut self, fd: BorrowedFd<'_>, group: &ProvidedBufferRing, length: u32, offset: Option<u64>, bundle: bool, ) -> Result<SubmissionToken, Errno>

IORING_OP_READ (22) avec sélection automatique de buffer. length borne le nombre d’octets lus (≤ taille du buffer). bundle active IORING_RECVSEND_BUNDLE.

Errors

Voir IoUring::submit_receive_provided.

impl IoUring

pub fn register_ring_fd(&mut self) -> Result<(), Errno>

REGISTER_RING_FDS (20) : enregistre le FD du ring → les io_uring_enter suivants utilisent IORING_ENTER_REGISTERED_RING (pas de résolution de FD). Idempotent côté façade : un second appel ré-enregistre (le kernel rend l’index).

Errors

Erreurs de io_uring_register ([Errno::EINVAL] si déjà enregistré côté kernel, [Errno::ENXIO]).

pub fn unregister_ring_fd(&mut self) -> Result<(), Errno>

UNREGISTER_RING_FDS (21) : désenregistre le FD du ring (retour aux enter par FD ordinaire).

Errors

[Errno::EINVAL] si le ring fd n’était pas enregistré ; erreurs de io_uring_register.

pub fn register_eventfd(&mut self, efd: BorrowedFd<'_>) -> Result<(), Errno>

REGISTER_EVENTFD (4) : lie un eventfd (famille ipc) aux complétions (le kernel y écrit à chaque CQE posté → réveil d’un reactor via epoll).

Errors

[Errno::EINVAL] si un eventfd est déjà enregistré ; [Errno::EBADF] si efd est invalide.

pub fn register_eventfd_async( &mut self, efd: BorrowedFd<'_>, ) -> Result<(), Errno>

REGISTER_EVENTFD_ASYNC (7) : comme IoUring::register_eventfd mais ne notifie que pour les complétions traitées en asynchrone (filtre le bruit des complétions inline).

Errors

Voir IoUring::register_eventfd.

pub fn unregister_eventfd(&mut self) -> Result<(), Errno>

UNREGISTER_EVENTFD (5) : détache l’eventfd.

Errors

[Errno::EINVAL] si aucun eventfd n’était enregistré.

pub fn register_personality(&mut self) -> Result<Personality, Errno>

REGISTER_PERSONALITY (9) : enregistre les credentials du process et rend un id (Personality) — une op peut ensuite s’exécuter avec ces credentials (sqe.personality, via IoUring::with_personality).

Errors

Erreurs de io_uring_register ([Errno::EINVAL] si la table de personalities est pleine).

pub fn unregister_personality(&mut self, p: Personality) -> Result<(), Errno>

UNREGISTER_PERSONALITY (10) : retire la personality p (id passé en nr_args).

Errors

[Errno::EINVAL] si l’id n’est pas enregistré.

pub fn set_work_queue_affinity(&mut self, cpus: &CpuSet) -> Result<(), Errno>

REGISTER_IOWQ_AFF (17) : fixe l’affinité CPU des workers io-wq.

Errors

[Errno::EINVAL] (masque invalide) ; erreurs de io_uring_register.

pub fn clear_work_queue_affinity(&mut self) -> Result<(), Errno>

UNREGISTER_IOWQ_AFF (18) : rétablit l’affinité par défaut des workers.

Errors

Erreurs de io_uring_register.

pub fn set_work_queue_max_workers( &mut self, bounded: u32, unbounded: u32, ) -> Result<WorkQueueWorkerLimits, Errno>

REGISTER_IOWQ_MAX_WORKERS (19) : plafonne les workers bornés/non-bornés (0 = inchangé). Rend les valeurs précédentes (réécrites par le kernel) — maîtrise de l’empreinte CPU sur matériel modeste (Charte).

Errors

Erreurs de io_uring_register.

pub fn register_napi(&mut self, config: NapiConfig) -> Result<NapiConfig, Errno>

REGISTER_NAPI (27) : active le busy-poll NAPI (latence réseau ↓, CPU ↑). Rend la configuration précédente (réécrite par le kernel).

Errors

Erreurs de io_uring_register ([Errno::EINVAL] si NAPI indisponible).

pub fn unregister_napi(&mut self) -> Result<(), Errno>

UNREGISTER_NAPI (28) : désactive le busy-poll NAPI.

Errors

Erreurs de io_uring_register.

pub fn register_clock(&mut self, clock: ClockSource) -> Result<(), Errno>

REGISTER_CLOCK (29) : fixe l’horloge des timeouts du ring (cohérent avec TimeoutFlags du Temps 2c et family-time).

Errors

Erreurs de io_uring_register ([Errno::EINVAL] si l’horloge n’est pas supportée).

pub fn submit_openat2_direct( &mut self, dirfd: DirFd<'_>, path: CString, how: OpenHow, slot: FixedSlotTarget, ) -> Result<SubmissionToken, Errno>

IORING_OP_OPENAT2 (28) direct : range le FD ouvert dans un slot fixe (slot) au lieu de le rendre en FD ordinaire. Pour FixedSlotTarget::Alloc, le slot choisi est rendu dans cqe->res (Completion::allocated_slot).

Errors

[Errno::EINVAL] si slot est Index(u32::MAX) ; [Errno::EBUSY] si la SQ/le slab sont pleins.

pub fn submit_accept_direct( &mut self, listener: BorrowedFd<'_>, flags: AcceptFlags, slot: FixedSlotTarget, ) -> Result<SubmissionToken, Errno>

IORING_OP_ACCEPT (13) direct : range le socket accepté dans un slot fixe. Pas de restitution d’adresse pair.

Le kernel rejette SOCK_CLOEXEC sur un descripteur direct (kernel-managed) : ne pas l’ajouter (flags transmis tel quel). Le O_CLOEXEC est posé à la matérialisation (fixed_fd_install).

Errors

Voir IoUring::submit_openat2_direct.

pub fn submit_socket_direct( &mut self, domain: SocketDomain, ty: SocketType, protocol: i32, slot: FixedSlotTarget, ) -> Result<SubmissionToken, Errno>

IORING_OP_SOCKET (45) direct : crée un socket rangé dans un slot fixe.

Le kernel rejette SOCK_CLOEXEC sur un descripteur direct : ne pas l’ajouter. Le O_CLOEXEC est posé à la matérialisation (fixed_fd_install).

Errors

Voir IoUring::submit_openat2_direct.

pub fn submit_read_fixed_file( &mut self, slot: FixedSlot<'_>, buffer: Vec<u8>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

IORING_OP_READ (22) via un FixedSlot (IOSQE_FIXED_FILE) : lit dans buffer (déplacé dans le slot). Complétion via Completion::into_buffer_result.

Errors

[Errno::EINVAL] si buffer.len() déborde un u32 ; [Errno::EBUSY] (SQ/slab pleins).

pub fn submit_write_fixed_file( &mut self, slot: FixedSlot<'_>, buffer: Vec<u8>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

IORING_OP_WRITE (23) via un FixedSlot : écrit buffer (déplacé dans le slot). Complétion via Completion::into_buffer_result.

Errors

Voir IoUring::submit_read_fixed_file.

pub fn submit_fixed_fd_install( &mut self, slot: FixedSlot<'_>, ) -> Result<SubmissionToken, Errno>

IORING_OP_FIXED_FD_INSTALL (54) : matérialise un FixedSlot (FD direct) en FD ordinaire (O_CLOEXEC posé). Complétion via Completion::opened_fd.

Errors

[Errno::EBUSY] (SQ/slab pleins) ; à la complétion, EBADF si le slot est vide.

pub fn submit_read_fixed( &mut self, fd: BorrowedFd<'_>, slice: RegisteredBufferSlice<'_>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

IORING_OP_READ_FIXED (4) : lit fd dans la tranche d’un buffer enregistré (slice). Les octets atterrissent dans la mémoire épinglée (relue via la RegisteredBuffers). Complétion via Completion::into_result (nombre d’octets).

Errors

[Errno::EINVAL] si la tranche déborde un u32/u16 ; [Errno::EBUSY].

pub fn submit_write_fixed( &mut self, fd: BorrowedFd<'_>, slice: RegisteredBufferSlice<'_>, offset: Option<u64>, ) -> Result<SubmissionToken, Errno>

IORING_OP_WRITE_FIXED (5) : écrit dans fd depuis la tranche d’un buffer enregistré. Complétion via Completion::into_result (nombre d’octets).

Errors

Voir IoUring::submit_read_fixed.

impl IoUring

pub fn new(entries: NonZeroU32) -> Result<Self, Errno>

Raccourci : IoUringBuilder::new(entries).build().

Errors

Voir IoUringBuilder::build.

pub fn enable(&mut self) -> Result<(), Errno>

Active un ring créé avec R_DISABLED (REGISTER_ENABLE_RINGS).

Inutile sur un ring déjà actif : retourne alors l’EINVAL du kernel.

Errors

• [Errno::EINVAL] : ring déjà actif (remonté tel quel).
• [Errno::EBADF] : FD de ring invalide.

pub fn completion_queue_overflowed(&self) -> bool

Vrai si la CQ a débordé (IORING_SQ_CQ_OVERFLOW). Avec FEAT_NODROP (présent en 6.12) le kernel retient les complétions et les re-livre.

pub fn submission_queue_space_left(&self) -> u32

Nombre de places libres dans la SQ (calculé par tail - head masqué).

pub fn in_flight(&self) -> u32

Nombre d’opérations actuellement en vol (slots occupés du slab S1).

pub fn shutdown(self) -> Result<(), Errno>

Téardown propre (S2) : annule les ops en vol (IoUring::sync_cancel Any), draine la CQ jusqu’à in_flight() == 0, munmap les anneaux et ferme le FD. À préférer au drop implicite sur chemin chaud.

Errors

Propage les erreurs de drainage/annulation (l’appelant décide de la suite) ; voir IoUring::sync_cancel.

impl IoUring

pub fn submit(&mut self) -> Result<u32, Errno>

Soumet les SQE en attente (io_uring_enter, sans attente). Retourne le nombre de SQE consommés par le kernel.

Publie la queue SQ par un store release (§3.2) avant l’enter. En mode SQPOLL chaud, peut n’avoir aucun syscall à faire (juste la publication), ne réveillant le thread que si SQ_NEED_WAKEUP.

Errors

• [Errno::EINTR] : remonté tel quel (ADR-021 conv. 2 ; l’appelant écrit sa propre boucle de retry).
• [Errno::EAGAIN] : ressources momentanément indisponibles.
• [Errno::EBUSY] : CQ pleine non drainée (selon contexte).
• [Errno::EINVAL], [Errno::EFAULT], [Errno::EBADF].

pub fn submit_and_wait(&mut self, want: u32) -> Result<u32, Errno>

Soumet puis attend au moins want complétions (IORING_ENTER_GETEVENTS, min_complete = want).

Errors

Mêmes erreurs que IoUring::submit ; [Errno::EINTR] remonté tel quel.

pub fn with(&mut self, opts: SubmitOptions) -> &mut Self

Applique des options par-opération (SubmitOptions) à la prochaine soumission submit_*. Style builder (chaînable).

pub fn with_personality(&mut self, personality: Personality) -> &mut Self

Exécute la prochaine soumission submit_* avec les credentials d’une Personality enregistrée (sqe.personality, Temps 3a §6). Consommée pour cette seule opération. Style builder (chaînable).

pub fn submit_nop(&mut self) -> Result<SubmissionToken, Errno>

Prépare et met en file un IORING_OP_NOP — la première opération de validation du cœur. Réserve un slot S1, écrit le SQE, et retourne le jeton ; la soumission effective se fait par IoUring::submit / IoUring::submit_and_wait.

Errors

[Errno::EBUSY] si la SQ ou le slab sont pleins (back-pressure structurelle, aucun syscall — §4.3).

impl IoUring

pub fn submission_queue_capacity(&self) -> u32

Capacité totale de la SQ (entrées effectives, arrondi kernel). Sûr.

pub fn submission_queue_available(&self) -> u32

Emplacements SQ actuellement disponibles. Sûr.

pub fn completion_queue_capacity(&self) -> u32

Capacité totale de la CQ. Sûr.

pub unsafe fn raw_get_submission_queue_entry( &mut self, ) -> Option<&mut RawSubmissionQueueEntry>

Réserve un emplacement SQE libre et le rend pour remplissage manuel (accès brut niveau 1, Temps 4). None si la SQ est pleine. La publication reste submit()/submit_and_wait() (sûrs) : la façade fait le store release et garde la main sur l’ordering d’anneau ; l’unsafe ne porte donc QUE sur le contenu du SQE et la validité des buffers.

Safety

L’appelant garantit (contrat §6 de la spec) :

1. opcode valide et supporté par le kernel courant (IoUring::supports_op/probe) ;
2. cohérence des champs du SQE (fd/addr/len/flags) pour cet opcode ;
3. validité mémoire : tout buffer pointé par addr/addr2/addr3 reste valide et non déplacé jusqu’à la complétion (le slab S1 ne le protège pas en accès brut) ;
4. tag user_data : poser RAW_USER_DATA_TAG (§5) pour coexister avec le niveau 2 sans collision (vérifié en build debug à la soumission) ;
5. pas de double consommation de la complétion correspondante (IoUring::raw_advance_completion_queue cohérent avec les peeks).

pub fn raw_peek_completion_queue_entry( &self, ) -> Option<&RawCompletionQueueEntry>

Inspecte la prochaine complétion sans la consommer (None si la CQ est vide). Sûr : lecture seule via le load acquire interne. L’interprétation de res/flags et la lecture du tag user_data (§5) sont à la charge de l’appelant (selon l’opcode soumis).

pub fn raw_advance_completion_queue(&mut self, n: u32)

Consomme n complétions de la CQ (avance la tête + store release par la façade). Sûr : borné au nombre réellement prêt (Principe 4) ; l’appelant garantit la cohérence avec ses IoUring::raw_peek_completion_queue_entry (pas de double consommation, §6 pt 5).

impl IoUring

pub fn wait_completion(&mut self) -> Result<Completion, Errno>

Attend (bloquant) la prochaine complétion et la consomme (io_uring_enter(.., GETEVENTS, min_complete = 1) ; lecture de la CQ par load acquire, §3.2). Les complétions périmées (génération de slot non concordante, §4.2) sont filtrées en silence.

Errors

• [Errno::EINTR] : remonté tel quel.
• [Errno::EBADF].

pub fn wait_completion_timeout( &mut self, timeout: Duration, ) -> Result<Option<Completion>, Errno>

Attend une complétion avec délai maximal (IORING_ENTER_EXT_ARG + io_uring_getevents_arg, ou ABS_TIMER si FEAT_MIN_TIMEOUT). Retourne Ok(None) à l’expiration.

Errors

• [Errno::EINTR] : remonté tel quel.
• [Errno::EBADF], [Errno::EINVAL].

pub fn try_completion(&mut self) -> Option<Completion>

Récupère une complétion si disponible, sans bloquer ni syscall (load acquire de la CQ). Filtre les complétions périmées.

pub fn completions(&mut self) -> CompletionIter<'_>

Itère les complétions actuellement disponibles dans la CQ, avançant head (store release) au fil de l’itération.

pub fn supports_op(&self, op: IoUringOpcode) -> bool

Vrai si le kernel courant supporte op (IORING_REGISTER_PROBE, mis en cache à la construction ; ADR-022 Décision 8). Permet le fallback vers le syscall synchrone correspondant.

pub fn capabilities(&self) -> IoUringCapabilities

Features io_uring négociées au setup (axe G), exposées par prédicats stables.

pub fn sync_cancel(&mut self, target: CancelTarget<'_>) -> Result<u32, Errno>

Annulation synchrone globale ou ciblée (IORING_REGISTER_SYNC_CANCEL, avec timeout). Brique de IoUring::shutdown (S2). Retourne le nombre d’opérations annulées.

Errors

• [Errno::EINTR] : remonté tel quel.
• [Errno::EALREADY] : annulation déjà en cours pour la cible.
• [Errno::ENOENT] : aucune opération ne correspond à la cible.
• [Errno::EINVAL].

Trait Implementations

impl Drop for IoUring

fn drop(&mut self)

Filet de sécurité (S2) : si des ops sont en vol, quiesce (annule + draine, bloquant et best-effort, boucle bornée) avant de libérer la mémoire. Coût (blocage potentiel) assumé et documenté : sur chemin chaud, préférer IoUring::shutdown. Un Drop qui laisserait le kernel écrire dans de la mémoire libérée serait un défaut de soundness inacceptable en couche 0 (Principe 5 : sur-sécuriser puis dégraisser).

impl Send for IoUring