1 // Copyright 2016 The Fuchsia Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #![allow(non_camel_case_types)] 6 7 #[macro_use] 8 extern crate bitflags; 9 10 use std::{cmp, fmt}; 11 12 pub type zx_handle_t = i32; 13 14 pub type zx_status_t = i32; 15 16 pub type zx_futex_t = isize; 17 pub type zx_addr_t = usize; 18 pub type zx_paddr_t = usize; 19 pub type zx_vaddr_t = usize; 20 pub type zx_off_t = u64; 21 22 // Auto-generated using tools/gen_status.py 23 pub const ZX_OK : zx_status_t = 0; 24 pub const ZX_ERR_INTERNAL : zx_status_t = -1; 25 pub const ZX_ERR_NOT_SUPPORTED : zx_status_t = -2; 26 pub const ZX_ERR_NO_RESOURCES : zx_status_t = -3; 27 pub const ZX_ERR_NO_MEMORY : zx_status_t = -4; 28 pub const ZX_ERR_CALL_FAILED : zx_status_t = -5; 29 pub const ZX_ERR_INTERRUPTED_RETRY : zx_status_t = -6; 30 pub const ZX_ERR_INVALID_ARGS : zx_status_t = -10; 31 pub const ZX_ERR_BAD_HANDLE : zx_status_t = -11; 32 pub const ZX_ERR_WRONG_TYPE : zx_status_t = -12; 33 pub const ZX_ERR_BAD_SYSCALL : zx_status_t = -13; 34 pub const ZX_ERR_OUT_OF_RANGE : zx_status_t = -14; 35 pub const ZX_ERR_BUFFER_TOO_SMALL : zx_status_t = -15; 36 pub const ZX_ERR_BAD_STATE : zx_status_t = -20; 37 pub const ZX_ERR_TIMED_OUT : zx_status_t = -21; 38 pub const ZX_ERR_SHOULD_WAIT : zx_status_t = -22; 39 pub const ZX_ERR_CANCELED : zx_status_t = -23; 40 pub const ZX_ERR_PEER_CLOSED : zx_status_t = -24; 41 pub const ZX_ERR_NOT_FOUND : zx_status_t = -25; 42 pub const ZX_ERR_ALREADY_EXISTS : zx_status_t = -26; 43 pub const ZX_ERR_ALREADY_BOUND : zx_status_t = -27; 44 pub const ZX_ERR_UNAVAILABLE : zx_status_t = -28; 45 pub const ZX_ERR_ACCESS_DENIED : zx_status_t = -30; 46 pub const ZX_ERR_IO : zx_status_t = -40; 47 pub const ZX_ERR_IO_REFUSED : zx_status_t = -41; 48 pub const ZX_ERR_IO_DATA_INTEGRITY : zx_status_t = -42; 49 pub const ZX_ERR_IO_DATA_LOSS : zx_status_t = -43; 50 pub const ZX_ERR_BAD_PATH : zx_status_t = -50; 51 pub const ZX_ERR_NOT_DIR : zx_status_t = -51; 52 pub const ZX_ERR_NOT_FILE : zx_status_t = -52; 53 pub const ZX_ERR_FILE_BIG : zx_status_t = -53; 54 pub const ZX_ERR_NO_SPACE : zx_status_t = -54; 55 pub const ZX_ERR_STOP : zx_status_t = -60; 56 pub const ZX_ERR_NEXT : zx_status_t = -61; 57 58 pub type zx_time_t = u64; 59 pub type zx_duration_t = u64; 60 pub const ZX_TIME_INFINITE : zx_time_t = ::std::u64::MAX; 61 62 bitflags! { 63 #[repr(C)] 64 pub flags zx_signals_t: u32 { 65 const ZX_SIGNAL_NONE = 0, 66 const ZX_OBJECT_SIGNAL_ALL = 0x00ffffff, 67 const ZX_USER_SIGNAL_ALL = 0xff000000, 68 const ZX_OBJECT_SIGNAL_0 = 1 << 0, 69 const ZX_OBJECT_SIGNAL_1 = 1 << 1, 70 const ZX_OBJECT_SIGNAL_2 = 1 << 2, 71 const ZX_OBJECT_SIGNAL_3 = 1 << 3, 72 const ZX_OBJECT_SIGNAL_4 = 1 << 4, 73 const ZX_OBJECT_SIGNAL_5 = 1 << 5, 74 const ZX_OBJECT_SIGNAL_6 = 1 << 6, 75 const ZX_OBJECT_SIGNAL_7 = 1 << 7, 76 const ZX_OBJECT_SIGNAL_8 = 1 << 8, 77 const ZX_OBJECT_SIGNAL_9 = 1 << 9, 78 const ZX_OBJECT_SIGNAL_10 = 1 << 10, 79 const ZX_OBJECT_SIGNAL_11 = 1 << 11, 80 const ZX_OBJECT_SIGNAL_12 = 1 << 12, 81 const ZX_OBJECT_SIGNAL_13 = 1 << 13, 82 const ZX_OBJECT_SIGNAL_14 = 1 << 14, 83 const ZX_OBJECT_SIGNAL_15 = 1 << 15, 84 const ZX_OBJECT_SIGNAL_16 = 1 << 16, 85 const ZX_OBJECT_SIGNAL_17 = 1 << 17, 86 const ZX_OBJECT_SIGNAL_18 = 1 << 18, 87 const ZX_OBJECT_SIGNAL_19 = 1 << 19, 88 const ZX_OBJECT_SIGNAL_20 = 1 << 20, 89 const ZX_OBJECT_SIGNAL_21 = 1 << 21, 90 const ZX_OBJECT_LAST_HANDLE = 1 << 22, 91 const ZX_OBJECT_HANDLE_CLOSED = 1 << 23, 92 const ZX_USER_SIGNAL_0 = 1 << 24, 93 const ZX_USER_SIGNAL_1 = 1 << 25, 94 const ZX_USER_SIGNAL_2 = 1 << 26, 95 const ZX_USER_SIGNAL_3 = 1 << 27, 96 const ZX_USER_SIGNAL_4 = 1 << 28, 97 const ZX_USER_SIGNAL_5 = 1 << 29, 98 const ZX_USER_SIGNAL_6 = 1 << 30, 99 const ZX_USER_SIGNAL_7 = 1 << 31, 100 101 const ZX_OBJECT_READABLE = ZX_OBJECT_SIGNAL_0.bits, 102 const ZX_OBJECT_WRITABLE = ZX_OBJECT_SIGNAL_1.bits, 103 const ZX_OBJECT_PEER_CLOSED = ZX_OBJECT_SIGNAL_2.bits, 104 105 // Cancelation (handle was closed while waiting with it) 106 const ZX_SIGNAL_HANDLE_CLOSED = ZX_OBJECT_HANDLE_CLOSED.bits, 107 108 // Only one user-more reference (handle) to the object exists. 109 const ZX_SIGNAL_LAST_HANDLE = ZX_OBJECT_LAST_HANDLE.bits, 110 111 // Event 112 const ZX_EVENT_SIGNALED = ZX_OBJECT_SIGNAL_3.bits, 113 114 // EventPair 115 const ZX_EPAIR_SIGNALED = ZX_OBJECT_SIGNAL_3.bits, 116 const ZX_EPAIR_CLOSED = ZX_OBJECT_SIGNAL_2.bits, 117 118 // Task signals (process, thread, job) 119 const ZX_TASK_TERMINATED = ZX_OBJECT_SIGNAL_3.bits, 120 121 // Channel 122 const ZX_CHANNEL_READABLE = ZX_OBJECT_SIGNAL_0.bits, 123 const ZX_CHANNEL_WRITABLE = ZX_OBJECT_SIGNAL_1.bits, 124 const ZX_CHANNEL_PEER_CLOSED = ZX_OBJECT_SIGNAL_2.bits, 125 126 // Socket 127 const ZX_SOCKET_READABLE = ZX_OBJECT_SIGNAL_0.bits, 128 const ZX_SOCKET_WRITABLE = ZX_OBJECT_SIGNAL_1.bits, 129 const ZX_SOCKET_PEER_CLOSED = ZX_OBJECT_SIGNAL_2.bits, 130 131 // Port 132 const ZX_PORT_READABLE = ZX_OBJECT_READABLE.bits, 133 134 // Resource 135 const ZX_RESOURCE_DESTROYED = ZX_OBJECT_SIGNAL_3.bits, 136 const ZX_RESOURCE_READABLE = ZX_OBJECT_READABLE.bits, 137 const ZX_RESOURCE_WRITABLE = ZX_OBJECT_WRITABLE.bits, 138 const ZX_RESOURCE_CHILD_ADDED = ZX_OBJECT_SIGNAL_4.bits, 139 140 // Fifo 141 const ZX_FIFO_READABLE = ZX_OBJECT_READABLE.bits, 142 const ZX_FIFO_WRITABLE = ZX_OBJECT_WRITABLE.bits, 143 const ZX_FIFO_PEER_CLOSED = ZX_OBJECT_PEER_CLOSED.bits, 144 145 // Job 146 const ZX_JOB_NO_PROCESSES = ZX_OBJECT_SIGNAL_3.bits, 147 const ZX_JOB_NO_JOBS = ZX_OBJECT_SIGNAL_4.bits, 148 149 // Process 150 const ZX_PROCESS_TERMINATED = ZX_OBJECT_SIGNAL_3.bits, 151 152 // Thread 153 const ZX_THREAD_TERMINATED = ZX_OBJECT_SIGNAL_3.bits, 154 155 // Log 156 const ZX_LOG_READABLE = ZX_OBJECT_READABLE.bits, 157 const ZX_LOG_WRITABLE = ZX_OBJECT_WRITABLE.bits, 158 159 // Timer 160 const ZX_TIMER_SIGNALED = ZX_OBJECT_SIGNAL_3.bits, 161 } 162 } 163 164 pub type zx_size_t = usize; 165 pub type zx_ssize_t = isize; 166 167 bitflags! { 168 #[repr(C)] 169 pub flags zx_rights_t: u32 { 170 const ZX_RIGHT_NONE = 0, 171 const ZX_RIGHT_DUPLICATE = 1 << 0, 172 const ZX_RIGHT_TRANSFER = 1 << 1, 173 const ZX_RIGHT_READ = 1 << 2, 174 const ZX_RIGHT_WRITE = 1 << 3, 175 const ZX_RIGHT_EXECUTE = 1 << 4, 176 const ZX_RIGHT_MAP = 1 << 5, 177 const ZX_RIGHT_GET_PROPERTY = 1 << 6, 178 const ZX_RIGHT_SET_PROPERTY = 1 << 7, 179 const ZX_RIGHT_DEBUG = 1 << 8, 180 const ZX_RIGHT_SAME_RIGHTS = 1 << 31, 181 } 182 } 183 184 // clock ids 185 pub const ZX_CLOCK_MONOTONIC: u32 = 0; 186 187 // Buffer size limits on the cprng syscalls 188 pub const ZX_CPRNG_DRAW_MAX_LEN: usize = 256; 189 pub const ZX_CPRNG_ADD_ENTROPY_MAX_LEN: usize = 256; 190 191 // Socket flags and limits. 192 pub const ZX_SOCKET_HALF_CLOSE: u32 = 1; 193 194 // VM Object opcodes 195 pub const ZX_VMO_OP_COMMIT: u32 = 1; 196 pub const ZX_VMO_OP_DECOMMIT: u32 = 2; 197 pub const ZX_VMO_OP_LOCK: u32 = 3; 198 pub const ZX_VMO_OP_UNLOCK: u32 = 4; 199 pub const ZX_VMO_OP_LOOKUP: u32 = 5; 200 pub const ZX_VMO_OP_CACHE_SYNC: u32 = 6; 201 pub const ZX_VMO_OP_CACHE_INVALIDATE: u32 = 7; 202 pub const ZX_VMO_OP_CACHE_CLEAN: u32 = 8; 203 pub const ZX_VMO_OP_CACHE_CLEAN_INVALIDATE: u32 = 9; 204 205 // VM Object clone flags 206 pub const ZX_VMO_CLONE_COPY_ON_WRITE: u32 = 1; 207 208 // Mapping flags to vmar routines 209 bitflags! { 210 #[repr(C)] 211 pub flags zx_vmar_flags_t: u32 { 212 // flags to vmar routines 213 const ZX_VM_FLAG_PERM_READ = 1 << 0, 214 const ZX_VM_FLAG_PERM_WRITE = 1 << 1, 215 const ZX_VM_FLAG_PERM_EXECUTE = 1 << 2, 216 const ZX_VM_FLAG_COMPACT = 1 << 3, 217 const ZX_VM_FLAG_SPECIFIC = 1 << 4, 218 const ZX_VM_FLAG_SPECIFIC_OVERWRITE = 1 << 5, 219 const ZX_VM_FLAG_CAN_MAP_SPECIFIC = 1 << 6, 220 const ZX_VM_FLAG_CAN_MAP_READ = 1 << 7, 221 const ZX_VM_FLAG_CAN_MAP_WRITE = 1 << 8, 222 const ZX_VM_FLAG_CAN_MAP_EXECUTE = 1 << 9, 223 } 224 } 225 226 #[repr(C)] 227 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 228 pub enum zx_cache_policy_t { 229 ZX_CACHE_POLICY_CACHED = 0, 230 ZX_CACHE_POLICY_UNCACHED = 1, 231 ZX_CACHE_POLICY_UNCACHED_DEVICE = 2, 232 ZX_CACHE_POLICY_WRITE_COMBINING = 3, 233 } 234 235 #[repr(C)] 236 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 237 pub struct zx_wait_item_t { 238 pub handle: zx_handle_t, 239 pub waitfor: zx_signals_t, 240 pub pending: zx_signals_t, 241 } 242 243 #[repr(C)] 244 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 245 pub struct zx_waitset_result_t { 246 pub cookie: u64, 247 pub status: zx_status_t, 248 pub observed: zx_signals_t, 249 } 250 251 #[repr(C)] 252 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 253 pub struct zx_channel_call_args_t { 254 pub wr_bytes: *const u8, 255 pub wr_handles: *const zx_handle_t, 256 pub rd_bytes: *mut u8, 257 pub rd_handles: *mut zx_handle_t, 258 pub wr_num_bytes: u32, 259 pub wr_num_handles: u32, 260 pub rd_num_bytes: u32, 261 pub rd_num_handles: u32, 262 } 263 264 pub type zx_pci_irq_swizzle_lut_t = [[[u32; 4]; 8]; 32]; 265 266 #[repr(C)] 267 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 268 pub struct zx_pci_init_arg_t { 269 pub dev_pin_to_global_irq: zx_pci_irq_swizzle_lut_t, 270 pub num_irqs: u32, 271 pub irqs: [zx_irq_t; 32], 272 pub ecam_window_count: u32, 273 // Note: the ecam_windows field is actually a variable size array. 274 // We use a fixed size array to match the C repr. 275 pub ecam_windows: [zx_ecam_window_t; 1], 276 } 277 278 #[repr(C)] 279 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 280 pub struct zx_irq_t { 281 pub global_irq: u32, 282 pub level_triggered: bool, 283 pub active_high: bool, 284 } 285 286 #[repr(C)] 287 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 288 pub struct zx_ecam_window_t { 289 pub base: u64, 290 pub size: usize, 291 pub bus_start: u8, 292 pub bus_end: u8, 293 } 294 295 #[repr(C)] 296 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 297 pub struct zx_pcie_device_info_t { 298 pub vendor_id: u16, 299 pub device_id: u16, 300 pub base_class: u8, 301 pub sub_class: u8, 302 pub program_interface: u8, 303 pub revision_id: u8, 304 pub bus_id: u8, 305 pub dev_id: u8, 306 pub func_id: u8, 307 } 308 309 #[repr(C)] 310 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 311 pub struct zx_pci_resource_t { 312 pub type_: u32, 313 pub size: usize, 314 // TODO: Actually a union 315 pub pio_addr: usize, 316 } 317 318 // TODO: Actually a union 319 pub type zx_rrec_t = [u8; 64]; 320 321 // Ports V2 322 #[repr(u32)] 323 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 324 pub enum zx_packet_type_t { 325 ZX_PKT_TYPE_USER = 0, 326 ZX_PKT_TYPE_SIGNAL_ONE = 1, 327 ZX_PKT_TYPE_SIGNAL_REP = 2, 328 } 329 330 impl Default for zx_packet_type_t { default() -> Self331 fn default() -> Self { 332 zx_packet_type_t::ZX_PKT_TYPE_USER 333 } 334 } 335 336 #[repr(C)] 337 #[derive(Debug, Copy, Clone)] 338 pub struct zx_packet_signal_t { 339 pub trigger: zx_signals_t, 340 pub observed: zx_signals_t, 341 pub count: u64, 342 } 343 344 pub const ZX_WAIT_ASYNC_ONCE: u32 = 0; 345 pub const ZX_WAIT_ASYNC_REPEATING: u32 = 1; 346 347 // Actually a union of different integer types, but this should be good enough. 348 pub type zx_packet_user_t = [u8; 32]; 349 350 #[repr(C)] 351 #[derive(Debug, Default, Copy, Clone, Eq, PartialEq)] 352 pub struct zx_port_packet_t { 353 pub key: u64, 354 pub packet_type: zx_packet_type_t, 355 pub status: i32, 356 pub union: [u8; 32], 357 } 358 359 #[repr(C)] 360 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 361 pub struct zx_guest_io_t { 362 port: u16, 363 access_size: u8, 364 input: bool, 365 // TODO: Actually a union 366 data: [u8; 4], 367 } 368 369 #[cfg(target_arch="aarch64")] 370 #[repr(C)] 371 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 372 pub struct zx_guest_memory_t { 373 addr: zx_vaddr_t, 374 inst: u32, 375 } 376 377 pub const X86_MAX_INST_LEN: usize = 15; 378 379 #[cfg(target_arch="x86_64")] 380 #[repr(C)] 381 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 382 pub struct zx_guest_memory_t { 383 addr: zx_vaddr_t, 384 inst_len: u8, 385 inst_buf: [u8; X86_MAX_INST_LEN], 386 } 387 388 #[repr(u8)] 389 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 390 pub enum zx_guest_packet_t_type { 391 ZX_GUEST_PKT_MEMORY = 1, 392 ZX_GUEST_PKT_IO = 2, 393 } 394 395 #[repr(C)] 396 #[derive(Copy, Clone)] 397 pub union zx_guest_packet_t_union { 398 // ZX_GUEST_PKT_MEMORY 399 memory: zx_guest_memory_t, 400 // ZX_GUEST_PKT_IO 401 io: zx_guest_io_t, 402 } 403 404 // Note: values of this type must maintain the invariant that 405 // `packet_type` correctly indicates the type of `contents`. 406 // Failure to do so will result in unsafety. 407 #[repr(C)] 408 #[derive(Copy, Clone)] 409 pub struct zx_guest_packet_t { 410 packet_type: zx_guest_packet_t_type, 411 contents: zx_guest_packet_t_union, 412 } 413 414 impl fmt::Debug for zx_guest_packet_t { fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error>415 fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { 416 write!(f, "zx_guest_packet_t {{ packet_type: {:?}, contents: ", self.packet_type)?; 417 match self.packet_type { 418 zx_guest_packet_t_type::ZX_GUEST_PKT_MEMORY => 419 write!(f, "zx_guest_packet_t_union {{ memory: {:?} }} }}", 420 unsafe { self.contents.memory } 421 ), 422 zx_guest_packet_t_type::ZX_GUEST_PKT_IO => 423 write!(f, "zx_guest_packet_t_union {{ io: {:?} }} }}", 424 unsafe { self.contents.io } 425 ), 426 } 427 } 428 } 429 430 impl cmp::PartialEq for zx_guest_packet_t { eq(&self, other: &Self) -> bool431 fn eq(&self, other: &Self) -> bool { 432 (self.packet_type == other.packet_type) && 433 match self.packet_type { 434 zx_guest_packet_t_type::ZX_GUEST_PKT_MEMORY => 435 unsafe { self.contents.memory == other.contents.memory }, 436 zx_guest_packet_t_type::ZX_GUEST_PKT_IO => 437 unsafe { self.contents.io == other.contents.io }, 438 } 439 } 440 } 441 442 impl cmp::Eq for zx_guest_packet_t {} 443 444 #[cfg(target_arch="x86_64")] 445 #[repr(C)] 446 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 447 pub struct zx_vcpu_create_args_t { 448 pub ip: zx_vaddr_t, 449 pub cr3: zx_vaddr_t, 450 pub apic_vmo: zx_handle_t, 451 } 452 453 #[cfg(not(target_arch="x86_64"))] 454 #[repr(C)] 455 #[derive(Debug, Copy, Clone, Eq, PartialEq)] 456 pub struct zx_vcpu_create_args_t { 457 pub ip: zx_vaddr_t, 458 } 459 460 include!("definitions.rs");