<div class='slidealt'>Experience kvm <a title='virtualization for embedded heterogeneous arm core platforms' href='/en/products'>virtualization extensions</a></div> <div class='slidealt'>Benefit from custom <a title='kvm on arm services full virtualization' href='/en/services'>virtualization services</a></div> <div class='slidealt'>KVM on ARMv7 and ARMv8 <a title='kvm-on-arm open source smu extensions' href='/en/solutions/guides/vfio-on-arm/'>IOMMU full virtualization</a></div> <div class='slidealt'>Virtualization research projects <a title='ARM multicore kvm open source' href='/en/research'>in cloud and embedded systems</a></div> <div class='slidealt'>Virtualization solutions for heterogeneous <a title='ARMv7-ARMv8 virtualization open source solutions' href='/en/solutions'>ARM multicore systems</a></div>

RTOS with KVM Virtualized GPOS co-Execution for ARMv8 Architecture

How to run concurrently a RTOS and a KVM GPOS on Juno 64-bit ARM Platform

An important trend in the design of embedded systems is the integration of applications with different levels of criticality on multi-core heterogeneous hardware platforms. ECUs integration in automotive marketplace is a good example of such a mixed criticality system, aiming to meet stringent requirements related to latency, performance, cost, space, weight and power consumption. In fact, ethernet/vSwitch-centric gateways in a connected car executes safety-critical functions (e.g., break, electric-assist steering, etc.) that have to be securely isolated from In-Vehicle Infotainment (IVI) functionalities, while running on a multi-core SoC.

To support such type of mixed-criticality use-cases, Virtual Open Systems has developed KVM virtualization extensions and a TrustZone-enabling custom monitor layer to showcase through this step by step guide how to run concurrently a Real Time Operating System (RTOS) and a General Purpose Operating System (GPOS) on a real ARMv8 hardware target.

Introduction to ALS mixed-criticality PoC - concurrent RTOS and virtualized GPOS

Virtual Open Systems, official sponsor at the Tokyo Automotive Linux Summit (ALS) 2015, a Linux Foundation event, has showcased a Proof of Concept (PoC) of a RTOS and a GPOS concurrently executed on the ARMv8 Juno development platform, an ARMv8 architecture with two Cortex-A57 running at 1.2GHz, and four Cortex-A53 at 650MHz. The two Operating Systems (OSes) are executed within an ARM TrustZone environment which defines two execution worlds, a normal world and a secure world which are completely isolated each other.

The RTOS used in this PoC is a custom port to Juno board of a 32-bit FreeRTOS, which has been adapted by Virtual Open Systems. It executes, in the TrustZone Secure world (S-EL1 exception level), different tasks to control sequentially hardware LEDs available in the Juno, located under the board chassis; on the other hand, as GPOS, a Linux kernel version 4.0 with KVM virtualization extension enabled is executed in the TrustZone Normal world (NS-EL1 exception level). Thanks to KVM virtualization, the GPOS is able to run different virtual machines in parallel such as Tizen, Android.


This guide doesn't describe the process to virtualize a guest on the host Linux, however information about how to enable KVM Virtualization can be found on the Virtual Open Systems' Kvm on armv8 guide.

To manage the CPU resources and context switches between these two OSes, Virtual Open Systems has extended Arm Trusted Firmware (ATF). This extended software layer, called herewith VOSYS-custom-ATF, is a key part of the system, as it is able to stop the execution of one world to prioritize the other (Quality of Service), depending on the specific interrupt occurred.


In this guide we refer to ARM64, ARMv8 or aarch64 as the same architecture.

PoC Requirements to enable RTOS with KVM Linux

This guide is mainly based on the ARM Juno Development board and Ubuntu 14.04 (code name Trusty). However, all the software tools used hereinafter are also available for other Linux distributions, such as Debian and Fedora. Additional requirements are:

bullet 2 Converters UART/USB, 2 UART cables, 1 Ethernet cable, 1 USB cable TypeA/TypeB

bullet Personal computer with Ubuntu 14.04 or similar distribution

bullet 64-bit ARM cross compiler The cross compiler used to compile toward the ARMv8 64bit architecture

bullet 32-bits GCC cross compiler for bare metal application on ARM Cortex-A/R/M processors


The JUNO ARM Development Platform

Install and set up an execution environment

This section describes how to install an execution environment and to set up the Juno ARM development platform.

How to get the 64-bit and 32-bit bare metal ARM cross compiler

First of all, there is a need to install ARM cross compilers, which will be used to compile ARM applications on an x86 workstation. To install them, run the following commands:

$ sudo apt-get install gcc-aarch64-linux-gnu
$ sudo apt-get install gcc-arm-none-eabi

Then, to test if the compilers have been correctly added to the PATH environmental variable, type:

$ which aarch64-linux-gnu-gcc
  < You should get the compiler path here >
$ which arm-none-eabi-gcc
  < You should get the compiler path here >

How to install serial communication and versioning tools

At this point, in order to receive UART data from the JUNO board, a serial communication tool, such as minicom, is necessary. Similarly, GIT, the Linux versioning tool used by developers to retrieve the kernel code is needed to download the sources used in this guide. To install them, run:

$ sudo apt-get install minicom
$ sudo apt-get install git

User-space NFS Image for the Host

Network File System (NFS) allows to access the ARM host filesystem from the development workstation even when the Juno board is not running. For this flexibility, NFS will be used in the next sections with OpenEmbedded (Minimal), a linaro pre-configured image (linaro-image-minimal-genericarmv8-20140223-649.rootfs.tar.gz).

In order to export a directory through NFS, we have to install the NFS service, which is available in almost all Linux distributions. For instance, in Ubuntu, it can be installed as it follows:

$ sudo apt-get install nfs-kernel-server nfs-common

At this point, /srv/nfsroot, the folder that will serve the ARM Host image, can be created and populated with the host filesystem:

$ sudo mkdir -p /srv/nfsroot/
$ sudo tar -xf linaro-image-minimal-genericarmv8-20130526-319.rootfs.tar.gz \
            -C /srv/nfsroot/

Moreover, to make it available for the Juno, the NFS configuration file /etc/exports needs to be modified in the following manner:

$ /srv/nfsroot,sync,no_root_squash,no_subtree_check,insecure)

Then, to apply the new configuration, restart the NFS server:

$ sudo service nfs-kernel-server restart

Preparing the Juno board

Once the necessary software tools have been installed as instructed, the Juno board must be connected to the workstation and the serial link must be correctly set to enable the communication between hardware peripherals.


Virtual Open Systems is not responsible for any damage which might be caused to your platform while following the instructions below. While the content of this guide has been tested thoroughly, Virtual Open Systems cannot guarantee for any potential user errors which may harm the target platform.

bullet Connect two UART cables on UART ports of the Juno platform, that you link on the converter UART/USB to connect the USB to your computer

bullet Connect the USB TypeB connector on the Juno board and the USB TypeA connector on your computer

bullet Link the Juno ARM Development Platform to the network by connecting the ethernet cable

bullet Plug the 12 volt power supply to the board

Login or register to access full information