fuchsia

Overview

The purpose of this document is to provide short definitions for a collection of technical terms used in Fuchsia.

本文档的目的是为Fuchsia中使用的一系列技术术语提供简短的定义。

Adding new definitions

• A definition should provide a high-level description of a term and in most cases should not be longer than two or three sentences.
• When another non-trivial technical term needs to be employed as part of the description, consider adding a definition for that term and linking to it from the original definition.
• A definition should be complemented by a list of links to more detailed documentation and related topics.

•定义应提供术语的高级描述，并且在大多数情况下，不应超过两个或三个句子。

•当需要在描述中使用另一个非平凡的技术术语时，请考虑为该术语添加一个定义，并将其与原始定义链接。

•定义应辅以更详细的文档和相关主题的链接列表。

Terms

Agent

An agent is a role a component can play to execute in the background in the context of a session. An agent's life cycle is not tied to any story, is a singleton per session, and provides services to other components. An agent can be invoked by other components or by the system in response to triggers like push notifications. An agent can provide services to components, send and receive messages, and make proposals to give suggestions to the user.

代理是组件可以在会话的上下文中扮演的角色。 代理的生命周期与任何故事都没有关系，每个会话都是一个单例，并为其他组件提供服务。 代理可以由其他组件或由系统响应诸如推送通知之类的触发器来调用。 代理可以为组件提供服务，发送和接收消息以及提出建议以向用户提供建议。

AppMgr

The Application Manager (AppMgr) is responsible for launching components and managing the namespaces in which those components run. It is the first process started in the fuchsia job by the DevMgr.

应用程序管理器（AppMgr）负责启动组件和管理这些组件在其中运行的名称空间。 这是DevMgr在fuchsia 工作中启动的第一个进程

Banjo

Banjo is a language for defining protocols that are used to communicate between drivers. It is different from FIDL in that it specifies an ABI for drivers to use to call into each other, rather than an IPC protocol.

Banjo是一种用于定义用于在驱动程序之间进行通信的协议的语言。 它与FIDL的不同之处在于，它为驱动程序指定了一个ABI供驱动程序相互调用，而不是IPC协议。

Base shell

The platform-guaranteed set of software functionality which provides a basic user-facing interface for boot, first-use, authentication, escape from and selection of session shells, and device recovery.

该平台保证的软件功能集提供了一个基本的面向用户的界面，用于引导，首次使用，身份验证，从会话外壳逃脱和选择会话以及设备恢复。

bootfs

The bootfs RAM disk contains the files needed early in the boot process when no other filesystems are available. It is part of the ZBI, and is decompressed and served by bootsvc. After the early boot process is complete, the bootfs is mounted at /boot.

• Documentation

bootsvc

bootsvc is the second process started in Fuchsia. It provides a filesystem service for the bootfs and a loader service that loads programs from the same bootfs. After starting these services, it loads the third program, which defaults todevmgr.

bootsvc是在Fuchsia中启动的第二个进程。 它为bootfs提供了文件系统服务，并提供了从同一bootfs加载程序的加载程序服务。 启动这些服务后，它将加载第三个程序，默认为devmgr。

• Documentation

Bus Driver

A driver for a device that has multiple children. For example, hardware interfaces like PCI specify a topology in which a single controller is used to interface with multiple devices connected to it. In that situation, the driver for the controller would be a bus driver.

具有多个子代的设备的驱动程序。 例如，诸如PCI之类的硬件接口指定了一种拓扑，其中单个控制器用于与与其连接的多个设备进行接口。 在这种情况下，控制器的驱动程序将是总线驱动程序。

Cache directory

Similar to a data directory, except that the contents of a cache directory may be cleared by the system at any time, such as when the device is under storage pressure. Canonically mapped to /cache in the component instance’s namespace.

与数据目录相似，不同之处在于缓存目录的内容可以在任何时候（例如，设备处于存储压力下）由系统清除。 规范地映射到组件实例名称空间中的/ cache。

• Testing isolated cache storage.

Capability

A capability is a value which combines an object reference and a set of rights. When a program has a capability it is conferred the privilege to perform certain actions using that capability. A handle is a common example for a capability.

能力是将对象引用和一组权限组合在一起的值。 程序具有某种功能时，将被授予使用该功能执行某些操作的特权。 句柄是功能的常见示例。

Capability routing

