Buildroot: building embedded Linux systems made easy! (Linux Conf Australia 2014)

Linux Conf Australia 2014
Buildroot: building
embedded Linux
systems made easy!
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/29

Thomas Petazzoni
CTO and embedded Linux engineer at
Free Electrons
Embedded Linux expertise
Development, consulting and training
Strong open-source focus
Embedded Linux
Developers
Free Electrons

Thomas Petazzoni
Free Electrons
Open-source contributor
Contributing the kernel support for
Marvell ARM processors
Major contributor to Buildroot, 1600+
patches contributed

Thomas Petazzoni
Free Electrons
Open-source contributor
Living in Toulouse, south west of France

Embedded ?
These days, when you say embedded, most people think:

Embedded ?
These days, when you say embedded, most people think:
Powerful dual/quad ARM/x86 processor
Several GBs of RAM
Dozens of GBs of storage
Full-featured, general-purpose operating system (Android)

Embedded ?
But there are much more embedded systems than just phones and
tablets:

Embedded ?
But there are much more embedded systems than just phones and
tablets:
Very application-speciﬁc →
need a custom Linux system
Less powerful CPUs,
sometimes specialized CPU
architectures
Less RAM (a few dozen to a
few hundred MBs)
Less storage
Long life-time and
maintenance period

Building an embedded Linux system
+ Readily available
- Large, usually 100+ MB
- Not available for all architectures
- Not easy to customize
- Generally require native compilation

+ Smaller and ﬂexible
- Very hard to handle cross-compilation and dependencies
- Not reproducible
- No beneﬁt from other people’s work

+ Small and ﬂexible
+ Reproducible, handles cross-compilation and dependencies
+ Available for virtually all architectures
- One tool to learn
- Build time

Embedded Linux build system: principle
Building from source → lot of ﬂexibility

Cross-compilation → leveraging fast build machines

Cross-compilation → leveraging fast build machines
Recipes for building components → easy

Embedded Linux build system: tools
A wide range of solutions: Yocto/OpenEmbedded, PTXdist,
Buildroot, LTIB, OpenBricks, OpenWRT, and more.

Today, two solutions are emerging as the most popular ones

Yocto/OpenEmbedded
Builds a complete Linux distribution with binary packages.
Powerful, but somewhat complex, and quite steep learning
curve.

Yocto/OpenEmbedded
Builds a complete Linux distribution with binary packages.
Powerful, but somewhat complex, and quite steep learning
curve.
Buildroot
Builds a root ﬁlesystem image, no binary packages. Much
simpler to use, understand and modify.

Buildroot at a glance
Can build a toolchain, a rootfs, a kernel, a bootloader
Easy to configure: menuconfig, xconfig, etc.
Fast: builds a simple root filesystem in a few minutes
Easy to understand: written in make, extensive documentation
Small root filesystem, starting at 2 MB
More than 1000 packages for userspace libraries/apps
available
Many architectures supported
Well-known technologies : make and kconfig
Vendor neutral
Active community, regular releases
http://buildroot.org

Who’s using Buildroot?
System makers
Google
Barco
Rockwell Collins

System makers
Google
Barco
Rockwell Collins
Processor vendors
Analog Devices
Imagination Technologies
Marvell
Atmel

System makers
Google
Barco
Rockwell Collins
Processor vendors
Analog Devices
Imagination Technologies
Marvell
Atmel
Many, many hobbyists on
development boards: Rasberry Pi,
BeagleBone Black, etc.

Getting started
git clone git://git.busybox.net/buildroot
cd buildroot
make menuconfig

Buildroot configuration
1. Target architecture
Architecture
ARC, ARM, AArch64, AVR32,
Blackfin, Microblaze, MIPS, NIOS II,
PowerPC, SuperH, SPARC, x86,
x86 64, Xtensa
Specific processor
ABI
Floating point strategy

2. Build options
Download directory
Number of parallel jobs
Use of ccache
Shared or static libraries
etc.

2. Build options
3. Toolchain
Buildroot toolchain
Buildroot builds the toolchain
uClibc, glibc, eglibc
External toolchain
Uses a pre-built toolchain
Proﬁles for existing popular
toolchains
Linaro, Sourcery CodeBench,
Analog Devices, etc.

2. Build options
3. Toolchain
4. System conﬁguration
Init system to use: Busybox,
Sysvinit, Systemd
/dev management solution: static,
devtmpfs, mdev, udev
Hostname, password, getty
terminal, etc.
Custom post build and post image
scripts
etc.

