Pro Linux Embedded Systems

Contents at a Glance

Table of contents

About the Author

About the Technical Reviewer

Acknowledgments

Introduction

CHAPTER 1 About Embedded Linux

Why Use Embedded Linux?

Technical Reasons to Use Embedded Linux

Standards Based

Process Isolation and Control

Peripheral Support

Security

Commercial Reasons to Use Embedded Linux

10,000-Foot Embedded Linux Development Flyover

Target Hardware

Obtaining Linux

Booting Linux

Development Environment

System Design

Anatomy of an Embedded Linux System

Boot Loader

Kernel

Root File System

Your Application

Cross-Compiler

Tools of the Trade

The GNU Compiler Collection

GDB

BusyBox

uClibc

Automake/Autoconf

Packaging Systems

Patch

Make

Where to Get Help

University of Google

Mailing Lists and Newsgroups

Etiquette

Trade Group and Community Interest Sites

Vendor-Sponsored Resources

IRC

Next Up

CHAPTER 2 Configuring the Software Environment

Host Services

Host Environment

Linux

Debian (Ubuntu) Systems

RPM

Windows

Cygwin

Virtual Linux Machines on Windows

Turn Off Your Firewall

TFTP

DHCP

NFS

NFS with Cygwin

PXE

Cabling

Serial (for Console)

Network

Avoiding an Angry Visit from IT

Dual-Homed Host

CHAPTER 3 Target Emulationand Virtual Machines

Why Target Emulation?

Emulation via QEMU

Compiling QEMU

Using QEMU to Emulate a Target

Using QEMU to Compile under Emulation

Virtualization Software for x86 Hosts

Approaches to Virtualization

Summary

CHAPTER 4 Starting Your Project

Most Boards Include a Linux Distribution

What to Do After Unpacking the Board

Have Linux? Boot It!

Assess the Kernel

Locate Sources and Patches

Locate the Configuration

Understand the RFS

File System Format

Locate Sources for the Root File System

Devices and In-Memory File Systems

Suitability for Your Project

Cross-Compiler

Moving Forward

CHAPTER 5 Getting Linux for Your Board

Obtaining Linux from the Board Vendor

Questions You Should Ask Your Board Vendor

Now That You’re a Customer…

Open Source Embedded Distributions

Why Embedded Linux Distribution Builders Exist

Should You Use One?

Popular Open Source Embedded Distributions

