Abstract
Real-Time Application Interface (RTAI) is a real-time Linux implementation based on
RTLinux. It adds a small real-time kernel below the standard Linux kernel and treats the
Linux kernel as a low priority real-time task. RTAI provides a large selection of inter-process
communication mechanisms and other real-time services. Additionally, RTAI provides a
LXRT module for easy developement of real-time applications in user space. LXRT makes
it possible to dynamically switch between real-time and non-real-time operation in the userspace.
Finally, we give a small example of using RTAI and LXRT.
1 Introduction
Linux operating system is gaining popularity in research and student communities, and lately
also in the business world. Linux is a multitasking system, which provides fair, non-preemptive
scheduling among several dynamically created and deleted processes. The disadvantage of Linux
is that it can not guarantee response times for its processes. However, there are application areas
which require real-time response, such as robotic devices, computers used in health care and
military, and various embedded systems used in different kinds of devices.
There are several commercial hard real-time operating systems available, such as QNX [Hil],
AMX [Kad], RTKernel [On ], which are small and convenient to be used in embedded systems, for
example. However, some developers and researchers have pointed out that while there are needs
for hard real-time, it would be useful to have the various device drivers, networking protocols, and
other features offered by Linux also available.
For the above-presented needs, several Real-Time Linux implementations have been presented
(KURT [NDH99], Linux/RK [OR99], etc.). Perhaps the best known solution is RTLinux [BY97]
which has been used as a basis for many other real-time Linux solutions. RTLinux inserts a small
real-time kernel below the standard Linux kernel and treats the Linux kernel as one of the real-time
2 RTAI FUNDAMENTALS 2
processes. The disadvantage of this approach is that the real-time tasks operate in kernel-space
and in case of software bug they may cause substantial harm.
One of the solutions based on RTLinux is Real-Time Application Interface (RTAI) developed
in the Milan Polytechnic, which we describe in this presentation. Of the available Real-Time
Linux solutions it claims to be one of the most actively updated and maintained. Currently RTAI
patches exist for Linux 2.2 and Linux 2.4 and new features for RTAI are being constantly developed.
The most important features of RTAI include various flexible inter-process communication
methods and a symmetrical API allowing creation of real-time tasks in the user-space, avoiding
the disadvantage of operating in the kernel-space.
Rest of this presentation is organized as follows. Section 2 describes the architecture and the
fundamental concepts of RTAI. Some of the important features of RTAI are briefly described in
Section 3. Section 4 describes LXRT, which is a common API for both real-time tasks and userspace
processes. LXRT provides the means for implementing real-time tasks in user-space, and is
hence one of the most important features of RTAI. Before we conclude, a simple example of how
to construct a simple real-time application with LXRT and RTAI is given in Section 5.
2 RTAI Fundamentals
RTAI [Clo00, Lin00] has similar architecture to RTLinux [BY97]. Like RTLinux, RTAI treats the
conventional Linux kernel as a low-priority real-time task, which may do its normal operations
whenever there are no higher priority real-time tasks running. In the basic RTAI operation the
real-time tasks are implemented as Linux kernel modules, similarly to RTLinux. RTAI handles
the interrupts from peripherals and dispatches the interrupts to Linux kernel after handling the
possible real-time actions triggered by the interrupts.
Figure 1 shows the basic architecture of RTAI, which is rather similar to RTLinux architecture.
There are interrupts originating from processor and peripherals, of which processor originated interrupts
(mainly error signals such as division error) are still handled by the standard Linux kernel
but the interrupts from the peripherals (e.g. timer) are handled by RTAI’s Interrupt dispatcher.
The RTAI forwards the interrupts to the standard Linux kernel handlers (Hardware management
in Figure 1) when there no active real-time tasks. The interrupt disabling and enabling instructions
(cli()/sti()) in Linux kernel are replaced by macros that forward the instructions to RTAI.
When interrupts are disabled in the standard kernel, RTAI queues the interrupts to be delivered
after the Linux kernel has enabled the interrupts again.
Additionally Figure 1 shows inter-process communication mechanisms, which are implemented
separately for Linux and for RTAI. The communication mechanisms of RTAI are described
in more detail in Section 3. Also the scheduler exists separately for Linux side


Download full report
http://cse.iitb.ac~cs684/RTATutors/rtai.pdf