2. Build options
3. Toolchain
5. Kernel
Kernel source (stable version, Git
tree, patches)
Kernel conﬁguration
Support for RTAI and Xenomai
real-time extensions

2. Build options
3. Toolchain
5. Kernel
6. Target packages
More than 1000 packages
Qt4, Qt5, X.org, Gtk, EFL
GStreamer, ﬀmpeg
Python, Perl, Ruby, Lua
Samba, OpenSSL, OpenSSH,
dropbear, lighttpd
OpenGL support for various
platforms
And many, many more libraries and
utilities

2. Build options
3. Toolchain
5. Kernel
6. Target packages
7. Filesystem images
Major ﬁlesystem formats supported
cloop
cpio, for kernel initramfs
cramfs
ext2/3/4
jﬀs2
romfs
squashfs
tar
ubifs

2. Build options
3. Toolchain
5. Kernel
6. Target packages
8. Bootloaders
Grub
Syslinux
U-Boot
Barebox
and more platform-speciﬁc
bootloaders: imx-bootlets,
at91bootstrap, etc.

2. Build options
3. Toolchain
5. Kernel
6. Target packages
8. Bootloaders
9. Host utilities
Allows to build some native tools,
useful for development.

Example conﬁguration
BR2_arm=y
BR2_arm1176jzf_s=y
BR2_TOOLCHAIN_EXTERNAL=y
BR2_TARGET_GENERIC_GETTY_PORT="tty1"
BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_CUSTOM_GIT=y
BR2_LINUX_KERNEL_CUSTOM_REPO_URL="git://github.com/raspberrypi/linux.git"
BR2_LINUX_KERNEL_CUSTOM_REPO_VERSION="75d03120bc36b1cc3166973b8edc11f033ab7c0d"
BR2_LINUX_KERNEL_DEFCONFIG="bcmrpi_quick"
BR2_LINUX_KERNEL_ZIMAGE=y
BR2_PACKAGE_RPI_FIRMWARE=y
BR2_PACKAGE_I2C_TOOLS=y
BR2_PACKAGE_RPI_USERLAND=y
BR2_PACKAGE_LIBCOFI=y
BR2_PACKAGE_DROPBEAR=y
BR2_PACKAGE_LIGHTTPD=y
BR2_PACKAGE_TVHEADEND=y
ARM1176 platform, external
toolchain
Rasberry-Pi kernel
Rasberry-Pi ﬁrmware
lighttpd web server
tvheadend streaming server
dropbear SSH server
I2C tools

Building and using
To start the build: make
Results in output/images:
rootfs.tar, root filesystem in tar format
rootfs.ubi, root filesystem in UBI format
uImage, Linux kernel image
u-boot.bin, U-Boot bootloader image
Ready to be flashed on your embedded system.

Exploring the build output
All the output produced by Buildroot is stored in output/
Can be customized using O= for out-of-tree build
output/ contains
output/build, with one sub-directory for the source code of
each component
output/host, which contains all native utilities needed for the
build, including the cross-compiler
output/host/usr/<tuple>/sysroot, which contains all the
headers and libraries built for the target
output/target, which contains almost the target root
ﬁlesystem
output/images, the ﬁnal images

Summarized build process
1. Copies the rootfs skeleton to target/
2. Takes care of the cross-compilation toolchain
internal toolchain: Downloads, patches, configures, builds
and installs binutils, gcc, C library and the necessary
dependencies
external toolchain: Copy the necessary bits of the toolchain
into Buildroot output directory.
3. For each selected package, after taking care of its
dependencies: download, extract, patch, configure, build,
install
To target/ for target apps and libs
To host/usr/<tuple>/sysroot for target libs
To host/ for native apps and libs
4. Generate the root filesystem image

Real-world example 1
The device is an ARM AT91-based platform with GPS, RFID
readers, GSM modem, Ethernet and USB.
The Buildroot conﬁguration:
CodeSourcery ARM glibc toolchain
Linux kernel
BusyBox for the basic system
Dropbear for SSH access (debugging)
Qt with only QtCore, QtNetwork and QtXml, no GUI
QExtSerialPort
zlib, libxml2, logrotate, pppd, strace, a special RFID library,
popt library
The Qt application
JFFS2 root ﬁlesystem
Filesystem size: 11 MB. Could be reduced by using uClibc.
Build time: 10 minutes on a fast build server (quad-core i7,
12 GB of RAM)

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

