Linux Kernel and Driver Development Training

Linux Kernel and Driver

Free Electrons
Development Training
Embedded Linux
Developers
Free Electrons

© Copyright 2004-2014, Free Electrons.

Creative Commons BY-SA 3.0 license.
Latest update: February 5, 2014.
Document updates and sources:
http://free- electrons.com/doc/training/linux- kernel
Corrections, suggestions, contributions and translations are welcome!

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 1/484
 Linux Kernel Introduction

Linux Kernel Free Electrons

Introduction Embedded Linux

Developers

Free Electrons

© Copyright 2004-2014, Free Electrons.

Creative Commons BY-SA 3.0 license.
Corrections, suggestions, contributions and translations are welcome!

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 16/484
 Linux Kernel Introduction

Linux features

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 17/484
 History

I The Linux kernel is one component of a system, which also

requires libraries and applications to provide features to end
users.
I The Linux kernel was created as a hobby in 1991 by a Finnish
student, Linus Torvalds.
I Linux quickly started to be used as the kernel for free software
operating systems
I Linus Torvalds has been able to create a large and dynamic
developer and user community around Linux.
I Nowadays, hundreds of people contribute to each kernel
release, individuals or companies big and small.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 18/484
 Linux kernel in the system

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 19/484
 Linux kernel main roles

I Manage all the hardware resources: CPU, memory, I/O.

I Provide a set of portable, architecture and hardware
independent APIs to allow userspace applications and
libraries to use the hardware resources.
I Handle concurrent accesses and usage of hardware
resources from different applications.
I Example: a single network interface is used by multiple
userspace applications through various network connections.
The kernel is responsible to “multiplex” the hardware resource.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 20/484
 Inside the Linux kernel

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 21/484
 Linux license

I The whole Linux sources are Free Software released under the
GNU General Public License version 2 (GPL v2).
I For the Linux kernel, this basically implies that:
I When you receive or buy a device with Linux on it, you should
receive the Linux sources, with the right to study, modify and
redistribute them.
I When you produce Linux based devices, you must release the
sources to the recipient, with the same rights, with no
restriction..

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 22/484
 Linux kernel key features

I Portability and hardware I Security. It can’t hide its

support. Runs on most flaws. Its code is reviewed
architectures. by many experts.
I Scalability. Can run on I Stability and reliability.
super computers as well as I Modularity. Can include
on tiny devices (4 MB of only what a system needs
RAM is enough). even at run time.
I Compliance to standards I Easy to program. You can
and interoperability. learn from existing code.
I Exhaustive networking Many useful resources on
support. the net.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 23/484
 Supported hardware architectures

I See the arch/ directory in the kernel sources

I Minimum: 32 bit processors, with or without MMU, and gcc
support
I 32 bit architectures (arch/ subdirectories)
Examples: arm, avr32, blackfin, m68k, microblaze, mips,
score, sparc, um
I 64 bit architectures:
Examples: alpha, arm64, ia64, sparc64, tile
I 32/64 bit architectures
Examples: powerpc, x86, sh
I Find details in kernel sources: arch/<arch>/Kconfig,
arch/<arch>/README, or Documentation/<arch>/

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 24/484
 System calls

I The main interface between the kernel and userspace is the

set of system calls
I About 300 system calls that provide the main kernel services
I File and device operations, networking operations,
inter-process communication, process management, memory
mapping, timers, threads, synchronization primitives, etc.
I This interface is stable over time: only new system calls can
be added by the kernel developers
I This system call interface is wrapped by the C library, and
userspace applications usually never make a system call
directly but rather use the corresponding C library function

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 25/484
 Virtual filesystems

I Linux makes system and kernel information available in

user-space through virtual filesystems.
I Virtual filesystems allow applications to see directories and
files that do not exist on any real storage: they are created on
the fly by the kernel
I The two most important virtual filesystems are
I proc, usually mounted on /proc:
Operating system related information (processes, memory
management parameters...)
I sysfs, usually mounted on /sys:
Representation of the system as a set of devices and buses.
Information about these devices.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 26/484
 Embedded Linux Kernel Usage

