Struct Uring 

pub struct Uring;

Implementations

impl Uring

pub fn layout<T>(count: usize) -> Result<NonZero<usize>, Error>

Trait Implementations

impl Completion for Uring

type Opened = Opened

impl Control for Uring

type Target = Fixed

type Owned<T: Token> = Owned<T>

type Poll<'a, T: Token> = Poll<'a, T>

fn nop<T: Token>(complete: T) -> Self::Owned<T>

fn cancel<T: Token>(target: T, complete: T) -> Self::Owned<T>

fn close<T: Token>(slot: Self::Target, complete: T) -> Self::Owned<T>

fn shutdown<T: Token>(slot: Self::Target, complete: T) -> Self::Owned<T>

First step of a hard-linked close, suppressing its successful completion.

impl<C, G> Create<C, G> for Uring

where C: Config<G>, C::Layout: Canary, <<C as Context>::Token as Codec>::Context: Build<Errno<Register<6>>>, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary: From<Primary<Cause<Errno<Setup>, Errno<Map>>, Errno<Register<20>>, Errno<Register<22>>>> + From<Error> + From<Rejection<Errno<Register<24>>, Errno<Register<13>>, Errno<Register<25>>>>, Ring<C::Token>: Validate<C::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, Probe = <<<C as Context>::Token as Codec>::Context as Context>::Probe, Cleanup = Result<<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, Recover<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary>>> + Validate<C::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed, Range = Range, Probe = <<<C as Context>::Token as Codec>::Context as Context>::Probe, Update = Errno<Register<6>>, Cleanup = Result<<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, Recover<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary>>, Release = Result<(<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed, Fixed), Released<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed>>>, Session<C::Token, C::Layout>: Create<<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, Ring = Ring<C::Token>, Cleanup = Resources<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary>> + Validate<<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed, Update = Errno<Register<6>>, Cleanup = Result<<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, Recover<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary>>, Release = Result<(<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed, Fixed), Released<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed>>>,

type Receive = <Uring as Source>::Queue<<C as Config<G>>::Key, <C as Config<G>>::Index>

type Error = Failure<<Ring<<C as Context>::Token> as Create>::Setup, <Ring<<C as Context>::Token> as Create>::Map, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary, Resources<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Primary>, Result<(<<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed, Fixed), Released<<C as Context>::Token, <C as Context>::Layout, <<<C as Context>::Token as Codec>::Context as Build<Errno<Register<6>>>>::Removed>>>

unsafe fn try_new( config: &G, ) -> Result<(Engine<C>, Context<<C as Context>::Layout>, <Uring as Source>::Queue<<C as Config<G>>::Key, <C as Config<G>>::Index>), Self::Error>

Safety

impl Debug for Uring

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Directory for Uring

type Stream = Stream

fn from_fd<E: From<Errno>>(file: OwnedFd) -> Result<Stream, OpenError<E>>

fn descriptor(stream: &Stream) -> Descriptor

fn next<E: From<Errno>>( stream: &mut Stream, ) -> Result<Option<Entry<'_>>, ReadError<E>>

fn open_dir<E>(path: &CStr) -> Result<Self::Stream, OpenError<E>>

where E: From<Errno>, Self: File,

impl<'a, C, H> Dispatch<'a, C, H> for Uring

where C: Context + Context<H, Backend = Engine<C>>, C::Tuning: Progress<C::Token>, H: 'a,

type Turn<Q: Quota<H>> = Turn<'a, H, Q>

impl File for Uring

type Options = OpenHow

type Request<'a> = Borrowed<'a>

fn open<E>(path: &CStr, flags: Open, mode: Mode) -> Result<OwnedFd, E>

where E: From<Errno>,

