compio-compat 0.1.0-rc.1

Compatibility layer for compio to work with various async runtimes.
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

#[cfg(target_os = "linux")]
use std::os::fd::OwnedFd;
use std::{
    io,
    ops::Deref,
    os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd},
};

use compio_runtime::Runtime;
use mod_use::mod_use;

#[cfg(feature = "tokio")]
mod_use![tokio];

#[cfg(feature = "futures")]
mod_use![futures];

struct UnixAdapter {
    runtime: Runtime,
    #[cfg(target_os = "linux")]
    efd: Option<OwnedFd>,
}

#[cfg(target_os = "linux")]
impl UnixAdapter {
    fn new(runtime: Runtime) -> io::Result<Self> {
        if runtime.driver_type().is_iouring() {
            use rustix::{
                event::{EventfdFlags, eventfd},
                io_uring::{IoringRegisterOp, io_uring_register},
            };

            let efd = eventfd(0, EventfdFlags::CLOEXEC | EventfdFlags::NONBLOCK)?;
            let efd_raw = efd.as_raw_fd();
            unsafe {
                io_uring_register(
                    BorrowedFd::borrow_raw(runtime.as_raw_fd()),
                    IoringRegisterOp::RegisterEventfd,
                    (&raw const efd_raw).cast(),
                    1,
                )?;
            }
            Ok(Self {
                runtime,
                efd: Some(efd),
            })
        } else {
            Ok(Self { runtime, efd: None })
        }
    }

    fn clear(&self) -> io::Result<()> {
        if let Some(efd) = &self.efd {
            let mut buf = [0u8; 8];
            match rustix::io::read(efd, &mut buf) {
                Ok(_) => {}
                Err(e)
                    if matches!(
                        e.kind(),
                        io::ErrorKind::WouldBlock | io::ErrorKind::Interrupted
                    ) => {}
                Err(e) => return Err(io::Error::from(e)),
            }
        }
        Ok(())
    }
}

#[cfg(not(target_os = "linux"))]
impl UnixAdapter {
    fn new(runtime: Runtime) -> io::Result<Self> {
        Ok(Self { runtime })
    }

    fn clear(&self) -> io::Result<()> {
        Ok(())
    }
}

impl AsRawFd for UnixAdapter {
    fn as_raw_fd(&self) -> RawFd {
        #[cfg(target_os = "linux")]
        {
            self.efd
                .as_ref()
                .map(|f| f.as_raw_fd())
                .unwrap_or_else(|| self.runtime.as_raw_fd())
        }
        #[cfg(not(target_os = "linux"))]
        {
            self.runtime.as_raw_fd()
        }
    }
}

impl AsFd for UnixAdapter {
    fn as_fd(&self) -> BorrowedFd<'_> {
        unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
    }
}

impl Deref for UnixAdapter {
    type Target = Runtime;

    fn deref(&self) -> &Self::Target {
        &self.runtime
    }
}