fn open(
        &self,
        ctx: Context,
        inode: Self::Inode,
        flags: u32,
    ) -> io::Result<(Option<Self::Handle>, OpenOptions)> {
        // Matches the behavior of libfuse.
        Ok((None, OpenOptions::empty()))
    }
/// Open a file.
///
/// Open the file associated with `inode` for reading / writing. All values accepted by the
/// `open(2)` system call are valid values for `flags` and must be handled by the file system.
/// However, there are some additional rules:
///
/// * Creation flags (`libc::O_CREAT`, `libc::O_EXCL`, `libc::O_NOCTTY`) will be filtered out
///   and handled by the kernel.
///
/// * The file system should check the access modes (`libc::O_RDONLY`, `libc::O_WRONLY`,
///   `libc::O_RDWR`) to determine if the operation is permitted. If the file system was mounted
///   with the `-o default_permissions` mount option, then this check will also be carried out
///   by the kernel before sending the open request.
///
/// * When writeback caching is enabled (`FsOptions::WRITEBACK_CACHE`) the kernel may send read
///   requests even for files opened with `libc::O_WRONLY`. The file system should be prepared
///   to handle this.
///
/// * When writeback caching is enabled, the kernel will handle the `libc::O_APPEND` flag.
///   However, this will not work reliably unless the kernel has exclusive access to the file.
///   In this case the file system may either ignore the `libc::O_APPEND` flag or return an
///   error to indicate that reliable `libc::O_APPEND` handling is not available.
///
/// * When writeback caching is disabled, the file system is expected to properly handle
///   `libc::O_APPEND` and ensure that each write is appended to the end of the file.
///
/// The file system may choose to return a `Handle` to refer to the newly opened file. The
/// kernel will then use this `Handle` for all operations on the content of the file (`read`,
/// `write`, `flush`, `release`, `fsync`). If the file system does not return a
/// `Handle` then the kernel will use the `Inode` for the file to operate on its contents. In
/// this case the file system may wish to enable the `FsOptions::ZERO_MESSAGE_OPEN` feature if
/// it is supported by the kernel (see below).
///
/// The returned `OpenOptions` allow the file system to change the way the opened file is
/// handled by the kernel. See the documentation of `OpenOptions` for more information.
///
/// If the `FsOptions::ZERO_MESSAGE_OPEN` feature is enabled by both the file system
/// implementation and the kernel, then the file system may return an error of `ENOSYS`. This
/// will be interpreted by the kernel as success and future calls to `open` and `release` will
/// be handled by the kernel without being passed on to the file system.
Open a file.
Open the file associated with `inode` for reading / writing. All values accepted by the
`open(2)` system call are valid values for `flags` and must be handled by the file system.
However, there are some additional rules.





When writeback caching is enabled (`FsOptions::WRITEBACK_CACHE`) the kernel may send read
requests even for files opened with `libc::O_WRONLY`. The file system should be prepared
to handle this.

When writeback caching is enabled, the kernel will handle the `libc::O_APPEND` flag.
However, this will not work reliably unless the kernel has exclusive access to the file.
In this case the file system may either ignore the `libc::O_APPEND` flag or return an
error to indicate that reliable `libc::O_APPEND` handling is not available.

When writeback caching is disabled, the file system is expected to properly handle
`libc::O_APPEND` and ensure that each write is appended to the end of the file.

The file system may choose to return a `Handle` to refer to the newly opened file.

The returned `OpenOptions` allow the file system to change the way the opened file is
handled by the kernel. See the documentation of `OpenOptions` for more information.

If the `FsOptions::ZERO_MESSAGE_OPEN` feature is enabled by both the file system
implementation and the kernel, then the file system may return an error of `ENOSYS`. This
will be interpreted by the kernel as success and future calls to `open` and `release` will
be handled by the kernel without being passed on to the file system.
Open a file . Open the file associated with ` inode ` for reading / writing . All values accepted by the ` open ( 2 ) ` system call are valid values for ` flags ` and must be handled by the file system . However there are some additional rules . When writeback caching is enabled ( ` FsOptions :: WRITEBACK_CACHE ` ) the kernel may send read requests even for files opened with ` libc :: O_WRONLY ` . The file system should be prepared to handle this . When writeback caching is enabled the kernel will handle the ` libc :: O_APPEND ` flag . However this will not work reliably unless the kernel has exclusive access to the file . In this case the file system may either ignore the ` libc :: O_APPEND ` flag or return an error to indicate that reliable ` libc :: O_APPEND ` handling is not available . When writeback caching is disabled the file system is expected to properly handle ` libc :: O_APPEND ` and ensure that each write is appended to the end of the file . The file system may choose to return a ` Handle ` to refer to the newly opened file . The returned ` OpenOptions ` allow the file system to change the way the opened file is handled by the kernel . See the documentation of ` OpenOptions ` for more information . If the ` FsOptions :: ZERO_MESSAGE_OPEN ` feature is enabled by both the file system implementation and the kernel then the file system may return an error of ` ENOSYS ` . This will be interpreted by the kernel as success and future calls to ` open ` and ` release ` will be handled by the kernel without being passed on to the file system .
fn open(
        &self,
        ctx: Context,
        inode: Self::Inode,
        flags: u32,
    ) -> io::Result<(Option<Self::Handle>, OpenOptions)> {
        // Matches the behavior of libfuse.
        Ok((None, OpenOptions::empty()))
    }
fn open ( & self , ctx : Context , inode : Self :: Inode , flags : u32 , ) -> io :: Result < ( Option < Self :: Handle > , OpenOptions ) > { // Matches the behavior of libfuse. Ok ( ( None , OpenOptions :: empty ( ) ) ) }
Open a file.
Open a file .
&self
ctx
Context
inode
Self::Inode
flags
u32