Linux kernel sources

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 28/484
 Location of kernel sources

I The official version of the Linux kernel, as released by Linus

Torvalds is available at http://www.kernel.org
I This version follows the well-defined development model of the
kernel
I However, it may not contain the latest development from a
specific area, due to the organization of the development
model and because features in development might not be
ready for mainline inclusion
I Many kernel sub-communities maintain their own kernel, with
usually newer but less stable features
I Architecture communities (ARM, MIPS, PowerPC, etc.),
device drivers communities (I2C, SPI, USB, PCI, network,
etc.), other communities (real-time, etc.)
I They generally don’t release official versions, only development
trees are available

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 29/484
 Getting Linux sources

I The kernel sources are available from

http://kernel.org/pub/linux/kernel as full tarballs
(complete kernel sources) and patches (differences between
two kernel versions).
I But for kernel development, one generally uses the Git version
control system:
I Fetch the entire kernel sources and history
git clone git://git.kernel.org/pub/scm/linux/
kernel/git/torvalds/linux.git
I Create a branch that starts at a specific stable version
git checkout -b <name-of-branch> v3.11
I Web interface available at http://git.kernel.org/cgit/
linux/kernel/git/torvalds/linux.git/tree/.
I Read more about Git at http://git-scm.com/

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 30/484
 Linux kernel size (1)

I Linux 3.10 sources:

Raw size: 573 MB (43,000 files, approx 15,800,000 lines)
gzip compressed tar archive: 105 MB
bzip2 compressed tar archive: 83 MB (better)
xz compressed tar archive: 69 MB (best)
I Minimum Linux 2.6.29 compiled kernel size with
CONFIG_EMBEDDED, for a kernel that boots a QEMU PC (IDE
hard drive, ext2 filesystem, ELF executable support):
532 KB (compressed), 1325 KB (raw)
I Why are these sources so big?
Because they include thousands of device drivers, many
network protocols, support many architectures and
filesystems...
I The Linux core (scheduler, memory management...) is pretty
small!
Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 31/484
 Linux kernel size (2)

As of kernel version 3.10.

I drivers/: 49.4%
I tools/: 0.9%
I arch/: 21.9%
I scripts/: 0.5%
I fs/: 6.0%
I mm/: 0.5%
I include/: 4.7%
I crypto/: 0.4%
I sound/: 4.4%
I security/: 0.4%
I Documentation/: 4.0%
I lib/: 0.4%
I net/: 3.9%
I block/: 0.2%
I firmware/: 1.0%
I ...
I kernel/: 1.0%

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 32/484
 Kernel Source Code

Kernel Source Free Electrons

Code Embedded Linux

Developers

Free Electrons

© Copyright 2004-2014, Free Electrons.

Creative Commons BY-SA 3.0 license.
Corrections, suggestions, contributions and translations are welcome!

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 34/484
 Kernel Source Code

Linux Code and Device Drivers

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 35/484
 Programming language

I Implemented in C like all Unix systems. (C was created to

implement the first Unix systems)
I A little Assembly is used too:
I CPU and machine initialization, exceptions
I Critical library routines.
I No C++ used, see http://www.tux.org/lkml/#s15-3
I All the code compiled with gcc
I Many gcc specific extensions used in the kernel code, any
ANSI C compiler will not compile the kernel
I A few alternate compilers are supported (Intel and Marvell)
I See http://gcc.gnu.org/onlinedocs/gcc-4.6.1/gcc/C-
Extensions.html

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 37/484
 No C library

I The kernel has to be standalone and can’t use user-space

code.
I Userspace is implemented on top of kernel services, not the
opposite.
I Kernel code has to supply its own library implementations
(string utilities, cryptography, uncompression ...)
I So, you can’t use standard C library functions in kernel code.
(printf(), memset(), malloc(),...).
I Fortunately, the kernel provides similar C functions for your
convenience, like printk(), memset(), kmalloc(), ...

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 38/484
 Portability

I The Linux kernel code is designed to be portable

