Mastering Embedded Linux Programming - Second Edition电子书

Title Page

Mastering Embedded Linux Programming

Second Edition

Copyright

Mastering Embedded Linux Programming

Second Edition

Credits

About the Author

About the Reviewers

www.PacktPub.com

Why subscribe?

Customer Feedback

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Starting Out

Selecting the right operating system

The players

Project life cycle

The four elements of embedded Linux

Open source

Licenses

Hardware for embedded Linux

Hardware used in this book

The BeagleBone Black

QEMU

Software used in this book

Summary

Learning About Toolchains

Introducing toolchains

Types of toolchains

CPU architectures

Choosing the C library

Finding a toolchain

Building a toolchain using crosstool-NG

Installing crosstool-NG

Building a toolchain for BeagleBone Black

Building a toolchain for QEMU

Anatomy of a toolchain

Finding out about your cross compiler

The sysroot, library, and header files

Other tools in the toolchain

Looking at the components of the C library

Linking with libraries – static and dynamic linking

Static libraries

Shared libraries

Understanding shared library version numbers

The art of cross compiling

Simple makefiles

Autotools

An example: SQLite

Package configuration

Problems with cross compiling

Summary

All About Bootloaders

What does a bootloader do?

The boot sequence

Phase 1 – ROM code

Phase 2 – secondary program loader

Phase 3 – TPL

Booting with UEFI firmware

Moving from bootloader to kernel

Introducing device trees

Device tree basics

The reg property

Labels and interrupts

Device tree include files

Compiling a device tree

Choosing a bootloader

U-Boot

Building U-Boot

Installing U-Boot

Using U-Boot

Environment variables

Boot image format

Loading images

Booting Linux

Automating the boot with U-Boot scripts

Porting U-Boot to a new board

Board-specific files

Configuring header files

Building and testing

Falcon mode

Barebox

Getting barebox

Building barebox

Using barebox

Summary

Configuring and Building the Kernel

What does the kernel do?

Choosing a kernel

Kernel development cycle

Stable and long term support releases

Vendor support

Licensing

Building the kernel

Getting the source

Understanding kernel configuration – Kconfig

Using LOCALVERSION to identify your kernel

Kernel modules

Compiling – Kbuild

Finding out which kernel target to build

Build artifacts

Compiling device trees

Compiling modules

Cleaning kernel sources

Building a kernel for the BeagleBone Black

Building a kernel for QEMU

Booting the kernel

Booting the BeagleBone Black

Booting QEMU

Kernel panic

Early user space

Kernel messages

Kernel command line

Porting Linux to a new board

A new device tree

Setting the board compatible property

Additional reading

Summary

Building a Root Filesystem

What should be in the root filesystem?

The directory layout

The staging directory

POSIX file access permissions

File ownership permissions in the staging directory

Programs for the root filesystem

The init program

Shell

Utilities

BusyBox to the rescue!

Building BusyBox

ToyBox – an alternative to BusyBox

Libraries for the root filesystem

Reducing the size by stripping

Device nodes

The proc and sysfs filesystems

Mounting filesystems

Kernel modules

Transferring the root filesystem to the target

Creating a boot initramfs

Standalone initramfs

Booting the initramfs

Booting with QEMU

Booting the BeagleBone Black

Mounting proc

Building an initramfs into the kernel image

Building an initramfs using a device table

The old initrd format

The init program

Starting a daemon process

Configuring user accounts

Adding user accounts to the root filesystem

A better way of managing device nodes

An example using devtmpfs

An example using mdev

Are static device nodes so bad after all?

Configuring the network

Network components for glibc

Creating filesystem images with device tables

Booting the BeagleBone Black

Mounting the root filesystem using NFS

Testing with QEMU

Testing with the BeagleBone Black

Problems with file permissions

Using TFTP to load the kernel

Additional reading

Summary

Selecting a Build System

Build systems

Package formats and package managers

Buildroot

Background

Stable releases and long-term support

Installing

Configuring

Running

Creating a custom BSP

U-Boot

Linux

Build

Adding your own code

Overlays

Adding a package

License compliance

The Yocto Project

Background

Stable releases and supports

Installing the Yocto Project

Configuring

Building

Running the QEMU target

Layers

BitBake and recipes

Customizing images via local.conf

Writing an image recipe

Creating an SDK

The license audit

Further reading

Summary

Creating a Storage Strategy

Storage options

NOR flash

NAND flash

Managed flash

MultiMediaCard and Secure Digital cards

eMMC

Other types of managed flash

Accessing flash memory from the bootloader

U-Boot and NOR flash

U-Boot and NAND flash

U-Boot and MMC, SD, and eMMC

Accessing flash memory from Linux

Memory technology devices

MTD partitions

MTD device drivers

The MTD character device, mtd

The MTD block device, mtdblock

Logging kernel oops to MTD

Simulating NAND memory

The MMC block driver

Filesystems for flash memory

Flash translation layers

Filesystems for NOR and NAND flash memory

JFFS2

Summary nodes

Clean markers

Creating a JFFS2 filesystem

YAFFS2

Creating a YAFFS2 filesystem

UBI and UBIFS