A way for one component to give capabilities to another instance over the component instance tree. Component manifests define how routing takes place, with syntax for service capabilities, directory capabilities, and storage capabilities.

Capability routing is a components v2 concept.

一种组件通过组件实例树为另一实例提供功能的方法。 组件清单定义了路由的发生方式，以及服务功能，目录功能和存储功能的语法。

能力路由是v2组件的概念。

expose

A component instance may use the expose manifest keyword to indicate that it is making a capability available to its parent to route. Parents may offer a capability exposed by any of their children to their other children or to their parent, but they cannot use it themselves in order to avoid dependency cycles.

offer

A component instance may use the offer manifest keyword to route a capability that was exposed to it to one of its children (other than the child that exposed it).

use

A component instance may use the use manifest keyword to consume a capability that was offered to it by its parent.

Channel

A channel is an IPC primitive provided by Zircon. It is a bidirectional, datagram-like transport that can transfer small messages including Handles. FIDL protocols typically use channels as their underlying transport.

通道是Zircon提供的IPC原语。 它是一种双向的，类似于数据报的传输方式，可以传输包括句柄在内的小消息。 FIDL协议通常使用通道作为其基础传输。

• Channel Overview
• Update Channel Usage Policy

Component

A component is a unit of executable software on Fuchsia. Components support capability routing, software composition, isolation boundaries, continuity between executions, and introspection.

Component collection

A node in the component instance tree whose children are dynamically instantiated rather than statically defined in acomponent manifest.

Component collection is a components v2 concept.

Component declaration

A component declaration is a FIDL table (fuchsia.sys2.ComponentDecl) that includes information about a component’s runtime configuration, capabilities it exposes, offers, and uses, and facets.

Component declaration is a components v2 concept.

Component Framework

An application framework for declaring and managing components, consisting of build tools, APIs, conventions, and system services.

• Components v1, Components v2

Component instance

One of possibly many instances of a particular component at runtime. A component instance has its own environmentand lifecycle independent of other instances.

Component instance tree

A tree structure that represents the runtime state of parent-child relationships between component instances. If instance A launches instance B then in the tree A will be the parent of B. The component instance tree is used in static capability routing such that parents can offer capabilities to their children to use, and children can expose capabilities for their parents to expose to their parents or offer to other children.

Component instance tree is a components v2 concept.

Component Manager

A system service which lets component instances manage their children and routes capabilities between them, thus implementing the component instance tree. Component Manager is the system service that implements thecomponents v2 runtime.

Component Manifest

In Components v1, a component manifest is a JSON file with a .cmx extension that contains information about acomponent’s runtime configuration, services and directories it receives in its namespace, and facets.

In Components v2, a component manifest is a file with a .cm extension, that encodes a component declaration.

• Component manifests v2

Component Manifest Facet

Additional metadata that is carried in a component manifest. This is an extension point to the component framework.

Components v1

A shorthand for the Component Architecture as first implemented on Fuchsia. Includes a runtime as implemented byappmgr and sysmgr, protocols and types as defined in fuchsia.sys, build-time tools such as cmc, and SDK libraries such as libsys and libsvc.

• Components v2

Components v2

A shorthand for the Component Architecture in its modern implementation. Includes a runtime as implemented bycomponent_manager, protocols and types as defined in fuchsia.sys2, and build-time tools such as cmc.

• Components v1

Concurrent Device Driver

A concurrent device driver is a hardware driver that supports multiple concurrent operations. This may be, for example, through a hardware command queue or multiple device channels. From the perspective of the core driver, the device has multiple pending operations, each of which completes or fails independently. If the driven device can internally parallelize an operation, but can only have one operation outstanding at a time, it may be better implemented with asequential device driver.

Core Driver

A core driver is a driver that implements the application-facing RPC interface for a class of drivers (e.g. block drivers, ethernet drivers). It is hardware-agnostic. It communicates with a hardware driver through banjo to service its requests.

Data directory

A private directory within which a component instance may store data local to the device, canonically mapped to /data in the component instance’s namespace.

DevHost

A Device Host (DevHost) is a process containing one or more device drivers. They are created by the Device Manager, as needed, to provide isolation between drivers for stability and security.

DevMgr

The Device Manager (DevMgr) is responsible for enumerating, loading, and managing the life cycle of device drivers, as well as low level system tasks (providing filesystem servers for the boot filesystem, launching AppMgr, and so on).

