The answer requires understanding one architectural decision ARM made that is genuinely elegant: KVM and RMM are two different hypervisors, running in two different security worlds, with a deliberate and principled split of authority between them.
ARM's architecture specification explicitly documents the design principle (verified from official ARM documentation):
KVM remains the resource scheduler — it decides which physical pages a Realm gets, which pCPUs run which vCPUs, which devices are assigned. KVM retains full control plane authority. What KVM loses is data plane authority — once pages are delegated to the Realm, KVM cannot observe or modify what is in them.
Stated simply: KVM is the landlord who allocates rooms. RMM is the locksmith who changes the locks once a tenant moves in. The landlord cannot enter after the lock is changed — not by policy, but because the hardware key no longer works for them.
When KVM decides to give physical pages to a Realm VM, it calls RMI_GRANULE_DELEGATE via SMC. The CPU traps to EL3 (Root Monitor). The Root Monitor updates the GPT for those pages: GPI_NS → GPI_REALM. The Root Monitor then switches to RMM at Realm EL2 to complete the operation.
KVM (Normal EL2) │ SMC: RMI_GRANULE_DELEGATE(page_PA) ▼ Root Monitor (EL3) │ Updates GPT: page_PA → GPI_REALM │ Switches to Realm EL2 ▼ RMM (Realm EL2) │ Receives delegation, assigns to Realm VM │ Updates RTTs (Realm Translation Tables) ▼ Page is now Realm PAS Any Normal world access → GPC fault (hardware, immediate) KVM cannot read, write, or remap this page
One important nuance verified from the Linux kernel patch series: KVM can destroy a Realm VM at any time, which forces undelgation of all its pages back to NS PAS. KVM retains lifecycle authority (create and destroy) — it loses memory-access authority during the lifetime of a running Realm.
Because KVM cannot access Realm memory, standard virtio I/O (which relies on the hypervisor reading and writing guest buffers) cannot work directly. The solution inverts the traditional authority model in an elegant way:
The Realm VM itself decides which pages to make available for I/O. Using the RSI (Realm Services Interface) — a call from Realm EL1/EL0 up to RMM at Realm EL2 — the guest can transition specific pages from Realm PAS to NS PAS (GPI_NS), making them accessible to the hypervisor for device I/O.
Realm VM (R-EL1) │ RSI_IPA_STATE_SET(buffer_page, NS) ▼ RMM (R-EL2) │ SMC to Root Monitor ▼ Root Monitor (EL3) │ Updates GPT: buffer_page → GPI_NONSECURE ▼ KVM can now DMA device ↔ buffer_page Realm VM retains control — it chose which page to share KVM cannot pull pages out; Realm pushes them out
The Granule Protection Check (GPC) fires at the output of every MMU and SMMU translation — both stage 1 and stage 2, for both CPU and DMA. When any translation produces a physical address, the GPC looks up that PA in the GPT. If the accessing security world does not match the GPT entry, a Granule Protection Fault occurs.
This maps directly into the framework:
| Mechanism | Identity | Resource | Side | Granularity |
|---|---|---|---|---|
| TZASC / TZC-400 | HNONSEC (binary S/NS) | DRAM range | Target | Configurable ranges |
| MPC (STM32) | HNONSEC (binary S/NS) | SRAM block | Target | 256–512 B per block |
| GPT/GPC (ARM CCA) | Security world (NS/Realm/Secure/Root) | Physical granule | Target | 4 KB per granule |
| AMD SEV-SNP RMP | ASID (per-VM) | Physical page | Target | 4 KB per page |
| Operation | KVM can? | Mechanism that enforces |
|---|---|---|
| Create a Realm VM | ✅ Yes | KVM calls RMI_REALM_CREATE via SMC |
| Schedule Realm VM vCPU | ✅ Yes | KVM calls RMI_REC_ENTER |
| Assign physical pages to Realm | ✅ Yes (delegate) | RMI_GRANULE_DELEGATE → GPT update by Root Monitor |
| Provide virtio I/O devices | ✅ Yes (via shared NS pages) | Realm VM must explicitly RSI-share pages first |
| Destroy Realm VM | ✅ Yes (any time) | KVM calls RMI_REALM_DESTROY → forces undelegation |
| Read Realm VM memory | ❌ No | GPT = GPI_REALM → GPC fault on any NS access |
| Modify Realm VM page tables | ❌ No | RTTs managed exclusively by RMM at Realm EL2 |
| Observe Realm VM register state | ❌ No | CPU register state protected during world switch |
| Forge Realm attestation token | ❌ No | Signed by Root Monitor with platform private key |
| Remap a Realm page to another VM | ❌ No | GPT = GPI_REALM → NS access faults; only Root Monitor updates GPT |
The Realm VM's attestation is managed entirely within the trusted components — RMM and Root Monitor. KVM and the host OS are not in the attestation path at all.
Realm VM (R-EL1) requests attestation:
RSI_ATTESTATION_TOKEN_INIT (nonce from relying party)
RSI_ATTESTATION_TOKEN_CONTINUE
│
▼
RMM (R-EL2) collects measurements:
RIM — Realm Initial Measurement (initial image digest)
REM — Realm Extensible Measurement (runtime measurements)
RMM measurement itself (measured at boot by Root Monitor)
│
▼
Root Monitor (EL3) signs the token:
Platform private key (device certificate chain)
Produces: CCA token (CBOR, per IETF RATS RFC 9334)
│
▼
Token returned to Realm VM → forwarded to relying party
TCB components visible in attestation:
• CPU hardware (RME extension)
• Root Monitor (TF-A, measured at boot)
• RMM (measured, in attestation token)
• Realm VM initial image (RIM)
NOT in TCB:
• KVM ← removed from trust path entirely
• Host Linux
• Other Realm VMs
• Other guest VMs in Normal world
| Property | ARM CCA (Realm) | AMD SEV-SNP | Intel SGX |
|---|---|---|---|
| Isolation granularity | VM-level (Realm VM) | VM-level | Process-level (enclave) |
| Memory protection mechanism | GPT/GPC at 4KB | RMP at 4KB | EPCM at 4KB |
| Mechanism side | Target (GPC at translation output) | Target (RMP at walk end) | Target (EPCM on EPC access) |
| Hypervisor in TCB? | No (KVM excluded) | No (hypervisor excluded) | N/A (process-level) |
| Trusted component | RMM (Realm EL2) + Root Monitor | AMD Secure Processor | CPU enclave mode |
| Memory encryption | Implementation-defined (not mandated) | Mandatory (per-VM AES key) | Mandatory (MEE) |
| Intra-VM privilege levels | R-EL0/EL1/EL2 | VMPL 0–3 | N/A |
| Device DMA to private memory | Via SMMU GPC + TDISP (in development) | Via AMD IOMMU + RMP | Not supported (EPC is CPU-internal) |
| Entry point enforcement | World switch (hardware) | VMGEXIT (hardware) | ECALL via EENTER (SG-equivalent) |
ARM CCA's hardware architecture specification states that isolation is enforced "by faulting exceptions and by physical memory encryption." However — this is an important nuance — memory encryption is implementation-defined, not architecturally mandated by the CCA specification. A compliant CCA implementation can exist without inline DRAM encryption, relying solely on GPT/GPC for isolation.
This contrasts with AMD SEV-SNP, where per-VM AES-128 encryption is a core architectural feature, not optional. For deployments where physical DRAM probing is in the threat model, the presence or absence of inline memory encryption is an important platform selection criterion, not something guaranteed by the CCA logo.
Licensed under CC BY 4.0.