What is a protocol?
A protocol is a strict interface definition.
The ethernet driver published an interface that conforms to
This means that it must provide a set of functions defined in a data structure
(in this case,
These functions are common to all devices implementing the protocol — for example, all ethernet devices must provide a function that queries the MAC address of the interface.
Other protocols will of course have different requirements for the functions they
For example a block device will publish an interface that conforms to the
"block implementation protocol" (
provide functions defined by
This protocol includes a function that returns the size of the device in blocks,
In many cases a Protocol is used to allow drivers to be simpler by taking advantage of a common implementation of an Interface. For example, the "block" driver implements the common block interface, and binds to devices implementing the Block Core Protocol, and the "ethernet" driver does the same thing for the Ethernet Interface and Ethermac Protocol. Some protocols, such as the two cited here, make use of shared memory, and non-rpc signaling for more efficient, lower latency, and higher throughput than could be achieved otherwise.
Classes represent a promise that a device implements an Interface or Protocol.
Devices exist in the Device Filesystem under a topological path, like
/sys/pci/00:02:00/e1000. If they are a specific class, they also appear
as an alias under
e1000 driver implements
the Ethermac interface, so it also shows up at
/dev/class/ethermac/000. The names
within class directories are unique but not meaningful, and are assigned on demand.
- the PCI root protocol (
- the PCI device protocol (
- the ethernet implementation protocol (
The names in brackets are the C language constants corresponding to the protocols, for reference.
Platform dependent vs platform independent
Above, we mentioned that
ZX_PROTOCOL_ETHERNET_IMPL was "close to" the functions used
by the client, but one step removed.
That's because there's one more protocol,
ZX_PROTOCOL_ETHERNET, that sits between
the client and the driver.
This additional protocol is in place to handle functionality common to all ethernet
drivers (in order to avoid code duplication).
Such functionality includes buffer management, status reporting, and administrative
This is effectively a "platform dependent" vs "platform independent" decoupling; common code exists in the platform independent part (once), and driver-specific code is implemented in the platform dependent part.
This architecture is repeated in multiple places.
With block devices, for example, the hardware driver binds to the bus (e.g., PCI)
and provides a
The platform independent driver binds to
ZX_PROTOCOL_BLOCK_IMPL, and publishes the
You'll also see this with the display controllers, I2C bus, and serial drivers.
Process / protocol mapping
In order to keep the discussions above simple, we didn't talk about process separation as it relates to the drivers. To understand the issues, let's see how other operating systems deal with them, and compare that to the Fuchsia approach.
In a monolithic kernel, such as Linux, many drivers are implemented within the kernel. This means that they share the same address space, and effectively live in the same "process."
The major problem with this approach is fault isolation / exploitation. A bad driver can take out the entire kernel, because it lives in the same address space and thus has privileged access to all kernel memory and resources. A compromised driver can present a security threat for the same reason.
The other extreme, that is, putting each and every driver service into its own process, is used by some microkernel operating systems. Its major drawback is that if one driver relies on the services of another driver, the kernel must effect at least a context switch operation (if not a data transfer as well) between the two driver processes. While microkernel operating systems are usually designed to be fast at these kinds of operations, performing them at high frequency is undesirable.
The approach taken by Fuchsia is based on the concept of a driver host. A driver host is a process that contains a protocol stack — that is, one or more protocols that work together. The driver host loads drivers from ELF shared libraries (called Dynamic Shared Objects, or DSOs). In the simple drivers section, we'll see the meta information that's contained in the DSO to facilitate the discovery process.
The protocol stack effectively allows the creation of a complete "driver" for a device, consisting of platform dependent and platform independent components, in a self-contained process container.
For the advanced reader, take a look at the
dm dump command available from
the Fuchsia command line.
It displays a tree of devices, and shows you the process ID, DSO name, and
other useful information.
Here's a highly-edited version showing just the PCI ethernet driver parts:
1. [root] 2. [sys] 3. <sys> pid=1416 /boot/driver/bus-acpi.so 4. [acpi] pid=1416 /boot/driver/bus-acpi.so 5. [pci] pid=1416 /boot/driver/bus-acpi.so ... 6. [00:02:00] pid=1416 /boot/driver/bus-pci.so 7. <00:02:00> pid=2052 /boot/driver/bus-pci.proxy.so 8. [e1000] pid=2052 /boot/driver/e1000.so 9. [ethernet] pid=2052 /boot/driver/ethernet.so
From the above, you can see that process ID
1416 (lines 3 through 6)
is the Advanced Configuration and Power Interface (ACPI) driver, implemented
by the DSO
During primary enumeration, the ACPI DSO detected a PCI bus.
This caused the publication of a parent with
ZX_PROTOCOL_PCI_ROOT (line 5,
causing the appearance of the
which then caused the driver host to load the
bus-pci.so DSO and bind to it.
That DSO is the "base PCI driver" to which we've been referring throughout the
During its binding, the base PCI driver enumerated the PCI bus, and found an ethernet
card (line 6 detects bus 0, device 2, function 0, shown as
(Of course, many other devices were found as well, but we've removed them from
the above listing for simplicity).
The detection of this device then caused the base PCI driver to publish a new parent
ZX_PROTOCOL_PCI and the device's VID and DID.
Additionally, a new driver host (process ID
2052) was created and loaded with the
bus-pci.proxy.so DSO (line 7).
This proxy serves as the interface from the new driver host (pid
2052) to the base PCI
This is where the decision was made to "sever" the device driver into its own process — the new driver host and the base PCI driver now live in two different processes.
The new driver host
2052 then finds a matching child (the
DSO on line 8; it's considered a match because it has
ZX_PROTOCOL_PCI and the correct
VID and DID).
That DSO publishes a
ZX_PROTOCOL_ETHERNET_IMPL, which binds to a matching
ethernet.so DSO on line 9; it's considered a match because it has a
What's not shown by this chain is that the final DSO (
ZX_PROTOCOL_ETHERNET — that's the piece that clients can use, so of
course there's no further "device" binding involved.