dope-sys 0.27.0

Typed operating-system call contracts
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

use crate::{memory, ring::map};
mod error;
pub mod raw;
use std::{os::fd, time};

pub use error::Error;
use o3::base::num::bounded;

use crate::{
    io::{
        Close,
        reactor::{complete, submit},
    },
    memory::{buffer, buffer::provided},
    ring::{
        enter,
        enter::{Enter, Poll},
    },
};

type Completion<R> = (
    <R as Complete>::Entry,
    Option<Result<<R as Complete>::Pending, <R as Complete>::Index>>,
);
type Failure<R> = Poll<<R as Ready>::Error, <R as Ready>::CancelError>;

/// Acquires completions and publishes returned storage without submitting native work.
pub trait Complete: Sized {
    type Token: complete::raw::Token;
    type Layout: memory::raw::Receive;
    type Pending: buffer::raw::Token<Index = Self::Index>
        + buffer::raw::Pending<
            Extent = <Self::Layout as memory::raw::Receive>::Extent,
            Complete: buffer::raw::Token<
                Index = Self::Index,
                Length = <<Self::Layout as memory::raw::Receive>::Extent as memory::raw::Extent>::Length,
            >,
        >;
    type Index: Copy;
    type Entry: complete::Entry<Token = Self::Token>;

    fn acquire(&mut self);
    /// Publishes consumed completion ownership without acquiring another batch.
    fn publish(&mut self);
    fn pop(&mut self) -> Option<Completion<Self>>;
    fn refresh(&mut self) -> bounded::U32<0, { u32::MAX }>;
    fn layout(&self) -> Self::Layout;
    fn flush(&mut self);
}

/// A registered reactor and its provided-buffer entries share one owner.
pub trait Ready: Complete + Close<State: map::Unmap> + Sized {
    type Ring;
    type Context: provided::Context;
    type Producer: provided::Producer<Layout = Self::Layout, Context = Self::Context>;
    type Registration;
    type Registered;
    type BufferError;
    type Error;
    type InstallError;
    type CancelError;
    type Target;
    type Queue<'q>: submit::Queue<'q, Self::Token>
    where
        Self: 'q;
    type Enter<'q>: Enter<Error = Self::Error>
    where
        Self: 'q;

    fn submission(&mut self) -> Self::Queue<'_>;
    fn enter(&mut self) -> Self::Enter<'_>;

    fn submit(&mut self) -> Result<(), Failure<Self>>;
    fn commit(&mut self) -> Result<(), Failure<Self>>;
    fn advance(&mut self) -> Result<enter::Progress, Failure<Self>>;
    fn try_wait(&mut self, timeout: Option<time::Duration>) -> Result<(), Failure<Self>>;

    fn install(
        &mut self,
        target: Self::Target,
        file: fd::BorrowedFd<'_>,
    ) -> Result<(), Self::InstallError>;
    fn cancel_all(&mut self) -> Result<(), Failure<Self>>;
}