pub fn fsync<'a>(&'a self, file: &'a File, ordering: EventOrdering) -> Completion<'a, ()> {
        self.with_sqe(None, false, |sqe| {
            sqe.prep_rw(IORING_OP_FSYNC, file.as_raw_fd(), 0, 0, ordering)
        })
    }
/// Flushes all buffered writes, and associated
/// metadata changes.
///
/// You probably want to
/// either use a `Link` ordering on a previous
/// write (or chain of separate writes), or
/// use the `Drain` ordering on this operation.
///
/// You may pass in an `EventOrdering` to specify
/// two different optional behaviors:
///
/// * `EventOrdering::Link` causes the next
///   submitted operation to wait until
///   this one finishes. Useful for
///   things like file copy, fsync-after-write,
///   or proxies.
/// * `EventOrdering::Drain` causes all previously
///   submitted operations to complete before
///   this one begins.
///
/// # Warning
///
/// fsync does not ensure that
/// the file actually exists in its parent
/// directory. So, for new files, you must
/// also fsync the parent directory.
/// This does nothing for files opened in
/// `O_DIRECT` mode.
Flushes all buffered writes, and associated
metadata changes.

You probably want to
either use a `Link` ordering on a previous
write (or chain of separate writes), or
use the `Drain` ordering on this operation.

You may pass in an `EventOrdering` to specify
two different optional behaviors.

`EventOrdering::Link` causes the next
submitted operation to wait until
this one finishes. Useful for
things like file copy, fsync-after-write,
or proxies.
`EventOrdering::Drain` causes all previously
submitted operations to complete before
this one begins.
Flushes all buffered writes and associated metadata changes . You probably want to either use a ` Link ` ordering on a previous write ( or chain of separate writes ) or use the ` Drain ` ordering on this operation . You may pass in an ` EventOrdering ` to specify two different optional behaviors . ` EventOrdering :: Link ` causes the next submitted operation to wait until this one finishes . Useful for things like file copy fsync - after - write or proxies . ` EventOrdering :: Drain ` causes all previously submitted operations to complete before this one begins .
pub fn fsync<'a>(&'a self, file: &'a File, ordering: EventOrdering) -> Completion<'a, ()> {
        self.with_sqe(None, false, |sqe| {
            sqe.prep_rw(IORING_OP_FSYNC, file.as_raw_fd(), 0, 0, ordering)
        })
    }
pub fn fsync < ' a > ( & ' a self , file : & ' a File , ordering : EventOrdering ) -> Completion < ' a , ( ) > { self . with_sqe ( None , false , | sqe | { sqe . prep_rw ( IORING_OP_FSYNC , file . as_raw_fd ( ) , 0 , 0 , ordering ) } ) }
Flushes all buffered writes, and associated
metadata changes.
Flushes all buffered writes and associated metadata changes .
&'a self
file
&'a File
ordering
EventOrdering
&'a self
file
&'a File
ordering
EventOrdering
warning
fsync does not ensure that
the file actually exists in its parent
directory. So, for new files, you must
also fsync the parent directory.
This does nothing for files opened in
`O_DIRECT` mode.
fsync does not ensure that the file actually exists in its parent directory . So for new files you must also fsync the parent directory . This does nothing for files opened in ` O_DIRECT ` mode .