Libre Software Meeting 2012

Buildroot: a nice,
simple and efficient
embedded Linux build
system

Thomas Petazzoni
Free Electrons
thomas.petazzoni@free-electrons.com

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 1/50
 Thomas Petazzoni

I Embedded Linux engineer and trainer at Free Electrons since

2008
I Embedded Linux development: kernel and driver
development, system integration, boot time and power
consumption optimization, consulting, etc.
I Embedded Linux training, Linux driver development training
and Android system development training, with materials
freely available under a Creative Commons license.
I http://www.free-electrons.com
I Major contributor to Buildroot, an open-source, simple and
fast embedded Linux build system
I Speaker at Embedded Linux Conference, Embedded Linux
Conference Europe, FOSDEM, Libre Software Meeting, etc.
I Living in Toulouse, south west of France

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 2/50
 Building embedded Linux systems

To create an embedded Linux system, one has multiple choices:

1. Use a pre-built binary distribution such as Debian, Ubuntu
or Fedora
I Quick to set up, but not very flexible: support for only a few
architectures, no flexibility on package configuration, no easy
way to rebuild the entire system automatically.
2. Build all system components manually
I Highly flexible, but painful and inefficient: need to handle
complex cross-compilation issues, understand inter-package
dependencies, not reproducible.
3. Use an automated build system, that builds the entire
system from source
I Automated, flexible, handle most cross-compilation issues
I Examples: Buildroot, OpenWRT, PTXdist, OpenBricks,
OpenEmbedded, Yocto, etc.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 3/50
 Buildroot main characteristics

I Based on well-known technologies: kconfig for the

configuration interface and language, make for the build logic.
These technologies are familiar to all embedded Linux
developers.
I Very simple to use, and easily hackable code base. The
core infrastructure is a few hundred lines of make code.
I Fast. It does really build only what’s necessary. The base
system, composed only of BusyBox, takes less than 3 minutes
to build with an external toolchain.
I Designed for small to medium sized embedded systems.
There is no runtime package management system (dpkg,
rpm). Complete rebuilds are often required. Well-suited for
systems with a limited number of components.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 4/50
 Buildroot vs. OpenEmbedded/Yocto

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 5/50
 Context: quick Buildroot history

December 2001

Buildroot is created by uClibc developers as a way of building small

embedded Linux systems to test uClibc

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 6/50
 Context: quick Buildroot history

Starting around 2005

Buildroot really starts to be used as an embedded Linux build

system for production devices.

The number of developers increases with everybody having

write-access to the repository, and the maintainer is no longer
active. No stable releases, no design.

The code slowly gets crappier over the years.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 7/50
 Context: quick Buildroot history

January 2009

Peter Korsgaard becomes the new maintainer. Start of a new

period for the project:
I Stable releases every three months. First release 2009.02,
2012.08 due at the end of august.
I Huge cleanup effort: code base reduction from 5.2 MB to 2.2
MB, while many packages are added, updated and many new
features are added.
I Increase in the number of contributors and users. Regular
Buildroot Developer Days.
I Linux model: only the maintainer has write-access. Allows to
keep a very good consistency in the design decisions.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 8/50
 Context: quick Buildroot history

Number of commits per month

Number of e-mails per day

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 9/50
 Three years of change

After three years of major changes in Buildroot, it’s

a good time to have a fresh look at it.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 10/50
 Buildroot: general principle

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 11/50
 Using Buildroot

$ wget http://buildroot.org/downloads/buildroot-2012.05.tar.bz2
$ tar xjf buildroot-2012.05.tar.bz2
$ cd buildroot-2012.05

$ make [menu|x|n|g]config

I No need to run as root. Ever.

I No need to symlink /bin/sh to bash
I Very limited set of dependencies: a native compiler, and basic
utilities like awk, bison, patch, gzip, tar, wget, etc.
I Out-of-tree build is possible using O=, exactly like the Linux
kernel.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 12/50
 Buildroot menuconfig

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 13/50
 Target architecture

Allows you to define:

I The target architecture, i.e ARM, x86, PowerPC, MIPS.
Buildroot supports non-MMU architectures such as Blackfin
or soon Microblaze, thanks to its uClibc support.
I The target architecture variant, such as ARM926 or
Cortex-A8 on ARM. Allows to automatically add the
appropriate -mcpu, -march, -mtune arguments to gcc.
I Target architecture ABI

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 14/50
 Build options

