Struct tokio::io::bsd::Aio

pub struct Aio<E> { /* private fields */ }

Available on FreeBSD and crate feature net only.

Associates a POSIX AIO control block with the reactor that drives it.

Aio’s wrapped type must implement AioSource to be driven by the reactor.

The wrapped source may be accessed through the Aio via the Deref and DerefMut traits.

Clearing readiness

If Aio::poll_ready returns ready, but the consumer determines that the Source is not completely ready and must return to the Pending state, Aio::clear_ready may be used. This can be useful with lio_listio, which may generate a kevent when only a portion of the operations have completed.

Platforms

Only FreeBSD implements POSIX AIO with kqueue notification, so Aio is only available for that operating system.

Implementations

impl<E: AioSource> Aio<E>

pub fn new_for_aio(io: E) -> Result<Self>

Creates a new Aio suitable for use with POSIX AIO functions.

It will be associated with the default reactor. The runtime is usually set implicitly when this function is called from a future driven by a Tokio runtime, otherwise runtime can be set explicitly with Runtime::enter function.

pub fn new_for_lio(io: E) -> Result<Self>

Creates a new Aio suitable for use with lio_listio.

It will be associated with the default reactor. The runtime is usually set implicitly when this function is called from a future driven by a Tokio runtime, otherwise runtime can be set explicitly with Runtime::enter function.

pub fn clear_ready(&self, ev: AioEvent)

Indicates to Tokio that the source is no longer ready. The internal readiness flag will be cleared, and tokio will wait for the next edge-triggered readiness notification from the OS.

It is critical that this method not be called unless your code actually observes that the source is not ready. The OS must deliver a subsequent notification, or this source will block forever. It is equally critical that you do call this method if you resubmit the same structure to the kernel and poll it again.

This method is not very useful with AIO readiness, since each aiocb structure is typically only used once. It’s main use with lio_listio, which will sometimes send notification when only a portion of its elements are complete. In that case, the caller must call clear_ready before resubmitting it.

pub fn into_inner(self) -> E

Destroy the Aio and return its inner source.

pub fn poll_ready<'a>(&'a self, cx: &mut Context<'_>) -> Poll<Result<AioEvent>>

Polls for readiness. Either AIO or LIO counts.

This method returns:

• Poll::Pending if the underlying operation is not complete, whether or not it completed successfully. This will be true if the OS is still processing it, or if it has not yet been submitted to the OS.
• Poll::Ready(Ok(_)) if the underlying operation is complete.
• Poll::Ready(Err(_)) if the reactor has been shutdown. This does not indicate that the underlying operation encountered an error.

When the method returns Poll::Pending, the Waker in the provided Context is scheduled to receive a wakeup when the underlying operation completes. Note that on multiple calls to poll_ready, only the Waker from the Context passed to the most recent call is scheduled to receive a wakeup.

Trait Implementations

impl<E: AioSource + Debug> Debug for Aio<E>

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

Formats the value using the given formatter.

impl<E: AioSource> Deref for Aio<E>

type Target = E

The resulting type after dereferencing.

fn deref(&self) -> &E

Dereferences the value.

impl<E: AioSource> DerefMut for Aio<E>

fn deref_mut(&mut self) -> &mut E

Mutably dereferences the value.