karmaio 0.1.0

A modern, fast, share-nothing 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
111
112

//! Windows/IOCP syscall helpers for `IocpOperation` implementations.

/// Execute a synchronous Windows API call and return `io::Result<u32>`.
///
/// - `BOOL` — non-zero indicates success (e.g. `CreateDirectoryW`, `CloseHandle`)
/// - `BOOLEAN` — `true` indicates success (e.g. `CreateSymbolicLinkW`)
/// - `SOCKET` — zero indicates success (e.g. `closesocket`)
macro_rules! windows_syscall {
    (BOOL, $e:expr) => {{
        #[allow(unused_unsafe)]
        let res = unsafe { $e };
        if res == 0 {
            Err(std::io::Error::last_os_error())
        } else {
            Ok(0u32)
        }
    }};
    (BOOLEAN, $e:expr) => {{
        #[allow(unused_unsafe)]
        let res = unsafe { $e };
        if !res {
            Err(std::io::Error::last_os_error())
        } else {
            Ok(0u32)
        }
    }};
    (SOCKET, $e:expr) => {{
        #[allow(unused_unsafe)]
        let res = unsafe { $e };
        if res != 0 {
            Err(std::io::Error::from_raw_os_error(unsafe {
                windows_sys::Win32::Networking::WinSock::WSAGetLastError()
            }))
        } else {
            Ok(0u32)
        }
    }};
}

/// Package a synchronous Windows call as [`IocpSubmission::Blocking`] for the thread pool.
///
/// Prefer this for path-based FS APIs (`CreateDirectoryW`, `DeleteFileW`, …).
macro_rules! windows_syscall_blocking {
    (value $block:block) => {{
        $crate::driver::backends::iocp::IocpSubmission::Blocking($crate::driver::ops::BlockingJob::new(move || {
            $crate::driver::ops::Completion::from_blocking_result({ $block })
        }))
    }};
    ($block:block) => {{
        // EINTR is retried by [`BlockingJob::run`]; the closure itself is a single attempt.
        $crate::driver::backends::iocp::IocpSubmission::Blocking($crate::driver::ops::BlockingJob::new(move || match {
            $block
        } {
            Ok(val) => $crate::driver::ops::Completion::new(Ok(val)),
            Err(err) => $crate::driver::ops::Completion::new(Err(err)),
        }))
    }};
}

/// Map an overlapped API result to `IocpSubmission::Pending` or `IocpSubmission::Ready(Err)`.
///
/// - `file` — Win32 `BOOL` APIs (`ReadFile`, `WriteFile`); uses `last_os_error`
/// - `socket` — Winsock APIs returning `0` on success (`WSARecv`, `WSASend`); uses `WSAGetLastError`
/// - `winsock` — Winsock `BOOL` APIs (`AcceptEx`, `ConnectEx`); uses `WSAGetLastError`
macro_rules! windows_syscall_submit_overlapped {
    ($interest:expr, file, $call:expr) => {{
        #[allow(unused_unsafe)]
        let result = unsafe { $call };
        if result != 0 {
            return $crate::driver::backends::iocp::IocpSubmission::Pending($interest);
        }

        let err = std::io::Error::last_os_error();
        if err.raw_os_error() == Some(windows_sys::Win32::Foundation::ERROR_IO_PENDING as i32) {
            return $crate::driver::backends::iocp::IocpSubmission::Pending($interest);
        }

        $crate::driver::backends::iocp::IocpSubmission::Ready($crate::driver::ops::Completion::new(Err(err)))
    }};
    ($interest:expr, socket, $call:expr) => {{
        #[allow(unused_unsafe)]
        let result = unsafe { $call };
        if result == 0 {
            return $crate::driver::backends::iocp::IocpSubmission::Pending($interest);
        }

        let err = unsafe { windows_sys::Win32::Networking::WinSock::WSAGetLastError() };
        if err == windows_sys::Win32::Networking::WinSock::WSA_IO_PENDING {
            return $crate::driver::backends::iocp::IocpSubmission::Pending($interest);
        }

        $crate::driver::backends::iocp::IocpSubmission::Ready($crate::driver::ops::Completion::new(Err(
            std::io::Error::from_raw_os_error(err),
        )))
    }};
    ($interest:expr, winsock, $call:expr) => {{
        #[allow(unused_unsafe)]
        let result = unsafe { $call };
        if result != 0 {
            return $crate::driver::backends::iocp::IocpSubmission::Pending($interest);
        }

        let err = unsafe { windows_sys::Win32::Networking::WinSock::WSAGetLastError() };
        if err == windows_sys::Win32::Networking::WinSock::WSA_IO_PENDING {
            return $crate::driver::backends::iocp::IocpSubmission::Pending($interest);
        }

        $crate::driver::backends::iocp::IocpSubmission::Ready($crate::driver::ops::Completion::new(Err(
            std::io::Error::from_raw_os_error(err),
        )))
    }};
}