pub fn fdatasync<'a>(&'a self, file: &'a File, ordering: EventOrdering) -> Completion<'a, ()> {
        self.with_sqe(None, false, |mut sqe| {
            sqe.prep_rw(IORING_OP_FSYNC, file.as_raw_fd(), 0, 0, ordering);
            sqe.flags |= IORING_FSYNC_DATASYNC;
        })
    }
/// Flushes all buffered writes, and the specific
/// metadata required to access the data. This
/// will skip syncing metadata like atime.
///
/// 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
///
/// fdatasync 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 the specific
metadata required to access the data. This
will skip syncing metadata like atime.

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 the specific metadata required to access the data . This will skip syncing metadata like atime . 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 fdatasync<'a>(&'a self, file: &'a File, ordering: EventOrdering) -> Completion<'a, ()> {
        self.with_sqe(None, false, |mut sqe| {
            sqe.prep_rw(IORING_OP_FSYNC, file.as_raw_fd(), 0, 0, ordering);
            sqe.flags |= IORING_FSYNC_DATASYNC;
        })
    }
pub fn fdatasync < ' a > ( & ' a self , file : & ' a File , ordering : EventOrdering ) -> Completion < ' a , ( ) > { self . with_sqe ( None , false , | mut sqe | { sqe . prep_rw ( IORING_OP_FSYNC , file . as_raw_fd ( ) , 0 , 0 , ordering ) ; sqe . flags |= IORING_FSYNC_DATASYNC ; } ) }
Flushes all buffered writes, and the specific
metadata required to access the data.
Flushes all buffered writes and the specific metadata required to access the data .
&'a self
file
&'a File
ordering
EventOrdering
&'a self
file
&'a File
ordering
EventOrdering
warning
fdatasync 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.
fdatasync 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 .