Struct nix::sys::aio::AioFsync

pub struct AioFsync<'a> { /* private fields */ }

Available on crate feature aio only.

An asynchronous version of fsync(2).

References

aio_fsync

Examples

let f = tempfile().unwrap();
let mut aiof = Box::pin(AioFsync::new(f.as_fd(), AioFsyncMode::O_SYNC,
    0, SigevNone));
aiof.as_mut().submit().expect("aio_fsync failed early");
while (aiof.as_mut().error() == Err(Errno::EINPROGRESS)) {
    thread::sleep(time::Duration::from_millis(10));
}
aiof.as_mut().aio_return().expect("aio_fsync failed late");

Implementations

impl<'a> AioFsync<'a>

pub fn mode(&self) -> AioFsyncMode

Returns the operation’s fsync mode: data and metadata or data only?

pub fn new( fd: BorrowedFd<'a>, mode: AioFsyncMode, prio: i32, sigev_notify: SigevNotify ) -> Self

Create a new AioFsync.

Arguments

• fd: File descriptor to sync.
• mode: Whether to sync file metadata too, or just data.
• prio: If POSIX Prioritized IO is supported, then the operation will be prioritized at the process’s priority level minus prio.
• sigev_notify: Determines how you will be notified of event completion.

Trait Implementations

impl<'a> Aio for AioFsync<'a>

type Output = ()

The return type of Aio::aio_return.

fn cancel(self: Pin<&mut Self>) -> Result<AioCancelStat>

Cancels an outstanding AIO request.

fn error(self: Pin<&mut Self>) -> Result<()>

Retrieve error status of an asynchronous operation.

fn fd(&self) -> BorrowedFd<'a>

Returns the underlying file descriptor associated with the operation.

fn in_progress(&self) -> bool

Does this operation currently have any in-kernel state?

fn priority(&self) -> i32

Returns the priority of the AioCb

fn set_sigev_notify(&mut self, sev: SigevNotify)

Update the notification settings for an existing AIO operation that has not yet been submitted.

fn sigevent(&self) -> SigEvent

Returns the SigEvent that will be used for notification.

fn aio_return(self: Pin<&mut Self>) -> Result<()>

Retrieve return status of an asynchronous operation.

fn submit(self: Pin<&mut Self>) -> Result<()>

Actually start the I/O operation.

impl<'a> AsRef<aiocb> for AioFsync<'a>

fn as_ref(&self) -> &aiocb

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Debug for AioFsync<'a>

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

Formats the value using the given formatter.