Collections of Apollo Kernels
Switch branches/tags
Nothing to show
Clone or download
Latest commit e5d431f Aug 8, 2018

Apollo Kernel

The Apollo Kernel provides the necessary kernel level support to run Apollo software stack. In the first release, we add the most popular solution, Linux Kernel, under the linux directory.

Linux Kernel

Apollo Linux Kernel is based on official Linux Kernel 4.4.32 with some modifications.

What is the difference

Kernel config files are modified for Apollo based on Ubuntu's config-4.4.0-X-generic.

The Apollo team would like to thank everybody in the open source community. The GitHub apollo-kernel/linux is based on Linux. Currently, Apollo team maintains this repository. In near future, we’ll send patches back to Linux community.

Add ESD CAN Support

You will need to add ESD CAN driver to run Apollo software using ESD CAN card. Please refer to linux/ for more information.

How to Download the Release Package

Download the release packages from the release section on github:

How to Install

After having the release package downloaded:

tar zxvf linux-4.4.32-apollo-1.0.0.tar.gz
cd install
sudo ./

How to Build

If you would like cutomize and build your own kernel, simply run:


You can find the installation kernel package under directory:


Realtime "Hello World" Example


  • Setting a real time scheduling policy and priority
  • Locking memory so that page faults caused by virtual memory will not undermine deterministic behavior
  • Pre-faulting the stack, so that a future stack fault will not undermine deterministic behavior

The following example contains some very basic example code of a real time application with realtime preemption patch. Compile as follows:

gcc -o test_rt test_rt.c -lrt

Source code as below:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <sys/mman.h>
#include <string.h>

#define MY_PRIORITY (49) /* we use 49 as the PRREMPT_RT use 50
                            as the priority of kernel tasklets
                            and interrupt handler by default */

#define MAX_SAFE_STACK (8*1024) /* The maximum stack size which is
                                   guaranteed safe to access without
                                   faulting */

#define NSEC_PER_SEC    (1000000000) /* The number of nsecs per sec. */

void stack_prefault(void) {

        unsigned char dummy[MAX_SAFE_STACK];

        memset(dummy, 0, MAX_SAFE_STACK);

int main(int argc, char* argv[])
        struct timespec t;
        struct sched_param param;
        int interval = 50000; /* 50us*/

        /* Declare ourself as a real time task */

        param.sched_priority = MY_PRIORITY;
        if(sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
                perror("sched_setscheduler failed");

        /* Lock memory */

        if(mlockall(MCL_CURRENT|MCL_FUTURE) == -1) {
                perror("mlockall failed");

        /* Pre-fault our stack */


        clock_gettime(CLOCK_MONOTONIC ,&t);
        /* start after one second */

        while(1) {
                /* wait until next shot */
                clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &t, NULL);

                /* do the stuff */

                /* calculate next shot */
                t.tv_nsec += interval;

                while (t.tv_nsec >= NSEC_PER_SEC) {
                       t.tv_nsec -= NSEC_PER_SEC;


The patched Linux kernel is specifically for running Apollo software stack on an Apollo 1.0 Reference Hardware Platform (see Apollo 1.0 Hardware and System Installation Guide for more information). It is not recommended for any other purposes.