1#![expect(non_camel_case_types)]
8#![expect(non_upper_case_globals)]
9#![no_std]
10pub use zx_types::{
11 zx_duration_mono_t as SchedDuration, zx_instant_mono_t,
12 zx_instant_mono_t as WaitQueueCollection_PrimaryKey, zx_status_t,
13};
14pub type Deadline = core::ffi::c_void;
15pub type Thread = core::ffi::c_void;
16pub type Timer = core::ffi::c_void;
17
18#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash)]
19#[repr(C, align(8))]
20pub struct __BindgenOpaqueArray8<T>(pub T);
21impl<T: Copy + Default, const N: usize> Default for __BindgenOpaqueArray8<[T; N]> {
22 fn default() -> Self {
23 Self([<T as Default>::default(); N])
24 }
25}
26#[repr(C)]
27#[repr(align(8))]
28#[derive(Debug, Copy, Clone)]
29pub struct SchedulerState_EffectiveProfile {
30 pub _bindgen_opaque_blob: __BindgenOpaqueArray8<[u8; 32usize]>,
31}
32#[repr(C)]
33#[repr(align(8))]
34#[derive(Debug, Copy, Clone)]
35pub struct SchedulerState_WaitQueueInheritedSchedulerState {
36 pub _bindgen_opaque_blob: __BindgenOpaqueArray8<[u8; 64usize]>,
37}
38#[repr(i32)]
39#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
40pub enum ResourceOwnership {
41 Normal = 0,
42 Reader = 1,
43}
44#[repr(u8)]
45#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
46pub enum Interruptible {
47 No = 0,
48 Yes = 1,
49}
50#[repr(u8)]
51#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
52pub enum ForceInheritance {
53 No = 0,
54 Yes = 1,
55}
56unsafe extern "C" {
57 pub fn cpp_wait_queue_base_init(wait_queue: *mut u8, magic: u32);
58}
59unsafe extern "C" {
60 pub fn cpp_wait_queue_base_magic(wait_queue: *const WaitQueueBase) -> u32;
61}
62unsafe extern "C" {
63 pub fn cpp_wait_queue_base_is_empty(wait_queue: *const WaitQueueBase) -> bool;
64}
65unsafe extern "C" {
66 pub fn cpp_wait_queue_base_count(wait_queue: *const WaitQueueBase) -> u32;
67}
68unsafe extern "C" {
69 pub fn cpp_wait_queue_base_unblock_thread(
70 wait_queue: *mut WaitQueueBase,
71 t: *mut Thread,
72 wait_queue_error: zx_status_t,
73 ) -> zx_status_t;
74}
75unsafe extern "C" {
76 pub fn cpp_wait_queue_base_peek_front(wait_queue: *mut WaitQueueBase) -> *mut Thread;
77}
78unsafe extern "C" {
79 pub fn cpp_wait_queue_base_block_etc_preamble(
80 wait_queue: *mut WaitQueueBase,
81 current_thread: *mut Thread,
82 deadline: *const Deadline,
83 signal_mask: u32,
84 reason: ResourceOwnership,
85 interruptible: Interruptible,
86 ) -> zx_status_t;
87}
88unsafe extern "C" {
89 pub fn cpp_wait_queue_base_block_etc_postamble(
90 wait_queue: *mut WaitQueueBase,
91 current_thread: *mut Thread,
92 deadline: *const Deadline,
93 ) -> zx_status_t;
94}
95unsafe extern "C" {
96 pub fn cpp_wait_queue_base_dequeue(
97 wait_queue: *mut WaitQueueBase,
98 t: *mut Thread,
99 wait_queue_error: zx_status_t,
100 );
101}
102unsafe extern "C" {
103 pub fn cpp_wait_queue_base_validate_queue(wait_queue: *mut WaitQueueBase);
104}
105unsafe extern "C" {
106 pub fn cpp_wait_queue_base_timeout_handler(
107 timer: *mut Timer,
108 now: zx_instant_mono_t,
109 arg: *mut ::core::ffi::c_void,
110 );
111}
112unsafe extern "C" {
113 pub fn cpp_wait_queue_base_update_blocked_thread_effective_profile(
114 wait_queue: *mut WaitQueueBase,
115 t: *mut Thread,
116 );
117}
118unsafe extern "C" {
119 pub fn cpp_wait_queue_init(wait_queue: *mut u8);
120}
121unsafe extern "C" {
122 pub fn cpp_wait_queue_block(
123 wait_queue: *mut WaitQueue,
124 current_thread: *mut Thread,
125 deadline: *const Deadline,
126 interruptible: Interruptible,
127 ) -> zx_status_t;
128}
129unsafe extern "C" {
130 pub fn cpp_wait_queue_block_instant(
131 wait_queue: *mut WaitQueue,
132 current_thread: *mut Thread,
133 deadline: zx_instant_mono_t,
134 interruptible: Interruptible,
135 ) -> zx_status_t;
136}
137unsafe extern "C" {
138 pub fn cpp_wait_queue_block_etc(
139 wait_queue: *mut WaitQueue,
140 current_thread: *mut Thread,
141 deadline: *const Deadline,
142 signal_mask: u32,
143 reason: ResourceOwnership,
144 interruptible: Interruptible,
145 ) -> zx_status_t;
146}
147unsafe extern "C" {
148 pub fn cpp_wait_queue_wake_one(
149 wait_queue: *mut WaitQueue,
150 wait_queue_error: zx_status_t,
151 ) -> bool;
152}
153unsafe extern "C" {
154 pub fn cpp_wait_queue_wake_all(wait_queue: *mut WaitQueue, wait_queue_error: zx_status_t);
155}
156unsafe extern "C" {
157 pub fn cpp_wait_queue_wake_one_locked(
158 wait_queue: *mut WaitQueue,
159 wait_queue_error: zx_status_t,
160 out_woken: *mut bool,
161 ) -> bool;
162}
163unsafe extern "C" {
164 pub fn cpp_wait_queue_wake_all_locked(
165 wait_queue: *mut WaitQueue,
166 wait_queue_error: zx_status_t,
167 out_woken: *mut u32,
168 ) -> bool;
169}
170unsafe extern "C" {
171 pub fn cpp_wait_queue_dequeue_thread(
172 wait_queue: *mut WaitQueue,
173 t: *mut Thread,
174 wait_queue_error: zx_status_t,
175 );
176}
177unsafe extern "C" {
178 pub fn cpp_wait_queue_move_thread(source: *mut WaitQueue, dest: *mut WaitQueue, t: *mut Thread);
179}
180#[repr(C)]
181#[derive(Debug)]
182pub struct WaitQueueCollection {
183 pub threads_: WaitQueueCollection_BlockedThreadTree,
184}
185#[repr(C)]
186pub struct WaitQueueCollection_ThreadState {
187 pub blocking_wait_queue_: *mut WaitQueueBase,
188 pub blocked_threads_tree_node_: __BindgenOpaqueArray8<[u8; 32usize]>,
189 pub blocked_threads_tree_sort_key_: WaitQueueCollection_PrimaryKey,
190 pub subtree_min_deadline_: SchedDuration,
191 pub blocked_status_: zx_status_t,
192 pub interruptible_: Interruptible,
193 pub __bindgen_padding_0: [u8; 3usize],
194 pub inherited_scheduler_state_storage_: SchedulerState_WaitQueueInheritedSchedulerState,
195}
196pub type WaitQueueCollection_BlockedThreadTree = __BindgenOpaqueArray8<[u8; 32usize]>;
197#[repr(C)]
198pub struct WaitQueueBase {
199 pub __bindgen_padding_0: [u8; 16usize],
200 pub magic_: u32,
201 pub __bindgen_padding_1: [u8; 4usize],
202 pub collection_: WaitQueueCollection,
203}
204#[repr(C)]
205pub struct WaitQueue {
206 pub _base: WaitQueueBase,
207}
208pub const WaitQueue_kMagic: u32 = 2002872692;