I All code outside arch/ should be portable
I To this aim, the kernel provides macros and functions to
abstract the architecture specific details
I Endianness
I cpu_to_be32()
I cpu_to_le32()
I be32_to_cpu()
I le32_to_cpu()
I I/O memory access
I Memory barriers to provide ordering guarantees if needed
I DMA API to flush and invalidate caches if needed

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 39/484
 No floating point computation

I Never use floating point numbers in kernel code. Your code

may be run on a processor without a floating point unit (like
on certain ARM CPUs).
I Don’t be confused with floating point related configuration
options
I They are related to the emulation of floating point operation
performed by the user space applications, triggering an
exception into the kernel.
I Using soft-float, i.e. emulation in user-space, is however
recommended for performance reasons.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 40/484
 No stable Linux internal API 1/3

I The internal kernel API to implement kernel code can undergo

changes between two stable 2.6.x or 3.x releases. A
stand-alone driver compiled for a given version may no longer
compile or work on a more recent one. See
Documentation/stable_api_nonsense.txt in kernel
sources for reasons why.
I Of course, the external API must not change (system calls,
/proc, /sys), as it could break existing programs. New
features can be added, but kernel developers try to keep
backward compatibility with earlier versions, at least for 1 or
several years.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 41/484
 No stable Linux internal API 2/3

I Whenever a developer changes an internal API, (s)he also has

to update all kernel code which uses it. Nothing broken!
I Works great for code in the mainline kernel tree.
I Difficult to keep in line for out of tree or closed-source drivers!

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 42/484
 No stable Linux internal API 3/3

I USB example
I Linux has updated its USB internal API at least 3 times (fixes,
security issues, support for high-speed devices) and has now
the fastest USB bus speeds (compared to other systems)
I Windows XP also had to rewrite its USB stack 3 times. But,
because of closed-source, binary drivers that can’t be updated,
they had to keep backward compatibility with all earlier
implementation. This is very costly (development, security,
stability, performance).
I See “Myths, Lies, and Truths about the Linux Kernel”, by
Greg K.H., for details about the kernel development process:
http://kroah.com/log/linux/ols_2006_keynote.html

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 43/484
 Kernel memory constraints

I No memory protection
I Accessing illegal memory locations result in (often fatal)
kernel oopses.
I Fixed size stack (8 or 4 KB). Unlike in userspace, there’s no
way to make it grow.
I Kernel memory can’t be swapped out (for the same reasons).

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 44/484
 Linux kernel licensing constraints

I The Linux kernel is licensed under the GNU General Public

License version 2
I This license gives you the right to use, study, modify and share
the software freely
I However, when the software is redistributed, either modified
or unmodified, the GPL requires that you redistribute the
software under the same license, with the source code
I If modifications are made to the Linux kernel (for example to
adapt it to your hardware), it is a derivative work of the kernel,
and therefore must be released under GPLv2
I The validity of the GPL on this point has already been verified
in courts
I However, you’re only required to do so
I At the time the device starts to be distributed
I To your customers, not to the entire world

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 45/484
 Proprietary code and the kernel

I It is illegal to distribute a binary kernel that includes statically

compiled proprietary drivers
I The kernel modules are a gray area: are they derived works of
the kernel or not?
I The general opinion of the kernel community is that
proprietary drivers are bad: http://j.mp/fbyuuH
I From a legal point of view, each driver is probably a different
case
I Is it really useful to keep your drivers secret?
I There are some examples of proprietary drivers, like the Nvidia
graphics drivers
I They use a wrapper between the driver and the kernel
I Unclear whether it makes it legal or not

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 46/484
 Advantages of GPL drivers 1/2

I You don’t have to write your driver from scratch. You can
reuse code from similar free software drivers.
I You get free community contributions, support, code review
and testing. Proprietary drivers (even with sources) don’t get
any.
I Your drivers can be freely shipped by others (mainly by
distributions).
I Closed source drivers often support a given kernel version. A
system with closed source drivers from 2 different sources is
unmanageable.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 47/484
 Advantages of GPL drivers 2/2

I Users and the community get a positive image of your

