zx_types/
lib.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#![allow(non_camel_case_types)]
6
7use std::fmt::{self, Debug};
8use std::hash::{Hash, Hasher};
9use std::sync::atomic::AtomicI32;
10#[cfg(feature = "zerocopy")]
11use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout};
12
13pub type zx_addr_t = usize;
14pub type zx_stream_seek_origin_t = u32;
15pub type zx_clock_t = u32;
16pub type zx_duration_t = i64;
17pub type zx_duration_mono_t = i64;
18pub type zx_duration_mono_ticks_t = i64;
19pub type zx_duration_boot_t = i64;
20pub type zx_duration_boot_ticks_t = i64;
21pub type zx_futex_t = AtomicI32;
22pub type zx_gpaddr_t = usize;
23pub type zx_guest_option_t = u32;
24pub type zx_vcpu_option_t = u32;
25pub type zx_guest_trap_t = u32;
26pub type zx_handle_t = u32;
27pub type zx_handle_op_t = u32;
28pub type zx_koid_t = u64;
29pub type zx_obj_type_t = u32;
30pub type zx_object_info_topic_t = u32;
31pub type zx_info_maps_type_t = u32;
32pub type zx_instant_boot_t = i64;
33pub type zx_instant_boot_ticks_t = i64;
34pub type zx_instant_mono_t = i64;
35pub type zx_instant_mono_ticks_t = i64;
36pub type zx_iob_access_t = u32;
37pub type zx_iob_allocate_id_options_t = u32;
38pub type zx_iob_discipline_type_t = u64;
39pub type zx_iob_region_type_t = u32;
40pub type zx_iob_write_options_t = u64;
41pub type zx_off_t = u64;
42pub type zx_paddr_t = usize;
43pub type zx_rights_t = u32;
44pub type zx_rsrc_flags_t = u32;
45pub type zx_rsrc_kind_t = u32;
46pub type zx_signals_t = u32;
47pub type zx_ssize_t = isize;
48pub type zx_status_t = i32;
49pub type zx_rsrc_system_base_t = u64;
50pub type zx_ticks_t = i64;
51pub type zx_time_t = i64;
52pub type zx_txid_t = u32;
53pub type zx_vaddr_t = usize;
54pub type zx_vm_option_t = u32;
55pub type zx_thread_state_topic_t = u32;
56pub type zx_vcpu_state_topic_t = u32;
57pub type zx_restricted_reason_t = u64;
58pub type zx_processor_power_level_options_t = u64;
59pub type zx_processor_power_control_t = u64;
60pub type zx_system_memory_stall_type_t = u32;
61
62macro_rules! const_assert {
63    ($e:expr $(,)?) => {
64        const _: [(); 1 - { const ASSERT: bool = $e; ASSERT as usize }] = [];
65    };
66}
67macro_rules! const_assert_eq {
68    ($lhs:expr, $rhs:expr $(,)?) => {
69        const_assert!($lhs == $rhs);
70    };
71}
72
73// TODO: magically coerce this to &`static str somehow?
74#[repr(C)]
75#[derive(Debug, Copy, Clone, Eq, PartialEq)]
76pub struct zx_string_view_t {
77    pub c_str: *const u8, // Guaranteed NUL-terminated valid UTF-8.
78    pub length: usize,
79}
80
81pub const ZX_MAX_NAME_LEN: usize = 32;
82
83// TODO: combine these macros with the bitflags and assoc consts macros below
84// so that we only have to do one macro invocation.
85// The result would look something like:
86// multiconst!(bitflags, zx_rights_t, Rights, [RIGHT_NONE => ZX_RIGHT_NONE = 0; ...]);
87// multiconst!(assoc_consts, zx_status_t, Status, [OK => ZX_OK = 0; ...]);
88// Note that the actual name of the inner macro (e.g. `bitflags`) can't be a variable.
89// It'll just have to be matched on manually
90macro_rules! multiconst {
91    ($typename:ident, [$($(#[$attr:meta])* $rawname:ident = $value:expr;)*]) => {
92        $(
93            $(#[$attr])*
94            pub const $rawname: $typename = $value;
95        )*
96    }
97}
98
99multiconst!(zx_handle_t, [
100    ZX_HANDLE_INVALID = 0;
101]);
102
103multiconst!(zx_handle_op_t, [
104    ZX_HANDLE_OP_MOVE = 0;
105    ZX_HANDLE_OP_DUPLICATE = 1;
106]);
107
108multiconst!(zx_koid_t, [
109    ZX_KOID_INVALID = 0;
110    ZX_KOID_KERNEL = 1;
111    ZX_KOID_FIRST = 1024;
112]);
113
114multiconst!(zx_time_t, [
115    ZX_TIME_INFINITE = i64::MAX;
116    ZX_TIME_INFINITE_PAST = ::std::i64::MIN;
117]);
118
119multiconst!(zx_rights_t, [
120    ZX_RIGHT_NONE           = 0;
121    ZX_RIGHT_DUPLICATE      = 1 << 0;
122    ZX_RIGHT_TRANSFER       = 1 << 1;
123    ZX_RIGHT_READ           = 1 << 2;
124    ZX_RIGHT_WRITE          = 1 << 3;
125    ZX_RIGHT_EXECUTE        = 1 << 4;
126    ZX_RIGHT_MAP            = 1 << 5;
127    ZX_RIGHT_GET_PROPERTY   = 1 << 6;
128    ZX_RIGHT_SET_PROPERTY   = 1 << 7;
129    ZX_RIGHT_ENUMERATE      = 1 << 8;
130    ZX_RIGHT_DESTROY        = 1 << 9;
131    ZX_RIGHT_SET_POLICY     = 1 << 10;
132    ZX_RIGHT_GET_POLICY     = 1 << 11;
133    ZX_RIGHT_SIGNAL         = 1 << 12;
134    ZX_RIGHT_SIGNAL_PEER    = 1 << 13;
135    ZX_RIGHT_WAIT           = 1 << 14;
136    ZX_RIGHT_INSPECT        = 1 << 15;
137    ZX_RIGHT_MANAGE_JOB     = 1 << 16;
138    ZX_RIGHT_MANAGE_PROCESS = 1 << 17;
139    ZX_RIGHT_MANAGE_THREAD  = 1 << 18;
140    ZX_RIGHT_APPLY_PROFILE  = 1 << 19;
141    ZX_RIGHT_MANAGE_SOCKET  = 1 << 20;
142    ZX_RIGHT_OP_CHILDREN    = 1 << 21;
143    ZX_RIGHT_RESIZE         = 1 << 22;
144    ZX_RIGHT_ATTACH_VMO     = 1 << 23;
145    ZX_RIGHT_MANAGE_VMO     = 1 << 24;
146    ZX_RIGHT_SAME_RIGHTS    = 1 << 31;
147]);
148
149multiconst!(u32, [
150    ZX_VMO_RESIZABLE = 1 << 1;
151    ZX_VMO_DISCARDABLE = 1 << 2;
152    ZX_VMO_TRAP_DIRTY = 1 << 3;
153    ZX_VMO_UNBOUNDED = 1 << 4;
154]);
155
156multiconst!(u64, [
157    ZX_VMO_DIRTY_RANGE_IS_ZERO = 1;
158]);
159
160multiconst!(u32, [
161    ZX_INFO_VMO_TYPE_PAGED = 1 << 0;
162    ZX_INFO_VMO_RESIZABLE = 1 << 1;
163    ZX_INFO_VMO_IS_COW_CLONE = 1 << 2;
164    ZX_INFO_VMO_VIA_HANDLE = 1 << 3;
165    ZX_INFO_VMO_VIA_MAPPING = 1 << 4;
166    ZX_INFO_VMO_PAGER_BACKED = 1 << 5;
167    ZX_INFO_VMO_CONTIGUOUS = 1 << 6;
168    ZX_INFO_VMO_DISCARDABLE = 1 << 7;
169    ZX_INFO_VMO_IMMUTABLE = 1 << 8;
170    ZX_INFO_VMO_VIA_IOB_HANDLE = 1 << 9;
171]);
172
173multiconst!(u32, [
174    ZX_VMO_OP_COMMIT = 1;
175    ZX_VMO_OP_DECOMMIT = 2;
176    ZX_VMO_OP_LOCK = 3;
177    ZX_VMO_OP_UNLOCK = 4;
178    ZX_VMO_OP_CACHE_SYNC = 6;
179    ZX_VMO_OP_CACHE_INVALIDATE = 7;
180    ZX_VMO_OP_CACHE_CLEAN = 8;
181    ZX_VMO_OP_CACHE_CLEAN_INVALIDATE = 9;
182    ZX_VMO_OP_ZERO = 10;
183    ZX_VMO_OP_TRY_LOCK = 11;
184    ZX_VMO_OP_DONT_NEED = 12;
185    ZX_VMO_OP_ALWAYS_NEED = 13;
186    ZX_VMO_OP_PREFETCH = 14;
187]);
188
189multiconst!(u32, [
190    ZX_VMAR_OP_COMMIT = 1;
191    ZX_VMAR_OP_DECOMMIT = 2;
192    ZX_VMAR_OP_MAP_RANGE = 3;
193    ZX_VMAR_OP_ZERO = 10;
194    ZX_VMAR_OP_DONT_NEED = 12;
195    ZX_VMAR_OP_ALWAYS_NEED = 13;
196    ZX_VMAR_OP_PREFETCH = 14;
197]);
198
199multiconst!(zx_vm_option_t, [
200    ZX_VM_PERM_READ                    = 1 << 0;
201    ZX_VM_PERM_WRITE                   = 1 << 1;
202    ZX_VM_PERM_EXECUTE                 = 1 << 2;
203    ZX_VM_COMPACT                      = 1 << 3;
204    ZX_VM_SPECIFIC                     = 1 << 4;
205    ZX_VM_SPECIFIC_OVERWRITE           = 1 << 5;
206    ZX_VM_CAN_MAP_SPECIFIC             = 1 << 6;
207    ZX_VM_CAN_MAP_READ                 = 1 << 7;
208    ZX_VM_CAN_MAP_WRITE                = 1 << 8;
209    ZX_VM_CAN_MAP_EXECUTE              = 1 << 9;
210    ZX_VM_MAP_RANGE                    = 1 << 10;
211    ZX_VM_REQUIRE_NON_RESIZABLE        = 1 << 11;
212    ZX_VM_ALLOW_FAULTS                 = 1 << 12;
213    ZX_VM_OFFSET_IS_UPPER_LIMIT        = 1 << 13;
214    ZX_VM_PERM_READ_IF_XOM_UNSUPPORTED = 1 << 14;
215    ZX_VM_FAULT_BEYOND_STREAM_SIZE     = 1 << 15;
216
217    // VM alignment options
218    ZX_VM_ALIGN_BASE                   = 24;
219    ZX_VM_ALIGN_1KB                    = 10 << ZX_VM_ALIGN_BASE;
220    ZX_VM_ALIGN_2KB                    = 11 << ZX_VM_ALIGN_BASE;
221    ZX_VM_ALIGN_4KB                    = 12 << ZX_VM_ALIGN_BASE;
222    ZX_VM_ALIGN_8KB                    = 13 << ZX_VM_ALIGN_BASE;
223    ZX_VM_ALIGN_16KB                   = 14 << ZX_VM_ALIGN_BASE;
224    ZX_VM_ALIGN_32KB                   = 15 << ZX_VM_ALIGN_BASE;
225    ZX_VM_ALIGN_64KB                   = 16 << ZX_VM_ALIGN_BASE;
226    ZX_VM_ALIGN_128KB                  = 17 << ZX_VM_ALIGN_BASE;
227    ZX_VM_ALIGN_256KB                  = 18 << ZX_VM_ALIGN_BASE;
228    ZX_VM_ALIGN_512KB                  = 19 << ZX_VM_ALIGN_BASE;
229    ZX_VM_ALIGN_1MB                    = 20 << ZX_VM_ALIGN_BASE;
230    ZX_VM_ALIGN_2MB                    = 21 << ZX_VM_ALIGN_BASE;
231    ZX_VM_ALIGN_4MB                    = 22 << ZX_VM_ALIGN_BASE;
232    ZX_VM_ALIGN_8MB                    = 23 << ZX_VM_ALIGN_BASE;
233    ZX_VM_ALIGN_16MB                   = 24 << ZX_VM_ALIGN_BASE;
234    ZX_VM_ALIGN_32MB                   = 25 << ZX_VM_ALIGN_BASE;
235    ZX_VM_ALIGN_64MB                   = 26 << ZX_VM_ALIGN_BASE;
236    ZX_VM_ALIGN_128MB                  = 27 << ZX_VM_ALIGN_BASE;
237    ZX_VM_ALIGN_256MB                  = 28 << ZX_VM_ALIGN_BASE;
238    ZX_VM_ALIGN_512MB                  = 29 << ZX_VM_ALIGN_BASE;
239    ZX_VM_ALIGN_1GB                    = 30 << ZX_VM_ALIGN_BASE;
240    ZX_VM_ALIGN_2GB                    = 31 << ZX_VM_ALIGN_BASE;
241    ZX_VM_ALIGN_4GB                    = 32 << ZX_VM_ALIGN_BASE;
242]);
243
244multiconst!(u32, [
245    ZX_PROCESS_SHARED = 1 << 0;
246]);
247
248// matches ///zircon/system/public/zircon/errors.h
249multiconst!(zx_status_t, [
250    ZX_OK                         = 0;
251    ZX_ERR_INTERNAL               = -1;
252    ZX_ERR_NOT_SUPPORTED          = -2;
253    ZX_ERR_NO_RESOURCES           = -3;
254    ZX_ERR_NO_MEMORY              = -4;
255    ZX_ERR_INTERRUPTED_RETRY      = -6;
256    ZX_ERR_INVALID_ARGS           = -10;
257    ZX_ERR_BAD_HANDLE             = -11;
258    ZX_ERR_WRONG_TYPE             = -12;
259    ZX_ERR_BAD_SYSCALL            = -13;
260    ZX_ERR_OUT_OF_RANGE           = -14;
261    ZX_ERR_BUFFER_TOO_SMALL       = -15;
262    ZX_ERR_BAD_STATE              = -20;
263    ZX_ERR_TIMED_OUT              = -21;
264    ZX_ERR_SHOULD_WAIT            = -22;
265    ZX_ERR_CANCELED               = -23;
266    ZX_ERR_PEER_CLOSED            = -24;
267    ZX_ERR_NOT_FOUND              = -25;
268    ZX_ERR_ALREADY_EXISTS         = -26;
269    ZX_ERR_ALREADY_BOUND          = -27;
270    ZX_ERR_UNAVAILABLE            = -28;
271    ZX_ERR_ACCESS_DENIED          = -30;
272    ZX_ERR_IO                     = -40;
273    ZX_ERR_IO_REFUSED             = -41;
274    ZX_ERR_IO_DATA_INTEGRITY      = -42;
275    ZX_ERR_IO_DATA_LOSS           = -43;
276    ZX_ERR_IO_NOT_PRESENT         = -44;
277    ZX_ERR_IO_OVERRUN             = -45;
278    ZX_ERR_IO_MISSED_DEADLINE     = -46;
279    ZX_ERR_IO_INVALID             = -47;
280    ZX_ERR_BAD_PATH               = -50;
281    ZX_ERR_NOT_DIR                = -51;
282    ZX_ERR_NOT_FILE               = -52;
283    ZX_ERR_FILE_BIG               = -53;
284    ZX_ERR_NO_SPACE               = -54;
285    ZX_ERR_NOT_EMPTY              = -55;
286    ZX_ERR_STOP                   = -60;
287    ZX_ERR_NEXT                   = -61;
288    ZX_ERR_ASYNC                  = -62;
289    ZX_ERR_PROTOCOL_NOT_SUPPORTED = -70;
290    ZX_ERR_ADDRESS_UNREACHABLE    = -71;
291    ZX_ERR_ADDRESS_IN_USE         = -72;
292    ZX_ERR_NOT_CONNECTED          = -73;
293    ZX_ERR_CONNECTION_REFUSED     = -74;
294    ZX_ERR_CONNECTION_RESET       = -75;
295    ZX_ERR_CONNECTION_ABORTED     = -76;
296]);
297
298multiconst!(zx_signals_t, [
299    ZX_SIGNAL_NONE              = 0;
300    ZX_OBJECT_SIGNAL_ALL        = 0x00ffffff;
301    ZX_USER_SIGNAL_ALL          = 0xff000000;
302    ZX_OBJECT_SIGNAL_0          = 1 << 0;
303    ZX_OBJECT_SIGNAL_1          = 1 << 1;
304    ZX_OBJECT_SIGNAL_2          = 1 << 2;
305    ZX_OBJECT_SIGNAL_3          = 1 << 3;
306    ZX_OBJECT_SIGNAL_4          = 1 << 4;
307    ZX_OBJECT_SIGNAL_5          = 1 << 5;
308    ZX_OBJECT_SIGNAL_6          = 1 << 6;
309    ZX_OBJECT_SIGNAL_7          = 1 << 7;
310    ZX_OBJECT_SIGNAL_8          = 1 << 8;
311    ZX_OBJECT_SIGNAL_9          = 1 << 9;
312    ZX_OBJECT_SIGNAL_10         = 1 << 10;
313    ZX_OBJECT_SIGNAL_11         = 1 << 11;
314    ZX_OBJECT_SIGNAL_12         = 1 << 12;
315    ZX_OBJECT_SIGNAL_13         = 1 << 13;
316    ZX_OBJECT_SIGNAL_14         = 1 << 14;
317    ZX_OBJECT_SIGNAL_15         = 1 << 15;
318    ZX_OBJECT_SIGNAL_16         = 1 << 16;
319    ZX_OBJECT_SIGNAL_17         = 1 << 17;
320    ZX_OBJECT_SIGNAL_18         = 1 << 18;
321    ZX_OBJECT_SIGNAL_19         = 1 << 19;
322    ZX_OBJECT_SIGNAL_20         = 1 << 20;
323    ZX_OBJECT_SIGNAL_21         = 1 << 21;
324    ZX_OBJECT_SIGNAL_22         = 1 << 22;
325    ZX_OBJECT_HANDLE_CLOSED     = 1 << 23;
326    ZX_USER_SIGNAL_0            = 1 << 24;
327    ZX_USER_SIGNAL_1            = 1 << 25;
328    ZX_USER_SIGNAL_2            = 1 << 26;
329    ZX_USER_SIGNAL_3            = 1 << 27;
330    ZX_USER_SIGNAL_4            = 1 << 28;
331    ZX_USER_SIGNAL_5            = 1 << 29;
332    ZX_USER_SIGNAL_6            = 1 << 30;
333    ZX_USER_SIGNAL_7            = 1 << 31;
334
335    ZX_OBJECT_READABLE          = ZX_OBJECT_SIGNAL_0;
336    ZX_OBJECT_WRITABLE          = ZX_OBJECT_SIGNAL_1;
337    ZX_OBJECT_PEER_CLOSED       = ZX_OBJECT_SIGNAL_2;
338
339    // Cancelation (handle was closed while waiting with it)
340    ZX_SIGNAL_HANDLE_CLOSED     = ZX_OBJECT_HANDLE_CLOSED;
341
342    // Event
343    ZX_EVENT_SIGNALED           = ZX_OBJECT_SIGNAL_3;
344
345    // EventPair
346    ZX_EVENTPAIR_SIGNALED       = ZX_OBJECT_SIGNAL_3;
347    ZX_EVENTPAIR_PEER_CLOSED    = ZX_OBJECT_SIGNAL_2;
348
349    // Task signals (process, thread, job)
350    ZX_TASK_TERMINATED          = ZX_OBJECT_SIGNAL_3;
351
352    // Channel
353    ZX_CHANNEL_READABLE         = ZX_OBJECT_SIGNAL_0;
354    ZX_CHANNEL_WRITABLE         = ZX_OBJECT_SIGNAL_1;
355    ZX_CHANNEL_PEER_CLOSED      = ZX_OBJECT_SIGNAL_2;
356
357    // Clock
358    ZX_CLOCK_STARTED            = ZX_OBJECT_SIGNAL_4;
359    ZX_CLOCK_UPDATED            = ZX_OBJECT_SIGNAL_5;
360
361    // Socket
362    ZX_SOCKET_READABLE            = ZX_OBJECT_READABLE;
363    ZX_SOCKET_WRITABLE            = ZX_OBJECT_WRITABLE;
364    ZX_SOCKET_PEER_CLOSED         = ZX_OBJECT_PEER_CLOSED;
365    ZX_SOCKET_PEER_WRITE_DISABLED = ZX_OBJECT_SIGNAL_4;
366    ZX_SOCKET_WRITE_DISABLED      = ZX_OBJECT_SIGNAL_5;
367    ZX_SOCKET_READ_THRESHOLD      = ZX_OBJECT_SIGNAL_10;
368    ZX_SOCKET_WRITE_THRESHOLD     = ZX_OBJECT_SIGNAL_11;
369
370    // Resource
371    ZX_RESOURCE_DESTROYED       = ZX_OBJECT_SIGNAL_3;
372    ZX_RESOURCE_READABLE        = ZX_OBJECT_READABLE;
373    ZX_RESOURCE_WRITABLE        = ZX_OBJECT_WRITABLE;
374    ZX_RESOURCE_CHILD_ADDED     = ZX_OBJECT_SIGNAL_4;
375
376    // Fifo
377    ZX_FIFO_READABLE            = ZX_OBJECT_READABLE;
378    ZX_FIFO_WRITABLE            = ZX_OBJECT_WRITABLE;
379    ZX_FIFO_PEER_CLOSED         = ZX_OBJECT_PEER_CLOSED;
380
381    // Iob
382    ZX_IOB_PEER_CLOSED           = ZX_OBJECT_PEER_CLOSED;
383    ZX_IOB_SHARED_REGION_UPDATED = ZX_OBJECT_SIGNAL_3;
384
385    // Job
386    ZX_JOB_TERMINATED           = ZX_OBJECT_SIGNAL_3;
387    ZX_JOB_NO_JOBS              = ZX_OBJECT_SIGNAL_4;
388    ZX_JOB_NO_PROCESSES         = ZX_OBJECT_SIGNAL_5;
389
390    // Process
391    ZX_PROCESS_TERMINATED       = ZX_OBJECT_SIGNAL_3;
392
393    // Thread
394    ZX_THREAD_TERMINATED        = ZX_OBJECT_SIGNAL_3;
395    ZX_THREAD_RUNNING           = ZX_OBJECT_SIGNAL_4;
396    ZX_THREAD_SUSPENDED         = ZX_OBJECT_SIGNAL_5;
397
398    // Log
399    ZX_LOG_READABLE             = ZX_OBJECT_READABLE;
400    ZX_LOG_WRITABLE             = ZX_OBJECT_WRITABLE;
401
402    // Timer
403    ZX_TIMER_SIGNALED           = ZX_OBJECT_SIGNAL_3;
404
405    // Vmo
406    ZX_VMO_ZERO_CHILDREN        = ZX_OBJECT_SIGNAL_3;
407
408    // Counter
409    ZX_COUNTER_SIGNALED          = ZX_OBJECT_SIGNAL_3;
410    ZX_COUNTER_POSITIVE          = ZX_OBJECT_SIGNAL_4;
411    ZX_COUNTER_NON_POSITIVE      = ZX_OBJECT_SIGNAL_5;
412]);
413
414multiconst!(zx_obj_type_t, [
415    ZX_OBJ_TYPE_NONE                = 0;
416    ZX_OBJ_TYPE_PROCESS             = 1;
417    ZX_OBJ_TYPE_THREAD              = 2;
418    ZX_OBJ_TYPE_VMO                 = 3;
419    ZX_OBJ_TYPE_CHANNEL             = 4;
420    ZX_OBJ_TYPE_EVENT               = 5;
421    ZX_OBJ_TYPE_PORT                = 6;
422    ZX_OBJ_TYPE_INTERRUPT           = 9;
423    ZX_OBJ_TYPE_PCI_DEVICE          = 11;
424    ZX_OBJ_TYPE_DEBUGLOG            = 12;
425    ZX_OBJ_TYPE_SOCKET              = 14;
426    ZX_OBJ_TYPE_RESOURCE            = 15;
427    ZX_OBJ_TYPE_EVENTPAIR           = 16;
428    ZX_OBJ_TYPE_JOB                 = 17;
429    ZX_OBJ_TYPE_VMAR                = 18;
430    ZX_OBJ_TYPE_FIFO                = 19;
431    ZX_OBJ_TYPE_GUEST               = 20;
432    ZX_OBJ_TYPE_VCPU                = 21;
433    ZX_OBJ_TYPE_TIMER               = 22;
434    ZX_OBJ_TYPE_IOMMU               = 23;
435    ZX_OBJ_TYPE_BTI                 = 24;
436    ZX_OBJ_TYPE_PROFILE             = 25;
437    ZX_OBJ_TYPE_PMT                 = 26;
438    ZX_OBJ_TYPE_SUSPEND_TOKEN       = 27;
439    ZX_OBJ_TYPE_PAGER               = 28;
440    ZX_OBJ_TYPE_EXCEPTION           = 29;
441    ZX_OBJ_TYPE_CLOCK               = 30;
442    ZX_OBJ_TYPE_STREAM              = 31;
443    ZX_OBJ_TYPE_MSI                 = 32;
444    ZX_OBJ_TYPE_IOB                 = 33;
445    ZX_OBJ_TYPE_COUNTER             = 34;
446]);
447
448// System ABI commits to having no more than 64 object types.
449//
450// See zx_info_process_handle_stats_t for an example of a binary interface that
451// depends on having an upper bound for the number of object types.
452pub const ZX_OBJ_TYPE_UPPER_BOUND: usize = 64;
453
454// TODO: add an alias for this type in the C headers.
455multiconst!(u32, [
456    // Argument is a char[ZX_MAX_NAME_LEN].
457    ZX_PROP_NAME                      = 3;
458
459    // Argument is a uintptr_t.
460    #[cfg(target_arch = "x86_64")]
461    ZX_PROP_REGISTER_GS               = 2;
462    #[cfg(target_arch = "x86_64")]
463    ZX_PROP_REGISTER_FS               = 4;
464
465    // Argument is the value of ld.so's _dl_debug_addr, a uintptr_t.
466    ZX_PROP_PROCESS_DEBUG_ADDR        = 5;
467
468    // Argument is the base address of the vDSO mapping (or zero), a uintptr_t.
469    ZX_PROP_PROCESS_VDSO_BASE_ADDRESS = 6;
470
471    // Whether the dynamic loader should issue a debug trap when loading a shared
472    // library, either initially or when running (e.g. dlopen).
473    ZX_PROP_PROCESS_BREAK_ON_LOAD = 7;
474
475    // Argument is a size_t.
476    ZX_PROP_SOCKET_RX_THRESHOLD       = 12;
477    ZX_PROP_SOCKET_TX_THRESHOLD       = 13;
478
479    // Argument is a size_t, describing the number of packets a channel
480    // endpoint can have pending in its tx direction.
481    ZX_PROP_CHANNEL_TX_MSG_MAX        = 14;
482
483    // Terminate this job if the system is low on memory.
484    ZX_PROP_JOB_KILL_ON_OOM           = 15;
485
486    // Exception close behavior.
487    ZX_PROP_EXCEPTION_STATE           = 16;
488
489    // The size of the content in a VMO, in bytes.
490    ZX_PROP_VMO_CONTENT_SIZE          = 17;
491
492    // How an exception should be handled.
493    ZX_PROP_EXCEPTION_STRATEGY        = 18;
494
495    // Whether the stream is in append mode or not.
496    ZX_PROP_STREAM_MODE_APPEND        = 19;
497]);
498
499// Value for ZX_THREAD_STATE_SINGLE_STEP. The value can be 0 (not single-stepping), or 1
500// (single-stepping). Other values will give ZX_ERR_INVALID_ARGS.
501pub type zx_thread_state_single_step_t = u32;
502
503// Possible values for "kind" in zx_thread_read_state and zx_thread_write_state.
504multiconst!(zx_thread_state_topic_t, [
505    ZX_THREAD_STATE_GENERAL_REGS       = 0;
506    ZX_THREAD_STATE_FP_REGS            = 1;
507    ZX_THREAD_STATE_VECTOR_REGS        = 2;
508    // No 3 at the moment.
509    ZX_THREAD_STATE_DEBUG_REGS         = 4;
510    ZX_THREAD_STATE_SINGLE_STEP        = 5;
511]);
512
513// Possible values for "kind" in zx_vcpu_read_state and zx_vcpu_write_state.
514multiconst!(zx_vcpu_state_topic_t, [
515    ZX_VCPU_STATE   = 0;
516    ZX_VCPU_IO      = 1;
517]);
518
519// From //zircon/system/public/zircon/features.h
520multiconst!(u32, [
521    ZX_FEATURE_KIND_CPU                        = 0;
522    ZX_FEATURE_KIND_HW_BREAKPOINT_COUNT        = 1;
523    ZX_FEATURE_KIND_HW_WATCHPOINT_COUNT        = 2;
524    ZX_FEATURE_KIND_ADDRESS_TAGGING            = 3;
525    ZX_FEATURE_KIND_VM                         = 4;
526]);
527
528// From //zircon/system/public/zircon/features.h
529multiconst!(u32, [
530    ZX_HAS_CPU_FEATURES                   = 1 << 0;
531
532    ZX_VM_FEATURE_CAN_MAP_XOM             = 1 << 0;
533
534    ZX_ARM64_FEATURE_ISA_FP               = 1 << 1;
535    ZX_ARM64_FEATURE_ISA_ASIMD            = 1 << 2;
536    ZX_ARM64_FEATURE_ISA_AES              = 1 << 3;
537    ZX_ARM64_FEATURE_ISA_PMULL            = 1 << 4;
538    ZX_ARM64_FEATURE_ISA_SHA1             = 1 << 5;
539    ZX_ARM64_FEATURE_ISA_SHA256           = 1 << 6;
540    ZX_ARM64_FEATURE_ISA_CRC32            = 1 << 7;
541    ZX_ARM64_FEATURE_ISA_ATOMICS          = 1 << 8;
542    ZX_ARM64_FEATURE_ISA_RDM              = 1 << 9;
543    ZX_ARM64_FEATURE_ISA_SHA3             = 1 << 10;
544    ZX_ARM64_FEATURE_ISA_SM3              = 1 << 11;
545    ZX_ARM64_FEATURE_ISA_SM4              = 1 << 12;
546    ZX_ARM64_FEATURE_ISA_DP               = 1 << 13;
547    ZX_ARM64_FEATURE_ISA_DPB              = 1 << 14;
548    ZX_ARM64_FEATURE_ISA_FHM              = 1 << 15;
549    ZX_ARM64_FEATURE_ISA_TS               = 1 << 16;
550    ZX_ARM64_FEATURE_ISA_RNDR             = 1 << 17;
551    ZX_ARM64_FEATURE_ISA_SHA512           = 1 << 18;
552    ZX_ARM64_FEATURE_ISA_I8MM             = 1 << 19;
553    ZX_ARM64_FEATURE_ISA_SVE              = 1 << 20;
554    ZX_ARM64_FEATURE_ISA_ARM32            = 1 << 21;
555    ZX_ARM64_FEATURE_ISA_SHA2             = 1 << 6;
556    ZX_ARM64_FEATURE_ADDRESS_TAGGING_TBI  = 1 << 0;
557]);
558
559// From //zircon/system/public/zircon/syscalls/resource.h
560multiconst!(zx_rsrc_kind_t, [
561    ZX_RSRC_KIND_MMIO       = 0;
562    ZX_RSRC_KIND_IRQ        = 1;
563    ZX_RSRC_KIND_IOPORT     = 2;
564    ZX_RSRC_KIND_ROOT       = 3;
565    ZX_RSRC_KIND_SMC        = 4;
566    ZX_RSRC_KIND_SYSTEM     = 5;
567]);
568
569// From //zircon/system/public/zircon/syscalls/resource.h
570multiconst!(zx_rsrc_system_base_t, [
571    ZX_RSRC_SYSTEM_HYPERVISOR_BASE  = 0;
572    ZX_RSRC_SYSTEM_VMEX_BASE        = 1;
573    ZX_RSRC_SYSTEM_DEBUG_BASE       = 2;
574    ZX_RSRC_SYSTEM_INFO_BASE        = 3;
575    ZX_RSRC_SYSTEM_CPU_BASE         = 4;
576    ZX_RSRC_SYSTEM_POWER_BASE       = 5;
577    ZX_RSRC_SYSTEM_MEXEC_BASE       = 6;
578    ZX_RSRC_SYSTEM_ENERGY_INFO_BASE = 7;
579    ZX_RSRC_SYSTEM_IOMMU_BASE       = 8;
580    ZX_RSRC_SYSTEM_FRAMEBUFFER_BASE = 9;
581    ZX_RSRC_SYSTEM_PROFILE_BASE     = 10;
582    ZX_RSRC_SYSTEM_MSI_BASE         = 11;
583    ZX_RSRC_SYSTEM_DEBUGLOG_BASE    = 12;
584    ZX_RSRC_SYSTEM_STALL_BASE       = 13;
585    ZX_RSRC_SYSTEM_TRACING_BASE     = 14;
586]);
587
588// clock ids
589multiconst!(zx_clock_t, [
590    ZX_CLOCK_MONOTONIC = 0;
591    ZX_CLOCK_BOOT      = 1;
592]);
593
594// from //zircon/system/public/zircon/syscalls/clock.h
595multiconst!(u64, [
596    ZX_CLOCK_OPT_MONOTONIC = 1 << 0;
597    ZX_CLOCK_OPT_CONTINUOUS = 1 << 1;
598    ZX_CLOCK_OPT_AUTO_START = 1 << 2;
599    ZX_CLOCK_OPT_BOOT = 1 << 3;
600    ZX_CLOCK_OPT_MAPPABLE = 1 << 4;
601
602    // v1 clock update flags
603    ZX_CLOCK_UPDATE_OPTION_VALUE_VALID = 1 << 0;
604    ZX_CLOCK_UPDATE_OPTION_RATE_ADJUST_VALID = 1 << 1;
605    ZX_CLOCK_UPDATE_OPTION_ERROR_BOUND_VALID = 1 << 2;
606
607    // Additional v2 clock update flags
608    ZX_CLOCK_UPDATE_OPTION_REFERENCE_VALUE_VALID = 1 << 3;
609    ZX_CLOCK_UPDATE_OPTION_SYNTHETIC_VALUE_VALID = ZX_CLOCK_UPDATE_OPTION_VALUE_VALID;
610
611    ZX_CLOCK_ARGS_VERSION_1 = 1 << 58;
612    ZX_CLOCK_ARGS_VERSION_2 = 2 << 58;
613]);
614
615// from //zircon/system/public/zircon/syscalls/exception.h
616multiconst!(u32, [
617    ZX_EXCEPTION_CHANNEL_DEBUGGER = 1 << 0;
618    ZX_EXCEPTION_TARGET_JOB_DEBUGGER = 1 << 0;
619
620    // Returned when probing a thread for its blocked state.
621    ZX_EXCEPTION_CHANNEL_TYPE_NONE = 0;
622    ZX_EXCEPTION_CHANNEL_TYPE_DEBUGGER = 1;
623    ZX_EXCEPTION_CHANNEL_TYPE_THREAD = 2;
624    ZX_EXCEPTION_CHANNEL_TYPE_PROCESS = 3;
625    ZX_EXCEPTION_CHANNEL_TYPE_JOB = 4;
626    ZX_EXCEPTION_CHANNEL_TYPE_JOB_DEBUGGER = 5;
627]);
628
629/// A byte used only to control memory alignment. All padding bytes are considered equal
630/// regardless of their content.
631///
632/// Note that the kernel C/C++ struct definitions use explicit padding fields to ensure no implicit
633/// padding is added. This is important for security since implicit padding bytes are not always
634/// safely initialized. These explicit padding fields are mirrored in the Rust struct definitions
635/// to minimize the opportunities for mistakes and inconsistencies.
636#[repr(transparent)]
637#[derive(Copy, Clone, Eq, Default)]
638#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable, IntoBytes))]
639pub struct PadByte(u8);
640
641impl PartialEq for PadByte {
642    fn eq(&self, _other: &Self) -> bool {
643        true
644    }
645}
646
647impl Hash for PadByte {
648    fn hash<H: Hasher>(&self, state: &mut H) {
649        state.write_u8(0);
650    }
651}
652
653impl Debug for PadByte {
654    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
655        f.write_str("-")
656    }
657}
658
659#[repr(C)]
660#[derive(Debug, Clone, Eq, PartialEq)]
661pub struct zx_clock_create_args_v1_t {
662    pub backstop_time: zx_time_t,
663}
664
665#[repr(C)]
666#[derive(Debug, Default, Clone, Eq, PartialEq)]
667pub struct zx_clock_rate_t {
668    pub synthetic_ticks: u32,
669    pub reference_ticks: u32,
670}
671
672#[repr(C)]
673#[derive(Debug, Default, Clone, Eq, PartialEq)]
674pub struct zx_clock_transformation_t {
675    pub reference_offset: i64,
676    pub synthetic_offset: i64,
677    pub rate: zx_clock_rate_t,
678}
679
680#[repr(C)]
681#[derive(Debug, Default, Clone, Eq, PartialEq)]
682pub struct zx_clock_details_v1_t {
683    pub options: u64,
684    pub backstop_time: zx_time_t,
685    pub reference_ticks_to_synthetic: zx_clock_transformation_t,
686    pub reference_to_synthetic: zx_clock_transformation_t,
687    pub error_bound: u64,
688    pub query_ticks: zx_ticks_t,
689    pub last_value_update_ticks: zx_ticks_t,
690    pub last_rate_adjust_update_ticks: zx_ticks_t,
691    pub last_error_bounds_update_ticks: zx_ticks_t,
692    pub generation_counter: u32,
693    padding1: [PadByte; 4],
694}
695
696#[repr(C)]
697#[derive(Debug, Clone, Eq, PartialEq)]
698pub struct zx_clock_update_args_v1_t {
699    pub rate_adjust: i32,
700    padding1: [PadByte; 4],
701    pub value: i64,
702    pub error_bound: u64,
703}
704
705#[repr(C)]
706#[derive(Debug, Default, Clone, Eq, PartialEq)]
707pub struct zx_clock_update_args_v2_t {
708    pub rate_adjust: i32,
709    padding1: [PadByte; 4],
710    pub synthetic_value: i64,
711    pub reference_value: i64,
712    pub error_bound: u64,
713}
714
715multiconst!(zx_stream_seek_origin_t, [
716    ZX_STREAM_SEEK_ORIGIN_START        = 0;
717    ZX_STREAM_SEEK_ORIGIN_CURRENT      = 1;
718    ZX_STREAM_SEEK_ORIGIN_END          = 2;
719]);
720
721// Stream constants
722pub const ZX_STREAM_MODE_READ: u32 = 1 << 0;
723pub const ZX_STREAM_MODE_WRITE: u32 = 1 << 1;
724pub const ZX_STREAM_MODE_APPEND: u32 = 1 << 2;
725
726pub const ZX_STREAM_APPEND: u32 = 1 << 0;
727
728pub const ZX_CPRNG_ADD_ENTROPY_MAX_LEN: usize = 256;
729
730// Socket flags and limits.
731pub const ZX_SOCKET_STREAM: u32 = 0;
732pub const ZX_SOCKET_DATAGRAM: u32 = 1 << 0;
733pub const ZX_SOCKET_DISPOSITION_WRITE_DISABLED: u32 = 1 << 0;
734pub const ZX_SOCKET_DISPOSITION_WRITE_ENABLED: u32 = 1 << 1;
735
736// VM Object clone flags
737pub const ZX_VMO_CHILD_SNAPSHOT: u32 = 1 << 0;
738pub const ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE: u32 = 1 << 4;
739pub const ZX_VMO_CHILD_RESIZABLE: u32 = 1 << 2;
740pub const ZX_VMO_CHILD_SLICE: u32 = 1 << 3;
741pub const ZX_VMO_CHILD_NO_WRITE: u32 = 1 << 5;
742pub const ZX_VMO_CHILD_REFERENCE: u32 = 1 << 6;
743pub const ZX_VMO_CHILD_SNAPSHOT_MODIFIED: u32 = 1 << 7;
744
745// channel write size constants
746pub const ZX_CHANNEL_MAX_MSG_HANDLES: u32 = 64;
747pub const ZX_CHANNEL_MAX_MSG_BYTES: u32 = 65536;
748pub const ZX_CHANNEL_MAX_MSG_IOVEC: u32 = 8192;
749
750// fifo write size constants
751pub const ZX_FIFO_MAX_SIZE_BYTES: u32 = 4096;
752
753// Min/max page size constants
754#[cfg(target_arch = "x86_64")]
755pub const ZX_MIN_PAGE_SHIFT: u32 = 12;
756#[cfg(target_arch = "x86_64")]
757pub const ZX_MAX_PAGE_SHIFT: u32 = 21;
758
759#[cfg(target_arch = "aarch64")]
760pub const ZX_MIN_PAGE_SHIFT: u32 = 12;
761#[cfg(target_arch = "aarch64")]
762pub const ZX_MAX_PAGE_SHIFT: u32 = 16;
763
764#[cfg(target_arch = "riscv64")]
765pub const ZX_MIN_PAGE_SHIFT: u32 = 12;
766#[cfg(target_arch = "riscv64")]
767pub const ZX_MAX_PAGE_SHIFT: u32 = 21;
768
769// Task response codes if a process is externally killed
770pub const ZX_TASK_RETCODE_SYSCALL_KILL: i64 = -1024;
771pub const ZX_TASK_RETCODE_OOM_KILL: i64 = -1025;
772pub const ZX_TASK_RETCODE_POLICY_KILL: i64 = -1026;
773pub const ZX_TASK_RETCODE_VDSO_KILL: i64 = -1027;
774pub const ZX_TASK_RETCODE_EXCEPTION_KILL: i64 = -1028;
775
776// Resource flags.
777pub const ZX_RSRC_FLAG_EXCLUSIVE: zx_rsrc_flags_t = 0x00010000;
778
779// Topics for CPU performance info syscalls
780pub const ZX_CPU_PERF_SCALE: u32 = 1;
781pub const ZX_CPU_DEFAULT_PERF_SCALE: u32 = 2;
782pub const ZX_CPU_POWER_LIMIT: u32 = 3;
783
784// Cache policy flags.
785pub const ZX_CACHE_POLICY_CACHED: u32 = 0;
786pub const ZX_CACHE_POLICY_UNCACHED: u32 = 1;
787pub const ZX_CACHE_POLICY_UNCACHED_DEVICE: u32 = 2;
788pub const ZX_CACHE_POLICY_WRITE_COMBINING: u32 = 3;
789
790// Flag bits for zx_cache_flush.
791multiconst!(u32, [
792    ZX_CACHE_FLUSH_INSN         = 1 << 0;
793    ZX_CACHE_FLUSH_DATA         = 1 << 1;
794    ZX_CACHE_FLUSH_INVALIDATE   = 1 << 2;
795]);
796
797#[repr(C)]
798#[derive(Debug, Copy, Clone, Eq, PartialEq)]
799pub struct zx_wait_item_t {
800    pub handle: zx_handle_t,
801    pub waitfor: zx_signals_t,
802    pub pending: zx_signals_t,
803}
804
805#[repr(C)]
806#[derive(Debug, Copy, Clone, Eq, PartialEq)]
807pub struct zx_waitset_result_t {
808    pub cookie: u64,
809    pub status: zx_status_t,
810    pub observed: zx_signals_t,
811}
812
813#[repr(C)]
814#[derive(Debug, Copy, Clone, Eq, PartialEq)]
815pub struct zx_handle_info_t {
816    pub handle: zx_handle_t,
817    pub ty: zx_obj_type_t,
818    pub rights: zx_rights_t,
819    pub unused: u32,
820}
821
822pub const ZX_CHANNEL_READ_MAY_DISCARD: u32 = 1;
823pub const ZX_CHANNEL_WRITE_USE_IOVEC: u32 = 2;
824
825#[repr(C)]
826#[derive(Debug, Copy, Clone, Eq, PartialEq)]
827pub struct zx_channel_call_args_t {
828    pub wr_bytes: *const u8,
829    pub wr_handles: *const zx_handle_t,
830    pub rd_bytes: *mut u8,
831    pub rd_handles: *mut zx_handle_t,
832    pub wr_num_bytes: u32,
833    pub wr_num_handles: u32,
834    pub rd_num_bytes: u32,
835    pub rd_num_handles: u32,
836}
837
838#[repr(C)]
839#[derive(Debug, Copy, Clone, Eq, PartialEq)]
840pub struct zx_channel_call_etc_args_t {
841    pub wr_bytes: *const u8,
842    pub wr_handles: *mut zx_handle_disposition_t,
843    pub rd_bytes: *mut u8,
844    pub rd_handles: *mut zx_handle_info_t,
845    pub wr_num_bytes: u32,
846    pub wr_num_handles: u32,
847    pub rd_num_bytes: u32,
848    pub rd_num_handles: u32,
849}
850
851#[repr(C)]
852#[derive(Debug, Copy, Clone, Eq, PartialEq)]
853pub struct zx_channel_iovec_t {
854    pub buffer: *const u8,
855    pub capacity: u32,
856    padding1: [PadByte; 4],
857}
858
859impl Default for zx_channel_iovec_t {
860    fn default() -> Self {
861        Self {
862            buffer: std::ptr::null(),
863            capacity: Default::default(),
864            padding1: Default::default(),
865        }
866    }
867}
868
869#[repr(C)]
870#[derive(Debug, Copy, Clone, Eq, PartialEq)]
871pub struct zx_handle_disposition_t {
872    pub operation: zx_handle_op_t,
873    pub handle: zx_handle_t,
874    pub type_: zx_obj_type_t,
875    pub rights: zx_rights_t,
876    pub result: zx_status_t,
877}
878
879#[repr(C)]
880#[derive(Debug, Copy, Clone)]
881pub struct zx_iovec_t {
882    pub buffer: *const u8,
883    pub capacity: usize,
884}
885
886pub type zx_pci_irq_swizzle_lut_t = [[[u32; 4]; 8]; 32];
887
888#[repr(C)]
889#[derive(Debug, Copy, Clone, Eq, PartialEq)]
890pub struct zx_pci_init_arg_t {
891    pub dev_pin_to_global_irq: zx_pci_irq_swizzle_lut_t,
892    pub num_irqs: u32,
893    pub irqs: [zx_irq_t; 32],
894    pub ecam_window_count: u32,
895    // Note: the ecam_windows field is actually a variable size array.
896    // We use a fixed size array to match the C repr.
897    pub ecam_windows: [zx_ecam_window_t; 1],
898}
899
900#[repr(C)]
901#[derive(Debug, Copy, Clone, Eq, PartialEq)]
902pub struct zx_irq_t {
903    pub global_irq: u32,
904    pub level_triggered: bool,
905    pub active_high: bool,
906}
907
908#[repr(C)]
909#[derive(Debug, Copy, Clone, Eq, PartialEq)]
910pub struct zx_ecam_window_t {
911    pub base: u64,
912    pub size: usize,
913    pub bus_start: u8,
914    pub bus_end: u8,
915}
916
917#[repr(C)]
918#[derive(Debug, Copy, Clone, Eq, PartialEq)]
919pub struct zx_pcie_device_info_t {
920    pub vendor_id: u16,
921    pub device_id: u16,
922    pub base_class: u8,
923    pub sub_class: u8,
924    pub program_interface: u8,
925    pub revision_id: u8,
926    pub bus_id: u8,
927    pub dev_id: u8,
928    pub func_id: u8,
929}
930
931#[repr(C)]
932#[derive(Debug, Copy, Clone, Eq, PartialEq)]
933pub struct zx_pci_resource_t {
934    pub type_: u32,
935    pub size: usize,
936    // TODO: Actually a union
937    pub pio_addr: usize,
938}
939
940// TODO: Actually a union
941pub type zx_rrec_t = [u8; 64];
942
943// Ports V2
944#[repr(u32)]
945#[derive(Debug, Copy, Clone, Eq, PartialEq)]
946pub enum zx_packet_type_t {
947    ZX_PKT_TYPE_USER = 0,
948    ZX_PKT_TYPE_SIGNAL_ONE = 1,
949    ZX_PKT_TYPE_GUEST_BELL = 3,
950    ZX_PKT_TYPE_GUEST_MEM = 4,
951    ZX_PKT_TYPE_GUEST_IO = 5,
952    ZX_PKT_TYPE_GUEST_VCPU = 6,
953    ZX_PKT_TYPE_INTERRUPT = 7,
954    ZX_PKT_TYPE_PAGE_REQUEST = 9,
955    ZX_PKT_TYPE_PROCESSOR_POWER_LEVEL_TRANSITION_REQUEST = 10,
956    #[doc(hidden)]
957    __Nonexhaustive,
958}
959
960impl Default for zx_packet_type_t {
961    fn default() -> Self {
962        zx_packet_type_t::ZX_PKT_TYPE_USER
963    }
964}
965
966#[repr(u32)]
967#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
968pub enum zx_packet_guest_vcpu_type_t {
969    #[default]
970    ZX_PKT_GUEST_VCPU_INTERRUPT = 0,
971    ZX_PKT_GUEST_VCPU_STARTUP = 1,
972    ZX_PKT_GUEST_VCPU_EXIT = 2,
973    #[doc(hidden)]
974    __Nonexhaustive,
975}
976
977#[repr(C)]
978#[derive(Debug, Copy, Clone, Eq, PartialEq)]
979pub struct zx_packet_signal_t {
980    pub trigger: zx_signals_t,
981    pub observed: zx_signals_t,
982    pub count: u64,
983    pub timestamp: zx_time_t,
984}
985
986pub const ZX_WAIT_ASYNC_TIMESTAMP: u32 = 1;
987pub const ZX_WAIT_ASYNC_EDGE: u32 = 2;
988pub const ZX_WAIT_ASYNC_BOOT_TIMESTAMP: u32 = 4;
989
990// Actually a union of different integer types, but this should be good enough.
991pub type zx_packet_user_t = [u8; 32];
992
993#[repr(C)]
994#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
995pub struct zx_port_packet_t {
996    pub key: u64,
997    pub packet_type: zx_packet_type_t,
998    pub status: i32,
999    pub union: [u8; 32],
1000}
1001
1002#[repr(C)]
1003#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1004pub struct zx_packet_guest_bell_t {
1005    pub addr: zx_gpaddr_t,
1006}
1007
1008#[repr(C)]
1009#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1010pub struct zx_packet_guest_io_t {
1011    pub port: u16,
1012    pub access_size: u8,
1013    pub input: bool,
1014    pub data: [u8; 4],
1015}
1016
1017#[repr(C)]
1018#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1019#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable))]
1020pub struct zx_packet_guest_vcpu_interrupt_t {
1021    pub mask: u64,
1022    pub vector: u8,
1023    padding1: [PadByte; 7],
1024}
1025
1026#[repr(C)]
1027#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1028#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable))]
1029pub struct zx_packet_guest_vcpu_startup_t {
1030    pub id: u64,
1031    pub entry: zx_gpaddr_t,
1032}
1033
1034#[repr(C)]
1035#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
1036#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable))]
1037pub struct zx_packet_guest_vcpu_exit_t {
1038    pub retcode: i64,
1039    padding1: [PadByte; 8],
1040}
1041
1042#[repr(C)]
1043#[derive(Copy, Clone)]
1044#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable))]
1045pub union zx_packet_guest_vcpu_union_t {
1046    pub interrupt: zx_packet_guest_vcpu_interrupt_t,
1047    pub startup: zx_packet_guest_vcpu_startup_t,
1048    pub exit: zx_packet_guest_vcpu_exit_t,
1049}
1050
1051#[cfg(feature = "zerocopy")]
1052impl Default for zx_packet_guest_vcpu_union_t {
1053    fn default() -> Self {
1054        Self::new_zeroed()
1055    }
1056}
1057
1058#[repr(C)]
1059#[derive(Copy, Clone, Default)]
1060pub struct zx_packet_guest_vcpu_t {
1061    pub r#type: zx_packet_guest_vcpu_type_t,
1062    padding1: [PadByte; 4],
1063    pub union: zx_packet_guest_vcpu_union_t,
1064    padding2: [PadByte; 8],
1065}
1066
1067impl PartialEq for zx_packet_guest_vcpu_t {
1068    fn eq(&self, other: &Self) -> bool {
1069        if self.r#type != other.r#type {
1070            return false;
1071        }
1072        match self.r#type {
1073            zx_packet_guest_vcpu_type_t::ZX_PKT_GUEST_VCPU_INTERRUPT => unsafe {
1074                self.union.interrupt == other.union.interrupt
1075            },
1076            zx_packet_guest_vcpu_type_t::ZX_PKT_GUEST_VCPU_STARTUP => unsafe {
1077                self.union.startup == other.union.startup
1078            },
1079            zx_packet_guest_vcpu_type_t::ZX_PKT_GUEST_VCPU_EXIT => unsafe {
1080                self.union.exit == other.union.exit
1081            },
1082            // No equality relationship is defined for invalid types.
1083            _ => false,
1084        }
1085    }
1086}
1087
1088impl Eq for zx_packet_guest_vcpu_t {}
1089
1090impl Debug for zx_packet_guest_vcpu_t {
1091    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1092        match self.r#type {
1093            zx_packet_guest_vcpu_type_t::ZX_PKT_GUEST_VCPU_INTERRUPT => {
1094                write!(f, "type: {:?} union: {:?}", self.r#type, unsafe { self.union.interrupt })
1095            }
1096            zx_packet_guest_vcpu_type_t::ZX_PKT_GUEST_VCPU_STARTUP => {
1097                write!(f, "type: {:?} union: {:?}", self.r#type, unsafe { self.union.startup })
1098            }
1099            zx_packet_guest_vcpu_type_t::ZX_PKT_GUEST_VCPU_EXIT => {
1100                write!(f, "type: {:?} union: {:?}", self.r#type, unsafe { self.union.exit })
1101            }
1102            _ => panic!("unexpected VCPU packet type"),
1103        }
1104    }
1105}
1106
1107#[repr(C)]
1108#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
1109pub struct zx_packet_page_request_t {
1110    pub command: zx_page_request_command_t,
1111    pub flags: u16,
1112    padding1: [PadByte; 4],
1113    pub offset: u64,
1114    pub length: u64,
1115    padding2: [PadByte; 8],
1116}
1117
1118#[repr(u16)]
1119#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
1120pub enum zx_page_request_command_t {
1121    #[default]
1122    ZX_PAGER_VMO_READ = 0x0000,
1123    ZX_PAGER_VMO_COMPLETE = 0x0001,
1124    ZX_PAGER_VMO_DIRTY = 0x0002,
1125    #[doc(hidden)]
1126    __Nonexhaustive,
1127}
1128
1129multiconst!(u32, [
1130    ZX_PAGER_OP_FAIL = 1;
1131    ZX_PAGER_OP_DIRTY = 2;
1132    ZX_PAGER_OP_WRITEBACK_BEGIN = 3;
1133    ZX_PAGER_OP_WRITEBACK_END = 4;
1134]);
1135
1136pub type zx_excp_type_t = u32;
1137
1138multiconst!(zx_excp_type_t, [
1139    ZX_EXCP_GENERAL               = 0x008;
1140    ZX_EXCP_FATAL_PAGE_FAULT      = 0x108;
1141    ZX_EXCP_UNDEFINED_INSTRUCTION = 0x208;
1142    ZX_EXCP_SW_BREAKPOINT         = 0x308;
1143    ZX_EXCP_HW_BREAKPOINT         = 0x408;
1144    ZX_EXCP_UNALIGNED_ACCESS      = 0x508;
1145
1146    ZX_EXCP_SYNTH                 = 0x8000;
1147
1148    ZX_EXCP_THREAD_STARTING       = 0x008 | ZX_EXCP_SYNTH;
1149    ZX_EXCP_THREAD_EXITING        = 0x108 | ZX_EXCP_SYNTH;
1150    ZX_EXCP_POLICY_ERROR          = 0x208 | ZX_EXCP_SYNTH;
1151    ZX_EXCP_PROCESS_STARTING      = 0x308 | ZX_EXCP_SYNTH;
1152    ZX_EXCP_USER                  = 0x309 | ZX_EXCP_SYNTH;
1153]);
1154
1155multiconst!(u32, [
1156    ZX_EXCP_USER_CODE_PROCESS_NAME_CHANGED = 0x0001;
1157
1158    ZX_EXCP_USER_CODE_USER0                = 0xF000;
1159    ZX_EXCP_USER_CODE_USER1                = 0xF001;
1160    ZX_EXCP_USER_CODE_USER2                = 0xF002;
1161]);
1162
1163#[repr(C)]
1164#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1165#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable, IntoBytes))]
1166pub struct zx_exception_info_t {
1167    pub pid: zx_koid_t,
1168    pub tid: zx_koid_t,
1169    pub type_: zx_excp_type_t,
1170    padding1: [PadByte; 4],
1171}
1172
1173#[repr(C)]
1174#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, KnownLayout, FromBytes, Immutable)]
1175pub struct zx_x86_64_exc_data_t {
1176    pub vector: u64,
1177    pub err_code: u64,
1178    pub cr2: u64,
1179}
1180
1181#[repr(C)]
1182#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, FromBytes, Immutable)]
1183pub struct zx_arm64_exc_data_t {
1184    pub esr: u32,
1185    padding1: [PadByte; 4],
1186    pub far: u64,
1187    padding2: [PadByte; 8],
1188}
1189
1190#[repr(C)]
1191#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, FromBytes, Immutable)]
1192pub struct zx_riscv64_exc_data_t {
1193    pub cause: u64,
1194    pub tval: u64,
1195    padding1: [PadByte; 8],
1196}
1197
1198#[repr(C)]
1199#[derive(Copy, Clone, KnownLayout, FromBytes, Immutable)]
1200pub union zx_exception_header_arch_t {
1201    pub x86_64: zx_x86_64_exc_data_t,
1202    pub arm_64: zx_arm64_exc_data_t,
1203    pub riscv_64: zx_riscv64_exc_data_t,
1204}
1205
1206impl Debug for zx_exception_header_arch_t {
1207    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1208        write!(f, "zx_exception_header_arch_t")
1209    }
1210}
1211
1212#[repr(C)]
1213#[derive(Debug, Copy, Clone, Eq, PartialEq, KnownLayout, FromBytes, Immutable)]
1214pub struct zx_exception_header_t {
1215    pub size: u32,
1216    pub type_: zx_excp_type_t,
1217}
1218
1219pub type zx_excp_policy_code_t = u32;
1220
1221multiconst!(zx_excp_policy_code_t, [
1222    ZX_EXCP_POLICY_CODE_BAD_HANDLE              = 0;
1223    ZX_EXCP_POLICY_CODE_WRONG_OBJECT            = 1;
1224    ZX_EXCP_POLICY_CODE_VMAR_WX                 = 2;
1225    ZX_EXCP_POLICY_CODE_NEW_ANY                 = 3;
1226    ZX_EXCP_POLICY_CODE_NEW_VMO                 = 4;
1227    ZX_EXCP_POLICY_CODE_NEW_CHANNEL             = 5;
1228    ZX_EXCP_POLICY_CODE_NEW_EVENT               = 6;
1229    ZX_EXCP_POLICY_CODE_NEW_EVENTPAIR           = 7;
1230    ZX_EXCP_POLICY_CODE_NEW_PORT                = 8;
1231    ZX_EXCP_POLICY_CODE_NEW_SOCKET              = 9;
1232    ZX_EXCP_POLICY_CODE_NEW_FIFO                = 10;
1233    ZX_EXCP_POLICY_CODE_NEW_TIMER               = 11;
1234    ZX_EXCP_POLICY_CODE_NEW_PROCESS             = 12;
1235    ZX_EXCP_POLICY_CODE_NEW_PROFILE             = 13;
1236    ZX_EXCP_POLICY_CODE_NEW_PAGER               = 14;
1237    ZX_EXCP_POLICY_CODE_AMBIENT_MARK_VMO_EXEC   = 15;
1238    ZX_EXCP_POLICY_CODE_CHANNEL_FULL_WRITE      = 16;
1239    ZX_EXCP_POLICY_CODE_PORT_TOO_MANY_PACKETS   = 17;
1240    ZX_EXCP_POLICY_CODE_BAD_SYSCALL             = 18;
1241    ZX_EXCP_POLICY_CODE_PORT_TOO_MANY_OBSERVERS = 19;
1242    ZX_EXCP_POLICY_CODE_HANDLE_LEAK             = 20;
1243    ZX_EXCP_POLICY_CODE_NEW_IOB                 = 21;
1244]);
1245
1246#[repr(C)]
1247#[derive(Debug, Copy, Clone, KnownLayout, FromBytes, Immutable)]
1248pub struct zx_exception_context_t {
1249    pub arch: zx_exception_header_arch_t,
1250    pub synth_code: zx_excp_policy_code_t,
1251    pub synth_data: u32,
1252}
1253
1254#[repr(C)]
1255#[derive(Debug, Copy, Clone, KnownLayout, FromBytes, Immutable)]
1256pub struct zx_exception_report_t {
1257    pub header: zx_exception_header_t,
1258    pub context: zx_exception_context_t,
1259}
1260
1261pub type zx_exception_state_t = u32;
1262
1263multiconst!(zx_exception_state_t, [
1264    ZX_EXCEPTION_STATE_TRY_NEXT    = 0;
1265    ZX_EXCEPTION_STATE_HANDLED     = 1;
1266    ZX_EXCEPTION_STATE_THREAD_EXIT = 2;
1267]);
1268
1269pub type zx_exception_strategy_t = u32;
1270
1271multiconst!(zx_exception_state_t, [
1272    ZX_EXCEPTION_STRATEGY_FIRST_CHANCE   = 0;
1273    ZX_EXCEPTION_STRATEGY_SECOND_CHANCE  = 1;
1274]);
1275
1276#[cfg(target_arch = "x86_64")]
1277#[repr(C)]
1278#[derive(Default, Copy, Clone, Eq, PartialEq, KnownLayout, FromBytes, Immutable)]
1279pub struct zx_thread_state_general_regs_t {
1280    pub rax: u64,
1281    pub rbx: u64,
1282    pub rcx: u64,
1283    pub rdx: u64,
1284    pub rsi: u64,
1285    pub rdi: u64,
1286    pub rbp: u64,
1287    pub rsp: u64,
1288    pub r8: u64,
1289    pub r9: u64,
1290    pub r10: u64,
1291    pub r11: u64,
1292    pub r12: u64,
1293    pub r13: u64,
1294    pub r14: u64,
1295    pub r15: u64,
1296    pub rip: u64,
1297    pub rflags: u64,
1298    pub fs_base: u64,
1299    pub gs_base: u64,
1300}
1301
1302#[cfg(target_arch = "x86_64")]
1303impl std::fmt::Debug for zx_thread_state_general_regs_t {
1304    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1305        f.debug_struct(std::any::type_name::<Self>())
1306            .field("rax", &format_args!("{:#x}", self.rax))
1307            .field("rbx", &format_args!("{:#x}", self.rbx))
1308            .field("rcx", &format_args!("{:#x}", self.rcx))
1309            .field("rdx", &format_args!("{:#x}", self.rdx))
1310            .field("rsi", &format_args!("{:#x}", self.rsi))
1311            .field("rdi", &format_args!("{:#x}", self.rdi))
1312            .field("rbp", &format_args!("{:#x}", self.rbp))
1313            .field("rsp", &format_args!("{:#x}", self.rsp))
1314            .field("r8", &format_args!("{:#x}", self.r8))
1315            .field("r9", &format_args!("{:#x}", self.r9))
1316            .field("r10", &format_args!("{:#x}", self.r10))
1317            .field("r11", &format_args!("{:#x}", self.r11))
1318            .field("r12", &format_args!("{:#x}", self.r12))
1319            .field("r13", &format_args!("{:#x}", self.r13))
1320            .field("r14", &format_args!("{:#x}", self.r14))
1321            .field("r15", &format_args!("{:#x}", self.r15))
1322            .field("rip", &format_args!("{:#x}", self.rip))
1323            .field("rflags", &format_args!("{:#x}", self.rflags))
1324            .field("fs_base", &format_args!("{:#x}", self.fs_base))
1325            .field("gs_base", &format_args!("{:#x}", self.gs_base))
1326            .finish()
1327    }
1328}
1329
1330#[cfg(target_arch = "x86_64")]
1331impl From<&zx_restricted_state_t> for zx_thread_state_general_regs_t {
1332    fn from(state: &zx_restricted_state_t) -> Self {
1333        Self {
1334            rdi: state.rdi,
1335            rsi: state.rsi,
1336            rbp: state.rbp,
1337            rbx: state.rbx,
1338            rdx: state.rdx,
1339            rcx: state.rcx,
1340            rax: state.rax,
1341            rsp: state.rsp,
1342            r8: state.r8,
1343            r9: state.r9,
1344            r10: state.r10,
1345            r11: state.r11,
1346            r12: state.r12,
1347            r13: state.r13,
1348            r14: state.r14,
1349            r15: state.r15,
1350            rip: state.ip,
1351            rflags: state.flags,
1352            fs_base: state.fs_base,
1353            gs_base: state.gs_base,
1354        }
1355    }
1356}
1357
1358#[cfg(target_arch = "aarch64")]
1359multiconst!(u64, [
1360    ZX_REG_CPSR_ARCH_32_MASK = 0x10;
1361    ZX_REG_CPSR_THUMB_MASK = 0x20;
1362]);
1363
1364#[cfg(target_arch = "aarch64")]
1365#[repr(C)]
1366#[derive(Default, Copy, Clone, Eq, PartialEq)]
1367pub struct zx_thread_state_general_regs_t {
1368    pub r: [u64; 30],
1369    pub lr: u64,
1370    pub sp: u64,
1371    pub pc: u64,
1372    pub cpsr: u64,
1373    pub tpidr: u64,
1374}
1375
1376#[cfg(target_arch = "aarch64")]
1377impl std::fmt::Debug for zx_thread_state_general_regs_t {
1378    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1379        struct RegisterAsHex(u64);
1380        impl std::fmt::Debug for RegisterAsHex {
1381            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1382                write!(f, "{:#x}", self.0)
1383            }
1384        }
1385
1386        f.debug_struct(std::any::type_name::<Self>())
1387            .field("r", &self.r.map(RegisterAsHex))
1388            .field("lr", &format_args!("{:#x}", self.lr))
1389            .field("sp", &format_args!("{:#x}", self.sp))
1390            .field("pc", &format_args!("{:#x}", self.pc))
1391            .field("cpsr", &format_args!("{:#x}", self.cpsr))
1392            .field("tpidr", &format_args!("{:#x}", self.tpidr))
1393            .finish()
1394    }
1395}
1396
1397#[cfg(target_arch = "aarch64")]
1398impl From<&zx_restricted_state_t> for zx_thread_state_general_regs_t {
1399    fn from(state: &zx_restricted_state_t) -> Self {
1400        if state.cpsr as u64 & ZX_REG_CPSR_ARCH_32_MASK == ZX_REG_CPSR_ARCH_32_MASK {
1401            // aarch32
1402            Self {
1403                r: [
1404                    state.r[0],
1405                    state.r[1],
1406                    state.r[2],
1407                    state.r[3],
1408                    state.r[4],
1409                    state.r[5],
1410                    state.r[6],
1411                    state.r[7],
1412                    state.r[8],
1413                    state.r[9],
1414                    state.r[10],
1415                    state.r[11],
1416                    state.r[12],
1417                    state.r[13],
1418                    state.r[14],
1419                    state.pc, // ELR overwrites this.
1420                    state.r[16],
1421                    state.r[17],
1422                    state.r[18],
1423                    state.r[19],
1424                    state.r[20],
1425                    state.r[21],
1426                    state.r[22],
1427                    state.r[23],
1428                    state.r[24],
1429                    state.r[25],
1430                    state.r[26],
1431                    state.r[27],
1432                    state.r[28],
1433                    state.r[29],
1434                ],
1435                lr: state.r[14], // R[14] for aarch32
1436                sp: state.r[13], // R[13] for aarch32
1437                // TODO(https://fxbug.dev/379669623) Should it be checked for thumb and make
1438                // sure it isn't over incrementing?
1439                pc: state.pc, // Zircon populated this from elr.
1440                cpsr: state.cpsr as u64,
1441                tpidr: state.tpidr_el0,
1442            }
1443        } else {
1444            Self {
1445                r: [
1446                    state.r[0],
1447                    state.r[1],
1448                    state.r[2],
1449                    state.r[3],
1450                    state.r[4],
1451                    state.r[5],
1452                    state.r[6],
1453                    state.r[7],
1454                    state.r[8],
1455                    state.r[9],
1456                    state.r[10],
1457                    state.r[11],
1458                    state.r[12],
1459                    state.r[13],
1460                    state.r[14],
1461                    state.r[15],
1462                    state.r[16],
1463                    state.r[17],
1464                    state.r[18],
1465                    state.r[19],
1466                    state.r[20],
1467                    state.r[21],
1468                    state.r[22],
1469                    state.r[23],
1470                    state.r[24],
1471                    state.r[25],
1472                    state.r[26],
1473                    state.r[27],
1474                    state.r[28],
1475                    state.r[29],
1476                ],
1477                lr: state.r[30],
1478                sp: state.sp,
1479                pc: state.pc,
1480                cpsr: state.cpsr as u64,
1481                tpidr: state.tpidr_el0,
1482            }
1483        }
1484    }
1485}
1486
1487#[cfg(target_arch = "riscv64")]
1488#[repr(C)]
1489#[derive(Default, Copy, Clone, Eq, PartialEq)]
1490pub struct zx_thread_state_general_regs_t {
1491    pub pc: u64,
1492    pub ra: u64,  // x1
1493    pub sp: u64,  // x2
1494    pub gp: u64,  // x3
1495    pub tp: u64,  // x4
1496    pub t0: u64,  // x5
1497    pub t1: u64,  // x6
1498    pub t2: u64,  // x7
1499    pub s0: u64,  // x8
1500    pub s1: u64,  // x9
1501    pub a0: u64,  // x10
1502    pub a1: u64,  // x11
1503    pub a2: u64,  // x12
1504    pub a3: u64,  // x13
1505    pub a4: u64,  // x14
1506    pub a5: u64,  // x15
1507    pub a6: u64,  // x16
1508    pub a7: u64,  // x17
1509    pub s2: u64,  // x18
1510    pub s3: u64,  // x19
1511    pub s4: u64,  // x20
1512    pub s5: u64,  // x21
1513    pub s6: u64,  // x22
1514    pub s7: u64,  // x23
1515    pub s8: u64,  // x24
1516    pub s9: u64,  // x25
1517    pub s10: u64, // x26
1518    pub s11: u64, // x27
1519    pub t3: u64,  // x28
1520    pub t4: u64,  // x29
1521    pub t5: u64,  // x30
1522    pub t6: u64,  // x31
1523}
1524
1525#[cfg(target_arch = "riscv64")]
1526impl std::fmt::Debug for zx_thread_state_general_regs_t {
1527    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1528        f.debug_struct(std::any::type_name::<Self>())
1529            .field("pc", &format_args!("{:#x}", self.pc))
1530            .field("ra", &format_args!("{:#x}", self.ra)) // x1
1531            .field("sp", &format_args!("{:#x}", self.sp)) // x2
1532            .field("gp", &format_args!("{:#x}", self.gp)) // x3
1533            .field("tp", &format_args!("{:#x}", self.tp)) // x4
1534            .field("t0", &format_args!("{:#x}", self.t0)) // x5
1535            .field("t1", &format_args!("{:#x}", self.t1)) // x6
1536            .field("t2", &format_args!("{:#x}", self.t2)) // x7
1537            .field("s0", &format_args!("{:#x}", self.s0)) // x8
1538            .field("s1", &format_args!("{:#x}", self.s1)) // x9
1539            .field("a0", &format_args!("{:#x}", self.a0)) // x10
1540            .field("a1", &format_args!("{:#x}", self.a1)) // x11
1541            .field("a2", &format_args!("{:#x}", self.a2)) // x12
1542            .field("a3", &format_args!("{:#x}", self.a3)) // x13
1543            .field("a4", &format_args!("{:#x}", self.a4)) // x14
1544            .field("a5", &format_args!("{:#x}", self.a5)) // x15
1545            .field("a6", &format_args!("{:#x}", self.a6)) // x16
1546            .field("a7", &format_args!("{:#x}", self.a7)) // x17
1547            .field("s2", &format_args!("{:#x}", self.s2)) // x18
1548            .field("s3", &format_args!("{:#x}", self.s3)) // x19
1549            .field("s4", &format_args!("{:#x}", self.s4)) // x20
1550            .field("s5", &format_args!("{:#x}", self.s5)) // x21
1551            .field("s6", &format_args!("{:#x}", self.s6)) // x22
1552            .field("s7", &format_args!("{:#x}", self.s7)) // x23
1553            .field("s8", &format_args!("{:#x}", self.s8)) // x24
1554            .field("s9", &format_args!("{:#x}", self.s9)) // x25
1555            .field("s10", &format_args!("{:#x}", self.s10)) // x26
1556            .field("s11", &format_args!("{:#x}", self.s11)) // x27
1557            .field("t3", &format_args!("{:#x}", self.t3)) // x28
1558            .field("t4", &format_args!("{:#x}", self.t4)) // x29
1559            .field("t5", &format_args!("{:#x}", self.t5)) // x30
1560            .field("t6", &format_args!("{:#x}", self.t6)) // x31
1561            .finish()
1562    }
1563}
1564
1565multiconst!(zx_restricted_reason_t, [
1566    ZX_RESTRICTED_REASON_SYSCALL = 0;
1567    ZX_RESTRICTED_REASON_EXCEPTION = 1;
1568    ZX_RESTRICTED_REASON_KICK = 2;
1569]);
1570
1571#[cfg(target_arch = "x86_64")]
1572#[repr(C)]
1573#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1574pub struct zx_restricted_state_t {
1575    pub rdi: u64,
1576    pub rsi: u64,
1577    pub rbp: u64,
1578    pub rbx: u64,
1579    pub rdx: u64,
1580    pub rcx: u64,
1581    pub rax: u64,
1582    pub rsp: u64,
1583    pub r8: u64,
1584    pub r9: u64,
1585    pub r10: u64,
1586    pub r11: u64,
1587    pub r12: u64,
1588    pub r13: u64,
1589    pub r14: u64,
1590    pub r15: u64,
1591    pub ip: u64,
1592    pub flags: u64,
1593    pub fs_base: u64,
1594    pub gs_base: u64,
1595}
1596
1597#[cfg(target_arch = "x86_64")]
1598impl From<&zx_thread_state_general_regs_t> for zx_restricted_state_t {
1599    fn from(registers: &zx_thread_state_general_regs_t) -> Self {
1600        Self {
1601            rdi: registers.rdi,
1602            rsi: registers.rsi,
1603            rbp: registers.rbp,
1604            rbx: registers.rbx,
1605            rdx: registers.rdx,
1606            rcx: registers.rcx,
1607            rax: registers.rax,
1608            rsp: registers.rsp,
1609            r8: registers.r8,
1610            r9: registers.r9,
1611            r10: registers.r10,
1612            r11: registers.r11,
1613            r12: registers.r12,
1614            r13: registers.r13,
1615            r14: registers.r14,
1616            r15: registers.r15,
1617            ip: registers.rip,
1618            flags: registers.rflags,
1619            fs_base: registers.fs_base,
1620            gs_base: registers.gs_base,
1621        }
1622    }
1623}
1624
1625#[cfg(target_arch = "aarch64")]
1626#[repr(C)]
1627#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1628pub struct zx_restricted_state_t {
1629    pub r: [u64; 31], // Note: r[30] is `lr` which is separated out in the general regs.
1630    pub sp: u64,
1631    pub pc: u64,
1632    pub tpidr_el0: u64,
1633    // Contains only the user-controllable upper 4-bits (NZCV).
1634    pub cpsr: u32,
1635    padding1: [PadByte; 4],
1636}
1637
1638#[cfg(target_arch = "aarch64")]
1639impl From<&zx_thread_state_general_regs_t> for zx_restricted_state_t {
1640    fn from(registers: &zx_thread_state_general_regs_t) -> Self {
1641        Self {
1642            r: [
1643                registers.r[0],
1644                registers.r[1],
1645                registers.r[2],
1646                registers.r[3],
1647                registers.r[4],
1648                registers.r[5],
1649                registers.r[6],
1650                registers.r[7],
1651                registers.r[8],
1652                registers.r[9],
1653                registers.r[10],
1654                registers.r[11],
1655                registers.r[12],
1656                registers.r[13],
1657                registers.r[14],
1658                registers.r[15],
1659                registers.r[16],
1660                registers.r[17],
1661                registers.r[18],
1662                registers.r[19],
1663                registers.r[20],
1664                registers.r[21],
1665                registers.r[22],
1666                registers.r[23],
1667                registers.r[24],
1668                registers.r[25],
1669                registers.r[26],
1670                registers.r[27],
1671                registers.r[28],
1672                registers.r[29],
1673                registers.lr, // for compat this works nicely with zircon.
1674            ],
1675            pc: registers.pc,
1676            tpidr_el0: registers.tpidr,
1677            sp: registers.sp,
1678            cpsr: registers.cpsr as u32,
1679            padding1: Default::default(),
1680        }
1681    }
1682}
1683
1684#[cfg(target_arch = "riscv64")]
1685pub type zx_restricted_state_t = zx_thread_state_general_regs_t;
1686
1687#[cfg(target_arch = "riscv64")]
1688impl From<&zx_thread_state_general_regs_t> for zx_restricted_state_t {
1689    fn from(registers: &zx_thread_state_general_regs_t) -> Self {
1690        *registers
1691    }
1692}
1693
1694#[repr(C)]
1695#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1696#[cfg(any(target_arch = "aarch64", target_arch = "x86_64", target_arch = "riscv64"))]
1697pub struct zx_restricted_syscall_t {
1698    pub state: zx_restricted_state_t,
1699}
1700
1701#[repr(C)]
1702#[derive(Copy, Clone)]
1703#[cfg(any(target_arch = "aarch64", target_arch = "x86_64", target_arch = "riscv64"))]
1704pub struct zx_restricted_exception_t {
1705    pub state: zx_restricted_state_t,
1706    pub exception: zx_exception_report_t,
1707}
1708
1709#[cfg(target_arch = "x86_64")]
1710#[repr(C)]
1711#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1712pub struct zx_vcpu_state_t {
1713    pub rax: u64,
1714    pub rcx: u64,
1715    pub rdx: u64,
1716    pub rbx: u64,
1717    pub rsp: u64,
1718    pub rbp: u64,
1719    pub rsi: u64,
1720    pub rdi: u64,
1721    pub r8: u64,
1722    pub r9: u64,
1723    pub r10: u64,
1724    pub r11: u64,
1725    pub r12: u64,
1726    pub r13: u64,
1727    pub r14: u64,
1728    pub r15: u64,
1729    // Contains only the user-controllable lower 32-bits.
1730    pub rflags: u64,
1731}
1732
1733#[cfg(target_arch = "aarch64")]
1734#[repr(C)]
1735#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1736pub struct zx_vcpu_state_t {
1737    pub x: [u64; 31],
1738    pub sp: u64,
1739    // Contains only the user-controllable upper 4-bits (NZCV).
1740    pub cpsr: u32,
1741    padding1: [PadByte; 4],
1742}
1743
1744#[cfg(target_arch = "riscv64")]
1745#[repr(C)]
1746#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1747pub struct zx_vcpu_state_t {
1748    pub empty: u32,
1749}
1750
1751#[repr(C)]
1752#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1753pub struct zx_vcpu_io_t {
1754    pub access_size: u8,
1755    padding1: [PadByte; 3],
1756    pub data: [u8; 4],
1757}
1758
1759#[cfg(target_arch = "aarch64")]
1760#[repr(C)]
1761#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1762pub struct zx_packet_guest_mem_t {
1763    pub addr: zx_gpaddr_t,
1764    pub access_size: u8,
1765    pub sign_extend: bool,
1766    pub xt: u8,
1767    pub read: bool,
1768    pub data: u64,
1769}
1770
1771#[cfg(target_arch = "riscv64")]
1772#[repr(C)]
1773#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1774pub struct zx_packet_guest_mem_t {
1775    pub addr: zx_gpaddr_t,
1776    padding1: [PadByte; 24],
1777}
1778
1779pub const X86_MAX_INST_LEN: usize = 15;
1780
1781#[cfg(target_arch = "x86_64")]
1782#[repr(C)]
1783#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1784pub struct zx_packet_guest_mem_t {
1785    pub addr: zx_gpaddr_t,
1786    pub cr3: zx_gpaddr_t,
1787    pub rip: zx_vaddr_t,
1788    pub instruction_size: u8,
1789    pub default_operand_size: u8,
1790}
1791
1792#[repr(C)]
1793#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
1794pub struct zx_packet_interrupt_t {
1795    pub timestamp: zx_time_t,
1796    padding1: [PadByte; 24],
1797}
1798
1799// Helper for constructing topics that have been versioned.
1800const fn info_topic(topic: u32, version: u32) -> u32 {
1801    (version << 28) | topic
1802}
1803
1804multiconst!(zx_object_info_topic_t, [
1805    ZX_INFO_NONE                       = 0;
1806    ZX_INFO_HANDLE_VALID               = 1;
1807    ZX_INFO_HANDLE_BASIC               = 2;  // zx_info_handle_basic_t[1]
1808    ZX_INFO_PROCESS                    = info_topic(3, 1);  // zx_info_process_t[1]
1809    ZX_INFO_PROCESS_THREADS            = 4;  // zx_koid_t[n]
1810    ZX_INFO_VMAR                       = 7;  // zx_info_vmar_t[1]
1811    ZX_INFO_JOB_CHILDREN               = 8;  // zx_koid_t[n]
1812    ZX_INFO_JOB_PROCESSES              = 9;  // zx_koid_t[n]
1813    ZX_INFO_THREAD                     = 10; // zx_info_thread_t[1]
1814    ZX_INFO_THREAD_EXCEPTION_REPORT    = info_topic(11, 1); // zx_exception_report_t[1]
1815    ZX_INFO_TASK_STATS                 = info_topic(12, 1); // zx_info_task_stats_t[1]
1816    ZX_INFO_PROCESS_MAPS               = info_topic(13, 2); // zx_info_maps_t[n]
1817    ZX_INFO_PROCESS_VMOS               = info_topic(14, 3); // zx_info_vmo_t[n]
1818    ZX_INFO_THREAD_STATS               = 15; // zx_info_thread_stats_t[1]
1819    ZX_INFO_CPU_STATS                  = 16; // zx_info_cpu_stats_t[n]
1820    ZX_INFO_KMEM_STATS                 = info_topic(17, 1); // zx_info_kmem_stats_t[1]
1821    ZX_INFO_RESOURCE                   = 18; // zx_info_resource_t[1]
1822    ZX_INFO_HANDLE_COUNT               = 19; // zx_info_handle_count_t[1]
1823    ZX_INFO_BTI                        = 20; // zx_info_bti_t[1]
1824    ZX_INFO_PROCESS_HANDLE_STATS       = 21; // zx_info_process_handle_stats_t[1]
1825    ZX_INFO_SOCKET                     = 22; // zx_info_socket_t[1]
1826    ZX_INFO_VMO                        = info_topic(23, 3); // zx_info_vmo_t[1]
1827    ZX_INFO_JOB                        = 24; // zx_info_job_t[1]
1828    ZX_INFO_TIMER                      = 25; // zx_info_timer_t[1]
1829    ZX_INFO_STREAM                     = 26; // zx_info_stream_t[1]
1830    ZX_INFO_HANDLE_TABLE               = 27; // zx_info_handle_extended_t[n]
1831    ZX_INFO_MSI                        = 28; // zx_info_msi_t[1]
1832    ZX_INFO_GUEST_STATS                = 29; // zx_info_guest_stats_t[1]
1833    ZX_INFO_TASK_RUNTIME               = info_topic(30, 1); // zx_info_task_runtime_t[1]
1834    ZX_INFO_KMEM_STATS_EXTENDED        = 31; // zx_info_kmem_stats_extended_t[1]
1835    ZX_INFO_VCPU                       = 32; // zx_info_vcpu_t[1]
1836    ZX_INFO_KMEM_STATS_COMPRESSION     = 33; // zx_info_kmem_stats_compression_t[1]
1837    ZX_INFO_IOB                        = 34; // zx_info_iob_t[1]
1838    ZX_INFO_IOB_REGIONS                = 35; // zx_iob_region_info_t[n]
1839    ZX_INFO_VMAR_MAPS                  = 36; // zx_info_maps_t[n]
1840    ZX_INFO_POWER_DOMAINS              = 37; // zx_info_power_domain_info_t[n]
1841    ZX_INFO_MEMORY_STALL               = 38; // zx_info_memory_stall_t[1]
1842    ZX_INFO_CLOCK_MAPPED_SIZE          = 40; // usize[1]
1843]);
1844
1845multiconst!(zx_system_memory_stall_type_t, [
1846    ZX_SYSTEM_MEMORY_STALL_SOME        = 0;
1847    ZX_SYSTEM_MEMORY_STALL_FULL        = 1;
1848]);
1849
1850// This macro takes struct-like syntax and creates another macro that can be used to create
1851// different instances of the struct with different names. This is used to keep struct definitions
1852// from drifting between this crate and the fuchsia-zircon crate where they are identical other
1853// than in name and location.
1854macro_rules! struct_decl_macro {
1855    ( $(#[$attrs:meta])* $vis:vis struct <$macro_name:ident> $($any:tt)* ) => {
1856        #[macro_export]
1857        macro_rules! $macro_name {
1858            ($name:ident) => {
1859                $(#[$attrs])* $vis struct $name $($any)*
1860            }
1861        }
1862    }
1863}
1864
1865// Don't need struct_decl_macro for this, the wrapper is different.
1866#[repr(C)]
1867#[derive(Default, Debug, Copy, Clone, Eq, FromBytes, Immutable, PartialEq)]
1868pub struct zx_info_handle_basic_t {
1869    pub koid: zx_koid_t,
1870    pub rights: zx_rights_t,
1871    pub type_: zx_obj_type_t,
1872    pub related_koid: zx_koid_t,
1873    padding1: [PadByte; 4],
1874}
1875
1876struct_decl_macro! {
1877    #[repr(C)]
1878    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
1879    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
1880    pub struct <zx_info_handle_count_t> {
1881        pub handle_count: u32,
1882    }
1883}
1884
1885zx_info_handle_count_t!(zx_info_handle_count_t);
1886
1887// Don't need struct_decl_macro for this, the wrapper is different.
1888#[repr(C)]
1889#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, KnownLayout, FromBytes, Immutable)]
1890pub struct zx_info_socket_t {
1891    pub options: u32,
1892    pub rx_buf_max: usize,
1893    pub rx_buf_size: usize,
1894    pub rx_buf_available: usize,
1895    pub tx_buf_max: usize,
1896    pub tx_buf_size: usize,
1897}
1898
1899multiconst!(u32, [
1900    ZX_INFO_PROCESS_FLAG_STARTED = 1 << 0;
1901    ZX_INFO_PROCESS_FLAG_EXITED = 1 << 1;
1902    ZX_INFO_PROCESS_FLAG_DEBUGGER_ATTACHED = 1 << 2;
1903]);
1904
1905struct_decl_macro! {
1906    #[repr(C)]
1907    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
1908    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
1909    pub struct <zx_info_process_t> {
1910        pub return_code: i64,
1911        pub start_time: zx_time_t,
1912        pub flags: u32,
1913    }
1914}
1915
1916zx_info_process_t!(zx_info_process_t);
1917
1918struct_decl_macro! {
1919    #[repr(C)]
1920    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
1921    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
1922    pub struct <zx_info_job_t> {
1923        pub return_code: i64,
1924        pub exited: u8,
1925        pub kill_on_oom: u8,
1926        pub debugger_attached: u8,
1927    }
1928}
1929
1930zx_info_job_t!(zx_info_job_t);
1931
1932struct_decl_macro! {
1933    #[repr(C)]
1934    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
1935    #[derive(zerocopy::FromBytes, zerocopy::IntoBytes, zerocopy::Immutable)]
1936    pub struct <zx_info_timer_t> {
1937        pub options: u32,
1938        pub clock_id: zx_clock_t,
1939        pub deadline: zx_time_t,
1940        pub slack: zx_duration_t,
1941    }
1942}
1943
1944zx_info_timer_t!(zx_info_timer_t);
1945
1946#[repr(C)]
1947#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1948pub struct zx_policy_basic {
1949    pub condition: u32,
1950    pub policy: u32,
1951}
1952
1953#[repr(C)]
1954#[derive(Debug, Copy, Clone, Eq, PartialEq)]
1955pub struct zx_policy_timer_slack {
1956    pub min_slack: zx_duration_t,
1957    pub default_mode: u32,
1958}
1959
1960multiconst!(u32, [
1961    // policy options
1962    ZX_JOB_POL_RELATIVE = 0;
1963    ZX_JOB_POL_ABSOLUTE = 1;
1964
1965    // policy topic
1966    ZX_JOB_POL_BASIC = 0;
1967    ZX_JOB_POL_TIMER_SLACK = 1;
1968
1969    // policy conditions
1970    ZX_POL_BAD_HANDLE            = 0;
1971    ZX_POL_WRONG_OBJECT          = 1;
1972    ZX_POL_VMAR_WX               = 2;
1973    ZX_POL_NEW_ANY               = 3;
1974    ZX_POL_NEW_VMO               = 4;
1975    ZX_POL_NEW_CHANNEL           = 5;
1976    ZX_POL_NEW_EVENT             = 6;
1977    ZX_POL_NEW_EVENTPAIR         = 7;
1978    ZX_POL_NEW_PORT              = 8;
1979    ZX_POL_NEW_SOCKET            = 9;
1980    ZX_POL_NEW_FIFO              = 10;
1981    ZX_POL_NEW_TIMER             = 11;
1982    ZX_POL_NEW_PROCESS           = 12;
1983    ZX_POL_NEW_PROFILE           = 13;
1984    ZX_POL_NEW_PAGER             = 14;
1985    ZX_POL_AMBIENT_MARK_VMO_EXEC = 15;
1986
1987    // policy actions
1988    ZX_POL_ACTION_ALLOW           = 0;
1989    ZX_POL_ACTION_DENY            = 1;
1990    ZX_POL_ACTION_ALLOW_EXCEPTION = 2;
1991    ZX_POL_ACTION_DENY_EXCEPTION  = 3;
1992    ZX_POL_ACTION_KILL            = 4;
1993
1994    // timer slack default modes
1995    ZX_TIMER_SLACK_CENTER = 0;
1996    ZX_TIMER_SLACK_EARLY  = 1;
1997    ZX_TIMER_SLACK_LATE   = 2;
1998]);
1999
2000multiconst!(u32, [
2001    // critical options
2002    ZX_JOB_CRITICAL_PROCESS_RETCODE_NONZERO = 1 << 0;
2003]);
2004
2005// Don't use struct_decl_macro, wrapper is different.
2006#[repr(C)]
2007#[derive(
2008    Default, Debug, Copy, Clone, Eq, PartialEq, KnownLayout, FromBytes, Immutable, IntoBytes,
2009)]
2010pub struct zx_info_vmo_t {
2011    pub koid: zx_koid_t,
2012    pub name: [u8; ZX_MAX_NAME_LEN],
2013    pub size_bytes: u64,
2014    pub parent_koid: zx_koid_t,
2015    pub num_children: usize,
2016    pub num_mappings: usize,
2017    pub share_count: usize,
2018    pub flags: u32,
2019    padding1: [PadByte; 4],
2020    pub committed_bytes: u64,
2021    pub handle_rights: zx_rights_t,
2022    pub cache_policy: u32,
2023    pub metadata_bytes: u64,
2024    pub committed_change_events: u64,
2025    pub populated_bytes: u64,
2026    pub committed_private_bytes: u64,
2027    pub populated_private_bytes: u64,
2028    pub committed_scaled_bytes: u64,
2029    pub populated_scaled_bytes: u64,
2030    pub committed_fractional_scaled_bytes: u64,
2031    pub populated_fractional_scaled_bytes: u64,
2032}
2033
2034struct_decl_macro! {
2035    #[repr(C)]
2036    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2037    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2038    pub struct <zx_info_cpu_stats_t> {
2039        pub cpu_number: u32,
2040        pub flags: u32,
2041        pub idle_time: zx_duration_t,
2042        pub reschedules: u64,
2043        pub context_switches: u64,
2044        pub irq_preempts: u64,
2045        pub preempts: u64,
2046        pub yields: u64,
2047        pub ints: u64,
2048        pub timer_ints: u64,
2049        pub timers: u64,
2050        pub page_faults: u64,
2051        pub exceptions: u64,
2052        pub syscalls: u64,
2053        pub reschedule_ipis: u64,
2054        pub generic_ipis: u64,
2055    }
2056}
2057
2058zx_info_cpu_stats_t!(zx_info_cpu_stats_t);
2059
2060struct_decl_macro! {
2061    #[repr(C)]
2062    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2063    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2064    pub struct <zx_info_kmem_stats_t> {
2065        pub total_bytes: u64,
2066        pub free_bytes: u64,
2067        pub free_loaned_bytes: u64,
2068        pub wired_bytes: u64,
2069        pub total_heap_bytes: u64,
2070        pub free_heap_bytes: u64,
2071        pub vmo_bytes: u64,
2072        pub mmu_overhead_bytes: u64,
2073        pub ipc_bytes: u64,
2074        pub cache_bytes: u64,
2075        pub slab_bytes: u64,
2076        pub zram_bytes: u64,
2077        pub other_bytes: u64,
2078        pub vmo_reclaim_total_bytes: u64,
2079        pub vmo_reclaim_newest_bytes: u64,
2080        pub vmo_reclaim_oldest_bytes: u64,
2081        pub vmo_reclaim_disabled_bytes: u64,
2082        pub vmo_discardable_locked_bytes: u64,
2083        pub vmo_discardable_unlocked_bytes: u64,
2084    }
2085}
2086
2087zx_info_kmem_stats_t!(zx_info_kmem_stats_t);
2088
2089struct_decl_macro! {
2090    #[repr(C)]
2091    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2092    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2093    pub struct <zx_info_kmem_stats_extended_t> {
2094        pub total_bytes: u64,
2095        pub free_bytes: u64,
2096        pub wired_bytes: u64,
2097        pub total_heap_bytes: u64,
2098        pub free_heap_bytes: u64,
2099        pub vmo_bytes: u64,
2100        pub vmo_pager_total_bytes: u64,
2101        pub vmo_pager_newest_bytes: u64,
2102        pub vmo_pager_oldest_bytes: u64,
2103        pub vmo_discardable_locked_bytes: u64,
2104        pub vmo_discardable_unlocked_bytes: u64,
2105        pub mmu_overhead_bytes: u64,
2106        pub ipc_bytes: u64,
2107        pub other_bytes: u64,
2108        pub vmo_reclaim_disable_bytes: u64,
2109    }
2110}
2111
2112zx_info_kmem_stats_extended_t!(zx_info_kmem_stats_extended_t);
2113
2114struct_decl_macro! {
2115    #[repr(C)]
2116    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2117    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2118    pub struct <zx_info_kmem_stats_compression_t> {
2119        pub uncompressed_storage_bytes: u64,
2120        pub compressed_storage_bytes: u64,
2121        pub compressed_fragmentation_bytes: u64,
2122        pub compression_time: zx_duration_t,
2123        pub decompression_time: zx_duration_t,
2124        pub total_page_compression_attempts: u64,
2125        pub failed_page_compression_attempts: u64,
2126        pub total_page_decompressions: u64,
2127        pub compressed_page_evictions: u64,
2128        pub eager_page_compressions: u64,
2129        pub memory_pressure_page_compressions: u64,
2130        pub critical_memory_page_compressions: u64,
2131        pub pages_decompressed_unit_ns: u64,
2132        pub pages_decompressed_within_log_time: [u64; 8],
2133    }
2134}
2135
2136zx_info_kmem_stats_compression_t!(zx_info_kmem_stats_compression_t);
2137
2138struct_decl_macro! {
2139    #[repr(C)]
2140    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2141    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2142    pub struct <zx_info_resource_t> {
2143        pub kind: u32,
2144        pub flags: u32,
2145        pub base: u64,
2146        pub size: usize,
2147        pub name: [u8; ZX_MAX_NAME_LEN],
2148    }
2149}
2150
2151pub type zx_thread_state_t = u32;
2152
2153multiconst!(zx_thread_state_t, [
2154    ZX_THREAD_STATE_NEW = 0x0000;
2155    ZX_THREAD_STATE_RUNNING = 0x0001;
2156    ZX_THREAD_STATE_SUSPENDED = 0x0002;
2157    ZX_THREAD_STATE_BLOCKED = 0x0003;
2158    ZX_THREAD_STATE_DYING = 0x0004;
2159    ZX_THREAD_STATE_DEAD = 0x0005;
2160    ZX_THREAD_STATE_BLOCKED_EXCEPTION = 0x0103;
2161    ZX_THREAD_STATE_BLOCKED_SLEEPING = 0x0203;
2162    ZX_THREAD_STATE_BLOCKED_FUTEX = 0x0303;
2163    ZX_THREAD_STATE_BLOCKED_PORT = 0x0403;
2164    ZX_THREAD_STATE_BLOCKED_CHANNEL = 0x0503;
2165    ZX_THREAD_STATE_BLOCKED_WAIT_ONE = 0x0603;
2166    ZX_THREAD_STATE_BLOCKED_WAIT_MANY = 0x0703;
2167    ZX_THREAD_STATE_BLOCKED_INTERRUPT = 0x0803;
2168    ZX_THREAD_STATE_BLOCKED_PAGER = 0x0903;
2169]);
2170
2171#[repr(C)]
2172#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, zerocopy::FromBytes, zerocopy::Immutable)]
2173pub struct zx_info_thread_t {
2174    pub state: zx_thread_state_t,
2175    pub wait_exception_channel_type: u32,
2176    pub cpu_affinity_mask: zx_cpu_set_t,
2177}
2178
2179struct_decl_macro! {
2180    #[repr(C)]
2181    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2182    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2183    pub struct <zx_info_thread_stats_t> {
2184        pub total_runtime: zx_duration_t,
2185        pub last_scheduled_cpu: u32,
2186    }
2187}
2188
2189zx_info_thread_stats_t!(zx_info_thread_stats_t);
2190
2191zx_info_resource_t!(zx_info_resource_t);
2192
2193struct_decl_macro! {
2194    #[repr(C)]
2195    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2196    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2197    pub struct <zx_info_vmar_t> {
2198        pub base: usize,
2199        pub len: usize,
2200    }
2201}
2202
2203zx_info_vmar_t!(zx_info_vmar_t);
2204
2205struct_decl_macro! {
2206    #[repr(C)]
2207    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2208    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2209    pub struct <zx_info_task_stats_t> {
2210        pub mem_mapped_bytes: usize,
2211        pub mem_private_bytes: usize,
2212        pub mem_shared_bytes: usize,
2213        pub mem_scaled_shared_bytes: usize,
2214        pub mem_fractional_scaled_shared_bytes: u64,
2215    }
2216}
2217
2218zx_info_task_stats_t!(zx_info_task_stats_t);
2219
2220struct_decl_macro! {
2221    #[repr(C)]
2222    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2223    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2224    pub struct <zx_info_task_runtime_t> {
2225        pub cpu_time: zx_duration_t,
2226        pub queue_time: zx_duration_t,
2227        pub page_fault_time: zx_duration_t,
2228        pub lock_contention_time: zx_duration_t,
2229    }
2230}
2231
2232zx_info_task_runtime_t!(zx_info_task_runtime_t);
2233
2234multiconst!(zx_info_maps_type_t, [
2235    ZX_INFO_MAPS_TYPE_NONE    = 0;
2236    ZX_INFO_MAPS_TYPE_ASPACE  = 1;
2237    ZX_INFO_MAPS_TYPE_VMAR    = 2;
2238    ZX_INFO_MAPS_TYPE_MAPPING = 3;
2239]);
2240
2241struct_decl_macro! {
2242    #[repr(C)]
2243    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2244    #[derive(zerocopy::FromBytes, zerocopy::Immutable, IntoBytes)]
2245    pub struct <zx_info_maps_mapping_t> {
2246        pub mmu_flags: zx_vm_option_t,
2247        padding1: [PadByte; 4],
2248        pub vmo_koid: zx_koid_t,
2249        pub vmo_offset: u64,
2250        pub committed_bytes: usize,
2251        pub populated_bytes: usize,
2252        pub committed_private_bytes: usize,
2253        pub populated_private_bytes: usize,
2254        pub committed_scaled_bytes: usize,
2255        pub populated_scaled_bytes: usize,
2256        pub committed_fractional_scaled_bytes: u64,
2257        pub populated_fractional_scaled_bytes: u64,
2258    }
2259}
2260
2261zx_info_maps_mapping_t!(zx_info_maps_mapping_t);
2262
2263#[repr(C)]
2264#[derive(Copy, Clone, KnownLayout, FromBytes, Immutable)]
2265pub union InfoMapsTypeUnion {
2266    pub mapping: zx_info_maps_mapping_t,
2267}
2268
2269struct_decl_macro! {
2270    #[repr(C)]
2271    #[derive(Copy, Clone)]
2272    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2273    pub struct <zx_info_maps_t> {
2274        pub name: [u8; ZX_MAX_NAME_LEN],
2275        pub base: zx_vaddr_t,
2276        pub size: usize,
2277        pub depth: usize,
2278        pub r#type: zx_info_maps_type_t,
2279        pub u: InfoMapsTypeUnion,
2280    }
2281}
2282
2283zx_info_maps_t!(zx_info_maps_t);
2284
2285struct_decl_macro! {
2286    #[repr(C)]
2287    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
2288    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2289    pub struct <zx_info_process_handle_stats_t> {
2290        pub handle_count: [u32; ZX_OBJ_TYPE_UPPER_BOUND],
2291    }
2292}
2293
2294impl Default for zx_info_process_handle_stats_t {
2295    fn default() -> Self {
2296        Self { handle_count: [0; ZX_OBJ_TYPE_UPPER_BOUND] }
2297    }
2298}
2299
2300zx_info_process_handle_stats_t!(zx_info_process_handle_stats_t);
2301
2302struct_decl_macro! {
2303    #[repr(C)]
2304    #[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
2305    #[derive(zerocopy::FromBytes, zerocopy::Immutable, zerocopy::IntoBytes)]
2306    pub struct <zx_info_memory_stall_t> {
2307        pub stall_time_some: zx_duration_mono_t,
2308        pub stall_time_full: zx_duration_mono_t,
2309    }
2310}
2311
2312zx_info_memory_stall_t!(zx_info_memory_stall_t);
2313
2314// from //zircon/system/public/zircon/syscalls/hypervisor.h
2315multiconst!(zx_guest_option_t, [
2316    ZX_GUEST_OPT_NORMAL = 0;
2317]);
2318
2319multiconst!(zx_guest_trap_t, [
2320    ZX_GUEST_TRAP_BELL = 0;
2321    ZX_GUEST_TRAP_MEM  = 1;
2322    ZX_GUEST_TRAP_IO   = 2;
2323]);
2324
2325pub const ZX_LOG_RECORD_MAX: usize = 256;
2326pub const ZX_LOG_RECORD_DATA_MAX: usize = 216;
2327
2328pub const DEBUGLOG_TRACE: u8 = 0x10;
2329pub const DEBUGLOG_DEBUG: u8 = 0x20;
2330pub const DEBUGLOG_INFO: u8 = 0x30;
2331pub const DEBUGLOG_WARNING: u8 = 0x40;
2332pub const DEBUGLOG_ERROR: u8 = 0x50;
2333pub const DEBUGLOG_FATAL: u8 = 0x60;
2334
2335struct_decl_macro! {
2336    #[repr(C)]
2337    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
2338    #[derive(zerocopy::FromBytes, zerocopy::Immutable)]
2339    pub struct <zx_log_record_t> {
2340        pub sequence: u64,
2341        padding1: [PadByte; 4],
2342        pub datalen: u16,
2343        pub severity: u8,
2344        pub flags: u8,
2345        pub timestamp: zx_instant_boot_t,
2346        pub pid: u64,
2347        pub tid: u64,
2348        pub data: [u8; ZX_LOG_RECORD_DATA_MAX],
2349    }
2350}
2351const_assert_eq!(std::mem::size_of::<zx_log_record_t>(), ZX_LOG_RECORD_MAX);
2352
2353zx_log_record_t!(zx_log_record_t);
2354
2355impl Default for zx_log_record_t {
2356    fn default() -> zx_log_record_t {
2357        zx_log_record_t {
2358            sequence: 0,
2359            padding1: Default::default(),
2360            datalen: 0,
2361            severity: 0,
2362            flags: 0,
2363            timestamp: 0,
2364            pid: 0,
2365            tid: 0,
2366            data: [0; ZX_LOG_RECORD_DATA_MAX],
2367        }
2368    }
2369}
2370
2371multiconst!(u32, [
2372    ZX_LOG_FLAG_READABLE = 0x40000000;
2373]);
2374
2375// For C, the below types are currently forward declared for syscalls.h.
2376// We might want to investigate a better solution for Rust or removing those
2377// forward declarations.
2378//
2379// These are hand typed translations from C types into Rust structures using a C
2380// layout
2381
2382// source: zircon/system/public/zircon/syscalls/system.h
2383#[repr(C)]
2384pub struct zx_system_powerctl_arg_t {
2385    // rust can't express anonymous unions at this time
2386    // https://github.com/rust-lang/rust/issues/49804
2387    pub powerctl_internal: zx_powerctl_union,
2388}
2389
2390#[repr(C)]
2391#[derive(Copy, Clone)]
2392pub union zx_powerctl_union {
2393    acpi_transition_s_state: acpi_transition_s_state,
2394    x86_power_limit: x86_power_limit,
2395}
2396
2397#[repr(C)]
2398#[derive(Default, Debug, PartialEq, Copy, Clone)]
2399pub struct acpi_transition_s_state {
2400    target_s_state: u8, // Value between 1 and 5 indicating which S-state
2401    sleep_type_a: u8,   // Value from ACPI VM (SLP_TYPa)
2402    sleep_type_b: u8,   // Value from ACPI VM (SLP_TYPb)
2403    padding1: [PadByte; 9],
2404}
2405
2406#[repr(C)]
2407#[derive(Default, Debug, PartialEq, Copy, Clone)]
2408pub struct x86_power_limit {
2409    power_limit: u32, // PL1 value in milliwatts
2410    time_window: u32, // PL1 time window in microseconds
2411    clamp: u8,        // PL1 clamping enable
2412    enable: u8,       // PL1 enable
2413    padding1: [PadByte; 2],
2414}
2415
2416// source: zircon/system/public/zircon/syscalls/pci.h
2417pub type zx_pci_bar_types_t = u32;
2418
2419multiconst!(zx_pci_bar_types_t, [
2420            ZX_PCI_BAR_TYPE_UNUSED = 0;
2421            ZX_PCI_BAR_TYPE_MMIO = 1;
2422            ZX_PCI_BAR_TYPE_PIO = 2;
2423]);
2424
2425#[repr(C)]
2426pub struct zx_pci_bar_t {
2427    pub id: u32,
2428    pub ty: u32,
2429    pub size: usize,
2430    // rust can't express anonymous unions at this time
2431    // https://github.com/rust-lang/rust/issues/49804
2432    pub zx_pci_bar_union: zx_pci_bar_union,
2433}
2434
2435#[repr(C)]
2436#[derive(Copy, Clone)]
2437pub union zx_pci_bar_union {
2438    addr: usize,
2439    zx_pci_bar_union_struct: zx_pci_bar_union_struct,
2440}
2441
2442#[repr(C)]
2443#[derive(Default, Debug, PartialEq, Copy, Clone)]
2444pub struct zx_pci_bar_union_struct {
2445    handle: zx_handle_t,
2446    padding1: [PadByte; 4],
2447}
2448
2449// source: zircon/system/public/zircon/syscalls/smc.h
2450#[repr(C)]
2451#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
2452pub struct zx_smc_parameters_t {
2453    pub func_id: u32,
2454    padding1: [PadByte; 4],
2455    pub arg1: u64,
2456    pub arg2: u64,
2457    pub arg3: u64,
2458    pub arg4: u64,
2459    pub arg5: u64,
2460    pub arg6: u64,
2461    pub client_id: u16,
2462    pub secure_os_id: u16,
2463    padding2: [PadByte; 4],
2464}
2465
2466#[repr(C)]
2467#[derive(Debug, Copy, Clone, Eq, PartialEq)]
2468pub struct zx_smc_result_t {
2469    pub arg0: u64,
2470    pub arg1: u64,
2471    pub arg2: u64,
2472    pub arg3: u64,
2473    pub arg6: u64,
2474}
2475
2476pub const ZX_CPU_SET_MAX_CPUS: usize = 512;
2477pub const ZX_CPU_SET_BITS_PER_WORD: usize = 64;
2478
2479#[repr(C)]
2480#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, zerocopy::FromBytes, zerocopy::Immutable)]
2481pub struct zx_cpu_set_t {
2482    pub mask: [u64; ZX_CPU_SET_MAX_CPUS / ZX_CPU_SET_BITS_PER_WORD],
2483}
2484
2485// source: zircon/system/public/zircon/syscalls/scheduler.h
2486#[repr(C)]
2487#[derive(Copy, Clone)]
2488pub struct zx_profile_info_t {
2489    pub flags: u32,
2490    padding1: [PadByte; 4],
2491    pub zx_profile_info_union: zx_profile_info_union,
2492    pub cpu_affinity_mask: zx_cpu_set_t,
2493}
2494
2495#[cfg(feature = "zerocopy")]
2496impl Default for zx_profile_info_t {
2497    fn default() -> Self {
2498        Self {
2499            flags: Default::default(),
2500            padding1: Default::default(),
2501            zx_profile_info_union: FromZeros::new_zeroed(),
2502            cpu_affinity_mask: Default::default(),
2503        }
2504    }
2505}
2506
2507#[repr(C)]
2508#[derive(Copy, Clone)]
2509#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable))]
2510pub struct priority_params {
2511    pub priority: i32,
2512    padding1: [PadByte; 20],
2513}
2514
2515#[repr(C)]
2516#[derive(Copy, Clone)]
2517#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable))]
2518pub union zx_profile_info_union {
2519    pub priority_params: priority_params,
2520    pub deadline_params: zx_sched_deadline_params_t,
2521}
2522
2523#[repr(C)]
2524#[derive(Debug, Copy, Clone, Eq, PartialEq)]
2525#[cfg_attr(feature = "zerocopy", derive(FromBytes, Immutable, KnownLayout))]
2526pub struct zx_sched_deadline_params_t {
2527    pub capacity: zx_duration_t,
2528    pub relative_deadline: zx_duration_t,
2529    pub period: zx_duration_t,
2530}
2531
2532#[repr(C)]
2533#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
2534pub struct zx_cpu_performance_scale_t {
2535    pub integer_part: u32,
2536    pub fractional_part: u32,
2537}
2538
2539#[repr(C)]
2540#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
2541pub struct zx_cpu_performance_info_t {
2542    pub logical_cpu_number: u32,
2543    pub performance_scale: zx_cpu_performance_scale_t,
2544}
2545
2546#[repr(C)]
2547#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
2548pub struct zx_cpu_power_limit_t {
2549    pub logical_cpu_number: u32,
2550    padding1: [PadByte; 4],
2551    pub max_power_nw: u64,
2552}
2553
2554#[repr(C)]
2555#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
2556pub struct zx_iommu_desc_dummy_t {
2557    padding1: PadByte,
2558}
2559
2560multiconst!(u32, [
2561    ZX_IOMMU_TYPE_DUMMY = 0;
2562    ZX_IOMMU_TYPE_INTEL = 1;
2563]);
2564
2565#[repr(C)]
2566#[derive(Debug, Copy, Clone)]
2567pub struct zx_sampler_config_t {
2568    pub period: zx_duration_t,
2569    pub buffer_size: usize,
2570    pub iobuffer_discipline: u64,
2571}
2572
2573multiconst!(zx_processor_power_level_options_t, [
2574    ZX_PROCESSOR_POWER_LEVEL_OPTIONS_DOMAIN_INDEPENDENT = 1 << 0;
2575]);
2576
2577multiconst!(zx_processor_power_control_t, [
2578    ZX_PROCESSOR_POWER_CONTROL_CPU_DRIVER = 0;
2579    ZX_PROCESSOR_POWER_CONTROL_ARM_PSCI = 1;
2580    ZX_PROCESSOR_POWER_CONTROL_ARM_WFI = 2;
2581    ZX_PROCESSOR_POWER_CONTROL_RISCV_SBI = 3;
2582    ZX_PROCESSOR_POWER_CONTROL_RISCV_WFI = 4;
2583]);
2584
2585#[repr(C)]
2586#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
2587pub struct zx_processor_power_level_t {
2588    pub options: zx_processor_power_level_options_t,
2589    pub processing_rate: u64,
2590    pub power_coefficient_nw: u64,
2591    pub control_interface: zx_processor_power_control_t,
2592    pub control_argument: u64,
2593    pub diagnostic_name: [u8; ZX_MAX_NAME_LEN],
2594    padding1: [PadByte; 32],
2595}
2596
2597#[repr(C)]
2598#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)]
2599pub struct zx_processor_power_level_transition_t {
2600    pub latency: zx_duration_t,
2601    pub energy: u64,
2602    pub from: u8,
2603    pub to: u8,
2604    padding1: [PadByte; 6],
2605}
2606
2607#[repr(C)]
2608#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
2609pub struct zx_packet_processor_power_level_transition_request_t {
2610    pub domain_id: u32,
2611    pub options: u32,
2612    pub control_interface: u64,
2613    pub control_argument: u64,
2614    padding1: [PadByte; 8],
2615}
2616
2617#[repr(C)]
2618#[derive(Debug, Copy, Clone, Eq, PartialEq)]
2619pub struct zx_processor_power_state_t {
2620    pub domain_id: u32,
2621    pub options: u32,
2622    pub control_interface: u64,
2623    pub control_argument: u64,
2624}
2625
2626#[repr(C)]
2627#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
2628pub struct zx_processor_power_domain_t {
2629    pub cpus: zx_cpu_set_t,
2630    pub domain_id: u32,
2631    padding1: [PadByte; 4],
2632}
2633
2634#[repr(C)]
2635#[derive(Debug, Copy, Clone, Eq, PartialEq)]
2636pub struct zx_power_domain_info_t {
2637    pub cpus: zx_cpu_set_t,
2638    pub domain_id: u32,
2639    pub idle_power_levels: u8,
2640    pub active_power_levels: u8,
2641    padding1: [PadByte; 2],
2642}
2643
2644multiconst!(u32, [
2645    ZX_BTI_PERM_READ = 1 << 0;
2646    ZX_BTI_PERM_WRITE = 1 << 1;
2647    ZX_BTI_PERM_EXECUTE = 1 << 2;
2648    ZX_BTI_COMPRESS = 1 << 3;
2649    ZX_BTI_CONTIGUOUS = 1 << 4;
2650]);
2651
2652// Options for zx_port_create
2653multiconst!(u32, [
2654    ZX_PORT_BIND_TO_INTERRUPT = 1 << 0;
2655]);
2656
2657// Options for zx_interrupt_create
2658multiconst!(u32, [
2659    ZX_INTERRUPT_VIRTUAL = 0x10;
2660    ZX_INTERRUPT_TIMESTAMP_MONO = 1 << 6;
2661]);
2662
2663// Options for zx_interrupt_bind
2664multiconst!(u32, [
2665    ZX_INTERRUPT_BIND = 0;
2666    ZX_INTERRUPT_UNBIND = 1;
2667]);
2668
2669#[repr(C)]
2670pub struct zx_iob_region_t {
2671    pub r#type: zx_iob_region_type_t,
2672    pub access: zx_iob_access_t,
2673    pub size: u64,
2674    pub discipline: zx_iob_discipline_t,
2675    pub extension: zx_iob_region_extension_t,
2676}
2677
2678multiconst!(zx_iob_region_type_t, [
2679    ZX_IOB_REGION_TYPE_PRIVATE = 0;
2680    ZX_IOB_REGION_TYPE_SHARED = 1;
2681]);
2682
2683multiconst!(zx_iob_access_t, [
2684    ZX_IOB_ACCESS_EP0_CAN_MAP_READ = 1 << 0;
2685    ZX_IOB_ACCESS_EP0_CAN_MAP_WRITE = 1 << 1;
2686    ZX_IOB_ACCESS_EP0_CAN_MEDIATED_READ = 1 << 2;
2687    ZX_IOB_ACCESS_EP0_CAN_MEDIATED_WRITE = 1 << 3;
2688    ZX_IOB_ACCESS_EP1_CAN_MAP_READ = 1 << 4;
2689    ZX_IOB_ACCESS_EP1_CAN_MAP_WRITE = 1 << 5;
2690    ZX_IOB_ACCESS_EP1_CAN_MEDIATED_READ = 1 << 6;
2691    ZX_IOB_ACCESS_EP1_CAN_MEDIATED_WRITE = 1 << 7;
2692]);
2693
2694#[repr(C)]
2695#[derive(Copy, Clone)]
2696pub struct zx_iob_discipline_t {
2697    pub r#type: zx_iob_discipline_type_t,
2698    pub extension: zx_iob_discipline_extension_t,
2699}
2700
2701#[repr(C)]
2702#[derive(Copy, Clone)]
2703pub union zx_iob_discipline_extension_t {
2704    // This is in vdso-next.
2705    pub ring_buffer: zx_iob_discipline_mediated_write_ring_buffer_t,
2706    pub reserved: [PadByte; 64],
2707}
2708
2709#[repr(C)]
2710#[derive(Debug, Copy, Clone)]
2711pub struct zx_iob_discipline_mediated_write_ring_buffer_t {
2712    pub tag: u64,
2713    pub padding: [PadByte; 56],
2714}
2715
2716multiconst!(zx_iob_discipline_type_t, [
2717    ZX_IOB_DISCIPLINE_TYPE_NONE = 0;
2718    ZX_IOB_DISCIPLINE_TYPE_MEDIATED_WRITE_RING_BUFFER = 2;
2719]);
2720
2721#[repr(C)]
2722#[derive(Clone, Copy, Default)]
2723pub struct zx_iob_region_private_t {
2724    options: u32,
2725    padding: [PadByte; 28],
2726}
2727
2728#[repr(C)]
2729#[derive(Clone, Copy)]
2730pub struct zx_iob_region_shared_t {
2731    pub options: u32,
2732    pub shared_region: zx_handle_t,
2733    pub padding: [PadByte; 24],
2734}
2735
2736#[repr(C)]
2737pub union zx_iob_region_extension_t {
2738    pub private_region: zx_iob_region_private_t,
2739    pub shared_region: zx_iob_region_shared_t,
2740    pub max_extension: [u8; 32],
2741}
2742
2743#[cfg(test)]
2744mod test {
2745    use super::*;
2746
2747    #[test]
2748    fn padded_struct_equality() {
2749        let test_struct = zx_clock_update_args_v1_t {
2750            rate_adjust: 222,
2751            padding1: Default::default(),
2752            value: 333,
2753            error_bound: 444,
2754        };
2755
2756        let different_data = zx_clock_update_args_v1_t { rate_adjust: 999, ..test_struct.clone() };
2757
2758        let different_padding = zx_clock_update_args_v1_t {
2759            padding1: [PadByte(0), PadByte(1), PadByte(2), PadByte(3)],
2760            ..test_struct.clone()
2761        };
2762
2763        // Structures with different data should not be equal.
2764        assert_ne!(test_struct, different_data);
2765        // Structures with only different padding should not be equal.
2766        assert_eq!(test_struct, different_padding);
2767    }
2768
2769    #[test]
2770    fn padded_struct_debug() {
2771        let test_struct = zx_clock_update_args_v1_t {
2772            rate_adjust: 222,
2773            padding1: Default::default(),
2774            value: 333,
2775            error_bound: 444,
2776        };
2777        let expectation = "zx_clock_update_args_v1_t { \
2778            rate_adjust: 222, \
2779            padding1: [-, -, -, -], \
2780            value: 333, \
2781            error_bound: 444 }";
2782        assert_eq!(format!("{:?}", test_struct), expectation);
2783    }
2784}