Skip to content

Guest Support ​

RVM paravirtualizes RTOS kernels with drop-in port layers: the guest library mirrors the relative layout of each official RTOS tree and contains only the files that were added — official kernel files are never included or modified, so a plain overlay is always safe.

Support matrix ​

GuestVersionStatusARMv6-MARMv7-MRV32GToolchains
RMPlatestPractical✅✅✅Keil, IAR, GCC
FreeRTOSV9.0.0Practical✅✅✅Keil, IAR, GCC
uC/OS-IIV2.93Practical✅✅✅Keil, IAR, GCC
uC/OS-IIIV3.08.02Practical✅✅✅Keil, IAR, GCC
RT-ThreadV4.1.1Practical✅✅✅Keil, IAR, GCC
ChibiOS21.11.6Practical✅✅✅Keil, IAR, GCC
RTEMS7.0-rc1Practical—✅—GCC
Zephyr3.7.0 LTSPractical—✅—GCC
NuttX13.1.0Practical—✅—GCC
DjyOSV1.1.0Commemorative—✅—GCC
KLiteV5.2.1Commemorative—✅—GCC
  • Practical ports are production ports; the ✅ columns show each port's verified architectures and toolchains, and every practical port is measured in the benchmark tables. RTEMS, Zephyr and NuttX target ARMv7-M with GCC, verified on the H743 and F429 boards; their benchmark rows are on the H743. ChibiOS covers the same three architectures and three toolchains as the classic guests, verified on the G071, H743, F429 and CH32V307 boards.
  • Commemorative ports are memorial single-combination ports (Cortex-M7 + GCC + STM32H743ZIT6). They demonstrate the porting technique on kernels with a fixed single combination.
  • RMP is not distributed in the guest library: it carries its RVM platform layers natively (Source/Platform/*_RVM/ in the RMP tree) and needs no guest-side packaging.

Evaluation boards

Cortex-M0+: STM32G071RBT6 · Cortex-M4: STM32F429ZIT6 · Cortex-M7: STM32H743ZIT6 · RV32IMAC: CH32V307VCT6

Per-guest notes ​

RMP ​

EDI's own real-time kernel. It defines the original RVM switch template that every other port transplants: locked-state yield requests become a kernel pend flag replayed at unlock, so the port only ever sees unmasked, immediate switch requests.

FreeRTOS (FRT) ​

A software deferred-yield that mimics the official PendSV pend via a nesting counter. configUSE_RVM_OPTIMISED_YIELD selects between the task-stack fast path and the pure-hypercall yield (which costs ~4x Yield latency with identical semantics); on RV32P, configUSE_PORT_RVF/configUSE_PORT_RVD select the FPU frame width.

uC/OS-II (UO2) ​

Self-contained (no uC-CPU/uC-LIB). OS_CPU_SR_Save/Restore map onto the RVM virtual interrupt mask snapshot; clean frames take the assembly fast path, dirty ones the yield hypercall. Kernel objects must be created from a task context, so applications boot from an init task.

uC/OS-III (UO3) ​

OS_CFG_RVM_FAST_YIELD_EN toggles the same fast/hypercall trade-off as FreeRTOS. The direct switch always lands the incoming task unmasked, preserving the kernel's Disable; Yield; Enable contract.

RT-Thread (RTT) ​

Fast path for clean frames, deferred hypercall path for dirty ICI/IT frames. Requires RT_USING_LIBC. On RV32P the port is GCC-only.

DjyOS (DJY) ​

DjyOS schedules events; every switch runs inside the kernel's async-signal mask. The port hosts all threads in one RVM user thread and masquerades contexts as 22-word exception frames. The guest must be compiled with -mfloat-abi=soft.

KLite (KLT) ​

The always-deferred kernel shape: cpu_contex_switch() only pends, and the outermost cpu_leave_critical() consumes the pend through a yield dispatcher with a masquerade fast path. Selected in the project generator with the -klt flag.

ChibiOS (CHB) ​

ChibiOS 21.11.6 LTS runs as an unprivileged RVM user thread with its own scheduler and chconf.h. The port adds two architecture directories, os/common/ports/ARMv7-M-RVM and RV32P-RVM (plus ARMv6-M-RVM for M0+), without touching the ChibiOS kernel. Clean task frames take a direct task-stack fast path; dirty or vector-captured frames go through the virtual context handler, and idle parks in RVM_Hyp_Vct_Wait(). ARMv7-M supports GCC, IAR EWARM and Keil MDK; RV32P is GCC-only. Verified with FPU frames on H743 and F429, basic frames on G071, and RVF frames on CH32V307. CHB_FAST_PATH=0 builds the all-vector variant.

RTEMS (RTE) ​

RTEMS 7.0-rc1 runs as an unprivileged RVM user thread. The port is distributed as the RTEMS_V701 BSP/spec/sample overlay for an official RTEMS tree, not a standalone tree. The task-level switch uses a 22-word basic frame (56-word extended frame with FPU) and a direct task-stack fast path; dirty or ISR-captured frames are handed to the Vct context handler. Setting RTE_FAST_PATH=False compiles out the fast path and routes every switch through the vector thread. The BSP keeps its fixed -O2 optimisation level. RTE_CPU_FLAGS selects Cortex-M4F or Cortex-M7; FPU frames are implemented and the two-task FPU test passes on H743. The full 15-item benchmark lives in the RTE chip test headers.

Zephyr (ZPR) ​

Zephyr 3.7.0 LTS runs as an unprivileged RVM user thread through the arch/arm/core/cortex_m/v7m_rvm/ arch port; upstream Cortex-M sources are untouched and the build selects the new port. The generator writes a per-VM zpr_board.dts for the single virtual armv7m board and passes it as DTS_SOURCE; no STM32 dtsi, RCC/PLL or peripheral nodes are involved. Normal ZPR images use the native benchmark process as the TIM4 heartbeat, so a normal guest never registers or rewrites TIM4. The context layer supports 22-word basic and 56-word FPU-extended frames; FPU preemption passes on H743 with both fast-path and all-Vct builds, and on F429 with the fast path. The port requires !SMP, !USERSPACE, !ARM_MPU, !CORTEX_M_SYSTICK, !TICKLESS_KERNEL and !GEN_ISR_TABLES. The benchmark exercises the common 15-item subset.

NuttX (NTX) ​

NuttX 13.1.0 runs as an unprivileged RVM user thread in a flat build. The port lives in arch/arm/src/armv7-m-rvm/ behind the chip-agnostic armv7-m-rvm/ntx board (virt for Cortex-M7, virt-m4 for Cortex-M4). A yield only posts the switch flag; the masquerade frame (22 words, 56 with FPU) is built on the task stack, and CONFIG_ARMV7M_RVM_FAST_PATH selects the direct stack-swap path for clean frames. No userspace, MPU, SMP, tickless mode or physical NVIC. The benchmark covers the nine NuttX-native rows — FIFO and event notification are absent because NuttX has no such primitives.

Port contracts ​

Every port implements the same five-part job — critical sections, yield, context switch, interrupt delivery hooks and startup — while each kernel guarantees something different. The full contract/strategy analysis for each guest (including the interrupt model's three-layer gate and frame interchangeability) lives in the GUEST.md document in the repository.

For installation (tree overlay) and project generation, see Getting Started.

An official work of EDI, released into the public domain.

GitHub·Discord·QQ 群 1038895132·rtospro.com