DDK

The Driver Development Kit is the documentation, APIs, and ABIs necessary to build Zircon Device Drivers. Device drivers are implemented as ELF shared libraries loaded by Zircon's Device Manager.

• DDK Overview
• DDK includes

Directory capability

A capability that permits access to a filesystem directory by adding it to the namespace of the component instance thatuses it. If multiple component instances are offered the same directory capability then they will have access to the same underlying filesystem directory.

Directory capability is a components v2 concept.

• Capability routing

Driver

A driver is a dynamic shared library which DevMgr can load into a DevHost and that enables, and controls one or more devices.

• Reference
• Driver Sources

Environment

A container for a set of components, which provides a way to manage their lifecycle and provision services for them. All components in an environment receive access to (a subset of) the environment's services.

Escher

Graphics library for compositing user interface content. Its design is inspired by modern real-time and physically based rendering techniques though we anticipate most of the content it renders to have non-realistic or stylized qualities suitable for user interfaces.

FAR

The Fuchsia Archive Format is a container for files to be used by Zircon and Fuchsia.

• FAR Spec

FBL

FBL is the Fuchsia Base Library, which is shared between kernel and userspace.

• Zircon C++

fdio

fdio is the Zircon IO Library. It provides the implementation of posix-style open(), close(), read(), write(), select(), poll(), etc, against the RemoteIO RPC protocol. These APIs are return- not-supported stubs in libc, and linking against libfdio overrides these stubs with functional implementations.

 

fdio是Zircon IO库。 它根据RemoteIO RPC协议提供posix样式的open（），close（），read（），write（），select（），poll（）等实现。 这些API是libc中不支持返回的存根，并且针对libfdio的链接会通过功能实现覆盖这些存根。

 

• Source

FIDL

The Fuchsia Interface Definition Language (FIDL) is a language for defining protocols that are typically used overchannels. FIDL is programming language agnostic and has bindings for many popular languages, including C, C++, Dart, Go, and Rust. This approach lets system components written in a variety of languages interact seamlessly.

 

fuchsia接口定义语言（FIDL）是一种用于定义通常在通道上使用的协议的语言。 FIDL与编程语言无关，并且具有对许多流行语言（包括C，C ++，Dart，Go和Rust）的绑定。 这种方法可以使用多种语言编写的系统组件无缝交互。

• FIDL

Flutter

Flutter is a functional-reactive user interface framework optimized for Fuchsia and is used by many system components. Flutter also runs on a variety of other platforms, including Android and iOS. Fuchsia itself does not require you to use any particular language or user interface framework.

Flutter是针对fuchsia而优化的功能响应型用户界面框架，许多系统组件都在使用它。 Flutter还可以在多种其他平台上运行，包括Android和iOS。 fuchsia本身不需要您使用任何特定的语言或用户界面框架。

Fuchsia API Surface

The Fuchsia API Surface is the combination of the Fuchsia System Interface and the client libraries included in theFuchsia SDK.

Fuchsia Package

A Fuchsia Package is a unit of software distribution. It is a collection of files, such as manifests, metadata, zero or more executables (e.g. Components), and assets. Individual Fuchsia Packages can be identified using fuchsia-pkg URLs.

fuchsia-pkg URL

The fuchsia-pkg URL scheme is a means for referring to a repository, a package, or a package resource. The syntax isfuchsia-pkg://<repo-hostname>[/<pkg-name>][#<path>]]. E.g., for the component echo_client_dart.cmxpublished under the package echo_dart's meta directory, from the fuchsia.com repository, its URL is fuchsia-pkg://fuchsia.com/echo_dart#meta/echo_client_dart.cmx.

Fuchsia SDK

The Fuchsia SDK is a collection of libraries and tools that the Fuchsia project provides to Fuchsia developers. Among other things, the Fuchsia SDK contains a definition of the Fuchsia System Interface as well as a number of client libraries.

Fuchsia System Interface

The Fuchsia System Interface is the binary interface that the Fuchsia operating system presents to software it runs. For example, the entry points into the vDSO as well as all the FIDL protocols are part of the Fuchsia System Interface.

Fuchsia Volume Manager

Fuchsia Volume Manager (FVM) is a partition manager providing dynamically allocated groups of blocks known as slices into a virtual block address space. The FVM partitions provide a block interface enabling filesystems to interact with it in a manner largely consistent with a regular block device.

