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