1#![allow(dead_code)]
8#![allow(non_camel_case_types)]
9#![allow(non_snake_case)]
10#![allow(unused_results)]
11#![allow(non_upper_case_globals)]
12
13pub type __socklen_t = ::std::os::raw::c_uint;
14pub type zx_rights_t = u32;
15pub type zx_time_t = i64;
16pub type zx_handle_t = u32;
17pub type zx_status_t = i32;
18pub type zx_signals_t = u32;
19pub type zx_koid_t = u64;
20pub type zx_off_t = u64;
21#[repr(C)]
22#[derive(Debug, Copy, Clone)]
23pub struct zx_iovec {
24 pub buffer: *mut ::std::os::raw::c_void,
25 pub capacity: usize,
26}
27#[allow(clippy::unnecessary_operation, clippy::identity_op)]
28const _: () = {
29 ["Size of zx_iovec"][::std::mem::size_of::<zx_iovec>() - 16usize];
30 ["Alignment of zx_iovec"][::std::mem::align_of::<zx_iovec>() - 8usize];
31 ["Offset of field: zx_iovec::buffer"][::std::mem::offset_of!(zx_iovec, buffer) - 0usize];
32 ["Offset of field: zx_iovec::capacity"][::std::mem::offset_of!(zx_iovec, capacity) - 8usize];
33};
34impl Default for zx_iovec {
35 fn default() -> Self {
36 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
37 unsafe {
38 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
39 s.assume_init()
40 }
41 }
42}
43pub type zx_iovec_t = zx_iovec;
44pub type zx_obj_type_t = u32;
45pub type zxio_flags_t = u32;
46pub type zxio_vmo_flags_t = u32;
47pub type zxio_signals_t = u32;
48#[repr(C)]
49#[derive(Debug, Default, Copy, Clone)]
50pub struct zxio_tag {
51 pub reserved: [u64; 4usize],
52}
53#[allow(clippy::unnecessary_operation, clippy::identity_op)]
54const _: () = {
55 ["Size of zxio_tag"][::std::mem::size_of::<zxio_tag>() - 32usize];
56 ["Alignment of zxio_tag"][::std::mem::align_of::<zxio_tag>() - 8usize];
57 ["Offset of field: zxio_tag::reserved"][::std::mem::offset_of!(zxio_tag, reserved) - 0usize];
58};
59pub type zxio_t = zxio_tag;
60#[repr(C)]
61#[derive(Debug, Default, Copy, Clone)]
62pub struct zxio_fsverity_descriptor {
63 pub hash_algorithm: u8,
64 pub salt_size: u8,
65 pub salt: [u8; 32usize],
66}
67#[allow(clippy::unnecessary_operation, clippy::identity_op)]
68const _: () = {
69 ["Size of zxio_fsverity_descriptor"]
70 [::std::mem::size_of::<zxio_fsverity_descriptor>() - 34usize];
71 ["Alignment of zxio_fsverity_descriptor"]
72 [::std::mem::align_of::<zxio_fsverity_descriptor>() - 1usize];
73 ["Offset of field: zxio_fsverity_descriptor::hash_algorithm"]
74 [::std::mem::offset_of!(zxio_fsverity_descriptor, hash_algorithm) - 0usize];
75 ["Offset of field: zxio_fsverity_descriptor::salt_size"]
76 [::std::mem::offset_of!(zxio_fsverity_descriptor, salt_size) - 1usize];
77 ["Offset of field: zxio_fsverity_descriptor::salt"]
78 [::std::mem::offset_of!(zxio_fsverity_descriptor, salt) - 2usize];
79};
80pub type zxio_fsverity_descriptor_t = zxio_fsverity_descriptor;
81#[repr(C)]
82#[derive(Debug, Default, Copy, Clone)]
83pub struct zxio_private {
84 pub reserved: [u64; 29usize],
85}
86#[allow(clippy::unnecessary_operation, clippy::identity_op)]
87const _: () = {
88 ["Size of zxio_private"][::std::mem::size_of::<zxio_private>() - 232usize];
89 ["Alignment of zxio_private"][::std::mem::align_of::<zxio_private>() - 8usize];
90 ["Offset of field: zxio_private::reserved"]
91 [::std::mem::offset_of!(zxio_private, reserved) - 0usize];
92};
93pub type zxio_private_t = zxio_private;
94#[repr(C)]
95#[derive(Debug, Default, Copy, Clone)]
96pub struct zxio_storage {
97 pub io: zxio_t,
98 pub reserved: zxio_private_t,
99}
100#[allow(clippy::unnecessary_operation, clippy::identity_op)]
101const _: () = {
102 ["Size of zxio_storage"][::std::mem::size_of::<zxio_storage>() - 264usize];
103 ["Alignment of zxio_storage"][::std::mem::align_of::<zxio_storage>() - 8usize];
104 ["Offset of field: zxio_storage::io"][::std::mem::offset_of!(zxio_storage, io) - 0usize];
105 ["Offset of field: zxio_storage::reserved"]
106 [::std::mem::offset_of!(zxio_storage, reserved) - 32usize];
107};
108pub type zxio_storage_t = zxio_storage;
109pub type zxio_object_type_t = u32;
110pub type zxio_storage_alloc = ::std::option::Option<
111 unsafe extern "C" fn(
112 type_: zxio_object_type_t,
113 out_storage: *mut *mut zxio_storage_t,
114 out_context: *mut *mut ::std::os::raw::c_void,
115 ) -> zx_status_t,
116>;
117#[repr(C)]
118#[derive(Debug, Default, Copy, Clone)]
119pub struct zxio_datagram_prelude_size {
120 pub tx: usize,
121 pub rx: usize,
122}
123#[allow(clippy::unnecessary_operation, clippy::identity_op)]
124const _: () = {
125 ["Size of zxio_datagram_prelude_size"]
126 [::std::mem::size_of::<zxio_datagram_prelude_size>() - 16usize];
127 ["Alignment of zxio_datagram_prelude_size"]
128 [::std::mem::align_of::<zxio_datagram_prelude_size>() - 8usize];
129 ["Offset of field: zxio_datagram_prelude_size::tx"]
130 [::std::mem::offset_of!(zxio_datagram_prelude_size, tx) - 0usize];
131 ["Offset of field: zxio_datagram_prelude_size::rx"]
132 [::std::mem::offset_of!(zxio_datagram_prelude_size, rx) - 8usize];
133};
134pub type zxio_datagram_prelude_size_t = zxio_datagram_prelude_size;
135pub type zxio_node_protocols_t = u64;
136pub type zxio_id_t = u64;
137pub type zxio_operations_t = u64;
138pub type zxio_rights_t = zxio_operations_t;
139pub type zxio_abilities_t = zxio_operations_t;
140pub type zxio_hash_algorithm_t = u8;
141#[repr(C)]
142#[derive(Debug, Default, Copy, Clone)]
143pub struct zxio_verification_options {
144 pub salt: [u8; 32usize],
145 pub salt_size: usize,
146 pub hash_alg: zxio_hash_algorithm_t,
147}
148#[allow(clippy::unnecessary_operation, clippy::identity_op)]
149const _: () = {
150 ["Size of zxio_verification_options"]
151 [::std::mem::size_of::<zxio_verification_options>() - 48usize];
152 ["Alignment of zxio_verification_options"]
153 [::std::mem::align_of::<zxio_verification_options>() - 8usize];
154 ["Offset of field: zxio_verification_options::salt"]
155 [::std::mem::offset_of!(zxio_verification_options, salt) - 0usize];
156 ["Offset of field: zxio_verification_options::salt_size"]
157 [::std::mem::offset_of!(zxio_verification_options, salt_size) - 32usize];
158 ["Offset of field: zxio_verification_options::hash_alg"]
159 [::std::mem::offset_of!(zxio_verification_options, hash_alg) - 40usize];
160};
161pub type zxio_verification_options_t = zxio_verification_options;
162pub type zxio_selinux_context_state_t = u8;
163#[repr(C)]
164#[derive(Debug, Copy, Clone)]
165pub struct zxio_node_attr {
166 pub protocols: zxio_node_protocols_t,
167 pub abilities: zxio_abilities_t,
168 pub id: zxio_id_t,
169 pub content_size: u64,
170 pub storage_size: u64,
171 pub link_count: u64,
172 pub creation_time: u64,
173 pub modification_time: u64,
174 pub change_time: u64,
175 pub access_time: u64,
176 pub selinux_context: *mut u8,
177 pub selinux_context_length: u16,
178 pub selinux_context_state: zxio_selinux_context_state_t,
179 pub mode: u32,
180 pub uid: u32,
181 pub gid: u32,
182 pub rdev: u64,
183 pub fsverity_options: zxio_verification_options_t,
184 pub fsverity_root_hash: *mut u8,
185 pub fsverity_enabled: bool,
186 pub casefold: bool,
187 pub object_type: zxio_object_type_t,
188 pub wrapping_key_id: [u8; 16usize],
189 pub has: zxio_node_attr_zxio_node_attr_has_t,
190}
191#[repr(C)]
192#[derive(Debug, Default, Copy, Clone)]
193pub struct zxio_node_attr_zxio_node_attr_has_t {
194 pub protocols: bool,
195 pub abilities: bool,
196 pub id: bool,
197 pub content_size: bool,
198 pub storage_size: bool,
199 pub link_count: bool,
200 pub creation_time: bool,
201 pub modification_time: bool,
202 pub change_time: bool,
203 pub access_time: bool,
204 pub mode: bool,
205 pub uid: bool,
206 pub gid: bool,
207 pub rdev: bool,
208 pub fsverity_options: bool,
209 pub fsverity_root_hash: bool,
210 pub fsverity_enabled: bool,
211 pub object_type: bool,
212 pub casefold: bool,
213 pub wrapping_key_id: bool,
214 pub selinux_context: bool,
215 pub pending_access_time_update: bool,
216}
217#[allow(clippy::unnecessary_operation, clippy::identity_op)]
218const _: () = {
219 ["Size of zxio_node_attr_zxio_node_attr_has_t"]
220 [::std::mem::size_of::<zxio_node_attr_zxio_node_attr_has_t>() - 22usize];
221 ["Alignment of zxio_node_attr_zxio_node_attr_has_t"]
222 [::std::mem::align_of::<zxio_node_attr_zxio_node_attr_has_t>() - 1usize];
223 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::protocols"]
224 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, protocols) - 0usize];
225 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::abilities"]
226 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, abilities) - 1usize];
227 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::id"]
228 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, id) - 2usize];
229 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::content_size"]
230 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, content_size) - 3usize];
231 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::storage_size"]
232 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, storage_size) - 4usize];
233 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::link_count"]
234 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, link_count) - 5usize];
235 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::creation_time"]
236 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, creation_time) - 6usize];
237 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::modification_time"]
238 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, modification_time) - 7usize];
239 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::change_time"]
240 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, change_time) - 8usize];
241 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::access_time"]
242 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, access_time) - 9usize];
243 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::mode"]
244 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, mode) - 10usize];
245 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::uid"]
246 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, uid) - 11usize];
247 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::gid"]
248 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, gid) - 12usize];
249 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::rdev"]
250 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, rdev) - 13usize];
251 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::fsverity_options"]
252 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, fsverity_options) - 14usize];
253 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::fsverity_root_hash"]
254 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, fsverity_root_hash) - 15usize];
255 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::fsverity_enabled"]
256 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, fsverity_enabled) - 16usize];
257 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::object_type"]
258 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, object_type) - 17usize];
259 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::casefold"]
260 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, casefold) - 18usize];
261 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::wrapping_key_id"]
262 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, wrapping_key_id) - 19usize];
263 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::selinux_context"]
264 [::std::mem::offset_of!(zxio_node_attr_zxio_node_attr_has_t, selinux_context) - 20usize];
265 ["Offset of field: zxio_node_attr_zxio_node_attr_has_t::pending_access_time_update"][::std::mem::offset_of!(
266 zxio_node_attr_zxio_node_attr_has_t,
267 pending_access_time_update
268 )
269 - 21usize];
270};
271#[allow(clippy::unnecessary_operation, clippy::identity_op)]
272const _: () = {
273 ["Size of zxio_node_attr"][::std::mem::size_of::<zxio_node_attr>() - 216usize];
274 ["Alignment of zxio_node_attr"][::std::mem::align_of::<zxio_node_attr>() - 8usize];
275 ["Offset of field: zxio_node_attr::protocols"]
276 [::std::mem::offset_of!(zxio_node_attr, protocols) - 0usize];
277 ["Offset of field: zxio_node_attr::abilities"]
278 [::std::mem::offset_of!(zxio_node_attr, abilities) - 8usize];
279 ["Offset of field: zxio_node_attr::id"][::std::mem::offset_of!(zxio_node_attr, id) - 16usize];
280 ["Offset of field: zxio_node_attr::content_size"]
281 [::std::mem::offset_of!(zxio_node_attr, content_size) - 24usize];
282 ["Offset of field: zxio_node_attr::storage_size"]
283 [::std::mem::offset_of!(zxio_node_attr, storage_size) - 32usize];
284 ["Offset of field: zxio_node_attr::link_count"]
285 [::std::mem::offset_of!(zxio_node_attr, link_count) - 40usize];
286 ["Offset of field: zxio_node_attr::creation_time"]
287 [::std::mem::offset_of!(zxio_node_attr, creation_time) - 48usize];
288 ["Offset of field: zxio_node_attr::modification_time"]
289 [::std::mem::offset_of!(zxio_node_attr, modification_time) - 56usize];
290 ["Offset of field: zxio_node_attr::change_time"]
291 [::std::mem::offset_of!(zxio_node_attr, change_time) - 64usize];
292 ["Offset of field: zxio_node_attr::access_time"]
293 [::std::mem::offset_of!(zxio_node_attr, access_time) - 72usize];
294 ["Offset of field: zxio_node_attr::selinux_context"]
295 [::std::mem::offset_of!(zxio_node_attr, selinux_context) - 80usize];
296 ["Offset of field: zxio_node_attr::selinux_context_length"]
297 [::std::mem::offset_of!(zxio_node_attr, selinux_context_length) - 88usize];
298 ["Offset of field: zxio_node_attr::selinux_context_state"]
299 [::std::mem::offset_of!(zxio_node_attr, selinux_context_state) - 90usize];
300 ["Offset of field: zxio_node_attr::mode"]
301 [::std::mem::offset_of!(zxio_node_attr, mode) - 92usize];
302 ["Offset of field: zxio_node_attr::uid"][::std::mem::offset_of!(zxio_node_attr, uid) - 96usize];
303 ["Offset of field: zxio_node_attr::gid"]
304 [::std::mem::offset_of!(zxio_node_attr, gid) - 100usize];
305 ["Offset of field: zxio_node_attr::rdev"]
306 [::std::mem::offset_of!(zxio_node_attr, rdev) - 104usize];
307 ["Offset of field: zxio_node_attr::fsverity_options"]
308 [::std::mem::offset_of!(zxio_node_attr, fsverity_options) - 112usize];
309 ["Offset of field: zxio_node_attr::fsverity_root_hash"]
310 [::std::mem::offset_of!(zxio_node_attr, fsverity_root_hash) - 160usize];
311 ["Offset of field: zxio_node_attr::fsverity_enabled"]
312 [::std::mem::offset_of!(zxio_node_attr, fsverity_enabled) - 168usize];
313 ["Offset of field: zxio_node_attr::casefold"]
314 [::std::mem::offset_of!(zxio_node_attr, casefold) - 169usize];
315 ["Offset of field: zxio_node_attr::object_type"]
316 [::std::mem::offset_of!(zxio_node_attr, object_type) - 172usize];
317 ["Offset of field: zxio_node_attr::wrapping_key_id"]
318 [::std::mem::offset_of!(zxio_node_attr, wrapping_key_id) - 176usize];
319 ["Offset of field: zxio_node_attr::has"]
320 [::std::mem::offset_of!(zxio_node_attr, has) - 192usize];
321};
322impl Default for zxio_node_attr {
323 fn default() -> Self {
324 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
325 unsafe {
326 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
327 s.assume_init()
328 }
329 }
330}
331pub type zxio_node_attributes_t = zxio_node_attr;
332pub type zxio_seek_origin_t = u32;
333#[repr(C)]
334#[derive(Debug, Copy, Clone)]
335pub struct zxio_dirent_iterator {
336 pub io: *mut zxio_t,
337 pub opaque: [u8; 65584usize],
338}
339#[allow(clippy::unnecessary_operation, clippy::identity_op)]
340const _: () = {
341 ["Size of zxio_dirent_iterator"][::std::mem::size_of::<zxio_dirent_iterator>() - 65592usize];
342 ["Alignment of zxio_dirent_iterator"][::std::mem::align_of::<zxio_dirent_iterator>() - 8usize];
343 ["Offset of field: zxio_dirent_iterator::io"]
344 [::std::mem::offset_of!(zxio_dirent_iterator, io) - 0usize];
345 ["Offset of field: zxio_dirent_iterator::opaque"]
346 [::std::mem::offset_of!(zxio_dirent_iterator, opaque) - 8usize];
347};
348impl Default for zxio_dirent_iterator {
349 fn default() -> Self {
350 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
351 unsafe {
352 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
353 s.assume_init()
354 }
355 }
356}
357pub type zxio_dirent_iterator_t = zxio_dirent_iterator;
358#[repr(C)]
359#[derive(Debug, Copy, Clone)]
360pub struct zxio_dirent {
361 pub protocols: zxio_node_protocols_t,
362 pub abilities: zxio_abilities_t,
363 pub id: zxio_id_t,
364 pub has: zxio_dirent_zxio_dirent_has_t,
365 pub name_length: u8,
366 pub name: *mut ::std::os::raw::c_char,
367}
368#[repr(C)]
369#[derive(Debug, Default, Copy, Clone)]
370pub struct zxio_dirent_zxio_dirent_has_t {
371 pub protocols: bool,
372 pub abilities: bool,
373 pub id: bool,
374}
375#[allow(clippy::unnecessary_operation, clippy::identity_op)]
376const _: () = {
377 ["Size of zxio_dirent_zxio_dirent_has_t"]
378 [::std::mem::size_of::<zxio_dirent_zxio_dirent_has_t>() - 3usize];
379 ["Alignment of zxio_dirent_zxio_dirent_has_t"]
380 [::std::mem::align_of::<zxio_dirent_zxio_dirent_has_t>() - 1usize];
381 ["Offset of field: zxio_dirent_zxio_dirent_has_t::protocols"]
382 [::std::mem::offset_of!(zxio_dirent_zxio_dirent_has_t, protocols) - 0usize];
383 ["Offset of field: zxio_dirent_zxio_dirent_has_t::abilities"]
384 [::std::mem::offset_of!(zxio_dirent_zxio_dirent_has_t, abilities) - 1usize];
385 ["Offset of field: zxio_dirent_zxio_dirent_has_t::id"]
386 [::std::mem::offset_of!(zxio_dirent_zxio_dirent_has_t, id) - 2usize];
387};
388#[allow(clippy::unnecessary_operation, clippy::identity_op)]
389const _: () = {
390 ["Size of zxio_dirent"][::std::mem::size_of::<zxio_dirent>() - 40usize];
391 ["Alignment of zxio_dirent"][::std::mem::align_of::<zxio_dirent>() - 8usize];
392 ["Offset of field: zxio_dirent::protocols"]
393 [::std::mem::offset_of!(zxio_dirent, protocols) - 0usize];
394 ["Offset of field: zxio_dirent::abilities"]
395 [::std::mem::offset_of!(zxio_dirent, abilities) - 8usize];
396 ["Offset of field: zxio_dirent::id"][::std::mem::offset_of!(zxio_dirent, id) - 16usize];
397 ["Offset of field: zxio_dirent::has"][::std::mem::offset_of!(zxio_dirent, has) - 24usize];
398 ["Offset of field: zxio_dirent::name_length"]
399 [::std::mem::offset_of!(zxio_dirent, name_length) - 27usize];
400 ["Offset of field: zxio_dirent::name"][::std::mem::offset_of!(zxio_dirent, name) - 32usize];
401};
402impl Default for zxio_dirent {
403 fn default() -> Self {
404 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
405 unsafe {
406 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
407 s.assume_init()
408 }
409 }
410}
411pub type zxio_dirent_t = zxio_dirent;
412pub type zxio_shutdown_options_t = u32;
413pub const advisory_lock_type_ADVISORY_LOCK_SHARED: advisory_lock_type = 1;
414pub const advisory_lock_type_ADVISORY_LOCK_EXCLUSIVE: advisory_lock_type = 2;
415pub const advisory_lock_type_ADVISORY_LOCK_UNLOCK: advisory_lock_type = 4;
416pub type advisory_lock_type = ::std::os::raw::c_uint;
417#[repr(C)]
418#[derive(Debug, Copy, Clone)]
419pub struct advisory_lock_req {
420 pub type_: advisory_lock_type,
421 pub wait: bool,
422}
423#[allow(clippy::unnecessary_operation, clippy::identity_op)]
424const _: () = {
425 ["Size of advisory_lock_req"][::std::mem::size_of::<advisory_lock_req>() - 8usize];
426 ["Alignment of advisory_lock_req"][::std::mem::align_of::<advisory_lock_req>() - 4usize];
427 ["Offset of field: advisory_lock_req::type_"]
428 [::std::mem::offset_of!(advisory_lock_req, type_) - 0usize];
429 ["Offset of field: advisory_lock_req::wait"]
430 [::std::mem::offset_of!(advisory_lock_req, wait) - 4usize];
431};
432impl Default for advisory_lock_req {
433 fn default() -> Self {
434 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
435 unsafe {
436 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
437 s.assume_init()
438 }
439 }
440}
441pub type zxio_advisory_lock_req_t = advisory_lock_req;
442pub type zxio_watch_directory_event_t = u32;
443pub type zxio_watch_directory_cb = ::std::option::Option<
444 unsafe extern "C" fn(
445 event: zxio_watch_directory_event_t,
446 name: *const ::std::os::raw::c_char,
447 context: *mut ::std::os::raw::c_void,
448 ) -> zx_status_t,
449>;
450pub type zxio_xattr_set_mode_t = u32;
451#[repr(C)]
452#[derive(Debug, Copy, Clone)]
453pub struct zxio_xattr_data {
454 pub data: *mut ::std::os::raw::c_void,
455 pub vmo: zx_handle_t,
456 pub len: usize,
457}
458#[allow(clippy::unnecessary_operation, clippy::identity_op)]
459const _: () = {
460 ["Size of zxio_xattr_data"][::std::mem::size_of::<zxio_xattr_data>() - 24usize];
461 ["Alignment of zxio_xattr_data"][::std::mem::align_of::<zxio_xattr_data>() - 8usize];
462 ["Offset of field: zxio_xattr_data::data"]
463 [::std::mem::offset_of!(zxio_xattr_data, data) - 0usize];
464 ["Offset of field: zxio_xattr_data::vmo"]
465 [::std::mem::offset_of!(zxio_xattr_data, vmo) - 8usize];
466 ["Offset of field: zxio_xattr_data::len"]
467 [::std::mem::offset_of!(zxio_xattr_data, len) - 16usize];
468};
469impl Default for zxio_xattr_data {
470 fn default() -> Self {
471 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
472 unsafe {
473 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
474 s.assume_init()
475 }
476 }
477}
478pub type zxio_xattr_data_t = zxio_xattr_data;
479pub type zxio_allocate_mode_t = u32;
480pub type zxio_open_flags_t = u64;
481#[repr(C)]
482#[derive(Debug, Copy, Clone)]
483pub struct zxio_open_options {
484 pub inout_attr: *mut zxio_node_attributes_t,
485 pub create_attr: *const zxio_node_attributes_t,
486}
487#[allow(clippy::unnecessary_operation, clippy::identity_op)]
488const _: () = {
489 ["Size of zxio_open_options"][::std::mem::size_of::<zxio_open_options>() - 16usize];
490 ["Alignment of zxio_open_options"][::std::mem::align_of::<zxio_open_options>() - 8usize];
491 ["Offset of field: zxio_open_options::inout_attr"]
492 [::std::mem::offset_of!(zxio_open_options, inout_attr) - 0usize];
493 ["Offset of field: zxio_open_options::create_attr"]
494 [::std::mem::offset_of!(zxio_open_options, create_attr) - 8usize];
495};
496impl Default for zxio_open_options {
497 fn default() -> Self {
498 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
499 unsafe {
500 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
501 s.assume_init()
502 }
503 }
504}
505pub type zxio_open_options_t = zxio_open_options;
506pub type va_list = __builtin_va_list;
507#[repr(C)]
508#[derive(Debug, Default, Copy, Clone)]
509pub struct zx_info_handle_basic {
510 pub koid: zx_koid_t,
511 pub rights: zx_rights_t,
512 pub type_: zx_obj_type_t,
513 pub related_koid: zx_koid_t,
514 pub reserved: u32,
515 pub padding1: [u8; 4usize],
516}
517#[allow(clippy::unnecessary_operation, clippy::identity_op)]
518const _: () = {
519 ["Size of zx_info_handle_basic"][::std::mem::size_of::<zx_info_handle_basic>() - 32usize];
520 ["Alignment of zx_info_handle_basic"][::std::mem::align_of::<zx_info_handle_basic>() - 8usize];
521 ["Offset of field: zx_info_handle_basic::koid"]
522 [::std::mem::offset_of!(zx_info_handle_basic, koid) - 0usize];
523 ["Offset of field: zx_info_handle_basic::rights"]
524 [::std::mem::offset_of!(zx_info_handle_basic, rights) - 8usize];
525 ["Offset of field: zx_info_handle_basic::type_"]
526 [::std::mem::offset_of!(zx_info_handle_basic, type_) - 12usize];
527 ["Offset of field: zx_info_handle_basic::related_koid"]
528 [::std::mem::offset_of!(zx_info_handle_basic, related_koid) - 16usize];
529 ["Offset of field: zx_info_handle_basic::reserved"]
530 [::std::mem::offset_of!(zx_info_handle_basic, reserved) - 24usize];
531 ["Offset of field: zx_info_handle_basic::padding1"]
532 [::std::mem::offset_of!(zx_info_handle_basic, padding1) - 28usize];
533};
534pub type zx_info_handle_basic_t = zx_info_handle_basic;
535unsafe extern "C" {
536 pub fn zxio_create(handle: zx_handle_t, storage: *mut zxio_storage_t) -> zx_status_t;
537}
538unsafe extern "C" {
539 pub fn zxio_create_with_on_representation(
540 handle: zx_handle_t,
541 inout_attr: *mut zxio_node_attributes_t,
542 storage: *mut zxio_storage_t,
543 ) -> zx_status_t;
544}
545unsafe extern "C" {
546 pub fn zxio_create_with_info(
547 handle: zx_handle_t,
548 handle_info: *const zx_info_handle_basic_t,
549 storage: *mut zxio_storage_t,
550 ) -> zx_status_t;
551}
552unsafe extern "C" {
553 pub fn zxio_create_with_type(
554 storage: *mut zxio_storage_t,
555 type_: zxio_object_type_t,
556 ...
557 ) -> zx_status_t;
558}
559unsafe extern "C" {
560 pub fn zxio_destroy(io: *mut zxio_t);
561}
562unsafe extern "C" {
563 pub fn zxio_close(io: *mut zxio_t) -> zx_status_t;
564}
565unsafe extern "C" {
566 pub fn zxio_release(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t;
567}
568unsafe extern "C" {
569 pub fn zxio_borrow(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t;
570}
571unsafe extern "C" {
572 pub fn zxio_clone(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t;
573}
574unsafe extern "C" {
575 pub fn zxio_wait_one(
576 io: *mut zxio_t,
577 signals: zxio_signals_t,
578 deadline: zx_time_t,
579 out_observed: *mut zxio_signals_t,
580 ) -> zx_status_t;
581}
582unsafe extern "C" {
583 pub fn zxio_wait_begin(
584 io: *mut zxio_t,
585 zxio_signals: zxio_signals_t,
586 out_handle: *mut zx_handle_t,
587 out_zx_signals: *mut zx_signals_t,
588 );
589}
590unsafe extern "C" {
591 pub fn zxio_wait_end(
592 io: *mut zxio_t,
593 zx_signals: zx_signals_t,
594 out_zxio_signals: *mut zxio_signals_t,
595 );
596}
597unsafe extern "C" {
598 pub fn zxio_sync(io: *mut zxio_t) -> zx_status_t;
599}
600unsafe extern "C" {
601 pub fn zxio_attr_get(io: *mut zxio_t, inout_attr: *mut zxio_node_attributes_t) -> zx_status_t;
602}
603unsafe extern "C" {
604 pub fn zxio_attr_set(io: *mut zxio_t, attr: *const zxio_node_attributes_t) -> zx_status_t;
605}
606unsafe extern "C" {
607 pub fn zxio_read(
608 io: *mut zxio_t,
609 buffer: *mut ::std::os::raw::c_void,
610 capacity: usize,
611 flags: zxio_flags_t,
612 out_actual: *mut usize,
613 ) -> zx_status_t;
614}
615unsafe extern "C" {
616 pub fn zxio_read_at(
617 io: *mut zxio_t,
618 offset: zx_off_t,
619 buffer: *mut ::std::os::raw::c_void,
620 capacity: usize,
621 flags: zxio_flags_t,
622 out_actual: *mut usize,
623 ) -> zx_status_t;
624}
625unsafe extern "C" {
626 pub fn zxio_write(
627 io: *mut zxio_t,
628 buffer: *const ::std::os::raw::c_void,
629 capacity: usize,
630 flags: zxio_flags_t,
631 out_actual: *mut usize,
632 ) -> zx_status_t;
633}
634unsafe extern "C" {
635 pub fn zxio_write_at(
636 io: *mut zxio_t,
637 offset: zx_off_t,
638 buffer: *const ::std::os::raw::c_void,
639 capacity: usize,
640 flags: zxio_flags_t,
641 out_actual: *mut usize,
642 ) -> zx_status_t;
643}
644unsafe extern "C" {
645 pub fn zxio_readv(
646 io: *mut zxio_t,
647 vector: *const zx_iovec_t,
648 vector_count: usize,
649 flags: zxio_flags_t,
650 out_actual: *mut usize,
651 ) -> zx_status_t;
652}
653unsafe extern "C" {
654 pub fn zxio_readv_at(
655 io: *mut zxio_t,
656 offset: zx_off_t,
657 vector: *const zx_iovec_t,
658 vector_count: usize,
659 flags: zxio_flags_t,
660 out_actual: *mut usize,
661 ) -> zx_status_t;
662}
663unsafe extern "C" {
664 pub fn zxio_writev(
665 io: *mut zxio_t,
666 vector: *const zx_iovec_t,
667 vector_count: usize,
668 flags: zxio_flags_t,
669 out_actual: *mut usize,
670 ) -> zx_status_t;
671}
672unsafe extern "C" {
673 pub fn zxio_writev_at(
674 io: *mut zxio_t,
675 offset: zx_off_t,
676 vector: *const zx_iovec_t,
677 vector_count: usize,
678 flags: zxio_flags_t,
679 out_actual: *mut usize,
680 ) -> zx_status_t;
681}
682unsafe extern "C" {
683 pub fn zxio_seek(
684 io: *mut zxio_t,
685 start: zxio_seek_origin_t,
686 offset: i64,
687 out_offset: *mut usize,
688 ) -> zx_status_t;
689}
690unsafe extern "C" {
691 pub fn zxio_truncate(io: *mut zxio_t, length: u64) -> zx_status_t;
692}
693unsafe extern "C" {
694 pub fn zxio_deprecated_flags_get(io: *mut zxio_t, out_flags: *mut u32) -> zx_status_t;
695}
696unsafe extern "C" {
697 pub fn zxio_deprecated_flags_set(io: *mut zxio_t, flags: u32) -> zx_status_t;
698}
699unsafe extern "C" {
700 pub fn zxio_flags_get(io: *mut zxio_t, out_flags: *mut u64) -> zx_status_t;
701}
702unsafe extern "C" {
703 pub fn zxio_flags_set(io: *mut zxio_t, flags: u64) -> zx_status_t;
704}
705unsafe extern "C" {
706 pub fn zxio_token_get(io: *mut zxio_t, out_token: *mut zx_handle_t) -> zx_status_t;
707}
708unsafe extern "C" {
709 pub fn zxio_vmo_get(
710 io: *mut zxio_t,
711 flags: zxio_vmo_flags_t,
712 out_vmo: *mut zx_handle_t,
713 ) -> zx_status_t;
714}
715unsafe extern "C" {
716 pub fn zxio_on_mapped(io: *mut zxio_t, ptr: *mut ::std::os::raw::c_void) -> zx_status_t;
717}
718unsafe extern "C" {
719 pub fn zxio_vmo_get_copy(io: *mut zxio_t, out_vmo: *mut zx_handle_t) -> zx_status_t;
720}
721unsafe extern "C" {
722 pub fn zxio_vmo_get_clone(io: *mut zxio_t, out_vmo: *mut zx_handle_t) -> zx_status_t;
723}
724unsafe extern "C" {
725 pub fn zxio_vmo_get_exact(io: *mut zxio_t, out_vmo: *mut zx_handle_t) -> zx_status_t;
726}
727unsafe extern "C" {
728 pub fn zxio_vmo_get_exec(io: *mut zxio_t, out_vmo: *mut zx_handle_t) -> zx_status_t;
729}
730unsafe extern "C" {
731 pub fn zxio_get_read_buffer_available(
732 io: *mut zxio_t,
733 out_available: *mut usize,
734 ) -> zx_status_t;
735}
736unsafe extern "C" {
737 pub fn zxio_shutdown(
738 io: *mut zxio_t,
739 options: zxio_shutdown_options_t,
740 out_code: *mut i16,
741 ) -> zx_status_t;
742}
743unsafe extern "C" {
744 pub fn zxio_open(
745 directory: *mut zxio_t,
746 path: *const ::std::os::raw::c_char,
747 path_len: usize,
748 flags: zxio_open_flags_t,
749 options: *const zxio_open_options_t,
750 storage: *mut zxio_storage_t,
751 ) -> zx_status_t;
752}
753unsafe extern "C" {
754 pub fn zxio_unlink(
755 directory: *mut zxio_t,
756 name: *const ::std::os::raw::c_char,
757 name_len: usize,
758 flags: ::std::os::raw::c_int,
759 ) -> zx_status_t;
760}
761unsafe extern "C" {
762 pub fn zxio_rename(
763 old_directory: *mut zxio_t,
764 old_path: *const ::std::os::raw::c_char,
765 old_path_len: usize,
766 new_directory_token: zx_handle_t,
767 new_path: *const ::std::os::raw::c_char,
768 new_path_len: usize,
769 ) -> zx_status_t;
770}
771unsafe extern "C" {
772 pub fn zxio_link(
773 src_directory: *mut zxio_t,
774 src_path: *const ::std::os::raw::c_char,
775 src_path_len: usize,
776 dst_directory_token: zx_handle_t,
777 dst_path: *const ::std::os::raw::c_char,
778 dst_path_len: usize,
779 ) -> zx_status_t;
780}
781unsafe extern "C" {
782 pub fn zxio_link_into(
783 object: *mut zxio_t,
784 dst_directory_token: zx_handle_t,
785 dst_path: *const ::std::os::raw::c_char,
786 dst_path_len: usize,
787 ) -> zx_status_t;
788}
789unsafe extern "C" {
790 pub fn zxio_dirent_iterator_init(
791 iterator: *mut zxio_dirent_iterator_t,
792 directory: *mut zxio_t,
793 ) -> zx_status_t;
794}
795unsafe extern "C" {
796 pub fn zxio_dirent_iterator_next(
797 iterator: *mut zxio_dirent_iterator_t,
798 inout_entry: *mut zxio_dirent_t,
799 ) -> zx_status_t;
800}
801unsafe extern "C" {
802 pub fn zxio_dirent_iterator_rewind(iterator: *mut zxio_dirent_iterator_t) -> zx_status_t;
803}
804unsafe extern "C" {
805 pub fn zxio_dirent_iterator_destroy(iterator: *mut zxio_dirent_iterator_t);
806}
807unsafe extern "C" {
808 pub fn zxio_isatty(io: *mut zxio_t, tty: *mut bool) -> zx_status_t;
809}
810unsafe extern "C" {
811 pub fn zxio_get_window_size(io: *mut zxio_t, width: *mut u32, height: *mut u32) -> zx_status_t;
812}
813unsafe extern "C" {
814 pub fn zxio_set_window_size(io: *mut zxio_t, width: u32, height: u32) -> zx_status_t;
815}
816unsafe extern "C" {
817 pub fn zxio_ioctl(
818 io: *mut zxio_t,
819 request: ::std::os::raw::c_int,
820 out_code: *mut i16,
821 va: *mut __va_list_tag,
822 ) -> zx_status_t;
823}
824unsafe extern "C" {
825 pub fn zxio_read_link(
826 io: *mut zxio_t,
827 out_target: *mut *const u8,
828 out_target_len: *mut usize,
829 ) -> zx_status_t;
830}
831unsafe extern "C" {
832 pub fn zxio_create_symlink(
833 io: *mut zxio_t,
834 name: *const ::std::os::raw::c_char,
835 name_len: usize,
836 target: *const u8,
837 target_len: usize,
838 storage: *mut zxio_storage_t,
839 ) -> zx_status_t;
840}
841unsafe extern "C" {
842 pub fn zxio_xattr_list(
843 io: *mut zxio_t,
844 callback: ::std::option::Option<
845 unsafe extern "C" fn(
846 context: *mut ::std::os::raw::c_void,
847 name: *const u8,
848 name_len: usize,
849 ),
850 >,
851 context: *mut ::std::os::raw::c_void,
852 ) -> zx_status_t;
853}
854unsafe extern "C" {
855 pub fn zxio_xattr_get(
856 io: *mut zxio_t,
857 name: *const u8,
858 name_len: usize,
859 callback: ::std::option::Option<
860 unsafe extern "C" fn(
861 context: *mut ::std::os::raw::c_void,
862 data: zxio_xattr_data_t,
863 ) -> zx_status_t,
864 >,
865 context: *mut ::std::os::raw::c_void,
866 ) -> zx_status_t;
867}
868unsafe extern "C" {
869 pub fn zxio_xattr_set(
870 io: *mut zxio_t,
871 name: *const u8,
872 name_len: usize,
873 value: *const u8,
874 value_len: usize,
875 mode: zxio_xattr_set_mode_t,
876 ) -> zx_status_t;
877}
878unsafe extern "C" {
879 pub fn zxio_xattr_remove(io: *mut zxio_t, name: *const u8, name_len: usize) -> zx_status_t;
880}
881unsafe extern "C" {
882 pub fn zxio_allocate(
883 io: *mut zxio_t,
884 offset: u64,
885 len: u64,
886 mode: zxio_allocate_mode_t,
887 ) -> zx_status_t;
888}
889unsafe extern "C" {
890 pub fn zxio_enable_verity(
891 io: *mut zxio_t,
892 descriptor: *const zxio_fsverity_descriptor_t,
893 ) -> zx_status_t;
894}
895#[repr(C)]
896#[derive(Debug, Copy, Clone)]
897pub struct iovec {
898 pub iov_base: *mut ::std::os::raw::c_void,
899 pub iov_len: usize,
900}
901#[allow(clippy::unnecessary_operation, clippy::identity_op)]
902const _: () = {
903 ["Size of iovec"][::std::mem::size_of::<iovec>() - 16usize];
904 ["Alignment of iovec"][::std::mem::align_of::<iovec>() - 8usize];
905 ["Offset of field: iovec::iov_base"][::std::mem::offset_of!(iovec, iov_base) - 0usize];
906 ["Offset of field: iovec::iov_len"][::std::mem::offset_of!(iovec, iov_len) - 8usize];
907};
908impl Default for iovec {
909 fn default() -> Self {
910 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
911 unsafe {
912 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
913 s.assume_init()
914 }
915 }
916}
917pub type socklen_t = __socklen_t;
918pub type sa_family_t = ::std::os::raw::c_ushort;
919#[repr(C)]
920#[derive(Debug, Default, Copy, Clone)]
921pub struct sockaddr {
922 pub sa_family: sa_family_t,
923 pub sa_data: [::std::os::raw::c_char; 14usize],
924}
925#[allow(clippy::unnecessary_operation, clippy::identity_op)]
926const _: () = {
927 ["Size of sockaddr"][::std::mem::size_of::<sockaddr>() - 16usize];
928 ["Alignment of sockaddr"][::std::mem::align_of::<sockaddr>() - 2usize];
929 ["Offset of field: sockaddr::sa_family"][::std::mem::offset_of!(sockaddr, sa_family) - 0usize];
930 ["Offset of field: sockaddr::sa_data"][::std::mem::offset_of!(sockaddr, sa_data) - 2usize];
931};
932#[repr(C)]
933#[derive(Debug, Copy, Clone)]
934pub struct msghdr {
935 pub msg_name: *mut ::std::os::raw::c_void,
936 pub msg_namelen: socklen_t,
937 pub msg_iov: *mut iovec,
938 pub msg_iovlen: usize,
939 pub msg_control: *mut ::std::os::raw::c_void,
940 pub msg_controllen: usize,
941 pub msg_flags: ::std::os::raw::c_int,
942}
943#[allow(clippy::unnecessary_operation, clippy::identity_op)]
944const _: () = {
945 ["Size of msghdr"][::std::mem::size_of::<msghdr>() - 56usize];
946 ["Alignment of msghdr"][::std::mem::align_of::<msghdr>() - 8usize];
947 ["Offset of field: msghdr::msg_name"][::std::mem::offset_of!(msghdr, msg_name) - 0usize];
948 ["Offset of field: msghdr::msg_namelen"][::std::mem::offset_of!(msghdr, msg_namelen) - 8usize];
949 ["Offset of field: msghdr::msg_iov"][::std::mem::offset_of!(msghdr, msg_iov) - 16usize];
950 ["Offset of field: msghdr::msg_iovlen"][::std::mem::offset_of!(msghdr, msg_iovlen) - 24usize];
951 ["Offset of field: msghdr::msg_control"][::std::mem::offset_of!(msghdr, msg_control) - 32usize];
952 ["Offset of field: msghdr::msg_controllen"]
953 [::std::mem::offset_of!(msghdr, msg_controllen) - 40usize];
954 ["Offset of field: msghdr::msg_flags"][::std::mem::offset_of!(msghdr, msg_flags) - 48usize];
955};
956impl Default for msghdr {
957 fn default() -> Self {
958 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
959 unsafe {
960 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
961 s.assume_init()
962 }
963 }
964}
965#[repr(C)]
966#[derive(Debug, Default, Copy, Clone)]
967pub struct zxio_ops {
968 pub destroy: ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t)>,
969 pub close: ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t) -> zx_status_t>,
970 pub release: ::std::option::Option<
971 unsafe extern "C" fn(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t,
972 >,
973 pub borrow: ::std::option::Option<
974 unsafe extern "C" fn(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t,
975 >,
976 pub clone: ::std::option::Option<
977 unsafe extern "C" fn(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t,
978 >,
979 pub wait_begin: ::std::option::Option<
980 unsafe extern "C" fn(
981 io: *mut zxio_t,
982 zxio_signals: zxio_signals_t,
983 out_handle: *mut zx_handle_t,
984 out_zx_signals: *mut zx_signals_t,
985 ),
986 >,
987 pub wait_end: ::std::option::Option<
988 unsafe extern "C" fn(
989 io: *mut zxio_t,
990 zx_signals: zx_signals_t,
991 out_zxio_signals: *mut zxio_signals_t,
992 ),
993 >,
994 pub sync: ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t) -> zx_status_t>,
995 pub attr_get: ::std::option::Option<
996 unsafe extern "C" fn(
997 io: *mut zxio_t,
998 inout_attr: *mut zxio_node_attributes_t,
999 ) -> zx_status_t,
1000 >,
1001 pub attr_set: ::std::option::Option<
1002 unsafe extern "C" fn(io: *mut zxio_t, attr: *const zxio_node_attributes_t) -> zx_status_t,
1003 >,
1004 pub readv: ::std::option::Option<
1005 unsafe extern "C" fn(
1006 io: *mut zxio_t,
1007 vector: *const zx_iovec_t,
1008 vector_count: usize,
1009 flags: zxio_flags_t,
1010 out_actual: *mut usize,
1011 ) -> zx_status_t,
1012 >,
1013 pub readv_at: ::std::option::Option<
1014 unsafe extern "C" fn(
1015 io: *mut zxio_t,
1016 offset: zx_off_t,
1017 vector: *const zx_iovec_t,
1018 vector_count: usize,
1019 flags: zxio_flags_t,
1020 out_actual: *mut usize,
1021 ) -> zx_status_t,
1022 >,
1023 pub writev: ::std::option::Option<
1024 unsafe extern "C" fn(
1025 io: *mut zxio_t,
1026 vector: *const zx_iovec_t,
1027 vector_count: usize,
1028 flags: zxio_flags_t,
1029 out_actual: *mut usize,
1030 ) -> zx_status_t,
1031 >,
1032 pub writev_at: ::std::option::Option<
1033 unsafe extern "C" fn(
1034 io: *mut zxio_t,
1035 offset: zx_off_t,
1036 vector: *const zx_iovec_t,
1037 vector_count: usize,
1038 flags: zxio_flags_t,
1039 out_actual: *mut usize,
1040 ) -> zx_status_t,
1041 >,
1042 pub seek: ::std::option::Option<
1043 unsafe extern "C" fn(
1044 io: *mut zxio_t,
1045 start: zxio_seek_origin_t,
1046 offset: i64,
1047 out_offset: *mut usize,
1048 ) -> zx_status_t,
1049 >,
1050 pub truncate:
1051 ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t, length: u64) -> zx_status_t>,
1052 pub flags_get_deprecated: ::std::option::Option<
1053 unsafe extern "C" fn(io: *mut zxio_t, out_flags: *mut u32) -> zx_status_t,
1054 >,
1055 pub flags_set_deprecated:
1056 ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t, flags: u32) -> zx_status_t>,
1057 pub flags_get: ::std::option::Option<
1058 unsafe extern "C" fn(io: *mut zxio_t, out_flags: *mut u64) -> zx_status_t,
1059 >,
1060 pub flags_set:
1061 ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t, flags: u64) -> zx_status_t>,
1062 pub vmo_get: ::std::option::Option<
1063 unsafe extern "C" fn(
1064 io: *mut zxio_t,
1065 flags: zxio_vmo_flags_t,
1066 out_vmo: *mut zx_handle_t,
1067 ) -> zx_status_t,
1068 >,
1069 pub on_mapped: ::std::option::Option<
1070 unsafe extern "C" fn(io: *mut zxio_t, ptr: *mut ::std::os::raw::c_void) -> zx_status_t,
1071 >,
1072 pub get_read_buffer_available: ::std::option::Option<
1073 unsafe extern "C" fn(io: *mut zxio_t, out_available: *mut usize) -> zx_status_t,
1074 >,
1075 pub shutdown: ::std::option::Option<
1076 unsafe extern "C" fn(
1077 io: *mut zxio_t,
1078 options: zxio_shutdown_options_t,
1079 out_code: *mut i16,
1080 ) -> zx_status_t,
1081 >,
1082 pub unlink: ::std::option::Option<
1083 unsafe extern "C" fn(
1084 io: *mut zxio_t,
1085 name: *const ::std::os::raw::c_char,
1086 name_len: usize,
1087 flags: ::std::os::raw::c_int,
1088 ) -> zx_status_t,
1089 >,
1090 pub token_get: ::std::option::Option<
1091 unsafe extern "C" fn(io: *mut zxio_t, out_token: *mut zx_handle_t) -> zx_status_t,
1092 >,
1093 pub rename: ::std::option::Option<
1094 unsafe extern "C" fn(
1095 io: *mut zxio_t,
1096 old_path: *const ::std::os::raw::c_char,
1097 old_path_len: usize,
1098 dst_token: zx_handle_t,
1099 new_path: *const ::std::os::raw::c_char,
1100 new_path_len: usize,
1101 ) -> zx_status_t,
1102 >,
1103 pub link: ::std::option::Option<
1104 unsafe extern "C" fn(
1105 io: *mut zxio_t,
1106 src_path: *const ::std::os::raw::c_char,
1107 src_path_len: usize,
1108 dst_token: zx_handle_t,
1109 dst_path: *const ::std::os::raw::c_char,
1110 dst_path_len: usize,
1111 ) -> zx_status_t,
1112 >,
1113 pub link_into: ::std::option::Option<
1114 unsafe extern "C" fn(
1115 object: *mut zxio_t,
1116 dst_directory_token: zx_handle_t,
1117 dst_path: *const ::std::os::raw::c_char,
1118 dst_path_len: usize,
1119 ) -> zx_status_t,
1120 >,
1121 pub dirent_iterator_init: ::std::option::Option<
1122 unsafe extern "C" fn(io: *mut zxio_t, iterator: *mut zxio_dirent_iterator_t) -> zx_status_t,
1123 >,
1124 pub dirent_iterator_next: ::std::option::Option<
1125 unsafe extern "C" fn(
1126 io: *mut zxio_t,
1127 iterator: *mut zxio_dirent_iterator_t,
1128 inout_entry: *mut zxio_dirent_t,
1129 ) -> zx_status_t,
1130 >,
1131 pub dirent_iterator_rewind: ::std::option::Option<
1132 unsafe extern "C" fn(io: *mut zxio_t, iterator: *mut zxio_dirent_iterator_t) -> zx_status_t,
1133 >,
1134 pub dirent_iterator_destroy: ::std::option::Option<
1135 unsafe extern "C" fn(io: *mut zxio_t, iterator: *mut zxio_dirent_iterator_t),
1136 >,
1137 pub isatty:
1138 ::std::option::Option<unsafe extern "C" fn(io: *mut zxio_t, tty: *mut bool) -> zx_status_t>,
1139 pub get_window_size: ::std::option::Option<
1140 unsafe extern "C" fn(io: *mut zxio_t, width: *mut u32, height: *mut u32) -> zx_status_t,
1141 >,
1142 pub set_window_size: ::std::option::Option<
1143 unsafe extern "C" fn(io: *mut zxio_t, width: u32, height: u32) -> zx_status_t,
1144 >,
1145 pub advisory_lock: ::std::option::Option<
1146 unsafe extern "C" fn(io: *mut zxio_t, req: *mut advisory_lock_req) -> zx_status_t,
1147 >,
1148 pub watch_directory: ::std::option::Option<
1149 unsafe extern "C" fn(
1150 io: *mut zxio_t,
1151 cb: zxio_watch_directory_cb,
1152 deadline: zx_time_t,
1153 context: *mut ::std::os::raw::c_void,
1154 ) -> zx_status_t,
1155 >,
1156 pub bind: ::std::option::Option<
1157 unsafe extern "C" fn(
1158 io: *mut zxio_t,
1159 addr: *const sockaddr,
1160 addrlen: socklen_t,
1161 out_code: *mut i16,
1162 ) -> zx_status_t,
1163 >,
1164 pub connect: ::std::option::Option<
1165 unsafe extern "C" fn(
1166 io: *mut zxio_t,
1167 addr: *const sockaddr,
1168 addrlen: socklen_t,
1169 out_code: *mut i16,
1170 ) -> zx_status_t,
1171 >,
1172 pub listen: ::std::option::Option<
1173 unsafe extern "C" fn(
1174 io: *mut zxio_t,
1175 backlog: ::std::os::raw::c_int,
1176 out_code: *mut i16,
1177 ) -> zx_status_t,
1178 >,
1179 pub accept: ::std::option::Option<
1180 unsafe extern "C" fn(
1181 io: *mut zxio_t,
1182 addr: *mut sockaddr,
1183 addrlen: *mut socklen_t,
1184 out_storage: *mut zxio_storage_t,
1185 out_code: *mut i16,
1186 ) -> zx_status_t,
1187 >,
1188 pub getsockname: ::std::option::Option<
1189 unsafe extern "C" fn(
1190 io: *mut zxio_t,
1191 addr: *mut sockaddr,
1192 addrlen: *mut socklen_t,
1193 out_code: *mut i16,
1194 ) -> zx_status_t,
1195 >,
1196 pub getpeername: ::std::option::Option<
1197 unsafe extern "C" fn(
1198 io: *mut zxio_t,
1199 addr: *mut sockaddr,
1200 addrlen: *mut socklen_t,
1201 out_code: *mut i16,
1202 ) -> zx_status_t,
1203 >,
1204 pub getsockopt: ::std::option::Option<
1205 unsafe extern "C" fn(
1206 io: *mut zxio_t,
1207 level: ::std::os::raw::c_int,
1208 optname: ::std::os::raw::c_int,
1209 optval: *mut ::std::os::raw::c_void,
1210 optlen: *mut socklen_t,
1211 out_code: *mut i16,
1212 ) -> zx_status_t,
1213 >,
1214 pub setsockopt: ::std::option::Option<
1215 unsafe extern "C" fn(
1216 io: *mut zxio_t,
1217 level: ::std::os::raw::c_int,
1218 optname: ::std::os::raw::c_int,
1219 optval: *const ::std::os::raw::c_void,
1220 optlen: socklen_t,
1221 out_code: *mut i16,
1222 ) -> zx_status_t,
1223 >,
1224 pub recvmsg: ::std::option::Option<
1225 unsafe extern "C" fn(
1226 io: *mut zxio_t,
1227 msg: *mut msghdr,
1228 flags: ::std::os::raw::c_int,
1229 out_actual: *mut usize,
1230 out_code: *mut i16,
1231 ) -> zx_status_t,
1232 >,
1233 pub sendmsg: ::std::option::Option<
1234 unsafe extern "C" fn(
1235 io: *mut zxio_t,
1236 msg: *const msghdr,
1237 flags: ::std::os::raw::c_int,
1238 out_actual: *mut usize,
1239 out_code: *mut i16,
1240 ) -> zx_status_t,
1241 >,
1242 pub ioctl: ::std::option::Option<
1243 unsafe extern "C" fn(
1244 io: *mut zxio_t,
1245 request: ::std::os::raw::c_int,
1246 out_code: *mut i16,
1247 va: *mut __va_list_tag,
1248 ) -> zx_status_t,
1249 >,
1250 pub read_link: ::std::option::Option<
1251 unsafe extern "C" fn(
1252 io: *mut zxio_t,
1253 out_target: *mut *const u8,
1254 out_target_len: *mut usize,
1255 ) -> zx_status_t,
1256 >,
1257 pub create_symlink: ::std::option::Option<
1258 unsafe extern "C" fn(
1259 io: *mut zxio_t,
1260 name: *const ::std::os::raw::c_char,
1261 name_len: usize,
1262 target: *const u8,
1263 target_len: usize,
1264 storage: *mut zxio_storage_t,
1265 ) -> zx_status_t,
1266 >,
1267 pub xattr_list: ::std::option::Option<
1268 unsafe extern "C" fn(
1269 io: *mut zxio_t,
1270 callback: ::std::option::Option<
1271 unsafe extern "C" fn(
1272 context: *mut ::std::os::raw::c_void,
1273 name: *const u8,
1274 name_len: usize,
1275 ),
1276 >,
1277 context: *mut ::std::os::raw::c_void,
1278 ) -> zx_status_t,
1279 >,
1280 pub xattr_get: ::std::option::Option<
1281 unsafe extern "C" fn(
1282 io: *mut zxio_t,
1283 name: *const u8,
1284 name_len: usize,
1285 callback: ::std::option::Option<
1286 unsafe extern "C" fn(
1287 context: *mut ::std::os::raw::c_void,
1288 data: zxio_xattr_data_t,
1289 ) -> zx_status_t,
1290 >,
1291 context: *mut ::std::os::raw::c_void,
1292 ) -> zx_status_t,
1293 >,
1294 pub xattr_set: ::std::option::Option<
1295 unsafe extern "C" fn(
1296 io: *mut zxio_t,
1297 name: *const u8,
1298 name_len: usize,
1299 value: *const u8,
1300 value_len: usize,
1301 mode: zxio_xattr_set_mode_t,
1302 ) -> zx_status_t,
1303 >,
1304 pub xattr_remove: ::std::option::Option<
1305 unsafe extern "C" fn(io: *mut zxio_t, name: *const u8, name_len: usize) -> zx_status_t,
1306 >,
1307 pub open: ::std::option::Option<
1308 unsafe extern "C" fn(
1309 directory: *mut zxio_t,
1310 path: *const ::std::os::raw::c_char,
1311 path_len: usize,
1312 flags: zxio_open_flags_t,
1313 options: *const zxio_open_options_t,
1314 storage: *mut zxio_storage_t,
1315 ) -> zx_status_t,
1316 >,
1317 pub allocate: ::std::option::Option<
1318 unsafe extern "C" fn(
1319 io: *mut zxio_t,
1320 offset: u64,
1321 len: u64,
1322 mode: zxio_allocate_mode_t,
1323 ) -> zx_status_t,
1324 >,
1325 pub enable_verity: ::std::option::Option<
1326 unsafe extern "C" fn(
1327 io: *mut zxio_t,
1328 descriptor: *const zxio_fsverity_descriptor_t,
1329 ) -> zx_status_t,
1330 >,
1331}
1332#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1333const _: () = {
1334 ["Size of zxio_ops"][::std::mem::size_of::<zxio_ops>() - 464usize];
1335 ["Alignment of zxio_ops"][::std::mem::align_of::<zxio_ops>() - 8usize];
1336 ["Offset of field: zxio_ops::destroy"][::std::mem::offset_of!(zxio_ops, destroy) - 0usize];
1337 ["Offset of field: zxio_ops::close"][::std::mem::offset_of!(zxio_ops, close) - 8usize];
1338 ["Offset of field: zxio_ops::release"][::std::mem::offset_of!(zxio_ops, release) - 16usize];
1339 ["Offset of field: zxio_ops::borrow"][::std::mem::offset_of!(zxio_ops, borrow) - 24usize];
1340 ["Offset of field: zxio_ops::clone"][::std::mem::offset_of!(zxio_ops, clone) - 32usize];
1341 ["Offset of field: zxio_ops::wait_begin"]
1342 [::std::mem::offset_of!(zxio_ops, wait_begin) - 40usize];
1343 ["Offset of field: zxio_ops::wait_end"][::std::mem::offset_of!(zxio_ops, wait_end) - 48usize];
1344 ["Offset of field: zxio_ops::sync"][::std::mem::offset_of!(zxio_ops, sync) - 56usize];
1345 ["Offset of field: zxio_ops::attr_get"][::std::mem::offset_of!(zxio_ops, attr_get) - 64usize];
1346 ["Offset of field: zxio_ops::attr_set"][::std::mem::offset_of!(zxio_ops, attr_set) - 72usize];
1347 ["Offset of field: zxio_ops::readv"][::std::mem::offset_of!(zxio_ops, readv) - 80usize];
1348 ["Offset of field: zxio_ops::readv_at"][::std::mem::offset_of!(zxio_ops, readv_at) - 88usize];
1349 ["Offset of field: zxio_ops::writev"][::std::mem::offset_of!(zxio_ops, writev) - 96usize];
1350 ["Offset of field: zxio_ops::writev_at"]
1351 [::std::mem::offset_of!(zxio_ops, writev_at) - 104usize];
1352 ["Offset of field: zxio_ops::seek"][::std::mem::offset_of!(zxio_ops, seek) - 112usize];
1353 ["Offset of field: zxio_ops::truncate"][::std::mem::offset_of!(zxio_ops, truncate) - 120usize];
1354 ["Offset of field: zxio_ops::flags_get_deprecated"]
1355 [::std::mem::offset_of!(zxio_ops, flags_get_deprecated) - 128usize];
1356 ["Offset of field: zxio_ops::flags_set_deprecated"]
1357 [::std::mem::offset_of!(zxio_ops, flags_set_deprecated) - 136usize];
1358 ["Offset of field: zxio_ops::flags_get"]
1359 [::std::mem::offset_of!(zxio_ops, flags_get) - 144usize];
1360 ["Offset of field: zxio_ops::flags_set"]
1361 [::std::mem::offset_of!(zxio_ops, flags_set) - 152usize];
1362 ["Offset of field: zxio_ops::vmo_get"][::std::mem::offset_of!(zxio_ops, vmo_get) - 160usize];
1363 ["Offset of field: zxio_ops::on_mapped"]
1364 [::std::mem::offset_of!(zxio_ops, on_mapped) - 168usize];
1365 ["Offset of field: zxio_ops::get_read_buffer_available"]
1366 [::std::mem::offset_of!(zxio_ops, get_read_buffer_available) - 176usize];
1367 ["Offset of field: zxio_ops::shutdown"][::std::mem::offset_of!(zxio_ops, shutdown) - 184usize];
1368 ["Offset of field: zxio_ops::unlink"][::std::mem::offset_of!(zxio_ops, unlink) - 192usize];
1369 ["Offset of field: zxio_ops::token_get"]
1370 [::std::mem::offset_of!(zxio_ops, token_get) - 200usize];
1371 ["Offset of field: zxio_ops::rename"][::std::mem::offset_of!(zxio_ops, rename) - 208usize];
1372 ["Offset of field: zxio_ops::link"][::std::mem::offset_of!(zxio_ops, link) - 216usize];
1373 ["Offset of field: zxio_ops::link_into"]
1374 [::std::mem::offset_of!(zxio_ops, link_into) - 224usize];
1375 ["Offset of field: zxio_ops::dirent_iterator_init"]
1376 [::std::mem::offset_of!(zxio_ops, dirent_iterator_init) - 232usize];
1377 ["Offset of field: zxio_ops::dirent_iterator_next"]
1378 [::std::mem::offset_of!(zxio_ops, dirent_iterator_next) - 240usize];
1379 ["Offset of field: zxio_ops::dirent_iterator_rewind"]
1380 [::std::mem::offset_of!(zxio_ops, dirent_iterator_rewind) - 248usize];
1381 ["Offset of field: zxio_ops::dirent_iterator_destroy"]
1382 [::std::mem::offset_of!(zxio_ops, dirent_iterator_destroy) - 256usize];
1383 ["Offset of field: zxio_ops::isatty"][::std::mem::offset_of!(zxio_ops, isatty) - 264usize];
1384 ["Offset of field: zxio_ops::get_window_size"]
1385 [::std::mem::offset_of!(zxio_ops, get_window_size) - 272usize];
1386 ["Offset of field: zxio_ops::set_window_size"]
1387 [::std::mem::offset_of!(zxio_ops, set_window_size) - 280usize];
1388 ["Offset of field: zxio_ops::advisory_lock"]
1389 [::std::mem::offset_of!(zxio_ops, advisory_lock) - 288usize];
1390 ["Offset of field: zxio_ops::watch_directory"]
1391 [::std::mem::offset_of!(zxio_ops, watch_directory) - 296usize];
1392 ["Offset of field: zxio_ops::bind"][::std::mem::offset_of!(zxio_ops, bind) - 304usize];
1393 ["Offset of field: zxio_ops::connect"][::std::mem::offset_of!(zxio_ops, connect) - 312usize];
1394 ["Offset of field: zxio_ops::listen"][::std::mem::offset_of!(zxio_ops, listen) - 320usize];
1395 ["Offset of field: zxio_ops::accept"][::std::mem::offset_of!(zxio_ops, accept) - 328usize];
1396 ["Offset of field: zxio_ops::getsockname"]
1397 [::std::mem::offset_of!(zxio_ops, getsockname) - 336usize];
1398 ["Offset of field: zxio_ops::getpeername"]
1399 [::std::mem::offset_of!(zxio_ops, getpeername) - 344usize];
1400 ["Offset of field: zxio_ops::getsockopt"]
1401 [::std::mem::offset_of!(zxio_ops, getsockopt) - 352usize];
1402 ["Offset of field: zxio_ops::setsockopt"]
1403 [::std::mem::offset_of!(zxio_ops, setsockopt) - 360usize];
1404 ["Offset of field: zxio_ops::recvmsg"][::std::mem::offset_of!(zxio_ops, recvmsg) - 368usize];
1405 ["Offset of field: zxio_ops::sendmsg"][::std::mem::offset_of!(zxio_ops, sendmsg) - 376usize];
1406 ["Offset of field: zxio_ops::ioctl"][::std::mem::offset_of!(zxio_ops, ioctl) - 384usize];
1407 ["Offset of field: zxio_ops::read_link"]
1408 [::std::mem::offset_of!(zxio_ops, read_link) - 392usize];
1409 ["Offset of field: zxio_ops::create_symlink"]
1410 [::std::mem::offset_of!(zxio_ops, create_symlink) - 400usize];
1411 ["Offset of field: zxio_ops::xattr_list"]
1412 [::std::mem::offset_of!(zxio_ops, xattr_list) - 408usize];
1413 ["Offset of field: zxio_ops::xattr_get"]
1414 [::std::mem::offset_of!(zxio_ops, xattr_get) - 416usize];
1415 ["Offset of field: zxio_ops::xattr_set"]
1416 [::std::mem::offset_of!(zxio_ops, xattr_set) - 424usize];
1417 ["Offset of field: zxio_ops::xattr_remove"]
1418 [::std::mem::offset_of!(zxio_ops, xattr_remove) - 432usize];
1419 ["Offset of field: zxio_ops::open"][::std::mem::offset_of!(zxio_ops, open) - 440usize];
1420 ["Offset of field: zxio_ops::allocate"][::std::mem::offset_of!(zxio_ops, allocate) - 448usize];
1421 ["Offset of field: zxio_ops::enable_verity"]
1422 [::std::mem::offset_of!(zxio_ops, enable_verity) - 456usize];
1423};
1424pub type zxio_ops_t = zxio_ops;
1425unsafe extern "C" {
1426 pub fn zxio_init(io: *mut zxio_t, ops: *const zxio_ops_t);
1427}
1428unsafe extern "C" {
1429 pub fn zxio_get_ops(io: *mut zxio_t) -> *const zxio_ops_t;
1430}
1431unsafe extern "C" {
1432 pub fn zxio_default_release(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t;
1433}
1434unsafe extern "C" {
1435 pub fn zxio_default_borrow(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t;
1436}
1437unsafe extern "C" {
1438 pub fn zxio_default_destroy(io: *mut zxio_t);
1439}
1440unsafe extern "C" {
1441 pub fn zxio_default_clone(io: *mut zxio_t, out_handle: *mut zx_handle_t) -> zx_status_t;
1442}
1443unsafe extern "C" {
1444 pub fn zxio_default_close(io: *mut zxio_t) -> zx_status_t;
1445}
1446unsafe extern "C" {
1447 pub fn zxio_default_wait_begin(
1448 io: *mut zxio_t,
1449 zxio_signals: zxio_signals_t,
1450 out_handle: *mut zx_handle_t,
1451 out_zx_signals: *mut zx_signals_t,
1452 );
1453}
1454unsafe extern "C" {
1455 pub fn zxio_default_wait_end(
1456 io: *mut zxio_t,
1457 zx_signals: zx_signals_t,
1458 out_zxio_signals: *mut zxio_signals_t,
1459 );
1460}
1461unsafe extern "C" {
1462 pub fn zxio_default_sync(io: *mut zxio_t) -> zx_status_t;
1463}
1464unsafe extern "C" {
1465 pub fn zxio_default_attr_get(
1466 io: *mut zxio_t,
1467 inout_attr: *mut zxio_node_attributes_t,
1468 ) -> zx_status_t;
1469}
1470unsafe extern "C" {
1471 pub fn zxio_default_attr_set(
1472 io: *mut zxio_t,
1473 attr: *const zxio_node_attributes_t,
1474 ) -> zx_status_t;
1475}
1476unsafe extern "C" {
1477 pub fn zxio_default_readv(
1478 io: *mut zxio_t,
1479 vector: *const zx_iovec_t,
1480 vector_count: usize,
1481 flags: zxio_flags_t,
1482 out_actual: *mut usize,
1483 ) -> zx_status_t;
1484}
1485unsafe extern "C" {
1486 pub fn zxio_default_readv_at(
1487 io: *mut zxio_t,
1488 offset: zx_off_t,
1489 vector: *const zx_iovec_t,
1490 vector_count: usize,
1491 flags: zxio_flags_t,
1492 out_actual: *mut usize,
1493 ) -> zx_status_t;
1494}
1495unsafe extern "C" {
1496 pub fn zxio_default_writev(
1497 io: *mut zxio_t,
1498 vector: *const zx_iovec_t,
1499 vector_count: usize,
1500 flags: zxio_flags_t,
1501 out_actual: *mut usize,
1502 ) -> zx_status_t;
1503}
1504unsafe extern "C" {
1505 pub fn zxio_default_writev_at(
1506 io: *mut zxio_t,
1507 offset: zx_off_t,
1508 vector: *const zx_iovec_t,
1509 vector_count: usize,
1510 flags: zxio_flags_t,
1511 out_actual: *mut usize,
1512 ) -> zx_status_t;
1513}
1514unsafe extern "C" {
1515 pub fn zxio_default_seek(
1516 io: *mut zxio_t,
1517 start: zxio_seek_origin_t,
1518 offset: i64,
1519 out_offset: *mut usize,
1520 ) -> zx_status_t;
1521}
1522unsafe extern "C" {
1523 pub fn zxio_default_truncate(io: *mut zxio_t, length: u64) -> zx_status_t;
1524}
1525unsafe extern "C" {
1526 pub fn zxio_default_flags_get_deprecated(io: *mut zxio_t, out_flags: *mut u32) -> zx_status_t;
1527}
1528unsafe extern "C" {
1529 pub fn zxio_default_flags_set_deprecated(io: *mut zxio_t, flags: u32) -> zx_status_t;
1530}
1531unsafe extern "C" {
1532 pub fn zxio_default_flags_get(io: *mut zxio_t, out_flags: *mut u64) -> zx_status_t;
1533}
1534unsafe extern "C" {
1535 pub fn zxio_default_flags_set(io: *mut zxio_t, flags: u64) -> zx_status_t;
1536}
1537unsafe extern "C" {
1538 pub fn zxio_default_vmo_get(
1539 io: *mut zxio_t,
1540 flags: zxio_vmo_flags_t,
1541 out_vmo: *mut zx_handle_t,
1542 ) -> zx_status_t;
1543}
1544unsafe extern "C" {
1545 pub fn zxio_default_on_mapped(io: *mut zxio_t, ptr: *mut ::std::os::raw::c_void)
1546 -> zx_status_t;
1547}
1548unsafe extern "C" {
1549 pub fn zxio_default_get_read_buffer_available(
1550 io: *mut zxio_t,
1551 out_available: *mut usize,
1552 ) -> zx_status_t;
1553}
1554unsafe extern "C" {
1555 pub fn zxio_default_shutdown(
1556 io: *mut zxio_t,
1557 options: zxio_shutdown_options_t,
1558 out_code: *mut i16,
1559 ) -> zx_status_t;
1560}
1561unsafe extern "C" {
1562 pub fn zxio_default_unlink(
1563 io: *mut zxio_t,
1564 name: *const ::std::os::raw::c_char,
1565 name_len: usize,
1566 flags: ::std::os::raw::c_int,
1567 ) -> zx_status_t;
1568}
1569unsafe extern "C" {
1570 pub fn zxio_default_token_get(io: *mut zxio_t, out_token: *mut zx_handle_t) -> zx_status_t;
1571}
1572unsafe extern "C" {
1573 pub fn zxio_default_rename(
1574 io: *mut zxio_t,
1575 old_path: *const ::std::os::raw::c_char,
1576 old_path_len: usize,
1577 dst_token: zx_handle_t,
1578 new_path: *const ::std::os::raw::c_char,
1579 new_path_len: usize,
1580 ) -> zx_status_t;
1581}
1582unsafe extern "C" {
1583 pub fn zxio_default_link(
1584 io: *mut zxio_t,
1585 src_path: *const ::std::os::raw::c_char,
1586 src_path_len: usize,
1587 dst_token: zx_handle_t,
1588 dst_path: *const ::std::os::raw::c_char,
1589 dst_path_len: usize,
1590 ) -> zx_status_t;
1591}
1592unsafe extern "C" {
1593 pub fn zxio_default_link_into(
1594 object: *mut zxio_t,
1595 dst_directory_token: zx_handle_t,
1596 dst_path: *const ::std::os::raw::c_char,
1597 dst_path_len: usize,
1598 ) -> zx_status_t;
1599}
1600unsafe extern "C" {
1601 pub fn zxio_default_dirent_iterator_init(
1602 directory: *mut zxio_t,
1603 iterator: *mut zxio_dirent_iterator_t,
1604 ) -> zx_status_t;
1605}
1606unsafe extern "C" {
1607 pub fn zxio_default_dirent_iterator_next(
1608 io: *mut zxio_t,
1609 iterator: *mut zxio_dirent_iterator_t,
1610 inout_entry: *mut zxio_dirent_t,
1611 ) -> zx_status_t;
1612}
1613unsafe extern "C" {
1614 pub fn zxio_default_dirent_iterator_rewind(
1615 io: *mut zxio_t,
1616 iterator: *mut zxio_dirent_iterator_t,
1617 ) -> zx_status_t;
1618}
1619unsafe extern "C" {
1620 pub fn zxio_default_dirent_iterator_destroy(
1621 io: *mut zxio_t,
1622 iterator: *mut zxio_dirent_iterator_t,
1623 );
1624}
1625unsafe extern "C" {
1626 pub fn zxio_default_isatty(io: *mut zxio_t, tty: *mut bool) -> zx_status_t;
1627}
1628unsafe extern "C" {
1629 pub fn zxio_default_get_window_size(
1630 io: *mut zxio_t,
1631 width: *mut u32,
1632 height: *mut u32,
1633 ) -> zx_status_t;
1634}
1635unsafe extern "C" {
1636 pub fn zxio_default_set_window_size(io: *mut zxio_t, width: u32, height: u32) -> zx_status_t;
1637}
1638unsafe extern "C" {
1639 pub fn zxio_default_advisory_lock(io: *mut zxio_t, req: *mut advisory_lock_req) -> zx_status_t;
1640}
1641unsafe extern "C" {
1642 pub fn zxio_default_watch_directory(
1643 io: *mut zxio_t,
1644 cb: zxio_watch_directory_cb,
1645 deadline: zx_time_t,
1646 context: *mut ::std::os::raw::c_void,
1647 ) -> zx_status_t;
1648}
1649unsafe extern "C" {
1650 pub fn zxio_default_bind(
1651 io: *mut zxio_t,
1652 addr: *const sockaddr,
1653 addrlen: socklen_t,
1654 out_code: *mut i16,
1655 ) -> zx_status_t;
1656}
1657unsafe extern "C" {
1658 pub fn zxio_default_connect(
1659 io: *mut zxio_t,
1660 addr: *const sockaddr,
1661 addrlen: socklen_t,
1662 out_code: *mut i16,
1663 ) -> zx_status_t;
1664}
1665unsafe extern "C" {
1666 pub fn zxio_default_listen(
1667 io: *mut zxio_t,
1668 backlog: ::std::os::raw::c_int,
1669 out_code: *mut i16,
1670 ) -> zx_status_t;
1671}
1672unsafe extern "C" {
1673 pub fn zxio_default_accept(
1674 io: *mut zxio_t,
1675 addr: *mut sockaddr,
1676 addrlen: *mut socklen_t,
1677 out_storage: *mut zxio_storage_t,
1678 out_code: *mut i16,
1679 ) -> zx_status_t;
1680}
1681unsafe extern "C" {
1682 pub fn zxio_default_getsockname(
1683 io: *mut zxio_t,
1684 addr: *mut sockaddr,
1685 addrlen: *mut socklen_t,
1686 out_code: *mut i16,
1687 ) -> zx_status_t;
1688}
1689unsafe extern "C" {
1690 pub fn zxio_default_getpeername(
1691 io: *mut zxio_t,
1692 addr: *mut sockaddr,
1693 addrlen: *mut socklen_t,
1694 out_code: *mut i16,
1695 ) -> zx_status_t;
1696}
1697unsafe extern "C" {
1698 pub fn zxio_default_getsockopt(
1699 io: *mut zxio_t,
1700 level: ::std::os::raw::c_int,
1701 optname: ::std::os::raw::c_int,
1702 optval: *mut ::std::os::raw::c_void,
1703 optlen: *mut socklen_t,
1704 out_code: *mut i16,
1705 ) -> zx_status_t;
1706}
1707unsafe extern "C" {
1708 pub fn zxio_default_setsockopt(
1709 io: *mut zxio_t,
1710 level: ::std::os::raw::c_int,
1711 optname: ::std::os::raw::c_int,
1712 optval: *const ::std::os::raw::c_void,
1713 optlen: socklen_t,
1714 out_code: *mut i16,
1715 ) -> zx_status_t;
1716}
1717unsafe extern "C" {
1718 pub fn zxio_default_recvmsg(
1719 io: *mut zxio_t,
1720 msg: *mut msghdr,
1721 flags: ::std::os::raw::c_int,
1722 out_actual: *mut usize,
1723 out_code: *mut i16,
1724 ) -> zx_status_t;
1725}
1726unsafe extern "C" {
1727 pub fn zxio_default_sendmsg(
1728 io: *mut zxio_t,
1729 msg: *const msghdr,
1730 flags: ::std::os::raw::c_int,
1731 out_actual: *mut usize,
1732 out_code: *mut i16,
1733 ) -> zx_status_t;
1734}
1735unsafe extern "C" {
1736 pub fn zxio_default_ioctl(
1737 io: *mut zxio_t,
1738 request: ::std::os::raw::c_int,
1739 out_code: *mut i16,
1740 va: *mut __va_list_tag,
1741 ) -> zx_status_t;
1742}
1743unsafe extern "C" {
1744 pub fn zxio_default_read_link(
1745 io: *mut zxio_t,
1746 out_target: *mut *const u8,
1747 out_target_len: *mut usize,
1748 ) -> zx_status_t;
1749}
1750unsafe extern "C" {
1751 pub fn zxio_default_create_symlink(
1752 io: *mut zxio_t,
1753 name: *const ::std::os::raw::c_char,
1754 name_len: usize,
1755 target: *const u8,
1756 target_len: usize,
1757 storage: *mut zxio_storage_t,
1758 ) -> zx_status_t;
1759}
1760unsafe extern "C" {
1761 pub fn zxio_default_xattr_list(
1762 io: *mut zxio_t,
1763 callback: ::std::option::Option<
1764 unsafe extern "C" fn(
1765 context: *mut ::std::os::raw::c_void,
1766 name: *const u8,
1767 name_len: usize,
1768 ),
1769 >,
1770 context: *mut ::std::os::raw::c_void,
1771 ) -> zx_status_t;
1772}
1773unsafe extern "C" {
1774 pub fn zxio_default_xattr_get(
1775 io: *mut zxio_t,
1776 name: *const u8,
1777 name_len: usize,
1778 callback: ::std::option::Option<
1779 unsafe extern "C" fn(
1780 context: *mut ::std::os::raw::c_void,
1781 data: zxio_xattr_data_t,
1782 ) -> zx_status_t,
1783 >,
1784 context: *mut ::std::os::raw::c_void,
1785 ) -> zx_status_t;
1786}
1787unsafe extern "C" {
1788 pub fn zxio_default_xattr_set(
1789 io: *mut zxio_t,
1790 name: *const u8,
1791 name_len: usize,
1792 value: *const u8,
1793 value_len: usize,
1794 mode: zxio_xattr_set_mode_t,
1795 ) -> zx_status_t;
1796}
1797unsafe extern "C" {
1798 pub fn zxio_default_xattr_remove(
1799 io: *mut zxio_t,
1800 name: *const u8,
1801 name_len: usize,
1802 ) -> zx_status_t;
1803}
1804unsafe extern "C" {
1805 pub fn zxio_default_allocate(
1806 io: *mut zxio_t,
1807 offset: u64,
1808 len: u64,
1809 mode: zxio_allocate_mode_t,
1810 ) -> zx_status_t;
1811}
1812unsafe extern "C" {
1813 pub fn zxio_default_enable_verity(
1814 io: *mut zxio_t,
1815 descriptor: *const zxio_fsverity_descriptor_t,
1816 ) -> zx_status_t;
1817}
1818unsafe extern "C" {
1819 pub fn zxio_default_open(
1820 directory: *mut zxio_t,
1821 path: *const ::std::os::raw::c_char,
1822 path_len: usize,
1823 flags: zxio_open_flags_t,
1824 options: *const zxio_open_options_t,
1825 storage: *mut zxio_storage_t,
1826 ) -> zx_status_t;
1827}
1828unsafe extern "C" {
1829 pub fn zxio_default_init(io: *mut zxio_t) -> zx_status_t;
1830}
1831unsafe extern "C" {
1832 pub fn zxio_null_init(io: *mut zxio_t) -> zx_status_t;
1833}
1834pub type __builtin_va_list = [__va_list_tag; 1usize];
1835#[repr(C)]
1836#[derive(Debug, Copy, Clone)]
1837pub struct __va_list_tag {
1838 pub gp_offset: ::std::os::raw::c_uint,
1839 pub fp_offset: ::std::os::raw::c_uint,
1840 pub overflow_arg_area: *mut ::std::os::raw::c_void,
1841 pub reg_save_area: *mut ::std::os::raw::c_void,
1842}
1843#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1844const _: () = {
1845 ["Size of __va_list_tag"][::std::mem::size_of::<__va_list_tag>() - 24usize];
1846 ["Alignment of __va_list_tag"][::std::mem::align_of::<__va_list_tag>() - 8usize];
1847 ["Offset of field: __va_list_tag::gp_offset"]
1848 [::std::mem::offset_of!(__va_list_tag, gp_offset) - 0usize];
1849 ["Offset of field: __va_list_tag::fp_offset"]
1850 [::std::mem::offset_of!(__va_list_tag, fp_offset) - 4usize];
1851 ["Offset of field: __va_list_tag::overflow_arg_area"]
1852 [::std::mem::offset_of!(__va_list_tag, overflow_arg_area) - 8usize];
1853 ["Offset of field: __va_list_tag::reg_save_area"]
1854 [::std::mem::offset_of!(__va_list_tag, reg_save_area) - 16usize];
1855};
1856impl Default for __va_list_tag {
1857 fn default() -> Self {
1858 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1859 unsafe {
1860 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1861 s.assume_init()
1862 }
1863 }
1864}