• Filesystems

GN

GN is a meta-build system which generates build files so that Fuchsia can be built with Ninja. GN is fast and comes with solid tools to manage and explore dependencies. GN files, named BUILD.gn, are located all over the repository.

• Language and operation
• Reference
• Fuchsia build overview

Handle

A Handle is how a userspace process refers to a kernel object. They can be passed to other processes over Channels.

句柄是用户空间进程如何引用内核对象的方法。 它们可以通过通道传递给其他进程。

• Reference

Hardware Driver

A hardware driver is a driver that controls a device. It receives requests from its core driver and translates them into hardware-specific operations. Hardware drivers strive to be as thin as possible. They do not support RPC interfaces, ideally have no local worker threads (though that is not a strict requirement), and some will have interrupt handling threads. They may be further classified into sequential device drivers and concurrent device drivers.

 

 

硬件驱动程序是控制设备的驱动程序。 它从其核心驱动程序接收请求，并将其转换为特定于硬件的操作。 硬件驱动程序力求尽可能地薄。 它们不支持RPC接口，理想情况下没有本地工作线程（尽管这不是严格的要求），有些将具有中断处理线程。 它们可以进一步分类为顺序设备驱动程序和并发设备驱动程序。

Hub

The hub is a portal for tools to access detailed structural information about component instances at runtime, such as their names, job and process ids, and exposed capabilities.

• Hub

Jiri

Jiri is a tool for multi-repo development. It is used to checkout the Fuchsia codebase. It supports various subcommands which makes it easy for developers to manage their local checkouts.

Jiri是用于多仓库开发的工具。 它用于签出Fuchsia代码库。 它支持各种子命令，这使开发人员可以轻松地管理其本地结帐。

• Reference
• Sub commands
• Behaviour
• Tips and tricks

Job

