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

Finding out about drivers at runtime

Once you have a running Linux system, it is useful to know which device drivers are loaded and what state they are in. You can find out a lot by reading the files in /proc and /sys.

First of all, you can list the character and block device drivers currently loaded and active by reading /proc/devices:

# cat /proc/devices
Character devices:
  1 mem 
  2 pty 
  3 ttyp 
  4 /dev/vc/0 
  4 tty 
  4 ttyS 
  5 /dev/tty 
  5 /dev/console 
  5 /dev/ptmx 
  7 vcs 
 10 misc 
 13 input 
 29 fb 
 81 video4linux 
 89 i2c 
 90 mtd 
116 alsa 
128 ptm 
136 pts 
153 spi 
180 usb 
189 usb_device 
204 ttySC 
204 ttyAMA 
207 ttymxc 
226 drm 
239 ttyLP 
240 ttyTHS 
241 ttySiRF 
242 ttyPS 
243 ttyWMT 
244 ttyAS 
245 ttyO 
246 ttyMSM 
247 ttyAML 
248 bsg 
249 iio 
250 watchdog 
251 ptp 
252 pps 
253 media 
254 rtc 

Block devices:
259 blkext 
  7 loop 
  8 sd 
 11 sr 
 31 mtdblock 
 65 sd 
 66 sd 
 67 sd 
 68 sd 
 69...
Previous Section
End of Section 6
Next Section