I The download directory, where tarballs are saved for future

builds. Defaults to $(TOPDIR)/dl. Can also be overridden
using the BUILDROOT_DL_DIR environment variable.
I The host directory, where all host utilities are installed,
including the toolchain and its sysroot. Defaults to
$(O)/host, but can be changed to generate an SDK in a
different directory.
I The number of jobs. Buildroot build the different
components sequentially, but uses make -j to compile the
individual components.
I Use of ccache
I Other build options: build with debugging symbols, install
documentation on target, install development files on target,
etc.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 15/50
 Toolchain
Buildroot provides three toolchain back-ends:
I An internal Buildroot toolchain back-end, which has been
available since Buildroot’s creation. Buildroot will directly
build a uClibc toolchain and use it for cross-compiling all
packages.
I An external toolchain back-end, which allows use existing
pre-built uClibc, glibc or eglibc toolchains, such as Sourcery
CodeBench toolchains, Linaro toolchains, or toolchains that
have previously been built using Crosstool-NG or Buildroot.
Using an external toolchain removes the toolchain build time.
I A Crosstool-NG back-end, which tells Buildroot to build a
cross-compiling toolchain with Crosstool-NG. This allows to
benefit from all Crosstool-NG advantages, such as support for
glibc or eglibc.
→ Buildroot often had the reputation of being limited to uClibc,
but it is no longer the case, for several years now.
Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 16/50
 System configuration

Allows the definition of various system-wide parameters:

I The /dev management solution:
I static, where device nodes are created statically at build time
according to a device table
I devtmpfs
I devtmpfs + BusyBox’ mdev
I devtmpfs + udev
I The serial port for the console
I Location of a post-build script that gets run after all packages
have been built, but before the filesystem images are created.
I Some various other parameters (hostname, etc.)

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 17/50
 Packages

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 18/50
 Packages

A selection of more than 750 open-source components typically

used in embedded systems:
I Audio and multimedia: gstreamer, mplayer, pulseaudio, many
codec libraries, alsa, etc.
I Graphics: full X.org stack, Gtk, Qt, EFL, DirectFB, SDL, etc.
I System tools, filesystem utilities, hardware utilities and
libraries
I Networking applications: dropbear, avahi, bluez, samba, pppd,
connman, etc.
I Development, debugging: oprofile, lttng, etc.
I Interpreters: Python, PHP, Ruby, Perl

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 19/50
 Filesystem images

Buildroot can generate filesystem images in multiple formats:

I tar
I cpio
I ext2
I jffs2
I ubi/ubifs
I cramfs
I cloop
I iso9660
I squashfs
I initramfs built into the kernel

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 20/50
 Kernel and bootloader

I Automates the Linux kernel build process. Builds the kernel

using a defconfig or a specified configuration file. Takes care
of installing the kernel modules into the root filesystem. It is
also capable of patching the kernel for real-time extensions
like Xenomai or RTAI.
I Includes support for the most popular bootloaders: U-Boot,
Barebox, Grub, syslinux, but also architecture-specific
bootloaders: AT91Bootstrap, X-Loader, lpc32xxcdl, etc.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 21/50
 Building

Once the configuration is defined and saved in .config, the

compilation is triggered using:

$ make
...
$ ls output/images/
dataflash_at91sam9m10g45ek.bin rootfs.tar
rootfs.ubi rootfs.ubifs
u-boot.bin u-boot-env.bin
uImage

Buildroot will automatically download, extract, patch, configure,

compile and install the selected components, taking care of
following the necessary dependencies.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 22/50
 Build output (1/2)

In the output directory (by default, output/, but can be changed

using out-of-tree build), Buildroot generates:
I build, with one sub-directory per component built. This is
where Buildroot extracts and builds the various components
of the system.
I host, with a typical Unix organization, in which Buildroot
installs all utilities compiled for the host, including the
cross-compiler. It also contains, in
host/usr/<tuple>/sysroot the toolchain sysroot, with all
the headers and libraries built for the target.
I images, with the final images (root filesystem, kernel,
bootloaders)
I ...

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 23/50
 Build output (2/2)

