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