fn flush(
        &self,
        ctx: Context,
        inode: Self::Inode,
        handle: Self::Handle,
        lock_owner: u64,
    ) -> io::Result<()> {
        Err(io::Error::from_raw_os_error(bindings::LINUX_ENOSYS))
    }
/// Flush the contents of a file.
///
/// This method is called on every `close()` of a file descriptor. Since it is possible to
/// duplicate file descriptors there may be many `flush` calls for one call to `open`.
///
/// File systems should not make any assumptions about when `flush` will be
/// called or even if it will be called at all.
///
/// `handle` is the `Handle` returned by the file system from the `open` method, if any. If the
/// file system did not return a `Handle` from `open` then the contents of `handle` are
/// undefined.
///
/// Unlike `fsync`, the file system is not required to flush pending writes. One reason to flush
/// data is if the file system wants to return write errors during close. However, this is not
/// portable because POSIX does not require `close` to wait for delayed I/O to complete.
///
/// If the `FsOptions::POSIX_LOCKS` feature is enabled, then the file system must remove all
/// locks belonging to `lock_owner`.
///
/// If this method returns an `ENOSYS` error then the kernel will treat it as success and all
/// subsequent calls to `flush` will be handled by the kernel without being forwarded to the
/// file system.
Flush the contents of a file.
This method is called on every `close()` of a file descriptor. Since it is possible to
duplicate file descriptors there may be many `flush` calls for one call to `open`.

File systems should not make any assumptions about when `flush` will be
called or even if it will be called at all.



Unlike `fsync`, the file system is not required to flush pending writes. One reason to flush
data is if the file system wants to return write errors during close. However, this is not
portable because POSIX does not require `close` to wait for delayed I/O to complete.

If the `FsOptions::POSIX_LOCKS` feature is enabled, then the file system must remove all
locks belonging to `lock_owner`.

If this method returns an `ENOSYS` error then the kernel will treat it as success and all
subsequent calls to `flush` will be handled by the kernel without being forwarded to the
file system.
Flush the contents of a file . This method is called on every ` close () ` of a file descriptor . Since it is possible to duplicate file descriptors there may be many ` flush ` calls for one call to ` open ` . File systems should not make any assumptions about when ` flush ` will be called or even if it will be called at all . Unlike ` fsync ` the file system is not required to flush pending writes . One reason to flush data is if the file system wants to return write errors during close . However this is not portable because POSIX does not require ` close ` to wait for delayed I / O to complete . If the ` FsOptions :: POSIX_LOCKS ` feature is enabled then the file system must remove all locks belonging to ` lock_owner ` . If this method returns an ` ENOSYS ` error then the kernel will treat it as success and all subsequent calls to ` flush ` will be handled by the kernel without being forwarded to the file system .
fn flush(
        &self,
        ctx: Context,
        inode: Self::Inode,
        handle: Self::Handle,
        lock_owner: u64,
    ) -> io::Result<()> {
        Err(io::Error::from_raw_os_error(bindings::LINUX_ENOSYS))
    }
fn flush ( & self , ctx : Context , inode : Self :: Inode , handle : Self :: Handle , lock_owner : u64 , ) -> io :: Result < ( ) > { Err ( io :: Error :: from_raw_os_error ( bindings :: LINUX_ENOSYS ) ) }
Flush the contents of a file.
Flush the contents of a file .
&self
ctx
Context
inode
Self::Inode
handle
Self::Handle
lock_owner
u64