Search Knowledge

© 2026 LIBREUNI PROJECT

Operating Systems Engineering/Protection, isolation, and synthesis
Page 27 of 29

Comparative Kernel Design

Workload-driven comparison of xv6, Linux, XNU, and seL4 mechanisms across file access, IPC, driver faults, authority, and multicore state.

Lesson briefProtection, isolation, and synthesis · 5 h · 4 outcomes

Required knowledge

  • System calls, scheduling, synchronization, virtual memory, devices, filesystems, and protection
  • Virtual-machine and container trust boundaries
  • Ability to separate an analytical mechanism claim from a benchmark result

Learning outcomes

  • Compare concrete kernel configurations by control path, protection boundary, shared state, and failure semantics rather than by historical label.
  • Trace equivalent file, IPC, and device workloads through xv6, Linux, XNU, and seL4 mechanisms without inventing unsupported performance results.
  • Choose evidence capable of testing architecture-sensitive latency, isolation, and scalability claims.
  • Defend a kernel/system configuration for an unfamiliar workload and identify the assumptions that could reverse the decision.

Assessment target

Given a workload and threat model, produce mechanism-level traces for at least three concrete systems, identify trusted and measured paths, then defend a design choice against a changed requirement.

Scope boundary

  • Chronological operating-system history, product surveys, market-share comparisons, and unsupported 'microkernel versus monolithic' rankings are excluded.
  • Windows NT, BSD variants, real-time kernels, verified device stacks, and distributed operating systems require equally concrete source and workload treatment beyond this comparison set.

“Choose a microkernel for security” and “choose a monolithic kernel for speed” are not engineering decisions. Neither statement identifies a workload, deployed component boundary, authority path, device model, cache state, failure, or measurement. A Linux system with a user-space service can isolate that service from the kernel address space; a carelessly configured microkernel system can grant a driver DMA authority over all memory. Labels constrain possibilities but do not instantiate a design.

The unit of comparison is a concrete system configuration under an explicit workload.

Freeze four reference configurations

The comparison uses these bounded configurations, not every possible build or extension:

configurationprivileged deployment boundaryservice/authority mechanisms relevant herestated purpose in comparison
xv6 RISC-V rev5 (7d7adbb1…) teaching baselinecompact kernel containing scheduler, VM, filesystem, pipes, and driversprocess page tables, simple Unix-style descriptors/permissions, one filesystem logexpose complete mechanism traces at inspectable scale
Linux general-purpose buildone kernel address space containing core subsystems and selected drivers; user processes outsideVFS objects, namespaces/cgroups, credentials/LSMs, descriptors, RCU and many locking schemesproduction mechanism and scalability evidence
XNU open-source treeMach, BSD, IOKit, VM, and security subsystems composed in the XNU kernel source; user tasks outsideMach ports/messages, BSD vnode/file interfaces, task/address-space mechanisms, IOKit driver frameworkhybrid composition and dual Mach/BSD interfaces
seL4-based component systemminimal seL4 kernel; selected services and drivers placed in separate user address spaceskernel-object capabilities, synchronous IPC endpoints, explicit address spaces, IRQ objectscapability-mediated component isolation

“Hybrid,” “monolithic,” and “microkernel” are summaries of these deployed boundaries. They do not specify which optional driver runs where, whether an IOMMU exists, or how a user-level filesystem is built.

The seL4 kernel does not itself supply a POSIX filesystem or full operating environment. A seL4 system must choose user-level servers and protocols. Comparing “Linux open” to “seL4 open” without defining those servers invents a path that the kernel does not prescribe.

Retrieval checkpoint: compare a kernel or a system?

A report claims that seL4 has slower pathname lookup than Linux but gives only seL4 kernel IPC timings. Identify the category error and the missing configuration.

Reveal the missing causal pathExpand

