Preface

• Who this book is for
• What this book covers
• To get the most out of this book
• Get in touch

1. Part 1: Elements of Embedded Linux

2. Starting Out FREE CHAPTER

• Choosing Linux
• When not to choose Linux
• Meeting the players
• Moving through the project life cycle
• The four elements of embedded Linux
• Navigating open source
• Selecting hardware for embedded Linux
• Obtaining the hardware for this book
• Provisioning your development environment
• Summary

3. Learning about Toolchains

• Technical requirements
• Introducing toolchains
• Finding a toolchain
• Anatomy of a toolchain
• Linking with libraries – static and dynamic linking
• Art of cross-compiling
• Summary
• Further study

4. All about Bootloaders

• Technical requirements
• What does a bootloader do?
• Boot sequence
• Moving from the bootloader to the kernel
• Introducing device trees
• U-Boot
• Summary

5. Configuring and Building the Kernel

• Technical requirements
• What does the kernel do?
• Choosing a kernel
• Configuring the kernel
• Compiling with Kbuild
• Building and booting the kernel
• Observing the kernel boot process
• Porting Linux to a new board
• Summary
• Further study

6. Building a Root Filesystem

• Technical requirements
• What should be in the root filesystem?
• Transferring the root filesystem to the target
• Creating a boot initramfs
• 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
• Summary
• Further study

7. Part 2: Building Embedded Linux Images

8. Selecting a Build System

• Technical requirements
• Comparing build systems
• Distributing binaries
• Introducing Buildroot
• Introducing The Yocto Project
• Summary
• Further study

9. Developing with Yocto

• Technical requirements
• Building on top of an existing BSP
• Capturing changes with devtool
• Building your own distro
• Provisioning a remote package server
• Summary
• Further study

10. Yocto under the Hood

• Technical requirements
• Decomposing Yocto’s architecture and workflow
• Separating metadata into layers
• Troubleshooting build failures
• Understanding BitBake syntax and semantics
• Summary
• Further study

11. Part 3: System Architecture and Design Decisions

12. Creating a Storage Strategy

• Technical requirements
• 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
• Summary
• Further study

13. Updating Software in the Field

• Technical requirements
• From where do updates originate?
• What to update
• Basics of software updates
• Types of update mechanism
• OTA updates
• Using Mender for local updates
• Using Mender for OTA updates
• Using SWUpdate for local updates
• Summary

14. Interfacing with Device Drivers

• Technical requirements
• 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
• Summary
• Further study

15. Prototyping with Add-On Boards

• Technical requirements
• Mapping schematics to pins
• Prototyping with add-on boards
• Testing hardware peripherals
• Summary
• Further study

16. Starting Up – The init Program

• Technical requirements
• After the kernel has booted
• Introducing the init programs
• BusyBox init
• System V init
• systemd
• Summary
• Further study

17. Managing Power

• Technical requirements
• Measuring power usage
• Scaling the clock frequency
• Selecting the best idle state
• Powering down peripherals
• Putting the system to sleep
• Summary
• Further study

18. Part 4: Developing Applications

19. Packaging Python

• Technical requirements
• Retracing the origins of Python packaging
• Installing Python packages with pip
• Managing Python virtual environments with venv
• Installing precompiled binaries with conda
• Summary
• Further study

20. Deploying Container Images

• Technical requirements
• What is DevOps?
• DevOps and Embedded Linux
• Deploying Python applications with Docker
• Setting up a CI/CD pipeline for a Python application
• Adding Docker to a Yocto image
• Updating software with Docker
• Summary
• Further study

21. Learning about Processes and Threads

• Technical requirements
• Process or thread?
• Processes
• Threads
• ZeroMQ
• Scheduling
• Summary
• Further study

22. Managing Memory

• Technical requirements
• Virtual memory basics
• Kernel-space memory layout
• User-space memory layout
• 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
• Summary
• Further study

23. Part 5: Debugging and Optimizing Performance

24. Debugging with GDB

• Technical requirements
• GNU debugger
• Preparing to debug
• Debugging applications
• Just-in-time debugging
• Debugging forks and threads
• Core files
• GDB user interfaces
• Debugging kernel code
• Summary
• Further study

25. Profiling and Tracing

• Technical requirements
• Observer effect
• Beginning to profile
• Introducing perf
• Tracing events
• Introducing Ftrace
• Using LTTng
• Using eBPF
• Using Valgrind
• Using strace
• Summary
• Further study

26. Real-Time Programming

• Technical requirements
• What is real time?
• Identifying sources of non-determinism
• Understanding scheduling latency
• Kernel preemption
• Preemptible kernel locks
• High-resolution timers
• Avoiding page faults
• Interrupt shielding
• Measuring scheduling latencies
• Summary
• Further study

27. Index

• Download a Free PDF Copy of This Book