/* automatically generated by rust-bindgen 0.72.1 */

#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
#[repr(C)]
pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
impl<T> __BindgenUnionField<T> {
    #[inline]
    pub const fn new() -> Self {
        __BindgenUnionField(::std::marker::PhantomData)
    }
    #[inline]
    pub unsafe fn as_ref(&self) -> &T {
        ::std::mem::transmute(self)
    }
    #[inline]
    pub unsafe fn as_mut(&mut self) -> &mut T {
        ::std::mem::transmute(self)
    }
}
impl<T> ::std::default::Default for __BindgenUnionField<T> {
    #[inline]
    fn default() -> Self {
        Self::new()
    }
}
impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__BindgenUnionField")
    }
}
impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
    fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
}
impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
    fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
        true
    }
}
impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
pub type pid_t = __pid_t;
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
pub struct pthread_mutex_t {
    pub __data: __BindgenUnionField<__pthread_mutex_s>,
    pub __size: __BindgenUnionField<[::std::os::raw::c_char; 40usize]>,
    pub __align: __BindgenUnionField<::std::os::raw::c_long>,
    pub bindgen_union_field: [u64; 5usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of pthread_mutex_t"][::std::mem::size_of::<pthread_mutex_t>() - 40usize];
    ["Alignment of pthread_mutex_t"][::std::mem::align_of::<pthread_mutex_t>() - 8usize];
    [
        "Offset of field: pthread_mutex_t::__data",
    ][::std::mem::offset_of!(pthread_mutex_t, __data) - 0usize];
    [
        "Offset of field: pthread_mutex_t::__size",
    ][::std::mem::offset_of!(pthread_mutex_t, __size) - 0usize];
    [
        "Offset of field: pthread_mutex_t::__align",
    ][::std::mem::offset_of!(pthread_mutex_t, __align) - 0usize];
};
impl Default for pthread_mutex_t {
    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 pthread_rwlock_t {
    pub __data: __BindgenUnionField<__pthread_rwlock_arch_t>,
    pub __size: __BindgenUnionField<[::std::os::raw::c_char; 56usize]>,
    pub __align: __BindgenUnionField<::std::os::raw::c_long>,
    pub bindgen_union_field: [u64; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of pthread_rwlock_t"][::std::mem::size_of::<pthread_rwlock_t>() - 56usize];
    [
        "Alignment of pthread_rwlock_t",
    ][::std::mem::align_of::<pthread_rwlock_t>() - 8usize];
    [
        "Offset of field: pthread_rwlock_t::__data",
    ][::std::mem::offset_of!(pthread_rwlock_t, __data) - 0usize];
    [
        "Offset of field: pthread_rwlock_t::__size",
    ][::std::mem::offset_of!(pthread_rwlock_t, __size) - 0usize];
    [
        "Offset of field: pthread_rwlock_t::__align",
    ][::std::mem::offset_of!(pthread_rwlock_t, __align) - 0usize];
};
impl Default for pthread_rwlock_t {
    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()
        }
    }
}
pub type dev_t = __dev_t;
pub type umode_t = ::std::os::raw::c_ushort;
pub type gfp_t = ::std::os::raw::c_uint;
pub type u64_ = __u64;
pub type s64 = __s64;
pub type u32_ = __u32;
pub type u16_ = __u16;
pub type s16 = __s16;
pub type u8_ = __u8;
pub type s8 = __s8;
pub type sector_t = u64_;
pub type loff_t = __loff_t;
pub const linux_page_size: usize = 4096;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cds_list_head {
    pub next: *mut cds_list_head,
    pub prev: *mut cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_list_head"][::std::mem::size_of::<cds_list_head>() - 16usize];
    ["Alignment of cds_list_head"][::std::mem::align_of::<cds_list_head>() - 8usize];
    [
        "Offset of field: cds_list_head::next",
    ][::std::mem::offset_of!(cds_list_head, next) - 0usize];
    [
        "Offset of field: cds_list_head::prev",
    ][::std::mem::offset_of!(cds_list_head, prev) - 8usize];
};
impl Default for cds_list_head {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct cds_hlist_head {
    pub next: *mut cds_hlist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_hlist_head"][::std::mem::size_of::<cds_hlist_head>() - 8usize];
    ["Alignment of cds_hlist_head"][::std::mem::align_of::<cds_hlist_head>() - 8usize];
    [
        "Offset of field: cds_hlist_head::next",
    ][::std::mem::offset_of!(cds_hlist_head, next) - 0usize];
};
impl Default for cds_hlist_head {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct cds_hlist_node {
    pub next: *mut cds_hlist_node,
    pub prev: *mut cds_hlist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_hlist_node"][::std::mem::size_of::<cds_hlist_node>() - 16usize];
    ["Alignment of cds_hlist_node"][::std::mem::align_of::<cds_hlist_node>() - 8usize];
    [
        "Offset of field: cds_hlist_node::next",
    ][::std::mem::offset_of!(cds_hlist_node, next) - 0usize];
    [
        "Offset of field: cds_hlist_node::prev",
    ][::std::mem::offset_of!(cds_hlist_node, prev) - 8usize];
};
impl Default for cds_hlist_node {
    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)]
#[derive(Debug, Default, Copy, Clone)]
pub struct atomic_t {
    pub counter: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of atomic_t"][::std::mem::size_of::<atomic_t>() - 4usize];
    ["Alignment of atomic_t"][::std::mem::align_of::<atomic_t>() - 4usize];
    [
        "Offset of field: atomic_t::counter",
    ][::std::mem::offset_of!(atomic_t, counter) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct atomic_long_t {
    pub counter: ::std::os::raw::c_long,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of atomic_long_t"][::std::mem::size_of::<atomic_long_t>() - 8usize];
    ["Alignment of atomic_long_t"][::std::mem::align_of::<atomic_long_t>() - 8usize];
    [
        "Offset of field: atomic_long_t::counter",
    ][::std::mem::offset_of!(atomic_long_t, counter) - 0usize];
};
#[repr(C)]
pub struct atomic64_t {
    pub counter: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of atomic64_t"][::std::mem::size_of::<atomic64_t>() - 8usize];
    ["Alignment of atomic64_t"][::std::mem::align_of::<atomic64_t>() - 8usize];
    [
        "Offset of field: atomic64_t::counter",
    ][::std::mem::offset_of!(atomic64_t, counter) - 0usize];
};
impl Default for atomic64_t {
    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 raw_spinlock_t {
    pub lock: pthread_mutex_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of raw_spinlock_t"][::std::mem::size_of::<raw_spinlock_t>() - 40usize];
    ["Alignment of raw_spinlock_t"][::std::mem::align_of::<raw_spinlock_t>() - 8usize];
    [
        "Offset of field: raw_spinlock_t::lock",
    ][::std::mem::offset_of!(raw_spinlock_t, lock) - 0usize];
};
impl Default for raw_spinlock_t {
    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()
        }
    }
}
pub type spinlock_t = raw_spinlock_t;
#[repr(C)]
pub struct wait_queue_head {
    pub lock: spinlock_t,
    pub task_list: cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of wait_queue_head"][::std::mem::size_of::<wait_queue_head>() - 56usize];
    ["Alignment of wait_queue_head"][::std::mem::align_of::<wait_queue_head>() - 8usize];
    [
        "Offset of field: wait_queue_head::lock",
    ][::std::mem::offset_of!(wait_queue_head, lock) - 0usize];
    [
        "Offset of field: wait_queue_head::task_list",
    ][::std::mem::offset_of!(wait_queue_head, task_list) - 40usize];
};
impl Default for wait_queue_head {
    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()
        }
    }
}
pub type wait_queue_head_t = wait_queue_head;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct shrink_control {
    pub gfp_mask: gfp_t,
    pub nr_to_scan: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of shrink_control"][::std::mem::size_of::<shrink_control>() - 16usize];
    ["Alignment of shrink_control"][::std::mem::align_of::<shrink_control>() - 8usize];
    [
        "Offset of field: shrink_control::gfp_mask",
    ][::std::mem::offset_of!(shrink_control, gfp_mask) - 0usize];
    [
        "Offset of field: shrink_control::nr_to_scan",
    ][::std::mem::offset_of!(shrink_control, nr_to_scan) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct seq_buf {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct shrinker {
    pub count_objects: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut shrinker,
            sc: *mut shrink_control,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub scan_objects: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut shrinker,
            sc: *mut shrink_control,
        ) -> ::std::os::raw::c_ulong,
    >,
    pub to_text: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut seq_buf, arg2: *mut shrinker),
    >,
    pub seeks: ::std::os::raw::c_int,
    pub batch: ::std::os::raw::c_long,
    pub list: cds_list_head,
    pub private_data: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of shrinker"][::std::mem::size_of::<shrinker>() - 64usize];
    ["Alignment of shrinker"][::std::mem::align_of::<shrinker>() - 8usize];
    [
        "Offset of field: shrinker::count_objects",
    ][::std::mem::offset_of!(shrinker, count_objects) - 0usize];
    [
        "Offset of field: shrinker::scan_objects",
    ][::std::mem::offset_of!(shrinker, scan_objects) - 8usize];
    [
        "Offset of field: shrinker::to_text",
    ][::std::mem::offset_of!(shrinker, to_text) - 16usize];
    [
        "Offset of field: shrinker::seeks",
    ][::std::mem::offset_of!(shrinker, seeks) - 24usize];
    [
        "Offset of field: shrinker::batch",
    ][::std::mem::offset_of!(shrinker, batch) - 32usize];
    [
        "Offset of field: shrinker::list",
    ][::std::mem::offset_of!(shrinker, list) - 40usize];
    [
        "Offset of field: shrinker::private_data",
    ][::std::mem::offset_of!(shrinker, private_data) - 56usize];
};
impl Default for shrinker {
    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()
        }
    }
}
pub type mempool_alloc_t = ::std::option::Option<
    unsafe extern "C" fn(
        gfp_mask: gfp_t,
        pool_data: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type mempool_free_t = ::std::option::Option<
    unsafe extern "C" fn(
        element: *mut ::std::os::raw::c_void,
        pool_data: *mut ::std::os::raw::c_void,
    ),
>;
#[repr(C)]
pub struct mempool_s {
    pub lock: spinlock_t,
    pub min_nr: ::std::os::raw::c_int,
    pub curr_nr: ::std::os::raw::c_int,
    pub elements: *mut *mut ::std::os::raw::c_void,
    pub pool_data: *mut ::std::os::raw::c_void,
    pub alloc: mempool_alloc_t,
    pub free: mempool_free_t,
    pub wait: wait_queue_head_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mempool_s"][::std::mem::size_of::<mempool_s>() - 136usize];
    ["Alignment of mempool_s"][::std::mem::align_of::<mempool_s>() - 8usize];
    [
        "Offset of field: mempool_s::lock",
    ][::std::mem::offset_of!(mempool_s, lock) - 0usize];
    [
        "Offset of field: mempool_s::min_nr",
    ][::std::mem::offset_of!(mempool_s, min_nr) - 40usize];
    [
        "Offset of field: mempool_s::curr_nr",
    ][::std::mem::offset_of!(mempool_s, curr_nr) - 44usize];
    [
        "Offset of field: mempool_s::elements",
    ][::std::mem::offset_of!(mempool_s, elements) - 48usize];
    [
        "Offset of field: mempool_s::pool_data",
    ][::std::mem::offset_of!(mempool_s, pool_data) - 56usize];
    [
        "Offset of field: mempool_s::alloc",
    ][::std::mem::offset_of!(mempool_s, alloc) - 64usize];
    [
        "Offset of field: mempool_s::free",
    ][::std::mem::offset_of!(mempool_s, free) - 72usize];
    [
        "Offset of field: mempool_s::wait",
    ][::std::mem::offset_of!(mempool_s, wait) - 80usize];
};
impl Default for mempool_s {
    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()
        }
    }
}
pub type mempool_t = mempool_s;
pub type congested_fn = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut ::std::os::raw::c_void,
        arg2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct backing_dev_info {
    pub bdi_list: cds_list_head,
    pub ra_pages: ::std::os::raw::c_uint,
    pub capabilities: ::std::os::raw::c_uint,
    pub congested_fn: congested_fn,
    pub congested_data: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of backing_dev_info"][::std::mem::size_of::<backing_dev_info>() - 40usize];
    [
        "Alignment of backing_dev_info",
    ][::std::mem::align_of::<backing_dev_info>() - 8usize];
    [
        "Offset of field: backing_dev_info::bdi_list",
    ][::std::mem::offset_of!(backing_dev_info, bdi_list) - 0usize];
    [
        "Offset of field: backing_dev_info::ra_pages",
    ][::std::mem::offset_of!(backing_dev_info, ra_pages) - 16usize];
    [
        "Offset of field: backing_dev_info::capabilities",
    ][::std::mem::offset_of!(backing_dev_info, capabilities) - 20usize];
    [
        "Offset of field: backing_dev_info::congested_fn",
    ][::std::mem::offset_of!(backing_dev_info, congested_fn) - 24usize];
    [
        "Offset of field: backing_dev_info::congested_data",
    ][::std::mem::offset_of!(backing_dev_info, congested_data) - 32usize];
};
impl Default for backing_dev_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()
        }
    }
}
#[repr(C)]
pub struct bvec_iter {
    pub bi_sector: sector_t,
    pub bi_size: ::std::os::raw::c_uint,
    pub bi_idx: ::std::os::raw::c_uint,
    pub bi_bvec_done: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bvec_iter"][::std::mem::size_of::<bvec_iter>() - 24usize];
    ["Alignment of bvec_iter"][::std::mem::align_of::<bvec_iter>() - 8usize];
    [
        "Offset of field: bvec_iter::bi_sector",
    ][::std::mem::offset_of!(bvec_iter, bi_sector) - 0usize];
    [
        "Offset of field: bvec_iter::bi_size",
    ][::std::mem::offset_of!(bvec_iter, bi_size) - 8usize];
    [
        "Offset of field: bvec_iter::bi_idx",
    ][::std::mem::offset_of!(bvec_iter, bi_idx) - 12usize];
    [
        "Offset of field: bvec_iter::bi_bvec_done",
    ][::std::mem::offset_of!(bvec_iter, bi_bvec_done) - 16usize];
};
impl Default for bvec_iter {
    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)]
