/* automatically generated by rust-bindgen 0.60.1 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
pub const FUSE_OPT_KEY_OPT: i32 = -1;
pub const FUSE_OPT_KEY_NONOPT: i32 = -2;
pub const FUSE_OPT_KEY_KEEP: i32 = -3;
pub const FUSE_OPT_KEY_DISCARD: i32 = -4;
pub const FUSE_MAJOR_VERSION: u32 = 2;
pub const FUSE_MINOR_VERSION: u32 = 9;
pub const FUSE_CAP_ASYNC_READ: u32 = 1;
pub const FUSE_CAP_POSIX_LOCKS: u32 = 2;
pub const FUSE_CAP_ATOMIC_O_TRUNC: u32 = 8;
pub const FUSE_CAP_EXPORT_SUPPORT: u32 = 16;
pub const FUSE_CAP_BIG_WRITES: u32 = 32;
pub const FUSE_CAP_DONT_MASK: u32 = 64;
pub const FUSE_CAP_SPLICE_WRITE: u32 = 128;
pub const FUSE_CAP_SPLICE_MOVE: u32 = 256;
pub const FUSE_CAP_SPLICE_READ: u32 = 512;
pub const FUSE_CAP_FLOCK_LOCKS: u32 = 1024;
pub const FUSE_CAP_IOCTL_DIR: u32 = 2048;
pub const FUSE_IOCTL_COMPAT: u32 = 1;
pub const FUSE_IOCTL_UNRESTRICTED: u32 = 2;
pub const FUSE_IOCTL_RETRY: u32 = 4;
pub const FUSE_IOCTL_DIR: u32 = 16;
pub const FUSE_IOCTL_MAX_IOV: u32 = 256;
pub const FUSE_ROOT_ID: u32 = 1;
pub const FUSE_SET_ATTR_MODE: u32 = 1;
pub const FUSE_SET_ATTR_UID: u32 = 2;
pub const FUSE_SET_ATTR_GID: u32 = 4;
pub const FUSE_SET_ATTR_SIZE: u32 = 8;
pub const FUSE_SET_ATTR_ATIME: u32 = 16;
pub const FUSE_SET_ATTR_MTIME: u32 = 32;
pub const FUSE_SET_ATTR_ATIME_NOW: u32 = 128;
pub const FUSE_SET_ATTR_MTIME_NOW: u32 = 256;
#[doc = " Option description"]
#[doc = ""]
#[doc = " This structure describes a single option, and action associated"]
#[doc = " with it, in case it matches."]
#[doc = ""]
#[doc = " More than one such match may occur, in which case the action for"]
#[doc = " each match is executed."]
#[doc = ""]
#[doc = " There are three possible actions in case of a match:"]
#[doc = ""]
#[doc = " i) An integer (int or unsigned) variable determined by 'offset' is"]
#[doc = "    set to 'value'"]
#[doc = ""]
#[doc = " ii) The processing function is called, with 'value' as the key"]
#[doc = ""]
#[doc = " iii) An integer (any) or string (char *) variable determined by"]
#[doc = "    'offset' is set to the value of an option parameter"]
#[doc = ""]
#[doc = " 'offset' should normally be either set to"]
#[doc = ""]
#[doc = "  - 'offsetof(struct foo, member)'  actions i) and iii)"]
#[doc = ""]
#[doc = "  - -1\t\t\t      action ii)"]
#[doc = ""]
#[doc = " The 'offsetof()' macro is defined in the <stddef.h> header."]
#[doc = ""]
#[doc = " The template determines which options match, and also have an"]
#[doc = " effect on the action.  Normally the action is either i) or ii), but"]
#[doc = " if a format is present in the template, then action iii) is"]
#[doc = " performed."]
#[doc = ""]
#[doc = " The types of templates are:"]
#[doc = ""]
#[doc = " 1) \"-x\", \"-foo\", \"--foo\", \"--foo-bar\", etc.\tThese match only"]
#[doc = "   themselves.  Invalid values are \"--\" and anything beginning"]
#[doc = "   with \"-o\""]
#[doc = ""]
#[doc = " 2) \"foo\", \"foo-bar\", etc.  These match \"-ofoo\", \"-ofoo-bar\" or"]
#[doc = "    the relevant option in a comma separated option list"]
#[doc = ""]
#[doc = " 3) \"bar=\", \"--foo=\", etc.  These are variations of 1) and 2)"]
#[doc = "    which have a parameter"]
#[doc = ""]
#[doc = " 4) \"bar=%s\", \"--foo=%lu\", etc.  Same matching as above but perform"]
#[doc = "    action iii)."]
#[doc = ""]
#[doc = " 5) \"-x \", etc.  Matches either \"-xparam\" or \"-x param\" as"]
#[doc = "    two separate arguments"]
#[doc = ""]
#[doc = " 6) \"-x %s\", etc.  Combination of 4) and 5)"]
#[doc = ""]
#[doc = " If the format is \"%s\", memory is allocated for the string unlike"]
#[doc = " with scanf()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fuse_opt {
    #[doc = " Matching template and optional parameter formatting"]
    pub templ: *const ::std::os::raw::c_char,
    #[doc = " Offset of variable within 'data' parameter of fuse_opt_parse()"]
    #[doc = " or -1"]
    pub offset: ::std::os::raw::c_ulong,
    #[doc = " Value to set the variable to, or to be passed as 'key' to the"]
    #[doc = " processing function.\t Ignored if template has a format"]
    pub value: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_fuse_opt() {
    assert_eq!(
        ::std::mem::size_of::<fuse_opt>(),
        24usize,
        concat!("Size of: ", stringify!(fuse_opt))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_opt>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_opt))
    );
    fn test_field_templ() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_opt>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).templ) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_opt),
                "::",
                stringify!(templ)
            )
        );
    }
    test_field_templ();
    fn test_field_offset() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_opt>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_opt),
                "::",
                stringify!(offset)
            )
        );
    }
    test_field_offset();
    fn test_field_value() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_opt>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_opt),
                "::",
                stringify!(value)
            )
        );
    }
    test_field_value();
}
impl Default for fuse_opt {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Argument list"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fuse_args {
    #[doc = " Argument count"]
    pub argc: ::std::os::raw::c_int,
    #[doc = " Argument vector.  NULL terminated"]
    pub argv: *mut *mut ::std::os::raw::c_char,
    #[doc = " Is 'argv' allocated?"]
    pub allocated: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_fuse_args() {
    assert_eq!(
        ::std::mem::size_of::<fuse_args>(),
        24usize,
        concat!("Size of: ", stringify!(fuse_args))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_args>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_args))
    );
    fn test_field_argc() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_args>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).argc) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_args),
                "::",
                stringify!(argc)
            )
        );
    }
    test_field_argc();
    fn test_field_argv() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_args>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).argv) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_args),
                "::",
                stringify!(argv)
            )
        );
    }
    test_field_argv();
    fn test_field_allocated() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_args>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).allocated) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_args),
                "::",
                stringify!(allocated)
            )
        );
    }
    test_field_allocated();
}
impl Default for fuse_args {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Processing function"]
#[doc = ""]
#[doc = " This function is called if"]
#[doc = "    - option did not match any 'struct fuse_opt'"]
#[doc = "    - argument is a non-option"]
#[doc = "    - option did match and offset was set to -1"]
#[doc = ""]
#[doc = " The 'arg' parameter will always contain the whole argument or"]
#[doc = " option including the parameter if exists.  A two-argument option"]
#[doc = " (\"-x foo\") is always converted to single argument option of the"]
#[doc = " form \"-xfoo\" before this function is called."]
#[doc = ""]
#[doc = " Options of the form '-ofoo' are passed to this function without the"]
#[doc = " '-o' prefix."]
#[doc = ""]
#[doc = " The return value of this function determines whether this argument"]
#[doc = " is to be inserted into the output argument vector, or discarded."]
#[doc = ""]
#[doc = " @param data is the user data passed to the fuse_opt_parse() function"]
#[doc = " @param arg is the whole argument or option"]
#[doc = " @param key determines why the processing function was called"]
#[doc = " @param outargs the current output argument list"]
#[doc = " @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept"]
pub type fuse_opt_proc_t = ::std::option::Option<
    unsafe extern "C" fn(
        data: *mut ::std::os::raw::c_void,
        arg: *const ::std::os::raw::c_char,
        key: ::std::os::raw::c_int,
        outargs: *mut fuse_args,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    #[doc = " Option parsing function"]
    #[doc = ""]
    #[doc = " If 'args' was returned from a previous call to fuse_opt_parse() or"]
    #[doc = " it was constructed from"]
    #[doc = ""]
    #[doc = " A NULL 'args' is equivalent to an empty argument vector"]
    #[doc = ""]
    #[doc = " A NULL 'opts' is equivalent to an 'opts' array containing a single"]
    #[doc = " end marker"]
    #[doc = ""]
    #[doc = " A NULL 'proc' is equivalent to a processing function always"]
    #[doc = " returning '1'"]
    #[doc = ""]
    #[doc = " @param args is the input and output argument list"]
    #[doc = " @param data is the user data"]
    #[doc = " @param opts is the option description array"]
    #[doc = " @param proc is the processing function"]
    #[doc = " @return -1 on error, 0 on success"]
    pub fn fuse_opt_parse(
        args: *mut fuse_args,
        data: *mut ::std::os::raw::c_void,
        opts: *const fuse_opt,
        proc_: fuse_opt_proc_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Add an option to a comma separated option list"]
    #[doc = ""]
    #[doc = " @param opts is a pointer to an option list, may point to a NULL value"]
    #[doc = " @param opt is the option to add"]
    #[doc = " @return -1 on allocation error, 0 on success"]
    pub fn fuse_opt_add_opt(
        opts: *mut *mut ::std::os::raw::c_char,
        opt: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Add an option, escaping commas, to a comma separated option list"]
    #[doc = ""]
    #[doc = " @param opts is a pointer to an option list, may point to a NULL value"]
    #[doc = " @param opt is the option to add"]
    #[doc = " @return -1 on allocation error, 0 on success"]
    pub fn fuse_opt_add_opt_escaped(
        opts: *mut *mut ::std::os::raw::c_char,
        opt: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Add an argument to a NULL terminated argument vector"]
    #[doc = ""]
    #[doc = " @param args is the structure containing the current argument list"]
    #[doc = " @param arg is the new argument to add"]
    #[doc = " @return -1 on allocation error, 0 on success"]
    pub fn fuse_opt_add_arg(
        args: *mut fuse_args,
        arg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Add an argument at the specified position in a NULL terminated"]
    #[doc = " argument vector"]
    #[doc = ""]
    #[doc = " Adds the argument to the N-th position.  This is useful for adding"]
    #[doc = " options at the beginning of the array which must not come after the"]
    #[doc = " special '--' option."]
    #[doc = ""]
    #[doc = " @param args is the structure containing the current argument list"]
    #[doc = " @param pos is the position at which to add the argument"]
    #[doc = " @param arg is the new argument to add"]
    #[doc = " @return -1 on allocation error, 0 on success"]
    pub fn fuse_opt_insert_arg(
        args: *mut fuse_args,
        pos: ::std::os::raw::c_int,
        arg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Free the contents of argument list"]
    #[doc = ""]
    #[doc = " The structure itself is not freed"]
    #[doc = ""]
    #[doc = " @param args is the structure containing the argument list"]
    pub fn fuse_opt_free_args(args: *mut fuse_args);
}
extern "C" {
    #[doc = " Check if an option matches"]
    #[doc = ""]
    #[doc = " @param opts is the option description array"]
    #[doc = " @param opt is the option to match"]
    #[doc = " @return 1 if a match is found, 0 if not"]
    pub fn fuse_opt_match(
        opts: *const fuse_opt,
        opt: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[doc = " Information about open files"]
#[doc = ""]
#[doc = " Changed in version 2.5"]
#[repr(C)]
pub struct fuse_file_info {
    #[doc = " Open flags.\t Available in open() and release()"]
    pub flags: ::std::os::raw::c_int,
    #[doc = " Old file handle, don't use"]
    pub fh_old: ::std::os::raw::c_ulong,
    #[doc = " In case of a write operation indicates if this was caused by a"]
    #[doc = "writepage"]
    pub writepage: ::std::os::raw::c_int,
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    #[doc = " File handle.  May be filled in by filesystem in open()."]
    #[doc = "Available in all other file operations"]
    pub fh: u64,
    #[doc = " Lock owner id.  Available in locking operations and flush"]
    pub lock_owner: u64,
}
#[test]
fn bindgen_test_layout_fuse_file_info() {
    assert_eq!(
        ::std::mem::size_of::<fuse_file_info>(),
        40usize,
        concat!("Size of: ", stringify!(fuse_file_info))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_file_info>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_file_info))
    );
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_file_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_file_info),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_fh_old() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_file_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fh_old) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_file_info),
                "::",
                stringify!(fh_old)
            )
        );
    }
    test_field_fh_old();
    fn test_field_writepage() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_file_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).writepage) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_file_info),
                "::",
                stringify!(writepage)
            )
        );
    }
    test_field_writepage();
    fn test_field_fh() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_file_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fh) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_file_info),
                "::",
                stringify!(fh)
            )
        );
    }
    test_field_fh();
    fn test_field_lock_owner() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_file_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).lock_owner) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_file_info),
                "::",
                stringify!(lock_owner)
            )
        );
    }
    test_field_lock_owner();
}
impl Default for fuse_file_info {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl fuse_file_info {
    #[inline]
    pub fn direct_io(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_direct_io(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn keep_cache(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_keep_cache(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn flush(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_flush(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn nonseekable(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_nonseekable(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn flock_release(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_flock_release(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn padding(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) }
    }
    #[inline]
    pub fn set_padding(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 27u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        direct_io: ::std::os::raw::c_uint,
        keep_cache: ::std::os::raw::c_uint,
        flush: ::std::os::raw::c_uint,
        nonseekable: ::std::os::raw::c_uint,
        flock_release: ::std::os::raw::c_uint,
        padding: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let direct_io: u32 = unsafe { ::std::mem::transmute(direct_io) };
            direct_io as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let keep_cache: u32 = unsafe { ::std::mem::transmute(keep_cache) };
            keep_cache as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let flush: u32 = unsafe { ::std::mem::transmute(flush) };
            flush as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let nonseekable: u32 = unsafe { ::std::mem::transmute(nonseekable) };
            nonseekable as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let flock_release: u32 = unsafe { ::std::mem::transmute(flock_release) };
            flock_release as u64
        });
        __bindgen_bitfield_unit.set(5usize, 27u8, {
            let padding: u32 = unsafe { ::std::mem::transmute(padding) };
            padding as u64
        });
        __bindgen_bitfield_unit
    }
}
#[doc = " Connection information, passed to the ->init() method"]
#[doc = ""]
#[doc = " Some of the elements are read-write, these can be changed to"]
#[doc = " indicate the value requested by the filesystem.  The requested"]
#[doc = " value must usually be smaller than the indicated value."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fuse_conn_info {
    #[doc = " Major version of the protocol (read-only)"]
    pub proto_major: ::std::os::raw::c_uint,
    #[doc = " Minor version of the protocol (read-only)"]
    pub proto_minor: ::std::os::raw::c_uint,
    #[doc = " Is asynchronous read supported (read-write)"]
    pub async_read: ::std::os::raw::c_uint,
    #[doc = " Maximum size of the write buffer"]
    pub max_write: ::std::os::raw::c_uint,
    #[doc = " Maximum readahead"]
    pub max_readahead: ::std::os::raw::c_uint,
    #[doc = " Capability flags, that the kernel supports"]
    pub capable: ::std::os::raw::c_uint,
    #[doc = " Capability flags, that the filesystem wants to enable"]
    pub want: ::std::os::raw::c_uint,
    #[doc = " Maximum number of backgrounded requests"]
    pub max_background: ::std::os::raw::c_uint,
    #[doc = " Kernel congestion threshold parameter"]
    pub congestion_threshold: ::std::os::raw::c_uint,
    #[doc = " For future use."]
    pub reserved: [::std::os::raw::c_uint; 23usize],
}
#[test]
fn bindgen_test_layout_fuse_conn_info() {
    assert_eq!(
        ::std::mem::size_of::<fuse_conn_info>(),
        128usize,
        concat!("Size of: ", stringify!(fuse_conn_info))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_conn_info>(),
        4usize,
        concat!("Alignment of ", stringify!(fuse_conn_info))
    );
    fn test_field_proto_major() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).proto_major) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(proto_major)
            )
        );
    }
    test_field_proto_major();
    fn test_field_proto_minor() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).proto_minor) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(proto_minor)
            )
        );
    }
    test_field_proto_minor();
    fn test_field_async_read() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).async_read) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(async_read)
            )
        );
    }
    test_field_async_read();
    fn test_field_max_write() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).max_write) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(max_write)
            )
        );
    }
    test_field_max_write();
    fn test_field_max_readahead() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).max_readahead) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(max_readahead)
            )
        );
    }
    test_field_max_readahead();
    fn test_field_capable() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).capable) as usize - ptr as usize
            },
            20usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(capable)
            )
        );
    }
    test_field_capable();
    fn test_field_want() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).want) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(want)
            )
        );
    }
    test_field_want();
    fn test_field_max_background() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).max_background) as usize - ptr as usize
            },
            28usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(max_background)
            )
        );
    }
    test_field_max_background();
    fn test_field_congestion_threshold() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).congestion_threshold) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(congestion_threshold)
            )
        );
    }
    test_field_congestion_threshold();
    fn test_field_reserved() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_conn_info>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize
            },
            36usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_conn_info),
                "::",
                stringify!(reserved)
            )
        );
    }
    test_field_reserved();
}
#[doc = " Session"]
#[doc = ""]
#[doc = " This provides hooks for processing requests, and exiting"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fuse_session {
    _unused: [u8; 0],
}
#[doc = " Channel"]
#[doc = ""]
#[doc = " A communication channel, providing hooks for sending and receiving"]
#[doc = " messages"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fuse_chan {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fuse_pollhandle {
    _unused: [u8; 0],
}
extern "C" {
    #[doc = " Create a FUSE mountpoint"]
    #[doc = ""]
    #[doc = " Returns a control file descriptor suitable for passing to"]
    #[doc = " fuse_new()"]
    #[doc = ""]
    #[doc = " @param mountpoint the mount point path"]
    #[doc = " @param args argument vector"]
    #[doc = " @return the communication channel on success, NULL on failure"]
    pub fn fuse_mount(
        mountpoint: *const ::std::os::raw::c_char,
        args: *mut fuse_args,
    ) -> *mut fuse_chan;
}
extern "C" {
    #[doc = " Umount a FUSE mountpoint"]
    #[doc = ""]
    #[doc = " @param mountpoint the mount point path"]
    #[doc = " @param ch the communication channel"]
    pub fn fuse_unmount(mountpoint: *const ::std::os::raw::c_char, ch: *mut fuse_chan);
}
extern "C" {
    #[doc = " Parse common options"]
    #[doc = ""]
    #[doc = " The following options are parsed:"]
    #[doc = ""]
    #[doc = "   '-f'\t     foreground"]
    #[doc = "   '-d' '-odebug'  foreground, but keep the debug option"]
    #[doc = "   '-s'\t     single threaded"]
    #[doc = "   '-h' '--help'   help"]
    #[doc = "   '-ho'\t     help without header"]
    #[doc = "   '-ofsname=..'   file system name, if not present, then set to the program"]
    #[doc = "\t\t     name"]
    #[doc = ""]
    #[doc = " All parameters may be NULL"]
    #[doc = ""]
    #[doc = " @param args argument vector"]
    #[doc = " @param mountpoint the returned mountpoint, should be freed after use"]
    #[doc = " @param multithreaded set to 1 unless the '-s' option is present"]
    #[doc = " @param foreground set to 1 if one of the relevant options is present"]
    #[doc = " @return 0 on success, -1 on failure"]
    pub fn fuse_parse_cmdline(
        args: *mut fuse_args,
        mountpoint: *mut *mut ::std::os::raw::c_char,
        multithreaded: *mut ::std::os::raw::c_int,
        foreground: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Go into the background"]
    #[doc = ""]
    #[doc = " @param foreground if true, stay in the foreground"]
    #[doc = " @return 0 on success, -1 on failure"]
    pub fn fuse_daemonize(foreground: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Get the version of the library"]
    #[doc = ""]
    #[doc = " @return the version"]
    pub fn fuse_version() -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Destroy poll handle"]
    #[doc = ""]
    #[doc = " @param ph the poll handle"]
    pub fn fuse_pollhandle_destroy(ph: *mut fuse_pollhandle);
}
#[doc = " Buffer contains a file descriptor"]
#[doc = ""]
#[doc = " If this flag is set, the .fd field is valid, otherwise the"]
#[doc = " .mem fields is valid."]
pub const fuse_buf_flags_FUSE_BUF_IS_FD: fuse_buf_flags = 2;
#[doc = " Seek on the file descriptor"]
#[doc = ""]
#[doc = " If this flag is set then the .pos field is valid and is"]
#[doc = " used to seek to the given offset before performing"]
#[doc = " operation on file descriptor."]
pub const fuse_buf_flags_FUSE_BUF_FD_SEEK: fuse_buf_flags = 4;
#[doc = " Retry operation on file descriptor"]
#[doc = ""]
#[doc = " If this flag is set then retry operation on file descriptor"]
#[doc = " until .size bytes have been copied or an error or EOF is"]
#[doc = " detected."]
pub const fuse_buf_flags_FUSE_BUF_FD_RETRY: fuse_buf_flags = 8;
#[doc = " Buffer flags"]
pub type fuse_buf_flags = ::std::os::raw::c_uint;
#[doc = " Don't use splice(2)"]
#[doc = ""]
#[doc = " Always fall back to using read and write instead of"]
#[doc = " splice(2) to copy data from one file descriptor to another."]
#[doc = ""]
#[doc = " If this flag is not set, then only fall back if splice is"]
#[doc = " unavailable."]
pub const fuse_buf_copy_flags_FUSE_BUF_NO_SPLICE: fuse_buf_copy_flags = 2;
#[doc = " Force splice"]
#[doc = ""]
#[doc = " Always use splice(2) to copy data from one file descriptor"]
#[doc = " to another.  If splice is not available, return -EINVAL."]
pub const fuse_buf_copy_flags_FUSE_BUF_FORCE_SPLICE: fuse_buf_copy_flags = 4;
#[doc = " Try to move data with splice."]
#[doc = ""]
#[doc = " If splice is used, try to move pages from the source to the"]
#[doc = " destination instead of copying.  See documentation of"]
#[doc = " SPLICE_F_MOVE in splice(2) man page."]
pub const fuse_buf_copy_flags_FUSE_BUF_SPLICE_MOVE: fuse_buf_copy_flags = 8;
#[doc = " Don't block on the pipe when copying data with splice"]
#[doc = ""]
#[doc = " Makes the operations on the pipe non-blocking (if the pipe"]
#[doc = " is full or empty).  See SPLICE_F_NONBLOCK in the splice(2)"]
#[doc = " man page."]
pub const fuse_buf_copy_flags_FUSE_BUF_SPLICE_NONBLOCK: fuse_buf_copy_flags = 16;
#[doc = " Buffer copy flags"]
pub type fuse_buf_copy_flags = ::std::os::raw::c_uint;
#[doc = " Single data buffer"]
#[doc = ""]
#[doc = " Generic data buffer for I/O, extended attributes, etc...  Data may"]
#[doc = " be supplied as a memory pointer or as a file descriptor"]
#[repr(C)]
pub struct fuse_buf {
    #[doc = " Size of data in bytes"]
    pub size: size_t,
    #[doc = " Buffer flags"]
    pub flags: fuse_buf_flags,
    #[doc = " Memory pointer"]
    #[doc = ""]
    #[doc = " Used unless FUSE_BUF_IS_FD flag is set."]
    pub mem: *mut ::std::os::raw::c_void,
    #[doc = " File descriptor"]
    #[doc = ""]
    #[doc = " Used if FUSE_BUF_IS_FD flag is set."]
    pub fd: ::std::os::raw::c_int,
    #[doc = " File position"]
    #[doc = ""]
    #[doc = " Used if FUSE_BUF_FD_SEEK flag is set."]
    pub pos: off_t,
}
#[test]
fn bindgen_test_layout_fuse_buf() {
    assert_eq!(
        ::std::mem::size_of::<fuse_buf>(),
        40usize,
        concat!("Size of: ", stringify!(fuse_buf))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_buf>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_buf))
    );
    fn test_field_size() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_buf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_buf),
                "::",
                stringify!(size)
            )
        );
    }
    test_field_size();
    fn test_field_flags() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_buf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_buf),
                "::",
                stringify!(flags)
            )
        );
    }
    test_field_flags();
    fn test_field_mem() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_buf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mem) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_buf),
                "::",
                stringify!(mem)
            )
        );
    }
    test_field_mem();
    fn test_field_fd() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_buf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_buf),
                "::",
                stringify!(fd)
            )
        );
    }
    test_field_fd();
    fn test_field_pos() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_buf>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_buf),
                "::",
                stringify!(pos)
            )
        );
    }
    test_field_pos();
}
impl Default for fuse_buf {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Data buffer vector"]
#[doc = ""]
#[doc = " An array of data buffers, each containing a memory pointer or a"]
#[doc = " file descriptor."]
#[doc = ""]
#[doc = " Allocate dynamically to add more than one buffer."]
#[repr(C)]
pub struct fuse_bufvec {
    #[doc = " Number of buffers in the array"]
    pub count: size_t,
    #[doc = " Index of current buffer within the array"]
    pub idx: size_t,
    #[doc = " Current offset within the current buffer"]
    pub off: size_t,
    #[doc = " Array of buffers"]
    pub buf: [fuse_buf; 1usize],
}
#[test]
fn bindgen_test_layout_fuse_bufvec() {
    assert_eq!(
        ::std::mem::size_of::<fuse_bufvec>(),
        64usize,
        concat!("Size of: ", stringify!(fuse_bufvec))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_bufvec>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_bufvec))
    );
    fn test_field_count() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_bufvec>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_bufvec),
                "::",
                stringify!(count)
            )
        );
    }
    test_field_count();
    fn test_field_idx() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_bufvec>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).idx) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_bufvec),
                "::",
                stringify!(idx)
            )
        );
    }
    test_field_idx();
    fn test_field_off() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_bufvec>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).off) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_bufvec),
                "::",
                stringify!(off)
            )
        );
    }
    test_field_off();
    fn test_field_buf() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_bufvec>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_bufvec),
                "::",
                stringify!(buf)
            )
        );
    }
    test_field_buf();
}
impl Default for fuse_bufvec {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
extern "C" {
    #[doc = " Get total size of data in a fuse buffer vector"]
    #[doc = ""]
    #[doc = " @param bufv buffer vector"]
    #[doc = " @return size of data"]
    pub fn fuse_buf_size(bufv: *const fuse_bufvec) -> size_t;
}
extern "C" {
    #[doc = " Copy data from one buffer vector to another"]
    #[doc = ""]
    #[doc = " @param dst destination buffer vector"]
    #[doc = " @param src source buffer vector"]
    #[doc = " @param flags flags controlling the copy"]
    #[doc = " @return actual number of bytes copied or -errno on error"]
    pub fn fuse_buf_copy(
        dst: *mut fuse_bufvec,
        src: *mut fuse_bufvec,
        flags: fuse_buf_copy_flags,
    ) -> ssize_t;
}
extern "C" {
    #[doc = " Exit session on HUP, TERM and INT signals and ignore PIPE signal"]
    #[doc = ""]
    #[doc = " Stores session in a global variable.\t May only be called once per"]
    #[doc = " process until fuse_remove_signal_handlers() is called."]
    #[doc = ""]
    #[doc = " @param se the session to exit"]
    #[doc = " @return 0 on success, -1 on failure"]
    pub fn fuse_set_signal_handlers(se: *mut fuse_session) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Restore default signal handlers"]
    #[doc = ""]
    #[doc = " Resets global session.  After this fuse_set_signal_handlers() may"]
    #[doc = " be called again."]
    #[doc = ""]
    #[doc = " @param se the same session as given in fuse_set_signal_handlers()"]
    pub fn fuse_remove_signal_handlers(se: *mut fuse_session);
}
#[doc = " Inode number type"]
pub type fuse_ino_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fuse_req {
    _unused: [u8; 0],
}
#[doc = " Request pointer type"]
pub type fuse_req_t = *mut fuse_req;
#[doc = " Directory entry parameters supplied to fuse_reply_entry()"]
#[repr(C)]
pub struct fuse_entry_param {
    #[doc = " Unique inode number"]
    #[doc = ""]
    #[doc = " In lookup, zero means negative entry (from version 2.5)"]
    #[doc = " Returning ENOENT also means negative entry, but by setting zero"]
    #[doc = " ino the kernel may cache negative entries for entry_timeout"]
    #[doc = " seconds."]
    pub ino: fuse_ino_t,
    #[doc = " Generation number for this entry."]
    #[doc = ""]
    #[doc = " If the file system will be exported over NFS, the"]
    #[doc = " ino/generation pairs need to be unique over the file"]
    #[doc = " system's lifetime (rather than just the mount time). So if"]
    #[doc = " the file system reuses an inode after it has been deleted,"]
    #[doc = " it must assign a new, previously unused generation number"]
    #[doc = " to the inode at the same time."]
    #[doc = ""]
    #[doc = " The generation must be non-zero, otherwise FUSE will treat"]
    #[doc = " it as an error."]
    #[doc = ""]
    pub generation: ::std::os::raw::c_ulong,
    #[doc = " Inode attributes."]
    #[doc = ""]
    #[doc = " Even if attr_timeout == 0, attr must be correct. For example,"]
    #[doc = " for open(), FUSE uses attr.st_size from lookup() to determine"]
    #[doc = " how many bytes to request. If this value is not correct,"]
    #[doc = " incorrect data will be returned."]
    pub attr: stat,
    #[doc = " Validity timeout (in seconds) for the attributes"]
    pub attr_timeout: f64,
    #[doc = " Validity timeout (in seconds) for the name"]
    pub entry_timeout: f64,
}
#[test]
fn bindgen_test_layout_fuse_entry_param() {
    assert_eq!(
        ::std::mem::size_of::<fuse_entry_param>(),
        176usize,
        concat!("Size of: ", stringify!(fuse_entry_param))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_entry_param>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_entry_param))
    );
    fn test_field_ino() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_entry_param>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ino) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_entry_param),
                "::",
                stringify!(ino)
            )
        );
    }
    test_field_ino();
    fn test_field_generation() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_entry_param>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).generation) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_entry_param),
                "::",
                stringify!(generation)
            )
        );
    }
    test_field_generation();
    fn test_field_attr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_entry_param>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).attr) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_entry_param),
                "::",
                stringify!(attr)
            )
        );
    }
    test_field_attr();
    fn test_field_attr_timeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_entry_param>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).attr_timeout) as usize - ptr as usize
            },
            160usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_entry_param),
                "::",
                stringify!(attr_timeout)
            )
        );
    }
    test_field_attr_timeout();
    fn test_field_entry_timeout() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_entry_param>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).entry_timeout) as usize - ptr as usize
            },
            168usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_entry_param),
                "::",
                stringify!(entry_timeout)
            )
        );
    }
    test_field_entry_timeout();
}
impl Default for fuse_entry_param {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Additional context associated with requests."]
#[doc = ""]
#[doc = " Note that the reported client uid, gid and pid may be zero in some"]
#[doc = " situations. For example, if the FUSE file system is running in a"]
#[doc = " PID or user namespace but then accessed from outside the namespace,"]
#[doc = " there is no valid uid/pid/gid that could be reported."]
#[repr(C)]
pub struct fuse_ctx {
    #[doc = " User ID of the calling process"]
    pub uid: uid_t,
    #[doc = " Group ID of the calling process"]
    pub gid: gid_t,
    #[doc = " Thread ID of the calling process"]
    pub pid: pid_t,
    #[doc = " Umask of the calling process (introduced in version 2.8)"]
    pub umask: mode_t,
}
#[test]
fn bindgen_test_layout_fuse_ctx() {
    assert_eq!(
        ::std::mem::size_of::<fuse_ctx>(),
        16usize,
        concat!("Size of: ", stringify!(fuse_ctx))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_ctx>(),
        4usize,
        concat!("Alignment of ", stringify!(fuse_ctx))
    );
    fn test_field_uid() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_ctx>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).uid) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_ctx),
                "::",
                stringify!(uid)
            )
        );
    }
    test_field_uid();
    fn test_field_gid() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_ctx>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).gid) as usize - ptr as usize
            },
            4usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_ctx),
                "::",
                stringify!(gid)
            )
        );
    }
    test_field_gid();
    fn test_field_pid() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_ctx>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).pid) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_ctx),
                "::",
                stringify!(pid)
            )
        );
    }
    test_field_pid();
    fn test_field_umask() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_ctx>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).umask) as usize - ptr as usize
            },
            12usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_ctx),
                "::",
                stringify!(umask)
            )
        );
    }
    test_field_umask();
}
impl Default for fuse_ctx {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct fuse_forget_data {
    pub ino: u64,
    pub nlookup: u64,
}
#[test]
fn bindgen_test_layout_fuse_forget_data() {
    assert_eq!(
        ::std::mem::size_of::<fuse_forget_data>(),
        16usize,
        concat!("Size of: ", stringify!(fuse_forget_data))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_forget_data>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_forget_data))
    );
    fn test_field_ino() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_forget_data>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ino) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_forget_data),
                "::",
                stringify!(ino)
            )
        );
    }
    test_field_ino();
    fn test_field_nlookup() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_forget_data>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).nlookup) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_forget_data),
                "::",
                stringify!(nlookup)
            )
        );
    }
    test_field_nlookup();
}
impl Default for fuse_forget_data {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Low level filesystem operations"]
#[doc = ""]
#[doc = " Most of the methods (with the exception of init and destroy)"]
#[doc = " receive a request handle (fuse_req_t) as their first argument."]
#[doc = " This handle must be passed to one of the specified reply functions."]
#[doc = ""]
#[doc = " This may be done inside the method invocation, or after the call"]
#[doc = " has returned.  The request handle is valid until one of the reply"]
#[doc = " functions is called."]
#[doc = ""]
#[doc = " Other pointer arguments (name, fuse_file_info, etc) are not valid"]
#[doc = " after the call has returned, so if they are needed later, their"]
#[doc = " contents have to be copied."]
#[doc = ""]
#[doc = " The filesystem sometimes needs to handle a return value of -ENOENT"]
#[doc = " from the reply function, which means, that the request was"]
#[doc = " interrupted, and the reply discarded.  For example if"]
#[doc = " fuse_reply_open() return -ENOENT means, that the release method for"]
#[doc = " this file will not be called."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fuse_lowlevel_ops {
    #[doc = " Initialize filesystem"]
    #[doc = ""]
    #[doc = " Called before any other filesystem method"]
    #[doc = ""]
    #[doc = " There's no reply to this function"]
    #[doc = ""]
    #[doc = " @param userdata the user data passed to fuse_lowlevel_new()"]
    pub init: ::std::option::Option<
        unsafe extern "C" fn(userdata: *mut ::std::os::raw::c_void, conn: *mut fuse_conn_info),
    >,
    #[doc = " Clean up filesystem"]
    #[doc = ""]
    #[doc = " Called on filesystem exit"]
    #[doc = ""]
    #[doc = " There's no reply to this function"]
    #[doc = ""]
    #[doc = " @param userdata the user data passed to fuse_lowlevel_new()"]
    pub destroy: ::std::option::Option<unsafe extern "C" fn(userdata: *mut ::std::os::raw::c_void)>,
    #[doc = " Look up a directory entry by name and get its attributes."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_entry"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name the name to look up"]
    pub lookup: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
        ),
    >,
    #[doc = " Forget about an inode"]
    #[doc = ""]
    #[doc = " This function is called when the kernel removes an inode"]
    #[doc = " from its internal caches."]
    #[doc = ""]
    #[doc = " The inode's lookup count increases by one for every call to"]
    #[doc = " fuse_reply_entry and fuse_reply_create. The nlookup parameter"]
    #[doc = " indicates by how much the lookup count should be decreased."]
    #[doc = ""]
    #[doc = " Inodes with a non-zero lookup count may receive request from"]
    #[doc = " the kernel even after calls to unlink, rmdir or (when"]
    #[doc = " overwriting an existing file) rename. Filesystems must handle"]
    #[doc = " such requests properly and it is recommended to defer removal"]
    #[doc = " of the inode until the lookup count reaches zero. Calls to"]
    #[doc = " unlink, remdir or rename will be followed closely by forget"]
    #[doc = " unless the file or directory is open, in which case the"]
    #[doc = " kernel issues forget only after the release or releasedir"]
    #[doc = " calls."]
    #[doc = ""]
    #[doc = " Note that if a file system will be exported over NFS the"]
    #[doc = " inodes lifetime must extend even beyond forget. See the"]
    #[doc = " generation field in struct fuse_entry_param above."]
    #[doc = ""]
    #[doc = " On unmount the lookup count for all inodes implicitly drops"]
    #[doc = " to zero. It is not guaranteed that the file system will"]
    #[doc = " receive corresponding forget messages for the affected"]
    #[doc = " inodes."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_none"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param nlookup the number of lookups to forget"]
    pub forget: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, nlookup: ::std::os::raw::c_ulong),
    >,
    #[doc = " Get file attributes"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_attr"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi for future use, currently always NULL"]
    pub getattr: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, fi: *mut fuse_file_info),
    >,
    #[doc = " Set file attributes"]
    #[doc = ""]
    #[doc = " In the 'attr' argument only members indicated by the 'to_set'"]
    #[doc = " bitmask contain valid values.  Other members contain undefined"]
    #[doc = " values."]
    #[doc = ""]
    #[doc = " If the setattr was invoked from the ftruncate() system call"]
    #[doc = " under Linux kernel versions 2.6.15 or later, the fi->fh will"]
    #[doc = " contain the value set by the open method or will be undefined"]
    #[doc = " if the open method didn't set any value.  Otherwise (not"]
    #[doc = " ftruncate call, or kernel version earlier than 2.6.15) the fi"]
    #[doc = " parameter will be NULL."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_attr"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param attr the attributes"]
    #[doc = " @param to_set bit mask of attributes which should be set"]
    #[doc = " @param fi file information, or NULL"]
    #[doc = ""]
    #[doc = " Changed in version 2.5:"]
    #[doc = "     file information filled in for ftruncate"]
    pub setattr: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            attr: *mut stat,
            to_set: ::std::os::raw::c_int,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Read symbolic link"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_readlink"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    pub readlink: ::std::option::Option<unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t)>,
    #[doc = " Create file node"]
    #[doc = ""]
    #[doc = " Create a regular file, character device, block device, fifo or"]
    #[doc = " socket node."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_entry"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name to create"]
    #[doc = " @param mode file type and mode with which to create the new file"]
    #[doc = " @param rdev the device number (only valid if created file is a device)"]
    pub mknod: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
            mode: mode_t,
            rdev: dev_t,
        ),
    >,
    #[doc = " Create a directory"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_entry"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name to create"]
    #[doc = " @param mode with which to create the new file"]
    pub mkdir: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
            mode: mode_t,
        ),
    >,
    #[doc = " Remove a file"]
    #[doc = ""]
    #[doc = " If the file's inode's lookup count is non-zero, the file"]
    #[doc = " system is expected to postpone any removal of the inode"]
    #[doc = " until the lookup count reaches zero (see description of the"]
    #[doc = " forget function)."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name to remove"]
    pub unlink: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
        ),
    >,
    #[doc = " Remove a directory"]
    #[doc = ""]
    #[doc = " If the directory's inode's lookup count is non-zero, the"]
    #[doc = " file system is expected to postpone any removal of the"]
    #[doc = " inode until the lookup count reaches zero (see description"]
    #[doc = " of the forget function)."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name to remove"]
    pub rmdir: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
        ),
    >,
    #[doc = " Create a symbolic link"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_entry"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param link the contents of the symbolic link"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name to create"]
    pub symlink: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            link: *const ::std::os::raw::c_char,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
        ),
    >,
    #[doc = " Rename a file"]
    #[doc = ""]
    #[doc = " If the target exists it should be atomically replaced. If"]
    #[doc = " the target's inode's lookup count is non-zero, the file"]
    #[doc = " system is expected to postpone any removal of the inode"]
    #[doc = " until the lookup count reaches zero (see description of the"]
    #[doc = " forget function)."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the old parent directory"]
    #[doc = " @param name old name"]
    #[doc = " @param newparent inode number of the new parent directory"]
    #[doc = " @param newname new name"]
    pub rename: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
            newparent: fuse_ino_t,
            newname: *const ::std::os::raw::c_char,
        ),
    >,
    #[doc = " Create a hard link"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_entry"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the old inode number"]
    #[doc = " @param newparent inode number of the new parent directory"]
    #[doc = " @param newname new name to create"]
    pub link: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            newparent: fuse_ino_t,
            newname: *const ::std::os::raw::c_char,
        ),
    >,
    #[doc = " Open a file"]
    #[doc = ""]
    #[doc = " Open flags (with the exception of O_CREAT, O_EXCL, O_NOCTTY and"]
    #[doc = " O_TRUNC) are available in fi->flags."]
    #[doc = ""]
    #[doc = " Filesystem may store an arbitrary file handle (pointer, index,"]
    #[doc = " etc) in fi->fh, and use this in other all other file operations"]
    #[doc = " (read, write, flush, release, fsync)."]
    #[doc = ""]
    #[doc = " Filesystem may also implement stateless file I/O and not store"]
    #[doc = " anything in fi->fh."]
    #[doc = ""]
    #[doc = " There are also some flags (direct_io, keep_cache) which the"]
    #[doc = " filesystem may set in fi, to change the way the file is opened."]
    #[doc = " See fuse_file_info structure in <fuse_common.h> for more details."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_open"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    pub open: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, fi: *mut fuse_file_info),
    >,
    #[doc = " Read data"]
    #[doc = ""]
    #[doc = " Read should send exactly the number of bytes requested except"]
    #[doc = " on EOF or error, otherwise the rest of the data will be"]
    #[doc = " substituted with zeroes.  An exception to this is when the file"]
    #[doc = " has been opened in 'direct_io' mode, in which case the return"]
    #[doc = " value of the read system call will reflect the return value of"]
    #[doc = " this operation."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the open method, or will"]
    #[doc = " be undefined if the open method didn't set any value."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_buf"]
    #[doc = "   fuse_reply_iov"]
    #[doc = "   fuse_reply_data"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param size number of bytes to read"]
    #[doc = " @param off offset to read from"]
    #[doc = " @param fi file information"]
    pub read: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            size: size_t,
            off: off_t,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Write data"]
    #[doc = ""]
    #[doc = " Write should return exactly the number of bytes requested"]
    #[doc = " except on error.  An exception to this is when the file has"]
    #[doc = " been opened in 'direct_io' mode, in which case the return value"]
    #[doc = " of the write system call will reflect the return value of this"]
    #[doc = " operation."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the open method, or will"]
    #[doc = " be undefined if the open method didn't set any value."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_write"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param buf data to write"]
    #[doc = " @param size number of bytes to write"]
    #[doc = " @param off offset to write to"]
    #[doc = " @param fi file information"]
    pub write: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            buf: *const ::std::os::raw::c_char,
            size: size_t,
            off: off_t,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Flush method"]
    #[doc = ""]
    #[doc = " This is called on each close() of the opened file."]
    #[doc = ""]
    #[doc = " Since file descriptors can be duplicated (dup, dup2, fork), for"]
    #[doc = " one open call there may be many flush calls."]
    #[doc = ""]
    #[doc = " Filesystems shouldn't assume that flush will always be called"]
    #[doc = " after some writes, or that if will be called at all."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the open method, or will"]
    #[doc = " be undefined if the open method didn't set any value."]
    #[doc = ""]
    #[doc = " NOTE: the name of the method is misleading, since (unlike"]
    #[doc = " fsync) the filesystem is not forced to flush pending writes."]
    #[doc = " One reason to flush data, is if the filesystem wants to return"]
    #[doc = " write errors."]
    #[doc = ""]
    #[doc = " If the filesystem supports file locking operations (setlk,"]
    #[doc = " getlk) it should remove all locks belonging to 'fi->owner'."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    pub flush: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, fi: *mut fuse_file_info),
    >,
    #[doc = " Release an open file"]
    #[doc = ""]
    #[doc = " Release is called when there are no more references to an open"]
    #[doc = " file: all file descriptors are closed and all memory mappings"]
    #[doc = " are unmapped."]
    #[doc = ""]
    #[doc = " For every open call there will be exactly one release call."]
    #[doc = ""]
    #[doc = " The filesystem may reply with an error, but error values are"]
    #[doc = " not returned to close() or munmap() which triggered the"]
    #[doc = " release."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the open method, or will"]
    #[doc = " be undefined if the open method didn't set any value."]
    #[doc = " fi->flags will contain the same flags as for open."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    pub release: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, fi: *mut fuse_file_info),
    >,
    #[doc = " Synchronize file contents"]
    #[doc = ""]
    #[doc = " If the datasync parameter is non-zero, then only the user data"]
    #[doc = " should be flushed, not the meta data."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param datasync flag indicating if only data should be flushed"]
    #[doc = " @param fi file information"]
    pub fsync: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            datasync: ::std::os::raw::c_int,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Open a directory"]
    #[doc = ""]
    #[doc = " Filesystem may store an arbitrary file handle (pointer, index,"]
    #[doc = " etc) in fi->fh, and use this in other all other directory"]
    #[doc = " stream operations (readdir, releasedir, fsyncdir)."]
    #[doc = ""]
    #[doc = " Filesystem may also implement stateless directory I/O and not"]
    #[doc = " store anything in fi->fh, though that makes it impossible to"]
    #[doc = " implement standard conforming directory stream operations in"]
    #[doc = " case the contents of the directory can change between opendir"]
    #[doc = " and releasedir."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_open"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    pub opendir: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, fi: *mut fuse_file_info),
    >,
    #[doc = " Read directory"]
    #[doc = ""]
    #[doc = " Send a buffer filled using fuse_add_direntry(), with size not"]
    #[doc = " exceeding the requested size.  Send an empty buffer on end of"]
    #[doc = " stream."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the opendir method, or"]
    #[doc = " will be undefined if the opendir method didn't set any value."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_buf"]
    #[doc = "   fuse_reply_data"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param size maximum number of bytes to send"]
    #[doc = " @param off offset to continue reading the directory stream"]
    #[doc = " @param fi file information"]
    pub readdir: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            size: size_t,
            off: off_t,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Release an open directory"]
    #[doc = ""]
    #[doc = " For every opendir call there will be exactly one releasedir"]
    #[doc = " call."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the opendir method, or"]
    #[doc = " will be undefined if the opendir method didn't set any value."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    pub releasedir: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, fi: *mut fuse_file_info),
    >,
    #[doc = " Synchronize directory contents"]
    #[doc = ""]
    #[doc = " If the datasync parameter is non-zero, then only the directory"]
    #[doc = " contents should be flushed, not the meta data."]
    #[doc = ""]
    #[doc = " fi->fh will contain the value set by the opendir method, or"]
    #[doc = " will be undefined if the opendir method didn't set any value."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param datasync flag indicating if only data should be flushed"]
    #[doc = " @param fi file information"]
    pub fsyncdir: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            datasync: ::std::os::raw::c_int,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Get file system statistics"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_statfs"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number, zero means \"undefined\""]
    pub statfs: ::std::option::Option<unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t)>,
    #[doc = " Set an extended attribute"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    pub setxattr: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
            value: *const ::std::os::raw::c_char,
            size: size_t,
            flags: ::std::os::raw::c_int,
        ),
    >,
    #[doc = " Get an extended attribute"]
    #[doc = ""]
    #[doc = " If size is zero, the size of the value should be sent with"]
    #[doc = " fuse_reply_xattr."]
    #[doc = ""]
    #[doc = " If the size is non-zero, and the value fits in the buffer, the"]
    #[doc = " value should be sent with fuse_reply_buf."]
    #[doc = ""]
    #[doc = " If the size is too small for the value, the ERANGE error should"]
    #[doc = " be sent."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_buf"]
    #[doc = "   fuse_reply_data"]
    #[doc = "   fuse_reply_xattr"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param name of the extended attribute"]
    #[doc = " @param size maximum size of the value to send"]
    pub getxattr: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
            size: size_t,
        ),
    >,
    #[doc = " List extended attribute names"]
    #[doc = ""]
    #[doc = " If size is zero, the total size of the attribute list should be"]
    #[doc = " sent with fuse_reply_xattr."]
    #[doc = ""]
    #[doc = " If the size is non-zero, and the null character separated"]
    #[doc = " attribute list fits in the buffer, the list should be sent with"]
    #[doc = " fuse_reply_buf."]
    #[doc = ""]
    #[doc = " If the size is too small for the list, the ERANGE error should"]
    #[doc = " be sent."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_buf"]
    #[doc = "   fuse_reply_data"]
    #[doc = "   fuse_reply_xattr"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param size maximum size of the list to send"]
    pub listxattr:
        ::std::option::Option<unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, size: size_t)>,
    #[doc = " Remove an extended attribute"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param name of the extended attribute"]
    pub removexattr: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, name: *const ::std::os::raw::c_char),
    >,
    #[doc = " Check file access permissions"]
    #[doc = ""]
    #[doc = " This will be called for the access() system call.  If the"]
    #[doc = " 'default_permissions' mount option is given, this method is not"]
    #[doc = " called."]
    #[doc = ""]
    #[doc = " This method is not called under Linux kernel versions 2.4.x"]
    #[doc = ""]
    #[doc = " Introduced in version 2.5"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param mask requested access mode"]
    pub access: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, mask: ::std::os::raw::c_int),
    >,
    #[doc = " Create and open a file"]
    #[doc = ""]
    #[doc = " If the file does not exist, first create it with the specified"]
    #[doc = " mode, and then open it."]
    #[doc = ""]
    #[doc = " Open flags (with the exception of O_NOCTTY) are available in"]
    #[doc = " fi->flags."]
    #[doc = ""]
    #[doc = " Filesystem may store an arbitrary file handle (pointer, index,"]
    #[doc = " etc) in fi->fh, and use this in other all other file operations"]
    #[doc = " (read, write, flush, release, fsync)."]
    #[doc = ""]
    #[doc = " There are also some flags (direct_io, keep_cache) which the"]
    #[doc = " filesystem may set in fi, to change the way the file is opened."]
    #[doc = " See fuse_file_info structure in <fuse_common.h> for more details."]
    #[doc = ""]
    #[doc = " If this method is not implemented or under Linux kernel"]
    #[doc = " versions earlier than 2.6.15, the mknod() and open() methods"]
    #[doc = " will be called instead."]
    #[doc = ""]
    #[doc = " Introduced in version 2.5"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_create"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param parent inode number of the parent directory"]
    #[doc = " @param name to create"]
    #[doc = " @param mode file type and mode with which to create the new file"]
    #[doc = " @param fi file information"]
    pub create: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            parent: fuse_ino_t,
            name: *const ::std::os::raw::c_char,
            mode: mode_t,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Test for a POSIX file lock"]
    #[doc = ""]
    #[doc = " Introduced in version 2.6"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_lock"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    #[doc = " @param lock the region/type to test"]
    pub getlk: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            fi: *mut fuse_file_info,
            lock: *mut flock,
        ),
    >,
    #[doc = " Acquire, modify or release a POSIX file lock"]
    #[doc = ""]
    #[doc = " For POSIX threads (NPTL) there's a 1-1 relation between pid and"]
    #[doc = " owner, but otherwise this is not always the case.  For checking"]
    #[doc = " lock ownership, 'fi->owner' must be used.  The l_pid field in"]
    #[doc = " 'struct flock' should only be used to fill in this field in"]
    #[doc = " getlk()."]
    #[doc = ""]
    #[doc = " Note: if the locking methods are not implemented, the kernel"]
    #[doc = " will still allow file locking to work locally.  Hence these are"]
    #[doc = " only interesting for network filesystems and similar."]
    #[doc = ""]
    #[doc = " Introduced in version 2.6"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    #[doc = " @param lock the region/type to set"]
    #[doc = " @param sleep locking operation may sleep"]
    pub setlk: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            fi: *mut fuse_file_info,
            lock: *mut flock,
            sleep: ::std::os::raw::c_int,
        ),
    >,
    #[doc = " Map block index within file to block index within device"]
    #[doc = ""]
    #[doc = " Note: This makes sense only for block device backed filesystems"]
    #[doc = " mounted with the 'blkdev' option"]
    #[doc = ""]
    #[doc = " Introduced in version 2.6"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_bmap"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param blocksize unit of block index"]
    #[doc = " @param idx block index within file"]
    pub bmap: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, ino: fuse_ino_t, blocksize: size_t, idx: u64),
    >,
    #[doc = " Ioctl"]
    #[doc = ""]
    #[doc = " Note: For unrestricted ioctls (not allowed for FUSE"]
    #[doc = " servers), data in and out areas can be discovered by giving"]
    #[doc = " iovs and setting FUSE_IOCTL_RETRY in @flags.  For"]
    #[doc = " restricted ioctls, kernel prepares in/out data area"]
    #[doc = " according to the information encoded in cmd."]
    #[doc = ""]
    #[doc = " Introduced in version 2.8"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_ioctl_retry"]
    #[doc = "   fuse_reply_ioctl"]
    #[doc = "   fuse_reply_ioctl_iov"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param cmd ioctl command"]
    #[doc = " @param arg ioctl argument"]
    #[doc = " @param fi file information"]
    #[doc = " @param flags for FUSE_IOCTL_* flags"]
    #[doc = " @param in_buf data fetched from the caller"]
    #[doc = " @param in_bufsz number of fetched bytes"]
    #[doc = " @param out_bufsz maximum size of output data"]
    pub ioctl: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            cmd: ::std::os::raw::c_int,
            arg: *mut ::std::os::raw::c_void,
            fi: *mut fuse_file_info,
            flags: ::std::os::raw::c_uint,
            in_buf: *const ::std::os::raw::c_void,
            in_bufsz: size_t,
            out_bufsz: size_t,
        ),
    >,
    #[doc = " Poll for IO readiness"]
    #[doc = ""]
    #[doc = " Introduced in version 2.8"]
    #[doc = ""]
    #[doc = " Note: If ph is non-NULL, the client should notify"]
    #[doc = " when IO readiness events occur by calling"]
    #[doc = " fuse_lowelevel_notify_poll() with the specified ph."]
    #[doc = ""]
    #[doc = " Regardless of the number of times poll with a non-NULL ph"]
    #[doc = " is received, single notification is enough to clear all."]
    #[doc = " Notifying more times incurs overhead but doesn't harm"]
    #[doc = " correctness."]
    #[doc = ""]
    #[doc = " The callee is responsible for destroying ph with"]
    #[doc = " fuse_pollhandle_destroy() when no longer in use."]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_poll"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    #[doc = " @param ph poll handle to be used for notification"]
    pub poll: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            fi: *mut fuse_file_info,
            ph: *mut fuse_pollhandle,
        ),
    >,
    #[doc = " Write data made available in a buffer"]
    #[doc = ""]
    #[doc = " This is a more generic version of the ->write() method.  If"]
    #[doc = " FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the"]
    #[doc = " kernel supports splicing from the fuse device, then the"]
    #[doc = " data will be made available in pipe for supporting zero"]
    #[doc = " copy data transfer."]
    #[doc = ""]
    #[doc = " buf->count is guaranteed to be one (and thus buf->idx is"]
    #[doc = " always zero). The write_buf handler must ensure that"]
    #[doc = " bufv->off is correctly updated (reflecting the number of"]
    #[doc = " bytes read from bufv->buf[0])."]
    #[doc = ""]
    #[doc = " Introduced in version 2.9"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_write"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param bufv buffer containing the data"]
    #[doc = " @param off offset to write to"]
    #[doc = " @param fi file information"]
    pub write_buf: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            bufv: *mut fuse_bufvec,
            off: off_t,
            fi: *mut fuse_file_info,
        ),
    >,
    #[doc = " Callback function for the retrieve request"]
    #[doc = ""]
    #[doc = " Introduced in version 2.9"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "\tfuse_reply_none"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param cookie user data supplied to fuse_lowlevel_notify_retrieve()"]
    #[doc = " @param ino the inode number supplied to fuse_lowlevel_notify_retrieve()"]
    #[doc = " @param offset the offset supplied to fuse_lowlevel_notify_retrieve()"]
    #[doc = " @param bufv the buffer containing the returned data"]
    pub retrieve_reply: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            cookie: *mut ::std::os::raw::c_void,
            ino: fuse_ino_t,
            offset: off_t,
            bufv: *mut fuse_bufvec,
        ),
    >,
    #[doc = " Forget about multiple inodes"]
    #[doc = ""]
    #[doc = " See description of the forget function for more"]
    #[doc = " information."]
    #[doc = ""]
    #[doc = " Introduced in version 2.9"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_none"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    pub forget_multi: ::std::option::Option<
        unsafe extern "C" fn(req: fuse_req_t, count: size_t, forgets: *mut fuse_forget_data),
    >,
    #[doc = " Acquire, modify or release a BSD file lock"]
    #[doc = ""]
    #[doc = " Note: if the locking methods are not implemented, the kernel"]
    #[doc = " will still allow file locking to work locally.  Hence these are"]
    #[doc = " only interesting for network filesystems and similar."]
    #[doc = ""]
    #[doc = " Introduced in version 2.9"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param fi file information"]
    #[doc = " @param op the locking operation, see flock(2)"]
    pub flock: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            fi: *mut fuse_file_info,
            op: ::std::os::raw::c_int,
        ),
    >,
    #[doc = " Allocate requested space. If this function returns success then"]
    #[doc = " subsequent writes to the specified range shall not fail due to the lack"]
    #[doc = " of free space on the file system storage media."]
    #[doc = ""]
    #[doc = " Introduced in version 2.9"]
    #[doc = ""]
    #[doc = " Valid replies:"]
    #[doc = "   fuse_reply_err"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param offset starting point for allocated region"]
    #[doc = " @param length size of allocated region"]
    #[doc = " @param mode determines the operation to be performed on the given range,"]
    #[doc = "             see fallocate(2)"]
    pub fallocate: ::std::option::Option<
        unsafe extern "C" fn(
            req: fuse_req_t,
            ino: fuse_ino_t,
            mode: ::std::os::raw::c_int,
            offset: off_t,
            length: off_t,
            fi: *mut fuse_file_info,
        ),
    >,
}
#[test]
fn bindgen_test_layout_fuse_lowlevel_ops() {
    assert_eq!(
        ::std::mem::size_of::<fuse_lowlevel_ops>(),
        328usize,
        concat!("Size of: ", stringify!(fuse_lowlevel_ops))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_lowlevel_ops>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_lowlevel_ops))
    );
    fn test_field_init() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).init) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(init)
            )
        );
    }
    test_field_init();
    fn test_field_destroy() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(destroy)
            )
        );
    }
    test_field_destroy();
    fn test_field_lookup() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).lookup) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(lookup)
            )
        );
    }
    test_field_lookup();
    fn test_field_forget() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).forget) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(forget)
            )
        );
    }
    test_field_forget();
    fn test_field_getattr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).getattr) as usize - ptr as usize
            },
            32usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(getattr)
            )
        );
    }
    test_field_getattr();
    fn test_field_setattr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).setattr) as usize - ptr as usize
            },
            40usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(setattr)
            )
        );
    }
    test_field_setattr();
    fn test_field_readlink() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).readlink) as usize - ptr as usize
            },
            48usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(readlink)
            )
        );
    }
    test_field_readlink();
    fn test_field_mknod() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mknod) as usize - ptr as usize
            },
            56usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(mknod)
            )
        );
    }
    test_field_mknod();
    fn test_field_mkdir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).mkdir) as usize - ptr as usize
            },
            64usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(mkdir)
            )
        );
    }
    test_field_mkdir();
    fn test_field_unlink() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).unlink) as usize - ptr as usize
            },
            72usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(unlink)
            )
        );
    }
    test_field_unlink();
    fn test_field_rmdir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).rmdir) as usize - ptr as usize
            },
            80usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(rmdir)
            )
        );
    }
    test_field_rmdir();
    fn test_field_symlink() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).symlink) as usize - ptr as usize
            },
            88usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(symlink)
            )
        );
    }
    test_field_symlink();
    fn test_field_rename() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).rename) as usize - ptr as usize
            },
            96usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(rename)
            )
        );
    }
    test_field_rename();
    fn test_field_link() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).link) as usize - ptr as usize
            },
            104usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(link)
            )
        );
    }
    test_field_link();
    fn test_field_open() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).open) as usize - ptr as usize
            },
            112usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(open)
            )
        );
    }
    test_field_open();
    fn test_field_read() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize
            },
            120usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(read)
            )
        );
    }
    test_field_read();
    fn test_field_write() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize
            },
            128usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(write)
            )
        );
    }
    test_field_write();
    fn test_field_flush() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).flush) as usize - ptr as usize
            },
            136usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(flush)
            )
        );
    }
    test_field_flush();
    fn test_field_release() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).release) as usize - ptr as usize
            },
            144usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(release)
            )
        );
    }
    test_field_release();
    fn test_field_fsync() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fsync) as usize - ptr as usize
            },
            152usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(fsync)
            )
        );
    }
    test_field_fsync();
    fn test_field_opendir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).opendir) as usize - ptr as usize
            },
            160usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(opendir)
            )
        );
    }
    test_field_opendir();
    fn test_field_readdir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).readdir) as usize - ptr as usize
            },
            168usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(readdir)
            )
        );
    }
    test_field_readdir();
    fn test_field_releasedir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).releasedir) as usize - ptr as usize
            },
            176usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(releasedir)
            )
        );
    }
    test_field_releasedir();
    fn test_field_fsyncdir() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fsyncdir) as usize - ptr as usize
            },
            184usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(fsyncdir)
            )
        );
    }
    test_field_fsyncdir();
    fn test_field_statfs() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).statfs) as usize - ptr as usize
            },
            192usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(statfs)
            )
        );
    }
    test_field_statfs();
    fn test_field_setxattr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).setxattr) as usize - ptr as usize
            },
            200usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(setxattr)
            )
        );
    }
    test_field_setxattr();
    fn test_field_getxattr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).getxattr) as usize - ptr as usize
            },
            208usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(getxattr)
            )
        );
    }
    test_field_getxattr();
    fn test_field_listxattr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).listxattr) as usize - ptr as usize
            },
            216usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(listxattr)
            )
        );
    }
    test_field_listxattr();
    fn test_field_removexattr() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).removexattr) as usize - ptr as usize
            },
            224usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(removexattr)
            )
        );
    }
    test_field_removexattr();
    fn test_field_access() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).access) as usize - ptr as usize
            },
            232usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(access)
            )
        );
    }
    test_field_access();
    fn test_field_create() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).create) as usize - ptr as usize
            },
            240usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(create)
            )
        );
    }
    test_field_create();
    fn test_field_getlk() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).getlk) as usize - ptr as usize
            },
            248usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(getlk)
            )
        );
    }
    test_field_getlk();
    fn test_field_setlk() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).setlk) as usize - ptr as usize
            },
            256usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(setlk)
            )
        );
    }
    test_field_setlk();
    fn test_field_bmap() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).bmap) as usize - ptr as usize
            },
            264usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(bmap)
            )
        );
    }
    test_field_bmap();
    fn test_field_ioctl() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).ioctl) as usize - ptr as usize
            },
            272usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(ioctl)
            )
        );
    }
    test_field_ioctl();
    fn test_field_poll() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).poll) as usize - ptr as usize
            },
            280usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(poll)
            )
        );
    }
    test_field_poll();
    fn test_field_write_buf() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).write_buf) as usize - ptr as usize
            },
            288usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(write_buf)
            )
        );
    }
    test_field_write_buf();
    fn test_field_retrieve_reply() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).retrieve_reply) as usize - ptr as usize
            },
            296usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(retrieve_reply)
            )
        );
    }
    test_field_retrieve_reply();
    fn test_field_forget_multi() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).forget_multi) as usize - ptr as usize
            },
            304usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(forget_multi)
            )
        );
    }
    test_field_forget_multi();
    fn test_field_flock() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).flock) as usize - ptr as usize
            },
            312usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(flock)
            )
        );
    }
    test_field_flock();
    fn test_field_fallocate() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_lowlevel_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).fallocate) as usize - ptr as usize
            },
            320usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_lowlevel_ops),
                "::",
                stringify!(fallocate)
            )
        );
    }
    test_field_fallocate();
}
extern "C" {
    #[doc = " Reply with an error code or success"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   all except forget"]
    #[doc = ""]
    #[doc = " unlink, rmdir, rename, flush, release, fsync, fsyncdir, setxattr,"]
    #[doc = " removexattr and setlk may send a zero code"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param err the positive error value, or zero for success"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_err(req: fuse_req_t, err: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Don't send reply"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   forget"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    pub fn fuse_reply_none(req: fuse_req_t);
}
extern "C" {
    #[doc = " Reply with a directory entry"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   lookup, mknod, mkdir, symlink, link"]
    #[doc = ""]
    #[doc = " Side effects:"]
    #[doc = "   increments the lookup count on success"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param e the entry parameters"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_entry(req: fuse_req_t, e: *const fuse_entry_param) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with a directory entry and open parameters"]
    #[doc = ""]
    #[doc = " currently the following members of 'fi' are used:"]
    #[doc = "   fh, direct_io, keep_cache"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   create"]
    #[doc = ""]
    #[doc = " Side effects:"]
    #[doc = "   increments the lookup count on success"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param e the entry parameters"]
    #[doc = " @param fi file information"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_create(
        req: fuse_req_t,
        e: *const fuse_entry_param,
        fi: *const fuse_file_info,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with attributes"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   getattr, setattr"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param attr the attributes"]
    #[doc = " @param attr_timeout\tvalidity timeout (in seconds) for the attributes"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_attr(
        req: fuse_req_t,
        attr: *const stat,
        attr_timeout: f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with the contents of a symbolic link"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   readlink"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param link symbolic link contents"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_readlink(
        req: fuse_req_t,
        link: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with open parameters"]
    #[doc = ""]
    #[doc = " currently the following members of 'fi' are used:"]
    #[doc = "   fh, direct_io, keep_cache"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   open, opendir"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param fi file information"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_open(req: fuse_req_t, fi: *const fuse_file_info) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with number of bytes written"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   write"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param count the number of bytes written"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_write(req: fuse_req_t, count: size_t) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with data"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   read, readdir, getxattr, listxattr"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param buf buffer containing data"]
    #[doc = " @param size the size of data in bytes"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_buf(
        req: fuse_req_t,
        buf: *const ::std::os::raw::c_char,
        size: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with data copied/moved from buffer(s)"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   read, readdir, getxattr, listxattr"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param bufv buffer vector"]
    #[doc = " @param flags flags controlling the copy"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_data(
        req: fuse_req_t,
        bufv: *mut fuse_bufvec,
        flags: fuse_buf_copy_flags,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with data vector"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   read, readdir, getxattr, listxattr"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param iov the vector containing the data"]
    #[doc = " @param count the size of vector"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_iov(
        req: fuse_req_t,
        iov: *const iovec,
        count: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with filesystem statistics"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   statfs"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param stbuf filesystem statistics"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_statfs(req: fuse_req_t, stbuf: *const statvfs) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with needed buffer size"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   getxattr, listxattr"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param count the buffer size needed in bytes"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_xattr(req: fuse_req_t, count: size_t) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with file lock information"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   getlk"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param lock the lock information"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_lock(req: fuse_req_t, lock: *const flock) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with block index"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   bmap"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param idx block index within device"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_bmap(req: fuse_req_t, idx: u64) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Add a directory entry to the buffer"]
    #[doc = ""]
    #[doc = " Buffer needs to be large enough to hold the entry.  If it's not,"]
    #[doc = " then the entry is not filled in but the size of the entry is still"]
    #[doc = " returned.  The caller can check this by comparing the bufsize"]
    #[doc = " parameter with the returned entry size.  If the entry size is"]
    #[doc = " larger than the buffer size, the operation failed."]
    #[doc = ""]
    #[doc = " From the 'stbuf' argument the st_ino field and bits 12-15 of the"]
    #[doc = " st_mode field are used.  The other fields are ignored."]
    #[doc = ""]
    #[doc = " Note: offsets do not necessarily represent physical offsets, and"]
    #[doc = " could be any marker, that enables the implementation to find a"]
    #[doc = " specific point in the directory stream."]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param buf the point where the new entry will be added to the buffer"]
    #[doc = " @param bufsize remaining size of the buffer"]
    #[doc = " @param name the name of the entry"]
    #[doc = " @param stbuf the file attributes"]
    #[doc = " @param off the offset of the next entry"]
    #[doc = " @return the space needed for the entry"]
    pub fn fuse_add_direntry(
        req: fuse_req_t,
        buf: *mut ::std::os::raw::c_char,
        bufsize: size_t,
        name: *const ::std::os::raw::c_char,
        stbuf: *const stat,
        off: off_t,
    ) -> size_t;
}
extern "C" {
    #[doc = " Reply to ask for data fetch and output buffer preparation.  ioctl"]
    #[doc = " will be retried with the specified input data fetched and output"]
    #[doc = " buffer prepared."]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   ioctl"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param in_iov iovec specifying data to fetch from the caller"]
    #[doc = " @param in_count number of entries in in_iov"]
    #[doc = " @param out_iov iovec specifying addresses to write output to"]
    #[doc = " @param out_count number of entries in out_iov"]
    #[doc = " @return zero for success, -errno for failure to send reply"]
    pub fn fuse_reply_ioctl_retry(
        req: fuse_req_t,
        in_iov: *const iovec,
        in_count: size_t,
        out_iov: *const iovec,
        out_count: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply to finish ioctl"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   ioctl"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param result result to be passed to the caller"]
    #[doc = " @param buf buffer containing output data"]
    #[doc = " @param size length of output data"]
    pub fn fuse_reply_ioctl(
        req: fuse_req_t,
        result: ::std::os::raw::c_int,
        buf: *const ::std::os::raw::c_void,
        size: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply to finish ioctl with iov buffer"]
    #[doc = ""]
    #[doc = " Possible requests:"]
    #[doc = "   ioctl"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param result result to be passed to the caller"]
    #[doc = " @param iov the vector containing the data"]
    #[doc = " @param count the size of vector"]
    pub fn fuse_reply_ioctl_iov(
        req: fuse_req_t,
        result: ::std::os::raw::c_int,
        iov: *const iovec,
        count: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Reply with poll result event mask"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param revents poll result event mask"]
    pub fn fuse_reply_poll(
        req: fuse_req_t,
        revents: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Notify IO readiness event"]
    #[doc = ""]
    #[doc = " For more information, please read comment for poll operation."]
    #[doc = ""]
    #[doc = " @param ph poll handle to notify IO readiness event for"]
    pub fn fuse_lowlevel_notify_poll(ph: *mut fuse_pollhandle) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Notify to invalidate cache for an inode"]
    #[doc = ""]
    #[doc = " @param ch the channel through which to send the invalidation"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param off the offset in the inode where to start invalidating"]
    #[doc = "            or negative to invalidate attributes only"]
    #[doc = " @param len the amount of cache to invalidate or 0 for all"]
    #[doc = " @return zero for success, -errno for failure"]
    pub fn fuse_lowlevel_notify_inval_inode(
        ch: *mut fuse_chan,
        ino: fuse_ino_t,
        off: off_t,
        len: off_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Notify to invalidate parent attributes and the dentry matching"]
    #[doc = " parent/name"]
    #[doc = ""]
    #[doc = " To avoid a deadlock don't call this function from a filesystem operation and"]
    #[doc = " don't call it with a lock held that can also be held by a filesystem"]
    #[doc = " operation."]
    #[doc = ""]
    #[doc = " @param ch the channel through which to send the invalidation"]
    #[doc = " @param parent inode number"]
    #[doc = " @param name file name"]
    #[doc = " @param namelen strlen() of file name"]
    #[doc = " @return zero for success, -errno for failure"]
    pub fn fuse_lowlevel_notify_inval_entry(
        ch: *mut fuse_chan,
        parent: fuse_ino_t,
        name: *const ::std::os::raw::c_char,
        namelen: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Notify to invalidate parent attributes and delete the dentry matching"]
    #[doc = " parent/name if the dentry's inode number matches child (otherwise it"]
    #[doc = " will invalidate the matching dentry)."]
    #[doc = ""]
    #[doc = " To avoid a deadlock don't call this function from a filesystem operation and"]
    #[doc = " don't call it with a lock held that can also be held by a filesystem"]
    #[doc = " operation."]
    #[doc = ""]
    #[doc = " @param ch the channel through which to send the notification"]
    #[doc = " @param parent inode number"]
    #[doc = " @param child inode number"]
    #[doc = " @param name file name"]
    #[doc = " @param namelen strlen() of file name"]
    #[doc = " @return zero for success, -errno for failure"]
    pub fn fuse_lowlevel_notify_delete(
        ch: *mut fuse_chan,
        parent: fuse_ino_t,
        child: fuse_ino_t,
        name: *const ::std::os::raw::c_char,
        namelen: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Store data to the kernel buffers"]
    #[doc = ""]
    #[doc = " Synchronously store data in the kernel buffers belonging to the"]
    #[doc = " given inode.  The stored data is marked up-to-date (no read will be"]
    #[doc = " performed against it, unless it's invalidated or evicted from the"]
    #[doc = " cache)."]
    #[doc = ""]
    #[doc = " If the stored data overflows the current file size, then the size"]
    #[doc = " is extended, similarly to a write(2) on the filesystem."]
    #[doc = ""]
    #[doc = " If this function returns an error, then the store wasn't fully"]
    #[doc = " completed, but it may have been partially completed."]
    #[doc = ""]
    #[doc = " @param ch the channel through which to send the invalidation"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param offset the starting offset into the file to store to"]
    #[doc = " @param bufv buffer vector"]
    #[doc = " @param flags flags controlling the copy"]
    #[doc = " @return zero for success, -errno for failure"]
    pub fn fuse_lowlevel_notify_store(
        ch: *mut fuse_chan,
        ino: fuse_ino_t,
        offset: off_t,
        bufv: *mut fuse_bufvec,
        flags: fuse_buf_copy_flags,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Retrieve data from the kernel buffers"]
    #[doc = ""]
    #[doc = " Retrieve data in the kernel buffers belonging to the given inode."]
    #[doc = " If successful then the retrieve_reply() method will be called with"]
    #[doc = " the returned data."]
    #[doc = ""]
    #[doc = " Only present pages are returned in the retrieve reply.  Retrieving"]
    #[doc = " stops when it finds a non-present page and only data prior to that is"]
    #[doc = " returned."]
    #[doc = ""]
    #[doc = " If this function returns an error, then the retrieve will not be"]
    #[doc = " completed and no reply will be sent."]
    #[doc = ""]
    #[doc = " This function doesn't change the dirty state of pages in the kernel"]
    #[doc = " buffer.  For dirty pages the write() method will be called"]
    #[doc = " regardless of having been retrieved previously."]
    #[doc = ""]
    #[doc = " @param ch the channel through which to send the invalidation"]
    #[doc = " @param ino the inode number"]
    #[doc = " @param size the number of bytes to retrieve"]
    #[doc = " @param offset the starting offset into the file to retrieve from"]
    #[doc = " @param cookie user data to supply to the reply callback"]
    #[doc = " @return zero for success, -errno for failure"]
    pub fn fuse_lowlevel_notify_retrieve(
        ch: *mut fuse_chan,
        ino: fuse_ino_t,
        size: size_t,
        offset: off_t,
        cookie: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Get the userdata from the request"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @return the user data passed to fuse_lowlevel_new()"]
    pub fn fuse_req_userdata(req: fuse_req_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[doc = " Get the context from the request"]
    #[doc = ""]
    #[doc = " The pointer returned by this function will only be valid for the"]
    #[doc = " request's lifetime"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @return the context structure"]
    pub fn fuse_req_ctx(req: fuse_req_t) -> *const fuse_ctx;
}
extern "C" {
    #[doc = " Get the current supplementary group IDs for the specified request"]
    #[doc = ""]
    #[doc = " Similar to the getgroups(2) system call, except the return value is"]
    #[doc = " always the total number of group IDs, even if it is larger than the"]
    #[doc = " specified size."]
    #[doc = ""]
    #[doc = " The current fuse kernel module in linux (as of 2.6.30) doesn't pass"]
    #[doc = " the group list to userspace, hence this function needs to parse"]
    #[doc = " \"/proc/$TID/task/$TID/status\" to get the group IDs."]
    #[doc = ""]
    #[doc = " This feature may not be supported on all operating systems.  In"]
    #[doc = " such a case this function will return -ENOSYS."]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param size size of given array"]
    #[doc = " @param list array of group IDs to be filled in"]
    #[doc = " @return the total number of supplementary group IDs or -errno on failure"]
    pub fn fuse_req_getgroups(
        req: fuse_req_t,
        size: ::std::os::raw::c_int,
        list: *mut gid_t,
    ) -> ::std::os::raw::c_int;
}
#[doc = " Callback function for an interrupt"]
#[doc = ""]
#[doc = " @param req interrupted request"]
#[doc = " @param data user data"]
pub type fuse_interrupt_func_t =
    ::std::option::Option<unsafe extern "C" fn(req: fuse_req_t, data: *mut ::std::os::raw::c_void)>;
extern "C" {
    #[doc = " Register/unregister callback for an interrupt"]
    #[doc = ""]
    #[doc = " If an interrupt has already happened, then the callback function is"]
    #[doc = " called from within this function, hence it's not possible for"]
    #[doc = " interrupts to be lost."]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @param func the callback function or NULL for unregister"]
    #[doc = " @param data user data passed to the callback function"]
    pub fn fuse_req_interrupt_func(
        req: fuse_req_t,
        func: fuse_interrupt_func_t,
        data: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    #[doc = " Check if a request has already been interrupted"]
    #[doc = ""]
    #[doc = " @param req request handle"]
    #[doc = " @return 1 if the request has been interrupted, 0 otherwise"]
    pub fn fuse_req_interrupted(req: fuse_req_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn fuse_lowlevel_is_lib_option(opt: *const ::std::os::raw::c_char)
        -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Create a low level session"]
    #[doc = ""]
    #[doc = " @param args argument vector"]
    #[doc = " @param op the low level filesystem operations"]
    #[doc = " @param op_size sizeof(struct fuse_lowlevel_ops)"]
    #[doc = " @param userdata user data"]
    #[doc = " @return the created session object, or NULL on failure"]
    pub fn fuse_lowlevel_new(
        args: *mut fuse_args,
        op: *const fuse_lowlevel_ops,
        op_size: size_t,
        userdata: *mut ::std::os::raw::c_void,
    ) -> *mut fuse_session;
}
#[doc = " Session operations"]
#[doc = ""]
#[doc = " This is used in session creation"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fuse_session_ops {
    #[doc = " Hook to process a request (mandatory)"]
    #[doc = ""]
    #[doc = " @param data user data passed to fuse_session_new()"]
    #[doc = " @param buf buffer containing the raw request"]
    #[doc = " @param len request length"]
    #[doc = " @param ch channel on which the request was received"]
    pub process: ::std::option::Option<
        unsafe extern "C" fn(
            data: *mut ::std::os::raw::c_void,
            buf: *const ::std::os::raw::c_char,
            len: size_t,
            ch: *mut fuse_chan,
        ),
    >,
    #[doc = " Hook for session exit and reset (optional)"]
    #[doc = ""]
    #[doc = " @param data user data passed to fuse_session_new()"]
    #[doc = " @param val exited status (1 - exited, 0 - not exited)"]
    pub exit: ::std::option::Option<
        unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, val: ::std::os::raw::c_int),
    >,
    #[doc = " Hook for querying the current exited status (optional)"]
    #[doc = ""]
    #[doc = " @param data user data passed to fuse_session_new()"]
    #[doc = " @return 1 if exited, 0 if not exited"]
    pub exited: ::std::option::Option<
        unsafe extern "C" fn(data: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    #[doc = " Hook for cleaning up the channel on destroy (optional)"]
    #[doc = ""]
    #[doc = " @param data user data passed to fuse_session_new()"]
    pub destroy: ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>,
}
#[test]
fn bindgen_test_layout_fuse_session_ops() {
    assert_eq!(
        ::std::mem::size_of::<fuse_session_ops>(),
        32usize,
        concat!("Size of: ", stringify!(fuse_session_ops))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_session_ops>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_session_ops))
    );
    fn test_field_process() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_session_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).process) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_session_ops),
                "::",
                stringify!(process)
            )
        );
    }
    test_field_process();
    fn test_field_exit() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_session_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).exit) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_session_ops),
                "::",
                stringify!(exit)
            )
        );
    }
    test_field_exit();
    fn test_field_exited() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_session_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).exited) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_session_ops),
                "::",
                stringify!(exited)
            )
        );
    }
    test_field_exited();
    fn test_field_destroy() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_session_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize
            },
            24usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_session_ops),
                "::",
                stringify!(destroy)
            )
        );
    }
    test_field_destroy();
}
extern "C" {
    #[doc = " Create a new session"]
    #[doc = ""]
    #[doc = " @param op session operations"]
    #[doc = " @param data user data"]
    #[doc = " @return new session object, or NULL on failure"]
    pub fn fuse_session_new(
        op: *mut fuse_session_ops,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut fuse_session;
}
extern "C" {
    #[doc = " Assign a channel to a session"]
    #[doc = ""]
    #[doc = " Note: currently only a single channel may be assigned.  This may"]
    #[doc = " change in the future"]
    #[doc = ""]
    #[doc = " If a session is destroyed, the assigned channel is also destroyed"]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @param ch the channel"]
    pub fn fuse_session_add_chan(se: *mut fuse_session, ch: *mut fuse_chan);
}
extern "C" {
    #[doc = " Remove a channel from a session"]
    #[doc = ""]
    #[doc = " If the channel is not assigned to a session, then this is a no-op"]
    #[doc = ""]
    #[doc = " @param ch the channel to remove"]
    pub fn fuse_session_remove_chan(ch: *mut fuse_chan);
}
extern "C" {
    #[doc = " Iterate over the channels assigned to a session"]
    #[doc = ""]
    #[doc = " The iterating function needs to start with a NULL channel, and"]
    #[doc = " after that needs to pass the previously returned channel to the"]
    #[doc = " function."]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @param ch the previous channel, or NULL"]
    #[doc = " @return the next channel, or NULL if no more channels exist"]
    pub fn fuse_session_next_chan(se: *mut fuse_session, ch: *mut fuse_chan) -> *mut fuse_chan;
}
extern "C" {
    #[doc = " Process a raw request"]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @param buf buffer containing the raw request"]
    #[doc = " @param len request length"]
    #[doc = " @param ch channel on which the request was received"]
    pub fn fuse_session_process(
        se: *mut fuse_session,
        buf: *const ::std::os::raw::c_char,
        len: size_t,
        ch: *mut fuse_chan,
    );
}
extern "C" {
    #[doc = " Process a raw request supplied in a generic buffer"]
    #[doc = ""]
    #[doc = " This is a more generic version of fuse_session_process().  The"]
    #[doc = " fuse_buf may contain a memory buffer or a pipe file descriptor."]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @param buf the fuse_buf containing the request"]
    #[doc = " @param ch channel on which the request was received"]
    pub fn fuse_session_process_buf(
        se: *mut fuse_session,
        buf: *const fuse_buf,
        ch: *mut fuse_chan,
    );
}
extern "C" {
    #[doc = " Receive a raw request supplied in a generic buffer"]
    #[doc = ""]
    #[doc = " This is a more generic version of fuse_chan_recv().  The fuse_buf"]
    #[doc = " supplied to this function contains a suitably allocated memory"]
    #[doc = " buffer.  This may be overwritten with a file descriptor buffer."]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @param buf the fuse_buf to store the request in"]
    #[doc = " @param chp pointer to the channel"]
    #[doc = " @return the actual size of the raw request, or -errno on error"]
    pub fn fuse_session_receive_buf(
        se: *mut fuse_session,
        buf: *mut fuse_buf,
        chp: *mut *mut fuse_chan,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Destroy a session"]
    #[doc = ""]
    #[doc = " @param se the session"]
    pub fn fuse_session_destroy(se: *mut fuse_session);
}
extern "C" {
    #[doc = " Exit a session"]
    #[doc = ""]
    #[doc = " @param se the session"]
    pub fn fuse_session_exit(se: *mut fuse_session);
}
extern "C" {
    #[doc = " Reset the exited status of a session"]
    #[doc = ""]
    #[doc = " @param se the session"]
    pub fn fuse_session_reset(se: *mut fuse_session);
}
extern "C" {
    #[doc = " Query the exited status of a session"]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @return 1 if exited, 0 if not exited"]
    pub fn fuse_session_exited(se: *mut fuse_session) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Get the user data provided to the session"]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @return the user data"]
    pub fn fuse_session_data(se: *mut fuse_session) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[doc = " Enter a single threaded event loop"]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @return 0 on success, -1 on error"]
    pub fn fuse_session_loop(se: *mut fuse_session) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Enter a multi-threaded event loop"]
    #[doc = ""]
    #[doc = " @param se the session"]
    #[doc = " @return 0 on success, -1 on error"]
    pub fn fuse_session_loop_mt(se: *mut fuse_session) -> ::std::os::raw::c_int;
}
#[doc = " Channel operations"]
#[doc = ""]
#[doc = " This is used in channel creation"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fuse_chan_ops {
    #[doc = " Hook for receiving a raw request"]
    #[doc = ""]
    #[doc = " @param ch pointer to the channel"]
    #[doc = " @param buf the buffer to store the request in"]
    #[doc = " @param size the size of the buffer"]
    #[doc = " @return the actual size of the raw request, or -1 on error"]
    pub receive: ::std::option::Option<
        unsafe extern "C" fn(
            chp: *mut *mut fuse_chan,
            buf: *mut ::std::os::raw::c_char,
            size: size_t,
        ) -> ::std::os::raw::c_int,
    >,
    #[doc = " Hook for sending a raw reply"]
    #[doc = ""]
    #[doc = " A return value of -ENOENT means, that the request was"]
    #[doc = " interrupted, and the reply was discarded"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    #[doc = " @param iov vector of blocks"]
    #[doc = " @param count the number of blocks in vector"]
    #[doc = " @return zero on success, -errno on failure"]
    pub send: ::std::option::Option<
        unsafe extern "C" fn(
            ch: *mut fuse_chan,
            iov: *const iovec,
            count: size_t,
        ) -> ::std::os::raw::c_int,
    >,
    #[doc = " Destroy the channel"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    pub destroy: ::std::option::Option<unsafe extern "C" fn(ch: *mut fuse_chan)>,
}
#[test]
fn bindgen_test_layout_fuse_chan_ops() {
    assert_eq!(
        ::std::mem::size_of::<fuse_chan_ops>(),
        24usize,
        concat!("Size of: ", stringify!(fuse_chan_ops))
    );
    assert_eq!(
        ::std::mem::align_of::<fuse_chan_ops>(),
        8usize,
        concat!("Alignment of ", stringify!(fuse_chan_ops))
    );
    fn test_field_receive() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_chan_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).receive) as usize - ptr as usize
            },
            0usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_chan_ops),
                "::",
                stringify!(receive)
            )
        );
    }
    test_field_receive();
    fn test_field_send() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_chan_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).send) as usize - ptr as usize
            },
            8usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_chan_ops),
                "::",
                stringify!(send)
            )
        );
    }
    test_field_send();
    fn test_field_destroy() {
        assert_eq!(
            unsafe {
                let uninit = ::std::mem::MaybeUninit::<fuse_chan_ops>::uninit();
                let ptr = uninit.as_ptr();
                ::std::ptr::addr_of!((*ptr).destroy) as usize - ptr as usize
            },
            16usize,
            concat!(
                "Offset of field: ",
                stringify!(fuse_chan_ops),
                "::",
                stringify!(destroy)
            )
        );
    }
    test_field_destroy();
}
extern "C" {
    #[doc = " Create a new channel"]
    #[doc = ""]
    #[doc = " @param op channel operations"]
    #[doc = " @param fd file descriptor of the channel"]
    #[doc = " @param bufsize the minimal receive buffer size"]
    #[doc = " @param data user data"]
    #[doc = " @return the new channel object, or NULL on failure"]
    pub fn fuse_chan_new(
        op: *mut fuse_chan_ops,
        fd: ::std::os::raw::c_int,
        bufsize: size_t,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut fuse_chan;
}
extern "C" {
    #[doc = " Query the file descriptor of the channel"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    #[doc = " @return the file descriptor passed to fuse_chan_new()"]
    pub fn fuse_chan_fd(ch: *mut fuse_chan) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Query the minimal receive buffer size"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    #[doc = " @return the buffer size passed to fuse_chan_new()"]
    pub fn fuse_chan_bufsize(ch: *mut fuse_chan) -> size_t;
}
extern "C" {
    #[doc = " Query the user data"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    #[doc = " @return the user data passed to fuse_chan_new()"]
    pub fn fuse_chan_data(ch: *mut fuse_chan) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[doc = " Query the session to which this channel is assigned"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    #[doc = " @return the session, or NULL if the channel is not assigned"]
    pub fn fuse_chan_session(ch: *mut fuse_chan) -> *mut fuse_session;
}
extern "C" {
    #[doc = " Receive a raw request"]
    #[doc = ""]
    #[doc = " A return value of -ENODEV means, that the filesystem was unmounted"]
    #[doc = ""]
    #[doc = " @param ch pointer to the channel"]
    #[doc = " @param buf the buffer to store the request in"]
    #[doc = " @param size the size of the buffer"]
    #[doc = " @return the actual size of the raw request, or -errno on error"]
    pub fn fuse_chan_recv(
        ch: *mut *mut fuse_chan,
        buf: *mut ::std::os::raw::c_char,
        size: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Send a raw reply"]
    #[doc = ""]
    #[doc = " A return value of -ENOENT means, that the request was"]
    #[doc = " interrupted, and the reply was discarded"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    #[doc = " @param iov vector of blocks"]
    #[doc = " @param count the number of blocks in vector"]
    #[doc = " @return zero on success, -errno on failure"]
    pub fn fuse_chan_send(
        ch: *mut fuse_chan,
        iov: *const iovec,
        count: size_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " Destroy a channel"]
    #[doc = ""]
    #[doc = " @param ch the channel"]
    pub fn fuse_chan_destroy(ch: *mut fuse_chan);
}