company. Makes it easier to hire talented developers.
I You don’t have to supply binary driver releases for each kernel
version and patch version (closed source drivers).
I Drivers have all privileges. You need the sources to make sure
that a driver is not a security risk.
I Your drivers can be statically compiled into the kernel (useful
to have a kernel image with all drivers needed at boot time)

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 48/484
 Advantages of in-tree kernel drivers

I Once your sources are accepted in the mainline tree, they are
maintained by people making changes.
I Cost-free maintenance, security fixes and improvements.
I Easy access to your sources by users.
I Many more people reviewing your code.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 49/484
 Userspace device drivers 1/2

I Possible to implement device drivers in user-space!

I Such drivers just need access to the devices through
minimum, generic kernel drivers.
I Examples
I Printer and scanner drivers (on top of generic parallel port or
USB drivers)
I X drivers: low level kernel drivers + user space X drivers.
I Userspace drivers based on UIO. See
Documentation/DocBook/uio-howto in the kernel
documentation for details about UIO and the Using UIO on an
Embedded platform talk at ELC 2008 (http://j.mp/tBzayM)

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 50/484
 Userspace device drivers 2/2

I Advantages
I No need for kernel coding skills. Easier to reuse code between
devices.
I Drivers can be written in any language, even Perl!
I Drivers can be kept proprietary.
I Driver code can be killed and debugged. Cannot crash the
kernel.
I Can be swapped out (kernel code cannot be).
I Can use floating-point computation.
I Less in-kernel complexity.
I Drawbacks
I Less straightforward to handle interrupts.
I Increased latency vs. kernel code.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 51/484
 Kernel Source Code

Linux sources

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 52/484
 Linux sources structure 1/4

I arch/<ARCH>
I Architecture specific code
I arch/<ARCH>/mach-<machine>, machine/board specific code
I arch/<ARCH>/include/asm, architecture-specific headers
I arch/<ARCH>/boot/dts, Device Tree files, for some
architectures
I block
I Block layer core
I COPYING
I Linux copying conditions (GNU GPL)
I CREDITS
I Linux main contributors
I crypto/
I Cryptographic libraries

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 53/484
 Linux sources structure 2/4

I Documentation/
I Kernel documentation. Don’t miss it!
I drivers/
I All device drivers except sound ones (usb, pci...)
I fs/
I Filesystems (fs/ext3/, etc.)
I include/
I Kernel headers
I include/linux
I Linux kernel core headers
I init/
I Linux initialization (including main.c)
I ipc/
I Code used for process communication

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 54/484
 Linux sources structure 3/4

I Kbuild
I Part of the kernel build system
I Kconfig
I Top level description file for configuration parameters
I kernel/
I Linux kernel core (very small!)
I lib/
I Misc library routines (zlib, crc32...)
I MAINTAINERS
I Maintainers of each kernel part. Very useful!
I Makefile
I Top Linux Makefile (sets arch and version)
I mm/
I Memory management code (small too!)

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 55/484
 Linux sources structure 4/4
I net/
I Network support code (not drivers)
I README
I Overview and building instructions
I REPORTING-BUGS
I Bug report instructions
I samples/
I Sample code (markers, kprobes, kobjects...)
I scripts/
I Scripts for internal or external use
I security/
I Security model implementations (SELinux...)
I sound/
I Sound support code and drivers
I usr/
I Code to generate an initramfs cpio archive
I virt/
I Virtualization support (KVM)
Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 56/484
 Practical lab - Kernel Source Code - Exploring

I Explore kernel sources manually

I Use automated tools to explore the
source code

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 62/484
 Kernel Source Code

Kernel configuration

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 63/484
 Kernel configuration and build system

I The kernel configuration and build system is based on

multiple Makefiles
I One only interacts with the main Makefile, present at the
top directory of the kernel source tree
I Interaction takes place
I using the make tool, which parses the Makefile
I through various targets, defining which action should be done
(configuration, compilation, installation, etc.). Run
make help to see all available targets.
I Example
I cd linux-3.6.x/
I make <target>

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 64/484
 Kernel configuration (1)

I The kernel contains thousands of device drivers, filesystem

drivers, network protocols and other configurable items
I Thousands of options are available, that are used to
selectively compile parts of the kernel source code
I The kernel configuration is the process of defining the set of
options with which you want your kernel to be compiled
I The set of options depends
I On your hardware (for device drivers, etc.)
I On the capabilities you would like to give to your kernel
(network capabilities, filesystems, real-time, etc.)

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 65/484
 Kernel configuration (2)

I The configuration is stored in the .config file at the root of

kernel sources
I Simple text file, key=value style
I As options have dependencies, typically never edited by hand,
but through graphical or text interfaces:
I make xconfig, make gconfig (graphical)
I make menuconfig, make nconfig (text)
I You can switch from one to another, they all load/save the
same .config file, and show the same set of options
I To modify a kernel in a GNU/Linux distribution: the
configuration files are usually released in /boot/, together
with kernel images: /boot/config-3.2.0-31-generic

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 66/484
 Kernel or module?

I The kernel image is a single file, resulting from the linking

of all object files that correspond to features enabled in the
configuration
I This is the file that gets loaded in memory by the bootloader
I All included features are therefore available as soon as the
kernel starts, at a time where no filesystem exists
I Some features (device drivers, filesystems, etc.) can however
be compiled as modules
I Those are plugins that can be loaded/unloaded dynamically to
add/remove features to the kernel
I Each module is stored as a separate file in the filesystem,
and therefore access to a filesystem is mandatory to use
modules
I This is not possible in the early boot procedure of the kernel,
because no filesystem is available

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 67/484
 Kernel option types

I There are different types of options

I bool options, they are either
I true (to include the feature in the kernel) or
I false (to exclude the feature from the kernel)
I tristate options, they are either
I true (to include the feature in the kernel image) or
I module (to include the feature as a kernel module) or
I false (to exclude the feature)
I int options, to specify integer values
I string options, to specify string values

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 68/484
 Kernel option dependencies

I There are dependencies between kernel options

I For example, enabling a network driver requires the network
stack to be enabled
I Two types of dependencies
I depends on dependencies. In this case, option A that depends
on option B is not visible until option B is enabled
I select dependencies. In this case, with option A depending
on option B, when option A is enabled, option B is
automatically enabled
I make xconfig allows to see all options, even those that
cannot be selected because of missing dependencies. In this
case, they are displayed in gray

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 69/484
 make xconfig

make xconfig
I The most common graphical interface to configure the kernel.
I Make sure you read
help -> introduction: useful options!
I File browser: easier to load configuration files
I Search interface to look for parameters
I Required Debian / Ubuntu packages: libqt4-dev g++
(libqt3-mt-dev for older kernel releases)

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 70/484
 make xconfig screenshot

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 71/484
 make xconfig search interface
Looks for a keyword in the parameter name. Allows to select or
unselect found parameters.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 72/484
 Kernel configuration options

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 73/484
 Corresponding .config file excerpt
Options are grouped by sections and are prefixed with CONFIG_.
#
# CD-ROM/DVD Filesystems
#
CONFIG_ISO9660_FS=m
CONFIG_JOLIET=y
CONFIG_ZISOFS=y
CONFIG_UDF_FS=y
CONFIG_UDF_NLS=y

#
# DOS/FAT/NT Filesystems
#
# CONFIG_MSDOS_FS is not set
# CONFIG_VFAT_FS is not set
CONFIG_NTFS_FS=m
# CONFIG_NTFS_DEBUG is not set
CONFIG_NTFS_RW=y
Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 74/484
 make gconfig

make gconfig
I GTK based graphical
configuration interface.
Functionality similar to that
of make xconfig.
I Just lacking a search
functionality.
I Required Debian packages:
libglade2-dev

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 75/484
 make menuconfig

make menuconfig
I Useful when no graphics are
available. Pretty convenient
too!
I Same interface found in
other tools: BusyBox,
Buildroot...
I Required Debian packages:
libncurses-dev

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 76/484
 make nconfig

make nconfig
I A newer, similar text
interface
I More user friendly (for
example, easier to access
help information).
I Required Debian packages:
libncurses-dev

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 77/484
 make oldconfig

make oldconfig
I Needed very often!
I Useful to upgrade a .config file from an earlier kernel release
I Issues warnings for configuration parameters that no longer
exist in the new kernel.
I Asks for values for new parameters
If you edit a .config file by hand, it’s strongly recommended to
run make oldconfig afterwards!

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 78/484
 Undoing configuration changes

A frequent problem:
I After changing several kernel configuration settings, your
kernel no longer works.
I If you don’t remember all the changes you made, you can get
back to your previous configuration:
$ cp .config.old .config
I All the configuration interfaces of the kernel (xconfig,
menuconfig, oldconfig...) keep this .config.old backup
copy.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 79/484
 Configuration per architecture

I The set of configuration options is architecture dependent

I Some configuration options are very architecture-specific
I Most of the configuration options (global kernel options,
network subsystem, filesystems, most of the device drivers) are
visible in all architectures.
I By default, the kernel build system assumes that the kernel is
being built for the host architecture, i.e. native compilation
I The architecture is not defined inside the configuration, but at
a higher level
I We will see later how to override this behaviour, to allow the
configuration of kernels for a different architecture

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 80/484
 Overview of kernel options (1)

I General setup
I Local version - append to kernel release allows to concatenate
an arbitrary string to the kernel version that a user can get
using uname -r. Very useful for support!
I Support for swap, can usually be disabled on most embedded
devices
I Configure standard kernel features (expert users) allows to
remove features from the kernel to reduce its size. Powerful,
but use with care!

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 81/484
 Overview of kernel options (2)

I Loadable module support

I Allows to enable or completely disable module support. If your
system doesn’t need kernel modules, best to disable since it
saves a significant amount of space and memory
I Enable the block layer
I If CONFIG_EXPERT is enabled, the block layer can be
completely removed. Embedded systems using only flash
storage can safely disable the block layer
I Processor type and features (x86) or System type (ARM) or
CPU selection (MIPS)
I Allows to select the CPU or machine for which the kernel must
be compiled
I On x86, only optimization-related, on other architectures very
important since there’s no compatibility

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 82/484
 Overview of kernel options (3)

I Kernel features
I Tickless system, which allows to disable the regular timer tick
and use on-demand ticks instead. Improves power savings
I High resolution timer support. By default, the resolution of
timer is the tick resolution. With high resolution timers, the
resolution is as precise as the hardware can give
I Preemptible kernel enables the preemption inside the kernel
code (the userspace code is always preemptible). See our
real-time presentation for details
I Power management
I Global power management option needed for all power
management related features
I Suspend to RAM, CPU frequency scaling, CPU idle control,
suspend to disk

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 83/484
 Overview of kernel options (4)

I Networking support
I The network stack
I Networking options
I Unix sockets, needed for a form of inter-process
communication
I TCP/IP protocol with options for multicast, routing,
tunneling, Ipsec, Ipv6, congestion algorithms, etc.
I Other protocols such as DCCP, SCTP, TIPC, ATM
I Ethernet bridging, QoS, etc.
I Support for other types of network
I CAN bus, Infrared, Bluetooth, Wireless stack, WiMax stack,
etc.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 84/484
 Overview of kernel options (5)

I Device drivers
I MTD is the subsystem for flash (NOR, NAND, OneNand,
battery-backed memory, etc.)
I Parallel port support
I Block devices, a few misc block drivers such as loopback,
NBD, etc.
I ATA/ATAPI, support for IDE disk, CD-ROM and tapes. A
new stack exists
I SCSI
I The SCSI core, needed not only for SCSI devices but also for
USB mass storage devices, SATA and PATA hard drives, etc.
I SCSI controller drivers

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 85/484
 Overview of kernel options (6)

I Device drivers (cont)

I SATA and PATA, the new stack for hard disks, relies on SCSI
I RAID and LVM, to aggregate hard drives and do replication
I Network device support, with the network controller drivers.
Ethernet, Wireless but also PPP
I Input device support, for all types of input devices: keyboards,
mice, joysticks, touchscreens, tablets, etc.
I Character devices, contains various device drivers, amongst
them
I serial port controller drivers
I PTY driver, needed for things like SSH or telnet
I I2C, SPI, 1-wire, support for the popular embedded buses
I Hardware monitoring support, infrastructure and drivers for
thermal sensors

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 86/484
 Overview of kernel options (7)

I Device drivers (cont)

I Watchdog support
I Multifunction drivers are drivers that do not fit in any other
category because the device offers multiple functionality at the
same time
I Multimedia support, contains the V4L and DVB subsystems,
for video capture, webcams, AM/FM cards, DVB adapters
I Graphics support, infrastructure and drivers for framebuffers
I Sound card support, the OSS and ALSA sound infrastructures
and the corresponding drivers
I HID devices, support for the devices that conform to the HID
specification (Human Input Devices)

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 87/484
 Overview of kernel options (8)

I Device drivers (cont)

I USB support
I Infrastructure
I Host controller drivers
I Device drivers, for devices connected to the embedded system
I Gadget controller drivers
I Gadget drivers, to let the embedded system act as a
mass-storage device, a serial port or an Ethernet adapter
I MMC/SD/SDIO support
I LED support
I Real Time Clock drivers
I Voltage and current regulators
I Staging drivers, crappy drivers being cleaned up

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 88/484
 Overview of kernel options (9)

I For some categories of devices the driver is not implemented

inside the kernel
I Printers
I Scanners
I Graphics drivers used by X.org
I Some USB devices
I For these devices, the kernel only provides a mechanism to
access the hardware, the driver is implemented in userspace

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 89/484
 Overview of kernel options (10)

I File systems
I The common Linux filesystems for block devices: ext2, ext3,
ext4
I Less common filesystems: XFS, JFS, ReiserFS, GFS2, OCFS2,
Btrfs
I CD-ROM filesystems: ISO9660, UDF
I DOS/Windows filesystems: FAT and NTFS
I Pseudo filesystems: proc and sysfs
I Miscellaneous filesystems, with amongst other flash filesystems
such as JFFS2, UBIFS, SquashFS, cramfs
I Network filesystems, with mainly NFS and SMB/CIFS
I Kernel hacking
I Debugging features useful for kernel developers

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 90/484
 Kernel Source Code

Compiling and installing the kernel

for the host system

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 91/484
 Kernel compilation

I make
I in the main kernel source directory
I Remember to run make -j 4 if you have multiple CPU cores
to speed up the compilation process
I No need to run as root!
I Generates
I vmlinux, the raw uncompressed kernel image, at the ELF
format, useful for debugging purposes, but cannot be booted
I arch/<arch>/boot/*Image, the final, usually compressed,
kernel image that can be booted
I bzImage for x86, zImage for ARM, vmImage.gz for Blackfin,
etc.
I arch/<arch>/boot/dts/*.dtb, compiled Device Tree files
(on some architectures)
I All kernel modules, spread over the kernel source tree, as .ko
files.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 92/484
 Kernel installation

I make install
I Does the installation for the host system by default, so needs
to be run as root. Generally not used when compiling for an
embedded system, and it installs files on the development
workstation.
I Installs
I /boot/vmlinuz-<version>
Compressed kernel image. Same as the one in
arch/<arch>/boot
I /boot/System.map-<version>
Stores kernel symbol addresses
I /boot/config-<version>
Kernel configuration for this version
I Typically re-runs the bootloader configuration utility to take
the new kernel into account.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 93/484
 Module installation

I make modules_install
I Does the installation for the host system by default, so needs
to be run as root
I Installs all modules in /lib/modules/<version>/
I kernel/
Module .ko (Kernel Object) files, in the same directory
structure as in the sources.
I modules.alias
Module aliases for module loading utilities. Example line:
alias sound-service-?-0 snd_mixer_oss
I modules.dep
Module dependencies
I modules.symbols
Tells which module a given symbol belongs to.

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 94/484
 Kernel cleanup targets

I Clean-up generated files (to force

re-compilation):
make clean
I Remove all generated files. Needed when
switching from one architecture to another.
Caution: it also removes your .config file!
make mrproper
I Also remove editor backup and patch reject files
(mainly to generate patches):
make distclean

Free Electrons. Embedded Linux, kernel, drivers and Android development, consulting, training and support. http://free-electrons.com 95/484