I ...
I stamps, a few stamp files used internally by Buildroot to keep
track of what has been built
I target, the target root filesystem (but with an empty /dev
and invalid permissions, those are fixed using fakeroot in the
final image)
I toolchain, where the different toolchain components are built
in the case of the internal back-end. Otherwise unused.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 24/50
 Build-time: basic examples

I Building a simple ARM system with simply BusyBox, using an

already extracted CodeSourcery glibc toolchain, and
generating a .tar filesystem image takes 39 seconds. The
target system size is 4.2 MB.
I Building a simple ARM system with simply BusyBox, using a
tarball CodeSourcery glibc toolchain, and generating an
UBIFS filesystem image takes 2 minutes 57 seconds.
Identical system size.
I Building the same simple ARM system, using an internal
Buildroot toolchain (with largefile, locales, C++ support),
takes 9 minutes 59 seconds. The target system size is 2.2
MB.
Note: durations measured with the real output of the time command. Download
times are excluded.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 25/50
 Build time: real-world example 1

I The device is an ARM AT91-based platform with GPS, RFID

readers, GSM modem, Ethernet and USB.
I The Buildroot configuration:
I CodeSourcery ARM glibc toolchain
I Linux kernel
I BusyBox for the basic system
I Dropbear for SSH access (debugging)
I Qt with only QtCore, QtNetwork and QtXml, no GUI
I QExtSerialPort
I zlib, libxml2, logrotate, pppd, strace, a special RFID library,
popt library
I The Qt application
I JFFS2 root filesystem
I Filesystem size: 11 MB. Could be reduced by using uClibc.
I Build time: 10 minutes on a fast build server (quad-core i7,
12 GB of RAM)
Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 26/50
 Dependencies: real-world example 1

ALL

pppd picocom logrotate rootfs-jffs2 rootfs-tar busybox dropbear my-application strace linux26

popt host-makedevs host-fakeroot zlib libltkcpp host-cmake qextserialport

libxml2 host-libxslt qt

host-mtd host-libxml2

host-e2fsprogs host-lzo host-zlib host-pkg-config

host-automake

host-autoconf

host-m4 host-libtool

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 27/50
 Build time: real-world example 2

I An x86-based system, with an OpenGL application for vehicle

navigation system.
I External glibc toolchain generated with crosstool-NG
I The Grub bootloader
I Linux kernel, of course
I BusyBox
I A large part of the X.org stack (the server, a few drivers, and
some client libraries), including libdrm, Mesa
I The fglrx ATI proprietary OpenGL driver
I ALSA utils, ALSA library, V4L library, Flashrom, LM Sensors,
Lua, Dropbear, Ethtool
I The OpenGL application and its data
I Filesystem size: 95 MB, with 10 MB of application (binary +
data) and 45 MB (!) of fglrx driver.
I Build time: 27 minutes on a fast build server (quad-core i7,
12 GB of RAM)

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 28/50
 Dependencies: real-world example 2

Just a small part of it...

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 29/50
 Overall logic: preparation

Buildroot starts by:

I Creating all output directories
I Copying the target root filesystem skeleton, located in
fs/skeleton in the source tree, into the target/ output
directory. This skeleton contains the basic directories and
configuration files for the target system.
One can specify a different skeleton through a configuration
option.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 30/50
 Overall logic: toolchain

Buildroot continues by building the toolchain:

I For internal toolchains, it extracts and builds the different
elements (binutils, gcc, uClibc, etc.) in the toolchain
directory, with stamp files to keep track of what has already
been done. It installs the results in the host/usr/ directory
(for binaries) and host/usr/<tuple>/sysroot directory (for
libraries and headers)
I For external toolchains, Buildroot copies the original
toolchain sysroot to the host/usr/<tuple>/sysroot
directory and creates wrappers for the toolchain binaries in
host/usr/bin
I For Crosstool-NG toolchains, Buildroot installs
Crosstool-NG in host/, and then uses it to generate a
toolchain with binaries in host/usr/bin and sysroot in
host/usr/<tuple>/sysroot.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 31/50
 Overall logic: packages (1/2)

I Buildroot continues by building the packages. Packages