#[derive(Debug, Default, Copy, Clone)]
pub struct bvec_iter_all {
    pub idx: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bvec_iter_all"][::std::mem::size_of::<bvec_iter_all>() - 4usize];
    ["Alignment of bvec_iter_all"][::std::mem::align_of::<bvec_iter_all>() - 4usize];
    [
        "Offset of field: bvec_iter_all::idx",
    ][::std::mem::offset_of!(bvec_iter_all, idx) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct attribute {
    pub name: *const ::std::os::raw::c_char,
    pub mode: umode_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of attribute"][::std::mem::size_of::<attribute>() - 16usize];
    ["Alignment of attribute"][::std::mem::align_of::<attribute>() - 8usize];
    [
        "Offset of field: attribute::name",
    ][::std::mem::offset_of!(attribute, name) - 0usize];
    [
        "Offset of field: attribute::mode",
    ][::std::mem::offset_of!(attribute, mode) - 8usize];
};
impl Default for attribute {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct attribute_group {
    pub attrs: *mut *mut attribute,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of attribute_group"][::std::mem::size_of::<attribute_group>() - 8usize];
    ["Alignment of attribute_group"][::std::mem::align_of::<attribute_group>() - 8usize];
    [
        "Offset of field: attribute_group::attrs",
    ][::std::mem::offset_of!(attribute_group, attrs) - 0usize];
};
impl Default for attribute_group {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct bin_attribute {
    pub attr: attribute,
    pub size: usize,
    pub private: *mut ::std::os::raw::c_void,
    pub read: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut file,
            arg2: *mut kobject,
            arg3: *const bin_attribute,
            arg4: *mut ::std::os::raw::c_char,
            arg5: loff_t,
            arg6: usize,
        ) -> isize,
    >,
    pub write: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut file,
            arg2: *mut kobject,
            arg3: *const bin_attribute,
            arg4: *mut ::std::os::raw::c_char,
            arg5: loff_t,
            arg6: usize,
        ) -> isize,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bin_attribute"][::std::mem::size_of::<bin_attribute>() - 48usize];
    ["Alignment of bin_attribute"][::std::mem::align_of::<bin_attribute>() - 8usize];
    [
        "Offset of field: bin_attribute::attr",
    ][::std::mem::offset_of!(bin_attribute, attr) - 0usize];
    [
        "Offset of field: bin_attribute::size",
    ][::std::mem::offset_of!(bin_attribute, size) - 16usize];
    [
        "Offset of field: bin_attribute::private",
    ][::std::mem::offset_of!(bin_attribute, private) - 24usize];
    [
        "Offset of field: bin_attribute::read",
    ][::std::mem::offset_of!(bin_attribute, read) - 32usize];
    [
        "Offset of field: bin_attribute::write",
    ][::std::mem::offset_of!(bin_attribute, write) - 40usize];
};
impl Default for bin_attribute {
    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)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sysfs_ops {
    pub show: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut kobject,
            arg2: *mut attribute,
            arg3: *mut ::std::os::raw::c_char,
        ) -> isize,
    >,
    pub store: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut kobject,
            arg2: *mut attribute,
            arg3: *const ::std::os::raw::c_char,
            arg4: usize,
        ) -> isize,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of sysfs_ops"][::std::mem::size_of::<sysfs_ops>() - 16usize];
    ["Alignment of sysfs_ops"][::std::mem::align_of::<sysfs_ops>() - 8usize];
    [
        "Offset of field: sysfs_ops::show",
    ][::std::mem::offset_of!(sysfs_ops, show) - 0usize];
    [
        "Offset of field: sysfs_ops::store",
    ][::std::mem::offset_of!(sysfs_ops, store) - 8usize];
};
unsafe extern "C" {
    pub fn sysfs_create_file(
        arg1: *mut kobject,
        arg2: *const attribute,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn sysfs_create_bin_file(
        arg1: *mut kobject,
        arg2: *const bin_attribute,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn sysfs_remove_bin_file(arg1: *mut kobject, arg2: *const bin_attribute);
}
unsafe extern "C" {
    #[link_name = "sysfs_create_link__extern"]
    pub fn sysfs_create_link(
        kobj: *mut kobject,
        target: *mut kobject,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "sysfs_remove_link__extern"]
    pub fn sysfs_remove_link(kobj: *mut kobject, name: *const ::std::os::raw::c_char);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timer_list {
    pub expires: ::std::os::raw::c_ulong,
    pub function: ::std::option::Option<unsafe extern "C" fn(timer: *mut timer_list)>,
    pub pending: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of timer_list"][::std::mem::size_of::<timer_list>() - 24usize];
    ["Alignment of timer_list"][::std::mem::align_of::<timer_list>() - 8usize];
    [
        "Offset of field: timer_list::expires",
    ][::std::mem::offset_of!(timer_list, expires) - 0usize];
    [
        "Offset of field: timer_list::function",
    ][::std::mem::offset_of!(timer_list, function) - 8usize];
    [
        "Offset of field: timer_list::pending",
    ][::std::mem::offset_of!(timer_list, pending) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct workqueue_struct {
    _unused: [u8; 0],
}
pub type work_func_t = ::std::option::Option<
    unsafe extern "C" fn(work: *mut work_struct),
>;
#[repr(C)]
pub struct work_struct {
    pub data: atomic_long_t,
    pub entry: cds_list_head,
    pub func: work_func_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of work_struct"][::std::mem::size_of::<work_struct>() - 32usize];
    ["Alignment of work_struct"][::std::mem::align_of::<work_struct>() - 8usize];
    [
        "Offset of field: work_struct::data",
    ][::std::mem::offset_of!(work_struct, data) - 0usize];
    [
        "Offset of field: work_struct::entry",
    ][::std::mem::offset_of!(work_struct, entry) - 8usize];
    [
        "Offset of field: work_struct::func",
    ][::std::mem::offset_of!(work_struct, func) - 24usize];
};
impl Default for work_struct {
    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 delayed_work {
    pub work: work_struct,
    pub timer: timer_list,
    pub wq: *mut workqueue_struct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of delayed_work"][::std::mem::size_of::<delayed_work>() - 64usize];
    ["Alignment of delayed_work"][::std::mem::align_of::<delayed_work>() - 8usize];
    [
        "Offset of field: delayed_work::work",
    ][::std::mem::offset_of!(delayed_work, work) - 0usize];
    [
        "Offset of field: delayed_work::timer",
    ][::std::mem::offset_of!(delayed_work, timer) - 32usize];
    [
        "Offset of field: delayed_work::wq",
    ][::std::mem::offset_of!(delayed_work, wq) - 56usize];
};
impl Default for delayed_work {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct kobj_type {
    pub release: ::std::option::Option<unsafe extern "C" fn(kobj: *mut kobject)>,
    pub sysfs_ops: *const sysfs_ops,
    pub default_groups: *mut *const attribute_group,
    pub child_ns_type: ::std::option::Option<
        unsafe extern "C" fn(kobj: *mut kobject) -> *const kobj_ns_type_operations,
    >,
    pub namespace: ::std::option::Option<
        unsafe extern "C" fn(kobj: *mut kobject) -> *const ::std::os::raw::c_void,
    >,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of kobj_type"][::std::mem::size_of::<kobj_type>() - 40usize];
    ["Alignment of kobj_type"][::std::mem::align_of::<kobj_type>() - 8usize];
    [
        "Offset of field: kobj_type::release",
    ][::std::mem::offset_of!(kobj_type, release) - 0usize];
    [
        "Offset of field: kobj_type::sysfs_ops",
    ][::std::mem::offset_of!(kobj_type, sysfs_ops) - 8usize];
    [
        "Offset of field: kobj_type::default_groups",
    ][::std::mem::offset_of!(kobj_type, default_groups) - 16usize];
    [
        "Offset of field: kobj_type::child_ns_type",
    ][::std::mem::offset_of!(kobj_type, child_ns_type) - 24usize];
    [
        "Offset of field: kobj_type::namespace",
    ][::std::mem::offset_of!(kobj_type, namespace) - 32usize];
};
impl Default for kobj_type {
    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)]
#[derive(Debug)]
pub struct kobject {
    pub name: *const ::std::os::raw::c_char,
    pub parent: *mut kobject,
    pub ktype: *const kobj_type,
    pub ref_: atomic_t,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub subdirs: kobject__bindgen_ty_1,
    pub files: kobject__bindgen_ty_2,
    pub bin_files: kobject__bindgen_ty_3,
}
#[repr(C)]
#[derive(Debug)]
pub struct kobject__bindgen_ty_1 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *mut kobject,
    pub preallocated: __IncompleteArrayField<*mut kobject>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of kobject__bindgen_ty_1",
    ][::std::mem::size_of::<kobject__bindgen_ty_1>() - 24usize];
    [
        "Alignment of kobject__bindgen_ty_1",
    ][::std::mem::align_of::<kobject__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_1::nr",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, nr) - 0usize];
    [
        "Offset of field: kobject__bindgen_ty_1::size",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, size) - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_1::data",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, data) - 16usize];
    [
        "Offset of field: kobject__bindgen_ty_1::preallocated",
    ][::std::mem::offset_of!(kobject__bindgen_ty_1, preallocated) - 24usize];
};
impl Default for kobject__bindgen_ty_1 {
    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)]
#[derive(Debug)]
pub struct kobject__bindgen_ty_2 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *const attribute,
    pub preallocated: __IncompleteArrayField<*const attribute>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of kobject__bindgen_ty_2",
    ][::std::mem::size_of::<kobject__bindgen_ty_2>() - 24usize];
    [
        "Alignment of kobject__bindgen_ty_2",
    ][::std::mem::align_of::<kobject__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_2::nr",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, nr) - 0usize];
    [
        "Offset of field: kobject__bindgen_ty_2::size",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, size) - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_2::data",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, data) - 16usize];
    [
        "Offset of field: kobject__bindgen_ty_2::preallocated",
    ][::std::mem::offset_of!(kobject__bindgen_ty_2, preallocated) - 24usize];
};
impl Default for kobject__bindgen_ty_2 {
    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)]
#[derive(Debug)]
pub struct kobject__bindgen_ty_3 {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *const bin_attribute,
    pub preallocated: __IncompleteArrayField<*const bin_attribute>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of kobject__bindgen_ty_3",
    ][::std::mem::size_of::<kobject__bindgen_ty_3>() - 24usize];
    [
        "Alignment of kobject__bindgen_ty_3",
    ][::std::mem::align_of::<kobject__bindgen_ty_3>() - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_3::nr",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, nr) - 0usize];
    [
        "Offset of field: kobject__bindgen_ty_3::size",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, size) - 8usize];
    [
        "Offset of field: kobject__bindgen_ty_3::data",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, data) - 16usize];
    [
        "Offset of field: kobject__bindgen_ty_3::preallocated",
    ][::std::mem::offset_of!(kobject__bindgen_ty_3, preallocated) - 24usize];
};
impl Default for kobject__bindgen_ty_3 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of kobject"][::std::mem::size_of::<kobject>() - 104usize];
    ["Alignment of kobject"][::std::mem::align_of::<kobject>() - 8usize];
    ["Offset of field: kobject::name"][::std::mem::offset_of!(kobject, name) - 0usize];
    [
        "Offset of field: kobject::parent",
    ][::std::mem::offset_of!(kobject, parent) - 8usize];
    [
        "Offset of field: kobject::ktype",
    ][::std::mem::offset_of!(kobject, ktype) - 16usize];
    ["Offset of field: kobject::ref_"][::std::mem::offset_of!(kobject, ref_) - 24usize];
    [
        "Offset of field: kobject::subdirs",
    ][::std::mem::offset_of!(kobject, subdirs) - 32usize];
    [
        "Offset of field: kobject::files",
    ][::std::mem::offset_of!(kobject, files) - 56usize];
    [
        "Offset of field: kobject::bin_files",
    ][::std::mem::offset_of!(kobject, bin_files) - 80usize];
};
impl Default for kobject {
    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 kobject {
    #[inline]
    pub fn state_initialized(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_initialized(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_initialized_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_initialized_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_in_sysfs(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_in_sysfs(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_in_sysfs_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 1usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_in_sysfs_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_add_uevent_sent(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_add_uevent_sent(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_add_uevent_sent_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_add_uevent_sent_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn state_remove_uevent_sent(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_state_remove_uevent_sent(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn state_remove_uevent_sent_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 3usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_state_remove_uevent_sent_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                3usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn uevent_suppress(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_uevent_suppress(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn uevent_suppress_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 4usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_uevent_suppress_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        state_initialized: bool,
        state_in_sysfs: bool,
        state_add_uevent_sent: bool,
        state_remove_uevent_sent: bool,
        uevent_suppress: bool,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let state_initialized: u8 = unsafe {
                        ::std::mem::transmute(state_initialized)
                    };
                    state_initialized as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                1usize,
                1u8,
                {
                    let state_in_sysfs: u8 = unsafe {
                        ::std::mem::transmute(state_in_sysfs)
                    };
                    state_in_sysfs as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                1u8,
                {
                    let state_add_uevent_sent: u8 = unsafe {
                        ::std::mem::transmute(state_add_uevent_sent)
                    };
                    state_add_uevent_sent as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                3usize,
                1u8,
                {
                    let state_remove_uevent_sent: u8 = unsafe {
                        ::std::mem::transmute(state_remove_uevent_sent)
                    };
                    state_remove_uevent_sent as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                4usize,
                1u8,
                {
                    let uevent_suppress: u8 = unsafe {
                        ::std::mem::transmute(uevent_suppress)
                    };
                    uevent_suppress as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
unsafe extern "C" {
    pub fn sysfs_read_or_html_dirlist(
        arg1: *const ::std::os::raw::c_char,
        arg2: *mut printbuf,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn sysfs_write(
        arg1: *const ::std::os::raw::c_char,
        arg2: *const ::std::os::raw::c_char,
        arg3: usize,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
pub struct mutex {
    pub lock: pthread_mutex_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mutex"][::std::mem::size_of::<mutex>() - 40usize];
    ["Alignment of mutex"][::std::mem::align_of::<mutex>() - 8usize];
    ["Offset of field: mutex::lock"][::std::mem::offset_of!(mutex, lock) - 0usize];
};
impl Default for mutex {
    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 rw_semaphore {
    pub lock: pthread_rwlock_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rw_semaphore"][::std::mem::size_of::<rw_semaphore>() - 56usize];
    ["Alignment of rw_semaphore"][::std::mem::align_of::<rw_semaphore>() - 8usize];
    [
        "Offset of field: rw_semaphore::lock",
    ][::std::mem::offset_of!(rw_semaphore, lock) - 0usize];
};
impl Default for rw_semaphore {
    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()
        }
    }
}
pub type blk_mode_t = ::std::os::raw::c_uint;
#[repr(C)]
pub struct inode {
    pub i_ino: ::std::os::raw::c_ulong,
    pub i_size: loff_t,
    pub i_sb: *mut super_block,
    pub mode: blk_mode_t,
    pub i_private: *mut ::std::os::raw::c_void,
    pub i_state: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of inode"][::std::mem::size_of::<inode>() - 48usize];
    ["Alignment of inode"][::std::mem::align_of::<inode>() - 8usize];
    ["Offset of field: inode::i_ino"][::std::mem::offset_of!(inode, i_ino) - 0usize];
    ["Offset of field: inode::i_size"][::std::mem::offset_of!(inode, i_size) - 8usize];
    ["Offset of field: inode::i_sb"][::std::mem::offset_of!(inode, i_sb) - 16usize];
    ["Offset of field: inode::mode"][::std::mem::offset_of!(inode, mode) - 24usize];
    [
        "Offset of field: inode::i_private",
    ][::std::mem::offset_of!(inode, i_private) - 32usize];
    [
        "Offset of field: inode::i_state",
    ][::std::mem::offset_of!(inode, i_state) - 40usize];
};
impl Default for inode {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct request_queue {
    pub backing_dev_info: *mut backing_dev_info,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of request_queue"][::std::mem::size_of::<request_queue>() - 8usize];
    ["Alignment of request_queue"][::std::mem::align_of::<request_queue>() - 8usize];
    [
        "Offset of field: request_queue::backing_dev_info",
    ][::std::mem::offset_of!(request_queue, backing_dev_info) - 0usize];
};
impl Default for request_queue {
    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)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct gendisk {
    pub _bindgen_opaque_blob: [u64; 6usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of gendisk"][::std::mem::size_of::<gendisk>() - 48usize];
    ["Alignment of gendisk"][::std::mem::align_of::<gendisk>() - 8usize];
};
#[repr(C)]
pub struct block_device {
    pub kobj: kobject,
    pub bd_device: block_device__bindgen_ty_1,
    pub bd_dev: dev_t,
    pub name: [::std::os::raw::c_char; 32usize],
    pub bd_inode: *mut inode,
    pub __bd_inode: inode,
    pub queue: request_queue,
    pub bd_holder: *mut ::std::os::raw::c_void,
    pub bd_disk: *mut gendisk,
    pub __bd_disk: gendisk,
    pub bd_fd: ::std::os::raw::c_int,
    pub bd_holder_lock: mutex,
}
#[repr(C)]
#[derive(Debug)]
pub struct block_device__bindgen_ty_1 {
    pub kobj: kobject,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of block_device__bindgen_ty_1",
    ][::std::mem::size_of::<block_device__bindgen_ty_1>() - 104usize];
    [
        "Alignment of block_device__bindgen_ty_1",
    ][::std::mem::align_of::<block_device__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: block_device__bindgen_ty_1::kobj",
    ][::std::mem::offset_of!(block_device__bindgen_ty_1, kobj) - 0usize];
};
impl Default for block_device__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of block_device"][::std::mem::size_of::<block_device>() - 424usize];
    ["Alignment of block_device"][::std::mem::align_of::<block_device>() - 8usize];
    [
        "Offset of field: block_device::kobj",
    ][::std::mem::offset_of!(block_device, kobj) - 0usize];
    [
        "Offset of field: block_device::bd_device",
    ][::std::mem::offset_of!(block_device, bd_device) - 104usize];
    [
        "Offset of field: block_device::bd_dev",
    ][::std::mem::offset_of!(block_device, bd_dev) - 208usize];
    [
        "Offset of field: block_device::name",
    ][::std::mem::offset_of!(block_device, name) - 216usize];
    [
        "Offset of field: block_device::bd_inode",
    ][::std::mem::offset_of!(block_device, bd_inode) - 248usize];
    [
        "Offset of field: block_device::__bd_inode",
    ][::std::mem::offset_of!(block_device, __bd_inode) - 256usize];
    [
        "Offset of field: block_device::queue",
    ][::std::mem::offset_of!(block_device, queue) - 304usize];
    [
        "Offset of field: block_device::bd_holder",
    ][::std::mem::offset_of!(block_device, bd_holder) - 312usize];
    [
        "Offset of field: block_device::bd_disk",
    ][::std::mem::offset_of!(block_device, bd_disk) - 320usize];
    [
        "Offset of field: block_device::__bd_disk",
    ][::std::mem::offset_of!(block_device, __bd_disk) - 328usize];
    [
        "Offset of field: block_device::bd_fd",
    ][::std::mem::offset_of!(block_device, bd_fd) - 376usize];
    [
        "Offset of field: block_device::bd_holder_lock",
    ][::std::mem::offset_of!(block_device, bd_holder_lock) - 384usize];
};
impl Default for block_device {
    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()
        }
    }
}
pub type blk_status_t = u8_;
unsafe extern "C" {
    #[link_name = "bio_inline_vecs__extern"]
    pub fn bio_inline_vecs(bio: *mut bio) -> *mut bio_vec;
}
pub type blk_opf_t = __u32;
unsafe extern "C" {
    #[link_name = "bio_set_op_attrs__extern"]
    pub fn bio_set_op_attrs(
        bio: *mut bio,
        op: ::std::os::raw::c_uint,
        op_flags: ::std::os::raw::c_uint,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct file {
    pub f_inode: *mut inode,
    pub private_data: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of file"][::std::mem::size_of::<file>() - 16usize];
    ["Alignment of file"][::std::mem::align_of::<file>() - 8usize];
    ["Offset of field: file::f_inode"][::std::mem::offset_of!(file, f_inode) - 0usize];
    [
        "Offset of field: file::private_data",
    ][::std::mem::offset_of!(file, private_data) - 8usize];
};
impl Default for file {
    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 super_block {
    pub s_fs_info: *mut ::std::os::raw::c_void,
    pub s_umount: rw_semaphore,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of super_block"][::std::mem::size_of::<super_block>() - 64usize];
    ["Alignment of super_block"][::std::mem::align_of::<super_block>() - 8usize];
    [
        "Offset of field: super_block::s_fs_info",
    ][::std::mem::offset_of!(super_block, s_fs_info) - 0usize];
    [
        "Offset of field: super_block::s_umount",
    ][::std::mem::offset_of!(super_block, s_umount) - 8usize];
};
impl Default for super_block {
    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()
        }
    }
}
unsafe extern "C" {
    #[link_name = "bio_data_dir__extern"]
    pub fn bio_data_dir(bio: *mut bio) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bio_has_data__extern"]
    pub fn bio_has_data(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_no_advance_iter__extern"]
    pub fn bio_no_advance_iter(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_is_rw__extern"]
    pub fn bio_is_rw(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_mergeable__extern"]
    pub fn bio_mergeable(bio: *mut bio) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_cur_bytes__extern"]
    pub fn bio_cur_bytes(bio: *mut bio) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bio_next_segment__extern"]
    pub fn bio_next_segment(bio: *const bio, iter: *mut bvec_iter_all) -> *mut bio_vec;
}
unsafe extern "C" {
    #[link_name = "bio_advance_iter__extern"]
    pub fn bio_advance_iter(
        bio: *mut bio,
        iter: *mut bvec_iter,
        bytes: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bio_segments__extern"]
    pub fn bio_segments(bio: *mut bio) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bio_get__extern"]
    pub fn bio_get(bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_flagged__extern"]
    pub fn bio_flagged(bio: *mut bio, bit: ::std::os::raw::c_uint) -> bool;
}
unsafe extern "C" {
    #[link_name = "bio_set_flag__extern"]
    pub fn bio_set_flag(bio: *mut bio, bit: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    #[link_name = "bio_clear_flag__extern"]
    pub fn bio_clear_flag(bio: *mut bio, bit: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bio_split(
        bio: *mut bio,
        sectors: ::std::os::raw::c_int,
        gfp: gfp_t,
        bs: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_next_split__extern"]
    pub fn bio_next_split(
        bio: *mut bio,
        sectors: ::std::os::raw::c_int,
        gfp: gfp_t,
        bs: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_alloc_bioset(
        arg1: *mut block_device,
        arg2: ::std::os::raw::c_uint,
        arg3: blk_opf_t,
        arg4: gfp_t,
        arg5: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_put(arg1: *mut bio);
}
unsafe extern "C" {
    pub fn bio_add_virt_nofail(
        arg1: *mut bio,
        arg2: *mut ::std::os::raw::c_void,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    #[link_name = "bio_add_vmalloc__extern"]
    pub fn bio_add_vmalloc(
        bio: *mut bio,
        vaddr: *mut ::std::os::raw::c_void,
        len: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bio_alloc_clone(
        arg1: *mut block_device,
        arg2: *mut bio,
        arg3: gfp_t,
        arg4: *mut bio_set,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_alloc(
        arg1: *mut block_device,
        arg2: ::std::os::raw::c_uint,
        arg3: blk_opf_t,
        arg4: gfp_t,
    ) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_kmalloc(arg1: ::std::os::raw::c_uint, arg2: gfp_t) -> *mut bio;
}
unsafe extern "C" {
    pub fn bio_endio(arg1: *mut bio);
}
unsafe extern "C" {
    pub fn bio_advance(arg1: *mut bio, arg2: ::std::os::raw::c_uint);
}
unsafe extern "C" {
    pub fn bio_reset(
        arg1: *mut bio,
        arg2: *mut block_device,
        arg3: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn bio_chain(arg1: *mut bio, arg2: *mut bio);
}
unsafe extern "C" {
    pub fn bio_copy_data_iter(
        dst: *mut bio,
        dst_iter: *mut bvec_iter,
        src: *mut bio,
        src_iter: *mut bvec_iter,
    );
}
unsafe extern "C" {
    pub fn bio_copy_data(dst: *mut bio, src: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_list_empty__extern"]
    pub fn bio_list_empty(bl: *const bio_list) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    #[link_name = "bio_list_init__extern"]
    pub fn bio_list_init(bl: *mut bio_list);
}
unsafe extern "C" {
    #[link_name = "bio_list_size__extern"]
    pub fn bio_list_size(bl: *const bio_list) -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    #[link_name = "bio_list_add__extern"]
    pub fn bio_list_add(bl: *mut bio_list, bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_list_add_head__extern"]
    pub fn bio_list_add_head(bl: *mut bio_list, bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_list_merge__extern"]
    pub fn bio_list_merge(bl: *mut bio_list, bl2: *mut bio_list);
}
unsafe extern "C" {
    #[link_name = "bio_list_merge_head__extern"]
    pub fn bio_list_merge_head(bl: *mut bio_list, bl2: *mut bio_list);
}
unsafe extern "C" {
    #[link_name = "bio_list_peek__extern"]
    pub fn bio_list_peek(bl: *mut bio_list) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_list_pop__extern"]
    pub fn bio_list_pop(bl: *mut bio_list) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_list_get__extern"]
    pub fn bio_list_get(bl: *mut bio_list) -> *mut bio;
}
unsafe extern "C" {
    #[link_name = "bio_inc_remaining__extern"]
    pub fn bio_inc_remaining(bio: *mut bio);
}
unsafe extern "C" {
    #[link_name = "bio_init__extern"]
    pub fn bio_init(
        bio: *mut bio,
        bdev: *mut block_device,
        table: *mut bio_vec,
        max_vecs: ::std::os::raw::c_ushort,
        opf: ::std::os::raw::c_uint,
    );
}
#[repr(C)]
pub struct completion {
    pub done: ::std::os::raw::c_uint,
    pub wait: wait_queue_head_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of completion"][::std::mem::size_of::<completion>() - 64usize];
    ["Alignment of completion"][::std::mem::align_of::<completion>() - 8usize];
    [
        "Offset of field: completion::done",
    ][::std::mem::offset_of!(completion, done) - 0usize];
    [
        "Offset of field: completion::wait",
    ][::std::mem::offset_of!(completion, wait) - 8usize];
};
impl Default for completion {
    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 task_struct {
    pub thread: pthread_t,
    pub thread_fn: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
    >,
    pub thread_data: *mut ::std::os::raw::c_void,
    pub prio: ::std::os::raw::c_int,
    pub usage: atomic_t,
    pub state: ::std::os::raw::c_int,
    pub kthread_flags: ::std::os::raw::c_ulong,
    pub exited: completion,
    pub flags: ::std::os::raw::c_uint,
    pub on_cpu: bool,
    pub comm: [::std::os::raw::c_char; 16usize],
    pub pid: pid_t,
    pub bio_list: *mut bio_list,
    pub signal: *mut task_struct_signal_struct,
    pub _signal: task_struct_signal_struct,
    pub se: task_struct__bindgen_ty_1,
}
#[repr(C)]
pub struct task_struct_signal_struct {
    pub exec_update_lock: rw_semaphore,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of task_struct_signal_struct",
    ][::std::mem::size_of::<task_struct_signal_struct>() - 56usize];
    [
        "Alignment of task_struct_signal_struct",
    ][::std::mem::align_of::<task_struct_signal_struct>() - 8usize];
    [
        "Offset of field: task_struct_signal_struct::exec_update_lock",
    ][::std::mem::offset_of!(task_struct_signal_struct, exec_update_lock) - 0usize];
};
impl Default for task_struct_signal_struct {
    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 task_struct__bindgen_ty_1 {
    pub sum_exec_runtime: u64_,
    pub exec_start: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of task_struct__bindgen_ty_1",
    ][::std::mem::size_of::<task_struct__bindgen_ty_1>() - 16usize];
    [
        "Alignment of task_struct__bindgen_ty_1",
    ][::std::mem::align_of::<task_struct__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: task_struct__bindgen_ty_1::sum_exec_runtime",
    ][::std::mem::offset_of!(task_struct__bindgen_ty_1, sum_exec_runtime) - 0usize];
    [
        "Offset of field: task_struct__bindgen_ty_1::exec_start",
    ][::std::mem::offset_of!(task_struct__bindgen_ty_1, exec_start) - 8usize];
};
impl Default for task_struct__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of task_struct"][::std::mem::size_of::<task_struct>() - 232usize];
    ["Alignment of task_struct"][::std::mem::align_of::<task_struct>() - 8usize];
    [
        "Offset of field: task_struct::thread",
    ][::std::mem::offset_of!(task_struct, thread) - 0usize];
    [
        "Offset of field: task_struct::thread_fn",
    ][::std::mem::offset_of!(task_struct, thread_fn) - 8usize];
    [
        "Offset of field: task_struct::thread_data",
    ][::std::mem::offset_of!(task_struct, thread_data) - 16usize];
    [
        "Offset of field: task_struct::prio",
    ][::std::mem::offset_of!(task_struct, prio) - 24usize];
    [
        "Offset of field: task_struct::usage",
    ][::std::mem::offset_of!(task_struct, usage) - 28usize];
    [
        "Offset of field: task_struct::state",
    ][::std::mem::offset_of!(task_struct, state) - 32usize];
    [
        "Offset of field: task_struct::kthread_flags",
    ][::std::mem::offset_of!(task_struct, kthread_flags) - 40usize];
    [
        "Offset of field: task_struct::exited",
    ][::std::mem::offset_of!(task_struct, exited) - 48usize];
    [
        "Offset of field: task_struct::flags",
    ][::std::mem::offset_of!(task_struct, flags) - 112usize];
    [
        "Offset of field: task_struct::on_cpu",
    ][::std::mem::offset_of!(task_struct, on_cpu) - 116usize];
    [
        "Offset of field: task_struct::comm",
    ][::std::mem::offset_of!(task_struct, comm) - 117usize];
    [
        "Offset of field: task_struct::pid",
    ][::std::mem::offset_of!(task_struct, pid) - 136usize];
    [
        "Offset of field: task_struct::bio_list",
    ][::std::mem::offset_of!(task_struct, bio_list) - 144usize];
    [
        "Offset of field: task_struct::signal",
    ][::std::mem::offset_of!(task_struct, signal) - 152usize];
    [
        "Offset of field: task_struct::_signal",
    ][::std::mem::offset_of!(task_struct, _signal) - 160usize];
    [
        "Offset of field: task_struct::se",
    ][::std::mem::offset_of!(task_struct, se) - 216usize];
};
impl Default for task_struct {
    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()
        }
    }
}
pub type percpu_ref_func_t = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut percpu_ref),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct percpu_ref {
    pub count: atomic_long_t,
    pub release: percpu_ref_func_t,
    pub confirm_switch: percpu_ref_func_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of percpu_ref"][::std::mem::size_of::<percpu_ref>() - 24usize];
    ["Alignment of percpu_ref"][::std::mem::align_of::<percpu_ref>() - 8usize];
    [
        "Offset of field: percpu_ref::count",
    ][::std::mem::offset_of!(percpu_ref, count) - 0usize];
    [
        "Offset of field: percpu_ref::release",
    ][::std::mem::offset_of!(percpu_ref, release) - 8usize];
    [
        "Offset of field: percpu_ref::confirm_switch",
    ][::std::mem::offset_of!(percpu_ref, confirm_switch) - 16usize];
};
#[repr(C)]
pub struct percpu_rw_semaphore {
    pub lock: pthread_mutex_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of percpu_rw_semaphore",
    ][::std::mem::size_of::<percpu_rw_semaphore>() - 40usize];
    [
        "Alignment of percpu_rw_semaphore",
    ][::std::mem::align_of::<percpu_rw_semaphore>() - 8usize];
    [
        "Offset of field: percpu_rw_semaphore::lock",
    ][::std::mem::offset_of!(percpu_rw_semaphore, lock) - 0usize];
};
impl Default for percpu_rw_semaphore {
    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()
        }
    }
}
/** typedef refcount_t - variant of atomic_t specialized for reference counts
 @refs: atomic_t counter field

 The counter saturates at REFCOUNT_SATURATED and will not move once
 there. This avoids wrapping the counter and causing 'spurious'
 use-after-free bugs.*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct refcount_struct {
    pub refs: atomic_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of refcount_struct"][::std::mem::size_of::<refcount_struct>() - 4usize];
    ["Alignment of refcount_struct"][::std::mem::align_of::<refcount_struct>() - 4usize];
    [
        "Offset of field: refcount_struct::refs",
    ][::std::mem::offset_of!(refcount_struct, refs) - 0usize];
};
/** typedef refcount_t - variant of atomic_t specialized for reference counts
 @refs: atomic_t counter field

 The counter saturates at REFCOUNT_SATURATED and will not move once
 there. This avoids wrapping the counter and causing 'spurious'
 use-after-free bugs.*/
pub type refcount_t = refcount_struct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cds_wfcq_node {
    pub next: *mut cds_wfcq_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of cds_wfcq_node"][::std::mem::size_of::<cds_wfcq_node>() - 8usize];
    ["Alignment of cds_wfcq_node"][::std::mem::align_of::<cds_wfcq_node>() - 8usize];
    [
        "Offset of field: cds_wfcq_node::next",
    ][::std::mem::offset_of!(cds_wfcq_node, next) - 0usize];
};
impl Default for cds_wfcq_node {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct rcu_head {
    pub next: cds_wfcq_node,
    pub func: ::std::option::Option<unsafe extern "C" fn(head: *mut rcu_head)>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rcu_head"][::std::mem::size_of::<rcu_head>() - 16usize];
    ["Alignment of rcu_head"][::std::mem::align_of::<rcu_head>() - 8usize];
    ["Offset of field: rcu_head::next"][::std::mem::offset_of!(rcu_head, next) - 0usize];
    ["Offset of field: rcu_head::func"][::std::mem::offset_of!(rcu_head, func) - 8usize];
};
impl Default for rcu_head {
    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 rhlist_head {
    pub rhead: rhash_head,
    pub next: *mut rhlist_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhlist_head"][::std::mem::size_of::<rhlist_head>() - 16usize];
    ["Alignment of rhlist_head"][::std::mem::align_of::<rhlist_head>() - 8usize];
    [
        "Offset of field: rhlist_head::rhead",
    ][::std::mem::offset_of!(rhlist_head, rhead) - 0usize];
    [
        "Offset of field: rhlist_head::next",
    ][::std::mem::offset_of!(rhlist_head, next) - 8usize];
};
impl Default for rhlist_head {
    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()
        }
    }
}
pub type rht_hashfn_t = ::std::option::Option<
    unsafe extern "C" fn(
        data: *const ::std::os::raw::c_void,
        len: u32_,
        seed: u32_,
    ) -> u32_,
>;
pub type rht_obj_hashfn_t = ::std::option::Option<
    unsafe extern "C" fn(
        data: *const ::std::os::raw::c_void,
        len: u32_,
        seed: u32_,
    ) -> u32_,
>;
pub type rht_obj_cmpfn_t = ::std::option::Option<
    unsafe extern "C" fn(
        arg: *mut rhashtable_compare_arg,
        obj: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
/** struct rhltable - Hash table with duplicate objects in a list
 @ht: Underlying rhtable*/
#[repr(C)]
pub struct rhltable {
    pub ht: rhashtable,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rhltable"][::std::mem::size_of::<rhltable>() - 184usize];
    ["Alignment of rhltable"][::std::mem::align_of::<rhltable>() - 8usize];
    ["Offset of field: rhltable::ht"][::std::mem::offset_of!(rhltable, ht) - 0usize];
};
impl Default for rhltable {
    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 semaphore {
    pub lock: raw_spinlock_t,
    pub count: ::std::os::raw::c_uint,
    pub wait_list: cds_list_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of semaphore"][::std::mem::size_of::<semaphore>() - 64usize];
    ["Alignment of semaphore"][::std::mem::align_of::<semaphore>() - 8usize];
    [
        "Offset of field: semaphore::lock",
    ][::std::mem::offset_of!(semaphore, lock) - 0usize];
    [
        "Offset of field: semaphore::count",
    ][::std::mem::offset_of!(semaphore, count) - 40usize];
    [
        "Offset of field: semaphore::wait_list",
    ][::std::mem::offset_of!(semaphore, wait_list) - 48usize];
};
impl Default for semaphore {
    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)]
#[derive(Debug, Default, Copy, Clone)]
pub struct seqcount {
    pub sequence: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of seqcount"][::std::mem::size_of::<seqcount>() - 4usize];
    ["Alignment of seqcount"][::std::mem::align_of::<seqcount>() - 4usize];
    [
        "Offset of field: seqcount::sequence",
    ][::std::mem::offset_of!(seqcount, sequence) - 0usize];
};
pub type seqcount_t = seqcount;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct utf8data {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct utf8data_table {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct unicode_map {
    pub version: ::std::os::raw::c_uint,
    pub ntab: [*const utf8data; 2usize],
    pub tables: *const utf8data_table,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of unicode_map"][::std::mem::size_of::<unicode_map>() - 32usize];
    ["Alignment of unicode_map"][::std::mem::align_of::<unicode_map>() - 8usize];
    [
        "Offset of field: unicode_map::version",
    ][::std::mem::offset_of!(unicode_map, version) - 0usize];
    [
        "Offset of field: unicode_map::ntab",
    ][::std::mem::offset_of!(unicode_map, ntab) - 8usize];
    [
        "Offset of field: unicode_map::tables",
    ][::std::mem::offset_of!(unicode_map, tables) - 24usize];
};
impl Default for unicode_map {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct llist_head {
    pub first: *mut llist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of llist_head"][::std::mem::size_of::<llist_head>() - 8usize];
    ["Alignment of llist_head"][::std::mem::align_of::<llist_head>() - 8usize];
    [
        "Offset of field: llist_head::first",
    ][::std::mem::offset_of!(llist_head, first) - 0usize];
};
impl Default for llist_head {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct llist_node {
    pub next: *mut llist_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of llist_node"][::std::mem::size_of::<llist_node>() - 8usize];
    ["Alignment of llist_node"][::std::mem::align_of::<llist_node>() - 8usize];
    [
        "Offset of field: llist_node::next",
    ][::std::mem::offset_of!(llist_node, next) - 0usize];
};
impl Default for llist_node {
    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 ratelimit_state {
    pub lock: raw_spinlock_t,
    pub interval: ::std::os::raw::c_int,
    pub burst: ::std::os::raw::c_int,
    pub rs_n_left: atomic_t,
    pub missed: atomic_t,
    pub flags: ::std::os::raw::c_uint,
    pub begin: ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ratelimit_state"][::std::mem::size_of::<ratelimit_state>() - 72usize];
    ["Alignment of ratelimit_state"][::std::mem::align_of::<ratelimit_state>() - 8usize];
    [
        "Offset of field: ratelimit_state::lock",
    ][::std::mem::offset_of!(ratelimit_state, lock) - 0usize];
    [
        "Offset of field: ratelimit_state::interval",
    ][::std::mem::offset_of!(ratelimit_state, interval) - 40usize];
    [
        "Offset of field: ratelimit_state::burst",
    ][::std::mem::offset_of!(ratelimit_state, burst) - 44usize];
    [
        "Offset of field: ratelimit_state::rs_n_left",
    ][::std::mem::offset_of!(ratelimit_state, rs_n_left) - 48usize];
    [
        "Offset of field: ratelimit_state::missed",
    ][::std::mem::offset_of!(ratelimit_state, missed) - 52usize];
    [
        "Offset of field: ratelimit_state::flags",
    ][::std::mem::offset_of!(ratelimit_state, flags) - 56usize];
    [
        "Offset of field: ratelimit_state::begin",
    ][::std::mem::offset_of!(ratelimit_state, begin) - 64usize];
};
impl Default for ratelimit_state {
    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()
        }
    }
}
pub type closure_fn = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut work_struct),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct closure_waitlist {
    pub list: llist_head,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of closure_waitlist"][::std::mem::size_of::<closure_waitlist>() - 8usize];
    [
        "Alignment of closure_waitlist",
    ][::std::mem::align_of::<closure_waitlist>() - 8usize];
    [
        "Offset of field: closure_waitlist::list",
    ][::std::mem::offset_of!(closure_waitlist, list) - 0usize];
};
impl Default for closure_waitlist {
    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 closure {
    pub __bindgen_anon_1: closure__bindgen_ty_1,
    pub parent: *mut closure,
    pub remaining: atomic_t,
}
#[repr(C)]
pub struct closure__bindgen_ty_1 {
    pub __bindgen_anon_1: __BindgenUnionField<closure__bindgen_ty_1__bindgen_ty_1>,
    pub work: __BindgenUnionField<work_struct>,
    pub bindgen_union_field: [u64; 4usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct closure__bindgen_ty_1__bindgen_ty_1 {
    pub wq: *mut workqueue_struct,
    pub sleeper: *mut task_struct,
    pub list: llist_node,
    pub fn_: closure_fn,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of closure__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<closure__bindgen_ty_1__bindgen_ty_1>() - 32usize];
    [
        "Alignment of closure__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<closure__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::wq",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, wq) - 0usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::sleeper",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, sleeper) - 8usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::list",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, list) - 16usize];
    [
        "Offset of field: closure__bindgen_ty_1__bindgen_ty_1::fn_",
    ][::std::mem::offset_of!(closure__bindgen_ty_1__bindgen_ty_1, fn_) - 24usize];
};
impl Default for closure__bindgen_ty_1__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of closure__bindgen_ty_1",
    ][::std::mem::size_of::<closure__bindgen_ty_1>() - 32usize];
    [
        "Alignment of closure__bindgen_ty_1",
    ][::std::mem::align_of::<closure__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: closure__bindgen_ty_1::work",
    ][::std::mem::offset_of!(closure__bindgen_ty_1, work) - 0usize];
};
impl Default for closure__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of closure"][::std::mem::size_of::<closure>() - 48usize];
    ["Alignment of closure"][::std::mem::align_of::<closure>() - 8usize];
    [
        "Offset of field: closure::parent",
    ][::std::mem::offset_of!(closure, parent) - 32usize];
    [
        "Offset of field: closure::remaining",
    ][::std::mem::offset_of!(closure, remaining) - 40usize];
};
impl Default for closure {
    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 mean_and_variance {
    pub n: s64,
    pub sum: s64,
    pub median: s64,
    pub mad: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mean_and_variance"][::std::mem::size_of::<mean_and_variance>() - 32usize];
    [
        "Alignment of mean_and_variance",
    ][::std::mem::align_of::<mean_and_variance>() - 8usize];
    [
        "Offset of field: mean_and_variance::n",
    ][::std::mem::offset_of!(mean_and_variance, n) - 0usize];
    [
        "Offset of field: mean_and_variance::sum",
    ][::std::mem::offset_of!(mean_and_variance, sum) - 8usize];
    [
        "Offset of field: mean_and_variance::median",
    ][::std::mem::offset_of!(mean_and_variance, median) - 16usize];
    [
        "Offset of field: mean_and_variance::mad",
    ][::std::mem::offset_of!(mean_and_variance, mad) - 24usize];
};
impl Default for mean_and_variance {
    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)]
#[derive(Debug, Default, Copy, Clone)]
pub struct local_lock {
    pub pad: ::std::os::raw::c_uchar,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of local_lock"][::std::mem::size_of::<local_lock>() - 1usize];
    ["Alignment of local_lock"][::std::mem::align_of::<local_lock>() - 1usize];
    [
        "Offset of field: local_lock::pad",
    ][::std::mem::offset_of!(local_lock, pad) - 0usize];
};
pub type local_lock_t = local_lock;
unsafe extern "C" {
    pub fn match_string(
        arg1: *const *const ::std::os::raw::c_char,
        arg2: usize,
        arg3: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
pub struct quantiles {
    pub entries: [quantiles_quantile_entry; 15usize],
}
#[repr(C)]
pub struct quantiles_quantile_entry {
    pub m: u64_,
    pub step: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of quantiles_quantile_entry",
    ][::std::mem::size_of::<quantiles_quantile_entry>() - 16usize];
    [
        "Alignment of quantiles_quantile_entry",
    ][::std::mem::align_of::<quantiles_quantile_entry>() - 8usize];
    [
        "Offset of field: quantiles_quantile_entry::m",
    ][::std::mem::offset_of!(quantiles_quantile_entry, m) - 0usize];
    [
        "Offset of field: quantiles_quantile_entry::step",
    ][::std::mem::offset_of!(quantiles_quantile_entry, step) - 8usize];
};
impl Default for quantiles_quantile_entry {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of quantiles"][::std::mem::size_of::<quantiles>() - 240usize];
    ["Alignment of quantiles"][::std::mem::align_of::<quantiles>() - 8usize];
    [
        "Offset of field: quantiles::entries",
    ][::std::mem::offset_of!(quantiles, entries) - 0usize];
};
impl Default for quantiles {
    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 time_stat_buffer {
    pub lock: local_lock_t,
    pub nr: ::std::os::raw::c_uint,
    pub entries: [time_stat_buffer_time_stat_buffer_entry; 31usize],
}
#[repr(C)]
pub struct time_stat_buffer_time_stat_buffer_entry {
    pub start: u64_,
    pub end: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of time_stat_buffer_time_stat_buffer_entry",
    ][::std::mem::size_of::<time_stat_buffer_time_stat_buffer_entry>() - 16usize];
    [
        "Alignment of time_stat_buffer_time_stat_buffer_entry",
    ][::std::mem::align_of::<time_stat_buffer_time_stat_buffer_entry>() - 8usize];
    [
        "Offset of field: time_stat_buffer_time_stat_buffer_entry::start",
    ][::std::mem::offset_of!(time_stat_buffer_time_stat_buffer_entry, start) - 0usize];
    [
        "Offset of field: time_stat_buffer_time_stat_buffer_entry::end",
    ][::std::mem::offset_of!(time_stat_buffer_time_stat_buffer_entry, end) - 8usize];
};
impl Default for time_stat_buffer_time_stat_buffer_entry {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of time_stat_buffer"][::std::mem::size_of::<time_stat_buffer>() - 504usize];
    [
        "Alignment of time_stat_buffer",
    ][::std::mem::align_of::<time_stat_buffer>() - 8usize];
    [
        "Offset of field: time_stat_buffer::lock",
    ][::std::mem::offset_of!(time_stat_buffer, lock) - 0usize];
    [
        "Offset of field: time_stat_buffer::nr",
    ][::std::mem::offset_of!(time_stat_buffer, nr) - 4usize];
    [
        "Offset of field: time_stat_buffer::entries",
    ][::std::mem::offset_of!(time_stat_buffer, entries) - 8usize];
};
impl Default for time_stat_buffer {
    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 bch2_time_stats {
    pub lock: spinlock_t,
    pub have_quantiles: bool,
    pub buffer: *mut time_stat_buffer,
    pub min_duration: u64_,
    pub max_duration: u64_,
    pub total_duration: u64_,
    pub max_freq: u64_,
    pub min_freq: u64_,
    pub last_event: u64_,
    pub last_event_start: u64_,
    pub start_time: u64_,
    pub duration_stats: mean_and_variance,
    pub freq_stats: mean_and_variance,
    pub duration_stats_weighted: mean_and_variance,
    pub freq_stats_weighted: mean_and_variance,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch2_time_stats"][::std::mem::size_of::<bch2_time_stats>() - 248usize];
    ["Alignment of bch2_time_stats"][::std::mem::align_of::<bch2_time_stats>() - 8usize];
    [
        "Offset of field: bch2_time_stats::lock",
    ][::std::mem::offset_of!(bch2_time_stats, lock) - 0usize];
    [
        "Offset of field: bch2_time_stats::have_quantiles",
    ][::std::mem::offset_of!(bch2_time_stats, have_quantiles) - 40usize];
    [
        "Offset of field: bch2_time_stats::buffer",
    ][::std::mem::offset_of!(bch2_time_stats, buffer) - 48usize];
    [
        "Offset of field: bch2_time_stats::min_duration",
    ][::std::mem::offset_of!(bch2_time_stats, min_duration) - 56usize];
    [
        "Offset of field: bch2_time_stats::max_duration",
    ][::std::mem::offset_of!(bch2_time_stats, max_duration) - 64usize];
    [
        "Offset of field: bch2_time_stats::total_duration",
    ][::std::mem::offset_of!(bch2_time_stats, total_duration) - 72usize];
    [
        "Offset of field: bch2_time_stats::max_freq",
    ][::std::mem::offset_of!(bch2_time_stats, max_freq) - 80usize];
    [
        "Offset of field: bch2_time_stats::min_freq",
    ][::std::mem::offset_of!(bch2_time_stats, min_freq) - 88usize];
    [
        "Offset of field: bch2_time_stats::last_event",
    ][::std::mem::offset_of!(bch2_time_stats, last_event) - 96usize];
    [
        "Offset of field: bch2_time_stats::last_event_start",
    ][::std::mem::offset_of!(bch2_time_stats, last_event_start) - 104usize];
    [
        "Offset of field: bch2_time_stats::start_time",
    ][::std::mem::offset_of!(bch2_time_stats, start_time) - 112usize];
    [
        "Offset of field: bch2_time_stats::duration_stats",
    ][::std::mem::offset_of!(bch2_time_stats, duration_stats) - 120usize];
    [
        "Offset of field: bch2_time_stats::freq_stats",
    ][::std::mem::offset_of!(bch2_time_stats, freq_stats) - 152usize];
    [
        "Offset of field: bch2_time_stats::duration_stats_weighted",
    ][::std::mem::offset_of!(bch2_time_stats, duration_stats_weighted) - 184usize];
    [
        "Offset of field: bch2_time_stats::freq_stats_weighted",
    ][::std::mem::offset_of!(bch2_time_stats, freq_stats_weighted) - 216usize];
};
impl Default for bch2_time_stats {
    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 bch2_time_stats_quantiles {
    pub stats: bch2_time_stats,
    pub quantiles: quantiles,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch2_time_stats_quantiles",
    ][::std::mem::size_of::<bch2_time_stats_quantiles>() - 488usize];
    [
        "Alignment of bch2_time_stats_quantiles",
    ][::std::mem::align_of::<bch2_time_stats_quantiles>() - 8usize];
    [
        "Offset of field: bch2_time_stats_quantiles::stats",
    ][::std::mem::offset_of!(bch2_time_stats_quantiles, stats) - 0usize];
    [
        "Offset of field: bch2_time_stats_quantiles::quantiles",
    ][::std::mem::offset_of!(bch2_time_stats_quantiles, quantiles) - 248usize];
};
impl Default for bch2_time_stats_quantiles {
    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(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum printbuf_si {
    PRINTBUF_UNITS_2 = 0,
    PRINTBUF_UNITS_10 = 1,
}
#[repr(C, packed(4))]
pub struct bversion {
    pub lo: __u64,
    pub hi: __u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bversion"][::std::mem::size_of::<bversion>() - 12usize];
    ["Alignment of bversion"][::std::mem::align_of::<bversion>() - 4usize];
    ["Offset of field: bversion::lo"][::std::mem::offset_of!(bversion, lo) - 0usize];
    ["Offset of field: bversion::hi"][::std::mem::offset_of!(bversion, hi) - 8usize];
};
impl Default for bversion {
    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 recovery_pass_entry {
    pub last_run: __le64,
    pub last_runtime: __le32,
    pub flags: __le32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of recovery_pass_entry",
    ][::std::mem::size_of::<recovery_pass_entry>() - 16usize];
    [
        "Alignment of recovery_pass_entry",
    ][::std::mem::align_of::<recovery_pass_entry>() - 8usize];
    [
        "Offset of field: recovery_pass_entry::last_run",
    ][::std::mem::offset_of!(recovery_pass_entry, last_run) - 0usize];
    [
        "Offset of field: recovery_pass_entry::last_runtime",
    ][::std::mem::offset_of!(recovery_pass_entry, last_runtime) - 8usize];
    [
        "Offset of field: recovery_pass_entry::flags",
    ][::std::mem::offset_of!(recovery_pass_entry, flags) - 12usize];
};
impl Default for recovery_pass_entry {
    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, packed(8))]
pub struct bset {
    pub seq: __le64,
    pub journal_seq: __le64,
    pub flags: __le32,
    pub version: __le16,
    pub u64s: __le16,
    pub start: __IncompleteArrayField<bkey_packed>,
    pub _data: __IncompleteArrayField<__u64>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bset"][::std::mem::size_of::<bset>() - 24usize];
    ["Alignment of bset"][::std::mem::align_of::<bset>() - 8usize];
    ["Offset of field: bset::seq"][::std::mem::offset_of!(bset, seq) - 0usize];
    [
        "Offset of field: bset::journal_seq",
    ][::std::mem::offset_of!(bset, journal_seq) - 8usize];
    ["Offset of field: bset::flags"][::std::mem::offset_of!(bset, flags) - 16usize];
    ["Offset of field: bset::version"][::std::mem::offset_of!(bset, version) - 20usize];
    ["Offset of field: bset::u64s"][::std::mem::offset_of!(bset, u64s) - 22usize];
    ["Offset of field: bset::start"][::std::mem::offset_of!(bset, start) - 24usize];
    ["Offset of field: bset::_data"][::std::mem::offset_of!(bset, _data) - 24usize];
};
impl Default for bset {
    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()
        }
    }
}
pub type io_timer_fn = ::std::option::Option<unsafe extern "C" fn(arg1: *mut io_timer)>;
#[repr(C)]
pub struct io_timer {
    pub fn_: io_timer_fn,
    pub fn2: *mut ::std::os::raw::c_void,
    pub expire: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_timer"][::std::mem::size_of::<io_timer>() - 24usize];
    ["Alignment of io_timer"][::std::mem::align_of::<io_timer>() - 8usize];
    ["Offset of field: io_timer::fn_"][::std::mem::offset_of!(io_timer, fn_) - 0usize];
    ["Offset of field: io_timer::fn2"][::std::mem::offset_of!(io_timer, fn2) - 8usize];
    [
        "Offset of field: io_timer::expire",
    ][::std::mem::offset_of!(io_timer, expire) - 16usize];
};
impl Default for io_timer {
    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)]
#[derive(Debug)]
pub struct io_timer_heap {
    pub nr: usize,
    pub size: usize,
    pub data: *mut *mut io_timer,
    pub preallocated: __IncompleteArrayField<*mut io_timer>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_timer_heap"][::std::mem::size_of::<io_timer_heap>() - 24usize];
    ["Alignment of io_timer_heap"][::std::mem::align_of::<io_timer_heap>() - 8usize];
    [
        "Offset of field: io_timer_heap::nr",
    ][::std::mem::offset_of!(io_timer_heap, nr) - 0usize];
    [
        "Offset of field: io_timer_heap::size",
    ][::std::mem::offset_of!(io_timer_heap, size) - 8usize];
    [
        "Offset of field: io_timer_heap::data",
    ][::std::mem::offset_of!(io_timer_heap, data) - 16usize];
    [
        "Offset of field: io_timer_heap::preallocated",
    ][::std::mem::offset_of!(io_timer_heap, preallocated) - 24usize];
};
impl Default for io_timer_heap {
    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 io_clock {
    pub now: atomic64_t,
    pub pcpu_buf: *mut u16_,
    pub max_slop: ::std::os::raw::c_uint,
    pub timer_lock: spinlock_t,
    pub timers: io_timer_heap,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_clock"][::std::mem::size_of::<io_clock>() - 88usize];
    ["Alignment of io_clock"][::std::mem::align_of::<io_clock>() - 8usize];
    ["Offset of field: io_clock::now"][::std::mem::offset_of!(io_clock, now) - 0usize];
    [
        "Offset of field: io_clock::pcpu_buf",
    ][::std::mem::offset_of!(io_clock, pcpu_buf) - 8usize];
    [
        "Offset of field: io_clock::max_slop",
    ][::std::mem::offset_of!(io_clock, max_slop) - 16usize];
    [
        "Offset of field: io_clock::timer_lock",
    ][::std::mem::offset_of!(io_clock, timer_lock) - 24usize];
    [
        "Offset of field: io_clock::timers",
    ][::std::mem::offset_of!(io_clock, timers) - 64usize];
};
impl Default for io_clock {
    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 enumerated_ref {
    pub ref_: percpu_ref,
    pub stop_fn: ::std::option::Option<unsafe extern "C" fn(arg1: *mut enumerated_ref)>,
    pub stop_complete: completion,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of enumerated_ref"][::std::mem::size_of::<enumerated_ref>() - 96usize];
    ["Alignment of enumerated_ref"][::std::mem::align_of::<enumerated_ref>() - 8usize];
    [
        "Offset of field: enumerated_ref::ref_",
    ][::std::mem::offset_of!(enumerated_ref, ref_) - 0usize];
    [
        "Offset of field: enumerated_ref::stop_fn",
    ][::std::mem::offset_of!(enumerated_ref, stop_fn) - 24usize];
    [
        "Offset of field: enumerated_ref::stop_complete",
    ][::std::mem::offset_of!(enumerated_ref, stop_complete) - 32usize];
};
impl Default for enumerated_ref {
    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 ida {
    pub lock: mutex,
    pub depth: ::std::os::raw::c_uint,
    pub nodes: *mut ::std::os::raw::c_ulong,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ida"][::std::mem::size_of::<ida>() - 56usize];
    ["Alignment of ida"][::std::mem::align_of::<ida>() - 8usize];
    ["Offset of field: ida::lock"][::std::mem::offset_of!(ida, lock) - 0usize];
    ["Offset of field: ida::depth"][::std::mem::offset_of!(ida, depth) - 40usize];
    ["Offset of field: ida::nodes"][::std::mem::offset_of!(ida, nodes) - 48usize];
};
impl Default for ida {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct fast_list_pcpu {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct fast_list {
    pub items: fast_list__bindgen_ty_1,
    pub slots_allocated: ida,
    pub buffer: *mut fast_list_pcpu,
}
#[repr(C)]
pub struct fast_list__bindgen_ty_1 {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of fast_list__bindgen_ty_1",
    ][::std::mem::size_of::<fast_list__bindgen_ty_1>() - 8usize];
    [
        "Alignment of fast_list__bindgen_ty_1",
    ][::std::mem::align_of::<fast_list__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: fast_list__bindgen_ty_1::tree",
    ][::std::mem::offset_of!(fast_list__bindgen_ty_1, tree) - 0usize];
    [
        "Offset of field: fast_list__bindgen_ty_1::type_",
    ][::std::mem::offset_of!(fast_list__bindgen_ty_1, type_) - 8usize];
};
impl Default for fast_list__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fast_list"][::std::mem::size_of::<fast_list>() - 72usize];
    ["Alignment of fast_list"][::std::mem::align_of::<fast_list>() - 8usize];
    [
        "Offset of field: fast_list::items",
    ][::std::mem::offset_of!(fast_list, items) - 0usize];
    [
        "Offset of field: fast_list::slots_allocated",
    ][::std::mem::offset_of!(fast_list, slots_allocated) - 8usize];
    [
        "Offset of field: fast_list::buffer",
    ][::std::mem::offset_of!(fast_list, buffer) - 64usize];
};
impl Default for fast_list {
    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 mutex_noio {
    pub lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of mutex_noio"][::std::mem::size_of::<mutex_noio>() - 40usize];
    ["Alignment of mutex_noio"][::std::mem::align_of::<mutex_noio>() - 8usize];
    [
        "Offset of field: mutex_noio::lock",
    ][::std::mem::offset_of!(mutex_noio, lock) - 0usize];
};
impl Default for mutex_noio {
    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 percpu_rwsem_noio {
    pub lock: percpu_rw_semaphore,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of percpu_rwsem_noio"][::std::mem::size_of::<percpu_rwsem_noio>() - 40usize];
    [
        "Alignment of percpu_rwsem_noio",
    ][::std::mem::align_of::<percpu_rwsem_noio>() - 8usize];
    [
        "Offset of field: percpu_rwsem_noio::lock",
    ][::std::mem::offset_of!(percpu_rwsem_noio, lock) - 0usize];
};
impl Default for percpu_rwsem_noio {
    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()
        }
    }
}
unsafe extern "C" {
    pub fn rust_memalloc_noio_save() -> ::std::os::raw::c_uint;
}
unsafe extern "C" {
    pub fn rust_memalloc_flags_restore(flags: ::std::os::raw::c_uint);
}
#[repr(C)]
pub struct seqmutex {
    pub lock: mutex,
    pub seq: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of seqmutex"][::std::mem::size_of::<seqmutex>() - 48usize];
    ["Alignment of seqmutex"][::std::mem::align_of::<seqmutex>() - 8usize];
    ["Offset of field: seqmutex::lock"][::std::mem::offset_of!(seqmutex, lock) - 0usize];
    ["Offset of field: seqmutex::seq"][::std::mem::offset_of!(seqmutex, seq) - 40usize];
};
impl Default for seqmutex {
    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 stdio_buf {
    pub lock: spinlock_t,
    pub wait: wait_queue_head_t,
    pub buf: darray_char,
    pub waiting_for_line: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of stdio_buf"][::std::mem::size_of::<stdio_buf>() - 128usize];
    ["Alignment of stdio_buf"][::std::mem::align_of::<stdio_buf>() - 8usize];
    [
        "Offset of field: stdio_buf::lock",
    ][::std::mem::offset_of!(stdio_buf, lock) - 0usize];
    [
        "Offset of field: stdio_buf::wait",
    ][::std::mem::offset_of!(stdio_buf, wait) - 40usize];
    [
        "Offset of field: stdio_buf::buf",
    ][::std::mem::offset_of!(stdio_buf, buf) - 96usize];
    [
        "Offset of field: stdio_buf::waiting_for_line",
    ][::std::mem::offset_of!(stdio_buf, waiting_for_line) - 120usize];
};
impl Default for stdio_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()
        }
    }
}
#[repr(C)]
pub struct stdio_redirect {
    pub input: stdio_buf,
    pub output: stdio_buf,
    pub done: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of stdio_redirect"][::std::mem::size_of::<stdio_redirect>() - 264usize];
    ["Alignment of stdio_redirect"][::std::mem::align_of::<stdio_redirect>() - 8usize];
    [
        "Offset of field: stdio_redirect::input",
    ][::std::mem::offset_of!(stdio_redirect, input) - 0usize];
    [
        "Offset of field: stdio_redirect::output",
    ][::std::mem::offset_of!(stdio_redirect, output) - 128usize];
    [
        "Offset of field: stdio_redirect::done",
    ][::std::mem::offset_of!(stdio_redirect, done) - 256usize];
};
impl Default for stdio_redirect {
    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 bucket_gens {
    pub rcu: rcu_head,
    pub first_bucket: u16_,
    pub nbuckets: usize,
    pub nbuckets_minus_first: usize,
    pub b: __IncompleteArrayField<u8_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bucket_gens"][::std::mem::size_of::<bucket_gens>() - 40usize];
    ["Alignment of bucket_gens"][::std::mem::align_of::<bucket_gens>() - 8usize];
    [
        "Offset of field: bucket_gens::rcu",
    ][::std::mem::offset_of!(bucket_gens, rcu) - 0usize];
    [
        "Offset of field: bucket_gens::first_bucket",
    ][::std::mem::offset_of!(bucket_gens, first_bucket) - 16usize];
    [
        "Offset of field: bucket_gens::nbuckets",
    ][::std::mem::offset_of!(bucket_gens, nbuckets) - 24usize];
    [
        "Offset of field: bucket_gens::nbuckets_minus_first",
    ][::std::mem::offset_of!(bucket_gens, nbuckets_minus_first) - 32usize];
    [
        "Offset of field: bucket_gens::b",
    ][::std::mem::offset_of!(bucket_gens, b) - 40usize];
};
impl Default for bucket_gens {
    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 disk_reservation {
    pub sectors: u64_,
    pub generation: u32_,
    pub nr_replicas: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of disk_reservation"][::std::mem::size_of::<disk_reservation>() - 16usize];
    [
        "Alignment of disk_reservation",
    ][::std::mem::align_of::<disk_reservation>() - 8usize];
    [
        "Offset of field: disk_reservation::sectors",
    ][::std::mem::offset_of!(disk_reservation, sectors) - 0usize];
    [
        "Offset of field: disk_reservation::generation",
    ][::std::mem::offset_of!(disk_reservation, generation) - 8usize];
    [
        "Offset of field: disk_reservation::nr_replicas",
    ][::std::mem::offset_of!(disk_reservation, nr_replicas) - 12usize];
};
impl Default for disk_reservation {
    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()
        }
    }
}
pub type open_bucket_idx_t = u16;
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct open_bucket {
    pub _bindgen_opaque_blob: [u64; 9usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of open_bucket"][::std::mem::size_of::<open_bucket>() - 72usize];
    ["Alignment of open_bucket"][::std::mem::align_of::<open_bucket>() - 8usize];
};
#[repr(C)]
#[repr(align(2))]
#[derive(Debug, Default, Copy, Clone)]
pub struct open_buckets {
    pub _bindgen_opaque_blob: [u16; 17usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of open_buckets"][::std::mem::size_of::<open_buckets>() - 34usize];
    ["Alignment of open_buckets"][::std::mem::align_of::<open_buckets>() - 2usize];
};
#[repr(C)]
pub struct dev_stripe_state {
    pub next_alloc: [u64_; 256usize],
    pub cached_devs: bch_devs_mask,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dev_stripe_state"][::std::mem::size_of::<dev_stripe_state>() - 2080usize];
    [
        "Alignment of dev_stripe_state",
    ][::std::mem::align_of::<dev_stripe_state>() - 8usize];
    [
        "Offset of field: dev_stripe_state::next_alloc",
    ][::std::mem::offset_of!(dev_stripe_state, next_alloc) - 0usize];
    [
        "Offset of field: dev_stripe_state::cached_devs",
    ][::std::mem::offset_of!(dev_stripe_state, cached_devs) - 2048usize];
};
impl Default for dev_stripe_state {
    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(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum write_point_state {
    WRITE_POINT_stopped = 0,
    WRITE_POINT_waiting_io = 1,
    WRITE_POINT_waiting_work = 2,
    WRITE_POINT_runnable = 3,
    WRITE_POINT_running = 4,
    WRITE_POINT_STATE_NR = 5,
}
#[repr(C)]
#[repr(align(64))]
pub struct write_point {
    pub __bindgen_anon_1: write_point__bindgen_ty_1,
    pub __bindgen_anon_2: write_point__bindgen_ty_2,
}
#[repr(C)]
#[repr(align(64))]
pub struct write_point__bindgen_ty_1 {
    pub node: cds_hlist_node,
    pub lock: mutex,
    pub last_used: u64_,
    pub write_point: ::std::os::raw::c_ulong,
    pub data_type: bch_data_type,
    pub sectors_free: ::std::os::raw::c_uint,
    pub prev_sectors_free: ::std::os::raw::c_uint,
    pub ptrs: open_buckets,
    pub stripe: dev_stripe_state,
    pub sectors_allocated: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of write_point__bindgen_ty_1",
    ][::std::mem::size_of::<write_point__bindgen_ty_1>() - 2240usize];
    [
        "Alignment of write_point__bindgen_ty_1",
    ][::std::mem::align_of::<write_point__bindgen_ty_1>() - 64usize];
    [
        "Offset of field: write_point__bindgen_ty_1::node",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, node) - 0usize];
    [
        "Offset of field: write_point__bindgen_ty_1::lock",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, lock) - 16usize];
    [
        "Offset of field: write_point__bindgen_ty_1::last_used",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, last_used) - 56usize];
    [
        "Offset of field: write_point__bindgen_ty_1::write_point",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, write_point) - 64usize];
    [
        "Offset of field: write_point__bindgen_ty_1::data_type",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, data_type) - 72usize];
    [
        "Offset of field: write_point__bindgen_ty_1::sectors_free",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, sectors_free) - 76usize];
    [
        "Offset of field: write_point__bindgen_ty_1::prev_sectors_free",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, prev_sectors_free) - 80usize];
    [
        "Offset of field: write_point__bindgen_ty_1::ptrs",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, ptrs) - 84usize];
    [
        "Offset of field: write_point__bindgen_ty_1::stripe",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, stripe) - 120usize];
    [
        "Offset of field: write_point__bindgen_ty_1::sectors_allocated",
    ][::std::mem::offset_of!(write_point__bindgen_ty_1, sectors_allocated) - 2200usize];
};
impl Default for write_point__bindgen_ty_1 {
    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)]
#[repr(align(64))]
pub struct write_point__bindgen_ty_2 {
    pub index_update_work: work_struct,
    pub writes: cds_list_head,
    pub writes_lock: spinlock_t,
    pub state: write_point_state,
    pub last_state_change: u64_,
    pub time: [u64_; 5usize],
    pub last_runtime: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of write_point__bindgen_ty_2",
    ][::std::mem::size_of::<write_point__bindgen_ty_2>() - 192usize];
    [
        "Alignment of write_point__bindgen_ty_2",
    ][::std::mem::align_of::<write_point__bindgen_ty_2>() - 64usize];
    [
        "Offset of field: write_point__bindgen_ty_2::index_update_work",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, index_update_work) - 0usize];
    [
        "Offset of field: write_point__bindgen_ty_2::writes",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, writes) - 32usize];
    [
        "Offset of field: write_point__bindgen_ty_2::writes_lock",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, writes_lock) - 48usize];
    [
        "Offset of field: write_point__bindgen_ty_2::state",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, state) - 88usize];
    [
        "Offset of field: write_point__bindgen_ty_2::last_state_change",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, last_state_change) - 96usize];
    [
        "Offset of field: write_point__bindgen_ty_2::time",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, time) - 104usize];
    [
        "Offset of field: write_point__bindgen_ty_2::last_runtime",
    ][::std::mem::offset_of!(write_point__bindgen_ty_2, last_runtime) - 144usize];
};
impl Default for write_point__bindgen_ty_2 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of write_point"][::std::mem::size_of::<write_point>() - 2432usize];
    ["Alignment of write_point"][::std::mem::align_of::<write_point>() - 64usize];
};
impl Default for write_point {
    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 discard_in_flight {
    pub dev_bucket: u64_,
    pub ca: *mut bch_dev,
    pub complete: bool,
    pub marking_free: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of discard_in_flight"][::std::mem::size_of::<discard_in_flight>() - 24usize];
    [
        "Alignment of discard_in_flight",
    ][::std::mem::align_of::<discard_in_flight>() - 8usize];
    [
        "Offset of field: discard_in_flight::dev_bucket",
    ][::std::mem::offset_of!(discard_in_flight, dev_bucket) - 0usize];
    [
        "Offset of field: discard_in_flight::ca",
    ][::std::mem::offset_of!(discard_in_flight, ca) - 8usize];
    [
        "Offset of field: discard_in_flight::complete",
    ][::std::mem::offset_of!(discard_in_flight, complete) - 16usize];
    [
        "Offset of field: discard_in_flight::marking_free",
    ][::std::mem::offset_of!(discard_in_flight, marking_free) - 17usize];
};
impl Default for discard_in_flight {
    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 discard_release {
    pub buffer: u64_,
    pub pending_need_flush: u64_,
    pub pending_need_rewind_advance: u64_,
    pub pending_total: u64_,
    pub free: u64_,
    pub reserve: u64_,
    pub buffer_clamped: u64_,
    pub release: s64,
    pub new_rewind_seq: u64_,
    pub flush_journal: bool,
    pub flush_wb: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of discard_release"][::std::mem::size_of::<discard_release>() - 80usize];
    ["Alignment of discard_release"][::std::mem::align_of::<discard_release>() - 8usize];
    [
        "Offset of field: discard_release::buffer",
    ][::std::mem::offset_of!(discard_release, buffer) - 0usize];
    [
        "Offset of field: discard_release::pending_need_flush",
    ][::std::mem::offset_of!(discard_release, pending_need_flush) - 8usize];
    [
        "Offset of field: discard_release::pending_need_rewind_advance",
    ][::std::mem::offset_of!(discard_release, pending_need_rewind_advance) - 16usize];
    [
        "Offset of field: discard_release::pending_total",
    ][::std::mem::offset_of!(discard_release, pending_total) - 24usize];
    [
        "Offset of field: discard_release::free",
    ][::std::mem::offset_of!(discard_release, free) - 32usize];
    [
        "Offset of field: discard_release::reserve",
    ][::std::mem::offset_of!(discard_release, reserve) - 40usize];
    [
        "Offset of field: discard_release::buffer_clamped",
    ][::std::mem::offset_of!(discard_release, buffer_clamped) - 48usize];
    [
        "Offset of field: discard_release::release",
    ][::std::mem::offset_of!(discard_release, release) - 56usize];
    [
        "Offset of field: discard_release::new_rewind_seq",
    ][::std::mem::offset_of!(discard_release, new_rewind_seq) - 64usize];
    [
        "Offset of field: discard_release::flush_journal",
    ][::std::mem::offset_of!(discard_release, flush_journal) - 72usize];
    [
        "Offset of field: discard_release::flush_wb",
    ][::std::mem::offset_of!(discard_release, flush_wb) - 73usize];
};
impl Default for discard_release {
    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 discard_state {
    pub seen: u64_,
    pub not_rw: u64_,
    pub eexist: u64_,
    pub eagain: u64_,
    pub open: u64_,
    pub need_journal_commit: u64_,
    pub need_rewind_advance: u64_,
    pub bad_data_type: u64_,
    pub discarded: u64_,
    pub committed: u64_,
    pub pos: bpos,
    pub r: discard_release,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of discard_state"][::std::mem::size_of::<discard_state>() - 184usize];
    ["Alignment of discard_state"][::std::mem::align_of::<discard_state>() - 8usize];
    [
        "Offset of field: discard_state::seen",
    ][::std::mem::offset_of!(discard_state, seen) - 0usize];
    [
        "Offset of field: discard_state::not_rw",
    ][::std::mem::offset_of!(discard_state, not_rw) - 8usize];
    [
        "Offset of field: discard_state::eexist",
    ][::std::mem::offset_of!(discard_state, eexist) - 16usize];
    [
        "Offset of field: discard_state::eagain",
    ][::std::mem::offset_of!(discard_state, eagain) - 24usize];
    [
        "Offset of field: discard_state::open",
    ][::std::mem::offset_of!(discard_state, open) - 32usize];
    [
        "Offset of field: discard_state::need_journal_commit",
    ][::std::mem::offset_of!(discard_state, need_journal_commit) - 40usize];
    [
        "Offset of field: discard_state::need_rewind_advance",
    ][::std::mem::offset_of!(discard_state, need_rewind_advance) - 48usize];
    [
        "Offset of field: discard_state::bad_data_type",
    ][::std::mem::offset_of!(discard_state, bad_data_type) - 56usize];
    [
        "Offset of field: discard_state::discarded",
    ][::std::mem::offset_of!(discard_state, discarded) - 64usize];
    [
        "Offset of field: discard_state::committed",
    ][::std::mem::offset_of!(discard_state, committed) - 72usize];
    [
        "Offset of field: discard_state::pos",
    ][::std::mem::offset_of!(discard_state, pos) - 80usize];
    [
        "Offset of field: discard_state::r",
    ][::std::mem::offset_of!(discard_state, r) - 104usize];
};
impl Default for discard_state {
    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(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum gc_phase {
    GC_PHASE_not_running = 0,
    GC_PHASE_start = 1,
    GC_PHASE_sb = 2,
    GC_PHASE_btree = 3,
}
#[repr(C)]
pub struct gc_pos {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub level: u16_,
    pub pos: bpos,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of gc_pos"][::std::mem::size_of::<gc_pos>() - 24usize];
    ["Alignment of gc_pos"][::std::mem::align_of::<gc_pos>() - 4usize];
    ["Offset of field: gc_pos::level"][::std::mem::offset_of!(gc_pos, level) - 2usize];
    ["Offset of field: gc_pos::pos"][::std::mem::offset_of!(gc_pos, pos) - 4usize];
};
impl Default for gc_pos {
    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 gc_pos {
    #[inline]
    pub fn phase(&self) -> gc_phase {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_phase(&mut self, val: gc_phase) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn phase_raw(this: *const Self) -> gc_phase {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_phase_raw(this: *mut Self, val: gc_phase) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn btree(&self) -> btree_id {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_btree(&mut self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn btree_raw(this: *const Self) -> btree_id {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 2usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 8usize, 8u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_btree_raw(this: *mut Self, val: btree_id) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 2usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        phase: gc_phase,
        btree: btree_id,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                8u8,
                {
                    let phase: u32 = unsafe { ::std::mem::transmute(phase) };
                    phase as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                8usize,
                8u8,
                {
                    let btree: u32 = unsafe { ::std::mem::transmute(btree) };
                    btree as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
pub struct reflink_gc {
    pub offset: u64_,
    pub size: u32_,
    pub refcount: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of reflink_gc"][::std::mem::size_of::<reflink_gc>() - 16usize];
    ["Alignment of reflink_gc"][::std::mem::align_of::<reflink_gc>() - 8usize];
    [
        "Offset of field: reflink_gc::offset",
    ][::std::mem::offset_of!(reflink_gc, offset) - 0usize];
    [
        "Offset of field: reflink_gc::size",
    ][::std::mem::offset_of!(reflink_gc, size) - 8usize];
    [
        "Offset of field: reflink_gc::refcount",
    ][::std::mem::offset_of!(reflink_gc, refcount) - 12usize];
};
impl Default for reflink_gc {
    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 reflink_gc_table {
    pub tree: __genradix,
    pub type_: __IncompleteArrayField<reflink_gc>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of reflink_gc_table"][::std::mem::size_of::<reflink_gc_table>() - 8usize];
    [
        "Alignment of reflink_gc_table",
    ][::std::mem::align_of::<reflink_gc_table>() - 8usize];
    [
        "Offset of field: reflink_gc_table::tree",
    ][::std::mem::offset_of!(reflink_gc_table, tree) - 0usize];
    [
        "Offset of field: reflink_gc_table::type_",
    ][::std::mem::offset_of!(reflink_gc_table, type_) - 8usize];
};
impl Default for reflink_gc_table {
    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()
        }
    }
}
pub type rcu_pending_process_fn = ::std::option::Option<
    unsafe extern "C" fn(arg1: *mut rcu_pending, arg2: *mut rcu_head),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rcu_pending_pcpu {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct rcu_pending {
    pub p: *mut rcu_pending_pcpu,
    pub srcu: *mut srcu_struct,
    pub process: rcu_pending_process_fn,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of rcu_pending"][::std::mem::size_of::<rcu_pending>() - 24usize];
    ["Alignment of rcu_pending"][::std::mem::align_of::<rcu_pending>() - 8usize];
    ["Offset of field: rcu_pending::p"][::std::mem::offset_of!(rcu_pending, p) - 0usize];
    [
        "Offset of field: rcu_pending::srcu",
    ][::std::mem::offset_of!(rcu_pending, srcu) - 8usize];
    [
        "Offset of field: rcu_pending::process",
    ][::std::mem::offset_of!(rcu_pending, process) - 16usize];
};
impl Default for rcu_pending {
    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 found_btree_node {
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub btree_id: u8_,
    pub level: u8_,
    pub sectors_written: ::std::os::raw::c_uint,
    pub seq: u32_,
    pub journal_seq: u64_,
    pub cookie: u64_,
    pub min_key: bpos,
    pub max_key: bpos,
    pub nr_ptrs: ::std::os::raw::c_uint,
    pub ptrs: [bch_extent_ptr; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of found_btree_node"][::std::mem::size_of::<found_btree_node>() - 112usize];
    [
        "Alignment of found_btree_node",
    ][::std::mem::align_of::<found_btree_node>() - 8usize];
    [
        "Offset of field: found_btree_node::btree_id",
    ][::std::mem::offset_of!(found_btree_node, btree_id) - 1usize];
    [
        "Offset of field: found_btree_node::level",
    ][::std::mem::offset_of!(found_btree_node, level) - 2usize];
    [
        "Offset of field: found_btree_node::sectors_written",
    ][::std::mem::offset_of!(found_btree_node, sectors_written) - 4usize];
    [
        "Offset of field: found_btree_node::seq",
    ][::std::mem::offset_of!(found_btree_node, seq) - 8usize];
    [
        "Offset of field: found_btree_node::journal_seq",
    ][::std::mem::offset_of!(found_btree_node, journal_seq) - 16usize];
    [
        "Offset of field: found_btree_node::cookie",
    ][::std::mem::offset_of!(found_btree_node, cookie) - 24usize];
    [
        "Offset of field: found_btree_node::min_key",
    ][::std::mem::offset_of!(found_btree_node, min_key) - 32usize];
    [
        "Offset of field: found_btree_node::max_key",
    ][::std::mem::offset_of!(found_btree_node, max_key) - 52usize];
    [
        "Offset of field: found_btree_node::nr_ptrs",
    ][::std::mem::offset_of!(found_btree_node, nr_ptrs) - 72usize];
    [
        "Offset of field: found_btree_node::ptrs",
    ][::std::mem::offset_of!(found_btree_node, ptrs) - 80usize];
};
impl Default for found_btree_node {
    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 found_btree_node {
    #[inline]
    pub fn range_updated(&self) -> bool {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_range_updated(&mut self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn range_updated_raw(this: *const Self) -> bool {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 1usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 1u8) as u8,
            )
        }
    }
    #[inline]
    pub unsafe fn set_range_updated_raw(this: *mut Self, val: bool) {
        unsafe {
            let val: u8 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 1usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(range_updated: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                1u8,
                {
                    let range_updated: u8 = unsafe {
                        ::std::mem::transmute(range_updated)
                    };
                    range_updated as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
pub struct find_btree_nodes {
    pub ret: ::std::os::raw::c_int,
    pub lock: mutex,
    pub nodes: darray_found_btree_node,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of find_btree_nodes"][::std::mem::size_of::<find_btree_nodes>() - 72usize];
    [
        "Alignment of find_btree_nodes",
    ][::std::mem::align_of::<find_btree_nodes>() - 8usize];
    [
        "Offset of field: find_btree_nodes::ret",
    ][::std::mem::offset_of!(find_btree_nodes, ret) - 0usize];
    [
        "Offset of field: find_btree_nodes::lock",
    ][::std::mem::offset_of!(find_btree_nodes, lock) - 8usize];
    [
        "Offset of field: find_btree_nodes::nodes",
    ][::std::mem::offset_of!(find_btree_nodes, nodes) - 48usize];
};
impl Default for find_btree_nodes {
    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 wb_key_ref {
    pub __bindgen_anon_1: wb_key_ref__bindgen_ty_1,
}
#[repr(C)]
pub struct wb_key_ref__bindgen_ty_1 {
    pub __bindgen_anon_1: __BindgenUnionField<wb_key_ref__bindgen_ty_1__bindgen_ty_1>,
    pub __bindgen_anon_2: __BindgenUnionField<wb_key_ref__bindgen_ty_1__bindgen_ty_2>,
    pub bindgen_union_field: [u64; 3usize],
}
#[repr(C, packed)]
pub struct wb_key_ref__bindgen_ty_1__bindgen_ty_1 {
    pub idx: u32_,
    pub pos: [u8_; 20usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of wb_key_ref__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_1>() - 24usize];
    [
        "Alignment of wb_key_ref__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_1>() - 1usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_1::idx",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_1, idx) - 0usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_1::pos",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_1, pos) - 4usize];
};
impl Default for wb_key_ref__bindgen_ty_1__bindgen_ty_1 {
    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 wb_key_ref__bindgen_ty_1__bindgen_ty_2 {
    pub lo: u64_,
    pub mi: u64_,
    pub hi: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of wb_key_ref__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::size_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_2>() - 24usize];
    [
        "Alignment of wb_key_ref__bindgen_ty_1__bindgen_ty_2",
    ][::std::mem::align_of::<wb_key_ref__bindgen_ty_1__bindgen_ty_2>() - 8usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_2::lo",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_2, lo) - 0usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_2::mi",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_2, mi) - 8usize];
    [
        "Offset of field: wb_key_ref__bindgen_ty_1__bindgen_ty_2::hi",
    ][::std::mem::offset_of!(wb_key_ref__bindgen_ty_1__bindgen_ty_2, hi) - 16usize];
};
impl Default for wb_key_ref__bindgen_ty_1__bindgen_ty_2 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of wb_key_ref__bindgen_ty_1",
    ][::std::mem::size_of::<wb_key_ref__bindgen_ty_1>() - 24usize];
    [
        "Alignment of wb_key_ref__bindgen_ty_1",
    ][::std::mem::align_of::<wb_key_ref__bindgen_ty_1>() - 8usize];
};
impl Default for wb_key_ref__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of wb_key_ref"][::std::mem::size_of::<wb_key_ref>() - 24usize];
    ["Alignment of wb_key_ref"][::std::mem::align_of::<wb_key_ref>() - 8usize];
};
impl Default for wb_key_ref {
    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(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum wb_flush_caller {
    WB_FLUSH_thread = 0,
    WB_FLUSH_journal_pin = 1,
    WB_FLUSH_sync = 2,
    WB_FLUSH_maybe = 3,
    WB_FLUSH_tryflush = 4,
    WB_FLUSH_NR = 5,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum six_lock_type {
    SIX_LOCK_read = 0,
    SIX_LOCK_intent = 1,
    SIX_LOCK_write = 2,
}
#[repr(C)]
pub struct six_lock_waiter {
    pub trans_start_time: u64_,
    pub task: *mut task_struct,
    pub lock_want: six_lock_type,
    pub lock_acquired: bool,
    pub slot_idx: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of six_lock_waiter"][::std::mem::size_of::<six_lock_waiter>() - 24usize];
    ["Alignment of six_lock_waiter"][::std::mem::align_of::<six_lock_waiter>() - 8usize];
    [
        "Offset of field: six_lock_waiter::trans_start_time",
    ][::std::mem::offset_of!(six_lock_waiter, trans_start_time) - 0usize];
    [
        "Offset of field: six_lock_waiter::task",
    ][::std::mem::offset_of!(six_lock_waiter, task) - 8usize];
    [
        "Offset of field: six_lock_waiter::lock_want",
    ][::std::mem::offset_of!(six_lock_waiter, lock_want) - 16usize];
    [
        "Offset of field: six_lock_waiter::lock_acquired",
    ][::std::mem::offset_of!(six_lock_waiter, lock_acquired) - 20usize];
    [
        "Offset of field: six_lock_waiter::slot_idx",
    ][::std::mem::offset_of!(six_lock_waiter, slot_idx) - 22usize];
};
impl Default for six_lock_waiter {
    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 six_lock_wait_slot {
    pub w: *mut six_lock_waiter,
    pub start_time: u64_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of six_lock_wait_slot",
    ][::std::mem::size_of::<six_lock_wait_slot>() - 16usize];
    [
        "Alignment of six_lock_wait_slot",
    ][::std::mem::align_of::<six_lock_wait_slot>() - 8usize];
    [
        "Offset of field: six_lock_wait_slot::w",
    ][::std::mem::offset_of!(six_lock_wait_slot, w) - 0usize];
    [
        "Offset of field: six_lock_wait_slot::start_time",
    ][::std::mem::offset_of!(six_lock_wait_slot, start_time) - 8usize];
};
impl Default for six_lock_wait_slot {
    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 six_lock_wait_fifo {
    pub size: u16_,
    pub nr: u16_,
    pub next_free_hint: u16_,
    pub data: __IncompleteArrayField<six_lock_wait_slot>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of six_lock_wait_fifo"][::std::mem::size_of::<six_lock_wait_fifo>() - 8usize];
    [
        "Alignment of six_lock_wait_fifo",
    ][::std::mem::align_of::<six_lock_wait_fifo>() - 8usize];
    [
        "Offset of field: six_lock_wait_fifo::size",
    ][::std::mem::offset_of!(six_lock_wait_fifo, size) - 0usize];
    [
        "Offset of field: six_lock_wait_fifo::nr",
    ][::std::mem::offset_of!(six_lock_wait_fifo, nr) - 2usize];
    [
        "Offset of field: six_lock_wait_fifo::next_free_hint",
    ][::std::mem::offset_of!(six_lock_wait_fifo, next_free_hint) - 4usize];
    [
        "Offset of field: six_lock_wait_fifo::data",
    ][::std::mem::offset_of!(six_lock_wait_fifo, data) - 8usize];
};
impl Default for six_lock_wait_fifo {
    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 six_lock {
    pub state: atomic_t,
    pub seq: u32_,
    pub readers: *mut ::std::os::raw::c_uint,
    pub intent_lock_recurse: ::std::os::raw::c_uint,
    pub write_lock_recurse: ::std::os::raw::c_uint,
    pub owner: *mut task_struct,
    pub wait_lock: raw_spinlock_t,
    pub wait_fifo: *mut six_lock_wait_fifo,
    pub inline_fifo: six_lock_wait_fifo,
    pub inline_fifo_data: [six_lock_wait_slot; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of six_lock"][::std::mem::size_of::<six_lock>() - 216usize];
    ["Alignment of six_lock"][::std::mem::align_of::<six_lock>() - 8usize];
    [
        "Offset of field: six_lock::state",
    ][::std::mem::offset_of!(six_lock, state) - 0usize];
    ["Offset of field: six_lock::seq"][::std::mem::offset_of!(six_lock, seq) - 4usize];
    [
        "Offset of field: six_lock::readers",
    ][::std::mem::offset_of!(six_lock, readers) - 8usize];
    [
        "Offset of field: six_lock::intent_lock_recurse",
    ][::std::mem::offset_of!(six_lock, intent_lock_recurse) - 16usize];
    [
        "Offset of field: six_lock::write_lock_recurse",
    ][::std::mem::offset_of!(six_lock, write_lock_recurse) - 20usize];
    [
        "Offset of field: six_lock::owner",
    ][::std::mem::offset_of!(six_lock, owner) - 24usize];
    [
        "Offset of field: six_lock::wait_lock",
    ][::std::mem::offset_of!(six_lock, wait_lock) - 32usize];
    [
        "Offset of field: six_lock::wait_fifo",
    ][::std::mem::offset_of!(six_lock, wait_fifo) - 72usize];
    [
        "Offset of field: six_lock::inline_fifo",
    ][::std::mem::offset_of!(six_lock, inline_fifo) - 80usize];
    [
        "Offset of field: six_lock::inline_fifo_data",
    ][::std::mem::offset_of!(six_lock, inline_fifo_data) - 88usize];
};
impl Default for six_lock {
    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 bset_tree {
    pub size: u16_,
    pub extra: u16_,
    pub data_offset: u16_,
    pub aux_data_offset: u16_,
    pub end_offset: u16_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bset_tree"][::std::mem::size_of::<bset_tree>() - 10usize];
    ["Alignment of bset_tree"][::std::mem::align_of::<bset_tree>() - 2usize];
    [
        "Offset of field: bset_tree::size",
    ][::std::mem::offset_of!(bset_tree, size) - 0usize];
    [
        "Offset of field: bset_tree::extra",
    ][::std::mem::offset_of!(bset_tree, extra) - 2usize];
    [
        "Offset of field: bset_tree::data_offset",
    ][::std::mem::offset_of!(bset_tree, data_offset) - 4usize];
    [
        "Offset of field: bset_tree::aux_data_offset",
    ][::std::mem::offset_of!(bset_tree, aux_data_offset) - 6usize];
    [
        "Offset of field: bset_tree::end_offset",
    ][::std::mem::offset_of!(bset_tree, end_offset) - 8usize];
};
impl Default for bset_tree {
    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)]
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct gc_stripe {
    pub _bindgen_opaque_blob: [u64; 24usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of gc_stripe"][::std::mem::size_of::<gc_stripe>() - 192usize];
    ["Alignment of gc_stripe"][::std::mem::align_of::<gc_stripe>() - 8usize];
};
#[repr(C)]
#[repr(align(64))]
pub struct nocow_lock_bucket {
    pub wait: closure_waitlist,
    pub lock: spinlock_t,
    pub b: [u64_; 6usize],
    pub l: [atomic_t; 6usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of nocow_lock_bucket"][::std::mem::size_of::<nocow_lock_bucket>() - 128usize];
    [
        "Alignment of nocow_lock_bucket",
    ][::std::mem::align_of::<nocow_lock_bucket>() - 64usize];
    [
        "Offset of field: nocow_lock_bucket::wait",
    ][::std::mem::offset_of!(nocow_lock_bucket, wait) - 0usize];
    [
        "Offset of field: nocow_lock_bucket::lock",
    ][::std::mem::offset_of!(nocow_lock_bucket, lock) - 8usize];
    [
        "Offset of field: nocow_lock_bucket::b",
    ][::std::mem::offset_of!(nocow_lock_bucket, b) - 48usize];
    [
        "Offset of field: nocow_lock_bucket::l",
    ][::std::mem::offset_of!(nocow_lock_bucket, l) - 96usize];
};
impl Default for nocow_lock_bucket {
    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)]
#[repr(align(64))]
pub struct bucket_nocow_lock_table {
    pub l: [nocow_lock_bucket; 1024usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bucket_nocow_lock_table",
    ][::std::mem::size_of::<bucket_nocow_lock_table>() - 131072usize];
    [
        "Alignment of bucket_nocow_lock_table",
    ][::std::mem::align_of::<bucket_nocow_lock_table>() - 64usize];
    [
        "Offset of field: bucket_nocow_lock_table::l",
    ][::std::mem::offset_of!(bucket_nocow_lock_table, l) - 0usize];
};
impl Default for bucket_nocow_lock_table {
    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 scrub_journal_repair {
    pub btree_id: btree_id,
    pub bad_devs: ::std::os::raw::c_uint,
    pub k: bkey_i,
    pub k_pad: [__u64; 41usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of scrub_journal_repair",
    ][::std::mem::size_of::<scrub_journal_repair>() - 376usize];
    [
        "Alignment of scrub_journal_repair",
    ][::std::mem::align_of::<scrub_journal_repair>() - 8usize];
    [
        "Offset of field: scrub_journal_repair::btree_id",
    ][::std::mem::offset_of!(scrub_journal_repair, btree_id) - 0usize];
    [
        "Offset of field: scrub_journal_repair::bad_devs",
    ][::std::mem::offset_of!(scrub_journal_repair, bad_devs) - 4usize];
    [
        "Offset of field: scrub_journal_repair::k",
    ][::std::mem::offset_of!(scrub_journal_repair, k) - 8usize];
    [
        "Offset of field: scrub_journal_repair::k_pad",
    ][::std::mem::offset_of!(scrub_journal_repair, k_pad) - 48usize];
};
impl Default for scrub_journal_repair {
    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 progress_indicator {
    pub msg: *const ::std::os::raw::c_char,
    pub units: bch_progress_units,
    pub pos: bbpos,
    pub next_print: ::std::os::raw::c_ulong,
    pub seen: u64_,
    pub total: u64_,
    pub last_node: *mut btree,
    pub silent: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of progress_indicator",
    ][::std::mem::size_of::<progress_indicator>() - 80usize];
    [
        "Alignment of progress_indicator",
    ][::std::mem::align_of::<progress_indicator>() - 8usize];
    [
        "Offset of field: progress_indicator::msg",
    ][::std::mem::offset_of!(progress_indicator, msg) - 0usize];
    [
        "Offset of field: progress_indicator::units",
    ][::std::mem::offset_of!(progress_indicator, units) - 8usize];
    [
        "Offset of field: progress_indicator::pos",
    ][::std::mem::offset_of!(progress_indicator, pos) - 12usize];
    [
        "Offset of field: progress_indicator::next_print",
    ][::std::mem::offset_of!(progress_indicator, next_print) - 40usize];
    [
        "Offset of field: progress_indicator::seen",
    ][::std::mem::offset_of!(progress_indicator, seen) - 48usize];
    [
        "Offset of field: progress_indicator::total",
    ][::std::mem::offset_of!(progress_indicator, total) - 56usize];
    [
        "Offset of field: progress_indicator::last_node",
    ][::std::mem::offset_of!(progress_indicator, last_node) - 64usize];
    [
        "Offset of field: progress_indicator::silent",
    ][::std::mem::offset_of!(progress_indicator, silent) - 72usize];
};
impl Default for progress_indicator {
    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 memquota_counter {
    pub v: u64_,
    pub hardlimit: u64_,
    pub softlimit: u64_,
    pub timer: s64,
    pub warns: ::std::os::raw::c_int,
    pub warning_issued: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of memquota_counter"][::std::mem::size_of::<memquota_counter>() - 40usize];
    [
        "Alignment of memquota_counter",
    ][::std::mem::align_of::<memquota_counter>() - 8usize];
    [
        "Offset of field: memquota_counter::v",
    ][::std::mem::offset_of!(memquota_counter, v) - 0usize];
    [
        "Offset of field: memquota_counter::hardlimit",
    ][::std::mem::offset_of!(memquota_counter, hardlimit) - 8usize];
    [
        "Offset of field: memquota_counter::softlimit",
    ][::std::mem::offset_of!(memquota_counter, softlimit) - 16usize];
    [
        "Offset of field: memquota_counter::timer",
    ][::std::mem::offset_of!(memquota_counter, timer) - 24usize];
    [
        "Offset of field: memquota_counter::warns",
    ][::std::mem::offset_of!(memquota_counter, warns) - 32usize];
    [
        "Offset of field: memquota_counter::warning_issued",
    ][::std::mem::offset_of!(memquota_counter, warning_issued) - 36usize];
};
impl Default for memquota_counter {
    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 quota_limit {
    pub timelimit: u32_,
    pub warnlimit: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of quota_limit"][::std::mem::size_of::<quota_limit>() - 8usize];
    ["Alignment of quota_limit"][::std::mem::align_of::<quota_limit>() - 4usize];
    [
        "Offset of field: quota_limit::timelimit",
    ][::std::mem::offset_of!(quota_limit, timelimit) - 0usize];
    [
        "Offset of field: quota_limit::warnlimit",
    ][::std::mem::offset_of!(quota_limit, warnlimit) - 4usize];
};
impl Default for quota_limit {
    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)]
#[derive(Debug, Copy, Clone)]
pub struct fsck_err_state {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct fsck_damaged_path {
    pub inum: u64_,
    pub snapshot: u32_,
    pub nr_errors: u16_,
    pub errors: [u16_; 7usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fsck_damaged_path"][::std::mem::size_of::<fsck_damaged_path>() - 32usize];
    [
        "Alignment of fsck_damaged_path",
    ][::std::mem::align_of::<fsck_damaged_path>() - 8usize];
    [
        "Offset of field: fsck_damaged_path::inum",
    ][::std::mem::offset_of!(fsck_damaged_path, inum) - 0usize];
    [
        "Offset of field: fsck_damaged_path::snapshot",
    ][::std::mem::offset_of!(fsck_damaged_path, snapshot) - 8usize];
    [
        "Offset of field: fsck_damaged_path::nr_errors",
    ][::std::mem::offset_of!(fsck_damaged_path, nr_errors) - 12usize];
    [
        "Offset of field: fsck_damaged_path::errors",
    ][::std::mem::offset_of!(fsck_damaged_path, errors) - 14usize];
};
impl Default for fsck_damaged_path {
    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 snapshot_id_list {
    pub nr: usize,
    pub size: usize,
    pub data: *mut u32_,
    pub preallocated: __IncompleteArrayField<u32_>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_id_list"][::std::mem::size_of::<snapshot_id_list>() - 24usize];
    [
        "Alignment of snapshot_id_list",
    ][::std::mem::align_of::<snapshot_id_list>() - 8usize];
    [
        "Offset of field: snapshot_id_list::nr",
    ][::std::mem::offset_of!(snapshot_id_list, nr) - 0usize];
    [
        "Offset of field: snapshot_id_list::size",
    ][::std::mem::offset_of!(snapshot_id_list, size) - 8usize];
    [
        "Offset of field: snapshot_id_list::data",
    ][::std::mem::offset_of!(snapshot_id_list, data) - 16usize];
    [
        "Offset of field: snapshot_id_list::preallocated",
    ][::std::mem::offset_of!(snapshot_id_list, preallocated) - 24usize];
};
impl Default for snapshot_id_list {
    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 snapshot_t {
    pub state: snapshot_t_snapshot_id_state,
    pub parent: u32_,
    pub skip: [u32_; 3usize],
    pub depth: u32_,
    pub children: [u32_; 2usize],
    pub subvol: u32_,
    pub tree: u32_,
    pub is_ancestor: [::std::os::raw::c_ulong; 2usize],
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum snapshot_t_snapshot_id_state {
    SNAPSHOT_ID_empty = 0,
    SNAPSHOT_ID_live = 1,
    SNAPSHOT_ID_deleted = 2,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_t"][::std::mem::size_of::<snapshot_t>() - 56usize];
    ["Alignment of snapshot_t"][::std::mem::align_of::<snapshot_t>() - 8usize];
    [
        "Offset of field: snapshot_t::state",
    ][::std::mem::offset_of!(snapshot_t, state) - 0usize];
    [
        "Offset of field: snapshot_t::parent",
    ][::std::mem::offset_of!(snapshot_t, parent) - 4usize];
    [
        "Offset of field: snapshot_t::skip",
    ][::std::mem::offset_of!(snapshot_t, skip) - 8usize];
    [
        "Offset of field: snapshot_t::depth",
    ][::std::mem::offset_of!(snapshot_t, depth) - 20usize];
    [
        "Offset of field: snapshot_t::children",
    ][::std::mem::offset_of!(snapshot_t, children) - 24usize];
    [
        "Offset of field: snapshot_t::subvol",
    ][::std::mem::offset_of!(snapshot_t, subvol) - 32usize];
    [
        "Offset of field: snapshot_t::tree",
    ][::std::mem::offset_of!(snapshot_t, tree) - 36usize];
    [
        "Offset of field: snapshot_t::is_ancestor",
    ][::std::mem::offset_of!(snapshot_t, is_ancestor) - 40usize];
};
impl Default for snapshot_t {
    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 snapshot_table {
    pub rcu: rcu_head,
    pub nr: usize,
    pub s: __IncompleteArrayField<snapshot_t>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_table"][::std::mem::size_of::<snapshot_table>() - 24usize];
    ["Alignment of snapshot_table"][::std::mem::align_of::<snapshot_table>() - 8usize];
    [
        "Offset of field: snapshot_table::rcu",
    ][::std::mem::offset_of!(snapshot_table, rcu) - 0usize];
    [
        "Offset of field: snapshot_table::nr",
    ][::std::mem::offset_of!(snapshot_table, nr) - 16usize];
    [
        "Offset of field: snapshot_table::s",
    ][::std::mem::offset_of!(snapshot_table, s) - 24usize];
};
impl Default for snapshot_table {
    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 snapshot_interior_delete {
    pub id: u32_,
    pub live_child: u32_,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of snapshot_interior_delete",
    ][::std::mem::size_of::<snapshot_interior_delete>() - 8usize];
    [
        "Alignment of snapshot_interior_delete",
    ][::std::mem::align_of::<snapshot_interior_delete>() - 4usize];
    [
        "Offset of field: snapshot_interior_delete::id",
    ][::std::mem::offset_of!(snapshot_interior_delete, id) - 0usize];
    [
        "Offset of field: snapshot_interior_delete::live_child",
    ][::std::mem::offset_of!(snapshot_interior_delete, live_child) - 4usize];
};
impl Default for snapshot_interior_delete {
    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 interior_delete_list {
    pub nr: usize,
    pub size: usize,
    pub data: *mut snapshot_interior_delete,
    pub preallocated: __IncompleteArrayField<snapshot_interior_delete>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of interior_delete_list",
    ][::std::mem::size_of::<interior_delete_list>() - 24usize];
    [
        "Alignment of interior_delete_list",
    ][::std::mem::align_of::<interior_delete_list>() - 8usize];
    [
        "Offset of field: interior_delete_list::nr",
    ][::std::mem::offset_of!(interior_delete_list, nr) - 0usize];
    [
        "Offset of field: interior_delete_list::size",
    ][::std::mem::offset_of!(interior_delete_list, size) - 8usize];
    [
        "Offset of field: interior_delete_list::data",
    ][::std::mem::offset_of!(interior_delete_list, data) - 16usize];
    [
        "Offset of field: interior_delete_list::preallocated",
    ][::std::mem::offset_of!(interior_delete_list, preallocated) - 24usize];
};
impl Default for interior_delete_list {
    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 snapshot_delete {
    pub progress_lock: mutex,
    pub deleting_from_trees: snapshot_id_list,
    pub delete_leaves: snapshot_id_list,
    pub delete_interior: interior_delete_list,
    pub no_keys: interior_delete_list,
    pub eytzinger_delete_list: interior_delete_list,
    pub running: bool,
    pub version: ::std::os::raw::c_uint,
    pub progress: progress_indicator,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of snapshot_delete"][::std::mem::size_of::<snapshot_delete>() - 248usize];
    ["Alignment of snapshot_delete"][::std::mem::align_of::<snapshot_delete>() - 8usize];
    [
        "Offset of field: snapshot_delete::progress_lock",
    ][::std::mem::offset_of!(snapshot_delete, progress_lock) - 0usize];
    [
        "Offset of field: snapshot_delete::deleting_from_trees",
    ][::std::mem::offset_of!(snapshot_delete, deleting_from_trees) - 40usize];
    [
        "Offset of field: snapshot_delete::delete_leaves",
    ][::std::mem::offset_of!(snapshot_delete, delete_leaves) - 64usize];
    [
        "Offset of field: snapshot_delete::delete_interior",
    ][::std::mem::offset_of!(snapshot_delete, delete_interior) - 88usize];
    [
        "Offset of field: snapshot_delete::no_keys",
    ][::std::mem::offset_of!(snapshot_delete, no_keys) - 112usize];
    [
        "Offset of field: snapshot_delete::eytzinger_delete_list",
    ][::std::mem::offset_of!(snapshot_delete, eytzinger_delete_list) - 136usize];
    [
        "Offset of field: snapshot_delete::running",
    ][::std::mem::offset_of!(snapshot_delete, running) - 160usize];
    [
        "Offset of field: snapshot_delete::version",
    ][::std::mem::offset_of!(snapshot_delete, version) - 164usize];
    [
        "Offset of field: snapshot_delete::progress",
    ][::std::mem::offset_of!(snapshot_delete, progress) - 168usize];
};
impl Default for snapshot_delete {
    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 io_count {
    pub sectors: [[u64_; 12usize]; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of io_count"][::std::mem::size_of::<io_count>() - 192usize];
    ["Alignment of io_count"][::std::mem::align_of::<io_count>() - 8usize];
    [
        "Offset of field: io_count::sectors",
    ][::std::mem::offset_of!(io_count, sectors) - 0usize];
};
impl Default for io_count {
    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 bucket_bitmap {
    pub buckets: *mut ::std::os::raw::c_ulong,
    pub nr: u64_,
    pub lock: mutex,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bucket_bitmap"][::std::mem::size_of::<bucket_bitmap>() - 56usize];
    ["Alignment of bucket_bitmap"][::std::mem::align_of::<bucket_bitmap>() - 8usize];
    [
        "Offset of field: bucket_bitmap::buckets",
    ][::std::mem::offset_of!(bucket_bitmap, buckets) - 0usize];
    [
        "Offset of field: bucket_bitmap::nr",
    ][::std::mem::offset_of!(bucket_bitmap, nr) - 8usize];
    [
        "Offset of field: bucket_bitmap::lock",
    ][::std::mem::offset_of!(bucket_bitmap, lock) - 16usize];
};
impl Default for bucket_bitmap {
    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()
        }
    }
}
unsafe extern "C" {
    pub fn read_file_str(
        arg1: ::std::os::raw::c_int,
        arg2: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn read_file_u64(
        arg1: ::std::os::raw::c_int,
        arg2: *const ::std::os::raw::c_char,
    ) -> u64_;
}
unsafe extern "C" {
    pub fn ask_yn() -> bool;
}
unsafe extern "C" {
    pub fn read_passphrase(
        arg1: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn derive_passphrase(
        arg1: *mut bch_sb_field_crypt,
        arg2: *const ::std::os::raw::c_char,
    ) -> bch_key;
}
unsafe extern "C" {
    pub fn bch2_sb_is_encrypted(arg1: *mut bch_sb) -> bool;
}
unsafe extern "C" {
    pub fn bch2_passphrase_check(
        arg1: *mut bch_sb,
        arg2: *const ::std::os::raw::c_char,
        arg3: *mut bch_key,
        arg4: *mut bch_encrypted_key,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch2_add_key(
        arg1: *mut bch_sb,
        arg2: *const ::std::os::raw::c_char,
        arg3: *const ::std::os::raw::c_char,
        arg4: *const ::std::os::raw::c_char,
    ) -> bool;
}
unsafe extern "C" {
    pub fn bch_sb_crypt_init(
        sb: *mut bch_sb,
        arg1: *mut bch_sb_field_crypt,
        arg2: *const ::std::os::raw::c_char,
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct bch_opt_strs {
    pub __bindgen_anon_1: bch_opt_strs__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union bch_opt_strs__bindgen_ty_1 {
    pub by_id: [*mut ::std::os::raw::c_char; 94usize],
    pub __bindgen_anon_1: bch_opt_strs__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct bch_opt_strs__bindgen_ty_1__bindgen_ty_1 {
    pub block_size: *mut ::std::os::raw::c_char,
    pub btree_node_size: *mut ::std::os::raw::c_char,
    pub errors: *mut ::std::os::raw::c_char,
    pub write_error_timeout: *mut ::std::os::raw::c_char,
    pub metadata_replicas: *mut ::std::os::raw::c_char,
    pub data_replicas: *mut ::std::os::raw::c_char,
    pub encoded_extent_max: *mut ::std::os::raw::c_char,
    pub metadata_checksum: *mut ::std::os::raw::c_char,
    pub data_checksum: *mut ::std::os::raw::c_char,
    pub checksum_err_retry_nr: *mut ::std::os::raw::c_char,
    pub compression: *mut ::std::os::raw::c_char,
    pub background_compression: *mut ::std::os::raw::c_char,
    pub str_hash: *mut ::std::os::raw::c_char,
    pub metadata_target: *mut ::std::os::raw::c_char,
    pub foreground_target: *mut ::std::os::raw::c_char,
    pub background_target: *mut ::std::os::raw::c_char,
    pub promote_target: *mut ::std::os::raw::c_char,
    pub erasure_code: *mut ::std::os::raw::c_char,
    pub ec_max_data_blocks: *mut ::std::os::raw::c_char,
    pub casefold: *mut ::std::os::raw::c_char,
    pub casefold_disabled: *mut ::std::os::raw::c_char,
    pub inodes_32bit: *mut ::std::os::raw::c_char,
    pub shard_inode_numbers_bits: *mut ::std::os::raw::c_char,
    pub gc_reserve_percent: *mut ::std::os::raw::c_char,
    pub gc_reserve_bytes: *mut ::std::os::raw::c_char,
    pub root_reserve_percent: *mut ::std::os::raw::c_char,
    pub wide_macs: *mut ::std::os::raw::c_char,
    pub inline_data: *mut ::std::os::raw::c_char,
    pub promote_whole_extents: *mut ::std::os::raw::c_char,
    pub acl: *mut ::std::os::raw::c_char,
    pub usrquota: *mut ::std::os::raw::c_char,
    pub grpquota: *mut ::std::os::raw::c_char,
    pub prjquota: *mut ::std::os::raw::c_char,
    pub degraded: *mut ::std::os::raw::c_char,
    pub missing_dev_timeout: *mut ::std::os::raw::c_char,
    pub mount_trusts_udev: *mut ::std::os::raw::c_char,
    pub no_splitbrain_check: *mut ::std::os::raw::c_char,
    pub no_version_check: *mut ::std::os::raw::c_char,
    pub verbose: *mut ::std::os::raw::c_char,
    pub journal_flush_delay: *mut ::std::os::raw::c_char,
    pub journal_flush_disabled: *mut ::std::os::raw::c_char,
    pub move_writes_fua: *mut ::std::os::raw::c_char,
    pub journal_reclaim_delay: *mut ::std::os::raw::c_char,
    pub writeback_timeout: *mut ::std::os::raw::c_char,
    pub move_bytes_in_flight: *mut ::std::os::raw::c_char,
    pub move_ios_in_flight: *mut ::std::os::raw::c_char,
    pub fsck: *mut ::std::os::raw::c_char,
    pub fsck_memory_usage_percent: *mut ::std::os::raw::c_char,
    pub fix_errors: *mut ::std::os::raw::c_char,
    pub ratelimit_errors: *mut ::std::os::raw::c_char,
    pub no_commit_validate: *mut ::std::os::raw::c_char,
    pub nochanges: *mut ::std::os::raw::c_char,
    pub norecovery: *mut ::std::os::raw::c_char,
    pub journal_rewind: *mut ::std::os::raw::c_char,
    pub journal_rewind_discard_buffer_percent: *mut ::std::os::raw::c_char,
    pub scrub_recent_journal_entries: *mut ::std::os::raw::c_char,
    pub scrub_journal_max_rewind_secs: *mut ::std::os::raw::c_char,
    pub recovery_passes: *mut ::std::os::raw::c_char,
    pub recovery_passes_exclude: *mut ::std::os::raw::c_char,
    pub recovery_pass_last: *mut ::std::os::raw::c_char,
    pub recovery_passes_skip_scheduled: *mut ::std::os::raw::c_char,
    pub retain_recovery_info: *mut ::std::os::raw::c_char,
    pub read_entire_journal: *mut ::std::os::raw::c_char,
    pub read_journal_only: *mut ::std::os::raw::c_char,
    pub journal_transaction_names: *mut ::std::os::raw::c_char,
    pub allocator_stuck_timeout: *mut ::std::os::raw::c_char,
    pub noexcl: *mut ::std::os::raw::c_char,
    pub direct_io: *mut ::std::os::raw::c_char,
    pub sb: *mut ::std::os::raw::c_char,
    pub read_only: *mut ::std::os::raw::c_char,
    pub nostart: *mut ::std::os::raw::c_char,
    pub dangerously_reconstruct_alloc: *mut ::std::os::raw::c_char,
    pub version_upgrade: *mut ::std::os::raw::c_char,
    pub stdio: *mut ::std::os::raw::c_char,
    pub project: *mut ::std::os::raw::c_char,
    pub nocow: *mut ::std::os::raw::c_char,
    pub nocow_enabled: *mut ::std::os::raw::c_char,
    pub copygc_enabled: *mut ::std::os::raw::c_char,
    pub reconcile_enabled: *mut ::std::os::raw::c_char,
    pub reconcile_on_ac_only: *mut ::std::os::raw::c_char,
    pub auto_snapshot_deletion: *mut ::std::os::raw::c_char,
    pub no_data_io: *mut ::std::os::raw::c_char,
    pub state: *mut ::std::os::raw::c_char,
    pub label: *mut ::std::os::raw::c_char,
    pub failure_domain: *mut ::std::os::raw::c_char,
    pub bucket_size: *mut ::std::os::raw::c_char,
    pub durability: *mut ::std::os::raw::c_char,
    pub data_allowed: *mut ::std::os::raw::c_char,
    pub discard: *mut ::std::os::raw::c_char,
    pub rotational: *mut ::std::os::raw::c_char,
    pub btree_node_prefetch: *mut ::std::os::raw::c_char,
    pub btree_cache_shrinker_seeks: *mut ::std::os::raw::c_char,
    pub dev_readahead: *mut ::std::os::raw::c_char,
    pub ec_stripe_buf_limit: *mut ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_opt_strs__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::size_of::<bch_opt_strs__bindgen_ty_1__bindgen_ty_1>() - 752usize];
    [
        "Alignment of bch_opt_strs__bindgen_ty_1__bindgen_ty_1",
    ][::std::mem::align_of::<bch_opt_strs__bindgen_ty_1__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::block_size",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, block_size)
        - 0usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::btree_node_size",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, btree_node_size)
        - 8usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::errors",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, errors)
        - 16usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::write_error_timeout",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, write_error_timeout
    ) - 24usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::metadata_replicas",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, metadata_replicas)
        - 32usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::data_replicas",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, data_replicas)
        - 40usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::encoded_extent_max",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, encoded_extent_max
    ) - 48usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::metadata_checksum",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, metadata_checksum)
        - 56usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::data_checksum",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, data_checksum)
        - 64usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::checksum_err_retry_nr",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, checksum_err_retry_nr
    ) - 72usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::compression",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, compression)
        - 80usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::background_compression",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, background_compression
    ) - 88usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::str_hash",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, str_hash)
        - 96usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::metadata_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, metadata_target)
        - 104usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::foreground_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, foreground_target)
        - 112usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::background_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, background_target)
        - 120usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::promote_target",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, promote_target)
        - 128usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::erasure_code",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, erasure_code)
        - 136usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::ec_max_data_blocks",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, ec_max_data_blocks
    ) - 144usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::casefold",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, casefold)
        - 152usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::casefold_disabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, casefold_disabled)
        - 160usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::inodes_32bit",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, inodes_32bit)
        - 168usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::shard_inode_numbers_bits",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, shard_inode_numbers_bits
    ) - 176usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::gc_reserve_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, gc_reserve_percent
    ) - 184usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::gc_reserve_bytes",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, gc_reserve_bytes)
        - 192usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::root_reserve_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, root_reserve_percent
    ) - 200usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::wide_macs",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, wide_macs)
        - 208usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::inline_data",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, inline_data)
        - 216usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::promote_whole_extents",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, promote_whole_extents
    ) - 224usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::acl",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, acl) - 232usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::usrquota",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, usrquota)
        - 240usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::grpquota",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, grpquota)
        - 248usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::prjquota",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, prjquota)
        - 256usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::degraded",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, degraded)
        - 264usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::missing_dev_timeout",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, missing_dev_timeout
    ) - 272usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::mount_trusts_udev",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, mount_trusts_udev)
        - 280usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_splitbrain_check",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_splitbrain_check
    ) - 288usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_version_check",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_version_check)
        - 296usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::verbose",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, verbose)
        - 304usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_flush_delay",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_flush_delay
    ) - 312usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_flush_disabled",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_flush_disabled
    ) - 320usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::move_writes_fua",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, move_writes_fua)
        - 328usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_reclaim_delay",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_reclaim_delay
    ) - 336usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::writeback_timeout",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, writeback_timeout)
        - 344usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::move_bytes_in_flight",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, move_bytes_in_flight
    ) - 352usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::move_ios_in_flight",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, move_ios_in_flight
    ) - 360usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::fsck",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, fsck) - 368usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::fsck_memory_usage_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, fsck_memory_usage_percent
    ) - 376usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::fix_errors",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, fix_errors)
        - 384usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::ratelimit_errors",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, ratelimit_errors)
        - 392usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_commit_validate",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_commit_validate
    ) - 400usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nochanges",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nochanges)
        - 408usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::norecovery",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, norecovery)
        - 416usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_rewind",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_rewind)
        - 424usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_rewind_discard_buffer_percent",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_rewind_discard_buffer_percent
    ) - 432usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::scrub_recent_journal_entries",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, scrub_recent_journal_entries
    ) - 440usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::scrub_journal_max_rewind_secs",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, scrub_journal_max_rewind_secs
    ) - 448usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_passes",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_passes)
        - 456usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_passes_exclude",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_passes_exclude
    ) - 464usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_pass_last",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_pass_last
    ) - 472usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::recovery_passes_skip_scheduled",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, recovery_passes_skip_scheduled
    ) - 480usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::retain_recovery_info",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, retain_recovery_info
    ) - 488usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::read_entire_journal",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, read_entire_journal
    ) - 496usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::read_journal_only",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, read_journal_only)
        - 504usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::journal_transaction_names",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, journal_transaction_names
    ) - 512usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::allocator_stuck_timeout",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, allocator_stuck_timeout
    ) - 520usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::noexcl",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, noexcl)
        - 528usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::direct_io",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, direct_io)
        - 536usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::sb",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, sb) - 544usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::read_only",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, read_only)
        - 552usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nostart",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nostart)
        - 560usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::dangerously_reconstruct_alloc",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, dangerously_reconstruct_alloc
    ) - 568usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::version_upgrade",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, version_upgrade)
        - 576usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::stdio",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, stdio)
        - 584usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::project",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, project)
        - 592usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nocow",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nocow)
        - 600usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::nocow_enabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, nocow_enabled)
        - 608usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::copygc_enabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, copygc_enabled)
        - 616usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::reconcile_enabled",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, reconcile_enabled)
        - 624usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::reconcile_on_ac_only",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, reconcile_on_ac_only
    ) - 632usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::auto_snapshot_deletion",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, auto_snapshot_deletion
    ) - 640usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::no_data_io",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, no_data_io)
        - 648usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::state",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, state)
        - 656usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::label",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, label)
        - 664usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::failure_domain",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, failure_domain)
        - 672usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::bucket_size",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, bucket_size)
        - 680usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::durability",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, durability)
        - 688usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::data_allowed",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, data_allowed)
        - 696usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::discard",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, discard)
        - 704usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::rotational",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, rotational)
        - 712usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::btree_node_prefetch",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, btree_node_prefetch
    ) - 720usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::btree_cache_shrinker_seeks",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, btree_cache_shrinker_seeks
    ) - 728usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::dev_readahead",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1__bindgen_ty_1, dev_readahead)
        - 736usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1__bindgen_ty_1::ec_stripe_buf_limit",
    ][::std::mem::offset_of!(
        bch_opt_strs__bindgen_ty_1__bindgen_ty_1, ec_stripe_buf_limit
    ) - 744usize];
};
impl Default for bch_opt_strs__bindgen_ty_1__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of bch_opt_strs__bindgen_ty_1",
    ][::std::mem::size_of::<bch_opt_strs__bindgen_ty_1>() - 752usize];
    [
        "Alignment of bch_opt_strs__bindgen_ty_1",
    ][::std::mem::align_of::<bch_opt_strs__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: bch_opt_strs__bindgen_ty_1::by_id",
    ][::std::mem::offset_of!(bch_opt_strs__bindgen_ty_1, by_id) - 0usize];
};
impl Default for bch_opt_strs__bindgen_ty_1 {
    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()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of bch_opt_strs"][::std::mem::size_of::<bch_opt_strs>() - 752usize];
    ["Alignment of bch_opt_strs"][::std::mem::align_of::<bch_opt_strs>() - 8usize];
};
impl Default for bch_opt_strs {
    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()
        }
    }
}
unsafe extern "C" {
    pub fn bch2_opt_strs_free(arg1: *mut bch_opt_strs);
}
unsafe extern "C" {
    pub fn bch2_parse_opts(arg1: bch_opt_strs) -> bch_opts;
}
#[repr(C)]
pub struct format_opts {
    pub label: *mut ::std::os::raw::c_char,
    pub uuid: __uuid_t,
    pub version: ::std::os::raw::c_uint,
    pub superblock_size: ::std::os::raw::c_uint,
    pub encrypted: bool,
    pub passphrase_file: *mut ::std::os::raw::c_char,
    pub passphrase: *mut ::std::os::raw::c_char,
    pub source: *mut ::std::os::raw::c_char,
    pub no_sb_at_end: bool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of format_opts"][::std::mem::size_of::<format_opts>() - 72usize];
    ["Alignment of format_opts"][::std::mem::align_of::<format_opts>() - 8usize];
    [
        "Offset of field: format_opts::label",
    ][::std::mem::offset_of!(format_opts, label) - 0usize];
    [
        "Offset of field: format_opts::uuid",
    ][::std::mem::offset_of!(format_opts, uuid) - 8usize];
    [
        "Offset of field: format_opts::version",
    ][::std::mem::offset_of!(format_opts, version) - 24usize];
    [
        "Offset of field: format_opts::superblock_size",
    ][::std::mem::offset_of!(format_opts, superblock_size) - 28usize];
    [
        "Offset of field: format_opts::encrypted",
    ][::std::mem::offset_of!(format_opts, encrypted) - 32usize];
    [
        "Offset of field: format_opts::passphrase_file",
    ][::std::mem::offset_of!(format_opts, passphrase_file) - 40usize];
    [
        "Offset of field: format_opts::passphrase",
    ][::std::mem::offset_of!(format_opts, passphrase) - 48usize];
    [
        "Offset of field: format_opts::source",
    ][::std::mem::offset_of!(format_opts, source) - 56usize];
    [
        "Offset of field: format_opts::no_sb_at_end",
    ][::std::mem::offset_of!(format_opts, no_sb_at_end) - 64usize];
};
impl Default for format_opts {
    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 dev_opts {
    pub file: *mut file,
    pub bdev: *mut block_device,
    pub path: *const ::std::os::raw::c_char,
    pub sb_offset: u64_,
    pub sb_end: u64_,
    pub nbuckets: u64_,
    pub fs_size: u64_,
    pub label: *const ::std::os::raw::c_char,
    pub opts: bch_opts,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of dev_opts"][::std::mem::size_of::<dev_opts>() - 304usize];
    ["Alignment of dev_opts"][::std::mem::align_of::<dev_opts>() - 8usize];
    ["Offset of field: dev_opts::file"][::std::mem::offset_of!(dev_opts, file) - 0usize];
    ["Offset of field: dev_opts::bdev"][::std::mem::offset_of!(dev_opts, bdev) - 8usize];
    [
        "Offset of field: dev_opts::path",
    ][::std::mem::offset_of!(dev_opts, path) - 16usize];
    [
        "Offset of field: dev_opts::sb_offset",
    ][::std::mem::offset_of!(dev_opts, sb_offset) - 24usize];
    [
        "Offset of field: dev_opts::sb_end",
    ][::std::mem::offset_of!(dev_opts, sb_end) - 32usize];
    [
        "Offset of field: dev_opts::nbuckets",
    ][::std::mem::offset_of!(dev_opts, nbuckets) - 40usize];
    [
        "Offset of field: dev_opts::fs_size",
    ][::std::mem::offset_of!(dev_opts, fs_size) - 48usize];
    [
        "Offset of field: dev_opts::label",
    ][::std::mem::offset_of!(dev_opts, label) - 56usize];
    [
        "Offset of field: dev_opts::opts",
    ][::std::mem::offset_of!(dev_opts, opts) - 64usize];
};
impl Default for dev_opts {
    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()
        }
    }
}
unsafe extern "C" {
    /** Initializes the RAID system.

 You must call this function before any other.

 The RAID system is initialized in the RAID_MODE_CAUCHY mode.*/
    pub fn raid_init();
}
pub type u96 = u64_;
unsafe extern "C" {
    pub fn rust_fuse_ensure_current();
}
unsafe extern "C" {
    pub fn rust_fuse_rcu_register();
}
unsafe extern "C" {
    pub fn rust_fuse_rcu_unregister();
}
pub type rust_fuse_filldir_fn = ::std::option::Option<
    unsafe extern "C" fn(
        ctx: *mut ::std::os::raw::c_void,
        name: *const ::std::os::raw::c_char,
        name_len: ::std::os::raw::c_uint,
        ino: u64_,
        type_: ::std::os::raw::c_uint,
        pos: u64_,
    ) -> ::std::os::raw::c_int,
>;
unsafe extern "C" {
    pub fn rust_fuse_readdir(
        c: *mut bch_fs,
        dir: subvol_inum,
        pos: u64_,
        ctx: *mut ::std::os::raw::c_void,
        filldir: rust_fuse_filldir_fn,
    ) -> ::std::os::raw::c_int;
}
pub const BCH_BLKGETSIZE64: ::std::os::raw::c_ulong = 2148012658;
pub const BCH_BLKPBSZGET: ::std::os::raw::c_ulong = 4731;
pub const BCH_BLKROTATIONAL: ::std::os::raw::c_ulong = 4734;
unsafe extern "C" {
    pub fn rust_csum_vstruct_sb(sb: *mut bch_sb) -> bch_csum;
}
unsafe extern "C" {
    pub fn rust_strip_alloc_do(c: *mut bch_fs);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct rust_journal_entries {
    pub entries: *mut *mut journal_replay,
    pub nr: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of rust_journal_entries",
    ][::std::mem::size_of::<rust_journal_entries>() - 16usize];
    [
        "Alignment of rust_journal_entries",
    ][::std::mem::align_of::<rust_journal_entries>() - 8usize];
    [
        "Offset of field: rust_journal_entries::entries",
    ][::std::mem::offset_of!(rust_journal_entries, entries) - 0usize];
    [
        "Offset of field: rust_journal_entries::nr",
    ][::std::mem::offset_of!(rust_journal_entries, nr) - 8usize];
};
impl Default for rust_journal_entries {
    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()
        }
    }
}
unsafe extern "C" {
    pub fn rust_collect_journal_entries(c: *mut bch_fs) -> rust_journal_entries;
}
unsafe extern "C" {
    pub fn rust_set_bit(nr: ::std::os::raw::c_ulong, addr: *mut ::std::os::raw::c_ulong);
}
unsafe extern "C" {
    pub fn rust_link_data(
        c: *mut bch_fs,
        dst_inum: __u64,
        sectors_delta: *mut __s64,
        logical: __u64,
        physical: __u64,
        length: __u64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    pub fn rust_accounting_mem_read(
        c: *mut bch_fs,
        p: bpos,
        v: *mut __u64,
        nr: ::std::os::raw::c_uint,
    );
}
unsafe extern "C" {
    pub fn rust_eytzinger_test() -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct kobj_ns_type_operations {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct device {
    pub _address: u8,
}