fn metadata<E>(file: BorrowedFd<'_>) -> Result<Metadata, E>

where E: From<Errno>,

fn stat<E>(path: &CStr) -> Result<Metadata, E>

where E: From<Errno>,

fn mkdir<E>(path: &CStr, mode: Mode) -> Result<(), E>

where E: From<Errno>,

fn metadata_at<E>( dir: Option<BorrowedFd<'_>>, name: &CStr, ) -> Result<Metadata, E>

where E: From<Errno>,

Classifies the named entry itself while retaining its parent directory.

fn unlink<E>(path: &CStr) -> Result<(), E>

where E: From<Errno>,

fn rename<E>(from: &CStr, to: &CStr) -> Result<(), E>

where E: From<Errno>,

fn try_lock<E>(file: BorrowedFd<'_>) -> Result<(), E>

where E: From<Errno>,

Attempts an exclusive advisory lock without waiting for its current owner.

fn sync<E>(file: BorrowedFd<'_>) -> Result<(), E>

where E: From<Errno>,

fn truncate<E>(file: BorrowedFd<'_>, len: i64) -> Result<(), E>

where E: From<Errno>,

fn unlink_at<E>(dir: BorrowedFd<'_>, name: &CStr) -> Result<(), E>

where E: From<Errno>,

fn remove_dir_at<E>(dir: Option<BorrowedFd<'_>>, name: &CStr) -> Result<(), E>

where E: From<Errno>,

fn open_at<E>( dir: BorrowedFd<'_>, name: &CStr, flags: Open, mode: Mode, ) -> Result<OwnedFd, E>

where E: From<Errno>,

fn rename_at<E>(dir: BorrowedFd<'_>, old: &CStr, new: &CStr) -> Result<(), E>

where E: From<Errno>,

fn read_at<'a, E>( file: BorrowedFd<'_>, output: &'a mut [u8], offset: Offset, ) -> Result<&'a mut [u8], E>

where E: From<Errno>,

Reads one prefix without changing the descriptor’s current position.

fn write_at<E>( file: BorrowedFd<'_>, input: Prefix<'_, dope_sys::::io::file::File::write_at::{constant#0}>, offset: Offset, ) -> Result<U32<0, dope_sys::::io::file::File::write_at::{constant#2}>, E>

where E: From<Errno>,

impl<'a, C, R> Finish<'a, R> for Uring

where C: Context + 'a, C::Tuning: Progress<C::Token>, R: Reclaim<Backend = Engine<C>> + 'a,

type Quiesced = Quiesced<R>

fn try_finish( resolver: R, ) -> Result<Self::Quiesced, Stopped<R, Error<<Self as Source>::Poll, R::Fault>>>

impl Native for Uring

type Error<F> = !

impl<T: Copy + Eq, S: Copy + Eq, F: Copy + Eq> Observe<T, S, F> for Uring

type Observation = Observed<T>

impl Pipe for Uring

fn open() -> Result<(OwnedFd, OwnedFd), Error>

fn nonblocking() -> Result<(OwnedFd, OwnedFd), Error>

impl Prepare for Uring

type Handle = OwnedFd

type Fast = NonZero<i32>

fn fast_open(depth: Option<NonZero<i32>>) -> Result<Option<Self::Fast>, Error>

fn open(domain: Domain, kind: Kind) -> Result<Self::Handle, Create>

fn listener(domain: Domain) -> Result<Self::Handle, Create>

fn adopt(file: OwnedFd) -> Result<Self::Handle, Setup>

fn into_fd(handle: Self::Handle) -> OwnedFd

Transfers the prepared socket’s descriptor without changing its native configuration.

fn set_fast(file: BorrowedFd<'_>, fast: Self::Fast) -> Result<(), Errno>

impl<'a, C, R> Quiesce<'a, R> for Uring

where C: Context + 'a, C::Tuning: Progress<C::Token>, R: Cancel<Backend = Engine<C>> + 'a, R::Cancelling: 'a, R::Closing: 'a,

type Quiesced = Quiesced<<R as Close>::Closing>

fn try_quiesce( resolver: R, ) -> Result<Self::Quiesced, Stopped<R::Closing, Error<<Self as Source>::Poll, R::Fault>>>

impl Removal for Uring

type Slot = <Uring as Control>::Target

impl<'a, C, R> Resume<'a, R> for Uring

where C: Context + 'a, C::Tuning: Progress<C::Token>, R: Resume<Backend = Engine<C>> + 'a,

unsafe fn try_resume( resolver: R, ) -> Result<R, Stopped<R, Error<<Self as Source>::Poll, R::Fault>>>

Safety

impl<L: Copy + Eq> Selection<L> for Uring

type Error = (<Uring as Source>::Index, L)

impl Socket for Uring

const MAX_IOVECS: usize

type Error = Errno

type Records = Packet

fn socket(domain: c_int, kind: c_int) -> Result<OwnedFd, Self::Error>

fn pair() -> Result<(OwnedFd, OwnedFd), Error>

Creates exclusively owned endpoints using this backend’s record transport.

fn datagram<E>(domain: Domain) -> Result<OwnedFd, E>

where E: From<Errno>,

Creates one datagram descriptor without changing its descriptor flags.

fn try_open<E>(domain: i32, kind: i32, protocol: i32) -> Result<OwnedFd, E>

where E: From<Errno>,

fn listen<E>(file: BorrowedFd<'_>, backlog: i32) -> Result<(), E>

where E: From<Errno>,

fn shutdown<E>(file: BorrowedFd<'_>, how: How) -> Result<(), E>

where E: From<Errno>,

Half-closes one socket in the requested direction.

fn peer_addr<E>(file: BorrowedFd<'_>, address: &mut Storage) -> Result<(), E>

where E: From<Errno>,

Observes the connected peer into caller-owned native address storage.

fn reset_on_close<E>(file: BorrowedFd<'_>) -> Result<(), E>

where E: From<Errno>,

Makes closing this exclusively owned connection send a reset.

fn kind<E>(file: BorrowedFd<'_>) -> Result<Type, E>

where E: From<Errno>,

Observes the socket type of one adopted descriptor.

fn is_listening<E>(file: BorrowedFd<'_>) -> Result<bool, E>

where E: From<Errno>,

Whether one adopted descriptor is already listening.

fn set_reuse<E>(file: BorrowedFd<'_>, reuse: Reuse) -> Result<(), E>

where E: From<Errno>,

Admits the requested address reuse on one socket.

fn send_quiet<'a, E>( file: BorrowedFd<'_>, input: &'a [u8], ) -> Result<&'a [u8], E>

where E: From<Errno>,

Sends one byte string without raising the termination signal.

fn send_now<'a, E>(file: BorrowedFd<'_>, input: &'a [u8]) -> Result<&'a [u8], E>

where E: From<Errno>,

Sends without waiting or raising the termination signal.

fn get_option<const OPTION: i32, E>(file: BorrowedFd<'_>) -> Result<i32, E>

where E: From<Errno>,

fn set_option<E>( file: BorrowedFd<'_>, level: i32, option: i32, value: &i32, ) -> Result<(), E>

where E: From<Errno>,

fn send<'a, const FLAGS: i32, E>( file: BorrowedFd<'_>, input: &'a [u8], ) -> Result<&'a [u8], E>

where E: From<Errno>,

fn recv<'a, const FLAGS: i32, E>( file: BorrowedFd<'_>, output: &'a mut [u8], ) -> Result<&'a mut [u8], E>

where E: From<Errno>,

fn send_to<'a, E>( file: BorrowedFd<'_>, input: &'a [u8], address: Addr<'_>, ) -> Result<&'a [u8], E>

where E: From<Errno>,

Sends one datagram to the retained native destination.

fn recv_from<'a, E>( file: BorrowedFd<'_>, output: &'a mut [u8], address: &mut Storage, ) -> Result<&'a mut [u8], E>

where E: From<Errno>,

Receives one datagram and its source into caller-owned storage.

fn try_pair<E>(kind: i32) -> Result<(OwnedFd, OwnedFd), E>

where E: From<Errno>,

impl Source for Uring

const MAX_IN_FLIGHT: NonZero<usize> = num::NonZero<usize>::MAX

Maximum simultaneous native accept operations on one listener.

type Failure<F: From<Errno>> = Errno

fn is_retryable(error: Errno) -> bool

Whether one native accept failure permits another attempt on the listener. Resource exhaustion never permits an unconditional retry; retain its exact error.

fn can_defer(error: Errno) -> bool

Whether actual descriptor retirement permits one later attempt after this error. This does not establish a pending retirement or identify the error’s origin.

impl Source for Uring

type Install = Installer

fn try_prepare(plan: Plan) -> Result<Self::Install, Failure>

impl Source for Uring

const LIMITS: Option<(U32<1, { _ }>, U32<2, { _ }>)>

type Mode = Control

impl Source for Uring

type Code = Code

type Failure<S: Copy + Eq> = Failure<S>

type Returned = Returned

impl Source for Uring

fn clear()

fn try_get() -> Result<Option<Errno>, Invalid>

impl Source for Uring

type Queue<K: Key, I: Compact> = Fifo<K, I>

impl Source for Uring

const PROVIDED: u16 = 1

const CANARY: u16 = 2

type Entry = Entry

type Index = Buffer

type Context<L: Receive> = Context<L>

type Canary<L: Canary> = Canary<L>

type Cleanup<L: Receive> = Cleanup<L>

type Producer<L: Receive> = Producer<L>

type Pending<E: Extent> = Selected<E, <E as Extent>::Capacity>

type Complete<E: Extent> = Selected<E, <E as Extent>::Length>

impl Source for Uring

const UNIX_TERMINATED: bool = false

Whether every pathname must retain a trailing NUL inside the path field.

const UNIX_ABSTRACT: bool = true

Whether a leading NUL selects the native abstract namespace.

fn header(domain: Domain, _: Socklen) -> [u8; 2]

impl Source for Uring

const KEEP_IDLE: Name

fn option(kind: Kind) -> (Level, Name)

fn set(fd: BorrowedFd<'_>, kind: Kind, value: &Value) -> Result<(), Errno>

impl Source for Uring

type State<E: Copy, const N: usize> = State<E, N>

type Table<E: Copy, const N: usize> = Table<E, N>

impl Source for Uring

type Decoded<T: Copy, E> = Decoded<T, E, ()>

type Ready<T: Token, L: Receive> = Ready<T, L>

type Packet<T: Copy, B> = Packet<T, B>

type Poll = Poll<Errno<Enter>, Errno<Register<24>>>

type Enter<'a, T: 'a> = Enter<'a, T>

type Entry<T> = Entry<T>

type Message<'a, const NAME: usize, const CONTROL: usize> = Output<'a, NAME, CONTROL>

type Ring<T: Token> = Ring<T>

impl Source for Uring

type Range = Range

type Release<T: Codec, L: Canary, P: Copy> = Released<T, L, P>

type Cleanup<T: Codec, L: Canary, P: Copy> = Recover<T, L, P>

type Payload = Payload

type Accept<T: Codec> = Accepted<T>

type Session<T: Codec, L: Canary> = Session<T, L>

type Outcome<T: Token, P: Copy> = Outcome<T, P>

type Waiting<T: Codec, S> = Waiting<S, T>

impl Source for Uring

type Primary = Primary<Cause<Errno<Setup>, Errno<Map>>, Errno<Register<20>>, Errno<Register<22>>>

type Failure<T: Codec> = Failure<Storage<Errno<Unmap>>, Cause<<<T as Codec>::Context as Context>::Probe, Observed<T>, Errno<Enter>>>

type Resources<T: Codec, L: Canary, P: Copy + From<Self::Primary> + From<Error>> = Resources<T, L, P>

impl Source for Uring

type Token<C: Context> = Encoded<C>

impl Source for Uring

type Socket<H> = Operation<H>

impl Source for Uring

type Control = Control

type Combined = Combined

Owns the selected source and exactly the optional segmentation capability supplied.

fn control(source: Address) -> Self::Control

fn compose(source: Control, gso: Option<Control>) -> Combined

fn release(control: Combined) -> (Control, Option<Control>)

fn bytes(control: &mut Combined) -> &[u8]

fn source( bind: SocketAddr, peer: SocketAddr, ) -> Result<(Address, Self::Control), Error>

Preserves an explicit source; resolves wildcard binds once on a separate socket.

impl Source for Uring

fn read() -> i32

Reads this thread’s unchanged native errno slot.

impl<C: Context> Source<C> for Uring

type Map = <C as Context>::Map

type Backend = Engine<C>

type Closing = Closing<C>

impl<C: Context> Source<C> for Uring

const GROUP: u16 = <Self as provided::Source>::PROVIDED

type Raw = Entry

fn target(slot: C::Target) -> Fixed

fn outbound(slot: C::Outbound) -> Fixed

fn datagram<'d>(fd: &C::Datagram<'d>) -> Fixed

impl<C, P, R> Storage<C, P, R> for Uring

where C: Context<Layout: Canary>, P: Copy + From<Primary<Cause<Errno<Setup>, Errno<Map>>, Errno<Register<20>>, Errno<Register<22>>>> + From<Error>, R: Copy,

type Cleanup = <Uring as Source>::Resources<<C as Context>::Token, <C as Context>::Layout, P>

type Release = <Uring as Source>::Release<<C as Context>::Token, <C as Context>::Layout, R>

impl Thread for Uring

type Timer = Timer

type Receiver = Receiver

type Cpus = Cpus

fn is_main() -> bool

Returns whether the caller is the process’s original thread.

fn current() -> Result<Self::Cpus, Error>

fn bind(cpu: Cpu) -> Result<(), Error>

fn try_crc32() -> Result<bool, Errno>

Admits the native IEEE CRC32 backend without shared feature state. A denied native query retains its exact errno; callers may use software CRC.

fn entropy<const N: usize>( bytes: &mut MaybeUninit<[u8; N]>, ) -> Result<&mut [u8; N], Errno>

Initializes N caller-owned bytes from the operating system; N must not exceed 256.