UBI

UBIFS

Filesystems for managed flash

Flashbench

Discard and TRIM

Ext4

F2FS

FAT16/32

Read-only compressed filesystems

squashfs

Temporary filesystems

Making the root filesystem read-only

Filesystem choices

Further reading

Summary

Updating Software in the Field

What to update?

Bootloader

Kernel

Root filesystem

System applications

Device-specific data

Components that need to be updated

The basics of software update

Making updates robust

Making updates fail-safe

Making updates secure

Types of update mechanism

Symmetric image update

Asymmetric image update

Atomic file updates

OTA updates

Using Mender for local updates

Building the Mender client

Installing an update

Using Mender for OTA updates

Summary

Interfacing with Device Drivers

The role of device drivers

Character devices

Block devices

Network devices

Finding out about drivers at runtime

Getting information from sysfs

The devices: /sys/devices

The drivers: /sys/class

The block drivers: /sys/block

Finding the right device driver

Device drivers in user space

GPIO

Handling interrupts from GPIO

LEDs

I2C

Serial Peripheral Interface (SPI)

Writing a kernel device driver

Designing a character driver interface

The anatomy of a device driver

Compiling kernel modules

Loading kernel modules

Discovering the hardware configuration

Device trees

The platform data

Linking hardware with device drivers

Additional reading

Summary

Starting Up – The init Program

After the kernel has booted

Introducing the init programs

BusyBox init

Buildroot init scripts

System V init

inittab

The init.d scripts

Adding a new daemon

Starting and stopping services

systemd

Building systemd with the Yocto Project and Buildroot

Introducing targets, services, and units

Units

Services

Targets

How systemd boots the system

Adding your own service

Adding a watchdog

Implications for embedded Linux

Further reading

Summary

Managing Power

Measuring power usage

Scaling the clock frequency

The CPUFreq driver

Using CPUFreq

Selecting the best idle state

The CPUIdle driver

Tickless operation

Powering down peripherals

Putting the system to sleep

Power states

Wakeup events

Timed wakeups from the real-time clock

Further reading

Summary

Learning About Processes and Threads

Process or thread?

Processes

Creating a new process

Terminating a process

Running a different program

Daemons

Inter-process communication

Message-based IPC

Unix (or local) sockets

FIFOs and named pipes

POSIX message queues

Summary of message-based IPC

Shared memory-based IPC

POSIX shared memory

Threads

Creating a new thread

Terminating a thread

Compiling a program with threads

Inter-thread communication

Mutual exclusion

Changing conditions

Partitioning the problem

Scheduling

Fairness versus determinism

Time-shared policies

Niceness

Real-time policies

Choosing a policy

Choosing a real-time priority

Further reading

Summary

Managing Memory

Virtual memory basics

Kernel space memory layout

How much memory does the kernel use?

User space memory layout

The process memory map

Swapping

Swapping to compressed memory (zram)

Mapping memory with mmap

Using mmap to allocate private memory

Using mmap to share memory

Using mmap to access device memory

How much memory does my application use?

Per-process memory usage

Using top and ps

Using smem

Other tools to consider

Identifying memory leaks

mtrace

Valgrind

Running out of memory

Further reading

Summary

Debugging with GDB

The GNU debugger

Preparing to debug

Debugging applications

Remote debugging using gdbserver

Setting up the Yocto Project for remote debugging

Setting up Buildroot for remote debugging

Starting to debug

Connecting GDB and gdbserver

Setting the sysroot

GDB command files

Overview of GDB commands

Breakpoints

Running and stepping

Getting information

Running to a breakpoint

Native debugging

The Yocto Project

Buildroot

Just-in-time debugging

Debugging forks and threads

Core files

Using GDB to look at core files

GDB user interfaces

Terminal user interface

Data display debugger

Eclipse

Debugging kernel code

Debugging kernel code with kgdb

A sample debug session

Debugging early code

Debugging modules

Debugging kernel code with kdb

Looking at an Oops

Preserving the Oops

Further reading

Summary

Profiling and Tracing

The observer effect

Symbol tables and compile flags

Beginning to profile

Profiling with top

Poor man's profiler

Introducing perf

Configuring the kernel for perf

Building perf with the Yocto Project

Building perf with Buildroot

Profiling with perf

Call graphs

perf annotate

Other profilers – OProfile and gprof

Tracing events

Introducing Ftrace

Preparing to use Ftrace

Using Ftrace

Dynamic Ftrace and trace filters

Trace events

Using LTTng

LTTng and the Yocto Project

LTTng and Buildroot

Using LTTng for kernel tracing

Using Valgrind

Callgrind

Helgrind

Using strace

Summary

Real-Time Programming

What is real time?

Identifying sources of non-determinism

Understanding scheduling latency

Kernel preemption

The real-time Linux kernel (PREEMPT_RT)

Threaded interrupt handlers

Preemptible kernel locks

Getting the PREEMPT_RT patches

The Yocto Project and PREEMPT_RT

High-resolution timers

Avoiding page faults

Interrupt shielding

Measuring scheduling latencies

cyclictest

Using Ftrace

Combining cyclictest and Ftrace

Further reading

Summary