How is the Linux kernel tested ?

The linux kernel has a heavy emphasis on community testing.

Typically any developer will test their own code before submitting, and quite often they will be using a development version of the kernel from Linus, or one of the other unstable/development trees for a project relevant to their work. This means they are often testing both their changes and other people's changes.

There tend not to be much in the way of formal test plans, but extra testing may be asked for before features are merged into upstream trees.

As Dean pointed out, there's also some automated testing, the linux test project and the kernel autotest (good overview).

Developers will often also write automated tests targetted to test their change, but I'm not sure there's a (often used) mechanism to centrally collect these adhoc tests.

It depends a lot on which area of the kernel is being changed of course - the testing you'd do for a new network driver is quite different to the testing you'd do when replacing the core scheduling algorithm.


Naturally, the kernel itself and its parts are tested prior to the release, but these tests cover only the basic functionality. There are some testing systems which perform testing of Linux Kernel:

The Linux Test Project (LTP) delivers test suites to the open source community that validate the reliability and stability of Linux. The LTP test suite contains a collection of tools for testing the Linux kernel and related features. https://github.com/linux-test-project/ltp

Autotest -- a framework for fully automated testing. It is designed primarily to test the Linux kernel, though it is useful for many other purposes such as qualifying new hardware, virtualization testing, and other general user space program testing under Linux platforms. It's an open-source project under the GPL and is used and developed by a number of organizations, including Google, IBM, Red Hat, and many others. http://autotest.github.io/

Also there are certification systems developed by some major GNU/Linux distribution companies. These systems usually check complete GNU/Linux distributions for compatibility with hardware. There are certification systems developed by Novell, Red Hat, Oracle, Canonical, Google.

There are also systems for dynamic analysis of Linux kernel:

Kmemleak is a memory leak detector included in the Linux kernel. It provides a way of detecting possible kernel memory leaks in a way similar to a tracing garbage collector with the difference that the orphan objects are not freed but only reported via /sys/kernel/debug/kmemleak.

Kmemcheck traps every read and write to memory that was allocated dynamically (i.e. with kmalloc()). If a memory address is read that has not previously been written to, a message is printed to the kernel log. Also is a part of Linux Kernel

Fault Injection Framework (included in Linux kernel) allows for infusing errors and exceptions into an application's logic to achieve a higher coverage and fault tolerance of the system.


How do the Linux kernel developers test their code locally and after they have it committed?

Do they use some kind of unit testing, build automation?

In classic sense of words, no.

E. g. Ingo Molnar is running the following workload: 1. build new kernel with random set of config options 2. boot into it 3. goto 1

Every build fail, boot fail, BUG or runtime warning is dealt with. 24/7. Multiply by several boxes, and one can uncover quite a lot of problems.

test plans?

No.

There may be misunderstanding that there is central testing facility, there is none. Everyone does what he wants.


In-tree tools

A good way to find test tools in the kernel is to:

  • make help and read all targets
  • look under tools/testing

In v4.0, this leads me to:

  • kselftest under tools/testing/selftests. Run with make kselftest. Must be running built kernel already. See also: Documentation/kselftest.txt , https://kselftest.wiki.kernel.org/

  • ktest under tools/testing/ktest. See also: http://elinux.org/Ktest , http://www.slideshare.net/satorutakeuchi18/kernel-auto-testbyktest

  • Static analysers section of make help, which contains targets like:

    • checkstack: Perl: what does checkstack.pl in linux source do?
    • coccicheck for Coccinelle (mentioned by askb)

Kernel CI

https://kernelci.org/ is a project that aims to make kernel testing more automated and visible.

It appears to do only build and boot tests (TODO how to test automatically that boot worked Source should be at https://github.com/kernelci/).

Linaro seems to be the main maintainer of the project, with contributions from many big companies: https://kernelci.org/sponsors/

Linaro Lava

http://www.linaro.org/initiatives/lava/ looks like a CI system with focus on development board bringup and the Linux kernel.

ARM LISA

https://github.com/ARM-software/lisa

Not sure what it does in detail, but it is by ARM and Apache Licensed, so likely worth a look.

Demo: https://www.youtube.com/watch?v=yXZzzUEngiU

Step debuggers

Not really unit testing, but may help once your tests start failing:

  • QEMU + GDB: https://stackoverflow.com/a/42316607/895245
  • KGDB: https://stackoverflow.com/a/44226360/895245

My own QEMU + Buildroot + Python setup

I also started a setup focused on ease of development, but I ended up adding some simple testing capabilities to it as well: https://github.com/cirosantilli/linux-kernel-module-cheat/tree/8217e5508782827320209644dcbaf9a6b3141724#test-this-repo

I haven't analyzed all the other setups in great detail, and they likely do much more than mine, however I believe that my setup is very easy to get started with quickly because it has a lot of documentation and automation.


Its not very easy to automate kernel testing. Most Linux developers do the testing on their own, much like adobriyan mentioned.

However, there are a few things that help with debugging the Linux Kernel:

  • kexec: A system call that allows you to put another kernel into memory and reboot without going back to the BIOS, and if it fails, reboot back.
  • dmesg: Definitely the place to look for information about what happened during the kernel boot and whether it works/doesn't work.
  • Kernel Instrumentation: In addition to printk's (and an option called 'CONFIG_PRINTK_TIME' which allows you to see (to microsecond accuracy) when the kernel output what), the kernel configuration allows you to turn on a LOT of tracers that enable them to debug what is happening.

Then, developers usually have others review their patches. Once the patches are reviewed locally and seen not to interfere with anything else, and the patches are tested to work with the latest kernel from Linus without breaking anything, the patches are pushed upstream.

Edit: Here's a nice video detailing the process a patch goes through before it is integrated into the kernel.