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