Customizing the build
Besides the existing packages, there are multiple ways to customize
the generated root filesystem:
Create custom post-build and/or post-image scripts
Use a root filesystem overlay, recommended to add all your
config files
Add your own packages

Adding a new package: Config.in (1/2)
package/libmicrohttpd/Conﬁg.in
config BR2_PACKAGE_LIBMICROHTTPD
bool "libmicrohttpd"
depends on BR2_TOOLCHAIN_HAS_THREADS
help
GNU libmicrohttpd is a small C library that makes it easy to
run an HTTP server as part of another application.
http://www.gnu.org/software/libmicrohttpd/
comment "libmicrohttpd needs a toolchain w/ threads"
depends on !BR2_TOOLCHAIN_HAS_THREADS

Adding a new package: Config.in (2/2)
package/Conﬁg.in
[...]
source "package/libmicrohttpd/Config.in"
[...]

Adding a new package: <pkg>.mk
package/libmicrohttpd/libmicrohttpd.mk
LIBMICROHTTPD_VERSION = 0.9.33
LIBMICROHTTPD_SITE = $(BR2_GNU_MIRROR)/libmicrohttpd
LIBMICROHTTPD_LICENSE = LGPLv2.1+
LIBMICROHTTPD_LICENSE_FILES = COPYING
LIBMICROHTTPD_INSTALL_STAGING = YES
LIBMICROHTTPD_CONF_OPT = --disable-spdy
$(eval $(autotools-package))

Adding a new package: infrastructures
In order to factorize similar behavior between packages using
the same build mechanism, Buildroot has package
infrastructures
autotools-package for autoconf/automake based packages
cmake-package for CMake based packages
python-package for Python Distutils and Setuptools based
packages
generic-package for non-standard build systems
Coming: infrastructures for Perl and Lua packages

Legal infrastructure
License compliance is an important topic for embedded Linux
systems
Needs to keep track of the license and source code of each
component
In Buildroot, licensing informations are attached to each
package
The make legal-info target generates:
A licensing manifest, CSV format
License text for all components
Source code for all components

Dependency graphing
make graph-depends
ALL
rpi-ﬁrmware busybox linux tvheadendlibcoﬁ toolchain-external rootfs-tardropbear
lighttpd
rpi-userland i2c-tools
host-python
host-expat
host-autoconf
host-automake
host-libtool
host-zlib
host-pkgconf
host-kmod
host-lzop openssldvb-apps
host-m4
zlibhost-lzo
host-fakeroot host-makedevs host-cmake

Defconfigs
Pre-defined configurations for popular platforms
They build a minimal system for the platform
make <foobar>_defconfig to load one of them
Some of the configs
RasberryPi
BeagleBone
CubieBoard
PandaBoard
Many Atmel development boards
Several Freescale i.MX6 boards
Many Qemu configurations
and more...
make help for the full list

Buildroot, an active project
Releases published
every 3 months

Releases published
every 3 months
Growing number of
contributors: 35-40
diﬀerent contributors
each month

Releases published
every 3 months
Growing number of
contributors: 35-40
each month
Growing activity:
1500-2000
e-mails/month

Releases published
every 3 months
Growing number of
contributors: 35-40
each month
Growing activity:
1500-2000
e-mails/month
Growing number of
packages

Releases published
every 3 months
Growing number of
contributors: 35-40
each month
Growing activity:
1500-2000
e-mails/month
Growing number of
packages
Bi-yearly physical
meeting

Getting support
Documentation:
http://buildroot.org/downloads/manual/manual.html
Mailing list: buildroot@uclibc.org
IRC channel: #buildroot on Freenode
Bug tracker: https://bugs.uclibc.org
Friendly and welcoming community
Companies oﬀering commercial support

Conclusion
Nice : uses well-known technologies and languages, kconﬁg
and make. Active and friendly community.
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.
Eﬃcient : very reasonable build times, only what’s necessary
gets built.

Questions?
http://buildroot.org
Thomas Petazzoni
thomas.petazzoni@free-electrons.com
Slides under CC-BY-SA 3.0
http://free-electrons.com/pub/conferences/2014/lca/buildroot/

Buildroot: building embedded Linux systems made easy! (Linux Conf Australia 2014)

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Empfohlen

Empfohlen (20)

Buildroot: building embedded Linux systems made easy! (Linux Conf Australia 2014)