dope-uring 0.35.1

Owned io_uring backend for dope
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

pub(in crate::reactor::ring) mod cleanup;
pub(in crate::reactor::ring) mod closing;
pub(in crate::reactor::ring) mod setups;

use std::{mem, num, ptr};

use dope_sys::{
    io::{Close, Retry},
    kernel,
    ring::create,
};
use o3::mem::Rejected;

use crate::{Mapping, error, reactor::ring};

type Cause = create::Cause<kernel::Errno<error::Setup>, kernel::Errno<error::Map>>;

#[derive(Debug)]
pub(crate) struct Region {
    address: *mut libc::c_void,
    len: num::NonZero<usize>,
}

#[derive(Debug)]
pub(crate) struct Unmap {
    region: Region,
    code: kernel::Errno<error::Unmap>,
}

#[derive(Debug)]
pub(crate) struct Closing(State<Unmap>);
pub(crate) struct Pending(State<Region>);

pub(crate) enum Open {
    Failure(Mapping),
    Cleanup { failure: Mapping, unmap: Unmap },
}

#[derive(Debug)]
pub(crate) struct Set(ring::ffi::Map, ring::ffi::Map);

#[derive(Debug)]
struct State<C> {
    current: C,
    next: Option<ring::ffi::Map>,
}

impl Region {
    pub(crate) const fn new(address: *mut libc::c_void, len: num::NonZero<usize>) -> Self {
        Self { address, len }
    }

    pub(crate) const fn address(&self) -> *mut libc::c_void {
        self.address
    }

    pub(crate) const fn len(&self) -> num::NonZero<usize> {
        self.len
    }
}

impl Close for Region {
    type State = Unmap;

    fn try_close(self) -> Result<(), Unmap> {
        ring::ffi::Map::release(self)
    }
}

impl Unmap {
    pub(crate) const fn new(
        address: *mut libc::c_void,
        len: num::NonZero<usize>,
        code: kernel::Errno<error::Unmap>,
    ) -> Self {
        Self {
            region: Region::new(address, len),
            code,
        }
    }

    pub(crate) const fn failure(&self) -> crate::Unmap {
        crate::Unmap::new(self.region.address, self.region.len, self.code)
    }
}

impl Retry for Unmap {
    type Failure = crate::Unmap;
    type Owner = Region;

    fn recover(self) -> Rejected<Region, crate::Unmap> {
        let failure = self.failure();
        Rejected::new(self.region, failure)
    }
}

impl Closing {
    pub(crate) fn failure(&self) -> crate::Unmap {
        self.0.current.failure()
    }

    pub(crate) fn close(current: ring::ffi::Map, next: Option<ring::ffi::Map>) -> Result<(), Self> {
        Pending(State {
            current: current.into_region(),
            next,
        })
        .try_close()
    }

    pub(crate) const fn dirty(current: Unmap, next: Option<ring::ffi::Map>) -> Self {
        Self(State { current, next })
    }
}

impl Retry for Closing {
    type Failure = crate::Unmap;
    type Owner = Pending;

    fn recover(self) -> Rejected<Pending, crate::Unmap> {
        let State { current, next } = self.0;
        current
            .recover()
            .map(|current| Pending(State { current, next }))
    }
}

impl Close for Pending {
    type State = Closing;

    fn try_close(self) -> Result<(), Closing> {
        let State { current, next } = self.0;
        match current.try_close() {
            Ok(()) => next.map_or(Ok(()), |next| Closing::close(next, None)),
            Err(current) => Err(Closing::dirty(current, next)),
        }
    }
}

impl Set {
    pub(crate) const fn single(submit: ring::ffi::Map, entries: ring::ffi::Map) -> Self {
        Self(submit, entries)
    }

    pub(crate) const fn rings(&self) -> &ring::ffi::Map {
        &self.0
    }

    pub(crate) const fn entries(&self) -> &ring::ffi::Map {
        &self.1
    }

    pub(crate) fn try_close(self) -> Result<(), Closing> {
        let Self(submit, entries) = self;
        Closing::close(entries, Some(submit))
    }
}

const _: () = {
    assert!(mem::size_of::<Set>() == 2 * mem::size_of::<ring::ffi::Map>());
    assert!(mem::align_of::<Set>() == mem::align_of::<ring::ffi::Map>());
    assert!(mem::size_of::<crate::Unmap>() == 3 * mem::size_of::<usize>());
    assert!(mem::align_of::<Unmap>() == mem::align_of::<ptr::NonNull<libc::c_void>>());
};