magma/

magma.rs

/* automatically generated by rust-bindgen 0.72.0 */

// Copyright 2021 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.

use zerocopy::{FromBytes, Immutable, IntoBytes};

pub const MAGMA_DEVICE_NAMESPACE: &[u8; 1] = b"\0";
pub const MAGMA_API_VERSION: u32 = 14;
pub const MAGMA_VENDOR_ID_MALI: u32 = 5045;
pub const MAGMA_VENDOR_ID_INTEL: u32 = 32902;
pub type magma_log_severity_t = i8;
pub type magma_query_t = u64;
pub type magma_status_t = i32;
pub type magma_cache_operation_t = u32;
pub type magma_cache_policy_t = u32;
pub type magma_format_t = u32;
pub type magma_format_modifier_t = u64;
pub type magma_colorspace_t = u32;
pub type magma_coherency_domain_t = u32;
pub type magma_buffer_range_op_t = u32;
pub type magma_bool_t = u8;
pub type magma_device_t = u64;
pub type magma_buffer_t = u64;
pub type magma_semaphore_t = u64;
pub type magma_perf_count_pool_t = u64;
pub type magma_connection_t = u64;
pub type magma_sysmem_connection_t = u64;
pub type magma_handle_t = u32;
pub type magma_buffer_id_t = u64;
pub type magma_semaphore_id_t = u64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct magma_poll_item {
    pub __bindgen_anon_1: magma_poll_item__bindgen_ty_1,
    pub type_: u32,
    pub condition: u32,
    pub result: u32,
    pub unused: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union magma_poll_item__bindgen_ty_1 {
    pub semaphore: magma_semaphore_t,
    pub handle: magma_handle_t,
}
impl Default for magma_poll_item__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        #[allow(
            clippy::undocumented_unsafe_blocks,
            reason = "Force documented unsafe blocks in Starnix"
        )]
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for magma_poll_item {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        #[allow(
            clippy::undocumented_unsafe_blocks,
            reason = "Force documented unsafe blocks in Starnix"
        )]
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type magma_poll_item_t = magma_poll_item;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_exec_resource {
    pub buffer_id: magma_buffer_id_t,
    pub offset: u64,
    pub length: u64,
}
pub type magma_exec_resource_t = magma_exec_resource;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_exec_command_buffer {
    pub resource_index: u32,
    pub unused: u32,
    pub start_offset: u64,
}
pub type magma_exec_command_buffer_t = magma_exec_command_buffer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct magma_command_descriptor {
    pub resource_count: u32,
    pub command_buffer_count: u32,
    pub wait_semaphore_count: u32,
    pub signal_semaphore_count: u32,
    pub resources: *mut magma_exec_resource,
    pub command_buffers: *mut magma_exec_command_buffer,
    pub semaphore_ids: *mut u64,
    pub flags: u64,
}
impl Default for magma_command_descriptor {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        #[allow(
            clippy::undocumented_unsafe_blocks,
            reason = "Force documented unsafe blocks in Starnix"
        )]
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type magma_command_descriptor_t = magma_command_descriptor;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct magma_inline_command_buffer {
    pub data: *mut ::std::os::raw::c_void,
    pub size: u64,
    pub semaphore_ids: *mut u64,
    pub semaphore_count: u32,
    pub __bindgen_padding_0: [u8; 4usize],
}
impl Default for magma_inline_command_buffer {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        #[allow(
            clippy::undocumented_unsafe_blocks,
            reason = "Force documented unsafe blocks in Starnix"
        )]
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type magma_inline_command_buffer_t = magma_inline_command_buffer;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_total_time_query_result {
    pub gpu_time_ns: u64,
    pub monotonic_time_ns: u64,
}
pub type magma_total_time_query_result_t = magma_total_time_query_result;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_buffer_offset {
    pub buffer_id: u64,
    pub offset: u64,
    pub length: u64,
}
pub type magma_buffer_offset_t = magma_buffer_offset;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_buffer_info {
    pub committed_byte_count: u64,
    pub size: u64,
}
pub type magma_buffer_info_t = magma_buffer_info;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_image_create_info {
    pub drm_format: u64,
    pub drm_format_modifiers: [u64; 16usize],
    pub width: u32,
    pub height: u32,
    pub flags: u64,
}
pub type magma_image_create_info_t = magma_image_create_info;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct magma_image_info {
    pub plane_strides: [u64; 4usize],
    pub plane_offsets: [u32; 4usize],
    pub drm_format_modifier: u64,
    pub coherency_domain: u32,
    pub unused: u32,
}
pub type magma_image_info_t = magma_image_info;
pub type magma_priority_t = u64;
unsafe extern "C" {
    #[doc = "\n \\brief Imports and takes ownership of a channel to a device. Takes ownership of |device_channel|\n        on both success and failure.\n \\param device_channel A channel connecting to a gpu class device.\n \\param device_out Returned device.\n"]
    pub fn magma_device_import(
        device_channel: magma_handle_t,
        device_out: *mut magma_device_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases a handle to a device\n \\param device An open device.\n"]
    pub fn magma_device_release(device: magma_device_t);
}
unsafe extern "C" {
    #[doc = "\n \\brief Returns information describing the magma devices that are available. NOTE - this is\n        appropriate for use only if devices are guaranteed to be present at the time the call is\n        made. On Fuchsia, this guarantee is provided by the loader design for Vulkan ICDs. Other\n        asynchronous environments may require a directory watcher mechanism to handle racy\n        startup conditions. Returns: MAGMA_STATUS_MEMORY_ERROR if |device_count_inout| is\n        insufficient; MAGMA_STATUS_INVALID_ARGS if |device_path_size| is insufficient.\n \\param device_namespace Namespace corresponding to the |device_directory_channel|; this should\n        be MAGMA_DEVICE_NAMESPACE.  Used only on Fuchsia.\n \\param device_directory_channel Channel used for reading devices from |device_namespace|.  Used\n        only on Fuchsia.\n \\param device_count_inout The number of array elements in |device_paths_out|. On success, will\n        be set to the number of elements written.\n \\param device_path_size Size of each entry in |device_paths_out|.  PATH_MAX should be\n        sufficient.\n \\param device_paths_out Pointer to storage for magma device paths.  The buffer's size in bytes\n        should be |*device_count_inout| * |device_path_size|.\n"]
    pub fn magma_enumerate_devices(
        device_namespace: *const ::std::os::raw::c_char,
        device_directory_channel: magma_handle_t,
        device_count_inout: *mut u32,
        device_path_size: u32,
        device_paths_out: *mut ::std::os::raw::c_char,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Performs a query synchronously. On MAGMA_STATUS_OK, a given query |id| will return either\n        a buffer in |result_buffer_out|, or a value in |result_out|. A NULL pointer may be\n        provided for whichever result parameter is not needed.\n \\param device An open device.\n \\param id A vendor-specific ID.\n \\param result_buffer_out Handle to the returned buffer.\n \\param result_out Pointer to a uint64 result.\n"]
    pub fn magma_device_query(
        device: magma_device_t,
        id: u64,
        result_buffer_out: *mut magma_handle_t,
        result_out: *mut u64,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Opens a connection to a device.\n \\param device An open device\n \\param connection_out Returned connection.\n"]
    pub fn magma_device_create_connection(
        device: magma_device_t,
        connection_out: *mut magma_connection_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases the given connection.\n \\param connection An open connection.\n"]
    pub fn magma_connection_release(connection: magma_connection_t);
}
unsafe extern "C" {
    #[doc = "\n \\brief If a system driver error occurs, the connection will be closed, and this interface will\n        eventually return the error. This interface does not flush messages that may be pending\n        (see magma_connection_flush).\n \\param connection An open connection.\n"]
    pub fn magma_connection_get_error(connection: magma_connection_t) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Creates a context on the given connection.\n \\param connection An open connection.\n \\param context_id_out The returned context id.\n"]
    pub fn magma_connection_create_context(
        connection: magma_connection_t,
        context_id_out: *mut u32,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases the context associated with the given id.\n \\param connection An open connection.\n \\param context_id A valid context id.\n"]
    pub fn magma_connection_release_context(connection: magma_connection_t, context_id: u32);
}
unsafe extern "C" {
    #[doc = "\n \\brief Creates a memory buffer of at least the given size.\n \\param connection An open connection.\n \\param size Requested buffer size.\n \\param size_out The returned buffer's actual size.\n \\param buffer_out The returned buffer.\n \\param id_out The buffer id of the buffer.\n"]
    pub fn magma_connection_create_buffer(
        connection: magma_connection_t,
        size: u64,
        size_out: *mut u64,
        buffer_out: *mut magma_buffer_t,
        id_out: *mut magma_buffer_id_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases the given memory buffer.\n \\param connection An open connection.\n \\param buffer A valid buffer.\n"]
    pub fn magma_connection_release_buffer(connection: magma_connection_t, buffer: magma_buffer_t);
}
unsafe extern "C" {
    #[doc = "\n \\brief Imports and takes ownership of the buffer referred to by the given handle. Takes\n        ownership of |buffer_handle| on both success and failure.\n \\param connection An open connection.\n \\param buffer_handle A valid handle.\n \\param size_out The size of the buffer in bytes.\n \\param buffer_out The returned buffer.\n \\param id_out The buffer id of the buffer.\n"]
    pub fn magma_connection_import_buffer(
        connection: magma_connection_t,
        buffer_handle: magma_handle_t,
        size_out: *mut u64,
        buffer_out: *mut magma_buffer_t,
        id_out: *mut magma_buffer_id_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Creates a semaphore.\n \\param connection An open connection.\n \\param semaphore_out The returned semaphore.\n \\param id_out The id of the semaphore.\n"]
    pub fn magma_connection_create_semaphore(
        connection: magma_connection_t,
        semaphore_out: *mut magma_semaphore_t,
        id_out: *mut magma_semaphore_id_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases the given semaphore.\n \\param connection An open connection.\n \\param semaphore A valid semaphore.\n"]
    pub fn magma_connection_release_semaphore(
        connection: magma_connection_t,
        semaphore: magma_semaphore_t,
    );
}
unsafe extern "C" {
    #[doc = "\n \\brief Imports and takes ownership of the semaphore referred to by the given handle. Takes\n        ownership of |semaphore_handle| on both success and failure.\n \\param connection An open connection.\n \\param semaphore_handle A valid semaphore handle.\n \\param flags Pass MAGMA_IMPORT_SEMAPHORE_ONESHOT to prevent auto-reset after wait.\n \\param semaphore_out The returned semaphore.\n \\param id_out The id of the semaphore.\n"]
    pub fn magma_connection_import_semaphore2(
        connection: magma_connection_t,
        semaphore_handle: magma_handle_t,
        flags: u64,
        semaphore_out: *mut magma_semaphore_t,
        id_out: *mut magma_semaphore_id_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Perform an operation on a range of a buffer\n \\param connection An open connection.\n \\param buffer A valid buffer.\n \\param options Options for the operation.\n \\param start_offset Byte offset into the buffer.\n \\param length Length (in bytes) of the region to operate on.\n"]
    pub fn magma_connection_perform_buffer_op(
        connection: magma_connection_t,
        buffer: magma_buffer_t,
        options: u32,
        start_offset: u64,
        length: u64,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Maps a buffer range onto the hardware in the connection's address space at the given\n        address. Depending on the MSD this may automatically commit and populate that range.\n \\param connection An open connection.\n \\param hw_va Destination virtual address for the mapping.\n \\param buffer A valid buffer.\n \\param offset Offset into the buffer.\n \\param length Length in bytes of the range to map.\n \\param map_flags A valid MAGMA_MAP_FLAGS value.\n"]
    pub fn magma_connection_map_buffer(
        connection: magma_connection_t,
        hw_va: u64,
        buffer: magma_buffer_t,
        offset: u64,
        length: u64,
        map_flags: u64,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases the mapping at the given hardware address.\n \\param connection An open connection.\n \\param hw_va A hardware virtual address associated with an existing mapping of the given buffer.\n \\param buffer A valid buffer.\n"]
    pub fn magma_connection_unmap_buffer(
        connection: magma_connection_t,
        hw_va: u64,
        buffer: magma_buffer_t,
    );
}
unsafe extern "C" {
    #[doc = "\n \\brief Submits command buffers for execution on the hardware.\n \\param connection An open connection.\n \\param context_id A valid context id.\n \\param descriptor A pointer to the command descriptor.\n"]
    pub fn magma_connection_execute_command(
        connection: magma_connection_t,
        context_id: u32,
        descriptor: *mut magma_command_descriptor_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Submits a series of commands for execution on the hardware without using a command\n        buffer.\n \\param connection An open connection.\n \\param context_id A valid context ID.\n \\param command_count The number of commands in the provided buffer.\n \\param command_buffers An array of command_count magma_inline_command_buffer structs.\n"]
    pub fn magma_connection_execute_inline_commands(
        connection: magma_connection_t,
        context_id: u32,
        command_count: u64,
        command_buffers: *mut magma_inline_command_buffer_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Incurs a round-trip to the system driver, used to ensure all previous messages have been\n        observed, but not necessarily completed.  If a system driver error occurs, the connection\n        will be closed, and this interface will return the error.\n \\param connection An open connection.\n"]
    pub fn magma_connection_flush(connection: magma_connection_t) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Returns a handle that can be waited on to determine when the connection has data in the\n        notification channel. This channel has the same lifetime as the connection and must not\n        be closed by the client.\n \\param connection An open connection.\n"]
    pub fn magma_connection_get_notification_channel_handle(
        connection: magma_connection_t,
    ) -> magma_handle_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Reads a notification from the channel into the given buffer.  Message sizes may vary\n        depending on the MSD.  If the buffer provided is too small for the message,\n        MAGMA_STATUS_INVALID_ARGS will be returned and the size of message will be returned in\n        the buffer_size_out parameter.\n \\param connection An open connection.\n \\param buffer Buffer into which to read notification data.\n \\param buffer_size Size of the given buffer.\n \\param buffer_size_out Returned size of the notification data written to the buffer, or 0 if\n        there are no messages pending.\n \\param more_data_out True if there is more notification data waiting.\n"]
    pub fn magma_connection_read_notification_channel(
        connection: magma_connection_t,
        buffer: *mut ::std::os::raw::c_void,
        buffer_size: u64,
        buffer_size_out: *mut u64,
        more_data_out: *mut magma_bool_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Cleans, and optionally invalidates, the cache for the region of memory specified by the\n        given buffer, offset, and size, and write the contents to ram.\n \\param buffer A valid buffer.\n \\param offset An offset into the buffer. Must be less than or equal to the buffer's size.\n \\param size Size of region to be cleaned. Offset + size must be less than or equal to the\n        buffer's size.\n \\param operation One of MAGMA_CACHE_OPERATION_CLEAN or MAGMA_CACHE_OPERATION_CLEAN_INVALIDATE.\n"]
    pub fn magma_buffer_clean_cache(
        buffer: magma_buffer_t,
        offset: u64,
        size: u64,
        operation: magma_cache_operation_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Configures the cache for the given buffer.\n \\param buffer A valid buffer.\n \\param policy One of MAGMA_CACHE_POLICY_[CACHED|WRITE_COMBINING|UNCACHED].\n"]
    pub fn magma_buffer_set_cache_policy(
        buffer: magma_buffer_t,
        policy: magma_cache_policy_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Queries the cache policy for a buffer.\n \\param buffer A valid buffer.\n \\param cache_policy_out The returned cache policy.\n"]
    pub fn magma_buffer_get_cache_policy(
        buffer: magma_buffer_t,
        cache_policy_out: *mut magma_cache_policy_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Sets a name for the buffer for use in debugging tools.\n \\param buffer A valid buffer.\n \\param name The 0-terminated name of the buffer. May be truncated.\n"]
    pub fn magma_buffer_set_name(
        buffer: magma_buffer_t,
        name: *const ::std::os::raw::c_char,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Get information on a magma buffer\n \\param buffer A valid buffer.\n \\param info_out Pointer to struct that receives the buffer info.\n"]
    pub fn magma_buffer_get_info(
        buffer: magma_buffer_t,
        info_out: *mut magma_buffer_info_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Gets a platform handle for the given buffer. This can be used to perform a CPU mapping of\n        the buffer using the standard syscall.  The handle may be released without invalidating\n        such CPU mappings.\n \\param buffer A valid buffer.\n \\param handle_out Pointer to the returned handle.\n"]
    pub fn magma_buffer_get_handle(
        buffer: magma_buffer_t,
        handle_out: *mut magma_handle_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Exports the given buffer, returning a handle that may be imported into a connection.\n \\param buffer A valid buffer.\n \\param buffer_handle_out The returned handle.\n"]
    pub fn magma_buffer_export(
        buffer: magma_buffer_t,
        buffer_handle_out: *mut magma_handle_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Signals the given semaphore.\n \\param semaphore A valid semaphore.\n"]
    pub fn magma_semaphore_signal(semaphore: magma_semaphore_t);
}
unsafe extern "C" {
    #[doc = "\n \\brief Resets the given semaphore.\n \\param semaphore A valid semaphore.\n"]
    pub fn magma_semaphore_reset(semaphore: magma_semaphore_t);
}
unsafe extern "C" {
    #[doc = "\n \\brief Exports the given semaphore, returning a handle that may be imported into a connection\n \\param semaphore A valid semaphore.\n \\param semaphore_handle_out The returned handle.\n"]
    pub fn magma_semaphore_export(
        semaphore: magma_semaphore_t,
        semaphore_handle_out: *mut magma_handle_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Waits for at least one of the given items to meet a condition. Does not reset any\n        semaphores. When MAGMA_STATUS_OK is returned, results are returned in the items array.\n        MAGMA_STATUS_TIMED_OUT is returned if no conditions are met before the given timeout\n        expires. If the notification channel handle is included in the item list, and the magma\n        connection is closed, then MAGMA_STATUS_CONNECTION_LOST is returned.\n \\param items Array of poll items. Type should be either MAGMA_POLL_TYPE_SEMAPHORE or\n        MAGMA_POLL_TYPE_HANDLE. Condition may be set to MAGMA_POLL_CONDITION_SIGNALED OR\n        MAGMA_POLL_CONDITION_READABLE. If condition is 0 the item is ignored. Item results are\n        set to the condition that was satisfied, otherwise 0. If the same item is given twice the\n        behavior is undefined.\n \\param count Number of poll items in the array.\n \\param timeout_ns Time in ns to wait before returning MAGMA_STATUS_TIMED_OUT.\n"]
    pub fn magma_poll(items: *mut magma_poll_item_t, count: u32, timeout_ns: u64)
    -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Initializes tracing. This should be called on Fuchsia; on other platforms it's not needed\n        and will just close the given handle.\n \\param channel An open connection to a tracing provider.\n"]
    pub fn magma_initialize_tracing(channel: magma_handle_t) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Initializes logging, used for debug and some exceptional error reporting. This should be\n        called on Fuchsia; on other platforms it's not needed and will just close the given\n        handle.\n \\param channel An open connection to the syslog service.\n"]
    pub fn magma_initialize_logging(channel: magma_handle_t) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Tries to enable access to performance counters. Returns MAGMA_STATUS_OK if counters were\n        successfully enabled or MAGMA_STATUS_ACCESS_DENIED if channel is for the wrong device and\n        counters were not successfully enabled previously.\n \\param connection An open connection to a device.\n \\param channel A handle to a channel to a gpu-performance-counter device.\n"]
    pub fn magma_connection_enable_performance_counter_access(
        connection: magma_connection_t,
        channel: magma_handle_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Enables a set of performance counters (the precise definition depends on the driver).\n        Disables enabled performance counters that are not in the new set. Performance counters\n        will also be automatically disabled on connection close. Performance counter access must\n        have been enabled using magma_connection_enable_performance_counter_access before calling\n        this method.\n \\param connection An open connection to a device.\n \\param counters An implementation-defined list of counters.\n \\param counters_count The number of entries in |counters|.\n"]
    pub fn magma_connection_enable_performance_counters(
        connection: magma_connection_t,
        counters: *mut u64,
        counters_count: u64,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Create a pool of buffers that performance counters can be dumped into. Performance\n        counter access must have been enabled using\n        magma_connection_enable_performance_counter_access before calling this method.\n \\param connection An open connection to a device.\n \\param pool_id_out A new pool id. Must not currently be in use.\n \\param notification_handle_out A handle that should be waited on.\n"]
    pub fn magma_connection_create_performance_counter_buffer_pool(
        connection: magma_connection_t,
        pool_id_out: *mut magma_perf_count_pool_t,
        notification_handle_out: *mut magma_handle_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Releases a pool of performance counter buffers. Performance counter access must have been\n        enabled using magma_connection_enable_performance_counter_access before calling this\n        method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool id.\n"]
    pub fn magma_connection_release_performance_counter_buffer_pool(
        connection: magma_connection_t,
        pool_id: magma_perf_count_pool_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Adds a an array of buffers + offset to the pool. |offsets[n].buffer_id| is the koid of a\n        buffer that was previously imported using ImportBuffer(). The same buffer may be added to\n        multiple pools. The pool will hold on to a reference to the buffer even after\n        ReleaseBuffer is called.  When dumped into this entry, counters will be written starting\n        at |offsets[n].offset| bytes into the buffer, and up to |offsets[n].offset| +\n        |offsets[n].size|. |offsets[n].size| must be large enough to fit all enabled counters.\n        Performance counter access must have been enabled using\n        magma_connection_enable_performance_counter_access before calling this method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool.\n \\param offsets An array of offsets to add.\n \\param offsets_count The number of elements in offsets.\n"]
    pub fn magma_connection_add_performance_counter_buffer_offsets_to_pool(
        connection: magma_connection_t,
        pool_id: magma_perf_count_pool_t,
        offsets: *const magma_buffer_offset_t,
        offsets_count: u64,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Removes every offset of a buffer from the pool. Performance counter access must have been\n        enabled using magma_connection_enable_performance_counter_access before calling this\n        method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool.\n \\param buffer A magma_buffer\n"]
    pub fn magma_connection_remove_performance_counter_buffer_from_pool(
        connection: magma_connection_t,
        pool_id: magma_perf_count_pool_t,
        buffer: magma_buffer_t,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Triggers dumping of the performance counters into a buffer pool. May fail silently if\n        there are no buffers in the pool. |trigger_id| is an arbitrary ID assigned by the client\n        that can be returned in OnPerformanceCounterReadCompleted. Performance counter access\n        must have been enabled using magma_connection_enable_performance_counter_access before\n        calling this method.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool\n \\param trigger_id An arbitrary ID assigned by the client that will be returned in\n        OnPerformanceCounterReadCompleted.\n"]
    pub fn magma_connection_dump_performance_counters(
        connection: magma_connection_t,
        pool_id: magma_perf_count_pool_t,
        trigger_id: u32,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Sets the values of all listed performance counters to 0. May not be supported by some\n        hardware. Performance counter access must have been enabled using\n        magma_connection_enable_performance_counter_access before calling this method.\n \\param connection An open connection to a device.\n \\param counters An implementation-defined list of counters.\n \\param counters_count The number of entries in |counters|.\n"]
    pub fn magma_connection_clear_performance_counters(
        connection: magma_connection_t,
        counters: *mut u64,
        counters_count: u64,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Reads one performance counter completion event, if available.\n \\param connection An open connection to a device.\n \\param pool_id An existing pool.\n \\param trigger_id_out The trigger ID for this event.\n \\param buffer_id_out The buffer ID for this event.\n \\param buffer_offset_out The buffer offset for this event.\n \\param time_out The monotonic time this event happened.\n \\param result_flags_out A set of flags giving more information about this event.\n"]
    pub fn magma_connection_read_performance_counter_completion(
        connection: magma_connection_t,
        pool_id: magma_perf_count_pool_t,
        trigger_id_out: *mut u32,
        buffer_id_out: *mut u64,
        buffer_offset_out: *mut u32,
        time_out: *mut u64,
        result_flags_out: *mut u32,
    ) -> magma_status_t;
}
unsafe extern "C" {
    #[doc = "\n \\brief Creates a context on the given connection.\n \\param connection An open connection.\n \\param priority The priority of the connection. Higher numbers are higher priorities.\n \\param context_id_out The returned context id.\n"]
    pub fn magma_connection_create_context2(
        connection: magma_connection_t,
        priority: magma_priority_t,
        context_id_out: *mut u32,
    ) -> magma_status_t;
}
pub type __u32 = ::std::os::raw::c_uint;
pub type __u64 = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtmagma_ioctl_args_handshake {
    pub handshake_inout: __u32,
    pub version_out: __u32,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtmagma_ioctl_args_magma_command {
    pub request_address: __u64,
    pub request_size: __u64,
    pub response_address: __u64,
    pub response_size: __u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtmagma_command_descriptor {
    pub descriptor_size: __u64,
    pub descriptor: __u64,
    pub resource_size: __u64,
    pub resources: __u64,
    pub command_buffer_size: __u64,
    pub command_buffers: __u64,
    pub semaphore_size: __u64,
    pub semaphores: __u64,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtmagma_buffer_set_name_wrapper {
    pub name_address: __u64,
    pub name_size: __u64,
}
pub const MAGMA_QUERY_VENDOR_ID: magma_query_t = 0;
pub const MAGMA_QUERY_DEVICE_ID: magma_query_t = 1;
pub const MAGMA_QUERY_VENDOR_VERSION: magma_query_t = 2;
pub const MAGMA_QUERY_IS_TOTAL_TIME_SUPPORTED: magma_query_t = 3;
pub const MAGMA_QUERY_MAXIMUM_INFLIGHT_PARAMS: magma_query_t = 5;
pub const MAGMA_QUERY_VENDOR_PARAM_0: magma_query_t = 10000;
pub const MAGMA_QUERY_TOTAL_TIME: magma_query_t = 500;
pub const MAGMA_INVALID_OBJECT_ID: u64 = 0;
pub const MAGMA_COMMAND_BUFFER_VENDOR_FLAGS_0: u64 = 65536;
pub const MAGMA_STATUS_OK: magma_status_t = 0;
pub const MAGMA_STATUS_INTERNAL_ERROR: magma_status_t = -1;
pub const MAGMA_STATUS_INVALID_ARGS: magma_status_t = -2;
pub const MAGMA_STATUS_ACCESS_DENIED: magma_status_t = -3;
pub const MAGMA_STATUS_MEMORY_ERROR: magma_status_t = -4;
pub const MAGMA_STATUS_CONTEXT_KILLED: magma_status_t = -5;
pub const MAGMA_STATUS_CONNECTION_LOST: magma_status_t = -6;
pub const MAGMA_STATUS_TIMED_OUT: magma_status_t = -7;
pub const MAGMA_STATUS_UNIMPLEMENTED: magma_status_t = -8;
pub const MAGMA_STATUS_BAD_STATE: magma_status_t = -9;
pub const MAGMA_STATUS_CONSTRAINTS_INTERSECTION_EMPTY: magma_status_t = -10;
pub const MAGMA_STATUS_TOO_MANY_GROUP_CHILD_COMBINATIONS: magma_status_t = -11;
pub const MAGMA_CACHE_OPERATION_CLEAN: magma_cache_operation_t = 0;
pub const MAGMA_CACHE_OPERATION_CLEAN_INVALIDATE: magma_cache_operation_t = 1;
pub const MAGMA_CACHE_POLICY_CACHED: magma_cache_policy_t = 0;
pub const MAGMA_CACHE_POLICY_WRITE_COMBINING: magma_cache_policy_t = 1;
pub const MAGMA_CACHE_POLICY_UNCACHED: magma_cache_policy_t = 2;
pub const MAGMA_DUMP_TYPE_NORMAL: u32 = 1;
pub const MAGMA_PERF_COUNTER_RESULT_DISCONTINUITY: u32 = 1;
pub const MAGMA_IMPORT_SEMAPHORE_ONE_SHOT: u64 = 1;
pub const MAGMA_FORMAT_INVALID: magma_format_t = 0;
pub const MAGMA_FORMAT_R8G8B8A8: magma_format_t = 1;
pub const MAGMA_FORMAT_BGRA32: magma_format_t = 101;
pub const MAGMA_FORMAT_I420: magma_format_t = 102;
pub const MAGMA_FORMAT_M420: magma_format_t = 103;
pub const MAGMA_FORMAT_NV12: magma_format_t = 104;
pub const MAGMA_FORMAT_YUY2: magma_format_t = 105;
pub const MAGMA_FORMAT_MJPEG: magma_format_t = 106;
pub const MAGMA_FORMAT_YV12: magma_format_t = 107;
pub const MAGMA_FORMAT_BGR24: magma_format_t = 108;
pub const MAGMA_FORMAT_RGB565: magma_format_t = 109;
pub const MAGMA_FORMAT_RGB332: magma_format_t = 110;
pub const MAGMA_FORMAT_RGB2220: magma_format_t = 111;
pub const MAGMA_FORMAT_L8: magma_format_t = 112;
pub const MAGMA_FORMAT_R8: magma_format_t = 113;
pub const MAGMA_FORMAT_R8G8: magma_format_t = 114;
pub const MAGMA_FORMAT_A2R10G10B10: magma_format_t = 115;
pub const MAGMA_FORMAT_A2B10G10R10: magma_format_t = 116;
pub const MAGMA_FORMAT_P010: magma_format_t = 117;
pub const MAGMA_FORMAT_R8G8B8: magma_format_t = 118;
pub const MAGMA_FORMAT_MODIFIER_LINEAR: magma_format_modifier_t = 0;
pub const MAGMA_FORMAT_MODIFIER_INTEL_X_TILED: magma_format_modifier_t = 72057594037927937;
pub const MAGMA_FORMAT_MODIFIER_INTEL_Y_TILED: magma_format_modifier_t = 72057594037927938;
pub const MAGMA_FORMAT_MODIFIER_INTEL_YF_TILED: magma_format_modifier_t = 72057594037927939;
pub const MAGMA_FORMAT_MODIFIER_INTEL_Y_TILED_CCS: magma_format_modifier_t = 72057594054705154;
pub const MAGMA_FORMAT_MODIFIER_INTEL_YF_TILED_CCS: magma_format_modifier_t = 72057594054705155;
pub const MAGMA_FORMAT_MODIFIER_ARM_YUV_BIT: magma_format_modifier_t = 16;
pub const MAGMA_FORMAT_MODIFIER_ARM_SPLIT_BLOCK_BIT: magma_format_modifier_t = 32;
pub const MAGMA_FORMAT_MODIFIER_ARM_SPARSE_BIT: magma_format_modifier_t = 64;
pub const MAGMA_FORMAT_MODIFIER_ARM_BCH_BIT: magma_format_modifier_t = 2048;
pub const MAGMA_FORMAT_MODIFIER_ARM_TE_BIT: magma_format_modifier_t = 4096;
pub const MAGMA_FORMAT_MODIFIER_ARM_TILED_HEADER_BIT: magma_format_modifier_t = 8192;
pub const MAGMA_FORMAT_MODIFIER_ARM: magma_format_modifier_t = 576460752303423488;
pub const MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16: magma_format_modifier_t = 576460752303423489;
pub const MAGMA_FORMAT_MODIFIER_ARM_AFBC_32X8: magma_format_modifier_t = 576460752303423490;
pub const MAGMA_FORMAT_MODIFIER_ARM_LINEAR_TE: magma_format_modifier_t = 576460752303427584;
pub const MAGMA_FORMAT_MODIFIER_ARM_AFBC_16X16_TE: magma_format_modifier_t = 576460752303427585;
pub const MAGMA_FORMAT_MODIFIER_ARM_AFBC_32X8_TE: magma_format_modifier_t = 576460752303427586;
pub const MAGMA_COLORSPACE_INVALID: magma_colorspace_t = 0;
pub const MAGMA_COLORSPACE_SRGB: magma_colorspace_t = 1;
pub const MAGMA_COLORSPACE_REC601_NTSC: magma_colorspace_t = 2;
pub const MAGMA_COLORSPACE_REC601_NTSC_FULL_RANGE: magma_colorspace_t = 3;
pub const MAGMA_COLORSPACE_REC601_PAL: magma_colorspace_t = 4;
pub const MAGMA_COLORSPACE_REC601_PAL_FULL_RANGE: magma_colorspace_t = 5;
pub const MAGMA_COLORSPACE_REC709: magma_colorspace_t = 6;
pub const MAGMA_COLORSPACE_REC2020: magma_colorspace_t = 7;
pub const MAGMA_COLORSPACE_REC2100: magma_colorspace_t = 8;
pub const MAGMA_COHERENCY_DOMAIN_CPU: magma_coherency_domain_t = 0;
pub const MAGMA_COHERENCY_DOMAIN_RAM: magma_coherency_domain_t = 1;
pub const MAGMA_COHERENCY_DOMAIN_INACCESSIBLE: magma_coherency_domain_t = 2;
pub const MAGMA_POLL_TYPE_SEMAPHORE: u32 = 1;
pub const MAGMA_POLL_TYPE_HANDLE: u32 = 2;
pub const MAGMA_POLL_CONDITION_READABLE: u32 = 1;
pub const MAGMA_POLL_CONDITION_SIGNALED: u32 = 3;
pub const MAGMA_BUFFER_RANGE_OP_POPULATE_TABLES: magma_buffer_range_op_t = 1;
pub const MAGMA_BUFFER_RANGE_OP_COMMIT: magma_buffer_range_op_t = 2;
pub const MAGMA_BUFFER_RANGE_OP_DEPOPULATE_TABLES: magma_buffer_range_op_t = 3;
pub const MAGMA_BUFFER_RANGE_OP_DECOMMIT: magma_buffer_range_op_t = 4;
pub const MAGMA_SYSMEM_FLAG_PROTECTED: u32 = 1;
pub const MAGMA_SYSMEM_FLAG_FOR_CLIENT: u32 = 4;
pub const MAGMA_MAX_IMAGE_PLANES: u32 = 4;
pub const MAGMA_MAX_DRM_FORMAT_MODIFIERS: u32 = 16;
pub const MAGMA_MAP_FLAG_VENDOR_SHIFT: u64 = 16;
pub const MAGMA_MAP_FLAG_READ: u64 = 1;
pub const MAGMA_MAP_FLAG_WRITE: u64 = 2;
pub const MAGMA_MAP_FLAG_EXECUTE: u64 = 4;
pub const MAGMA_MAP_FLAG_GROWABLE: u64 = 8;
pub const MAGMA_MAP_FLAG_VENDOR_0: u64 = 65536;
pub const MAGMA_IMAGE_CREATE_FLAGS_PRESENTABLE: u32 = 1;
pub const MAGMA_IMAGE_CREATE_FLAGS_VULKAN_USAGE: u32 = 2;
pub const MAGMA_PRIORITY_LOW: u64 = 128;
pub const MAGMA_PRIORITY_MEDIUM: u64 = 256;
pub const MAGMA_PRIORITY_HIGH: u64 = 512;
pub const MAGMA_PRIORITY_REALTIME: u64 = 1024;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_config {
    pub dummy: u64,
}
pub type virtio_magma_config_t = virtio_magma_config;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_IMPORT: virtio_magma_ctrl_type = 4142;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_RELEASE: virtio_magma_ctrl_type = 4143;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_ENUMERATE_DEVICES: virtio_magma_ctrl_type = 4144;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_QUERY: virtio_magma_ctrl_type = 4177;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_DEVICE_CREATE_CONNECTION: virtio_magma_ctrl_type =
    4146;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE: virtio_magma_ctrl_type = 4100;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_GET_ERROR: virtio_magma_ctrl_type =
    4101;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_CONTEXT:
    virtio_magma_ctrl_type = 4102;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_CONTEXT:
    virtio_magma_ctrl_type = 4103;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_BUFFER: virtio_magma_ctrl_type =
    4181;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_BUFFER:
    virtio_magma_ctrl_type = 4105;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_IMPORT_BUFFER: virtio_magma_ctrl_type =
    4180;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_SEMAPHORE:
    virtio_magma_ctrl_type = 4185;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_SEMAPHORE:
    virtio_magma_ctrl_type = 4131;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_IMPORT_SEMAPHORE2:
    virtio_magma_ctrl_type = 4187;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_PERFORM_BUFFER_OP:
    virtio_magma_ctrl_type = 4161;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_MAP_BUFFER: virtio_magma_ctrl_type =
    4178;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_UNMAP_BUFFER: virtio_magma_ctrl_type =
    4179;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_EXECUTE_COMMAND:
    virtio_magma_ctrl_type = 4176;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_EXECUTE_INLINE_COMMANDS:
    virtio_magma_ctrl_type = 4130;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_FLUSH: virtio_magma_ctrl_type = 4175;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_GET_NOTIFICATION_CHANNEL_HANDLE:
    virtio_magma_ctrl_type = 4138;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_READ_NOTIFICATION_CHANNEL:
    virtio_magma_ctrl_type = 4166;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_CLEAN_CACHE: virtio_magma_ctrl_type = 4110;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_SET_CACHE_POLICY: virtio_magma_ctrl_type =
    4111;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_GET_CACHE_POLICY: virtio_magma_ctrl_type =
    4112;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_SET_NAME: virtio_magma_ctrl_type = 4160;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_GET_INFO: virtio_magma_ctrl_type = 4162;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_GET_HANDLE: virtio_magma_ctrl_type = 4171;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_BUFFER_EXPORT: virtio_magma_ctrl_type = 4183;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SEMAPHORE_SIGNAL: virtio_magma_ctrl_type = 4133;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SEMAPHORE_RESET: virtio_magma_ctrl_type = 4134;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_SEMAPHORE_EXPORT: virtio_magma_ctrl_type = 4184;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_POLL: virtio_magma_ctrl_type = 4148;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INITIALIZE_TRACING: virtio_magma_ctrl_type = 4141;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_INITIALIZE_LOGGING: virtio_magma_ctrl_type = 4147;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_ENABLE_PERFORMANCE_COUNTER_ACCESS:
    virtio_magma_ctrl_type = 4149;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_ENABLE_PERFORMANCE_COUNTERS:
    virtio_magma_ctrl_type = 4152;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 4153 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_RELEASE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 4154 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_ADD_PERFORMANCE_COUNTER_BUFFER_OFFSETS_TO_POOL : virtio_magma_ctrl_type = 4155 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_REMOVE_PERFORMANCE_COUNTER_BUFFER_FROM_POOL : virtio_magma_ctrl_type = 4156 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_DUMP_PERFORMANCE_COUNTERS:
    virtio_magma_ctrl_type = 4157;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CLEAR_PERFORMANCE_COUNTERS:
    virtio_magma_ctrl_type = 4158;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_READ_PERFORMANCE_COUNTER_COMPLETION:
    virtio_magma_ctrl_type = 4159;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_CMD_CONNECTION_CREATE_CONTEXT2:
    virtio_magma_ctrl_type = 4188;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_IMPORT: virtio_magma_ctrl_type = 8238;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_RELEASE: virtio_magma_ctrl_type = 8239;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ENUMERATE_DEVICES: virtio_magma_ctrl_type = 8240;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_QUERY: virtio_magma_ctrl_type = 8273;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_DEVICE_CREATE_CONNECTION:
    virtio_magma_ctrl_type = 8242;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE: virtio_magma_ctrl_type =
    8196;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_GET_ERROR: virtio_magma_ctrl_type =
    8197;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_CONTEXT:
    virtio_magma_ctrl_type = 8198;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_CONTEXT:
    virtio_magma_ctrl_type = 8199;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_BUFFER:
    virtio_magma_ctrl_type = 8277;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_BUFFER:
    virtio_magma_ctrl_type = 8201;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_IMPORT_BUFFER:
    virtio_magma_ctrl_type = 8276;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_SEMAPHORE:
    virtio_magma_ctrl_type = 8281;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_SEMAPHORE:
    virtio_magma_ctrl_type = 8227;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_IMPORT_SEMAPHORE2:
    virtio_magma_ctrl_type = 8283;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_PERFORM_BUFFER_OP:
    virtio_magma_ctrl_type = 8257;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_MAP_BUFFER: virtio_magma_ctrl_type =
    8274;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_UNMAP_BUFFER: virtio_magma_ctrl_type =
    8275;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_EXECUTE_COMMAND:
    virtio_magma_ctrl_type = 8272;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_EXECUTE_INLINE_COMMANDS:
    virtio_magma_ctrl_type = 8226;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_FLUSH: virtio_magma_ctrl_type = 8271;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_GET_NOTIFICATION_CHANNEL_HANDLE:
    virtio_magma_ctrl_type = 8234;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_READ_NOTIFICATION_CHANNEL:
    virtio_magma_ctrl_type = 8262;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_CLEAN_CACHE: virtio_magma_ctrl_type =
    8206;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_SET_CACHE_POLICY: virtio_magma_ctrl_type =
    8207;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_GET_CACHE_POLICY: virtio_magma_ctrl_type =
    8208;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_SET_NAME: virtio_magma_ctrl_type = 8256;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_GET_INFO: virtio_magma_ctrl_type = 8258;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_GET_HANDLE: virtio_magma_ctrl_type = 8267;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_BUFFER_EXPORT: virtio_magma_ctrl_type = 8279;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SEMAPHORE_SIGNAL: virtio_magma_ctrl_type = 8229;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SEMAPHORE_RESET: virtio_magma_ctrl_type = 8230;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_SEMAPHORE_EXPORT: virtio_magma_ctrl_type = 8280;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_POLL: virtio_magma_ctrl_type = 8244;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INITIALIZE_TRACING: virtio_magma_ctrl_type =
    8237;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_INITIALIZE_LOGGING: virtio_magma_ctrl_type =
    8243;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_ENABLE_PERFORMANCE_COUNTER_ACCESS:
    virtio_magma_ctrl_type = 8245;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_ENABLE_PERFORMANCE_COUNTERS:
    virtio_magma_ctrl_type = 8248;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 8249 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_RELEASE_PERFORMANCE_COUNTER_BUFFER_POOL : virtio_magma_ctrl_type = 8250 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_ADD_PERFORMANCE_COUNTER_BUFFER_OFFSETS_TO_POOL : virtio_magma_ctrl_type = 8251 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_REMOVE_PERFORMANCE_COUNTER_BUFFER_FROM_POOL : virtio_magma_ctrl_type = 8252 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_DUMP_PERFORMANCE_COUNTERS:
    virtio_magma_ctrl_type = 8253;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CLEAR_PERFORMANCE_COUNTERS:
    virtio_magma_ctrl_type = 8254;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_READ_PERFORMANCE_COUNTER_COMPLETION : virtio_magma_ctrl_type = 8255 ;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_CONNECTION_CREATE_CONTEXT2:
    virtio_magma_ctrl_type = 8284;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_UNIMPLEMENTED: virtio_magma_ctrl_type =
    12289;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_INTERNAL: virtio_magma_ctrl_type = 12290;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_HOST_DISCONNECTED: virtio_magma_ctrl_type =
    12291;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_OUT_OF_MEMORY: virtio_magma_ctrl_type =
    12292;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND: virtio_magma_ctrl_type =
    12293;
pub const virtio_magma_ctrl_type_VIRTIO_MAGMA_RESP_ERR_INVALID_ARGUMENT: virtio_magma_ctrl_type =
    12294;
pub type virtio_magma_ctrl_type = ::std::os::raw::c_ushort;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_ctrl_hdr {
    pub type_: u32,
    pub flags: u32,
}
pub type virtio_magma_ctrl_hdr_t = virtio_magma_ctrl_hdr;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_import_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device_channel: u32,
}
pub type virtio_magma_device_import_ctrl_t = virtio_magma_device_import_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_import_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_device_import_resp_t = virtio_magma_device_import_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_release_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device: u64,
}
pub type virtio_magma_device_release_ctrl_t = virtio_magma_device_release_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_release_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_device_release_resp_t = virtio_magma_device_release_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_enumerate_devices_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device_namespace: u64,
    pub device_directory_channel: u32,
    pub device_count_inout: u64,
    pub device_path_size: u32,
}
pub type virtio_magma_enumerate_devices_ctrl_t = virtio_magma_enumerate_devices_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_enumerate_devices_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device_paths_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_enumerate_devices_resp_t = virtio_magma_enumerate_devices_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_query_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device: u64,
    pub id: u64,
}
pub type virtio_magma_device_query_ctrl_t = virtio_magma_device_query_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_query_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_buffer_out: u64,
    pub result_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_device_query_resp_t = virtio_magma_device_query_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_create_connection_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub device: u64,
}
pub type virtio_magma_device_create_connection_ctrl_t = virtio_magma_device_create_connection_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_device_create_connection_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_device_create_connection_resp_t = virtio_magma_device_create_connection_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_release_ctrl_t = virtio_magma_connection_release_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_connection_release_resp_t = virtio_magma_connection_release_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_get_error_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_get_error_ctrl_t = virtio_magma_connection_get_error_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_get_error_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_get_error_resp_t = virtio_magma_connection_get_error_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_context_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_create_context_ctrl_t =
    virtio_magma_connection_create_context_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_context_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub context_id_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_create_context_resp_t =
    virtio_magma_connection_create_context_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_context_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub context_id: u32,
}
pub type virtio_magma_connection_release_context_ctrl_t =
    virtio_magma_connection_release_context_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_context_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_connection_release_context_resp_t =
    virtio_magma_connection_release_context_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_buffer_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub size: u64,
}
pub type virtio_magma_connection_create_buffer_ctrl_t = virtio_magma_connection_create_buffer_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_buffer_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub size_out: u64,
    pub buffer_out: u64,
    pub id_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_create_buffer_resp_t = virtio_magma_connection_create_buffer_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_buffer_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub buffer: u64,
}
pub type virtio_magma_connection_release_buffer_ctrl_t =
    virtio_magma_connection_release_buffer_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_buffer_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_connection_release_buffer_resp_t =
    virtio_magma_connection_release_buffer_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_import_buffer_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub buffer_handle: u32,
}
pub type virtio_magma_connection_import_buffer_ctrl_t = virtio_magma_connection_import_buffer_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_import_buffer_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub size_out: u64,
    pub buffer_out: u64,
    pub id_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_import_buffer_resp_t = virtio_magma_connection_import_buffer_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_semaphore_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_create_semaphore_ctrl_t =
    virtio_magma_connection_create_semaphore_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_semaphore_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub semaphore_out: u64,
    pub id_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_create_semaphore_resp_t =
    virtio_magma_connection_create_semaphore_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_semaphore_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub semaphore: u64,
}
pub type virtio_magma_connection_release_semaphore_ctrl_t =
    virtio_magma_connection_release_semaphore_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_semaphore_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_connection_release_semaphore_resp_t =
    virtio_magma_connection_release_semaphore_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_import_semaphore2_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub semaphore_handle: u32,
    pub flags: u64,
}
pub type virtio_magma_connection_import_semaphore2_ctrl_t =
    virtio_magma_connection_import_semaphore2_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_import_semaphore2_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub semaphore_out: u64,
    pub id_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_import_semaphore2_resp_t =
    virtio_magma_connection_import_semaphore2_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_perform_buffer_op_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub buffer: u64,
    pub options: u32,
    pub start_offset: u64,
    pub length: u64,
}
pub type virtio_magma_connection_perform_buffer_op_ctrl_t =
    virtio_magma_connection_perform_buffer_op_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_perform_buffer_op_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_perform_buffer_op_resp_t =
    virtio_magma_connection_perform_buffer_op_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_map_buffer_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub hw_va: u64,
    pub buffer: u64,
    pub offset: u64,
    pub length: u64,
    pub map_flags: u64,
}
pub type virtio_magma_connection_map_buffer_ctrl_t = virtio_magma_connection_map_buffer_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_map_buffer_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_map_buffer_resp_t = virtio_magma_connection_map_buffer_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_unmap_buffer_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub hw_va: u64,
    pub buffer: u64,
}
pub type virtio_magma_connection_unmap_buffer_ctrl_t = virtio_magma_connection_unmap_buffer_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_unmap_buffer_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_connection_unmap_buffer_resp_t = virtio_magma_connection_unmap_buffer_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_execute_command_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub context_id: u32,
    pub descriptor: u64,
}
pub type virtio_magma_connection_execute_command_ctrl_t =
    virtio_magma_connection_execute_command_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_execute_command_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_execute_command_resp_t =
    virtio_magma_connection_execute_command_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_execute_inline_commands_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub context_id: u32,
    pub command_count: u64,
    pub command_buffers: u64,
}
pub type virtio_magma_connection_execute_inline_commands_ctrl_t =
    virtio_magma_connection_execute_inline_commands_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_execute_inline_commands_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_execute_inline_commands_resp_t =
    virtio_magma_connection_execute_inline_commands_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_flush_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_flush_ctrl_t = virtio_magma_connection_flush_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_flush_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_flush_resp_t = virtio_magma_connection_flush_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_get_notification_channel_handle_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_get_notification_channel_handle_ctrl_t =
    virtio_magma_connection_get_notification_channel_handle_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_get_notification_channel_handle_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u32,
}
pub type virtio_magma_connection_get_notification_channel_handle_resp_t =
    virtio_magma_connection_get_notification_channel_handle_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_read_notification_channel_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub buffer: u64,
    pub buffer_size: u64,
}
pub type virtio_magma_connection_read_notification_channel_ctrl_t =
    virtio_magma_connection_read_notification_channel_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_read_notification_channel_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer_size_out: u64,
    pub more_data_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_read_notification_channel_resp_t =
    virtio_magma_connection_read_notification_channel_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_clean_cache_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
    pub offset: u64,
    pub size: u64,
    pub operation: u64,
}
pub type virtio_magma_buffer_clean_cache_ctrl_t = virtio_magma_buffer_clean_cache_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_clean_cache_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_buffer_clean_cache_resp_t = virtio_magma_buffer_clean_cache_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_set_cache_policy_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
    pub policy: u64,
}
pub type virtio_magma_buffer_set_cache_policy_ctrl_t = virtio_magma_buffer_set_cache_policy_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_set_cache_policy_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_buffer_set_cache_policy_resp_t = virtio_magma_buffer_set_cache_policy_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_get_cache_policy_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
}
pub type virtio_magma_buffer_get_cache_policy_ctrl_t = virtio_magma_buffer_get_cache_policy_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_get_cache_policy_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub cache_policy_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_buffer_get_cache_policy_resp_t = virtio_magma_buffer_get_cache_policy_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_set_name_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
    pub name: u64,
}
pub type virtio_magma_buffer_set_name_ctrl_t = virtio_magma_buffer_set_name_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_set_name_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_buffer_set_name_resp_t = virtio_magma_buffer_set_name_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_get_info_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
    pub info_out: u64,
}
pub type virtio_magma_buffer_get_info_ctrl_t = virtio_magma_buffer_get_info_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_get_info_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_buffer_get_info_resp_t = virtio_magma_buffer_get_info_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_get_handle_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
}
pub type virtio_magma_buffer_get_handle_ctrl_t = virtio_magma_buffer_get_handle_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_get_handle_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub handle_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_buffer_get_handle_resp_t = virtio_magma_buffer_get_handle_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_export_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer: u64,
}
pub type virtio_magma_buffer_export_ctrl_t = virtio_magma_buffer_export_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_buffer_export_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub buffer_handle_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_buffer_export_resp_t = virtio_magma_buffer_export_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_semaphore_signal_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub semaphore: u64,
}
pub type virtio_magma_semaphore_signal_ctrl_t = virtio_magma_semaphore_signal_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_semaphore_signal_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_semaphore_signal_resp_t = virtio_magma_semaphore_signal_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_semaphore_reset_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub semaphore: u64,
}
pub type virtio_magma_semaphore_reset_ctrl_t = virtio_magma_semaphore_reset_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_semaphore_reset_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
}
pub type virtio_magma_semaphore_reset_resp_t = virtio_magma_semaphore_reset_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_semaphore_export_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub semaphore: u64,
}
pub type virtio_magma_semaphore_export_ctrl_t = virtio_magma_semaphore_export_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_semaphore_export_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub semaphore_handle_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_semaphore_export_resp_t = virtio_magma_semaphore_export_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_poll_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub items: u64,
    pub count: u32,
    pub timeout_ns: u64,
}
pub type virtio_magma_poll_ctrl_t = virtio_magma_poll_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_poll_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_poll_resp_t = virtio_magma_poll_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_initialize_tracing_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub channel: u32,
}
pub type virtio_magma_initialize_tracing_ctrl_t = virtio_magma_initialize_tracing_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_initialize_tracing_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_initialize_tracing_resp_t = virtio_magma_initialize_tracing_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_initialize_logging_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub channel: u32,
}
pub type virtio_magma_initialize_logging_ctrl_t = virtio_magma_initialize_logging_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_initialize_logging_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_initialize_logging_resp_t = virtio_magma_initialize_logging_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_enable_performance_counter_access_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub channel: u32,
}
pub type virtio_magma_connection_enable_performance_counter_access_ctrl_t =
    virtio_magma_connection_enable_performance_counter_access_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_enable_performance_counter_access_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_enable_performance_counter_access_resp_t =
    virtio_magma_connection_enable_performance_counter_access_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_enable_performance_counters_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub counters: u64,
    pub counters_count: u64,
}
pub type virtio_magma_connection_enable_performance_counters_ctrl_t =
    virtio_magma_connection_enable_performance_counters_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_enable_performance_counters_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_enable_performance_counters_resp_t =
    virtio_magma_connection_enable_performance_counters_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_performance_counter_buffer_pool_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
}
pub type virtio_magma_connection_create_performance_counter_buffer_pool_ctrl_t =
    virtio_magma_connection_create_performance_counter_buffer_pool_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_performance_counter_buffer_pool_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub pool_id_out: u64,
    pub notification_handle_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_create_performance_counter_buffer_pool_resp_t =
    virtio_magma_connection_create_performance_counter_buffer_pool_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_performance_counter_buffer_pool_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub pool_id: u64,
}
pub type virtio_magma_connection_release_performance_counter_buffer_pool_ctrl_t =
    virtio_magma_connection_release_performance_counter_buffer_pool_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_release_performance_counter_buffer_pool_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_release_performance_counter_buffer_pool_resp_t =
    virtio_magma_connection_release_performance_counter_buffer_pool_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub pool_id: u64,
    pub offsets: u64,
    pub offsets_count: u64,
}
pub type virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_ctrl_t =
    virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_resp_t =
    virtio_magma_connection_add_performance_counter_buffer_offsets_to_pool_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_remove_performance_counter_buffer_from_pool_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub pool_id: u64,
    pub buffer: u64,
}
pub type virtio_magma_connection_remove_performance_counter_buffer_from_pool_ctrl_t =
    virtio_magma_connection_remove_performance_counter_buffer_from_pool_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_remove_performance_counter_buffer_from_pool_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_remove_performance_counter_buffer_from_pool_resp_t =
    virtio_magma_connection_remove_performance_counter_buffer_from_pool_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_dump_performance_counters_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub pool_id: u64,
    pub trigger_id: u32,
}
pub type virtio_magma_connection_dump_performance_counters_ctrl_t =
    virtio_magma_connection_dump_performance_counters_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_dump_performance_counters_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_dump_performance_counters_resp_t =
    virtio_magma_connection_dump_performance_counters_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_clear_performance_counters_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub counters: u64,
    pub counters_count: u64,
}
pub type virtio_magma_connection_clear_performance_counters_ctrl_t =
    virtio_magma_connection_clear_performance_counters_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_clear_performance_counters_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub result_return: u64,
}
pub type virtio_magma_connection_clear_performance_counters_resp_t =
    virtio_magma_connection_clear_performance_counters_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_read_performance_counter_completion_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub pool_id: u64,
}
pub type virtio_magma_connection_read_performance_counter_completion_ctrl_t =
    virtio_magma_connection_read_performance_counter_completion_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_read_performance_counter_completion_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub trigger_id_out: u64,
    pub buffer_id_out: u64,
    pub buffer_offset_out: u64,
    pub time_out: u64,
    pub result_flags_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_read_performance_counter_completion_resp_t =
    virtio_magma_connection_read_performance_counter_completion_resp;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_context2_ctrl {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub connection: u64,
    pub priority: u64,
}
pub type virtio_magma_connection_create_context2_ctrl_t =
    virtio_magma_connection_create_context2_ctrl;
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone, IntoBytes, FromBytes, Immutable)]
pub struct virtio_magma_connection_create_context2_resp {
    pub hdr: virtio_magma_ctrl_hdr_t,
    pub context_id_out: u64,
    pub result_return: u64,
}
pub type virtio_magma_connection_create_context2_resp_t =
    virtio_magma_connection_create_context2_resp;