encapsulate the build procedure of userspace libraries and
programs but also the Linux kernel or bootloaders build
procedures.
I The build method of each package is described using an
infrastructure: AUTOTARGETS for autotools-based
packages, CMAKETARGETS for CMake-based packages
and GENTARGETS for other packages.
I Buildroot follows the dependencies expressed in the package
recipes, and triggers the configuration, compilation and
installation steps as described in the recipes.
I ...

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 32/50
 Overall logic: packages (2/2)

I ...
I The package source code is extracted in
build/<pkg>-<version>/, and stamp files are created after
each step to let Buildroot know of what has already been
done. Commands like make <foo>-reconfigure and
make <foo>-rebuild allow to restart the build of a package
if needed.
I Host packages are installed in host/, while target packages
are installed in target/ (usually stripped, no headers).
Target libraries are also installed in
host/usr/<tuple>/sysroot so that they are found by the
cross-compiler (unstripped, with headers and static libraries)

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 33/50
 Overall logic: root filesystem image

Finally, Buildroot generates the root filesystem image(s):

I It uses fakeroot to generate this root filesystem image without
having to be root
I A makedevs utility is used to adjust the file permissions and
ownership, and to create device files if a static /dev was
chosen.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 34/50
 Source code organization

I board, board-specific
patches and configuration
I package, all user-space
files packages (for the host and
the target)
I boot, bootloaders recipes
I support, misc scripts and
I configs, default tools
configuration files for various
platforms. Same concept as
I target, legacy, almost
kernel defconfigs empty directory
I docs
I toolchain, toolchain
handling code (build recipes
I fs, recipes for generating for internal and
root filesystem images in Crosstool-NG back-ends,
various formats, and also integration recipes for
root filesystem skeleton in external toolchains)
fs/skeleton

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 35/50
 Adding packages: configuration

I Each package has its own directory in package/. Let’s say

package/foo for our package.
I A package/foo/Config.in file needs to be created to
declare at least one configuration option for the package. The
syntax is identical to the kconfig syntax:
config BR2_PACKAGE_FOO
bool "foo"
select BR2_PACKAGE_ZLIB
help
This is package foo

http://foo-project.org

I This package/foo/Config.in file must be included from

package/Config.in:

source "package/foo/Config.in"

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 36/50
 Adding packages: writing the recipe

I The recipe must be written in the package/foo/foo.mk file

I It consists of
I Variable declarations to define the package location, version,
and the steps to be done to build the package.
I A call to one of the AUTOTARGETS, GENTARGETS or
CMAKETARGETS macro to expand the package recipe

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 37/50
 Adding packages: minimal recipe

Basic recipe for autotools based package

FOO_VERSION = 1.3
FOO_SOURCE = foo-$(FOO_VERSION).tar.bz2
FOO_SITE = http://foo-project.org/downloads
FOO_DEPENDENCIES = zlib host-pkg-config

$(eval $(call AUTOTARGETS))

The AUTOTARGETS infrastructure:

I knows how to configure, build and install the package
I handles the common cross-compilation issues with autotools based
packages (libtool problems, passing the right arguments and
environment variables to ./configure, etc.).

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 38/50
 Adding packages: various source methods

From Git
FOO_VERSION = this-branch
FOO_SITE = git://git.foo-project.org/foo.git

From Subversion
FOO_VERSION = 12345
FOO_SITE = http://foo-project.org/svn/foo/trunk/
FOO_SITE_METHOD = svn

From a local directory

FOO_SITE = /home/thomas/projects/foo/
FOO_SITE_METHOD = local

And also from Mercurial, from Bazaar, etc.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 39/50
 Packages: GENTARGETS

For packages that use a special build system (not autotools, not
CMake).
FOO_VERSION = 1.3
FOO_SOURCE = foo-$(FOO_VERSION).tar.bz2
FOO_SITE = http://foo-project.org/downloads
FOO_DEPENDENCIES = zlib

define FOO_CONFIGURE_CMDS
echo "HAS_ZLIB=YES" >> $(@D)/config
endef

define FOO_BUILD_CMDS
$(MAKE) -C $(@D) \
CC="$(TARGET_CC)" CFLAGS="$(TARGET_CFLAGS)" \
all
endef

define FOO_INSTALL_TARGET_CMDS
$(INSTALL) -D -m 0755 $(@D)/foo $(TARGET_DIR)/usr/bin
endef

