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

Scaling the clock frequency

Running for a kilometer takes more energy than walking. In a similar way, maybe running the CPU at a lower frequency can save energy. Let's see.

The power consumption of a CPU when executing code is the sum of a static component, caused by gate leakage current, among other things, and a dynamic component, caused by switching of the gates:

Pcpu = Pstatic + Pdyn

The dynamic power component is dependent on the total capacitance of the logic gates being switched, the clock frequency, and the square of the voltage:

Pdyn = CfV2

From this, we can see that changing the frequency by itself is not going to save any power because the same number of CPU cycles have to be completed in order to execute a given subroutine. If we reduce the frequency by half, it will take twice as long to complete the calculation, but the total power consumed due to the dynamic...

Previous Section
End of Section 3
Next Section