vibeio 0.2.8

A high-performance, cross-platform asynchronous runtime for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! Utility types and functions for `vibeio`.
//!
//! This module provides supporting infrastructure for the library:
//! - `AsyncWrap`: a wrapper that adapts `AsyncRead`/`AsyncWrite` implementations
//!   to the `tokio::io` traits, enabling interoperability with tokio-based code.
//! - `supports_completion`: check if the current driver supports completion-based I/O.
//! - `supports_io_uring`: check if the system supports io_uring with required operations.

mod async_wrap;

pub use async_wrap::*;

use crate::current_driver;
#[cfg(target_os = "linux")]
use std::sync::OnceLock;

/// Check if the current driver supports completion-based I/O operations.
///
/// This function returns `true` when the runtime is using a driver that can
/// handle completion-based operations (e.g., io_uring with completion queues).
#[inline]
pub fn supports_completion() -> bool {
    current_driver().is_some_and(|driver| driver.supports_completion())
}

/// Check if the system supports io_uring with required operations.
///
/// This function performs a runtime probe to verify that io_uring is available
/// and supports the operations needed by the library (accept, connect, poll,
/// timeout, read, write, etc.). On non-Linux platforms, this always returns `false`.
///
/// The result is cached for the lifetime of the program.
#[inline]
pub fn supports_io_uring() -> bool {
    #[cfg(target_os = "linux")]
    {
        static SUPPORTED: OnceLock<bool> = OnceLock::new();
        *SUPPORTED.get_or_init(detect_io_uring_support)
    }

    #[cfg(not(target_os = "linux"))]
    {
        false
    }
}

#[cfg(target_os = "linux")]
fn detect_io_uring_support() -> bool {
    use io_uring::opcode;

    let ring = match build_probe_ring() {
        Ok(ring) => ring,
        Err(_) => return false,
    };

    let mut probe = io_uring::Probe::new();
    if ring.submitter().register_probe(&mut probe).is_err() {
        return false;
    }

    let mut required_ops = Vec::new();
    required_ops.extend_from_slice(&[
        opcode::Accept::CODE,
        opcode::Connect::CODE,
        opcode::PollAdd::CODE,
        opcode::Timeout::CODE,
        opcode::Read::CODE,
        opcode::Readv::CODE,
        opcode::Recv::CODE,
        opcode::RecvMsg::CODE,
        opcode::Send::CODE,
        opcode::SendMsg::CODE,
        opcode::Write::CODE,
        opcode::Writev::CODE,
    ]);

    #[cfg(feature = "fs")]
    required_ops.extend_from_slice(&[
        opcode::OpenAt::CODE,
        opcode::Fsync::CODE,
        opcode::MkDirAt::CODE,
        opcode::RenameAt::CODE,
        opcode::LinkAt::CODE,
        opcode::SymlinkAt::CODE,
        opcode::UnlinkAt::CODE,
    ]);

    #[cfg(all(feature = "fs", any(target_env = "gnu", musl_v1_2_3)))]
    required_ops.push(opcode::Statx::CODE);

    #[cfg(feature = "splice")]
    required_ops.push(opcode::Splice::CODE);

    required_ops.iter().all(|op| probe.is_supported(*op))
}

#[cfg(target_os = "linux")]
fn build_probe_ring() -> std::io::Result<io_uring::IoUring> {
    let mut builder = io_uring::IoUring::builder();
    builder
        .setup_single_issuer()
        .setup_coop_taskrun()
        .setup_taskrun_flag()
        .setup_submit_all();

    match builder.build(2) {
        Ok(ring) => Ok(ring),
        Err(_) => io_uring::IoUring::new(2),
    }
}