1#![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#[repr(C)]
75#[derive(Debug, Copy, Clone, Eq, PartialEq)]
76pub struct zx_string_view_t {
77 pub c_str: *const u8, pub length: usize,
79}
80
81pub const ZX_MAX_NAME_LEN: usize = 32;
82
83macro_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 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
247multiconst!(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 ZX_SIGNAL_HANDLE_CLOSED = ZX_OBJECT_HANDLE_CLOSED;
340
341 ZX_EVENT_SIGNALED = ZX_OBJECT_SIGNAL_3;
343
344 ZX_EVENTPAIR_SIGNALED = ZX_OBJECT_SIGNAL_3;
346 ZX_EVENTPAIR_PEER_CLOSED = ZX_OBJECT_SIGNAL_2;
347
348 ZX_TASK_TERMINATED = ZX_OBJECT_SIGNAL_3;
350
351 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 ZX_CLOCK_STARTED = ZX_OBJECT_SIGNAL_4;
358 ZX_CLOCK_UPDATED = ZX_OBJECT_SIGNAL_5;
359
360 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 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 ZX_FIFO_READABLE = ZX_OBJECT_READABLE;
377 ZX_FIFO_WRITABLE = ZX_OBJECT_WRITABLE;
378 ZX_FIFO_PEER_CLOSED = ZX_OBJECT_PEER_CLOSED;
379
380 ZX_IOB_PEER_CLOSED = ZX_OBJECT_PEER_CLOSED;
382 ZX_IOB_SHARED_REGION_UPDATED = ZX_OBJECT_SIGNAL_3;
383
384 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 ZX_PROCESS_TERMINATED = ZX_OBJECT_SIGNAL_3;
391
392 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 ZX_LOG_READABLE = ZX_OBJECT_READABLE;
399 ZX_LOG_WRITABLE = ZX_OBJECT_WRITABLE;
400
401 ZX_TIMER_SIGNALED = ZX_OBJECT_SIGNAL_3;
403
404 ZX_VMO_ZERO_CHILDREN = ZX_OBJECT_SIGNAL_3;
406
407 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
446pub const ZX_OBJ_TYPE_UPPER_BOUND: usize = 64;
451
452multiconst!(u32, [
454 ZX_PROP_NAME = 3;
456
457 #[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 ZX_PROP_PROCESS_DEBUG_ADDR = 5;
465
466 ZX_PROP_PROCESS_VDSO_BASE_ADDRESS = 6;
468
469 ZX_PROP_PROCESS_BREAK_ON_LOAD = 7;
472
473 ZX_PROP_SOCKET_RX_THRESHOLD = 12;
475 ZX_PROP_SOCKET_TX_THRESHOLD = 13;
476
477 ZX_PROP_CHANNEL_TX_MSG_MAX = 14;
480
481 ZX_PROP_JOB_KILL_ON_OOM = 15;
483
484 ZX_PROP_EXCEPTION_STATE = 16;
486
487 ZX_PROP_VMO_CONTENT_SIZE = 17;
489
490 ZX_PROP_EXCEPTION_STRATEGY = 18;
492
493 ZX_PROP_STREAM_MODE_APPEND = 19;
495]);
496
497pub type zx_thread_state_single_step_t = u32;
500
501multiconst!(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 ZX_THREAD_STATE_DEBUG_REGS = 4;
508 ZX_THREAD_STATE_SINGLE_STEP = 5;
509]);
510
511multiconst!(zx_vcpu_state_topic_t, [
513 ZX_VCPU_STATE = 0;
514 ZX_VCPU_IO = 1;
515]);
516
517multiconst!(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
526multiconst!(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
557multiconst!(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
567multiconst!(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
586multiconst!(zx_clock_t, [
588 ZX_CLOCK_MONOTONIC = 0;
589 ZX_CLOCK_BOOT = 1;
590]);
591
592multiconst!(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 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 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
613multiconst!(u32, [
615 ZX_EXCEPTION_CHANNEL_DEBUGGER = 1 << 0;
616 ZX_EXCEPTION_TARGET_JOB_DEBUGGER = 1 << 0;
617
618 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#[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
719pub 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
728pub 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
734pub 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
743pub 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
748pub const ZX_FIFO_MAX_SIZE_BYTES: u32 = 4096;
750
751#[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
767pub 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
774pub const ZX_RSRC_FLAG_EXCLUSIVE: zx_rsrc_flags_t = 0x00010000;
776
777pub 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
782pub 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
788multiconst!(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 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 pub pio_addr: usize,
936}
937
938pub type zx_rrec_t = [u8; 64];
940
941#[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
988pub 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 _ => 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 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, 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], sp: state.r[13], pc: state.pc, 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, pub sp: u64, pub gp: u64, pub tp: u64, pub t0: u64, pub t1: u64, pub t2: u64, pub s0: u64, pub s1: u64, pub a0: u64, pub a1: u64, pub a2: u64, pub a3: u64, pub a4: u64, pub a5: u64, pub a6: u64, pub a7: u64, pub s2: u64, pub s3: u64, pub s4: u64, pub s5: u64, pub s6: u64, pub s7: u64, pub s8: u64, pub s9: u64, pub s10: u64, pub s11: u64, pub t3: u64, pub t4: u64, pub t5: u64, pub t6: u64, }
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], pub sp: u64,
1540 pub pc: u64,
1541 pub tpidr_el0: u64,
1542 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, ],
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 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 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
1708const 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_PROCESS = info_topic(3, 1); ZX_INFO_PROCESS_THREADS = 4; ZX_INFO_VMAR = 7; ZX_INFO_JOB_CHILDREN = 8; ZX_INFO_JOB_PROCESSES = 9; ZX_INFO_THREAD = 10; ZX_INFO_THREAD_EXCEPTION_REPORT = info_topic(11, 1); ZX_INFO_TASK_STATS = info_topic(12, 1); ZX_INFO_PROCESS_MAPS = info_topic(13, 2); ZX_INFO_PROCESS_VMOS = info_topic(14, 3); ZX_INFO_THREAD_STATS = 15; ZX_INFO_CPU_STATS = 16; ZX_INFO_KMEM_STATS = info_topic(17, 1); ZX_INFO_RESOURCE = 18; ZX_INFO_HANDLE_COUNT = 19; ZX_INFO_BTI = 20; ZX_INFO_PROCESS_HANDLE_STATS = 21; ZX_INFO_SOCKET = 22; ZX_INFO_VMO = info_topic(23, 3); ZX_INFO_JOB = 24; ZX_INFO_TIMER = 25; ZX_INFO_STREAM = 26; ZX_INFO_HANDLE_TABLE = 27; ZX_INFO_MSI = 28; ZX_INFO_GUEST_STATS = 29; ZX_INFO_TASK_RUNTIME = info_topic(30, 1); ZX_INFO_KMEM_STATS_EXTENDED = 31; ZX_INFO_VCPU = 32; ZX_INFO_KMEM_STATS_COMPRESSION = 33; ZX_INFO_IOB = 34; ZX_INFO_IOB_REGIONS = 35; ZX_INFO_VMAR_MAPS = 36; ZX_INFO_POWER_DOMAINS = 37; ZX_INFO_MEMORY_STALL = 38; ZX_INFO_CLOCK_MAPPED_SIZE = 40; ]);
1753
1754multiconst!(zx_system_memory_stall_type_t, [
1755 ZX_SYSTEM_MEMORY_STALL_SOME = 0;
1756 ZX_SYSTEM_MEMORY_STALL_FULL = 1;
1757]);
1758
1759macro_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#[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#[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 ZX_JOB_POL_RELATIVE = 0;
1872 ZX_JOB_POL_ABSOLUTE = 1;
1873
1874 ZX_JOB_POL_BASIC = 0;
1876 ZX_JOB_POL_TIMER_SLACK = 1;
1877
1878 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 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 ZX_TIMER_SLACK_CENTER = 0;
1905 ZX_TIMER_SLACK_EARLY = 1;
1906 ZX_TIMER_SLACK_LATE = 2;
1907]);
1908
1909multiconst!(u32, [
1910 ZX_JOB_CRITICAL_PROCESS_RETCODE_NONZERO = 1 << 0;
1912]);
1913
1914#[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
2223multiconst!(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#[repr(C)]
2293pub struct zx_system_powerctl_arg_t {
2294 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, sleep_type_a: u8, sleep_type_b: u8, padding1: [PadByte; 9],
2313}
2314
2315#[repr(C)]
2316#[derive(Default, Debug, PartialEq, Copy, Clone)]
2317pub struct x86_power_limit {
2318 power_limit: u32, time_window: u32, clamp: u8, enable: u8, padding1: [PadByte; 2],
2323}
2324
2325pub 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 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#[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#[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
2561multiconst!(u32, [
2563 ZX_PORT_BIND_TO_INTERRUPT = 1 << 0;
2564]);
2565
2566multiconst!(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 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 assert_ne!(test_struct, different_data);
2668 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}