book

Pro Linux Embedded Systems

Name: Pro Linux Embedded Systems
Author: Gene Sally
ISBN: 9781430272274

by Gene Sally

December 2009

Intermediate to advanced

550 pages

12h 57m

English

Apress

Read now

Unlock full access

Copyright
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
1. About Embedded Linux
1.1. Why Use Embedded Linux?1.1.1. Technical Reasons to Use Embedded Linux1.1.1.1. Standards Based1.1.1.2. Process Isolation and Control1.1.1.2.1. Manage and Isolate Tasks1.1.1.2.2. Memory Management and Linux1.1.1.2.3. Uniform Interface to Resources1.1.1.2.4. System Calls1.1.1.3. Peripheral Support1.1.1.4. Security1.1.1.4.1. SELinux1.1.1.4.2. PAM1.1.1.4.3. IPsec1.1.2. Commercial Reasons to Use Embedded Linux1.1.2.1.1.1.2.1.1. Complete Software Ecosystem1.1.2.1.2. No Royalties1.1.2.1.3. Control1.2. 10,000-Foot Embedded Linux Development Flyover1.2.1. Target Hardware1.2.2. Obtaining Linux1.2.3. Booting Linux1.2.4. Development Environment1.2.5. System Design1.3. Anatomy of an Embedded Linux System1.3.1. Boot Loader1.3.2. Kernel1.3.3. Root File System1.3.4. Your Application1.3.5. Cross-Compiler1.3.6. Tools of the Trade1.3.6.1. The GNU Compiler Collection1.3.6.1.1. GDB1.3.6.2. BusyBox1.3.6.3. uClibc1.3.6.4. Automake/Autoconf1.3.6.5. Packaging Systems1.3.6.6. Patch1.3.6.7. Make1.4. Where to Get Help1.4.1. University of Google1.4.2. Mailing Lists and Newsgroups1.4.2.1. Etiquette1.4.3. Vendor-Sponsored Resources1.4.4. Trade Group and Community Interest Sites1.4.5. IRC1.5. Next Up
2. Configuring the Software Environment
2.1. Host Environment2.1.1. Linux2.1.1.1. Debian (Ubuntu) Systems2.1.1.2. RPM2.1.2. Windows2.1.2.1. Cygwin2.1.2.1.1. Installation2.1.2.1.2. Cygwin's View of the File System2.1.2.2. Virtual Linux Machines on Windows2.1.2.2.1. Using VirtualBox2.2. Host Services2.2.1. Turn Off Your Firewall2.2.2. TFTP2.2.3. DHCP2.2.4. NFS2.2.4.1. NFS with Cygwin2.2.5. PXE2.3. Cabling2.3.1. Serial (for Console)2.3.2. Network2.4. Avoiding an Angry Visit from IT2.4.1. Dual-Homed Host
3. Target Emulation and Virtual Machines
3.1. Why Target Emulation?3.2. Emulation via QEMU3.2.1. Compiling QEMU3.2.2. Using QEMU to Emulate a Target3.2.3. Using QEMU to Compile under Emulation3.3. Virtualization Software for x86 Hosts3.3.1. Approaches to Virtualization3.4. Summary
4. Starting Your Project
4.1. Most Boards Include a Linux Distribution4.2. What to Do After Unpacking the Board4.2.1. Have Linux? Boot It!4.2.2. Assess the Kernel4.2.2.1. Locate Sources and Patches4.2.2.2. Locate the Configuration4.2.3. Understand the RFS4.2.3.1. File System Format4.2.3.2. Locate Sources for the Root File System4.2.3.3. Devices and In-Memory File Systems4.3. Suitability for Your Project4.3.1. Cross-Compiler4.4. Moving Forward
5. Getting Linux for Your Board
5.1. Obtaining Linux from the Board Vendor5.1.1. Questions You Should Ask Your Board Vendor5.1.2. Now That You're a Customer...5.2. Open Source Embedded Distributions5.2.1. Why Embedded Linux Distribution Builders Exist5.2.2. Should You Use One?5.2.3. Popular Open Source Embedded Distributions5.2.3.1. LTIB (http://www.bitshrine.org)5.2.3.1.1. Using LTIB5.2.3.1.2. LTIB Tricks5.2.3.1.3. Getting Help5.2.3.2. Buildroot (http://buildroot.uclibc.org/)5.2.3.2.1. Using Buildroot5.2.3.2.2. Buildroot Tricks5.2.3.2.3. Getting Help5.2.3.3. OpenEmbedded (http://wiki.openembedded.net/)5.2.3.3.1. Using OpenEmbedded5.2.3.3.2. Getting Help5.3. Getting Linux from Commercial Vendors and Consultants5.3.1. Do You Need a Commercial Vendor?5.3.2. What You Should Expect5.3.3. Roundup of Vendors5.3.3.1. Wind River5.3.3.2. MontaVista5.3.3.3. Embedded Alley5.3.3.4. DENX5.3.3.5. Free Electrons5.3.3.6. Code Sourcery5.4. What's Next