Pathname lookup is a whole-system service, not an seL4 kernel primitive. The report must define the user-level VFS/filesystem server, namespace and cache placement, client/server protocol, page sharing or copying, storage backend, scheduling, and cache state. Kernel IPC timing is one possible component cost, not pathname latency. Linux must also be pinned by filesystem, mount options, cache state, kernel build, and workload.

Kernel architectural boundaries and hardware isolation

0 / 4 answered

Evaluate each statement regarding kernel architectural models, device isolation, and hardware authority:

Classify each option as correct or incorrect, or leave uncertain options unanswered (“I don't know”) and verify at any time.

1
An seL4 microkernel system enforces all spatial authority and resource allocation through unforgeable capability tokens.
2
Formally verifying a microkernel proof mathematically guarantees that misconfigured user servers cannot corrupt each other.
3
User-space driver isolation prevents illegal CPU writes but requires an IOMMU to prevent malicious peripheral DMA writes.
4
Monolithic kernels are fundamentally unable to achieve multicore scalability across concurrent file lookup operations.

A comparison protocol

For every claim, fill this chain:

Code
left to right direction
rectangle "workload\ninput, operation mix, concurrency" as W
rectangle "required contract\ncorrectness, latency, isolation" as C
rectangle "mechanism path\ntransitions + shared state" as M
rectangle "trusted boundary\nwho may violate the contract" as T
rectangle "predicted events\nIPC, exits, locks, copies" as P
rectangle "evidence\ntraces, counters, tests, measurements" as E
rectangle "bounded decision\nfor this configuration" as D
W --> C : makes priorities explicit
C --> M : selects relevant path
M --> T : identifies authority/failure
M --> P : produces hypotheses
P --> E : chooses discriminating data
T --> E : chooses adversarial tests
E --> D : supports or rejects claim
workloadinput, operation mix,concurrencyrequired contractcorrectness, latency, isolationmechanism pathtransitions + shared statetrusted boundarywho may violate the contractpredicted eventsIPC, exits, locks, copiesevidencetraces, counters, tests,measurementsbounded decisionfor this configurationmakes priorities explicitselects relevant pathidentifiesauthority/failureproduces hypotheseschooses discriminatingdatachooses adversarialtestssupports or rejects claim

Skipping from system name to decision is a missing argument. Counting transitions without defining what each transition does is also weak: one IPC can batch a page, while one syscall can take several blocking device operations.

Workload A: open and read a hot 4 KiB file

Assumptions:

  • one process opens /data/x, reads 4096 bytes, and closes it;
  • pathname metadata and file data are resident in memory;
  • permissions allow the operation;
  • no concurrent rename or write occurs;
  • no storage I/O or page fault is required; and
  • each configuration uses its normal cached path.

These assumptions isolate naming, open-state creation, cache lookup, and copying. They do not represent cold-cache storage performance.

xv6 trace

user ecall
  -> syscall dispatch
  -> namei walks fixed directory entries under inode locks
  -> filealloc + process descriptor table
  -> read resolves struct file -> inode
  -> readi maps block and obtains buffer-cache block
  -> copyout 4096 bytes
  -> close drops file/inode references

The path is small enough to inspect completely. Linear directory scans, fixed cache capacities, coarse teaching choices, and copy behavior are not production baselines.

Linux trace at the stable abstraction level

open-family syscall
  -> VFS pathname walk through dentry/inode objects and filesystem methods
  -> allocate/install struct file in descriptor table
  -> read-family syscall resolves struct file
  -> filesystem/page-cache read path supplies resident bytes
  -> copy to user and advance open-file position

Linux’s exact functions vary by filesystem, kernel version, flags, and I/O interface. The VFS documents dentries as in-memory pathname components, inodes as filesystem objects, and struct file as the open-file object. RCU-walk and lock/ref-walk can take different pathname paths. A responsible trace records which path occurred rather than treating “VFS” as one instruction.

XNU trace at the open-source boundary

BSD syscall interface
  -> pathname/vnode and file-descriptor mechanisms in BSD subsystem
  -> filesystem vnode operations and resident-data path
  -> VM/unified-buffer integration where configured
  -> copy/result to user task

The XNU source tree composes BSD, Mach VM/IPC, IOKit, and security code in one kernel. “Mach-based” does not imply that a POSIX file read becomes a user-space filesystem IPC. A source-backed analysis must follow the selected XNU build and filesystem.

seL4 component-system trace

No unique trace exists until the architecture is supplied. One candidate is:

client invokes VFS endpoint capability
  -> user-level VFS server resolves cached components
  -> filesystem server or shared cache supplies page/bytes
  -> reply carries data, mapped page, or shared-buffer completion

The seL4 kernel mediates endpoint capability and IPC, scheduling, and mappings. User-level servers define pathname, descriptor, cache, and storage semantics. Copy count and context switches depend on protocol, passive-server/scheduling design, shared-memory policy, and whether VFS and filesystem are one component.

Worked comparison: what can be concluded without timing?

propertysource-backed conclusionunsupported conclusion
xv6 inspectabilitythe whole teaching path and fixed structures can be tracedxv6 is representative of production lookup scale
Linux implementationVFS and filesystem/page-cache paths are in the kernel configurationone kernel crossing means a fixed latency
XNU compositionBSD file mechanisms coexist with Mach/VM/IOKit in XNUevery file operation is a Mach message
seL4 placementfile service semantics live in selected user componentsmicrokernel structure determines exact copies or speed

Application checkpoint: cold-cache reversal

Change only one assumption: data requires storage I/O. Which new mechanisms must enter every comparison, and why can the hot-cache result no longer rank the systems?

Reveal the expanded pathExpand

Add block mapping, request queueing, device driver placement, DMA, interrupts, scheduler blocking/wakeup, read-ahead, filesystem recovery state, and the storage medium. The I/O latency may dominate naming and IPC costs; batching and asynchronous interfaces can reverse a hot-path ranking. Each system’s cache and driver architecture must be specified. A hot-cache measurement cannot estimate cold-device behavior by adding one constant unless that model is validated.

Workload B: a malformed device request

Assume a network or storage driver parses an adversarial descriptor and executes one out-of-bounds write. Compare the first protection boundary that can contain architectural memory corruption.

configurationdriver placement in bounded configurationfirst-order result
xv6kernel address spacekernel state can be corrupted; system integrity is lost
Linux with in-kernel driverkernel address spacecorruption is within kernel TCB; process isolation does not contain it
XNU with in-kernel IOKit driverkernel address spacehybrid label supplies no memory boundary around that driver
seL4 system with user driverseparate address space with bounded capabilitiesprocess memory fault may be contained; service can fail; delegated authority still matters

The seL4 row depends on page mappings, endpoint capabilities, IRQ authority, and DMA. Without an IOMMU or a trusted device that respects bounded DMA, a user-space driver can program a device to overwrite memory outside its address space. Moving code to user space changes CPU page-table protection; it does not automatically constrain devices.

Linux and XNU can also place selected device logic in user space. The right conclusion is that placement and authority, not kernel family name, determine this fault boundary.

Worked design: multi-tenant device gateway

Requirements:

  • untrusted clients submit variable-length commands;
  • one parser crash must not corrupt the scheduler or other tenants;
  • device DMA must reach only per-request buffers;
  • restart within 100 ms is required;
  • steady-state p99 is important but not yet measured.

A defensible initial architecture places parser and policy in an unprivileged component, gives it no direct DMA-programming authority, and uses a small broker/driver with IOMMU-enforced mappings and a restart protocol. seL4 capabilities can express endpoint, frame, and IRQ authority explicitly; a Linux design can use process isolation, descriptors, an IOMMU-aware kernel driver, seccomp/LSM, and a narrow broker protocol.

The choice between them cannot be made from “microkernel” alone. Evidence must include malformed-message tests, component restart state, stale DMA mapping tests, broker TCB review, and p99 measurements under the actual protocol. If formal assurance of the kernel mechanism is a hard requirement and the target board lies in a verified seL4 configuration, that requirement can dominate. If a required production driver exists only in Linux, implementation and verification cost can dominate.

Transfer checkpoint: remove the IOMMU

The same gateway runs on hardware with no IOMMU, and the device accepts arbitrary physical DMA addresses. What authority boundary remains credible?

Reveal the hardware dependencyExpand

CPU page tables still isolate ordinary loads/stores by the user driver, but they do not constrain device DMA programmed with arbitrary physical addresses. The trusted driver or broker must validate every descriptor and be trusted not to program out-of-range DMA; physical bounce buffers or a device with its own enforced bounds may reduce authority. The user-space address-space boundary alone no longer establishes memory containment for device actions.

Workload C: a 64-byte control message

Assume two mutually distrustful services send a request and receive a response. No payload page transfer is needed. Required semantics are one request boundary, authenticated endpoint authority, bounded queueing, and cancellation on peer death.

Mechanism comparison

systemconcrete primitivesemantic questions before timing
xv6pipe byte streamwho frames messages, handles partial reads/writes, and detects peer close?
LinuxUnix-domain socket or pipestream vs datagram/sequence packet, credential passing, descriptor transfer, buffer limits
XNUMach port/messagesend/receive rights, message structure, port death notification, queue limits
seL4endpoint capability and IPCsynchronous rendezvous, capability transfer, badge/authority, scheduling-context behavior

A count of “two context switches” is not portable evidence. A blocked sender may donate or not donate scheduling context; a socket may buffer without scheduling the receiver immediately; a pipe requires application framing; a Mach or seL4 message can carry protected references with different semantics.

Worked protocol selection

The server must never accept requests from a client lacking authority to one object. In a seL4 configuration, give each client an endpoint capability or badged derivation whose possession identifies the authorized channel; validate message length and object-specific protocol state. In Linux, accept over a protected Unix-domain socket, authenticate peer credentials where that policy is meaningful, and pass an already authorized object descriptor rather than a pathname. In XNU, bind authority to appropriate port rights and validate message descriptors. In xv6, the application must build framing and authority atop inherited pipe descriptors and the teaching kernel’s limited policy.

The protocols can implement equivalent high-level policy, but their trusted brokers, delegation semantics, revocation, and failure paths differ.

Boundary checkpoint: shortest path is not safest path

One design removes a broker IPC by mapping the device command queue writable into every client. It measures lower median latency. Identify the authority change and the missing evidence.

Reveal the security/performance tradeExpand

Every client now holds direct mutation authority over shared queue state and possibly device-visible descriptors. A malformed or malicious client can corrupt peers’ requests, violate queue invariants, or program excess DMA unless hardware and layout enforce separation. Required evidence includes per-client ring isolation, descriptor validation, IOMMU mappings, memory-order proof, overload behavior, and adversarial tests. Lower median latency does not compensate for violating the stated authority contract.

Workload D: read-mostly metadata on 64 cores

Assume 99% lookups, 1% insertion/removal, a skewed key distribution, and a target of stable p99 latency through 64 cores.

  • xv6’s small teaching caches and lock structure provide a readable baseline, not a scaling claim.
  • Linux uses several techniques, including RCU in pathname/dentry-related read-mostly paths, fine-grained locks, per-CPU state, and specialized caches; the actual path must be traced.
  • XNU’s current source contains subsystem-specific locks and scalable-memory-reclamation structures; a claim requires tracing the selected path rather than extrapolating from “hybrid.”
  • a seL4 system chooses whether metadata is in one server, sharded servers, shared memory with capabilities, or another arrangement; the kernel does not decide the data structure.

Worked experiment design

For each configuration:

  1. define identical abstract operations and key distribution;
  2. verify semantic equivalence, including update visibility and failure;
  3. pin core affinity, topology, memory placement, and interrupt handling;
  4. measure 1, 2, 4, 8, 16, 32, and 64 cores with repeated trials;
  5. report throughput, latency distribution, CPU time, migrations, cache/coherence indicators where valid, and IPC/lock traces;
  6. inspect the hottest serialized state; and
  7. run a controlled redesign or workload-shape change predicted to affect it.

If one system batches 100 lookups per IPC while another issues one syscall per lookup, report both operation and transition counts. “IPC count” is not a workload-normalized metric.

Architecture labels fail as predictors

Counterexamples to architectural taxonomy:

Taxonomy label assumptionConcrete counterexampleUnderlying mechanism causing the reversal
“Microkernels guarantee driver fault isolation”User-space driver without an IOMMU corrupts kernel RAMUnrestricted peripheral DMA bypasses CPU MMU page tables
“Monolithic kernels cannot scale pathname lookup”Linux VFS pathname walk scales across 64 coresLockless RCU traversal avoids writes to shared cache lines
“Microkernel IPC is always the dominant latency bottleneck”Batched IPC server outperforms single-syscall pathAmortizing message-passing cost across multi-block transfers
“Formally verified kernels guarantee total application safety”Verified kernel running misconfigured user serversProof assumes correct hardware, configuration, and user capability policy
“Monolithic kernels expose every subsystem bug to every process”Local unprivileged container cannot reach network parserNamespace filtering and seccomp remove vulnerable syscall entry paths

The comparison target is always the end-to-end trusted and executed path.

Section Exercises

Deep Practice

Solve these problems to test and consolidate your understanding. Complete worked solutions and diagnostic hints are available for each problem.

Exercise 7.5.1: Contrasting Monolithic and Microkernel Control Transfer Paths

Verificationapplication

A user application invokes a file read operation (read(fd, buf, 4096)). Compare the sequence of privilege transitions, context switches, and cache effects under:

  1. A monolithic kernel (such as Linux or xv6), and
  2. A classical microkernel (such as seL4 or Mach) where the file system executes in an independent user-space server task. Count the minimum number of user-kernel boundary crossings and address-space switches incurred by each architecture.
HintExpand

In a monolithic kernel, the syscall handler executes within the kernel address space. In a microkernel, client IPC to server and server reply to client each pass through the kernel.

Worked solutionExpand
  1. Monolithic path:

    • Client executes a trap instruction (ecall / syscall): User →\to Kernel transition.
    • The kernel resolves the descriptor, accesses the page cache / VFS in kernel mode, copies 4096 bytes directly to user buffer buf.
    • Kernel executes sret / sysret: Kernel →\to User transition.
    • Metrics: Exactly 2 privilege transitions (U -> K -> U), 0 address-space context switches (page table root register satp / CR3 does not change), minimal TLB invalidations.
  2. Microkernel path:

    • Client sends synchronous IPC to VFS server: User →\to Kernel trap (Transition 1).
    • Microkernel transfers IPC message, switches address space from Client to VFS Server: satp/CR3 switch (Switch 1), resumes VFS server in user space (Transition 2).
    • VFS server processes request, accesses buffer/disk, and sends IPC reply: User →\to Kernel trap (Transition 3).
    • Microkernel transfers reply data, switches address space from VFS Server back to Client: satp/CR3 switch (Switch 2), resumes Client in user space (Transition 4).
    • Metrics: At least 4 privilege transitions (U -> K -> U -> K -> U), 2 full address-space context switches, and potential TLB/cache eviction overhead depending on tagged TLB hardware support.

Exercise 7.5.2: Tracing seL4 Capability Invocation and IPC Message Transfer

Constructionapplication

In seL4, all kernel services are invoked via capabilities stored in per-thread C-nodes. Describe how a client thread initiates a synchronous rendezvous IPC with a server thread listening on an Endpoint object:

  1. The capability token checked by the kernel,
  2. The transfer of small message payloads via hardware CPU registers, and
  3. The generation and transmission of an unforgeable Reply capability to the server.
HintExpand

Explain how the kernel validates the Endpoint capability rights, copies register-sized arguments directly, and creates a single-use Reply capability.

Worked solutionExpand
  1. Capability validation: The client loads an Endpoint capability index from its C-space into a CPU register and invokes seL4_Call(ep_cap, msg_info). The kernel trap handler decodes the capability: it verifies that ep_cap points to a valid kernel Endpoint object and possesses the Write (or Call) right. If invalid or rights are missing, the kernel faults or returns an error.
  2. Direct register message passing: If the server is already blocked waiting on the Endpoint (seL4_Recv), the kernel performs a direct thread switch. For short messages (up to 4–8 words depending on ISA), the kernel transfers the message words directly across CPU argument registers (a2-a7 on RISC-V) without copying through kernel memory buffers.
  3. Reply capability issuance: Because the client invoked seL4_Call (a call-reply pattern), the kernel transitions the client to the BlockedOnReply state and automatically mints a transient, single-use Reply capability placed into the server thread’s designated C-slot. When the server finishes processing, it invokes seL4_Send on that Reply capability, waking the client, returning the result, and invalidating the Reply capability.

Exercise 7.5.3: Comparing Trusted Computing Base Footprints and Verification Tractability

Descriptionapplication

Evaluate the trade-off between Trusted Computing Base (TCB) size and system verification feasibility:

  1. Compare the lines of code (LoC) of the seL4 microkernel (~10,000 lines) with a general-purpose Linux kernel (~30+ million lines).
  2. Explain why end-to-end formal verification (such as the Isabelle/HOL functional correctness, integrity, and confidentiality proofs achieved for seL4) is tractable for seL4 but intractable for monolithic production kernels.
  3. Discuss what remains outside the verified boundary in a complete running seL4-based operating system.
HintExpand

Focus on state space explosion, concurrency complexity, device driver volume, and user-space policy servers.

Worked solutionExpand
  1. TCB scale difference: seL4 comprises approximately 10,000 lines of verified C code and assembly, maintaining a strictly minimized kernel state space. In contrast, a typical Linux distribution kernel exceeds 30 million lines of C, where drivers, filesystems, network protocols, and scheduling policies all reside in supervisor mode.
  2. Verification tractability:
    • Formal verification requires constructing mathematical proofs of refinement from abstract specification to executable binary. State space explosion makes automated and interactive theorem proving scale non-linearly with lines of code, concurrency interleavings, and unstructured pointers.
    • seL4 is deliberately single-threaded in the kernel (with event-driven preemption points or fine-grained multicore models), restricts dynamic memory allocation to capability retyping of user-provided untyped memory, and avoids in-kernel complexity.
    • In Linux, complex preemptible RCU subsystems, dynamic locking graphs, heterogeneous device drivers, and continuous code churn render complete formal proof mathematically intractable with current proof technology.
  3. Unverified residual boundary: Formal proof of seL4 guarantees only that the microkernel binary adheres to its specification under the assumed hardware model. It does not verify: hardware errata / CPU microarchitectural side-channels, board firmware / bootloaders, device firmware, or the application/server logic running in user space (for example, a buggy user-space file server can still leak its own files).

Exercise 7.5.4: Analyzing Unikernel Attack Surfaces and Single-Address-Space Boundaries

Formalisationtransfer

A unikernel (such as MirageOS or OSv) compiles a single specialized application together with minimal operating system library routines into a single binary running in a single address space at Ring 0 inside a hardware virtual machine (VM).

  1. Formalize the isolation boundary: what protects two distinct unikernel instances running on the same physical host?
  2. Compare the attack surface of an application running as a Linux container versus the same application running as a unikernel within a type-1 hypervisor.
  3. State one major operational disadvantage of unikernels regarding observability and debugging.
HintExpand

Contrast hardware hypervisor VM isolation (EPT/NPT) against Linux kernel system call attack surfaces, and note the absence of user/kernel boundary tools like gdb or ptrace.

Worked solutionExpand
  1. Formal isolation boundary: Within the unikernel instance, there is no spatial or privilege boundary: application logic and kernel library code execute at the identical privilege level (e.g., Ring 0 / S-mode) sharing one page table. Isolation between distinct unikernel instances is enforced entirely by the underlying hardware hypervisor (Type-1 or Type-2) using Second-Level Address Translation (Intel EPT / AMD NPT) and VMCS/VMCB hardware virtualization controls.
  2. Attack surface comparison:
    • In a Linux container, all containers share a single host kernel image. A vulnerability in any of the ~400+ host system calls, ioctl handlers, or network stack parsers allows container breakout to the host kernel.
    • In a unikernel, the guest cannot attack host kernel system calls because no host system call interface exists inside the guest. The hypervisor exposes a drastically narrower hypercall interface and virtual device emulation layer, substantially reducing the breakout attack surface.
  3. Operational disadvantage: Because a unikernel lacks multi-process abstractions, interactive shells (bash), and standard debugging infrastructure (ptrace, gdb, ps, /proc), inspecting runtime state, attaching debuggers, or applying live hot-patches is extremely difficult. Diagnosing production crashes requires external hypervisor memory inspection or rebuilding the whole binary.

Exercise 7.5.5: Proving Subsystem Fault Isolation in Microkernel Architectures

Proofsynthesis

Let a system consist of microkernel KK user application process AA file system server FF and device driver DD each residing in distinct address spaces SK,SA,SF,SDS_K, S_A, S_F, S_D Communication occurs solely via message passing across kernel endpoints EAFE_{AF} and EFDE_{FD} Hardware includes an MMU and an IOMMU configured such that peripheral PP controlled by DD can only DMA into memory mapped within SDS_D

  1. Prove that an arbitrary control-flow hijack or fatal memory fault in driver DD cannot alter the persistent file metadata state maintained in SFS_F without transmitting a semantically valid IPC message across EFDE_{FD}
  2. Specify the exact failure mode that occurs if the IOMMU is absent or disabled.
HintExpand

Formulate the invariants enforced by the MMU page tables, IOMMU DMA translation, and kernel capability enforcement.

Worked solutionExpand
  1. Proof of subsystem isolation:
    • Spatial CPU isolation: By MMU construction, the CPU page table for SDS_D maps only memory frames allocated to DD Frames backing SFS_F and SKS_K are either unmapped or marked invalid in DD‘s page table. Therefore, no CPU instruction executed by DD (even under arbitrary control-flow hijacking) can read or write memory in SFS_F directly via load/store instructions.
    • DMA peripheral isolation: Because the IOMMU translation tables for peripheral PP map only the DMA buffer frames assigned to SDS_D peripheral PP cannot write to SFS_F frames via direct memory access over the system bus.
    • Kernel control isolation: Control transfers between SDS_D and SFS_F are mediated exclusively by microkernel KK via endpoint EFDE_{FD} The kernel delivers messages to FF only if DD executes a valid kernel trap with a valid capability to EFDE_{FD}
    • Conclusion: Because DD‘s instructions cannot access SFS_F‘s memory directly and DD‘s peripheral cannot DMA into SFS_F‘s memory, the internal state of FF can change solely in response to messages received through EFDE_{FD} If FF‘s protocol rejects malformed or unauthenticated requests, corrupted state in DD cannot arbitrarily corrupt FF‘s metadata.
  2. Absence of IOMMU failure mode: If the IOMMU is absent, peripheral PP issues DMA writes with raw physical bus addresses. A compromised or malfunctioning driver DD can program PP‘s DMA target register to point directly to physical frames holding SFS_F or SKS_K memory, completely bypassing CPU MMU protections and corrupting file metadata or kernel code without sending any IPC message.

References & Further Reading