LTIB (http://www.bitshrine.org)

Buildroot (http://buildroot.uclibc.org/)

OpenEmbedded (http://wiki.openembedded.net/)

Getting Linux from Commercial Vendors and Consultants

Do You Need a Commercial Vendor?

What You Should Expect

Roundup of Vendors

Wind River

MontaVista

Embedded Alley

DENX

Free Electrons

Code Sourcery

What’s Next

CHAPTER 6 Creating a Linux Distributionfrom Scratch

Cross-Compiler Basics

A Note about Building Software

Get Comfortable with the Command Line

Overview of Building a GCC Cross-Compiler

The C Library

Gathering Sources

Getting Sources via Source Control

Getting via Source Archives

Building GCC

The Build Environment

Binutils

Kernel Headers

Bootstrap (Stage 1) GCC

Creating Glibc Headers

Building Glibc

Building the Next GCC

Building GMP and MPFR

Building the Final GCC

Building Toolchains with Crosstool-NG

Creating the Root File System

Configuring the Environment

Building and Installing BusyBox

Libraries

Finishing Touches

Building the Kernel

Troubleshooting Booting Problems

Improperly Configured Board

The Root File System Can’t Be Mounted

The Root File System init Program Doesn’t Run

Distributing the Distribution

Wrapping Up

CHAPTER 7 Booting the Board

Booting a Linux System Is a Three-Act Play

The Boot Loader

Kernel-Land vs. Userland

Boot Loaders

RedBoot

YAMON

Das U-Boot

LILO

GRUB

About Flash Memory

Kernel Startup

The Kernel Entry Point

Sysfs and Device Management

Finding a Root File System

Userland Startup

What an Init Program Needs to Do

Mysteries of the /etc/init.d Directory

BusyBox Init

Your Init

What’s Next

CHAPTER 8 Configuring the ApplicationDevelopment Environment

Pick the Right Tool for the Job

Know Your Application

Hardware Constraints

Software Constraints

What to Use for Development

C

C++

Java

Java Runtime Environment

Embedding Java: Using GCJ

Compiling Java Code with GCJ

Embedded GCJ

Non-Traditional Embedded Languages

Python

Embedding Python

Debugging

TCL

Embedding TCL

Debugging

Shell Scripting

Embedded Shell Scripting

PHP

Embedding PHP

Performance and Profiling Tools

Profiling

Gprof Option Reference

Leak Detection

dmalloc

Mpatrol

Static Analysis

IDE

Your Editor + Make + Shell

Using Make

Eclipse

Installing Eclipse and Plug-ins

Using Eclipse

What’s Next

CHAPTER 9 Application Development

Getting Started on Your Application

Desktop vs. Target

Coding for Portability

System Differences

FIFO

Hello World

Getting the Tools

Making Make Work

Running the Code on the Target

More Complex Projects

Getting Ready for Debugging

What’s Next

CHAPTER 10 Debugging Applications

Getting Started on Your Application

Types of Debugging

Remote Debugging Overview

Debugging C and C++

Building GDB

GDB Front Ends

Compiling for Debugging

GDB Command Line Survival Guide

Remote Debugging with DDD

Remote Debugging with GNU Emacs

Remote Debugging with Eclipse

Debugging Java

Instrumentation

Java Instrumentation

Instrumentation in Scripting Languages

What’s Next

CHAPTER 11 Kernel Configurationand Development

Kernel Project Layout

Downloading the Kernel

Downloading a Compressed Tar File

Using Git to Clone the Repository

Building the Kernel

How Kernel Configuration Works

Default Configurations

Editing .config By Hand

Building the Kernel

Building Modules

Cleaning Up

Open Source Community

The Kernel Development Process

Contributing to the Linux Kernel

Applying Patches

What’s Next

CHAPTER 12 Real Time

Real-Time Core Concepts

Deadline

Latency

Jitter

Predictability

Worst Case

Priority Inversion

Periodic Task

The Linux Scheduler

Group Scheduling

Real-Time Scheduler

Real-Time Implementation in Linux

Getting the Patch

Real-Time Programming Practices

The One Real-Time Process

Lock Memory

Avoid the Heap

Asking for Priority Inheritance Mutexes

I/O Is Nondeterministic

Using Thread Pools

LatencyTOP

Common Hardware Pitfalls

System Management Interrupts

VGA Console

DMA Bus Mastering

Summary

CHAPTER 13 Using Open Source Software Projects

Using Open Source Packages

How an Open Source Project Is Structured

The Project Team Isn’t Your Extended Workforce

Understand the Licensing

Permissive vs. Restrictive Licenses

Common Licensing Types

Downloading

Using Source Control Systems to Fetch Code

Using CVS

Using Subversion

Using Git

Using Mercurial

Cross-Compiling

Using configure

Creating the Script

Gaming the Cache

Installation

Setting Other Configure Options

Configuration Process for Non-Automake Projects

Building and Installing

Commonly Used Projects

DirectFB

Dropbear

QT/Qtopia

JamVM

Rzsz

Netcat

TinyXML

Micro_httpd

Stupid-FTPd

Quagga

Tslib

fgetty

CHAPTER 14 BusyBox

How a BusyBox-Based System Is Structured

Building a BusyBox-Based System

Download the Software

Configure

Build

Install

Copy Libraries

Add Help Text

Default Init Scripts

Update Permissions

Create Additional Folders

Create Device Nodes

What Makes BusyBox Small?

Creating Your Own Applet

Create the Applet Code

Add the Applet to the Make File

Register Applet with BusyBox

Build and Verify

Getting Help

What’s Next

CHAPTER 15 System Design

The Big Picture

Configuring the Boot Loader and Kernel

U-Boot

Other Boot loaders

Execute in Place

Selecting a Root File System

Block-Based File Systems

Ext2

Ext3

SquashFS

CramFS

Romfs

MINIX

MTD File Systems

JFFS2

YAFFS2

RAM Buffer–Based File Systems

Rafms

Tmpfs

Initramfs

File System Pairings

Assembling a Root File System

Create the Staging Area

Create a Directory Skeleton

Gather Libraries and Required Files

Required Files

Create Initialization Scripts

Using Init and Inittab

Using a Script

Using a Program

Set Ownership and Permissions

Security

Built-In Security

SELinux

Reference Policies

Using SEEdit

PAM

What’s Next

CHAPTER 16 System Tuning

Three or Fewer Megabytes

16–32 Megabytes

More than a Gigabyte

Reducing the Size of the Root File System

Start from Zero

Mounting Small File Systems

Shared Libraries

Compiling to Save Space

GCCs -Os

Static Linking

Stripping

Reducing the Size of the Kernel

Removing Unneeded Features and Drivers

Recommendations for Embedded Systems

Measuring

Using the Bloat-O-Meter

Minimizing Boot Time

Reducing Kernel Boot-Up Time

Uncompressed Kernel Image

No Console Output on Boot

Deferred Initialization

No Kernel Modules

Reducing Kernel Boot-Up Time

Uncompressed Kernel Image

No Console Output on Boot

Deferred Initialization

No Kernel Modules

Measuring Kernel Boot-Up Times

/proc/uptime

Grabserial

Initcall_debug

Reducing Root File System Startup Times

Use a Read-Only File System

Replacing Initialization Scripts

Inittab Abuse

Link with GNU Hash Style

What’s Next

CHAPTER 17 Deploying Applications

Deployment for Embedded Devices

Requirements

Industrial Design

Mechanical Design

Electrical Engineering

Manufacturing Engineering

Software Design

Software Engineering

Manufacturing

Deployment Strategies and Tactics

Boot Loaders

In General

UBOOT: Configuring Initial Parameters

Expect

Installing Expect

Expect on Windows

Using Expect

Boot Loaders Are Just Programs

Deployment Root File Systems

Application Files and Libraries

Small Root File Systems

First Field Update at the Factory

What’s Next

CHAPTER 18 Handling Field Updates

Root File System Updates

Basic Strategies

Forklift Upgrade

Designing for Forklift Upgrades

MTD Utilities

Forklift-Upgrade Example

Parallel Systems

Parallel System Example

Do It Yourself

Do-It-Yourself Example

Using Package Managers

RPM

Dpkg

Ipkg

Initramfs Root File Systems

Kernel Updates

Basic Strategies

Update Kernel Modules

Forklift Upgrade

Modules

Using Modprobe

Roll Your Own

Forklift

Field Update Failures

Report Failure, Stop

Failsafe Root File System

Failsafe Kernel

In Summary

Index