sdk/lib/driver/runtime/rust/fdf_sys/src/bindings.rs

// Copyright 2024 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Generated by sdk/lib/driver/runtime/rust/fdf_sys/bindgen.sh using bindgen 0.72.0

#![allow(dead_code)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

use libasync_sys::*;
use zx_types::*;

pub const DRIVER_REGISTRATION_VERSION_1: u32 = 1;
pub const DRIVER_REGISTRATION_VERSION_MAX: u32 = 1;
pub type fdf_handle_t = zx_handle_t;
pub type fdf_txid_t = zx_txid_t;
#[repr(C)]
#[derive(Debug)]
pub struct fdf_arena {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct fdf_channel_call_args {
    pub wr_arena: *mut fdf_arena,
    pub wr_data: *mut ::core::ffi::c_void,
    pub wr_num_bytes: u32,
    pub wr_handles: *mut zx_handle_t,
    pub wr_num_handles: u32,
    pub rd_arena: *mut *mut fdf_arena,
    pub rd_data: *mut *mut ::core::ffi::c_void,
    pub rd_num_bytes: *mut u32,
    pub rd_handles: *mut *mut zx_handle_t,
    pub rd_num_handles: *mut u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fdf_channel_call_args"][::core::mem::size_of::<fdf_channel_call_args>() - 80usize];
    ["Alignment of fdf_channel_call_args"]
        [::core::mem::align_of::<fdf_channel_call_args>() - 8usize];
    ["Offset of field: fdf_channel_call_args::wr_arena"]
        [::core::mem::offset_of!(fdf_channel_call_args, wr_arena) - 0usize];
    ["Offset of field: fdf_channel_call_args::wr_data"]
        [::core::mem::offset_of!(fdf_channel_call_args, wr_data) - 8usize];
    ["Offset of field: fdf_channel_call_args::wr_num_bytes"]
        [::core::mem::offset_of!(fdf_channel_call_args, wr_num_bytes) - 16usize];
    ["Offset of field: fdf_channel_call_args::wr_handles"]
        [::core::mem::offset_of!(fdf_channel_call_args, wr_handles) - 24usize];
    ["Offset of field: fdf_channel_call_args::wr_num_handles"]
        [::core::mem::offset_of!(fdf_channel_call_args, wr_num_handles) - 32usize];
    ["Offset of field: fdf_channel_call_args::rd_arena"]
        [::core::mem::offset_of!(fdf_channel_call_args, rd_arena) - 40usize];
    ["Offset of field: fdf_channel_call_args::rd_data"]
        [::core::mem::offset_of!(fdf_channel_call_args, rd_data) - 48usize];
    ["Offset of field: fdf_channel_call_args::rd_num_bytes"]
        [::core::mem::offset_of!(fdf_channel_call_args, rd_num_bytes) - 56usize];
    ["Offset of field: fdf_channel_call_args::rd_handles"]
        [::core::mem::offset_of!(fdf_channel_call_args, rd_handles) - 64usize];
    ["Offset of field: fdf_channel_call_args::rd_num_handles"]
        [::core::mem::offset_of!(fdf_channel_call_args, rd_num_handles) - 72usize];
};
impl Default for fdf_channel_call_args {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type fdf_channel_call_args_t = fdf_channel_call_args;
pub const FDF_SCHEDULER_ROLE_OPTION_NO_SYNC_CALLS: u32 = 1;
pub const FDF_DISPATCHER_OPTION_SYNCHRONIZED: u32 = 0;
pub const FDF_DISPATCHER_OPTION_UNSYNCHRONIZED: u32 = 1;
pub const FDF_DISPATCHER_OPTION_ALLOW_SYNC_CALLS: u32 = 2;
pub const FDF_DISPATCHER_OPTION_NO_THREAD_MIGRATION: u32 = 4;
pub const FDF_DISPATCHER_OPTION_SYNCHRONIZATION_MASK: u32 = 1;
pub const FDF_CHANNEL_WAIT_OPTION_FORCE_ASYNC_CANCEL: u32 = 1;
pub type fdf_arena_t = fdf_arena;
pub type fdf_arena_tag_t = u32;
unsafe extern "C" {
    pub fn fdf_arena_create(
        options: u32,
        tag: fdf_arena_tag_t,
        out_arena: *mut *mut fdf_arena_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_arena_allocate(arena: *mut fdf_arena_t, bytes: usize) -> *mut ::core::ffi::c_void;
}
unsafe extern "C" {
    pub fn fdf_arena_free(arena: *mut fdf_arena_t, ptr: *mut ::core::ffi::c_void);
}
unsafe extern "C" {
    pub fn fdf_arena_contains(
        arena: *mut fdf_arena_t,
        ptr: *const ::core::ffi::c_void,
        num_bytes: usize,
    ) -> bool;
}
unsafe extern "C" {
    pub fn fdf_arena_add_ref(arena: *mut fdf_arena_t);
}
unsafe extern "C" {
    pub fn fdf_arena_drop_ref(arena: *mut fdf_arena_t);
}
#[repr(C)]
#[derive(Debug)]
pub struct fdf_dispatcher {
    _unused: [u8; 0],
}
pub type fdf_dispatcher_t = fdf_dispatcher;
pub type fdf_dispatcher_shutdown_observer_t = fdf_dispatcher_shutdown_observer;
pub type fdf_dispatcher_shutdown_handler_t = ::core::option::Option<
    unsafe extern "C" fn(
        dispatcher: *mut fdf_dispatcher_t,
        observer: *mut fdf_dispatcher_shutdown_observer_t,
    ),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fdf_dispatcher_shutdown_observer {
    pub handler: fdf_dispatcher_shutdown_handler_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fdf_dispatcher_shutdown_observer"]
        [::core::mem::size_of::<fdf_dispatcher_shutdown_observer>() - 8usize];
    ["Alignment of fdf_dispatcher_shutdown_observer"]
        [::core::mem::align_of::<fdf_dispatcher_shutdown_observer>() - 8usize];
    ["Offset of field: fdf_dispatcher_shutdown_observer::handler"]
        [::core::mem::offset_of!(fdf_dispatcher_shutdown_observer, handler) - 0usize];
};
unsafe extern "C" {
    pub fn fdf_dispatcher_create(
        options: u32,
        name: *const ::core::ffi::c_char,
        name_len: usize,
        scheduler_role: *const ::core::ffi::c_char,
        scheduler_role_len: usize,
        observer: *mut fdf_dispatcher_shutdown_observer_t,
        out_dispatcher: *mut *mut fdf_dispatcher_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_dispatcher_get_async_dispatcher(
        dispatcher: *mut fdf_dispatcher_t,
    ) -> *mut async_dispatcher_t;
}
unsafe extern "C" {
    pub fn fdf_dispatcher_downcast_async_dispatcher(
        async_dispatcher: *mut async_dispatcher_t,
    ) -> *mut fdf_dispatcher_t;
}
unsafe extern "C" {
    pub fn fdf_dispatcher_get_current_dispatcher() -> *mut fdf_dispatcher_t;
}
unsafe extern "C" {
    pub fn fdf_dispatcher_get_options(dispatcher: *const fdf_dispatcher_t) -> u32;
}
unsafe extern "C" {
    pub fn fdf_dispatcher_shutdown_async(dispatcher: *mut fdf_dispatcher_t);
}
unsafe extern "C" {
    pub fn fdf_dispatcher_destroy(dispatcher: *mut fdf_dispatcher_t);
}
unsafe extern "C" {
    pub fn fdf_dispatcher_seal(dispatcher: *mut fdf_dispatcher_t, option: u32) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_handle_close(handle: fdf_handle_t);
}
unsafe extern "C" {
    pub fn fdf_channel_create(
        options: u32,
        out0: *mut fdf_handle_t,
        out1: *mut fdf_handle_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_channel_write(
        channel: fdf_handle_t,
        options: u32,
        arena: *mut fdf_arena_t,
        data: *mut ::core::ffi::c_void,
        num_bytes: u32,
        handles: *mut zx_handle_t,
        num_handles: u32,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_channel_read(
        channel: fdf_handle_t,
        options: u32,
        out_arena: *mut *mut fdf_arena_t,
        out_data: *mut *mut ::core::ffi::c_void,
        out_num_bytes: *mut u32,
        out_handles: *mut *mut zx_handle_t,
        out_num_handles: *mut u32,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_channel_wait_async(
        dispatcher: *mut fdf_dispatcher,
        channel_read: *mut fdf_channel_read,
        options: u32,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_channel_cancel_wait(handle: fdf_handle_t) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_channel_call(
        handle: fdf_handle_t,
        options: u32,
        deadline: zx_time_t,
        args: *const fdf_channel_call_args_t,
    ) -> zx_status_t;
}
pub type fdf_channel_read_t = fdf_channel_read;
pub type fdf_channel_read_handler_t = ::core::option::Option<
    unsafe extern "C" fn(
        dispatcher: *mut fdf_dispatcher_t,
        read: *mut fdf_channel_read_t,
        status: zx_status_t,
    ),
>;
#[repr(C)]
pub struct fdf_channel_read {
    pub state: async_state_t,
    pub handler: fdf_channel_read_handler_t,
    pub channel: fdf_handle_t,
    pub options: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fdf_channel_read"][::core::mem::size_of::<fdf_channel_read>() - 32usize];
    ["Alignment of fdf_channel_read"][::core::mem::align_of::<fdf_channel_read>() - 8usize];
    ["Offset of field: fdf_channel_read::state"]
        [::core::mem::offset_of!(fdf_channel_read, state) - 0usize];
    ["Offset of field: fdf_channel_read::handler"]
        [::core::mem::offset_of!(fdf_channel_read, handler) - 16usize];
    ["Offset of field: fdf_channel_read::channel"]
        [::core::mem::offset_of!(fdf_channel_read, channel) - 24usize];
    ["Offset of field: fdf_channel_read::options"]
        [::core::mem::offset_of!(fdf_channel_read, options) - 28usize];
};
impl Default for fdf_channel_read {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl ::core::fmt::Debug for fdf_channel_read {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        write!(f, "fdf_channel_read {{ handler: {:?} }}", self.handler)
    }
}
pub type fdf_env_driver_shutdown_observer_t = fdf_env_driver_shutdown_observer;
pub type fdf_env_driver_shutdown_handler_t = ::core::option::Option<
    unsafe extern "C" fn(
        driver: *const ::core::ffi::c_void,
        observer: *mut fdf_env_driver_shutdown_observer_t,
    ),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fdf_env_driver_shutdown_observer {
    pub handler: fdf_env_driver_shutdown_handler_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fdf_env_driver_shutdown_observer"]
        [::core::mem::size_of::<fdf_env_driver_shutdown_observer>() - 8usize];
    ["Alignment of fdf_env_driver_shutdown_observer"]
        [::core::mem::align_of::<fdf_env_driver_shutdown_observer>() - 8usize];
    ["Offset of field: fdf_env_driver_shutdown_observer::handler"]
        [::core::mem::offset_of!(fdf_env_driver_shutdown_observer, handler) - 0usize];
};
pub type fdf_env_stall_scanner_t = fdf_env_stall_scanner;
pub type fdf_env_stall_scan_begin = ::core::option::Option<
    unsafe extern "C" fn(scanner: *mut fdf_env_stall_scanner_t, duration: zx_duration_mono_t),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fdf_env_stall_scanner {
    pub handler: fdf_env_stall_scan_begin,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fdf_env_stall_scanner"][::core::mem::size_of::<fdf_env_stall_scanner>() - 8usize];
    ["Alignment of fdf_env_stall_scanner"]
        [::core::mem::align_of::<fdf_env_stall_scanner>() - 8usize];
    ["Offset of field: fdf_env_stall_scanner::handler"]
        [::core::mem::offset_of!(fdf_env_stall_scanner, handler) - 0usize];
};
unsafe extern "C" {
    pub fn fdf_env_start(options: u32) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_env_reset();
}
unsafe extern "C" {
    pub fn fdf_env_dispatcher_create_with_owner(
        driver: *const ::core::ffi::c_void,
        options: u32,
        name: *const ::core::ffi::c_char,
        name_len: usize,
        scheduler_role: *const ::core::ffi::c_char,
        scheduler_role_len: usize,
        observer: *mut fdf_dispatcher_shutdown_observer_t,
        out_dispatcher: *mut *mut fdf_dispatcher_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_env_dispatcher_dump(dispatcher: *mut fdf_dispatcher_t);
}
unsafe extern "C" {
    pub fn fdf_env_dispatcher_get_dump_deprecated(
        dispatcher: *mut fdf_dispatcher_t,
        out_dump: *mut *mut ::core::ffi::c_char,
    );
}
unsafe extern "C" {
    pub fn fdf_env_shutdown_dispatchers_async(
        driver: *const ::core::ffi::c_void,
        observer: *mut fdf_env_driver_shutdown_observer_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_env_destroy_all_dispatchers();
}
unsafe extern "C" {
    pub fn fdf_env_register_driver_entry(driver: *const ::core::ffi::c_void);
}
unsafe extern "C" {
    pub fn fdf_env_register_driver_exit();
}
unsafe extern "C" {
    pub fn fdf_env_get_current_driver() -> *const ::core::ffi::c_void;
}
unsafe extern "C" {
    pub fn fdf_env_dispatcher_has_queued_tasks(dispatcher: *mut fdf_dispatcher_t) -> bool;
}
unsafe extern "C" {
    pub fn fdf_env_get_thread_limit(
        scheduler_role: *const ::core::ffi::c_char,
        scheduler_role_len: usize,
    ) -> u32;
}
unsafe extern "C" {
    pub fn fdf_env_set_thread_limit(
        scheduler_role: *const ::core::ffi::c_char,
        scheduler_role_len: usize,
        max_threads: u32,
    ) -> zx_status_t;
}
unsafe extern "C" {
    #[doc = " Returns the currently set options for the scheduler role as a uint32_t bitmask."]
    pub fn fdf_env_get_scheduler_role_opts(
        scheduler_role: *const ::core::ffi::c_char,
        scheduler_role_len: usize,
    ) -> u32;
}
unsafe extern "C" {
    pub fn fdf_env_set_scheduler_role_opts(
        scheduler_role: *const ::core::ffi::c_char,
        scheduler_role_len: usize,
        options: u32,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_env_add_allowed_scheduler_role_for_driver(
        driver: *const ::core::ffi::c_void,
        role: *const ::core::ffi::c_char,
        role_length: usize,
    );
}
unsafe extern "C" {
    pub fn fdf_env_get_driver_on_tid(
        tid: zx_koid_t,
        out_driver: *mut *const ::core::ffi::c_void,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_env_scan_threads_for_stalls();
}
unsafe extern "C" {
    pub fn fdf_env_scan_threads_for_stalls2() -> zx_duration_mono_t;
}
unsafe extern "C" {
    pub fn fdf_env_register_stall_scanner(scanner: *mut fdf_env_stall_scanner_t);
}
unsafe extern "C" {
    pub fn fdf_testing_create_unmanaged_dispatcher(
        driver: *const ::core::ffi::c_void,
        options: u32,
        name: *const ::core::ffi::c_char,
        name_len: usize,
        observer: *mut fdf_dispatcher_shutdown_observer_t,
        out_dispatcher: *mut *mut fdf_dispatcher_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_testing_set_default_dispatcher(dispatcher: *mut fdf_dispatcher_t) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_testing_run(deadline: zx_time_t, once: bool) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_testing_run_until_idle() -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_testing_quit();
}
unsafe extern "C" {
    pub fn fdf_testing_reset_quit() -> zx_status_t;
}
pub type fdf_token_t = fdf_token;
pub type fdf_token_transfer_handler_t = ::core::option::Option<
    unsafe extern "C" fn(
        dispatcher: *mut fdf_dispatcher_t,
        token: *mut fdf_token_t,
        status: zx_status_t,
        handle: fdf_handle_t,
    ),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fdf_token {
    pub handler: fdf_token_transfer_handler_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of fdf_token"][::core::mem::size_of::<fdf_token>() - 8usize];
    ["Alignment of fdf_token"][::core::mem::align_of::<fdf_token>() - 8usize];
    ["Offset of field: fdf_token::handler"][::core::mem::offset_of!(fdf_token, handler) - 0usize];
};
unsafe extern "C" {
    pub fn fdf_token_register(
        token: zx_handle_t,
        dispatcher: *mut fdf_dispatcher_t,
        handler: *mut fdf_token_t,
    ) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_token_receive(token: zx_handle_t, handle: *mut fdf_handle_t) -> zx_status_t;
}
unsafe extern "C" {
    pub fn fdf_token_transfer(token: zx_handle_t, handle: fdf_handle_t) -> zx_status_t;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct DriverRegistration {
    pub version: u64,
    pub v1: DriverRegistration_driver_registration_v1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct DriverRegistration_driver_registration_v1 {
    pub initialize: ::core::option::Option<
        unsafe extern "C" fn(server_handle: fdf_handle_t) -> *mut ::core::ffi::c_void,
    >,
    pub destroy: ::core::option::Option<unsafe extern "C" fn(token: *mut ::core::ffi::c_void)>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of DriverRegistration_driver_registration_v1"]
        [::core::mem::size_of::<DriverRegistration_driver_registration_v1>() - 16usize];
    ["Alignment of DriverRegistration_driver_registration_v1"]
        [::core::mem::align_of::<DriverRegistration_driver_registration_v1>() - 8usize];
    ["Offset of field: DriverRegistration_driver_registration_v1::initialize"]
        [::core::mem::offset_of!(DriverRegistration_driver_registration_v1, initialize) - 0usize];
    ["Offset of field: DriverRegistration_driver_registration_v1::destroy"]
        [::core::mem::offset_of!(DriverRegistration_driver_registration_v1, destroy) - 8usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of DriverRegistration"][::core::mem::size_of::<DriverRegistration>() - 24usize];
    ["Alignment of DriverRegistration"][::core::mem::align_of::<DriverRegistration>() - 8usize];
    ["Offset of field: DriverRegistration::version"]
        [::core::mem::offset_of!(DriverRegistration, version) - 0usize];
    ["Offset of field: DriverRegistration::v1"]
        [::core::mem::offset_of!(DriverRegistration, v1) - 8usize];
};