diff options
Diffstat (limited to 'third_party/rust/fuchsia-zircon-sys')
| -rw-r--r-- | third_party/rust/fuchsia-zircon-sys/.cargo-checksum.json | 1 | ||||
| -rw-r--r-- | third_party/rust/fuchsia-zircon-sys/BUILD.gn | 9 | ||||
| -rw-r--r-- | third_party/rust/fuchsia-zircon-sys/Cargo.toml | 19 | ||||
| -rw-r--r-- | third_party/rust/fuchsia-zircon-sys/examples/hello.rs | 14 | ||||
| -rw-r--r-- | third_party/rust/fuchsia-zircon-sys/src/definitions.rs | 903 | ||||
| -rw-r--r-- | third_party/rust/fuchsia-zircon-sys/src/lib.rs | 474 |
6 files changed, 1420 insertions, 0 deletions
diff --git a/third_party/rust/fuchsia-zircon-sys/.cargo-checksum.json b/third_party/rust/fuchsia-zircon-sys/.cargo-checksum.json new file mode 100644 index 0000000000..3a0bedd264 --- /dev/null +++ b/third_party/rust/fuchsia-zircon-sys/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"BUILD.gn":"0a1529e038693c7d136f277d0987ccc35ebeaa46e5a8238ebce22da927e51bb2","Cargo.toml":"a952982a5ffbbb97d0e095c07903436dcc8fce0d4bf6c925877e751a98904967","examples/hello.rs":"66c6a147b98b913fef8e7a7da6387fb735f7f1e2c00abc8794a32a8cf0320851","src/definitions.rs":"557c48c3ae148158901abbc479cfefe4852141bafb0b926faa8669440bf6123b","src/lib.rs":"a3d9eb3d2243fea31ee2cfd2bf1bbf8ed77e15accf0542f133b83a97c87f6ca7"},"package":"3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"}
\ No newline at end of file diff --git a/third_party/rust/fuchsia-zircon-sys/BUILD.gn b/third_party/rust/fuchsia-zircon-sys/BUILD.gn new file mode 100644 index 0000000000..dc4701d3f9 --- /dev/null +++ b/third_party/rust/fuchsia-zircon-sys/BUILD.gn @@ -0,0 +1,9 @@ +# Copyright 2017 The Fuchsia Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import("//build/rust/rust_library.gni") + +rust_library("fuchsia-zircon-sys") { + deps = [] +} diff --git a/third_party/rust/fuchsia-zircon-sys/Cargo.toml b/third_party/rust/fuchsia-zircon-sys/Cargo.toml new file mode 100644 index 0000000000..274be529bd --- /dev/null +++ b/third_party/rust/fuchsia-zircon-sys/Cargo.toml @@ -0,0 +1,19 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g. crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "fuchsia-zircon-sys" +version = "0.3.3" +authors = ["Raph Levien <raph@google.com>"] +description = "Low-level Rust bindings for the Zircon kernel" +license = "BSD-3-Clause" +repository = "https://fuchsia.googlesource.com/garnet/" diff --git a/third_party/rust/fuchsia-zircon-sys/examples/hello.rs b/third_party/rust/fuchsia-zircon-sys/examples/hello.rs new file mode 100644 index 0000000000..f08bfa7503 --- /dev/null +++ b/third_party/rust/fuchsia-zircon-sys/examples/hello.rs @@ -0,0 +1,14 @@ +// Copyright 2016 The Fuchsia Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +extern crate fuchsia_zircon_sys as zircon_sys; + +pub fn main() { + let time = unsafe { zircon_sys::zx_time_get(zircon_sys::ZX_CLOCK_MONOTONIC) }; + println!("before sleep, time = {}", time); + unsafe { zircon_sys::zx_nanosleep(zircon_sys::zx_deadline_after(1000_000_000)); } + let time = unsafe { zircon_sys::zx_time_get(zircon_sys::ZX_CLOCK_MONOTONIC) }; + println!("after sleep, time = {}", time); +} + diff --git a/third_party/rust/fuchsia-zircon-sys/src/definitions.rs b/third_party/rust/fuchsia-zircon-sys/src/definitions.rs new file mode 100644 index 0000000000..956313dc86 --- /dev/null +++ b/third_party/rust/fuchsia-zircon-sys/src/definitions.rs @@ -0,0 +1,903 @@ +// Copyright 2017 The Fuchsia Authors. All rights reserved. +// This is a GENERATED file, see //zircon/system/host/sysgen. +// The license governing this file can be found in the LICENSE file. + +#[link(name = "zircon")] +extern { + pub fn zx_time_get( + clock_id: u32 + ) -> zx_time_t; + + pub fn zx_nanosleep( + deadline: zx_time_t + ) -> zx_status_t; + + pub fn zx_ticks_get( + ) -> u64; + + pub fn zx_ticks_per_second( + ) -> u64; + + pub fn zx_deadline_after( + nanoseconds: zx_duration_t + ) -> zx_time_t; + + pub fn zx_clock_adjust( + handle: zx_handle_t, + clock_id: u32, + offset: i64 + ) -> zx_status_t; + + pub fn zx_system_get_num_cpus( + ) -> u32; + + pub fn zx_system_get_version( + version: *mut u8, + version_len: u32 + ) -> zx_status_t; + + pub fn zx_system_get_physmem( + ) -> u64; + + pub fn zx_cache_flush( + addr: *const u8, + len: usize, + options: u32 + ) -> zx_status_t; + + pub fn zx_handle_close( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_handle_duplicate( + handle: zx_handle_t, + rights: zx_rights_t, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_handle_replace( + handle: zx_handle_t, + rights: zx_rights_t, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_object_wait_one( + handle: zx_handle_t, + waitfor: zx_signals_t, + deadline: zx_time_t, + observed: *mut zx_signals_t + ) -> zx_status_t; + + pub fn zx_object_wait_many( + items: *mut zx_wait_item_t, + count: u32, + deadline: zx_time_t + ) -> zx_status_t; + + pub fn zx_object_wait_async( + handle: zx_handle_t, + port_handle: zx_handle_t, + key: u64, + signals: zx_signals_t, + options: u32 + ) -> zx_status_t; + + pub fn zx_object_signal( + handle: zx_handle_t, + clear_mask: u32, + set_mask: u32 + ) -> zx_status_t; + + pub fn zx_object_signal_peer( + handle: zx_handle_t, + clear_mask: u32, + set_mask: u32 + ) -> zx_status_t; + + pub fn zx_object_get_property( + handle: zx_handle_t, + property: u32, + value: *mut u8, + size: usize + ) -> zx_status_t; + + pub fn zx_object_set_property( + handle: zx_handle_t, + property: u32, + value: *const u8, + size: usize + ) -> zx_status_t; + + pub fn zx_object_set_cookie( + handle: zx_handle_t, + scope: zx_handle_t, + cookie: u64 + ) -> zx_status_t; + + pub fn zx_object_get_cookie( + handle: zx_handle_t, + scope: zx_handle_t, + cookie: *mut u64 + ) -> zx_status_t; + + pub fn zx_object_get_info( + handle: zx_handle_t, + topic: u32, + buffer: *mut u8, + buffer_size: usize, + actual_count: *mut usize, + avail_count: *mut usize + ) -> zx_status_t; + + pub fn zx_object_get_child( + handle: zx_handle_t, + koid: u64, + rights: zx_rights_t, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_channel_create( + options: u32, + out0: *mut zx_handle_t, + out1: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_channel_read( + handle: zx_handle_t, + options: u32, + bytes: *mut u8, + handles: *mut zx_handle_t, + num_bytes: u32, + num_handles: u32, + actual_bytes: *mut u32, + actual_handles: *mut u32 + ) -> zx_status_t; + + pub fn zx_channel_write( + handle: zx_handle_t, + options: u32, + bytes: *const u8, + num_bytes: u32, + handles: *const zx_handle_t, + num_handles: u32 + ) -> zx_status_t; + + pub fn zx_channel_call_noretry( + handle: zx_handle_t, + options: u32, + deadline: zx_time_t, + args: *const zx_channel_call_args_t, + actual_bytes: *mut u32, + actual_handles: *mut u32, + read_status: *mut zx_status_t + ) -> zx_status_t; + + pub fn zx_channel_call_finish( + deadline: zx_time_t, + args: *const zx_channel_call_args_t, + actual_bytes: *mut u32, + actual_handles: *mut u32, + read_status: *mut zx_status_t + ) -> zx_status_t; + + pub fn zx_channel_call( + handle: zx_handle_t, + options: u32, + deadline: zx_time_t, + args: *const zx_channel_call_args_t, + actual_bytes: *mut u32, + actual_handles: *mut u32, + read_status: *mut zx_status_t + ) -> zx_status_t; + + pub fn zx_socket_create( + options: u32, + out0: *mut zx_handle_t, + out1: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_socket_write( + handle: zx_handle_t, + options: u32, + buffer: *const u8, + size: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_socket_read( + handle: zx_handle_t, + options: u32, + buffer: *mut u8, + size: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_thread_exit( + ); + + pub fn zx_thread_create( + process: zx_handle_t, + name: *const u8, + name_len: u32, + options: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_thread_start( + handle: zx_handle_t, + thread_entry: usize, + stack: usize, + arg1: usize, + arg2: usize + ) -> zx_status_t; + + pub fn zx_thread_read_state( + handle: zx_handle_t, + kind: u32, + buffer: *mut u8, + len: u32, + actual: *mut u32 + ) -> zx_status_t; + + pub fn zx_thread_write_state( + handle: zx_handle_t, + kind: u32, + buffer: *const u8, + buffer_len: u32 + ) -> zx_status_t; + + pub fn zx_thread_set_priority( + prio: i32 + ) -> zx_status_t; + + pub fn zx_process_exit( + retcode: isize + ); + + pub fn zx_process_create( + job: zx_handle_t, + name: *const u8, + name_len: u32, + options: u32, + proc_handle: *mut zx_handle_t, + vmar_handle: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_process_start( + process_handle: zx_handle_t, + thread_handle: zx_handle_t, + entry: usize, + stack: usize, + arg_handle: zx_handle_t, + arg2: usize + ) -> zx_status_t; + + pub fn zx_process_read_memory( + proc_: zx_handle_t, + vaddr: usize, + buffer: *mut u8, + len: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_process_write_memory( + proc_: zx_handle_t, + vaddr: usize, + buffer: *const u8, + len: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_job_create( + parent_job: zx_handle_t, + options: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_job_set_policy( + job: zx_handle_t, + options: u32, + topic: u32, + policy: *const u8, + count: u32 + ) -> zx_status_t; + + pub fn zx_task_bind_exception_port( + object: zx_handle_t, + eport: zx_handle_t, + key: u64, + options: u32 + ) -> zx_status_t; + + pub fn zx_task_suspend( + task_handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_task_resume( + task_handle: zx_handle_t, + options: u32 + ) -> zx_status_t; + + pub fn zx_task_kill( + task_handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_event_create( + options: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_eventpair_create( + options: u32, + out0: *mut zx_handle_t, + out1: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_futex_wait( + value_ptr: *mut zx_futex_t, + current_value: isize, + deadline: zx_time_t + ) -> zx_status_t; + + pub fn zx_futex_wake( + value_ptr: *const zx_futex_t, + count: u32 + ) -> zx_status_t; + + pub fn zx_futex_requeue( + wake_ptr: *mut zx_futex_t, + wake_count: u32, + current_value: isize, + requeue_ptr: *mut zx_futex_t, + requeue_count: u32 + ) -> zx_status_t; + + pub fn zx_port_create( + options: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_port_queue( + handle: zx_handle_t, + packet: *const zx_port_packet_t, + size: usize + ) -> zx_status_t; + + pub fn zx_port_wait( + handle: zx_handle_t, + deadline: zx_time_t, + packet: *mut zx_port_packet_t, + size: usize + ) -> zx_status_t; + + pub fn zx_port_cancel( + handle: zx_handle_t, + source: zx_handle_t, + key: u64 + ) -> zx_status_t; + + pub fn zx_timer_create( + options: u32, + clock_id: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_timer_set( + handle: zx_handle_t, + deadline: zx_time_t, + slack: zx_duration_t + ) -> zx_status_t; + + pub fn zx_timer_cancel( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_vmo_create( + size: u64, + options: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_vmo_read( + handle: zx_handle_t, + data: *mut u8, + offset: u64, + len: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_vmo_write( + handle: zx_handle_t, + data: *const u8, + offset: u64, + len: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_vmo_get_size( + handle: zx_handle_t, + size: *mut u64 + ) -> zx_status_t; + + pub fn zx_vmo_set_size( + handle: zx_handle_t, + size: u64 + ) -> zx_status_t; + + pub fn zx_vmo_op_range( + handle: zx_handle_t, + op: u32, + offset: u64, + size: u64, + buffer: *mut u8, + buffer_size: usize + ) -> zx_status_t; + + pub fn zx_vmo_clone( + handle: zx_handle_t, + options: u32, + offset: u64, + size: u64, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_vmo_set_cache_policy( + handle: zx_handle_t, + cache_policy: u32 + ) -> zx_status_t; + + pub fn zx_vmar_allocate( + parent_vmar_handle: zx_handle_t, + offset: usize, + size: usize, + map_flags: u32, + child_vmar: *mut zx_handle_t, + child_addr: *mut usize + ) -> zx_status_t; + + pub fn zx_vmar_destroy( + vmar_handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_vmar_map( + vmar_handle: zx_handle_t, + vmar_offset: usize, + vmo_handle: zx_handle_t, + vmo_offset: u64, + len: usize, + map_flags: u32, + mapped_addr: *mut usize + ) -> zx_status_t; + + pub fn zx_vmar_unmap( + vmar_handle: zx_handle_t, + addr: usize, + len: usize + ) -> zx_status_t; + + pub fn zx_vmar_protect( + vmar_handle: zx_handle_t, + addr: usize, + len: usize, + prot_flags: u32 + ) -> zx_status_t; + + pub fn zx_vmar_root_self() -> zx_handle_t; + + pub fn zx_cprng_draw( + buffer: *mut u8, + len: usize, + actual: *mut usize + ) -> zx_status_t; + + pub fn zx_cprng_add_entropy( + buffer: *const u8, + len: usize + ) -> zx_status_t; + + pub fn zx_fifo_create( + elem_count: u32, + elem_size: u32, + options: u32, + out0: *mut zx_handle_t, + out1: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_fifo_read( + handle: zx_handle_t, + data: *mut u8, + len: usize, + num_written: *mut u32 + ) -> zx_status_t; + + pub fn zx_fifo_write( + handle: zx_handle_t, + data: *const u8, + len: usize, + num_written: *mut u32 + ) -> zx_status_t; + + pub fn zx_vmar_unmap_handle_close_thread_exit( + vmar_handle: zx_handle_t, + addr: usize, + len: usize, + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_futex_wake_handle_close_thread_exit( + value_ptr: *const zx_futex_t, + count: u32, + new_value: isize, + handle: zx_handle_t + ); + + pub fn zx_log_create( + options: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_log_write( + handle: zx_handle_t, + len: u32, + buffer: *const u8, + options: u32 + ) -> zx_status_t; + + pub fn zx_log_read( + handle: zx_handle_t, + len: u32, + buffer: *mut u8, + options: u32 + ) -> zx_status_t; + + pub fn zx_ktrace_read( + handle: zx_handle_t, + data: *mut u8, + offset: u32, + len: u32, + actual: *mut u32 + ) -> zx_status_t; + + pub fn zx_ktrace_control( + handle: zx_handle_t, + action: u32, + options: u32, + ptr: *mut u8 + ) -> zx_status_t; + + pub fn zx_ktrace_write( + handle: zx_handle_t, + id: u32, + arg0: u32, + arg1: u32 + ) -> zx_status_t; + + pub fn zx_mtrace_control( + handle: zx_handle_t, + kind: u32, + action: u32, + options: u32, + ptr: *mut u8, + size: u32 + ) -> zx_status_t; + + pub fn zx_debug_read( + handle: zx_handle_t, + buffer: *mut u8, + length: u32 + ) -> zx_status_t; + + pub fn zx_debug_write( + buffer: *const u8, + length: u32 + ) -> zx_status_t; + + pub fn zx_debug_send_command( + resource_handle: zx_handle_t, + buffer: *const u8, + length: u32 + ) -> zx_status_t; + + pub fn zx_interrupt_create( + handle: zx_handle_t, + vector: u32, + options: u32, + out_handle: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_interrupt_complete( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_interrupt_wait( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_interrupt_signal( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_mmap_device_io( + handle: zx_handle_t, + io_addr: u32, + len: u32 + ) -> zx_status_t; + + pub fn zx_vmo_create_contiguous( + rsrc_handle: zx_handle_t, + size: usize, + alignment_log2: u32, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_vmo_create_physical( + rsrc_handle: zx_handle_t, + paddr: zx_paddr_t, + size: usize, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_bootloader_fb_get_info( + format: *mut u32, + width: *mut u32, + height: *mut u32, + stride: *mut u32 + ) -> zx_status_t; + + pub fn zx_set_framebuffer( + handle: zx_handle_t, + vaddr: *mut u8, + len: u32, + format: u32, + width: u32, + height: u32, + stride: u32 + ) -> zx_status_t; + + pub fn zx_set_framebuffer_vmo( + handle: zx_handle_t, + vmo: zx_handle_t, + len: u32, + format: u32, + width: u32, + height: u32, + stride: u32 + ) -> zx_status_t; + + pub fn zx_pci_get_nth_device( + handle: zx_handle_t, + index: u32, + out_info: *mut zx_pcie_device_info_t, + out_handle: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_pci_enable_bus_master( + handle: zx_handle_t, + enable: bool + ) -> zx_status_t; + + pub fn zx_pci_enable_pio( + handle: zx_handle_t, + enable: bool + ) -> zx_status_t; + + pub fn zx_pci_reset_device( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_pci_cfg_pio_rw( + handle: zx_handle_t, + bus: u8, + dev: u8, + func: u8, + offset: u8, + val: *mut u32, + width: usize, + write: bool + ) -> zx_status_t; + + pub fn zx_pci_get_bar( + handle: zx_handle_t, + bar_num: u32, + out_bar: *mut zx_pci_resource_t + ) -> zx_status_t; + + pub fn zx_pci_get_config( + handle: zx_handle_t, + out_config: *mut zx_pci_resource_t + ) -> zx_status_t; + + pub fn zx_pci_io_write( + handle: zx_handle_t, + bar_num: u32, + offset: u32, + len: u32, + value: u32 + ) -> zx_status_t; + + pub fn zx_pci_io_read( + handle: zx_handle_t, + bar_num: u32, + offset: u32, + len: u32, + out_value: *mut u32 + ) -> zx_status_t; + + pub fn zx_pci_map_interrupt( + handle: zx_handle_t, + which_irq: i32, + out_handle: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_pci_query_irq_mode_caps( + handle: zx_handle_t, + mode: u32, + out_max_irqs: *mut u32 + ) -> zx_status_t; + + pub fn zx_pci_set_irq_mode( + handle: zx_handle_t, + mode: u32, + requested_irq_count: u32 + ) -> zx_status_t; + + pub fn zx_pci_init( + handle: zx_handle_t, + init_buf: *const zx_pci_init_arg_t, + len: u32 + ) -> zx_status_t; + + pub fn zx_pci_add_subtract_io_range( + handle: zx_handle_t, + mmio: bool, + base: u64, + len: u64, + add: bool + ) -> zx_status_t; + + pub fn zx_acpi_uefi_rsdp( + handle: zx_handle_t + ) -> u64; + + pub fn zx_acpi_cache_flush( + handle: zx_handle_t + ) -> zx_status_t; + + pub fn zx_resource_create( + parent_handle: zx_handle_t, + kind: u32, + low: u64, + high: u64, + resource_out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_guest_create( + resource: zx_handle_t, + options: u32, + physmem_vmo: zx_handle_t, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_guest_set_trap( + guest: zx_handle_t, + kind: u32, + addr: zx_vaddr_t, + len: usize, + fifo: zx_handle_t + ) -> zx_status_t; + + pub fn zx_vcpu_create( + guest: zx_handle_t, + options: u32, + args: *const zx_vcpu_create_args_t, + out: *mut zx_handle_t + ) -> zx_status_t; + + pub fn zx_vcpu_resume( + vcpu: zx_handle_t, + packet: *mut zx_guest_packet_t + ) -> zx_status_t; + + pub fn zx_vcpu_interrupt( + vcpu: zx_handle_t, + vector: u32 + ) -> zx_status_t; + + pub fn zx_vcpu_read_state( + vcpu: zx_handle_t, + kind: u32, + buffer: *mut u8, + len: u32 + ) -> zx_status_t; + + pub fn zx_vcpu_write_state( + vcpu: zx_handle_t, + kind: u32, + buffer: *const u8, + len: u32 + ) -> zx_status_t; + + pub fn zx_system_mexec( + kernel: zx_handle_t, + bootimage: zx_handle_t, + cmdline: *const u8, + cmdline_len: u32 + ) -> zx_status_t; + + pub fn zx_job_set_relative_importance( + root_resource: zx_handle_t, + job: zx_handle_t, + less_important_job: zx_handle_t + ) -> zx_status_t; + + pub fn zx_syscall_test_0( + ) -> zx_status_t; + + pub fn zx_syscall_test_1( + a: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_2( + a: isize, + b: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_3( + a: isize, + b: isize, + c: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_4( + a: isize, + b: isize, + c: isize, + d: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_5( + a: isize, + b: isize, + c: isize, + d: isize, + e: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_6( + a: isize, + b: isize, + c: isize, + d: isize, + e: isize, + f: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_7( + a: isize, + b: isize, + c: isize, + d: isize, + e: isize, + f: isize, + g: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_8( + a: isize, + b: isize, + c: isize, + d: isize, + e: isize, + f: isize, + g: isize, + h: isize + ) -> zx_status_t; + + pub fn zx_syscall_test_wrapper( + a: isize, + b: isize, + c: isize + ) -> zx_status_t; + + +} diff --git a/third_party/rust/fuchsia-zircon-sys/src/lib.rs b/third_party/rust/fuchsia-zircon-sys/src/lib.rs new file mode 100644 index 0000000000..e9d51f8ad3 --- /dev/null +++ b/third_party/rust/fuchsia-zircon-sys/src/lib.rs @@ -0,0 +1,474 @@ +// Copyright 2016 The Fuchsia Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#![allow(non_camel_case_types)] +#![deny(warnings)] + +use std::{cmp, fmt}; + +pub type zx_addr_t = usize; +pub type zx_duration_t = u64; +pub type zx_futex_t = i32; +pub type zx_handle_t = u32; +pub type zx_off_t = u64; +pub type zx_paddr_t = usize; +pub type zx_rights_t = u32; +pub type zx_signals_t = u32; +pub type zx_size_t = usize; +pub type zx_ssize_t = isize; +pub type zx_status_t = i32; +pub type zx_time_t = u64; +pub type zx_vaddr_t = usize; + +// TODO: combine these macros with the bitflags and assoc consts macros below +// so that we only have to do one macro invocation. +// The result would look something like: +// multiconst!(bitflags, zx_rights_t, Rights, [RIGHT_NONE => ZX_RIGHT_NONE = 0; ...]); +// multiconst!(assoc_consts, zx_status_t, Status, [OK => ZX_OK = 0; ...]); +// Note that the actual name of the inner macro (e.g. `bitflags`) can't be a variable. +// It'll just have to be matched on manually +macro_rules! multiconst { + ($typename:ident, [$($rawname:ident = $value:expr;)*]) => { + $( + pub const $rawname: $typename = $value; + )* + } +} + +multiconst!(zx_handle_t, [ + ZX_HANDLE_INVALID = 0; +]); + +multiconst!(zx_time_t, [ + ZX_TIME_INFINITE = ::std::u64::MAX; +]); + +multiconst!(zx_rights_t, [ + ZX_RIGHT_NONE = 0; + ZX_RIGHT_DUPLICATE = 1 << 0; + ZX_RIGHT_TRANSFER = 1 << 1; + ZX_RIGHT_READ = 1 << 2; + ZX_RIGHT_WRITE = 1 << 3; + ZX_RIGHT_EXECUTE = 1 << 4; + ZX_RIGHT_MAP = 1 << 5; + ZX_RIGHT_GET_PROPERTY = 1 << 6; + ZX_RIGHT_SET_PROPERTY = 1 << 7; + ZX_RIGHT_ENUMERATE = 1 << 8; + ZX_RIGHT_DESTROY = 1 << 9; + ZX_RIGHT_SET_POLICY = 1 << 10; + ZX_RIGHT_GET_POLICY = 1 << 11; + ZX_RIGHT_SIGNAL = 1 << 12; + ZX_RIGHT_SIGNAL_PEER = 1 << 13; + ZX_RIGHT_WAIT = 0 << 14; // Coming Soon! + ZX_RIGHT_SAME_RIGHTS = 1 << 31; +]); + +// TODO: add an alias for this type in the C headers. +multiconst!(u32, [ + ZX_VMO_OP_COMMIT = 1; + ZX_VMO_OP_DECOMMIT = 2; + ZX_VMO_OP_LOCK = 3; + ZX_VMO_OP_UNLOCK = 4; + ZX_VMO_OP_LOOKUP = 5; + ZX_VMO_OP_CACHE_SYNC = 6; + ZX_VMO_OP_CACHE_INVALIDATE = 7; + ZX_VMO_OP_CACHE_CLEAN = 8; + ZX_VMO_OP_CACHE_CLEAN_INVALIDATE = 9; +]); + +// TODO: add an alias for this type in the C headers. +multiconst!(u32, [ + ZX_VM_FLAG_PERM_READ = 1 << 0; + ZX_VM_FLAG_PERM_WRITE = 1 << 1; + ZX_VM_FLAG_PERM_EXECUTE = 1 << 2; + ZX_VM_FLAG_COMPACT = 1 << 3; + ZX_VM_FLAG_SPECIFIC = 1 << 4; + ZX_VM_FLAG_SPECIFIC_OVERWRITE = 1 << 5; + ZX_VM_FLAG_CAN_MAP_SPECIFIC = 1 << 6; + ZX_VM_FLAG_CAN_MAP_READ = 1 << 7; + ZX_VM_FLAG_CAN_MAP_WRITE = 1 << 8; + ZX_VM_FLAG_CAN_MAP_EXECUTE = 1 << 9; +]); + +multiconst!(zx_status_t, [ + ZX_OK = 0; + ZX_ERR_INTERNAL = -1; + ZX_ERR_NOT_SUPPORTED = -2; + ZX_ERR_NO_RESOURCES = -3; + ZX_ERR_NO_MEMORY = -4; + ZX_ERR_CALL_FAILED = -5; + ZX_ERR_INTERRUPTED_RETRY = -6; + ZX_ERR_INVALID_ARGS = -10; + ZX_ERR_BAD_HANDLE = -11; + ZX_ERR_WRONG_TYPE = -12; + ZX_ERR_BAD_SYSCALL = -13; + ZX_ERR_OUT_OF_RANGE = -14; + ZX_ERR_BUFFER_TOO_SMALL = -15; + ZX_ERR_BAD_STATE = -20; + ZX_ERR_TIMED_OUT = -21; + ZX_ERR_SHOULD_WAIT = -22; + ZX_ERR_CANCELED = -23; + ZX_ERR_PEER_CLOSED = -24; + ZX_ERR_NOT_FOUND = -25; + ZX_ERR_ALREADY_EXISTS = -26; + ZX_ERR_ALREADY_BOUND = -27; + ZX_ERR_UNAVAILABLE = -28; + ZX_ERR_ACCESS_DENIED = -30; + ZX_ERR_IO = -40; + ZX_ERR_IO_REFUSED = -41; + ZX_ERR_IO_DATA_INTEGRITY = -42; + ZX_ERR_IO_DATA_LOSS = -43; + ZX_ERR_BAD_PATH = -50; + ZX_ERR_NOT_DIR = -51; + ZX_ERR_NOT_FILE = -52; + ZX_ERR_FILE_BIG = -53; + ZX_ERR_NO_SPACE = -54; + ZX_ERR_STOP = -60; + ZX_ERR_NEXT = -61; +]); + +multiconst!(zx_signals_t, [ + ZX_SIGNAL_NONE = 0; + ZX_OBJECT_SIGNAL_ALL = 0x00ffffff; + ZX_USER_SIGNAL_ALL = 0xff000000; + ZX_OBJECT_SIGNAL_0 = 1 << 0; + ZX_OBJECT_SIGNAL_1 = 1 << 1; + ZX_OBJECT_SIGNAL_2 = 1 << 2; + ZX_OBJECT_SIGNAL_3 = 1 << 3; + ZX_OBJECT_SIGNAL_4 = 1 << 4; + ZX_OBJECT_SIGNAL_5 = 1 << 5; + ZX_OBJECT_SIGNAL_6 = 1 << 6; + ZX_OBJECT_SIGNAL_7 = 1 << 7; + ZX_OBJECT_SIGNAL_8 = 1 << 8; + ZX_OBJECT_SIGNAL_9 = 1 << 9; + ZX_OBJECT_SIGNAL_10 = 1 << 10; + ZX_OBJECT_SIGNAL_11 = 1 << 11; + ZX_OBJECT_SIGNAL_12 = 1 << 12; + ZX_OBJECT_SIGNAL_13 = 1 << 13; + ZX_OBJECT_SIGNAL_14 = 1 << 14; + ZX_OBJECT_SIGNAL_15 = 1 << 15; + ZX_OBJECT_SIGNAL_16 = 1 << 16; + ZX_OBJECT_SIGNAL_17 = 1 << 17; + ZX_OBJECT_SIGNAL_18 = 1 << 18; + ZX_OBJECT_SIGNAL_19 = 1 << 19; + ZX_OBJECT_SIGNAL_20 = 1 << 20; + ZX_OBJECT_SIGNAL_21 = 1 << 21; + ZX_OBJECT_SIGNAL_22 = 1 << 22; + ZX_OBJECT_HANDLE_CLOSED = 1 << 23; + ZX_USER_SIGNAL_0 = 1 << 24; + ZX_USER_SIGNAL_1 = 1 << 25; + ZX_USER_SIGNAL_2 = 1 << 26; + ZX_USER_SIGNAL_3 = 1 << 27; + ZX_USER_SIGNAL_4 = 1 << 28; + ZX_USER_SIGNAL_5 = 1 << 29; + ZX_USER_SIGNAL_6 = 1 << 30; + ZX_USER_SIGNAL_7 = 1 << 31; + + ZX_OBJECT_READABLE = ZX_OBJECT_SIGNAL_0; + ZX_OBJECT_WRITABLE = ZX_OBJECT_SIGNAL_1; + ZX_OBJECT_PEER_CLOSED = ZX_OBJECT_SIGNAL_2; + + // Cancelation (handle was closed while waiting with it) + ZX_SIGNAL_HANDLE_CLOSED = ZX_OBJECT_HANDLE_CLOSED; + + // Event + ZX_EVENT_SIGNALED = ZX_OBJECT_SIGNAL_3; + + // EventPair + ZX_EPAIR_SIGNALED = ZX_OBJECT_SIGNAL_3; + ZX_EPAIR_CLOSED = ZX_OBJECT_SIGNAL_2; + + // Task signals (process, thread, job) + ZX_TASK_TERMINATED = ZX_OBJECT_SIGNAL_3; + + // Channel + ZX_CHANNEL_READABLE = ZX_OBJECT_SIGNAL_0; + ZX_CHANNEL_WRITABLE = ZX_OBJECT_SIGNAL_1; + ZX_CHANNEL_PEER_CLOSED = ZX_OBJECT_SIGNAL_2; + + // Socket + ZX_SOCKET_READABLE = ZX_OBJECT_SIGNAL_0; + ZX_SOCKET_WRITABLE = ZX_OBJECT_SIGNAL_1; + ZX_SOCKET_PEER_CLOSED = ZX_OBJECT_SIGNAL_2; + + // Port + ZX_PORT_READABLE = ZX_OBJECT_READABLE; + + // Resource + ZX_RESOURCE_DESTROYED = ZX_OBJECT_SIGNAL_3; + ZX_RESOURCE_READABLE = ZX_OBJECT_READABLE; + ZX_RESOURCE_WRITABLE = ZX_OBJECT_WRITABLE; + ZX_RESOURCE_CHILD_ADDED = ZX_OBJECT_SIGNAL_4; + + // Fifo + ZX_FIFO_READABLE = ZX_OBJECT_READABLE; + ZX_FIFO_WRITABLE = ZX_OBJECT_WRITABLE; + ZX_FIFO_PEER_CLOSED = ZX_OBJECT_PEER_CLOSED; + + // Job + ZX_JOB_NO_PROCESSES = ZX_OBJECT_SIGNAL_3; + ZX_JOB_NO_JOBS = ZX_OBJECT_SIGNAL_4; + + // Process + ZX_PROCESS_TERMINATED = ZX_OBJECT_SIGNAL_3; + + // Thread + ZX_THREAD_TERMINATED = ZX_OBJECT_SIGNAL_3; + + // Log + ZX_LOG_READABLE = ZX_OBJECT_READABLE; + ZX_LOG_WRITABLE = ZX_OBJECT_WRITABLE; + + // Timer + ZX_TIMER_SIGNALED = ZX_OBJECT_SIGNAL_3; +]); + +// clock ids +pub const ZX_CLOCK_MONOTONIC: u32 = 0; + +// Buffer size limits on the cprng syscalls +pub const ZX_CPRNG_DRAW_MAX_LEN: usize = 256; +pub const ZX_CPRNG_ADD_ENTROPY_MAX_LEN: usize = 256; + +// Socket flags and limits. +pub const ZX_SOCKET_HALF_CLOSE: u32 = 1; + +// VM Object clone flags +pub const ZX_VMO_CLONE_COPY_ON_WRITE: u32 = 1; + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub enum zx_cache_policy_t { + ZX_CACHE_POLICY_CACHED = 0, + ZX_CACHE_POLICY_UNCACHED = 1, + ZX_CACHE_POLICY_UNCACHED_DEVICE = 2, + ZX_CACHE_POLICY_WRITE_COMBINING = 3, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_wait_item_t { + pub handle: zx_handle_t, + pub waitfor: zx_signals_t, + pub pending: zx_signals_t, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_waitset_result_t { + pub cookie: u64, + pub status: zx_status_t, + pub observed: zx_signals_t, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_channel_call_args_t { + pub wr_bytes: *const u8, + pub wr_handles: *const zx_handle_t, + pub rd_bytes: *mut u8, + pub rd_handles: *mut zx_handle_t, + pub wr_num_bytes: u32, + pub wr_num_handles: u32, + pub rd_num_bytes: u32, + pub rd_num_handles: u32, +} + +pub type zx_pci_irq_swizzle_lut_t = [[[u32; 4]; 8]; 32]; + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_pci_init_arg_t { + pub dev_pin_to_global_irq: zx_pci_irq_swizzle_lut_t, + pub num_irqs: u32, + pub irqs: [zx_irq_t; 32], + pub ecam_window_count: u32, + // Note: the ecam_windows field is actually a variable size array. + // We use a fixed size array to match the C repr. + pub ecam_windows: [zx_ecam_window_t; 1], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_irq_t { + pub global_irq: u32, + pub level_triggered: bool, + pub active_high: bool, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_ecam_window_t { + pub base: u64, + pub size: usize, + pub bus_start: u8, + pub bus_end: u8, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_pcie_device_info_t { + pub vendor_id: u16, + pub device_id: u16, + pub base_class: u8, + pub sub_class: u8, + pub program_interface: u8, + pub revision_id: u8, + pub bus_id: u8, + pub dev_id: u8, + pub func_id: u8, +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_pci_resource_t { + pub type_: u32, + pub size: usize, + // TODO: Actually a union + pub pio_addr: usize, +} + +// TODO: Actually a union +pub type zx_rrec_t = [u8; 64]; + +// Ports V2 +#[repr(u32)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub enum zx_packet_type_t { + ZX_PKT_TYPE_USER = 0, + ZX_PKT_TYPE_SIGNAL_ONE = 1, + ZX_PKT_TYPE_SIGNAL_REP = 2, +} + +impl Default for zx_packet_type_t { + fn default() -> Self { + zx_packet_type_t::ZX_PKT_TYPE_USER + } +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct zx_packet_signal_t { + pub trigger: zx_signals_t, + pub observed: zx_signals_t, + pub count: u64, +} + +pub const ZX_WAIT_ASYNC_ONCE: u32 = 0; +pub const ZX_WAIT_ASYNC_REPEATING: u32 = 1; + +// Actually a union of different integer types, but this should be good enough. +pub type zx_packet_user_t = [u8; 32]; + +#[repr(C)] +#[derive(Debug, Default, Copy, Clone, Eq, PartialEq)] +pub struct zx_port_packet_t { + pub key: u64, + pub packet_type: zx_packet_type_t, + pub status: i32, + pub union: [u8; 32], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_guest_io_t { + port: u16, + access_size: u8, + input: bool, + // TODO: Actually a union + data: [u8; 4], +} + +#[cfg(target_arch="aarch64")] +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_guest_memory_t { + addr: zx_vaddr_t, + inst: u32, +} + +pub const X86_MAX_INST_LEN: usize = 15; + +#[cfg(target_arch="x86_64")] +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_guest_memory_t { + addr: zx_vaddr_t, + inst_len: u8, + inst_buf: [u8; X86_MAX_INST_LEN], +} + +#[repr(u8)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub enum zx_guest_packet_t_type { + ZX_GUEST_PKT_MEMORY = 1, + ZX_GUEST_PKT_IO = 2, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub union zx_guest_packet_t_union { + // ZX_GUEST_PKT_MEMORY + memory: zx_guest_memory_t, + // ZX_GUEST_PKT_IO + io: zx_guest_io_t, +} + +// Note: values of this type must maintain the invariant that +// `packet_type` correctly indicates the type of `contents`. +// Failure to do so will result in unsafety. +#[repr(C)] +#[derive(Copy, Clone)] +pub struct zx_guest_packet_t { + packet_type: zx_guest_packet_t_type, + contents: zx_guest_packet_t_union, +} + +impl fmt::Debug for zx_guest_packet_t { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + write!(f, "zx_guest_packet_t {{ packet_type: {:?}, contents: ", self.packet_type)?; + match self.packet_type { + zx_guest_packet_t_type::ZX_GUEST_PKT_MEMORY => + write!(f, "zx_guest_packet_t_union {{ memory: {:?} }} }}", + unsafe { self.contents.memory } + ), + zx_guest_packet_t_type::ZX_GUEST_PKT_IO => + write!(f, "zx_guest_packet_t_union {{ io: {:?} }} }}", + unsafe { self.contents.io } + ), + } + } +} + +impl cmp::PartialEq for zx_guest_packet_t { + fn eq(&self, other: &Self) -> bool { + (self.packet_type == other.packet_type) && + match self.packet_type { + zx_guest_packet_t_type::ZX_GUEST_PKT_MEMORY => + unsafe { self.contents.memory == other.contents.memory }, + zx_guest_packet_t_type::ZX_GUEST_PKT_IO => + unsafe { self.contents.io == other.contents.io }, + } + } +} + +impl cmp::Eq for zx_guest_packet_t {} + +#[cfg(target_arch="x86_64")] +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_vcpu_create_args_t { + pub ip: zx_vaddr_t, + pub cr3: zx_vaddr_t, + pub apic_vmo: zx_handle_t, +} + +#[cfg(not(target_arch="x86_64"))] +#[repr(C)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct zx_vcpu_create_args_t { + pub ip: zx_vaddr_t, +} + +include!("definitions.rs"); |