erXos: An Operating System in ErlangAppendix AGlossary
Contents
  1. 1Operating Systems from the Ground Up
  2. 2Microkernels and Capabilities
  3. 3Erlang and OTP
  4. 4History and Goals
  5. 5Design Overview of erXos
  6. 6Correct by Construction
  7. 7One Source for Every Fact
  8. 8The Kernel Interface and Fiasco
  9. 9Processes, Runtimes and Two-Level Scheduling
  10. 10Domains: A Wall Around Some Processes
  11. 11Authority and Security
  12. 12Memory and Budgets
  13. 13Native Programs, Pipes and POSIX-lite
  14. 14Files, Namespaces and Service Trees
  15. 15Devices and Drivers
  16. 16Storage and Updates
  17. 17The Network Stack
  18. 18WiFi
  19. 19Bluetooth
  20. 20The Command Shell and the UNIX Surface
  21. 21The Live Machine
  22. 22Displays, Windows and the Web
  23. 23Apps and Packages
  24. 24Startup, Configuration and Shutdown
  25. 25Checking the System
  26. AGlossary
  27. BReading the Design Documents
  28. CBuilding and Booting erXos
  29. DDependencies and Licenses
  30. ELineage

Appendix AGlossary

Every term a newcomer meets in the book, in one line, with a pointer to the section that explains it. It lists the terms that Chapters 1 to 25 and the appendices define: operating systems, microkernels and capabilities, Erlang and OTP, the history and goals of erXos, the system as a whole, construction, one source for every fact, the kernel interface on Fiasco, processes and scheduling, domains, authority and security, memory and budgets, native programs and pipes, files and namespaces, devices and drivers, storage and updates, the network stack, WiFi, Bluetooth, the command shell, the live machine, displays and windows, apps and packages, startup and shutdown, and checking the system, with the building, dependency and license terms of the appendices. A term that two chapters explain lists both places, and a word with two meanings has one entry for each. The entries are in alphabetical order.

  • 1:1 threading: A threading model in which each user thread is one kernel thread. Chapter 4, section 4.2.1
  • ABI (application binary interface): The binary contract between a program and what it calls: call numbers, registers, status codes and the layout of every shared structure; erXos states its own in one file, abi/erx_abi.txt. Chapter 4, section 4.5.4
  • abstraction: A simpler idea that stands for the hardware and hides its detail, so a program written against it runs whatever disk or network card the machine has. Chapter 1, section 1.1.2
  • access point: The radio a WiFi network offers; it has a hardware address, its BSSID. Chapter 18
  • ACL data packet: A HCI packet that carries a connection’s traffic, tagged with a connection handle. Chapter 19, section 19.2
  • act: In find and act, a line of rc that the session’s own shell runs, as if the person had typed it, offered for a value the person points at. Chapter 22, section 22.6
  • action (gen_statem): An instruction a state callback returns beside the next state: a reply to send, a timer to set or an event to postpone. Chapter 3, section 3.4.2
  • adapter: The directory otp/erts/emulator/sys/erxos/, the only part of ERTS that includes a liberx header, on which ERTS’s scheduler, garbage collector, loader and distribution sit. Chapter 9, section 9.4.2
  • address space: The set of virtual addresses a process can use, and what they map to. Chapter 1, section 1.4.1
  • address space identifier (ASID): A tag on each TLB entry that lets the translations of several processes sit in the TLB together, so a context switch need not clear it. Chapter 1, section 1.4.3
  • alias: A reference that stands in for a pid as a send target and that its owner can switch off. Chapter 10, section 10.3.2
  • ambient authority: Authority a program holds by being who it is, such as a UNIX process’s right to open any file its user id may open, and not because it was handed the right to one particular thing. Chapter 1, section 1.6.5; Chapter 2, section 2.3.1; Chapter 4, section 4.3.4
  • anchor: An empty space, the root of a native program’s tree of spaces, which the session holds. Chapter 13, section 13.1.1
  • app: Code that runs for no person, such as a kiosk’s screen, a network daemon or a developer’s experiment; it is a principal with a session template. Chapter 23, section 23.1
  • app template: The one session template every app’s sessions use, which the build derives from the start table’s app row. Chapter 23, section 23.1.3
  • app’s record: What the domain service sends an app’s session once its grants have settled: where the package lies, the image’s layout and root hash from the file check, and the applications or program to start. Chapter 23, section 23.3.3
  • application (OTP): OTP’s unit of code above processes: a set of modules and a supervision tree that start and stop together. Chapter 3, section 3.4.3
  • apps budget: The one budget below which every app’s principal hangs, with its guarantee equal to its cap. Chapter 12, section 12.1.1
  • arity: The number of a function’s arguments; a function is named by its name and its arity, so area/1 and area/2 are different functions. Chapter 3, section 3.1.3
  • atom: A named constant of Erlang, written as a lowercase word such as ok or error. Chapter 3, section 3.1.1
  • atomic instruction: A processor instruction that reads and changes a memory word in one step that no other core can interrupt. Chapter 1, section 1.7.2
  • attribute handle: The number by which a phone names one attribute of a Bluetooth server. Not a kernel handle; see handle. Chapter 19, section 19.1
  • attributed text: Text shown under its source’s name, such as a domain’s name, a log line or a source line from a file a domain supplied, which whatever displays it escapes. Chapter 21, section 21.6
  • backend: One implementation of liberx’s calls: the Fiasco backend the system runs on, or the hosted backend that runs a runtime as a host process. Chapter 8, section 8.2.2
  • backend reporter: A reporter that names the component of liberx’s Fiasco backend, in user mode, that measured a value the kernel itself does not report. Chapter 21, section 21.1.2
  • BAR (base address register): A register of a PCIe function that says how much memory its registers need and, once written, where they appear. Chapter 15, section 15.6
  • barrier: An instruction that makes the processor finish earlier memory operations before later ones. Chapter 1, section 1.7.3
  • BEAM: Erlang’s virtual machine: the instruction set the compiler targets and the engine that runs it. Chapter 3, section 3.5
  • BeamAsm: The BEAM’s just-in-time compiler, which translates each instruction into native machine code when a module is loaded. Chapter 3, section 3.5.1
  • behaviour: OTP’s name for a pattern of process, such as gen_server, whose generic part OTP supplies and whose specific part the programmer writes. Chapter 3, section 3.4
  • behaviour module: The module in which OTP supplies the generic part of a behaviour. Chapter 3, section 3.4
  • bell: A lane’s doorbell, bound to the consumer’s group, which the producer rings. Chapter 10, section 10.2.1
  • BIF: A built-in function: a function written in C inside ERTS, such as spawn/1 or length/1. Chapter 3, section 3.5.4
  • binary: An Erlang term that is a sequence of bytes, written <<1, 2, 3>>. Chapter 3, section 3.1.1
  • blob: A compiled module in the code store, named by the SHA-256 of its bytes; a module’s version is its blob’s hash. Chapter 21, section 21.4.2
  • block: The fixed-size unit in which a block device stores data, numbered from zero. Chapter 1, section 1.6.1
  • block device: A device that stores data in fixed-size blocks and offers two operations: read block n and write block n. Chapter 1, section 1.6.1
  • blocked: The state of a process or thread that waits for something other than a core, such as a disk read or a key press. Chapter 1, section 1.3.2
  • Bluetooth domain: The Erlang domain that parses every byte from the Bluetooth controller and holds no device. Chapter 19
  • bonding: Keeping the key that pairing made, so a phone and the machine recognize each other next time. Designed. Chapter 19, section 19.1
  • bootable file: The one file a loader boots: the first stage, Fiasco’s bootstrap, with the boot image after it. Chapter 24, section 24.1.1
  • boot image: The archive of every file a machine starts with (Fiasco’s kernel, sigma0, the root task, ERTS, the system manifest and the rest), on the page after the first stage in the bootable file. Chapter 24, section 24.1.1
  • boot information page: The page of starting facts, such as the handle of its crash area, that a new domain reads first. Chapter 8, section 8.3.4
  • boot loader: A program that knows enough about disks and file systems to find the kernel, load it into memory and pass it some information. Chapter 1, section 1.8
  • boot locator: 32 bytes at a fixed offset in the first stage, a magic word, a version and the archive’s offset and size, from which erx_boot_locate decides where the boot image lies. Chapter 24, section 24.1.1
  • boot order: The order in which the domain service creates the configured domains, servers before their clients, which the packer derives from the domains’ dependencies. Chapter 24, section 24.3.2
  • boot timeout: How long a configured domain has to report at boot before it is stopped, 60 seconds unless the manifest sets another. Chapter 24, section 24.3.2
  • boot value: Which slot the firmware booted, and whether as a trial; the slot writer reads it for itself beside the record. Chapter 16, section 16.6.2
  • boot-selection record: The one 512-byte sector, the file autoboot.txt of the record partition, that holds the whole state of an update and that the firmware reads to choose a slot. Chapter 16, section 16.6.1
  • bounded proof: A check that turns real code into a logical formula and asks a solver whether any input, up to stated sizes and loop counts, breaks an assertion; erXos runs CBMC this way. Chapter 25, section 25.4
  • brief form: The crash record a release build writes, with no registers, stack or log. Designed. Chapter 21, section 21.5.3
  • broken (lane): A pipe lane in which a reader has found an impossible position; the reader logs it once and treats the lane as a writer that has gone and been read to the end. Chapter 13, section 13.4.3
  • browser renderer: The renderer that hands a widget tree’s operations to the session’s web line, so that a browser shows them as a web page. Chapter 22, section 22.3.3
  • BSSID: The hardware address of one access point. Chapter 18
  • budget: An account for the memory a domain uses. The root service keeps one record per budget, carved from its parent’s, and charges each object it creates to one; ending a budget ends everything charged to it. Built as that record; the wall that refuses a charge past a limit is designed, not built. Chapter 1, section 1.4.7; Chapter 4, section 4.3.4
  • buffer (display): A range of a client’s pixel area laid out as an image, which present shows in a window; not the DMA buffer a driver hands a device. Chapter 22, section 22.1.2
  • buffer source: The kind of memory a pixel area is made from, for a device that shows or draws only into memory of its own kind. Designed. Chapter 22, section 22.8
  • build record: The file sdcard.img.receipt.json beside a packed medium: the commit, whether the tree had changes, and the digests of what was built. Appendix C, section C.6
  • bus: The wiring, and the protocol on it, that joins devices to the processor. Chapter 1, section 1.5.6
  • by construction: A property that holds because the wrong state cannot be expressed, not because every participant remembered a rule. Chapter 2, section 2.4.3
  • cell: One configuration a QEMU suite expects to report, such as one CPU or four, or a declared case; a cell the suite does not report counts as not_run, never passed. Chapter 25, section 25.7
  • C library: The library that gives programs printf, malloc and open. Chapter 1, section 1.1.4
  • cache: A small, fast memory close to the cores that holds recently used data. Chapter 1, section 1.5.5
  • cache line: The aligned block of a few dozen bytes, 64 on many current processors, in which a cache holds memory. Chapter 1, section 1.5.5
  • cache-coherent: A device is cache-coherent when the same hardware covers it, so its DMA reads see data still in the cache and its writes update or discard stale cached copies. Chapter 1, section 1.5.5
  • call (IPC): The usual IPC pattern: a client sends a request and waits for the server’s reply. Chapter 2, section 2.2.1
  • callback module: The module a programmer writes for a behaviour, exporting the functions the behaviour calls at each step. Chapter 3, section 3.4
  • canvas: A web page element into which the page’s code paints pixels. Chapter 22, section 22.7
  • cap (budget): The most pages a budget may spend; the root service records it, and refusing a charge past it is designed, not built. Chapter 12, section 12.1.1
  • capability: A reference to an object that the kernel honors and no program can forge, together with the rights to use it. Chapter 2; Chapter 2, section 2.3.2
  • capability table: An array in kernel memory, one per address space, with one slot per capability. Chapter 2, section 2.3.2
  • Capsicum: A system that brings capabilities to FreeBSD without changing its kernel’s structure. Chapter 2, section 2.3.6
  • cause (pause): In the design, the reason the session keeps for each pause of a program, job or signal; the program runs only when no cause remains. Designed, not built. Chapter 13, section 13.6.3
  • CBMC: A model checker for C, which checks the budget arithmetic and other C cores for every input within stated bounds. Chapter 6, section 6.5
  • central: The Bluetooth Low Energy role of the side that scans and connects, such as a phone. Chapter 19, section 19.1
  • channel: The pair of lanes between a native program and its handler, the program’s only way to ask for anything. Chapter 5, section 5.2.5
  • channel (SSH): One conversation inside an SSH connection, which asks for a pseudo-terminal of a given size and then for a shell or one command. Chapter 20, section 20.6
  • checkpoint (F2FS): A commit of F2FS’s state that names the tables saying which blocks are in use. Chapter 16, section 16.4.1
  • child budget: A budget the domain library carves from a domain’s outer budget for each connection, which pays for the ring the domain reads and its doorbell. Chapter 12, section 12.2
  • child specification: The description of one child of a supervisor: the function that starts it and its restart type. Chapter 3, section 3.3.4
  • child (supervisor): A process that a supervisor starts and restarts. Chapter 3, section 3.3.4
  • chip process: The process in the WiFi domain that drives the WiFi chip. Chapter 18, section 18.1.3
  • clause: One alternative of an Erlang function: a pattern and a body. Chapter 3, section 3.1.3
  • cleaning (cache): Writing the dirty lines of a buffer back to memory before a device reads it. Chapter 1, section 1.5.5
  • client: A program that calls a server. Chapter 2, section 2.1.2
  • C-list: A list of capabilities that a computation holds; it names an object by the position of an entry in its own list (Dennis and Van Horn’s term). Chapter 2, section 2.3.2
  • clock service: The service with the operation sample and not set, through which ntpd reports the server’s time minus monotonic time in nanoseconds. Chapter 17, section 17.7.1
  • CMSIS-SVD: Arm’s XML format in which chip vendors describe their devices’ registers; erXos generates its register accessors from it. Chapter 7, section 7.4
  • code service: The system domain’s service that loads modules into its runtime by hash, checking each file’s bytes against its SHA-256 before ERTS’s loader reads them. Chapter 9, section 9.5.2
  • coherent (flag): The device-tree fact, from a node’s dma-coherent property, that a device sees the processors’ caches; a device whose facts are missing gets no DMA memory. See also cache-coherent. Chapter 15, section 15.2.2
  • command namespace: The one order in which the shell resolves a command name: its built-ins, then Erlang commands, then program commands. Chapter 20, section 20.2.4
  • command server: erx_command_srv, process 1 of a session, which assigns every program’s id, records the program in its starter’s job and spawns its handler. Chapter 13, section 13.2.3
  • command shell: erXos’s shell, written in Erlang, which speaks the language of rc, Plan 9’s shell. Chapter 20
  • command stream: The list of operations and the addresses of their data that a program writes into memory for a GPU to execute. Chapter 22, section 22.8
  • commit and confirm (SAE): SAE’s two messages: a commit of two numbers built from PT and fresh random values, then a confirm, a MAC over both commits under a key from the shared secret. Chapter 18, section 18.3.3
  • complete mediation: Saltzer and Schroeder’s principle that every access to every object must be checked for authority; a capability kernel meets it by construction. Chapter 2, section 2.4.2
  • composition path: A way of putting a client’s pixels on the screen, beside copy and direct, that a GPU adds; erx_screen_core’s plan chooses it. Designed. Chapter 22, section 22.8
  • compositor: The code that copies the visible part of each program’s image into the framebuffer in stacking order. Chapter 22, section 22.1
  • confused deputy: A program acting for a client that uses its own authority on an object the client named but had no right to. Chapter 2, section 2.3.4; Chapter 11, section 11.6.3
  • connection: The pair of lanes, one each way, between two domains; the only way two domains exchange messages. Chapter 5, section 5.1.2
  • connection agent: erx_connections, the Erlang process in each domain that maps a new connection’s two sides and opens a lane port for it. Chapter 10, section 10.2.3
  • connection handle: The small number the Bluetooth controller assigns to a connection and reuses after it ends. Not a kernel handle; see handle. Chapter 19, section 19.2
  • console group: A shell’s group leader on a tty, which the terminal relay hands input when the shell is in the foreground. Chapter 20, section 20.4.2
  • console line: One of the two lines the system domain’s console service serves: the UART, erXos’s /dev/console, and the host link’s console line. Chapter 20, section 20.4.3
  • consumer (lane): The domain that reads a lane’s ring and alone writes its reader page. Chapter 10, section 10.2.1
  • context switch: Moving a core from one process or thread to another. Chapter 1, section 1.3.3
  • contiguous memory object: A memory object whose pages are physically contiguous, inside the range a device can reach, used for the device’s rings and buffers. Chapter 8, section 8.7.2
  • contiguous pool: One physically contiguous run of RAM that the root service takes at boot, outside its window, and from which it makes each device’s memory. Chapter 12, section 12.3
  • controller credit: One free buffer in the Bluetooth controller: room to send it one data packet. Not the channel credit of chapter 13 or the queue credit of chapter 17. Chapter 19, section 19.4.3
  • cooked mode: The tty mode, ICANON set, in which the line discipline collects and edits a line and hands the reader one whole line. Chapter 20, section 20.4.1
  • cookie: A secret atom that two Erlang nodes must share before they connect. Chapter 3, section 3.6.2
  • cooperative scheduling: Scheduling in which a thread runs until it gives up the processor itself, by blocking or by calling a yield function. Chapter 1, section 1.3.5
  • copy-on-write: A technique in which a copy of memory shares the original’s pages until either side writes one, which makes fork cheap. Chapter 1, section 1.4.6; Chapter 16, section 16.3
  • core: One of the complete processors on a chip; each core runs one stream of instructions at a time. Chapter 1, section 1.3
  • coverage-guided fuzzer: A fuzzer, such as LLVM’s libFuzzer, that records which branches each input reaches and keeps the mutants that reach new ones, so it works its way deep into a format. Chapter 25, section 25.3
  • coverage mask: An 8-bit image whose value at each pixel is how much of it a shape covers, through which the desktop draws rounded, shadowed shapes with only two primitives. Chapter 22, section 22.5.3
  • CPU set: The processors a domain’s threads may run on. Designed, not built. Chapter 5, section 5.1.4
  • crash area: A memory object, charged to a domain’s outer budget, into which its runtime writes its crash dump for the system domain to read after the domain ends. Chapter 8, section 8.3.4
  • crash dump: The registers, stack and memory of a whole program or kernel that died, kept for a developer to read afterwards. Chapter 21, section 21.5
  • crash record: The fixed layout of the ABI file that the root service writes to the console on its way down when the machine resets. Chapter 21, section 21.5.3
  • crash report: What OTP’s behaviours log when a process ends abnormally: its exit reason, its last message and its state. Chapter 21, section 21.5
  • creation (node): The number ERTS uses to tell one run of a node from the next run under the same name; a domain’s creation is its domain id. Chapter 10, section 10.1.2
  • credit (channel): The most requests a native program may have waiting for a reply on its channel: 16. Not the queue credit of chapter 17 or the controller credit of chapter 19; the queue credit is the same idea, a bound on what waits, by another mechanism. Chapter 13, section 13.2.1
  • credit (queue): A counter the receiver creates and publishes, which every sender must reserve units from before it sends; past the limit the packet is dropped, so every queue is bounded. The same idea as the channel credit, a bound on what waits for a receiver, but a different mechanism: a shared atomic counter in units, not a count of waiting requests. Chapter 17, section 17.2.3
  • critical section: Code that touches shared data, which only one thread at a time may run. Chapter 1, section 1.7.1
  • cryptographic hash: A function such as SHA-256 that maps any bytes to a short fixed-size value, so that finding two inputs with the same value is infeasible. Chapter 21, section 21.4
  • current and old (code): The two versions of a module that ERTS can hold at once; a fully qualified call always goes to the current one. Chapter 3, section 3.6.1
  • damage: The rectangles of a screen that changed, which a compositor copies instead of the whole screen. Chapter 22, section 22.1
  • Datalog: A logic language of facts and rules, from which an engine derives every fact that follows; one of the forms erXos’s principles allow for a specification. Chapter 7, section 7.10
  • deadlock: A state in which threads wait for locks that each other holds; the usual defense is to take locks in a fixed order. Chapter 1, section 1.7.2
  • delegation: Handing authority to another program. Chapter 2, section 2.3.5
  • demand paging: Bringing a page into memory only when it is first touched, so a program starts before all of it is read. Chapter 1, section 1.4.6
  • descriptor ring: An array in memory whose entries each describe one buffer, its address, its length and whether the device or the driver owns it. Chapter 1, section 1.5.4
  • device NIF: The one module through which Erlang reaches a device’s registers, buffers and interrupts; its C parses nothing the device wrote. Chapter 5, section 5.2.4
  • device registers: The small set of storage locations through which software controls a device. Chapter 1, section 1.5.1
  • device service: The system domain’s service that sends each holder the record of each device it holds: its object handles, its name in the CMSIS-SVD sources and its device-tree path. Chapter 15, section 15.2.1
  • device shim: The device NIF’s C, in otp/erts/emulator/nifs/erxos/: register access, interrupt binding, queues and the DMA plan with its check. Chapter 15, section 15.1.2
  • device tree: A data structure, handed to the kernel at boot, that describes the board’s memory and devices. Chapter 1, section 1.5.6; Chapter 1, section 1.8
  • diff: The comparison of a new widget tree with the one a toolkit holds, after which it applies only the differences. Chapter 22, section 22.3
  • differential test: A test whose oracle is a second implementation of the same contract: both get the same input, and any difference is reported. Chapter 25, section 25.1
  • direct memory access (DMA): A device’s reading or writing of memory without the processor doing the copy. Chapter 1, section 1.5.4
  • directory: A file whose contents map names to inode numbers. Chapter 1, section 1.6.2
  • dirty scheduler: One of the extra threads that ERTS keeps for C calls known to take long. Chapter 3, section 3.5.2
  • dispatcher: One helper thread per task that waits in Fiasco for any IRQ object bound to the task and wakes an executor when one fires. Chapter 8, section 8.7.1
  • display: A domain that holds a screen and its input devices and serves each window as a directory of files, as Plan 9’s rio did. Chapter 22
  • display’s session: The app session a kiosk’s start row keeps running, whose oldest window the single policy shows. Chapter 22, section 22.5.1
  • disposition: What a process does with a signal: the default action, ignore it, or run a handler function. Chapter 13, section 13.6
  • DMA range: The device-tree fact that a device sees processor address dma_cpu + x at bus address dma_bus + x, read from the dma-ranges properties above its node. Chapter 15, section 15.2.2
  • domain: A protected group of Erlang processes that share one address space and one runtime; the unit the hardware protects. Chapter 1, section 1.3.6; Chapter 3, section 3.9.1
  • domain id: A 32-bit number the domain service gives each domain and never reuses within a boot; the system domain’s is 4. Chapter 10, section 10.1.2
  • domain library: C code in liberx that the domain service calls to plan, build and end domains. Chapter 5, section 5.2.2
  • domain pid: A process in the system domain that stands for one domain; an exit signal to it stops the domain. Chapter 10, section 10.8.1
  • domain service: The system domain’s Erlang service that decides to create a domain, records it and calls the domain library to build it. Chapter 5, section 5.1.2
  • doorbell: An IRQ object with no device behind it, which one domain rings to wake another’s sleeping executors. Chapter 5, section 5.3.4
  • drain pump: A pump that copies a native program’s output out of its pipe. Chapter 13, section 13.5
  • draw connection: erx_draw_conn, the process of a program’s own session that the program’s writes to /dev/draw reach. Chapter 22, section 22.1.3
  • drive grant: The FAT server’s right to one partition of one drive, in place of a partition window. Chapter 16, section 16.5.1
  • driver: The code that knows one kind of device: its registers, what each bit means, the order of steps and how it fails. In erXos a driver is an Erlang process under a supervisor over a thin C device shim. Chapter 1, section 1.5.3; Chapter 4, section 4.5.1
  • driver domain: An Erlang domain that holds devices; its drivers are supervised Erlang processes over the device NIF. Chapter 5, section 5.2.4
  • driver table: The design’s list of native driver code, each row naming a device and the measurement that showed Erlang too slow for it; on Fiasco it has no rows. Chapter 15, section 15.1.2
  • driver-control facet: The facet through which the system domain stops, starts or restarts a domain’s drivers. Chapter 15, section 15.1
  • durable view: What an F2FS mount rebuilds after a power cut, the last checkpoint and its chain of roll-forward records; no write ever lands on a block it references. Chapter 16, section 16.4.1
  • dynamically linked: Said of a program that names shared libraries for the loader to map beside it. Chapter 13, section 13.1
  • EAPOL-Key: The frame type that carries the messages of the four-way handshake. Chapter 18, section 18.3
  • economy of mechanism: Saltzer and Schroeder’s principle that a design should be as small and simple as possible. Chapter 2, section 2.4.2
  • elastic (budget): A budget whose cap is above its guarantee, which past its guarantee may spend what its ancestors have promised to no one. Chapter 12, section 12.1.1
  • ending record (designed): What the domain library installs at the start of an ordered end: the requested end and a deadline 10 seconds away, past which its fault thread resets the machine. Chapter 24, section 24.6.3
  • end path: The one way the machine ends on Fiasco, in liberx/backend/fiasco/end.c: one end path with two entries, a named cause’s and the watchdog thread’s, which writes a crash record and resets or powers off. Chapter 24, section 24.6.1
  • endpoint: A kernel object between clients and the server threads that serve them; the destination of an IPC. Chapter 2, section 2.2.1
  • entry (of a kernel): One of the few ways a kernel is entered: at boot, on a system call or fault, and on an interrupt. Chapter 6, section 6.7.1
  • enumerator: The one process of the PCIe domain: it walks the bus, places each function’s BARs inside the bridge’s windows and reports each function to the device service. Chapter 15, section 15.6.1
  • epmd: The Erlang Port Mapper Daemon, which maps node names to the TCP ports their nodes listen on. Chapter 3, section 3.6.2
  • epoch: A counter that every wakeup of a group advances; an executor reads it before it looks for work, and its park returns at once if it has moved, so no wakeup is lost. Chapter 9
  • erase unit: The large region of flash that must be erased before pages in it can be written again. Chapter 16
  • Erlang command: A module that implements the erx_cmd behaviour and declares its command name, such as erx_cmd_ps for ps. Chapter 20, section 20.2.4
  • Erlang domain: A domain that runs one ERTS and the Erlang code of one purpose, such as a session or an app. Chapter 5, section 5.2.3
  • Erlang renderer: The renderer that lays out and draws a widget tree into its window’s buffer with erx_draw, for the desktop. Chapter 22, section 22.3.3
  • ERTS: The Erlang Run-Time System: the whole program around the BEAM. Chapter 3, section 3.5
  • ERX_ESTALE: The error a handle answers once its object has been destroyed: the generation its entry recorded no longer matches the object record’s. Chapter 2, section 2.5.4
  • ETS table: Erlang Term Storage: a table of tuples owned by one process. Chapter 3, section 3.5.3
  • event table: ERTS’s table from each doorbell label to what the label names: a connection sink, a port sink or a process sink. Chapter 9, section 9.4.4
  • exception (Erlang): What the runtime raises when no clause matches or an operation fails; it stops the function. Chapter 3, section 3.1.5
  • exception levels: AArch64’s name for the processor’s privilege modes, numbered 0 to 3, where a higher number has more power. Chapter 1, section 1.2.5
  • exception (processor): A trap caused by the instruction the program was running, such as a page fault. Chapter 1, section 1.2.1
  • executable file: The file a compiler makes and a loader runs; on FreeBSD, Linux and erXos it is in ELF, the Executable and Linkable Format. Chapter 13, section 13.1
  • executor: erXos’s name for a thread on which ERTS runs many Erlang processes; to Fiasco it is an ordinary thread. Chapter 4, section 4.2.3
  • exit reason: The term that a process’s exit signal carries. Chapter 3, section 3.3.2
  • exit signal: The signal the runtime sends to every process linked to one that ends, carrying its pid and exit reason; the runtime acts on it before any receive sees it. Chapter 3, section 3.3.2
  • exit status: The small number a process gives to exit, where 0 means success. Chapter 1, section 1.3.6
  • export (domain): To make one of a domain’s processes reachable by another domain, by sending its pid or explicitly; a pid never exported names nothing. Chapter 3, section 3.9.2
  • export (session): A file server of /bin, /dev and /etc that every session runs in its own domain, so that its programs reach the session’s local files; a different sense from a domain’s export of a pid. Chapter 14, section 14.3.1
  • export table: A domain’s own record of the processes it has exported to peer domains. Chapter 3, section 3.9.2
  • external term format: The byte encoding of Erlang terms that term_to_binary/1 produces and distribution sends. Chapter 3, section 3.6.3
  • facet: A process in a service’s domain that stands for one client’s right to use that service, and admits only what that right allows. The network service’s net facet is one whose process, erx_net_grant, lives in the network domain. Chapter 5, section 5.3.4
  • facet registry: erx_facets, a domain’s table of every facet it holds, by name; a namespace entry that names a facet is looked up in it afresh at each resolution. Chapter 14, section 14.1.1
  • facet table: A host link session’s authority: a table of facets, created empty with the session and ending with it, whose entries a call names by number. Chapter 21, section 21.4.1
  • factory: A Fiasco kernel object whose holder may create other kernel objects; only the system domain holds one. Chapter 6, section 6.2.1
  • failure memory: The map from an access point or an SSID to a count and a time, which holds a failed access point back for a while. Chapter 18, section 18.2.3
  • FAT server: erx_fat, the file server of a storage domain that serves a whole FAT partition as files; designed. Chapter 16, section 16.5.1
  • feed pump: A pump that copies bytes from the shell into a native program’s standard input pipe. Chapter 13, section 13.5
  • fence: An instruction that makes the processor finish its earlier stores before its later loads; one kind of barrier. Chapter 13, section 13.4.5
  • Fiasco: An L4 kernel from the Technische Universitaet Dresden, written almost entirely in C++; the kernel erXos runs on. Chapter 1, section 1.1.4; Chapter 2, section 2.5.2; Chapter 3, section 3.9
  • fid: A number that names a file on one 9P connection; a client walks a fid down names to new fids, opens, reads and writes one, and clunks it to let it go. Chapter 14, section 14.1
  • fid owner: The process of the client domain that made a fid; the file grant monitors it and clunks every fid it still owns when it ends. One of several senses of “owner”; see also owner (of a concept), line owner and owner (littlefs). Chapter 14, section 14.2.3
  • file: A named sequence of bytes that outlives the process that wrote it. Chapter 1, section 1.6.2
  • file check: erx_pkg_header:check_file/2, the one entry that judges a package file: it decodes the header, checks the file’s name against it and authenticates it. Chapter 23, section 23.2.3
  • file descriptor: A small integer that names an open file in one process. Chapter 1, section 1.6.3
  • file grant: A process at a file server that stands for one client domain’s right to one tree, with a root and rights (ro, rw or rx, never writable and runnable at once) fixed when the server made it; a namespace entry that leads to another domain holds its pid. Chapter 11, section 11.7.1
  • file run: A file of the boot image and the zeros up to the next page, whose BLAKE3 hash its entry records. Chapter 24, section 24.1.2
  • file system: The layout that stores files and directories on a block device. Chapter 1, section 1.6.4
  • firmware: Code stored in a chip on the board that runs when the power comes on. Chapter 1, section 1.8
  • firmware blob: The binary a chip’s vendor ships as its firmware, which nobody else can read or rebuild and which the host must trust to obey the radio rules. Chapter 18, section 18.1.2
  • first stage: The code a loader enters at the start of the bootable file, Fiasco’s bootstrap. Chapter 24, section 24.1.1
  • flush (L4): The L4 operation that removes a page from every space that received it from the flusher, directly or indirectly. Chapter 2, section 2.2.3
  • form (device NIF): The device NIF’s pure code for one kind of device’s descriptors, also called a descriptor form; it returns a plan that one check reads whole before the hardware sees it. Chapter 6, section 6.4.1
  • four-tuple: The local and remote address and port that name one TCP connection. Chapter 17
  • four-way handshake: The exchange, in EAPOL-Key frames, of two nonces from which both sides derive the PTK and which proves each knows the PMK. Chapter 18, section 18.3
  • frame (distribution): The bytes of a message between nodes plus a small header that says what they are and between which processes. Chapter 3, section 3.6.3
  • framebuffer: The memory that holds one value per pixel of a screen, row after row, which display hardware reads many times a second. Chapter 22, section 22.1
  • front end (web): A server that carries the web protocol to a browser: the host tool’s tools/erx web, or the web domain’s. Chapter 22, section 22.7.2
  • full gate: The slower tier of checks, run before a large body of work merges and in the background: the oracle, the sanitizers, the fuzz budgets, reproducibility, the model checkers and every QEMU suite booted fresh; design-build.md and tools/erx call it the milestone gate. Chapter 25, section 25.8
  • FullMAC: A WiFi chip whose own processor and firmware do the 802.11 work, from scanning to encryption with installed keys. Chapter 18, section 18.1.1
  • fully qualified call: A call written Module:Function(Args), which always goes to the current version of the module. Chapter 3, section 3.6.1
  • fun: A function used as an Erlang value. Chapter 3, section 3.1.1
  • funnel: The one reader of a domain’s lanes, which copies, checks and decodes frames. Chapter 3, section 3.9.2
  • gate (erXos): A kernel object of erXos’s interface that queues fault and exit records of a space for one thread of its creator. Chapter 8, section 8.1.1
  • gate (GATT, designed): The one pure function every attribute access passes, which compares the level the declaration requires with the link’s security. Designed, not built. Chapter 19, section 19.6
  • generation: A counter kept with a capability slot or object record that goes up whenever it is reused, so a stale reference never names a new object; erXos’s root service keeps one in each object record. Chapter 2, section 2.3.5; Chapter 5, section 5.1.6
  • gesture: Everything from the first button’s or finger’s down to the last one’s up, which the input router delivers to one window. Chapter 22, section 22.2.1
  • give: The act by which the system domain’s domain library makes a unit’s kernel objects (physical memory objects, a contiguous memory object for DMA and IRQ objects) each time its holder starts. Chapter 15, section 15.2.1
  • GPU: A processor built to draw, which executes command streams a program writes into memory. Chapter 22, section 22.8
  • grace tracker: The C17 core that decides when memory another CPU might still be reading may be reused: a retired item waits until every CPU has passed a point where it holds no reference. Chapter 25, section 25.4.3
  • grant (page): The L4 operation that gives a page to another address space; the granter loses it. Chapter 2, section 2.2.3
  • grantee: The one domain a facet’s grant is for; it is introduced to the facet and never to the service behind it. Chapter 11, section 11.6.1
  • granule (cache): The unit a cache writes back at once; DMA regions start and end on whole granules, so maintaining one region never touches another’s bytes. Chapter 6, section 6.4.2
  • group: The threads a domain’s runtime runs on, the unit of CPU time; erXos calls them executors. Chapter 5, section 5.1.4
  • group leader: The process that serves another process’s input and output. Chapter 10, section 10.3.2
  • guarantee (budget): The pages a budget is promised. Chapter 12, section 12.1.1
  • guard: A test on bound variables, written after when, that a clause adds to its pattern. Chapter 3, section 3.1.3
  • handle: A small number by which a program names a kernel object: an entry in the root service’s table for the program’s task, recording the object and its generation; the value carries the entry’s own generation, so a closed or stale handle answers ERX_ESTALE. Entries record rights; rights narrowed per creation kind and checked on every use are designed, not built. See also attribute handle and connection handle, which are not kernel handles. Chapter 2, section 2.5.4
  • handle table: The root service’s per-task table of handle entries, each naming an object record and the generation it had. Chapter 8, section 8.4.1
  • handler: The session’s Erlang process that serves one native program’s requests. Chapter 5, section 5.2.5
  • handoff record: The page bootstrap writes, read-only, for the root task before it starts the kernel: the archive’s address and size, the index hash, the command line, the console’s path and the boot value. Chapter 24, section 24.2.1
  • hash tree: A package image’s dm-verity tree, the structure that also protects the system partition, by which every block is checked before it is read. Chapter 23, section 23.2.2
  • HCI (host controller interface): The interface of the Bluetooth Core Specification between host and controller: commands, events and data packets. Chapter 19, section 19.2
  • header (package): The part of a package file that holds its declaration, where the image and hash tree lie, the tree’s salt and root hash, and a seal. Chapter 23, section 23.2.2
  • herd7: A tool that lists every outcome a processor’s memory model allows for a small program; erXos runs litmus tests of its lane and pipe handshakes with it. Chapter 10, section 10.2.2; Chapter 25, section 25.4.2
  • hint: A timer message that only tells the connection to run every deadline that is due; it carries no meaning of its own, so nothing is ever cancelled. Chapter 17, section 17.2.2
  • holder: The one domain a device belongs to and whose code drives it, named in the system manifest. Chapter 7, section 7.7
  • holders (export): The peers a name is exported to, with their rights, kept in the record that owns the name, so no export outlives what it names. Chapter 10, section 10.4.2
  • home (service): The storage domain’s third service, over the volume’s root/ and home/ directories, that serves each user’s home, /root or /home/NAME. Chapter 16, section 16.3.3
  • host bridge: The part that joins the processor to a PCIe bus. Chapter 15, section 15.6
  • host controller: The controller, here an xHCI controller, that runs a USB bus. Chapter 15, section 15.7
  • host key: The key pair by which an SSH server proves who it is; the client remembers its public half. Chapter 20, section 20.6
  • host link: The connection between the host tool, tools/erx, and the machine, over a second serial line that belongs to the system domain. Chapter 21, section 21.4.1
  • hosted mode: A runtime run as a macOS process on liberx’s hosted backend, under the sanitizers and lldb, for fast debugging; QEMU stays the authority. Chapter 9, section 9.6.2
  • hub: A USB device with ports of its own, through which more devices attach. Chapter 15, section 15.7
  • HydrOS: A system that ran one BEAM per CPU core over a small kernel, with drivers written only in Erlang. Chapter 4, section 4.1.4
  • image (package): The uncompressed EROFS image that holds a package’s files. Chapter 23, section 23.2.2
  • image (program): The space below a native program’s anchor in which its threads run. Chapter 13, section 13.1.1
  • immutable: Never changed after it is made; all data in Erlang is. Chapter 3, section 3.1.2
  • index hash: The hash of the boot image’s index run, which commits to every byte of the archive and is the image’s one identity. Chapter 24, section 24.1.2
  • index run: The boot image’s header, entries and paths, hashed with the hash field read as zeros. Chapter 24, section 24.1.2
  • initial RAM disk: An archive a boot loader places in memory beside the kernel, as Linux’s initrd; checking it is the kernel’s problem, or nobody’s. Chapter 24, section 24.1
  • inode: A record that holds a file’s size, owner, permission bits and the list of blocks where its bytes lie. Chapter 1, section 1.6.2
  • inspect facet: A process in the system domain that stands for one session’s right to inspect, with its scope fixed when the system domain made it. Chapter 21, section 21.1.3
  • inspection agent: erx_inspect_agent, the process each domain but the system domain starts at boot, which collects what the inspector asks about that domain’s processes. Chapter 21, section 21.1.3
  • inspection record: The inspector’s answer for a path: an Erlang map of attributes, each with its reporter and status. Chapter 21, section 21.1.1
  • inspector: The service in the system domain that answers for any part of the machine, from a CPU to one Erlang process, as an inspection record. Chapter 21
  • installed storage: The pages of the system domain’s release, or an arena only the code service writes; in the design the system domain’s runtime accepts a module only from there. Designed, not built. Chapter 9, section 9.5.2
  • interpreter (BEAM): The part of ERTS that runs BEAM instructions directly, fetching and dispatching each in turn. Chapter 3, section 3.5.1
  • inter-process communication (IPC): The ways separate processes exchange data: pipes, sockets, messages and shared memory. In a microkernel, the kernel carries a message from one address space to another. Chapter 1, section 1.7.4; Chapter 2, section 2.1.2
  • interrupt: A signal from outside the running program, such as a device finishing work, that makes the processor enter the kernel. Chapter 1, section 1.2.1
  • interrupt controller: The hardware that collects the interrupts of many devices, decides which core gets each, and lets the kernel mask and acknowledge them. Chapter 1, section 1.5.2
  • introduction: Joining two domains by a connection, which the domain service starts with erx_domain:introduce/2. Chapter 10, section 10.2.3
  • invalidating (cache): Marking the lines of a buffer stale before reading data a device wrote, so the next load fetches from memory. Chapter 1, section 1.5.5
  • IOMMU: A translation unit between devices and memory that works like the MMU but for devices, so a device can reach only the memory it was given. Chapter 1, section 1.5.4
  • iounit: The most bytes one read or write on a fid may carry. Chapter 14, section 14.2.2
  • IPC gate: Fiasco’s endpoint: a kernel object bound to one server thread, called through a capability. Chapter 2, section 2.5.2
  • IRQ object: A kernel object that fires to wake a waiting thread: a device’s interrupt line, or a doorbell. Chapter 8, section 8.1.1
  • JIT: A just-in-time compiler: a compiler that runs inside the program it serves and produces machine code while that program runs. Chapter 3, section 3.5.1
  • JIT alias: Two mappings of one JIT object in one domain: read and write for the compiler, read and execute for the code. Chapter 12, section 12.7.2
  • JIT memory: The kind of memory object BeamAsm writes code into, which only a space made with the JIT flag may create. Chapter 11, section 11.10.2
  • job: The commands of one shell line, which the shell starts, stops and waits for together. Chapter 13, section 13.2.3; Chapter 20, section 20.1
  • job control: Stopping the foreground job with Ctrl-Z, continuing it with fg or bg, and running jobs in the background. Chapter 13, section 13.6
  • join machine: The pure state machine that takes one candidate to an open port and keeps it open until the link ends. Chapter 18, section 18.2.2
  • journal: A log to which a file system writes a note of a whole change first, so that it can replay the notes after a crash. Chapter 1, section 1.6.4
  • keeper: The process of a tree that owns an event, such as a window’s keyboard queue, to which a file grant hands a read or write that must wait, and which answers it once the event comes; not the start table’s session keeper. Chapter 14, section 14.2.5
  • kernel: The core of an operating system, which runs with the processor’s full power. Chapter 1
  • kernel interface: The calls, rights, status codes and binary layouts defined in abi/erx_abi.txt, which liberx offers to every runtime and service; on Fiasco each call is one of Fiasco’s system calls or a request to the root service. Chapter 1, section 1.1.4; Chapter 4, section 4.3.2
  • kernel mode: The processor mode in which it executes every instruction it has. Chapter 1, section 1.2
  • kernel panic: A deliberate stop of the machine by a kernel that finds its own data inconsistent, because going on could corrupt the files on disk. Chapter 1, section 1.9
  • kernel threads: Threads that the kernel knows, saves the registers of and schedules. Chapter 1, section 1.3.4
  • key facet: A facet for one purpose that asks the key vault to sign input of that purpose’s protocol and returns the signature, never the key. Designed, not built. Chapter 11, section 11.11.2
  • key holder (designed): The vault purpose that keeps a network’s long-term secrets, answers the secret steps of each join and never gives a secret out. Designed, not built. Chapter 18, section 18.3.1
  • key slots: For each key slot of the chip, the key it was last asked to hold, the install that asked and whether the chip confirmed it. Chapter 18, section 18.3.2
  • key vault: A program that holds private keys and signs on request, so the programs that need signatures never hold the keys. Designed, not built. Chapter 11, section 11.11
  • KeyKOS and EROS: Capability systems: KeyKOS (first called GNOSIS) was built at Tymshare and first deployed in 1982, and EROS reimplemented its architecture in the 1990s. EROS space banks are the model for erXos budgets. Chapter 2, section 2.3.6
  • L4: The family of microkernels that Liedtke began, which this book follows to Fiasco. Chapter 2, section 2.1.4
  • L4Re: The L4 Runtime Environment: the user-mode libraries and servers that a system on Fiasco needs. Chapter 2, section 2.5.2
  • label: A number that names something to the code that chose it: the number a server chooses when it binds an IPC gate, which arrives with each call and tells clients apart; the number chosen when a doorbell is bound to a group, which the ready list returns and the event table resolves; and, in the root service’s range table, the name of one page table, a task’s or a memory object’s. Chapter 2, section 2.5.2; Chapter 9, section 9.4.4; Chapter 12, section 12.5.1
  • landing gate: The checks every commit passes: make check and the QEMU suites the change touches. Chapter 25, section 25.8
  • lane: One direction of a connection between two domains, a ring buffer that the sender alone writes. Chapter 1, section 1.7.4
  • lane driver: The port driver in erXos’s ERTS that runs the funnel and passes frames between ERTS and the lanes. Chapter 10, section 10.2.3
  • lane port: One port of the lane driver per connection, which ERTS’s distribution code treats as an accepted connection to the peer’s node. Chapter 10, section 10.2.3
  • liberx: erXos’s kernel interface, the one library through which every kernel call goes; on Fiasco it runs a call in the caller’s thread or sends it to the root service. Chapter 2, section 2.5.4
  • library: Code that programs link with and call like their own functions. Chapter 1, section 1.1.4
  • line discipline: The session’s code that edits and echoes typed input as termios asks; a terminal’s reads, modes and readiness belong to it and to the program protocol, not to a file protocol. Chapter 14, section 14.6; Chapter 20, section 20.4.1
  • line escape: The one function through which text shown under its source’s name passes, rendering every unsafe character as a visible token such as <U+202E>. Chapter 11, section 11.12.1
  • line owner: The process that binds a shared interrupt line once; the drivers of the devices that name the line join it instead of binding. One of several senses of “owner”. Chapter 15, section 15.5.2
  • line tree: The file tree of two files, data and ctl, with which the system domain serves the Bluetooth chip’s UART, declared in abi/services/line.txt. Chapter 19, section 19.2
  • LING: A reimplementation of the BEAM that boots with no operating system beneath it, as a guest of the Xen hypervisor. Chapter 4, section 4.1.4
  • link (Erlang): A connection between two processes so that each learns when the other stops. Chapter 3, section 3.3.2
  • link supervisor: The supervisor of one network interface, whose first and significant child is its driver, so that the driver’s end restarts the whole link. Chapter 15, section 15.1.1
  • list comprehension: An expression that builds one list from another: [2 * X || X <- [1, 2, 3]]. Chapter 3, section 3.1.4
  • list (Erlang): A term holding any number of terms, written in brackets: [1, 2, 3]. Chapter 3, section 3.1.1
  • litmus test: A small program that asks which orders of memory accesses the processor allows; erXos’s check that the lane’s fences do their job. Chapter 6, section 6.5
  • livelock: A failure in which the processor handles interrupts and nothing else, because they arrive faster than it can serve them. Chapter 1, section 1.5.2
  • loader (ERTS): The part of ERTS that reads a module file when the module is first needed and prepares it to run. Chapter 3, section 3.5.1
  • local call: A liberx call that runs in the caller’s own thread, such as a wait or a clock read; the other kind is a service call. Chapter 8, section 8.2.2
  • lock: A variable that guards a critical section; also called a mutex. Chapter 1, section 1.7.2
  • lock page: The page a pipe’s readers share, holding the reader lock and the record a reader was partway through. Chapter 13, section 13.4.2
  • log: A stream of short records, each with a time, a severity and a text. Chapter 21, section 21.5
  • log-structured file system: A file system that writes everything as an append-only log and cleans old segments later, which suits flash; F2FS is one. Chapter 16, section 16.3
  • login key: The key pair by which an SSH user proves who they are; the server lists its public half. Chapter 20, section 20.6
  • LVGL renderer: The renderer that hands a widget tree’s operations to a native program that draws them with LVGL, for panels. Chapter 22, section 22.3.3
  • Mach: An operating-systems research project at Carnegie Mellon University, active from 1985 to 1994, whose kernel was among the first microkernels. Chapter 2, section 2.1.4
  • mailbox: The queue of incoming messages that each Erlang process has. Chapter 3, section 3.2.1
  • malformed (frame): A frame no correct runtime writes; the funnel ends the connection on one. Chapter 10, section 10.3.3
  • manifest (code): A map from module names to blob hashes, which says what a code load installs. Chapter 21, section 21.4.2
  • manifest (package): A small document that names a package, its version, the files it holds and what it depends on. Chapter 23
  • map (Erlang): A term of keys and values: #{name => "eth0"}. Chapter 3, section 3.1.1
  • map (L4): The L4 operation that puts a page into another address space; the mapper keeps it. Chapter 2, section 2.2.3
  • mapper: The Erlang process that fills a mapped file’s shared object with ordinary reads and writes it back with ordinary writes. Chapter 12, section 12.8.2
  • mapping: The placement of part of a memory object in a space, with rights no greater than those of the capability that made it. Chapter 1, section 1.4.7
  • mapping database: Fiasco’s tree of which mapping was made from which, so one unmap of the root’s page removes it from every space. Chapter 8, section 8.4.2
  • mapping record: The root service’s record of one mapping of a memory object into a task: an address range inside one run, the object, the offset and the rights it was mapped with. Chapter 12, section 12.5.1
  • master (pseudo-terminal): The other side of a pseudo-terminal: a program such as sshd or a terminal window rather than a serial line. Chapter 20, section 20.4.1
  • match: The = operator of Erlang: it binds unbound variables so that the pattern equals the value, or fails. Chapter 3, section 3.1.2
  • mbuf: A chain of linked packet buffers that carries a packet through a UNIX kernel’s network stack; erXos’s stack carries checked records and binaries. Chapter 17
  • mechanism: The code that carries a decision out, such as stopping one program and starting another; kept apart from policy. Chapter 1, section 1.1.1
  • medium (disk): The one disk image laid out as the Raspberry Pi 4’s card is, two slots, the vault’s partition and /data, whose layout abi/medium.txt states. Chapter 16, section 16.1.1; Appendix C, section C.5.2
  • medium (network): The network stack’s word for a link it sends frames through; the WiFi domain makes wlan0 an Ethernet medium. Chapter 18, section 18.1.3
  • memory management unit (MMU): The part of the processor that translates virtual addresses to physical ones. Chapter 1, section 1.4.1
  • memory model: The rules for what reordering of memory operations a processor allows. Chapter 1, section 1.7.3
  • memory object: A kernel object that holds pages, which mappings place in spaces. Chapter 1, section 1.4.7
  • memory-mapped file: A file whose contents appear in an address space. Chapter 1, section 1.4.6
  • memory-mapped I/O: An arrangement in which device registers appear at physical addresses, so a load or store to one goes to the device. Chapter 1, section 1.5.1
  • merge (received segments): Joining consecutive in-order segments of one flow into one before classifying them, by the rule of FreeBSD’s LRO; one classification and one step, still one credit unit per segment. Chapter 17, section 17.5.3
  • message: A whole unit of data sent to a named receiver, delivered as a unit and not as a stream of bytes. Chapter 1, section 1.7.4
  • message-signalled interrupt (MSI): An interrupt that a PCIe function raises by writing a value to an address of the interrupt controller, since it has no interrupt wire. Chapter 15, section 15.6
  • MIC (message integrity code): A keyed checksum that proves a message came from a holder of the keys. Chapter 18, section 18.3
  • microkernel: A kernel that runs as little in kernel mode as it can and moves every other service into user-mode programs. Chapter 2, section 2.1
  • Midori: A Microsoft system that took Erlang’s supervisors as its model and tore a failed process down at once. Chapter 4, section 4.3
  • milestone gate: See full gate. Chapter 25, section 25.8
  • MINIX 3: A teaching and research system whose drivers run as user-mode processes and which restarts a driver that fails. Chapter 2, section 2.1.4
  • M:N threading: A model in which a user-level library runs M lightweight threads on N kernel threads and schedules them itself. Chapter 4, section 4.2.1
  • model checker: A tool that visits every state of a small description of a system within its bounds, checking a property in each, and prints the shortest counterexample when one fails; TLC is TLA+’s. Chapter 25, section 25.4
  • module: The unit of Erlang code that is compiled and loaded as one file. Chapter 3, section 3.1.3
  • monitor: A one-way link: the watcher learns when the watched process stops, and not the reverse. Chapter 3, section 3.3.3
  • monolithic kernel: A kernel that runs all of the operating system’s services in kernel mode, in one address space. Chapter 1, section 1.1.4; Chapter 2, section 2.1
  • mount point: The place where a namespace entry starts, written as plain names (/data is the one name data). Chapter 14, section 14.1.1
  • mounting: Attaching the root of a file system at a directory of the tree. Chapter 1, section 1.6.4
  • MTU (maximum transmission unit): The largest frame a link carries: 1,500 bytes on Ethernet. Chapter 17
  • musl: A small C library written to be read and ported, under every runtime and native program. Chapter 9, section 9.6
  • namespace: A domain’s private table from paths to the file servers it was given; a path never reaches a server outside it. Chapter 1, section 1.6.5
  • namespace entry: One of at most 64 rows of a namespace, each with a mount point, a provider, a root and rights. Chapter 14, section 14.1.1
  • Nerves and GRiSP: Systems that run an unmodified BEAM over a conventional kernel: Nerves over Linux, GRiSP over RTEMS. Chapter 4, section 4.1.4
  • NIF: A native implemented function: a C function in a shared library that a module loads and that stands in for an Erlang function. Chapter 3, section 3.5.4
  • no_facet: The refusal of a call that needs a facet the caller’s domain does not hold, before the call reaches anything. Chapter 11, section 11.6.1
  • node: A running ERTS that takes part in distribution. Chapter 3, section 3.6.2
  • nonce: A random number used once; the two sides of the four-way handshake exchange one each. Chapter 18, section 18.3
  • NOTICES: The file of every license and copyright notice an image holds, written from the image’s closure and carried as system/NOTICES. Appendix D, section D.4.2
  • notification: A signal that does not block the sender and that the receiver collects when it is ready. Chapter 2, section 2.2.3
  • object record: The root service’s entry for one kernel object, with its kind, creator, budget and generation. Chapter 8, section 8.3.4
  • old heap: The part of a process’s heap that holds terms that survived a collection and is collected less often. Chapter 3, section 3.5.3
  • operating system: The software that shares a computer among the programs on it, hides the hardware behind a few simple ideas and keeps the programs from harming each other. Chapter 1
  • oracle: An independent judge of right answers whose results the system’s own must match, such as stock OTP for erXos’s Erlang or musl’s own tests for its C library. Chapter 25, section 25.1; Appendix C, section C.3
  • ordered end (designed): The stricter shutdown of the design: an ending record with a deadline, then the vault’s quiesce and the storage freeze, before the machine ends. Chapter 24, section 24.6.3
  • origin record: The ORIGIN.md beside an imported component: its repository, release or commit, the archive’s SHA-256 and each file’s original hash and license. Appendix D, section D.2
  • OTP: The Open Telecom Platform: the libraries that ship with Erlang, including the behaviours. Chapter 3, section 3.4
  • outer budget: The budget that pays for what another domain may still use after a domain is gone, such as a ring a peer reads. Chapter 5, section 5.1.5
  • over a limit (frame): A frame too large or nested too deeply for the receiver’s own policy; the funnel drops and counts it and keeps the connection. Chapter 10, section 10.3.3
  • overcommit: Handing out more memory than the machine holds, betting that processes will not touch all they asked for. Chapter 1, section 1.4.7
  • overlay: The manifest of the modules loaded into a domain from outside, which the code service keeps so that the domain loads them again when it restarts. Designed. Chapter 21, section 21.4.3
  • owed (frame): A frame the handler cannot yet write because the program’s inbound lane is full; the handler keeps it and writes it when the program frees room. Chapter 13, section 13.2.2
  • own budget: The budget that pays for what a domain alone uses, and ends with it. Chapter 5, section 5.1.5
  • owner (littlefs): The process of erx_lfs that takes every client request, one at a time, and never blocks; the worker alone calls littlefs. One of several senses of “owner”. Chapter 16, section 16.3.1
  • owner (of a concept): The one part of the system that alone creates, changes and ends one of erXos’s seven concepts; not a fid owner, a line owner or the owner of a littlefs volume. Chapter 5, section 5.1
  • package: An app as it reaches a machine: one .app file with an authenticated header, a read-only image of its files and a hash tree over the image’s blocks. Chapter 5, section 5.1.7; Chapter 23, section 23.2.2
  • package manager: A program that installs, upgrades and removes software as units, such as Debian’s dpkg or FreeBSD’s pkg. Chapter 23
  • page: The fixed-size unit in which the MMU translates addresses; 4 KiB is common and is what erXos uses on AArch64. Chapter 1, section 1.4.1
  • page fault: An exception raised when a program touches memory with no valid translation. Chapter 1, section 1.2.1; Chapter 1, section 1.4.5
  • page funnel: The C17 core that moves pages between a budget’s reserve and the lists of free and released pages, keeping each reserve’s count equal to the pages it holds. Chapter 25, section 25.4.3
  • page index: The machine’s one hash table from a committed page’s address and its table’s label to its window address and protection. Chapter 12, section 12.5.1
  • page table: The map in memory from virtual pages to physical frames. Chapter 1, section 1.4.2
  • pager: The program that supplies memory to an address space when it touches a page not yet mapped; in L4Re, Sigma0 is the root pager. Chapter 2, section 2.5.3
  • pages out: Writing a page to disk to free its frame. Chapter 1, section 1.4.6
  • parking: How an ERTS scheduler thread with no work sleeps until some arrives. Chapter 8, section 8.5.2
  • partial boot (designed): A development manifest’s flag that replaces the configured domains with a list of native programs, for bringing up a board; a release manifest refuses it. Chapter 24, section 24.3.5
  • partition: A range of a medium’s blocks set aside for one use, listed in a partition table at the start of the disk. Chapter 16
  • partition window: An Erlang process of the block driver that serves one partition’s sectors, numbered from zero, and nothing beyond; a different thing from chapter 8’s window. Chapter 16, section 16.1.2
  • path: The name of a file given as a walk from the root directory. Chapter 1, section 1.6.2
  • path (inspection): A list of segments that names a part of the machine for the inspector, as a file path names a file: [] is the machine and [domains, 7] domain 7. Chapter 21, section 21.1.1
  • PCIe domain: The domain that alone reaches PCIe configuration space, and so can turn on any device’s DMA. Designed, not built. Chapter 11, section 11.2.2
  • PCIe function: One of the one or more independent parts a device offers behind a host bridge, each with its own configuration space and BARs. Chapter 15, section 15.6
  • pending state: The fixed-size state of a draw connection that what arrives while the device works replaces: the newest layout, and at most one waiting present per window. Chapter 22, section 22.1.3
  • peripheral: The Bluetooth Low Energy role of the side that advertises and waits; erXos implements it first. Chapter 19, section 19.1
  • persistent_term: An OTP store for terms that are read often and changed rarely. Chapter 3, section 3.5.3
  • pet: To restart a watchdog before it runs out; a pet proves only what the code that pets has checked. Chapter 24, section 24.5
  • physical address: A number that selects a byte in the actual memory chips. Chapter 1, section 1.4.1
  • pid: The process identifier of an Erlang process, a term that names it. Chapter 3, section 3.1.1
  • pin: An entry of deps.lock: a source’s identifier, exact URL, version or commit, archive SHA-256, root directory and license. Appendix C, section C.2
  • pipe: A one-way channel between two processes. Chapter 1, section 1.7.4
  • pipe NIF: The native code that gives a session’s Erlang processes pipe ends over the same rings programs use. Chapter 13, section 13.4.3
  • pipe server: erx_pipe_srv, the session’s process that makes every pipe’s lanes, lock page and doorbells and installs each end into its one holder. Chapter 13, section 13.4.4
  • pipe (USB): USB’s word, not a UNIX pipe: a fresh Erlang reference naming an attached device, with an endpoint, that a transfer names; detach removes it at once. Chapter 15, section 15.7.2
  • pixel: One point of a screen’s grid. Chapter 22, section 22.1
  • pixel area: The one memory object the system domain makes with a client’s display connection, which the client maps writable and the display read-only. Chapter 22, section 22.1.2
  • pixel format: The layout of one pixel’s bits, such as x8r8g8b8. Chapter 22, section 22.1
  • place (path): The path of the directory the resolver has reached so far, every name of which a walk answered as a directory. Chapter 14, section 14.1.4
  • places (USB): The fixed names, such as hid0 to hid7 and da0 to da3, under which other domains see USB devices, set when the domains are configured. Chapter 15, section 15.7.1
  • plan (DMA): What a descriptor form’s queue call returns beside the queue’s next state: the writes to apply, each of which erx_device_dma_check verifies before the effect layer applies any. Chapter 15, section 15.4.1
  • plan (range table): What the root service computes for a memory request before changing anything: the range, the state each reserved page in it becomes, and how many pages the change needs. Chapter 12, section 12.5.2
  • platform record: The file that lists a board’s devices, their addresses and its pins, such as config/platforms/raspi4b.json; a unit’s placement names one of its entries. Chapter 15, section 15.2.1
  • PMK (pairwise master key): The 32-byte key WPA2-PSK derives from the passphrase with PBKDF2, salted with the SSID. Chapter 18, section 18.3
  • policy: A decision about what the system favors, such as which program runs next; kept apart from the mechanism that carries it out. Chapter 1, section 1.1.1
  • poll: To read a device’s status register in a loop until it says it is done. Chapter 1, section 1.5.2
  • pool (page): The root service’s free list of pages, threaded through the pages themselves; a page taken from it is zeroed first. Chapter 8, section 8.6.1
  • port driver: C code linked into ERTS that an Erlang port talks to; to Erlang the port looks like a process. Chapter 3, section 3.5.4
  • port (Erlang): An Erlang value that connects a process to something outside: an external program or a C driver linked into ERTS. See also port (WiFi). Chapter 3, section 3.5.4
  • port (WiFi): The link state in the sense of IEEE 802.1X: data frames pass only once the keys are in. Not an Erlang port; see port (Erlang). Chapter 18, section 18.1.3
  • POSIX-lite personality: musl’s POSIX functions over liberx, enough to recompile and statically link an ordinary UNIX program without porting it. Designed, not built as a whole. Chapter 13, section 13.7.1
  • power-cut harness: The test of the F2FS core that runs a workload over a test window recording every write and makes every state a cut could leave, each write kept, lost or torn at a sector boundary; designed. Chapter 16, section 16.4.3
  • preemption: Taking the processor away from a running program by a timer interrupt. Chapter 1, section 1.2.3
  • preemptive scheduling: Scheduling in which the timer interrupt takes the processor back whether the thread cooperates or not. Chapter 1, section 1.3.5; Chapter 3, section 3.5.2
  • presentation: A type and a canonical text that a terminal’s output carries as a hyperlink, so that a click inserts the text and calls no service. Chapter 22, section 22.2.4
  • principal: A user in erXos’s sense: an identity with its own budget, CPU share and quotas. Chapter 4, section 4.4.1
  • priority: A number that says which thread should run first. Chapter 1, section 1.3.5
  • priority band (band): The range of Fiasco priorities a domain’s threads start in, together with a set of CPUs they may run on, so a spinning domain delays only its band and those below. Designed, not built: today every thread but the watchdog’s runs at one priority. Chapter 1, section 1.3.6; Chapter 3, section 3.9.1; Chapter 4, section 4.2.3
  • privileged instructions: The instructions that user mode refuses: those that change the memory map, reach devices, mask interrupts or set the timer. Chapter 1, section 1.2
  • process: A program running: its instructions plus everything that changes as they run. Chapter 1, section 1.3.1
  • process id: The number that identifies a UNIX process; also called a pid. Chapter 1, section 1.3.1
  • producer (lane): The domain that writes a lane’s ring and rings its bell. Chapter 10, section 10.2.1
  • program command: A native program the session’s export lists in /bin, which the shell runs as a command. Chapter 20, section 20.2.4
  • program counter: The register that holds the address of the next instruction. Chapter 1, section 1.3.1
  • program (native): C compiled against erXos’s C library, run in a sub-space of its session’s domain. Chapter 5, section 5.2.5
  • program protocol: The grammar of the frames between a native program and its handler, declared once in abi/protocols/prog.txt and generated for both sides. Chapter 13, section 13.2.1
  • provider: The part of a namespace entry that says who serves the names below its mount point: the release slice, an EROFS image, a file grant, a facet’s file grant, or ended. Chapter 14, section 14.1.1
  • PSCI: The Power State Coordination Interface: a call into the secure firmware with a function number in a register, through which the kernel starts a CPU, resets the board or powers it off. Chapter 24
  • pseudo-terminal: A tty whose other side, the master, is a program rather than a serial line. Chapter 20, section 20.4.1
  • PT: The value derived from the password that SAE starts from, as WPA2 starts from the PMK. Chapter 18, section 18.3.1
  • PTK (pairwise transient key): The key derived from the PMK, both nonces and both addresses, which splits into the MIC key, a key-wrapping key and the traffic key. Chapter 18, section 18.3
  • pump: An Erlang process of a native program’s starter that holds one of the program’s pipe ends through the pipe NIF and copies bytes between it and the shell. Chapter 13, section 13.5
  • pure function: A function whose result depends only on its arguments and which changes nothing: it reads no clock, no device and no other process. Chapter 3, section 3.9.4
  • purge: To remove the oldest version of a module and end the processes still running it. Chapter 3, section 3.6.1
  • QEMU suite: A test that builds an image, boots it in QEMU and judges what the guest writes on its serial console; each is one file in tools/lib/erx/qemu_suites/. Chapter 25, section 25.7
  • qid: A server’s identity for a file, returned in its replies. Chapter 14, section 14.2.2
  • query worker: The process an inspect facet runs each query in, which decides who owns the path before it collects anything. Chapter 21, section 21.1.3
  • race condition: A bug in which the result depends on how two activities’ steps interleave. Chapter 1, section 1.7.1
  • range table: The one piece of code, shared by both backends, that tracks a space’s reserved, committed and mapped ranges. Chapter 8, section 8.6.2
  • raw mode: The tty mode in which the line discipline hands bytes to the reader as they come, as a screen editor wants. Chapter 20, section 20.4.1
  • rc.d script: On FreeBSD, the short shell script in /etc/rc.d that knows how to start, stop and check one daemon. Chapter 23, section 23.1.1
  • reachability configuration: A TLA+ model configuration that claims some important state is never reached and expects TLC to refute it, proving the model reaches the paths that matter. Chapter 25, section 25.4.1
  • reader page: The page of a lane that the consumer alone writes and the producer maps read-only. Chapter 10, section 10.2.1
  • ready: The state of a process or thread that can run and waits for a core. Chapter 1, section 1.3.2
  • ready list: A group’s list of the doorbells that have fired and not yet been handled. Chapter 9, section 9.3.3
  • reaper: One helper thread per task that asks the root service to delete the task’s exited threads. Chapter 8, section 8.5.1
  • record partition: The first partition of the medium, a small FAT16 volume labelled ERXOS that holds the boot-selection record and the files a user adds before the first boot. Chapter 16, section 16.1.1
  • record (pipe): The bytes of one write to a pipe, at most PIPE_BUF (4,096), which a reader receives whole. Chapter 13, section 13.4.2
  • redirection: Sending a command’s stream to a file, as in ls >out. Chapter 20, section 20.1
  • reduction: ERTS’s unit of work, roughly one function call, in which a scheduler measures a process’s turn. Chapter 3, section 3.5.2
  • reference (Erlang): A term unique in the running system. Chapter 3, section 3.1.1
  • region (DMA): A span of a device’s memory, such as a ring or a buffer, that only the CPU or only the device writes at any moment. Chapter 6, section 6.4.2
  • registered name: An atom given to a process with register(Name, Pid) so that others can find it. Chapter 3, section 3.2.3
  • registers: The processor’s small fast storage; a process’s saved set holds its state while it does not run. Chapter 1, section 1.2.1
  • release (OTP): A set of applications at fixed versions with the runtime that runs them: a complete system that boots. Chapter 3, section 3.4.3
  • release slice: The part of the boot image that holds a domain’s own OTP release, in memory the kernel mapped before the domain could reach any server; the provider of the entry at /. Chapter 14, section 14.1.1
  • render service: A domain that holds a drawing device and fills clients’ buffers from commands their renderers build. Designed. Chapter 22, section 22.8
  • rendezvous: The moment when sender and receiver are both ready and the kernel moves a synchronous message. Chapter 2, section 2.2.1
  • replay watermark: The counter of the last handshake message accepted under a valid MIC, which lets an old message be told from a new one. Chapter 18, section 18.3.2
  • report filter: erx_report, the primary logger filter every event of a runtime passes, which rewrites reports so that they carry no term. Chapter 21, section 21.5.2
  • reporter: The party that measured or decided an inspected value: kernel, service or runtime, and on Fiasco a backend reporter. Chapter 21, section 21.1.2
  • reproducible build: A build that gives byte-identical output from the same source, tools and settings, whoever runs it and whenever. Chapter 25, section 25.6
  • request gate: A task’s IPC gate to the root service, which carries both its requests and its threads’ page faults. Chapter 8, section 8.3.2
  • reset count: The number of boots in a row that ended unordered, kept in a sector of its own beside the record; past three, the system boots its rescue configuration; designed. Chapter 16, section 16.6.4
  • restart intensity: How many restarts a supervisor allows within a period of seconds before it gives up. Chapter 3, section 3.3.4
  • restart strategy: The rule that says which children a supervisor restarts when one fails. Chapter 3, section 3.3.4
  • restart type: A child’s rule for when to restart: permanent (always), transient (only after an abnormal exit) or temporary (never). Chapter 3, section 3.3.4
  • retained tree: The toolkit style in which a program describes its whole interface as a tree each time its state changes, and the toolkit applies the differences. Chapter 22, section 22.3
  • revocation: Taking authority back after it was delegated. Chapter 2, section 2.3.5
  • rights only shrink: The rule that a program passing a capability can remove rights from the copy and never add any. Chapter 2, section 2.3.5
  • ring: A fixed area of shared memory used in a circle: the producer writes records and publishes its position, and the consumer reads up to it and publishes its own. Chapter 10
  • root directory: The top of the directory tree, written /. Chapter 1, section 1.6.2
  • root hash: The one hash left when every block of an image is hashed, then the list of hashes in blocks, and so on up; if it is trusted, so is every block that checks against it. Chapter 16, section 16.2
  • root service: A thread of the system domain’s first program that alone creates kernel objects and maps memory, on behalf of requests that liberx sends it; it plays the part of the L4Re root task. Chapter 1, section 1.2.5
  • root task: The one program the kernel starts with every initial capability, which then builds and starts the rest of the system. Chapter 2, section 2.5.3
  • route: In find and act, a rule that turns a value into an act. Chapter 22, section 22.6
  • run (segments): One TCP header, a contiguous range of payload and a segment size: consecutive segments of one connection that differ only in sequence number, lengths and checksums, so output pays once per run. Chapter 17, section 17.5.3
  • run queue: A queue of ready threads (kernel) or of ready Erlang processes (one per ERTS scheduler). Chapter 1, section 1.3.5; Chapter 3, section 3.5.2
  • running: The state of a process or thread that is executing on a core. Chapter 1, section 1.3.2
  • runs (range table): Each task’s reserved addresses, sorted and disjoint, one of the root service’s three facts about memory. Chapter 12, section 12.5.1
  • runtime image: One of the three builds of ERTS: the system image (the interpreter without BeamAsm or OpenSSL), the interpreter image (with OpenSSL) and the BeamAsm image. Chapter 9, section 9.5.1
  • scheduler: The part that picks which ready thread runs next on each core. ERTS has one scheduler thread per core, which picks among Erlang processes. Chapter 1, section 1.3.5; Chapter 3, section 3.5.2
  • scheduler activations: A design in which the kernel calls into a user-level scheduler whenever one of the program’s threads blocks or is preempted. Chapter 4, section 4.2.1
  • scope (inspection): What an inspect facet may see, fixed in the facet when the system domain made it. Chapter 21, section 21.1.3
  • SDIO host: The small host in the storage domain that brings the WiFi chip’s card up and runs lists of SDIO transactions for one client without understanding the chip. Chapter 18, section 18.1.3
  • seal: The last field of a package header: the signer’s Ed25519 public key and a signature over every byte of the header before it. Chapter 23, section 23.2.2
  • secure firmware: The most privileged code on an Arm chip, at EL3; Trusted Firmware-A leaves BL31 there for the machine’s whole life. Chapter 24
  • seeded test: A test that plants one deliberate violation and passes only if the check refuses it with the expected diagnostic. Chapter 7, section 7.7.2
  • seed (fuzzing): A valid input a coverage-guided fuzzer starts from and mutates. Chapter 25, section 25.3
  • segmentation: An older form of memory translation that gives each process a few variable-sized regions. Chapter 1, section 1.4.1
  • seL4: The L4 kernel built for formal verification, by NICTA and UNSW. Chapter 2, section 2.3.6; Chapter 2, section 2.5.1
  • selective receive: A receive that takes the first message in the mailbox that matches a pattern and leaves the others. Chapter 3, section 3.2.2
  • server: A user-mode program that answers requests from other programs, its clients. Chapter 2, section 2.1.2
  • service: A program that runs in the background with no person at the keyboard. Chapter 1, section 1.1.4
  • service call: A liberx call that becomes a request to the root service; the other kind is a local call. Chapter 8, section 8.2.2
  • session: A domain started from a principal’s session template, in which a person’s shell, commands and programs run. Chapter 5, section 5.1.7
  • session (host link): A conversation between the host tool and the machine over the host link, opened with a hello and a fresh nonce; not a login session. Chapter 21, section 21.4.1
  • session keeper: The one child of a start row’s supervisor: a process that asks the domain service for the row’s session and links to it. Chapter 23, section 23.1.2
  • session template: A principal’s description of the domain a session gets: its runtime, release, limits and the services it may use. Chapter 5, section 5.1.7
  • shader: A small program a GPU runs for each vertex or pixel. Chapter 22, section 22.8
  • share (reductions): In the design, the reductions per period within which a facet admits its client’s requests. Designed, not built. Chapter 9, section 9.7.2
  • shared memory: A region of physical memory mapped into two address spaces at once. Chapter 1, section 1.7.4; Chapter 2, section 2.2.3
  • shared object (file): The memory object a session holds for one file mapped with MAP_SHARED, which the file’s mapper fills and writes back. Chapter 12, section 12.8.2
  • shell (Erlang): The interactive prompt that reads an Erlang expression, evaluates it and prints the result. Chapter 3, section 3.1
  • shell pipe: One Erlang process holding up to 64 KiB of bytes in order, which carries bytes between Erlang stages of a pipeline. Chapter 13, section 13.5
  • shim: A small piece of C that touches a device’s registers, under the Erlang driver process. Chapter 3, section 3.9.3
  • side (connection): The one memory object that holds everything one domain writes on a connection: its outgoing lane’s ring and its incoming lane’s reader page. Chapter 10, section 10.2.1
  • signal: A notice the kernel delivers to a process on its own behalf or another process’s, such as SIGSEGV for a bad memory access. Chapter 1, section 1.3.6
  • signal right: In the design, an authority to signal a set of processes, which a starter may hand on. Designed, not built. Chapter 13, section 13.6.2
  • Singularity: A Microsoft Research system that ran each program as a sealed, type-safe process. Chapter 4, section 4.3
  • sink (event table): What a doorbell’s label leads to: a connection sink (a lane from another domain), a port sink (a port’s input task, such as a program’s channel) or a process sink (a term sent to an Erlang process, such as a device interrupt). Chapter 9, section 9.4.4
  • skeuomorphism: A thing wearing the name, syntax or shape of something it is not; erXos has none. Chapter 4, section 4.5.5
  • slot (group): An executor’s entry in its group’s table, by which another executor can wake it by name. Chapter 9
  • slot (update): A pair of partitions, a boot partition and a system partition; there are two, A and B, and an update writes the one that is not running. A different sense from a group’s slot. Chapter 16, section 16.1.1
  • slot writer: The one small domain that holds the only writable windows on the slots and the record, and decides each write from the record and the boot value; designed. Chapter 16, section 16.6.2
  • socket: A two-way channel between processes on one machine or on two machines across a network. Chapter 1, section 1.7.4
  • socket process: The gen_statem in a client’s domain that presents a connection as gen_tcp does and alone talks to the connection process in the network domain. Chapter 17, section 17.6.3
  • space: The kernel’s name for an address space. Chapter 1, section 1.4.7
  • space bank: EROS’s account of memory, from which a program pays for every object it creates; deleting the bank frees everything paid from it. Chapter 2, section 2.3.6; Chapter 4, section 4.3.4
  • spare: The slot an update writes, other than the one that runs. Chapter 16, section 16.6
  • SPIN: A system that linked extensions written in a safe language into the kernel. Chapter 4, section 4.3
  • split ring: Virtio’s way of moving data: a descriptor table, an available ring of descriptors handed to the device and a used ring of those it has finished. Chapter 15, section 15.3
  • SSH domain: The domain in which OTP’s ssh daemon runs and parses everything the network sends. Designed. Chapter 20, section 20.6
  • SSID: The network name an access point announces, which many access points of one network share. Chapter 18
  • stack pointer: The register that marks the top of a process’s stack. Chapter 1, section 1.3.1
  • stamp: The monotonic clock’s reading that a pipe record carries, by which a reader merges several writers’ lanes. Chapter 13, section 13.4.2
  • start row: A row of the start table: it names a principal, says whether its session starts at boot, may name a display for the app’s window and sets a restart intensity. Chapter 20, section 20.5; Chapter 23, section 23.1.2
  • start table: The one place that says which principals’ sessions run without a person; service changes it. Chapter 20, section 20.5; Chapter 23, section 23.1.2
  • starter: The Erlang process that asked for a native program to run; what it handed over bounds the program’s table. Chapter 13
  • startup message: What the handler writes into a new program’s inbound lane before its first thread starts: arguments, environment, working directory, signal state and descriptors. Chapter 13, section 13.3.1
  • starvation: The failure in which a low-priority thread never runs because higher ones are always ready. Chapter 1, section 1.3.5
  • static random address: The machine’s address on the air, made from the system’s random generator, which embeds no hardware address. Chapter 19, section 19.4.5
  • statically linked: Said of a program that carries every library function it calls in its own file. Chapter 13, section 13.1
  • station (WiFi): A device that joins a WiFi network. Chapter 18
  • status (command): A command’s result as a string, as in rc: empty for success, a program’s exit status, a signal’s name or an Erlang command’s error. Chapter 20, section 20.2.1
  • status page: Memory in which the root service’s own liberx writes its group’s parked and ready figures as its threads park and wake. Chapter 21, section 21.2.2
  • store-release: A store the processor may not make visible before the stores ahead of it. Chapter 13, section 13.4.5
  • stream file: A file whose reads wait for an event, answered by a keeper instead of by the file server’s callback. Chapter 14, section 14.2.5
  • stride: The distance in bytes from the start of one row of an image to the next. Chapter 22, section 22.1
  • sub-binary: A reference into part of a larger binary, made without copying; it keeps the whole binary alive, so a small held payload is copied out. Chapter 17, section 17.3.2
  • sub-space: An address space a domain creates for a native program; it holds only what the domain gives it and ends with its creator. Chapter 5, section 5.2.5
  • supervisor: A process whose only job is to start other processes, its children, and to restart them when they stop. Chapter 3, section 3.3.4
  • supplicant: The program that runs a station’s handshakes. Chapter 18
  • SYN cookie: A way to answer a SYN without remembering it when the syncache is full: the connection’s state is encoded in the SYN-ACK’s sequence number. Chapter 17, section 17.1.3
  • syncache: A small bounded table of half-open connections that answers a SYN flood; erXos keeps one share of it in each interface process. Chapter 17, section 17.1.3
  • synchronous (IPC): Moving a message only when the sender is ready to send and the receiver is ready to receive. Chapter 2, section 2.2.1
  • system call: A deliberate request from a program to the kernel. Chapter 1, section 1.2.1
  • system domain: The Erlang domain that decides policy and builds every other domain; it is erXos’s root task. Chapter 1, section 1.8; Chapter 2, section 2.5.3; Chapter 3, section 3.9.1
  • system knowledge base: Barrelfish’s store of facts about the hardware, in a subset of first-order logic, which answered queries such as where a driver should run. Chapter 7, section 7.10
  • system manifest: The one file that names every domain the machine runs, with its budget, its devices and the services it may reach. Chapter 4, section 4.5.4
  • system shell: The system domain’s own command shell, with the system domain’s authority, on the console’s terminal. Chapter 20, section 20.4.3
  • system tree: The apps/ directory of the booted slot’s system partition, served read-only by the storage domain through erx_storage_system. Chapter 16, section 16.2.3
  • table (program): What a native program may reach, its namespace, open files and pipe ends, kept by its handler. Chapter 13, section 13.1.1
  • tag (job): The mark every Erlang process of a job carries, so that a stop finds the job’s processes by tag. Chapter 20, section 20.2.6
  • tail call: A recursive call that is the last thing a function does; the runtime turns it into a jump that uses no stack. Chapter 3, section 3.1.4
  • task (Fiasco): Fiasco’s name for an address space together with the kernel objects its threads may use. Chapter 2, section 2.5.2
  • term: Any Erlang value. Chapter 3, section 3.1.1
  • terminal: A keyboard and screen, once on a serial line and today a terminal window or an SSH client, which sends bytes for keys and draws the bytes it receives. Chapter 20, section 20.4.1
  • terminal relay: erx_session_relay, the one process in a session’s domain that owns a tty: it holds the termios, runs the line discipline and talks to the master. Chapter 20, section 20.4.2
  • thread: One stream of execution: a program counter, a stack and a set of registers. Chapter 1, section 1.3.4
  • thread limit: The cap on how many threads a domain may have. Designed, not built. Chapter 5, section 5.1.4
  • threat model: A statement of who a security design defends against, what each adversary can and must not be able to do, the assets it protects and what it leaves out. Chapter 11
  • time of check to time of use: A bug in which an argument changes between the kernel’s check and its use; kernels avoid it by copying each argument once and using only the copy. Chapter 1, section 1.2.2
  • time slice: The few milliseconds a thread runs before the timer interrupt lets the kernel choose again. Chapter 1, section 1.3.5
  • timer interrupt: The interrupt by which a timer takes the processor back from the running program. Chapter 1, section 1.2.3
  • TLA+ and TLC: Leslie Lamport’s language for describing a concurrent protocol, and its model checker; erXos specifies its lane, connections and links in it. Chapter 6, section 6.5
  • total decoder: A packet decoder that returns a record or an error for every input and never raises, checking each length against the layer around it. Chapter 17, section 17.2.4
  • trace relay: The tracer a trace facet starts in a traced domain, which renders each trace message into plain terms and sends them in batches. Chapter 21, section 21.3.3
  • trace ring: 4,096 records that liberx writes in the root service as it carries out parks, wakes and doorbell deliveries, merged with OTP’s own trace into one timeline. Chapter 9, section 9.7.1; Chapter 21, section 21.3.1
  • trace session: In OTP 29, a handle that holds which processes are traced, for which events, and which process, the tracer, receives the trace messages. Chapter 21, section 21.3
  • tracer: The process that receives a trace session’s messages. Chapter 21, section 21.3
  • translation lookaside buffer (TLB): A small cache of recent address translations inside the processor. Chapter 1, section 1.4.3
  • trap: The special instruction that switches the processor to kernel mode and jumps into the kernel. Chapter 1, section 1.2.1
  • tree process: The one Erlang process that holds the whole value of /tmp’s tree and answers every callback by one step of a pure function. Chapter 14, section 14.4
  • trial: The one boot of the spare slot after an update; it becomes the committed slot only if the trial is healthy, and a trial writes nothing but the record. Chapter 16, section 16.6
  • trust placement: For each security property, the short list of code it rests on. Chapter 11, section 11.2.1
  • trusted base: erXos’s trusted computing base: Fiasco, the root service and the rest of the system domain. Chapter 11, section 11.2.2
  • trusted computing base (TCB): The parts of a system whose failure can break its security, as opposed to the parts whose failure harms only themselves. Chapter 2, section 2.4.1
  • tty: The state UNIX keeps for one terminal: its termios settings, its window size and the input it holds. Chapter 20, section 20.4.1
  • tuple: A fixed number of Erlang terms in braces: {point, 1, 2}. Chapter 3, section 3.1.1
  • two-file form: The bootable file split for debugging under QEMU: the first stage given to -kernel and the archive to -initrd. Chapter 24, section 24.1.1
  • two-level scheduling: An arrangement in which the kernel schedules at one level and a user-mode scheduler at the other. Chapter 4, section 4.2
  • umtx wait: A wait on a memory address, from which musl builds its mutexes and condition variables. Chapter 8, section 8.5.2
  • unforgeable: A property of a capability: no program can make one by itself. Chapter 2, section 2.3.3
  • unit (manifest): A set of devices that share a register page or an interrupt line, given whole to one domain. Chapter 7, section 7.7
  • unwrapped sequence number: A TCP sequence or acknowledgement number kept as an unbounded integer counted from the initial sequence number, so it never wraps inside a connection. Chapter 17, section 17.2.4
  • upcall: A call from the kernel into user code. Chapter 4, section 4.2.2
  • user mode: The processor mode that refuses privileged instructions. Chapter 1, section 1.2
  • user-level thread: A thread a program schedules itself on top of a few kernel threads, switching with no system call; Erlang’s processes are of this kind. Chapter 1, section 1.3.4
  • UTCB: A user thread control block: a small block of memory per thread for message words, shared by the thread and the kernel. Chapter 2, section 2.2.2
  • verdict: The answer the station’s choice gives for each scanned access point: a pick candidate or a named refusal. Chapter 18, section 18.2.1
  • view: The one value the station’s choice of a network is a function of: the configured networks, the key holder’s passwords, the last scan, the failure memory, the user’s request, the chip’s abilities and the time. Chapter 18, section 18.2.1
  • virtio: The standard that defines devices designed for emulation, such as a network card, a disk, a GPU and a keyboard, each with a few registers and one split ring. Chapter 15, section 15.3
  • virtual address: An address a program uses, which the MMU translates to a physical address. Chapter 1, section 1.4.1
  • wake word: The counter every wait in liberx sleeps on; a signal’s sender bumps it first, so the thread cannot sleep through the signal. Chapter 13, section 13.6.4
  • wall (budget): A budget whose cap equals its guarantee: memory set aside for a domain that no other domain can take. The records are built; the refusal that makes a wall hold is designed, not built. Chapter 12; Chapter 12, section 12.1.1
  • watchdog: A timer that resets the machine unless software pets it before it runs out; erXos’s is a chain from erx_watchdog through the root’s watchdog thread to, on the Pi 4, the board’s hardware watchdog. Chapter 24, section 24.5
  • web domain: The domain that carries the web protocol from the network to a browser after a login, with cowboy as its HTTP server. Designed. Chapter 22, section 22.7.2
  • WebAssembly: A compact instruction format that browsers run near native speed, so a program written in C, such as an emulator, runs in a page. Chapter 22, section 22.7
  • WebSocket: A two-way connection between a web page and a server, opened over HTTP, that carries whole messages either way. Chapter 22, section 22.7
  • widget: An element a toolkit gives a program, such as a button, label, list or slider. Chapter 22, section 22.3
  • widget server: erx_ui_server, the process erx_ui:open/1 starts in an application’s own runtime, which holds its window and its widget tree. Chapter 22, section 22.3.2
  • window (display): A rectangle on a screen that a display serves as a directory of files; not the root service’s window. Chapter 22, section 22.1
  • window (root service): The region of the root service’s address space where every page of RAM has one permanent address. Chapter 8, section 8.6.1
  • window policy: The display’s rule, single or overlapping, that the router asks only about what starts something, such as a key’s down or a gesture’s first event. Chapter 22, section 22.2.1
  • worker: A process that does the work, a leaf of a supervision tree. Chapter 3, section 3.3.5
  • worker (thread): A thread of a runtime that may block, such as ERTS’s dirty I/O thread; it never parks. Chapter 9
  • WPA2-PSK: WPA2 with a shared passphrase, from which station and access point derive the PMK. Chapter 18, section 18.3
  • WPA3-SAE: WPA3’s password exchange, which replaces the PMK-from-passphrase with a fresh key and gives an eavesdropper nothing to test guesses against. Chapter 18, section 18.3
  • writable and executable at once: The state of a page that a program could both rewrite and run; the rule W^X forbids it. Chapter 1, section 1.4.4
  • Zircon: The kernel of Google’s Fuchsia, which gives every process a table of handles with rights. Chapter 2, section 2.3.6