6. Creating a Linux Distribution from Scratch
6.1. Cross-Compiler Basics6.1.1. A Note about Building Software6.1.2. Get Comfortable with the Command Line6.2. Overview of Building a GCC Cross-Compiler6.2.1. The C Library6.2.2. Gathering Sources6.2.2.1. Getting Sources via Source Control6.2.2.1.1. Binutils6.2.2.1.2. GCC6.2.2.1.3. Glibc6.2.2.1.4. GMP and MPFR6.2.2.1.5. A Linux Kernel6.2.2.2. Getting via Source Archives6.2.2.2.1. Binutils6.2.2.2.2. Glibc6.2.2.2.3. GCC6.2.2.2.4. GMP and MPFR6.2.2.2.5. A Linux Kernel6.2.3. Building GCC6.2.3.1. The Build Environment6.2.3.2. Binutils6.2.3.3. Kernel Headers6.2.3.4. Bootstrap (Stage 1) GCC6.2.3.5. Creating Glibc Headers6.2.3.6. Building Glibc6.2.3.7. Building the Next GCC6.2.3.8. Building GMP and MPFR6.2.3.8.1. GMP6.2.3.8.2. MPFR6.2.3.9. Building the Final GCC6.3. Building Toolchains with Crosstool-NG6.4. Creating the Root File System6.4.1. Configuring the Environment6.4.2. Building and Installing BusyBox6.4.3. Libraries6.4.4. Creating Device Nodes and Directories6.4.5. Finishing Touches6.4.6. Building the Kernel6.4.7. Troubleshooting Booting Problems6.4.7.1. Improperly Configured Board6.4.7.2. The Root File System Can't Be Mounted6.4.7.3. The Root File System init Program Doesn't Run6.5. Distributing the Distribution6.6. Wrapping Up
7. Booting the Board
7.1. Booting a Linux System Is a Three-Act Play7.1.1. The Boot Loader7.1.2. Kernel-Land vs. Userland7.2. Boot Loaders7.2.1.7.2.1.1. RedBoot7.2.1.1.1. Using RedBoot7.2.1.2. YAMON7.2.1.3. Das U-Boot7.2.1.3.1. Using U-Boot7.2.1.4. LILO7.2.1.5. GRUB7.2.2. About Flash Memory7.3. Kernel Startup7.3.1. The Kernel Entry Point7.3.1.1. Sysfs and Device Management7.3.1.2. Finding a Root File System7.3.1.2.1. NFS Root File Systems7.3.2. Userland Startup7.3.2.1. What an Init Program Needs to Do7.3.2.2. Mysteries of the /etc/init.d Directory7.3.3. BusyBox Init7.3.4. Your Init7.4. What's Next
8. Configuring the Application Development Environment
8.1. Pick the Right Tool for the Job8.2. Know Your Application8.2.1. Hardware Constraints8.2.1.1. Software Constraints8.3. What to Use for Development8.3.1. C8.3.2. C++8.3.3. Java8.3.3.1. Java Runtime Environment8.3.3.2. Embedding Java: Using GCJ8.3.3.3. Compiling Java Code with GCJ8.3.3.4. Embedded GCJ8.4. Non-Traditional Embedded Languages8.4.1. Python8.4.1.1. Embedding Python8.4.1.2. Debugging8.4.2. TCL8.4.2.1. Embedding TCL8.4.2.2. Debugging8.4.3. Shell Scripting8.4.3.1. Embedded Shell Scripting8.4.4. PHP8.4.4.1. Embedding PHP8.5. Performance and Profiling Tools8.5.1. Profiling8.5.1.1. Gprof Option Reference8.5.2. Leak Detection8.5.2.1. dmalloc8.5.2.2. Mpatrol8.5.3. Static Analysis8.6. IDE8.6.1. Your Editor + Make + Shell8.6.1.1. Using Make8.6.2. Eclipse8.6.2.1. Installing Eclipse and Plug-ins8.6.2.2. Using Eclipse8.7. What's Next
9. Application Development
9.1. Getting Started on Your Application9.2. Desktop vs. Target9.2.1. Coding for Portability9.2.2. System Differences9.2.2.1. FIFO9.3. Hello World9.3.1. Getting the Tools9.3.2. Making Make Work9.3.3. Running the Code on the Target9.3.4. More Complex Projects9.4. Getting Ready for Debugging9.5. What's Next
10. Debugging Applications
10.1. Getting Started on Your Application10.2. Types of Debugging10.3. Remote Debugging Overview10.4. Debugging C and C++10.4.1. Building GDB10.4.2. GDB Front Ends10.4.3. Compiling for Debugging10.4.3.1. GDB Command Line Survival Guide10.4.3.2. Remote Debugging with DDD10.4.3.3. Remote Debugging with GNU Emacs10.4.3.4. Remote Debugging with Eclipse10.5. Debugging Java10.6. Instrumentation10.7. Java Instrumentation10.8. Instrumentation in Scripting Languages10.9. What's Next
11. Kernel Configuration and Development
11.1. Kernel Project Layout11.1.1. Downloading the Kernel11.1.1.1. Downloading a Compressed Tar File11.1.1.2. Using Git to Clone the Repository11.2. Building the Kernel11.2.1. How Kernel Configuration Works11.2.2. Default Configurations11.2.3. Editing .config By Hand11.2.4. Building the Kernel11.2.5. Building Modules11.2.6. Cleaning Up11.3. Open Source Community11.3.1. The Kernel Development Process11.3.2. Contributing to the Linux Kernel11.3.3. Applying Patches11.3.4. What's Next
12. Real Time
12.1.12.1.1. Real-Time Core Concepts12.1.1.1. Deadline12.1.1.2. Latency12.1.1.3. Jitter12.1.1.4. Predictability12.1.1.5. Worst Case12.1.1.6. Priority Inversion12.1.1.7. Periodic Task12.1.2. The Linux Scheduler12.1.2.1. Group Scheduling12.1.3. Real-Time Scheduler12.2. Real-Time Implementation in Linux12.2.1. Getting the Patch12.3. Real-Time Programming Practices12.3.1. The One Real-Time Process12.3.2. Lock Memory12.3.3. Avoid the Heap12.3.4. Asking for Priority Inheritance Mutexes12.3.5. I/O Is Nondeterministic12.3.6. Using Thread Pools12.3.7. LatencyTOP12.4. Common Hardware Pitfalls12.4.1. System Management Interrupts12.4.2. VGA Console12.4.3. DMA Bus Mastering12.5. Summary
13. Using Open Source Software Projects
13.1. Using Open Source Packages13.1.1. How an Open Source Project Is Structured13.1.2. The Project Team Isn't Your Extended Workforce13.1.3. Understand the Licensing13.1.3.1. Permissive vs. Restrictive Licenses13.1.3.2. Common Licensing Types13.1.4. Downloading13.1.5. Using Source Control Systems to Fetch Code13.1.5.1. Using CVS13.1.5.2. Using Subversion13.1.5.3. Using Git13.1.5.4. Using Mercurial13.1.6. Cross-Compiling13.1.7. Using configure13.1.7.1. Creating the Script13.1.7.2. Gaming the Cache13.1.7.3. Installation13.1.7.4. Setting Other Configure Options13.1.7.5. Configuration Process for Non-Automake Projects13.1.8. Building and Installing13.2. Commonly Used Projects13.2.1. DirectFB13.2.2. Dropbear13.2.3. QT/Qtopia13.2.4. JamVM13.2.5. Rzsz13.2.6. Netcat13.2.7. TinyXML13.2.8. Micro_httpd13.2.9. Stupid-FTPd13.2.10. Quagga13.2.11. Tslib13.2.12. fgetty
14. BusyBox
14.1. How a BusyBox-Based System Is Structured14.2. Building a BusyBox-Based System14.2.1. Download the Software14.2.2. Configure14.2.2.1. Build14.2.2.1.1. Static or Shared?14.2.2.2. Install14.2.2.3. Copy Libraries14.2.2.4. Default Init Scripts14.2.2.5. Update Permissions14.2.2.6. Create Additional Folders14.2.2.7. Create Device Nodes14.3. What Makes BusyBox Small?14.4. Creating Your Own Applet14.4.1. Create the Applet Code14.4.1.1. Add the Applet to the Make File14.4.1.2. Register Applet with BusyBox14.4.1.3. Add Help Text14.4.1.4. Build and Verify14.5. Getting Help14.6. What's Next
15. System Design
15.1. The Big Picture15.2. Configuring the Boot Loader and Kernel15.2.1. U-Boot15.2.2. Other Boot loaders15.2.3. Execute in Place15.3. Selecting a Root File System15.3.1. Block-Based File Systems15.3.1.1. Ext215.3.1.2. Ext315.3.1.3. SquashFS15.3.1.4. CramFS15.3.1.5. Romfs15.3.1.6. MINIX15.3.2. MTD File Systems15.3.2.1. JFFS215.3.2.2. YAFFS215.3.3. RAM Buffer-Based File Systems15.3.3.1. Rafms15.3.3.2. Tmpfs15.3.3.3. Initramfs15.3.4. File System Pairings15.4. Assembling a Root File System15.4.1. Create the Staging Area15.4.2. Create a Directory Skeleton15.4.3. Gather Libraries and Required Files15.4.3.1. Required Files15.4.4. Create Initialization Scripts15.4.4.1. Using Init and Inittab15.4.4.2. Using a Script15.4.4.3. Using a Program15.4.5. Set Ownership and Permissions15.5. Security15.5.1. Built-In Security15.5.2. SELinux15.5.2.1. Reference Policies15.5.2.2. Using SEEdit15.5.3. PAM15.6. What's Next
16. System Tuning
16.1.16.1.1. Three or Fewer Megabytes16.1.2. 16–32 Megabytes16.1.3. More than a Gigabyte16.2. Reducing the Size of the Root File System16.2.1. Start from Zero16.2.1.1. Mounting Small File Systems16.2.1.2. Shared Libraries16.2.2. Compiling to Save Space16.2.2.1. GCCs -Os16.2.2.2. Static Linking16.2.2.3. Stripping16.3. Reducing the Size of the Kernel16.3.1. Removing Unneeded Features and Drivers16.3.1.1. Recommendations for Embedded Systems16.3.1.2. Measuring16.3.1.3. Using the Bloat-O-Meter16.4. Minimizing Boot Time16.4.1. Reducing Kernel Boot-Up Time16.4.1.1. Uncompressed Kernel Image16.4.1.2. No Console Output on Boot16.4.1.3. Deferred Initialization16.4.1.4. No Kernel Modules16.4.2. Measuring Kernel Boot-Up Times16.4.2.1. /proc/uptime16.4.2.2. Grabserial16.4.2.3. Initcall_debug16.4.3. Reducing Root File System Startup Times16.4.3.1. Use a Read-Only File System16.4.3.2. Replacing Initialization Scripts16.4.3.3. Inittab Abuse16.4.3.4. Link with GNU Hash Style16.5. What's Next
17. Deploying Applications
17.1. Deployment for Embedded Devices17.1.1. Requirements17.1.2. Industrial Design17.1.3. Mechanical Design17.1.4. Electrical Engineering17.1.5. Manufacturing Engineering17.1.6. Software Design17.1.7. Software Engineering17.1.8. Manufacturing17.2. Deployment Strategies and Tactics17.3. Boot Loaders17.3.1. In General17.3.2. UBOOT: Configuring Initial Parameters17.3.3. Expect17.3.3.1. Installing Expect17.3.3.2. Expect on Windows17.3.3.3. Using Expect17.3.4. Boot Loaders Are Just Programs17.4. Deployment Root File Systems17.4.1. Application Files and Libraries17.4.1.1. Small Root File Systems17.4.2. First Field Update at the Factory17.5. What's Next
18. Handling Field Updates
18.1. Root File System Updates18.1.1. Basic Strategies18.1.2. Forklift Upgrade18.1.2.1. Designing for Forklift Upgrades18.1.2.2. MTD Utilities18.1.2.3. Forklift-Upgrade Example18.1.3. Parallel Systems18.1.3.1. Parallel System Example18.1.4. Do It Yourself18.1.4.1. Do-It-Yourself Example18.1.5. Using Package Managers18.1.5.1. RPM18.1.5.1.1. Using RPM18.1.5.1.2. Using YUM18.1.5.2. Dpkg18.1.5.2.1. Creating a dpkg18.1.5.2.2. Remote Update with Debian18.1.5.2.3. Using APT18.1.5.3. Ipkg18.1.5.3.1. Getting the Sources18.1.5.3.2. Creating an Ipkg18.1.5.3.3. Creating a Feed18.1.6. Initramfs Root File Systems18.2. Kernel Updates18.2.1. Basic Strategies18.2.1.1. Update Kernel Modules18.2.1.2. Forklift Upgrade18.2.2. Modules18.2.2.1. Using Modprobe18.2.2.2. Roll Your Own18.2.3. Forklift18.3. Field Update Failures18.3.1. Report Failure, Stop18.3.2. Failsafe Root File System18.3.3. Failsafe Kernel18.4. In Summary

Content preview from Pro Linux Embedded Systems

Chapter 4. Starting Your Project

Embedded projects start with selecting hardware. Based on the requirements of the project, such as cost, battery life, communications, and user interface, a few processors and technologies become obvious choices. For example, low-power consumer devices frequently use ARM processors, and industrial control applications frequently use Intel x86 parts. The hardware selection doesn't occur in isolation; the team selecting the hardware must at the same time consider the peripheral devices and driver availability. Chapter 17 goes into detail regarding the development process unique to embedded projects.

The trend is toward purchasing off-the-shelf hardware and peripherals and putting them together with standard interconnects, ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781430272274Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Pro Linux Embedded Systems

by Gene Sally

Chapter 4. Starting Your Project

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.