A Job is a kernel object that groups a set of related [processes][#process], their child processes, and their jobs (if any). Every process in the system belongs to a job and all jobs form a single rooted tree.

• Job Overview

Kernel Object

A kernel object is a kernel data structure which is used to regulate access to system resources such as memory, i/o, processor time and access to other processes. Userspace can only reference kernel objects via Handles.

内核对象是内核数据结构，用于调节对系统资源（如内存，I / O，处理器时间）和对其他进程的访问。 用户空间只能通过Handles引用内核对象。

• Reference

KOID

A Kernel Object Identifier.

• Kernel Object

Ledger

Ledger is a distributed storage system for Fuchsia. Applications use Ledger either directly or through state synchronization primitives exposed by the Modular framework that are based on Ledger under-the-hood.

LK

Little Kernel (LK) is the embedded kernel that formed the core of the Zircon Kernel. LK is more microcontroller-centric and lacks support for MMUs, userspace, system calls -- features that Zircon added.

• LK on Github

Module

A module is a role a component can play to participate in a story. Every component can be be used as a module, but typically a module is asked to show UI. Additionally, a module can have a module metadata file which describes the Module's data compatibility and semantic role.

• Module metadata format

Musl

Fuchsia's standard C library (libc) is based on Musl Libc.

• Source
• Musl Homepage

Namespace

A namespace is the composite hierarchy of files, directories, sockets, services, and other named objects which are offered to components by their environment.

• Fuchsia Namespace Spec

命名空间是文件，目录，套接字，服务和其他命名对象的组合层次结构，这些文件，目录，套接字，服务和其他命名对象由其环境提供给组件。

Netstack

An implementation of TCP, UDP, IP, and related networking protocols for Fuchsia.

Ninja

Ninja is the build system executing Fuchsia builds. It is a small build system with a strong emphasis on speed. Unlike other systems, Ninja files are not supposed to be manually written but should be generated by other systems, such asGN in Fuchsia.

Ninja是执行fuchsia构建的构建系统。 这是一个小型构建系统，非常注重速度。 与其他系统不同，Ninja文件不应手动编写，而应由其他系统（例如fuchsia的GN）生成。

• Manual
• Ninja rules in GN
• Fuchsia build overview

Outgoing directory

A file system directory where a component may expose capabilities for others to use.

Package

Package is an overloaded term. Package may refer to a Fuchsia Package or a GN build package.

Paver

A tool in Zircon that installs partition images to internal storage of a device.

• Guide for installing Fuchsia with paver.

Platform Source Tree

The Platform Source Tree is the open source code hosted on fuchsia.googlesource.com, which comprises the source code for Fuchsia. A given Fuchsia system can include additional software from outside the Platform Source Tree by adding the appropriate Fuchsia Package.

Process

A Process is a kernel object that represents an instance of a program as a set of instructions which are executed by one or more threads together with a collection of capabilities. Every process is contained in a job.

• Process Overview

Realm

In components v1, realm is synonymous to environment.

In components v2, a realm is a subtree of component instances in the component instance tree. It acts as a container for component instances and capabilities in the subtree.

Runner

A component that provides a runtime environment for other components, e.g. the ELF runner, the Dart AOT runner, the Chromium web runner.

Every component needs a runner in order to launch. Components express their dependency on a runner in the component's declaration.

When the component framework starts a component, it first determines the capabilities that the component should receive, then asks the component's runner to launch the component. The runner is responsible for creating any necessary processes, loading executable code, initializing language runtimes, handing control to the component's entry points, and terminating the component when requested by the component framework.

• ELF runner

Scenic

The system compositor. Includes views, input, compositor, and GPU services.

Sequential Device Driver

A sequential device driver is a hardware driver that will only service a single request at a time. The core driversynchronizes and serializes all requests.

Service

A service is an implementation of a FIDL interface. Components can offer their creator a set of services, which the creator can either use directly or offer to other components.

Services can also be obtained by interface name from a Namespace, which lets the component that created the namespace pick the implementation of the interface. Long-running services, such as Scenic, are typically obtained through a Namespace, which lets many clients connect to a common implementation.

 

服务是FIDL接口的实现。 组件可以为创建者提供一组服务，创建者可以直接使用这些服务，也可以将其提供给其他组件。

也可以通过接口名称从名称空间获得服务，该服务使创建名称空间的组件可以选择接口的实现。 诸如Scenic之类的长期运行的服务通常是通过命名空间获得的，该命名空间使许多客户端可以连接到通用实现。

Service capability

A capability that permits communicating with a service over a channel using a specified FIDL protocol. The server end of the channel is held by the component instance that provides the capability. The client end of the channel is given to the component instance that uses the capability.

• Capability routing

Service capability is a components v2 concept.

Session

An interactive session with one or more users. Has a session shell, which manages the UI for the session, and zero or more stories. A device might have multiple sessions, for example if users can interact with the device remotely or if the device has multiple terminals.

Session Shell

The replaceable set of software functionality that works in conjunction with devices to create an environment in which people can interact with mods, agents and suggestions.

Storage capability

A storage capability is a capability that allocates per-component isolated storage for a designated purpose within a filesystem directory. Multiple component instances may be given the same storage capability, but underlying directories that are isolated from each other will be allocated for each individual use. This is different from directory capabilities, where a specific filesystem directory is routed to a specific component instance.

Isolation is achieved because Fuchsia does not support dotdot.

There are three types of storage capabilities:

• data: a directory is added to the namespace of the component instance that uses the capability. Acts as a data directory.
• cache: same as data, but acts as a cache directory.
• meta: a directory is allocated to be used by component manager, where it will store metadata to enable features like persistent component collections.

Storage capability is a components v2 concept.

• Capability routing
• Storage capabilities

存储功能是为文件系统目录内的指定目的分配每个组件的隔离存储的功能。 可以为多个组件实例提供相同的存储功能，但是将相互隔离的基础目录分配给每种单独的用途。 这不同于目录功能，在目录功能中，特定的文件系统目录被路由到特定的组件实例。

因为fuchsia不支持点，所以可以实现隔离。

共有三种存储功能：

•数据：将目录添加到使用该功能的组件实例的名称空间。 充当数据目录。

•cache：与数据相同，但充当缓存目录。

•meta：目录已分配给组件管理器使用，它将在其中存储元数据以启用诸如持久性组件集合之类的功能。

存储功能是v2组件的概念。

•能力路由

•存储能力

Story

A user-facing logical container encapsulating human activity, satisfied by one or more related modules. Stories allow users to organize activities in ways they find natural, without developers having to imagine all those ways ahead of time.

封装人类活动的面向用户的逻辑容器，由一个或多个相关模块满足。 故事允许用户以他们认为自然的方式组织活动，而开发人员不必提前想象所有这些方式。

Story Shell

The system responsible for the visual presentation of a story. Includes the presenter component, plus structure and state information read from each story.

负责故事的视觉呈现的系统。 包括演示者组件，以及从每个故事中读取的结构和状态信息。

Thread

A Thread is a kernel object that represents a time-shared CPU execution context. Each thread is contained in a process.

• Thread Overview

userboot

userboot is the first process started by the Zircon kernel. It is loaded from the kernel image in the same way as thevDSO, instead of being loaded from a filesystem. Its primary purpose is to load the second process, bootsvc, from thebootfs.

userboot是Zircon内核启动的第一个进程。 它以与vDSO相同的方式从内核映像加载，而不是从文件系统加载。 其主要目的是从bootfs加载第二个进程bootsvc。

• Documentation

Virtual Dynamic Shared Object

The Virtual Dynamic Shared Object (vDSO) is a Virtual Shared Library -- it is provided by the Zircon kernel and does not appear in the filesystem or a package. It provides the Zircon System Call API/ABI to userspace processes in the form of an ELF library that's "always there." In the Fuchsia SDK and Zircon DDK it exists as libzircon.so for the purpose of having something to pass to the linker representing the vDSO.

 

虚拟动态共享库（vDSO）是虚拟共享库-它由Zircon内核提供，不会出现在文件系统或软件包中。 它以“始终存在”的ELF库的形式向用户空间进程提供Zircon系统调用API / ABI。 在Fuchsia SDK和Zircon DDK中，它以libzircon.so的形式存在，目的是将某些内容传递给表示vDSO的链接器。

Virtual Memory Address Range

A Virtual Memory Address Range (VMAR) is a Zircon kernel object that controls where and how Virtual Memory Objectsmay be mapped into the address space of a process.

虚拟内存地址范围（VMAR）是Zircon内核对象，用于控制虚拟内存对象在何处以及如何映射到进程的地址空间。

• VMAR Overview

Virtual Memory Object

A Virtual Memory Object (VMO) is a Zircon kernel object that represents a collection of pages (or the potential for pages) which may be read, written, mapped into the address space of a process, or shared with another process by passing a Handle over a Channel.

虚拟内存对象（VMO）是Zircon内核对象，它代表页面的集合（或潜在的页面），这些页面可以通过传递一个Handle进行读取，写入，映射到进程的地址空间或与其他进程共享 通过渠道。

• VMO Overview

Zircon Boot Image

A Zircon Boot Image (ZBI) contains everything needed during the boot process before any drivers are working. This includes the kernel image and a RAM disk for the boot filesystem.

• ZBI header file

Zedboot

Zedboot is a recovery image that is used to install and boot a full Fuchsia system. Zedboot is actually an instance of the Zircon kernel with a minimal set of drivers and services running used to bootstrap a complete Fuchsia system on a target device. Upon startup, Zedboot listens on the network for instructions from a bootserver which may instruct Zedboot to install a new OS. Upon completing the installation Zedboot will reboot into the newly installed system.

Zedboot是一个恢复映像，用于安装和引导完整的Fuchsia系统。 Zedboot实际上是Zircon内核的一个实例，运行着最少的驱动程序和服务，用于在目标设备上引导完整的Fuchsia系统。 启动后，Zedboot会在网络上侦听来自引导服务器的指令，这些指令可能会指示Zedboot安装新的操作系统。 完成安装后，Zedboot将重新引导到新安装的系统中。

Zircon

Zircon is the microkernel and lowest level userspace components (driver runtime environment, core drivers, libc, etc) at the core of Fuchsia. In a traditional monolithic kernel, many of the userspace components of Zircon would be part of the kernel itself.

Zircon是fuchsia核心的微内核和最低级别的用户空间组件（驱动程序运行时环境，核心驱动程序，libc等）。 在传统的单片内核中，Zircon的许多用户空间组件将成为内核本身的一部分。

• Zircon Documentation
• Zircon Concepts
• Source

ZX

ZX is an abbreviation of "Zircon" used in Zircon C APIs/ABIs (zx_channel_create(), zx_handle_t,ZX_EVENT_SIGNALED, etc) and libraries (libzx in particular).

ZX是Zircon C API / ABI（zx_channel_create（），zx_handle_t，ZX_EVENT_SIGNALED等）和库（尤其是libzx）中使用的“ Zircon”的缩写。

ZXDB

The native low-level system debugge

本机低级系统调试器