$(eval $(call GENTARGETS))

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 40/50
 Packages: other important mechanisms

I Patches in the package/foo directory are automatically

applied if they are named <number>-<something>.patch or
<version>/<number>-<something>.patch
I Need to set FOO_INSTALL_STAGING = YES for packages
that install libraries, so that headers and static library are
installed in the toolchain sysroot
I Can add hooks to execute custom actions before/after the
different steps, especially for AUTOTARGETS packages
I Can set FOO_AUTORECONF = YES for autotools-based package
to autoreconfigure them, useful when the configure.ac or
Makefile.am files are patched.
I The documentation contains tutorials and a reference with
all details about the package infrastructure
docs/manual/manual.pdf

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 41/50
 Buildroot simplicity
I After a configuration modification, Buildroot does not even
try to apply the configuration changes during the next
make invocation.
I Tracking the consequences of configuration modifications is
very complicated (when a toolchain setting is changed
everything need to be rebuilt; when a library is removed, all
reverse dependencies needs to be rebuilt)
I Buildroot remains simple: it simply executes the build
procedure of the selected packages, and does not try to
track the files installed by each package.
I Relies on the user’s knowledge about the configuration
change to know what needs to be done. Since building is very
fast, full rebuilds are not problematic.
I This focus on simplicity is a very strong design decision of
Buildroot. Some features, such as binary packages generation,
are not implemented in order to keep the build system simple.
Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 42/50
 Customizing for a project

Buildroot offers multiple mechanisms to handle all the

particularities of a given project:
I A board/<company>/<project> directory to store all
project-specific files: kernel and bootloaders patches, scripts
and configuration files, etc.
I Storage of the project configuration as a minimal defconfig
file in the configs/ directory.
I A hookable post-build script that gets called after all
packages are installed but before the root filesystem image is
created.
I The possibility of easily adding packages for custom
software, including software coming from local repositories or
directories.
See the slides of the Using Buildroot for real projects talk given at
the Embedded Linux Conference Europe 2011.
Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 43/50
 Testing effort

I Buildroot provides more than 2000 config options, which

creates a huge number of possible configurations.
I We are running 24/24 random configuration builds on 4
different machines, targeting 40+ combinations of
architectures/toolchains configurations.
I Results visible live at http://autobuild.buildroot.org
I Daily summary sent to the Buildroot mailing list

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 44/50
 autobuild.buildroot.org

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 45/50
 Future directions

I Implement a mechanism for automatic generation of a

licensing report, detailing all components used in the system
and their license
I Add more packages for SoC-specific software (hardware
codecs, 3D acceleration, special bootloaders)
I Improve the documentation with more tutorials
I Finalize the cleanup effort in the remaining areas

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 46/50
 References

I Website: http://buildroot.org
I Mailing-list: buildroot@uclibc.org
http://buildroot.org/lists.html
I IRC channel: #buildroot on Freenode
I Bug tracker: https://bugs.uclibc.org

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 47/50
 Buildroot tutorial at Libre Software Meeting

I Discover Buildroot by practice during this

Libre Software Meeting!
I Half-day tutorial organized on
Thursday 12th July, from 14:00 to
17:00, in room 2150
I Creating a first project configuration
(BusyBox+kernel), creating additional
packages, and more if time permits.
I Tutorial takes place on IGEPv2 boards,
based on OMAP3 ARM processors
I Participants need to come with their own
laptop, equipped with any reasonably
recent GNU/Linux distribution.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 48/50
 Conclusion

I Nice : uses well-known technologies and languages, kconfig

and make. Active community.
I Simple : only a few hundreds lines of code to understand the
core infrastructure. Easy to get started, and easy to fully
understand the internal mechanisms.
I Efficient : very reasonable build times, only what’s necessary
gets built.
Of course, Buildroot is not suitable for all embedded Linux
projects, but it is well adapted to industrial-like projects which have
a limited number of software components and fixed functionality.

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 49/50
 Questions?

Thomas Petazzoni
thomas.petazzoni@free-electrons.com

Slides under CC-BY-SA 3.0. PDF and sources will be available on

http://free-electrons.com/pub/conferences/2012/lsm/

Free Electrons. Kernel, drivers and embedded Linux development, consulting, training and support. http://free-electrons.com 50/50