Book Image

Mastering Embedded Linux Programming - Second Edition

By : Chris Simmonds
Book Image

Mastering Embedded Linux Programming - Second Edition

By: Chris Simmonds

Overview of this book

Embedded Linux runs many of the devices we use every day, from smart TVs to WiFi routers, test equipment to industrial controllers - all of them have Linux at their heart. Linux is a core technology in the implementation of the inter-connected world of the Internet of Things. The comprehensive guide shows you the technologies and techniques required to build Linux into embedded systems. You will begin by learning about the fundamental elements that underpin all embedded Linux projects: the toolchain, the bootloader, the kernel, and the root filesystem. You’ll see how to create each of these elements from scratch, and how to automate the process using Buildroot and the Yocto Project. Moving on, you’ll find out how to implement an effective storage strategy for flash memory chips, and how to install updates to the device remotely once it is deployed. You’ll also get to know the key aspects of writing code for embedded Linux, such as how to access hardware from applications, the implications of writing multi-threaded code, and techniques to manage memory in an efficient way. The final chapters show you how to debug your code, both in applications and in the Linux kernel, and how to profile the system so that you can look out for performance bottlenecks. By the end of the book, you will have a complete overview of the steps required to create a successful embedded Linux system.

Related Content you might be interested in

Current Title:

Small book image
Mastering Embedded Linux Programming - Second Edition
Chris Simmonds
Jun, 2017 | 478 pages
Small book image
Embedded Linux Development Using Yocto Project Cookbook.
Alex Gonzalez
Jan, 2018 | 456 pages
Small book image
GNU/Linux Rapid Embedded Programming
Rodolfo Giometti
Mar, 2017 | 732 pages
Small book image
Embedded Linux Development using Yocto Projects
Otavio Salvador | Daiane Angolini
Nov, 2017 | 162 pages
Table of Contents (17 chapters)
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Free Chapter
1
Starting Out
Starting Out
Selecting the right operating system
The players
Project life cycle
Open source
Hardware for embedded Linux
Hardware used in this book
Software used in this book
Summary
2
Learning About Toolchains
Learning About Toolchains
Introducing toolchains
Finding a toolchain
Building a toolchain using crosstool-NG
Anatomy of a toolchain
Linking with libraries – static and dynamic linking
The art of cross compiling
Summary
3
All About Bootloaders
All About Bootloaders
What does a bootloader do?
The boot sequence
Booting with UEFI firmware
Moving from bootloader to kernel
Introducing device trees
Choosing a bootloader
U-Boot
Barebox
Summary
4
Configuring and Building the Kernel
Configuring and Building the Kernel
What does the kernel do?
Choosing a kernel
Building the kernel
Compiling – Kbuild
Booting the kernel
Porting Linux to a new board
Additional reading
Summary
5
Building a Root Filesystem
Building a Root Filesystem
What should be in the root filesystem?
Transferring the root filesystem to the target
Creating a boot initramfs
The init program
Configuring user accounts
A better way of managing device nodes
Configuring the network
Creating filesystem images with device tables
Mounting the root filesystem using NFS
Using TFTP to load the kernel
Additional reading
Summary
6
Selecting a Build System
Selecting a Build System
Build systems
Package formats and package managers
Buildroot
The Yocto Project
Further reading
Summary
7
Creating a Storage Strategy
Creating a Storage Strategy
Storage options
Accessing flash memory from the bootloader
Accessing flash memory from Linux
Filesystems for flash memory
Filesystems for NOR and NAND flash memory
Filesystems for managed flash
Read-only compressed filesystems
Temporary filesystems
Making the root filesystem read-only
Filesystem choices
Further reading
Summary
8
Updating Software in the Field
Updating Software in the Field
What to update?
The basics of software update
Types of update mechanism
OTA updates
Using Mender for local updates
Using Mender for OTA updates
Summary
9
Interfacing with Device Drivers
Interfacing with Device Drivers
The role of device drivers
Character devices
Block devices
Network devices
Finding out about drivers at runtime
Finding the right device driver
Device drivers in user space
Writing a kernel device driver
Discovering the hardware configuration
Additional reading
Summary
10
Starting Up – The init Program
Starting Up – The init Program
After the kernel has booted
Introducing the init programs
BusyBox init
System V init
systemd
Further reading
Summary
11
Managing Power
Managing Power
Measuring power usage
Scaling the clock frequency
Selecting the best idle state
Powering down peripherals
Putting the system to sleep
Further reading
Summary
12
Learning About Processes and Threads
Learning About Processes and Threads
Process or thread?
Processes
Threads
Scheduling
Further reading
Summary
13
Managing Memory
Managing Memory
Virtual memory basics
Kernel space memory layout
User space memory layout
The process memory map
Swapping
Mapping memory with mmap
How much memory does my application use?
Per-process memory usage
Identifying memory leaks
Running out of memory
Further reading
Summary
14
Debugging with GDB
Debugging with GDB
The GNU debugger
Preparing to debug
Debugging applications
Just-in-time debugging
Debugging forks and threads
Core files
GDB user interfaces
Debugging kernel code
Further reading
Summary
15
Profiling and Tracing
Profiling and Tracing
The observer effect
Beginning to profile
Profiling with top
Poor man's profiler
Introducing perf
Other profilers – OProfile and gprof
Tracing events
Introducing Ftrace
Using LTTng
Using Valgrind
Using strace
Summary
16
Real-Time Programming
Real-Time Programming
What is real time?
Identifying sources of non-determinism
Understanding scheduling latency
Kernel preemption
The real-time Linux kernel (PREEMPT_RT)
Preemptible kernel locks
High-resolution timers
Avoiding page faults
Interrupt shielding
Measuring scheduling latencies
Further reading
Summary

Storage options

Embedded devices need storage that takes little power and is physically compact, robust, and reliable over a lifetime of perhaps tens of years. In almost all cases, this means solid-state storage. Solid-state storage was introduced many years ago with read-only memory (ROM), but for the past 20 years, it has been flash memory of some kind. There have been several generations of flash memory in that time, progressing from NOR to NAND to managed flash such as eMMC.

NOR flash is expensive but reliable and can be mapped into the CPU address space, which allows you to execute code directly from flash. NOR flash chips are low capacity, ranging from a few megabytes to a gigabyte or so.

NAND flash memory is much cheaper than NOR and is available in higher capacities, in the range of tens of megabytes to tens of gigabytes. However, it needs a lot of hardware and software...

Previous Section
End of Section 2
Next Section