| # 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. |
| |
| # |
| # The syntax of each line is |
| # syscall <name> [attributes] ([args]) |
| # [returns (<type> [attributes] [args])]; |
| # |
| # with '[]' being optional and '<>' being required input. |
| # |
| # <name> is the syscall function name. It must be a valid C identifier. |
| # |
| # [attributes] can be empty or is a space separated list of words with |
| # meaning for a particular generator. |
| # |
| # [args] can be empty or is a comma separated list of |
| # '<aname>: <type> [attributes] [ctr]' |
| # |
| # <aname> is the argument name. It must be a valid C indentifier. |
| # |
| # <type> is the argument type. It must be a valid C indentifer with an optional |
| # array-spec which when present it must be "[number]" or "[aname]", with the |
| # number being an integer and aname the name of the argument that controls the |
| # array size. |
| # |
| # [ctr] can be empty or is an all-caps word to specify a argument constraint |
| # with valid values being one of: 'IN', 'OUT', 'INOUT' |
| # |
| # The 'returns (<type>)' is expected unless one of the attributes is 'noreturn'. |
| # |
| # See <https://fuchsia.googlesource.com/docs/+/master/development/api/system.md> |
| # for readability guidelines. |
| # |
| # To help the clang static analyzer identify handle related syscalls, 3 |
| # attributes are available to describe handle behaviors. Which are |
| # handle_acquire, handle_release and handle_release_always. |
| # |
| # handle_acquire The handle will be allocated when this call is |
| # successful. |
| # |
| # handle_release The handle will be released/destroyed when this |
| # call is successful. |
| # |
| # handle_release_always The handle will be released/destroyed; the only failure |
| # possible is for an invalid handle. |
| # |
| # |
| |
| # Time |
| |
| syscall clock_get |
| (clock_id: uint32_t) |
| returns (zx_time_t); |
| |
| syscall nanosleep blocking |
| (deadline: zx_time_t) |
| returns (zx_status_t); |
| |
| syscall ticks_get vdsocall |
| () |
| returns (uint64_t); |
| |
| syscall ticks_per_second vdsocall const |
| () |
| returns (uint64_t); |
| |
| syscall deadline_after vdsocall |
| (nanoseconds: zx_duration_t) |
| returns (zx_time_t); |
| |
| syscall clock_adjust |
| (handle: zx_handle_t, clock_id: uint32_t, offset: int64_t) |
| returns (zx_status_t); |
| |
| # System information |
| |
| syscall system_get_dcache_line_size vdsocall const |
| () |
| returns (uint32_t); |
| |
| syscall system_get_num_cpus vdsocall const |
| () |
| returns (uint32_t); |
| |
| syscall system_get_version vdsocall |
| (version: char[version_size] OUT, version_size: size_t) |
| returns (zx_status_t); |
| |
| syscall system_get_physmem vdsocall |
| () |
| returns (uint64_t); |
| |
| syscall system_get_features vdsocall |
| (kind: uint32_t) |
| returns (zx_status_t, out: uint32_t features); |
| |
| # Abstraction of machine operations |
| |
| syscall cache_flush vdsocall |
| (addr: any[size] IN, size: size_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| # Generic handle operations |
| |
| syscall handle_close |
| (handle: zx_handle_t handle_release_always) |
| returns (zx_status_t); |
| |
| syscall handle_duplicate |
| (handle: zx_handle_t, rights: zx_rights_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall handle_replace |
| (handle: zx_handle_t handle_release_always, rights: zx_rights_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| # Generic object operations |
| |
| syscall object_wait_one blocking |
| (handle: zx_handle_t, signals: zx_signals_t, deadline: zx_time_t) |
| returns (zx_status_t, observed: zx_signals_t optional); |
| |
| syscall object_wait_many blocking |
| (items: zx_wait_item_t[count] INOUT, count: size_t, deadline: zx_time_t) |
| returns (zx_status_t); |
| |
| syscall object_wait_async |
| (handle: zx_handle_t, port: zx_handle_t, key: uint64_t, |
| signals: zx_signals_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall object_signal |
| (handle: zx_handle_t, clear_mask: uint32_t, set_mask: uint32_t) |
| returns (zx_status_t); |
| |
| syscall object_signal_peer |
| (handle: zx_handle_t, clear_mask: uint32_t, set_mask: uint32_t) |
| returns (zx_status_t); |
| |
| syscall object_get_property |
| (handle: zx_handle_t, property: uint32_t, value: any[value_size] OUT, value_size: size_t) |
| returns (zx_status_t); |
| |
| syscall object_set_property |
| (handle: zx_handle_t, property: uint32_t, value: any[value_size] IN, value_size: size_t) |
| returns (zx_status_t); |
| |
| syscall object_set_cookie |
| (handle: zx_handle_t, scope: zx_handle_t, cookie: uint64_t) |
| returns (zx_status_t); |
| |
| syscall object_get_cookie |
| (handle: zx_handle_t, scope: zx_handle_t) |
| returns (zx_status_t, cookie: uint64_t); |
| |
| syscall object_get_info |
| (handle: zx_handle_t, topic: uint32_t, buffer: any[buffer_size] OUT, buffer_size: size_t) |
| returns (zx_status_t, actual_count: size_t optional, avail_count: size_t optional); |
| |
| syscall object_get_child |
| (handle: zx_handle_t, koid: uint64_t, rights: zx_rights_t) |
| returns (zx_status_t, out: zx_handle_t); |
| |
| syscall object_set_profile |
| (handle: zx_handle_t, profile: zx_handle_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| # IPC: Channels |
| |
| syscall channel_create |
| (options: uint32_t) |
| returns (zx_status_t, out0: zx_handle_t handle_acquire, |
| out1: zx_handle_t handle_acquire); |
| |
| syscall channel_read |
| (handle: zx_handle_t, options: uint32_t, |
| bytes: any[num_bytes] OUT, |
| handles: zx_handle_t[num_handles] OUT, |
| num_bytes: uint32_t, |
| num_handles: uint32_t) |
| returns (zx_status_t, actual_bytes: uint32_t optional, actual_handles: uint32_t optional); |
| |
| syscall channel_read_etc |
| (handle: zx_handle_t, options: uint32_t, |
| bytes: any[num_bytes] OUT, |
| handles: zx_handle_info_t[num_handles] OUT, |
| num_bytes: uint32_t, |
| num_handles: uint32_t) |
| returns (zx_status_t, actual_bytes: uint32_t optional, actual_handles: uint32_t optional); |
| |
| syscall channel_write |
| (handle: zx_handle_t, options: uint32_t, |
| bytes: any[num_bytes] IN, num_bytes: uint32_t, |
| handles: zx_handle_t[num_handles] IN, num_handles: uint32_t) |
| returns (zx_status_t); |
| |
| syscall channel_call_noretry internal |
| (handle: zx_handle_t, options: uint32_t, deadline: zx_time_t, |
| args: zx_channel_call_args_t[1] IN) |
| returns (zx_status_t, actual_bytes: uint32_t, |
| actual_handles: uint32_t, read_status: zx_status_t optional); |
| |
| syscall channel_call_finish internal |
| (deadline: zx_time_t, args: zx_channel_call_args_t[1] IN) |
| returns (zx_status_t, actual_bytes: uint32_t, |
| actual_handles: uint32_t, read_status: zx_status_t optional); |
| |
| syscall channel_call blocking vdsocall |
| (handle: zx_handle_t, options: uint32_t, deadline: zx_time_t, |
| args: zx_channel_call_args_t[1] IN) |
| returns (zx_status_t, actual_bytes: uint32_t, |
| actual_handles: uint32_t, read_status: zx_status_t optional); |
| |
| # IPC: Sockets |
| |
| syscall socket_create |
| (options: uint32_t) |
| returns (zx_status_t, out0: zx_handle_t handle_acquire, |
| out1: zx_handle_t handle_acquire); |
| |
| syscall socket_write |
| (handle: zx_handle_t, options: uint32_t, buffer: any[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t, actual: size_t optional); |
| |
| syscall socket_read |
| (handle: zx_handle_t, options: uint32_t, buffer: any[buffer_size] OUT, buffer_size: size_t) |
| returns (zx_status_t, actual: size_t optional); |
| |
| syscall socket_share |
| (handle: zx_handle_t, socket_to_share: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall socket_accept |
| (handle: zx_handle_t) |
| returns (zx_status_t, out_socket: zx_handle_t handle_acquire); |
| |
| # Threads |
| |
| syscall thread_exit noreturn (); |
| |
| syscall thread_create |
| (process: zx_handle_t, name: char[name_size] IN, name_size: size_t, options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall thread_start |
| (handle: zx_handle_t, thread_entry: zx_vaddr_t, |
| stack: zx_vaddr_t, arg1: uintptr_t, arg2: uintptr_t) |
| returns (zx_status_t); |
| |
| syscall thread_read_state |
| (handle: zx_handle_t, kind: uint32_t, buffer: any[buffer_size] OUT, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall thread_write_state |
| (handle: zx_handle_t, kind: uint32_t, buffer: any[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| # NOTE: thread_set_priority is an experimental syscall. |
| # Do not use it. It is going away very soon. Just don't do it. This is not |
| # the syscall you are looking for. See ZX-940 |
| syscall thread_set_priority |
| (prio: int32_t) |
| returns (zx_status_t); |
| |
| # Processes |
| |
| syscall process_exit noreturn |
| (retcode: int64_t); |
| |
| syscall process_create |
| (job: zx_handle_t, name: char[name_size] IN, name_size: size_t, options: uint32_t) |
| returns (zx_status_t, proc_handle: zx_handle_t handle_acquire, |
| vmar_handle: zx_handle_t handle_acquire); |
| |
| syscall process_start |
| (handle: zx_handle_t, thread: zx_handle_t, entry: zx_vaddr_t, |
| stack: zx_vaddr_t, arg1: zx_handle_t handle_release_always, arg2: uintptr_t) |
| returns (zx_status_t); |
| |
| syscall process_read_memory |
| (proc: zx_handle_t, vaddr: zx_vaddr_t, buffer: any[buffer_size] OUT, buffer_size: size_t) |
| returns (zx_status_t, actual: size_t); |
| |
| syscall process_write_memory |
| (proc: zx_handle_t, vaddr: zx_vaddr_t, buffer: any[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t, actual: size_t); |
| |
| # Jobs |
| |
| syscall job_create |
| (parent_job: zx_handle_t, options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall job_set_policy |
| (job: zx_handle_t, options: uint32_t, topic: uint32_t, policy: any[count] IN, count: uint32_t) |
| returns (zx_status_t); |
| |
| # Tasks (shared between threads, processes, and jobs) |
| |
| syscall task_bind_exception_port |
| (handle: zx_handle_t, port: zx_handle_t, key: uint64_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall task_suspend |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall task_resume |
| (handle: zx_handle_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall task_suspend_token |
| (handle: zx_handle_t) |
| returns (zx_status_t, token: zx_handle_t handle_acquire); |
| |
| syscall task_resume_from_exception |
| (handle: zx_handle_t, port: zx_handle_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall task_kill |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| # Synchronization |
| |
| syscall event_create |
| (options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall eventpair_create |
| (options: uint32_t) |
| returns (zx_status_t, |
| out0: zx_handle_t handle_acquire, out1: zx_handle_t handle_acquire); |
| |
| syscall futex_wait blocking |
| (value_ptr: zx_futex_t[1] IN, current_value: int32_t, deadline: zx_time_t) |
| returns (zx_status_t); |
| |
| syscall futex_wake |
| (value_ptr: zx_futex_t[1] IN, count: uint32_t) |
| returns (zx_status_t); |
| |
| syscall futex_requeue |
| (wake_ptr: zx_futex_t[1] IN, wake_count: uint32_t, current_value: int32_t, |
| requeue_ptr: zx_futex_t[1] IN, requeue_count: uint32_t) |
| returns (zx_status_t); |
| |
| # Ports |
| |
| syscall port_create |
| (options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall port_queue |
| (handle: zx_handle_t, packet: zx_port_packet_t[1] IN) |
| returns (zx_status_t); |
| |
| syscall port_wait blocking |
| (handle: zx_handle_t, deadline: zx_time_t, packet: zx_port_packet_t[1] OUT) |
| returns (zx_status_t); |
| |
| syscall port_cancel |
| (handle: zx_handle_t, source: zx_handle_t, key: uint64_t) |
| returns (zx_status_t); |
| |
| # Timers |
| |
| syscall timer_create |
| (options: uint32_t, clock_id: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall timer_set |
| (handle: zx_handle_t, deadline: zx_time_t, slack: zx_duration_t) |
| returns (zx_status_t); |
| |
| syscall timer_cancel |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| # Memory management |
| |
| syscall vmo_create |
| (size: uint64_t, options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall vmo_read |
| (handle: zx_handle_t, buffer: any[buffer_size] OUT, offset: uint64_t, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall vmo_write |
| (handle: zx_handle_t, buffer: any[buffer_size] IN, offset: uint64_t, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall vmo_get_size |
| (handle: zx_handle_t) |
| returns (zx_status_t, size: uint64_t); |
| |
| syscall vmo_set_size |
| (handle: zx_handle_t, size: uint64_t) |
| returns (zx_status_t); |
| |
| syscall vmo_op_range |
| (handle: zx_handle_t, op: uint32_t, offset: uint64_t, size: uint64_t, |
| buffer: any[buffer_size] INOUT, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall vmo_clone |
| (handle: zx_handle_t, options: uint32_t, offset: uint64_t, size: uint64_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall vmo_set_cache_policy |
| (handle: zx_handle_t, cache_policy: uint32_t) |
| returns (zx_status_t); |
| |
| # Address space management |
| |
| syscall vmar_allocate |
| (parent_vmar: zx_handle_t, offset: uint64_t, size: uint64_t, map_flags: uint32_t) |
| returns (zx_status_t, |
| child_vmar: zx_handle_t handle_acquire, child_addr: zx_vaddr_t); |
| |
| syscall vmar_destroy |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall vmar_map |
| (handle: zx_handle_t, vmar_offset: uint64_t, |
| vmo: zx_handle_t, vmo_offset: uint64_t, |
| len: uint64_t, map_flags: uint32_t) |
| returns (zx_status_t, mapped_addr: zx_vaddr_t); |
| |
| syscall vmar_unmap |
| (handle: zx_handle_t, addr: zx_vaddr_t, len: uint64_t) |
| returns (zx_status_t); |
| |
| syscall vmar_protect |
| (handle: zx_handle_t, addr: zx_vaddr_t, len: uint64_t, prot_flags: uint32_t) |
| returns (zx_status_t); |
| |
| # Random Number generator |
| |
| syscall cprng_draw |
| (buffer: any[data_size] OUT, data_size: size_t) |
| returns (zx_status_t, actual: size_t); |
| |
| syscall cprng_add_entropy |
| (buffer: any[len] IN, len: size_t) |
| returns (zx_status_t); |
| |
| # IPC: Fifos |
| |
| syscall fifo_create |
| (elem_count: size_t, elem_size: size_t, options: uint32_t) |
| returns (zx_status_t, |
| out0: zx_handle_t handle_acquire, out1: zx_handle_t handle_acquire); |
| |
| syscall fifo_read |
| (handle: zx_handle_t, elem_size: size_t, data: any[count * elem_size] OUT, count: size_t) |
| returns (zx_status_t, actual_count: size_t optional); |
| |
| syscall fifo_write |
| (handle: zx_handle_t, elem_size: size_t, data: any[count * elem_size] IN, count: size_t) |
| returns (zx_status_t, actual_count: size_t optional); |
| |
| # Profiles |
| |
| syscall profile_create |
| (resource: zx_handle_t, profile: zx_profile_info_t[1] IN) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| # Multi-function |
| |
| syscall vmar_unmap_handle_close_thread_exit vdsocall |
| (vmar_handle: zx_handle_t, addr: zx_vaddr_t, size: size_t, handle: zx_handle_t handle_release) |
| returns (zx_status_t); |
| |
| syscall futex_wake_handle_close_thread_exit vdsocall noreturn |
| (value_ptr: zx_futex_t[1] IN, count: uint32_t, new_value: int32_t, |
| handle: zx_handle_t handle_release); |
| |
| # Logging |
| |
| syscall log_create |
| (options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall log_write |
| (handle: zx_handle_t, len: uint32_t, buffer: any[len] IN, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall log_read |
| (handle: zx_handle_t, len: uint32_t, buffer: any[len] OUT, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall debuglog_create |
| (resource: zx_handle_t, options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall debuglog_write |
| (handle: zx_handle_t, options: uint32_t, buffer: any[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall debuglog_read |
| (handle: zx_handle_t, options: uint32_t, buffer: any[buffer_size] OUT, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| # Tracing |
| |
| syscall ktrace_read |
| (handle: zx_handle_t, data: any[data_size] OUT, offset: uint32_t, data_size: size_t) |
| returns (zx_status_t, actual: size_t); |
| |
| syscall ktrace_control |
| (handle: zx_handle_t, action: uint32_t, options: uint32_t, ptr: any[action] INOUT) |
| returns (zx_status_t); |
| |
| syscall ktrace_write |
| (handle: zx_handle_t, id: uint32_t, arg0: uint32_t, arg1: uint32_t) |
| returns (zx_status_t); |
| |
| syscall mtrace_control |
| (handle: zx_handle_t, |
| kind: uint32_t, action: uint32_t, options: uint32_t, |
| ptr: any[ptr_size] INOUT, ptr_size: size_t) |
| returns (zx_status_t); |
| |
| # Legacy LK debug syscalls |
| |
| syscall debug_read |
| (handle: zx_handle_t, buffer: char[buffer_size] OUT, buffer_size: size_t[1] INOUT) |
| returns (zx_status_t); |
| |
| syscall debug_write |
| (buffer: char[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall debug_send_command |
| (resource: zx_handle_t, buffer: char[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| # DDK Syscalls: Interrupts |
| |
| syscall interrupt_create |
| (src_obj: zx_handle_t, src_num: uint32_t, options: uint32_t) |
| returns (zx_status_t, out: zx_handle_t); |
| |
| syscall interrupt_bind |
| (handle: zx_handle_t, port: zx_handle_t, key: uint64_t, options: uint32_t) |
| returns (zx_status_t); |
| |
| syscall interrupt_wait blocking |
| (handle: zx_handle_t) |
| returns (zx_status_t, out_timestamp: zx_time_t optional); |
| |
| syscall interrupt_destroy |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall interrupt_ack |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall interrupt_trigger |
| (handle: zx_handle_t, options: uint32_t, timestamp: zx_time_t) |
| returns (zx_status_t); |
| |
| # DDK Syscalls: MMIO and Ports |
| |
| syscall mmap_device_io |
| (handle: zx_handle_t, io_addr: uint32_t, len: uint32_t) |
| returns (zx_status_t); |
| |
| syscall vmo_create_contiguous |
| (bti: zx_handle_t, size: size_t, alignment_log2: uint32_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall vmo_create_physical |
| (resource: zx_handle_t, paddr: zx_paddr_t, size: size_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| # DDK Syscalls: Device Memory Access |
| |
| syscall iommu_create |
| (resource: zx_handle_t, type: uint32_t, desc: any[desc_size] IN, desc_size: size_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall bti_create |
| (iommu: zx_handle_t, options: uint32_t, bti_id: uint64_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall bti_pin |
| (handle: zx_handle_t, options: uint32_t, vmo: zx_handle_t, offset: uint64_t, size: uint64_t, |
| addrs: zx_paddr_t[addrs_count] OUT, addrs_count: size_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall bti_release_quarantine |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall pmt_unpin |
| (handle: zx_handle_t handle_release_always) |
| returns (zx_status_t); |
| |
| # DDK Syscalls: Misc Info |
| |
| syscall bootloader_fb_get_info |
| () |
| returns (zx_status_t, format: uint32_t, width: uint32_t, height: uint32_t, stride: uint32_t); |
| |
| syscall set_framebuffer |
| (handle: zx_handle_t, vmo: zx_handle_t, len: uint32_t, format: uint32_t, |
| width: uint32_t, height: uint32_t, stride: uint32_t) |
| returns (zx_status_t); |
| |
| # DDK Syscalls: PCI |
| |
| syscall pci_get_nth_device |
| (handle: zx_handle_t, index: uint32_t) |
| returns (zx_status_t, out_info: zx_pcie_device_info_t, out_handle: zx_handle_t handle_acquire); |
| |
| syscall pci_enable_bus_master |
| (handle: zx_handle_t, enable: bool) |
| returns (zx_status_t); |
| |
| syscall pci_reset_device |
| (handle: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall pci_config_read |
| (handle: zx_handle_t, offset: uint16_t, width: size_t, out_val: uint32_t[1] OUT) |
| returns (zx_status_t); |
| |
| syscall pci_config_write |
| (handle: zx_handle_t, offset: uint16_t, width: size_t, val: uint32_t) |
| returns (zx_status_t); |
| |
| syscall pci_cfg_pio_rw |
| (handle: zx_handle_t, bus: uint8_t, dev: uint8_t, func: uint8_t, offset: uint8_t, |
| val: uint32_t[1] INOUT, width: size_t, write: bool) |
| returns (zx_status_t); |
| |
| syscall pci_get_bar |
| (handle: zx_handle_t, bar_num: uint32_t, out_bar: zx_pci_bar_t[1] OUT) |
| returns (zx_status_t, out_handle: zx_handle_t handle_acquire); |
| |
| syscall pci_map_interrupt |
| (handle: zx_handle_t, which_irq: int32_t) |
| returns (zx_status_t, out_handle: zx_handle_t handle_acquire); |
| |
| syscall pci_query_irq_mode |
| (handle: zx_handle_t, mode: uint32_t) |
| returns (zx_status_t, out_max_irqs: uint32_t); |
| |
| syscall pci_set_irq_mode |
| (handle: zx_handle_t, mode: uint32_t, requested_irq_count: uint32_t) |
| returns (zx_status_t); |
| |
| syscall pci_init |
| (handle: zx_handle_t, init_buf: zx_pci_init_arg_t[len] IN, len: uint32_t) |
| returns (zx_status_t); |
| |
| syscall pci_add_subtract_io_range |
| (handle: zx_handle_t, mmio: bool, base: uint64_t, len: uint64_t, add: bool) |
| returns (zx_status_t); |
| |
| # DDK Syscalls: ACPI Glue |
| |
| syscall pc_firmware_tables |
| (handle: zx_handle_t) |
| returns (zx_status_t, acpi_rsdp: zx_paddr_t, smbios: zx_paddr_t); |
| |
| # DDK Syscalls: SMC Calls |
| |
| syscall smc_call |
| (resource: zx_handle_t, arg0: uint64_t, arg1: uint64_t, |
| arg2: uint64_t, arg3: uint64_t, out_smc_status: uint64_t[1] OUT) |
| returns (zx_status_t); |
| |
| # Resources |
| |
| syscall resource_create |
| (parent_resource: zx_handle_t, kind: uint32_t, low: uint64_t, high: uint64_t) |
| returns (zx_status_t, resource_out: zx_handle_t handle_acquire); |
| |
| # Hypervisor |
| |
| syscall guest_create |
| (resource: zx_handle_t, options: uint32_t, physmem_vmo: zx_handle_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall guest_set_trap |
| (handle: zx_handle_t, kind: uint32_t, addr: zx_vaddr_t, size: size_t, port: zx_handle_t, |
| key: uint64_t) |
| returns (zx_status_t); |
| |
| syscall vcpu_create |
| (guest: zx_handle_t, options: uint32_t, entry: zx_vaddr_t) |
| returns (zx_status_t, out: zx_handle_t handle_acquire); |
| |
| syscall vcpu_resume |
| (handle: zx_handle_t) |
| returns (zx_status_t, packet: zx_port_packet_t OUT); |
| |
| syscall vcpu_interrupt |
| (handle: zx_handle_t, vector: uint32_t) |
| returns (zx_status_t); |
| |
| syscall vcpu_read_state |
| (handle: zx_handle_t, kind: uint32_t, buffer: any[buffer_size] OUT, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| syscall vcpu_write_state |
| (handle: zx_handle_t, kind: uint32_t, buffer: any[buffer_size] IN, buffer_size: size_t) |
| returns (zx_status_t); |
| |
| # System Control |
| |
| syscall system_mexec |
| (resource: zx_handle_t, kernel: zx_handle_t, bootimage: zx_handle_t) |
| returns (zx_status_t); |
| |
| syscall system_powerctl |
| (resource: zx_handle_t, cmd: uint32_t, arg: zx_system_powerctl_arg_t[1] IN) |
| returns (zx_status_t); |
| |
| # Test syscalls (keep at the end) |
| |
| syscall syscall_test_0() returns (zx_status_t); |
| syscall syscall_test_1 test_category1 (a:int) returns (zx_status_t); |
| syscall syscall_test_2 test_category1 (a:int, b:int) returns (zx_status_t); |
| syscall syscall_test_3 test_category2 (a:int, b:int, c:int) returns (zx_status_t); |
| syscall syscall_test_4(a:int, b:int, c:int, d:int) returns (zx_status_t); |
| syscall syscall_test_5(a:int, b:int, c:int, d:int, e:int) returns (zx_status_t); |
| syscall syscall_test_6(a:int, b:int, c:int, d:int, e:int, f:int) returns (zx_status_t); |
| syscall syscall_test_7(a:int, b:int, c:int, d:int, e:int, f:int, g:int) returns (zx_status_t); |
| syscall syscall_test_8(a:int, b:int, c:int, d:int, e:int, f:int, g:int, h:int) returns (zx_status_t); |
| syscall syscall_test_wrapper(a:int, b:int, c:int) returns (zx_status_t); |