Yocto Project Development Manual

Scott Rifenbark

Intel Corporation

Permission is granted to copy, distribute and/or modify this document under the terms of the Creative Commons Attribution-Share Alike 2.0 UK: England & Wales as published by Creative Commons.

Note

Due to production processes, there could be differences between the Yocto Project documentation bundled in the release tarball and the Yocto Project Development Manual on the Yocto Project website. For the latest version of this manual, see the manual on the website.
Revision History
Revision 1.1 6 October 2011
The initial document released with the Yocto Project 1.1 Release.
Revision 1.2 April 2012
Released with the Yocto Project 1.2 Release.
Revision 1.3 October 2012
Released with the Yocto Project 1.3 Release.
Revision 1.4 April 2013
Released with the Yocto Project 1.4 Release.

Table of Contents

1. The Yocto Project Development Manual
1.1. Introduction
1.2. What This Manual Provides
1.3. What this Manual Does Not Provide
1.4. Other Information
2. Getting Started with the Yocto Project
2.1. Introducing the Yocto Project
2.2. Getting Set Up
2.3. Building Images
2.4. Using Pre-Built Binaries and QEMU
3. The Yocto Project Open Source Development Environment
3.1. Open Source Philosophy
3.2. Using the Yocto Project in a Team Environment
3.2.1. System Configurations
3.2.2. Source Control Management (SCM)
3.2.3. Autobuilders
3.2.4. Policies and Change Flow
3.2.5. Summary
3.3. Yocto Project Source Repositories
3.4. Yocto Project Terms
3.5. Licensing
3.6. Git
3.6.1. Repositories, Tags, and Branches
3.6.2. Basic Commands
3.7. Workflows
3.8. Tracking Bugs
3.9. How to Submit a Change
3.9.1. Using Scripts to Push a Change Upstream and Request a Pull
3.9.2. Using Email to Submit a Patch
4. Common Development Models
4.1. System Development Workflow
4.1.1. Developing a Board Support Package (BSP)
4.1.2. Modifying the Kernel
4.2. Application Development Workflow
4.2.1. Workflow Using the ADT and Eclipse
4.2.2. Working Within Eclipse
4.2.3. Workflow Using Stand-Alone Cross-Development Toolchains
4.3. Modifying Temporary Source Code
4.3.1. Finding the Temporary Source Code
4.3.2. Using a Quilt Workflow
4.3.3. Using a Git Workflow
4.4. Image Development Using Hob
4.5. Using a Development Shell
5. Common Tasks
5.1. Understanding and Creating Layers
5.1.1. Layers
5.1.2. Creating Your Own Layer
5.1.3. Enabling Your Layer
5.1.4. Using .bbappend Files
5.1.5. Prioritizing Your Layer
5.1.6. Managing Layers
5.1.7. Creating a General Layer Using the yocto-layer Script
5.2. Customizing Images
5.2.1. Customizing Images Using Custom .bb Files
5.2.2. Customizing Images Using Custom Package Groups
5.2.3. Customizing Images Using Custom IMAGE_FEATURES and EXTRA_IMAGE_FEATURES
5.2.4. Customizing Images Using local.conf
5.3. Writing a Recipe to Add a Package to Your Image
5.3.1. Single .c File Package (Hello World!)
5.3.2. Autotooled Package
5.3.3. Makefile-Based Package
5.3.4. Splitting an Application into Multiple Packages
5.3.5. Post-Installation Scripts
5.4. Adding a New Machine
5.4.1. Adding the Machine Configuration File
5.4.2. Adding a Kernel for the Machine
5.4.3. Adding a Formfactor Configuration File
5.5. Working With Libraries
5.5.1. Including Static Library Files
5.5.2. Combining Multiple Versions of Library Files into One Image
5.5.3. Installing Multiple Versions of the Same Library
5.6. Configuring the Kernel
5.6.1. Using  menuconfig
5.6.2. Creating Configuration Fragments
5.6.3. Fine-Tuning the Kernel Configuration File
5.7. Patching the Kernel
5.7.1. Create a Layer for your Changes
5.7.2. Finding the Kernel Source Code
5.7.3. Creating the Patch
5.7.4. Set Up Your Layer for the Build
5.7.5. Set Up for the Build
5.7.6. Build the Modified QEMU Kernel Image
5.7.7. Boot the Image and Verify Your Changes
5.8. Creating Your Own Distribution
5.9. Building a Tiny System
5.9.1. Overview
5.9.2. Goals and Guiding Principles
5.9.3. Understand What Gives Your Image Size
5.9.4. Trim the Root Filesystem
5.9.5. Trim the Kernel
5.9.6. Look for Other Ways to Minimize Size
5.9.7. Iterate on the Process
5.10. Working with Packages
5.10.1. Incrementing a Package Revision Number
5.10.2. Handling a Package Name Alias
5.10.3. Handling Optional Module Packaging
5.10.4. Setting Up Runtime Package Management
5.10.5. Testing Packages With ptest
5.11. Building Software from an External Source
5.12. Selecting an Initialization Manager
5.12.1. Using systemd Exclusively
5.12.2. Using systemd for the Main Image and Using SysVinit for the Rescue Image
5.13. Excluding Recipes From the Build
5.14. Using an External SCM
5.15. Creating a Read-Only Root Filesystem
5.15.1. Creating the Root Filesystem
5.15.2. Post-Installation Scripts
5.15.3. Areas With Write Access
5.16. Debugging With the GNU Project Debugger (GDB) Remotely
5.16.1. Set Up the Cross-Development Debugging Environment
5.16.2. Launch Gdbserver on the Target
5.16.3. Launch GDB on the Host Computer
5.16.4. Connect to the Remote GDB Server
5.16.5. Use the Debugger
5.17. Profiling with OProfile
5.17.1. Profiling on the Target
5.17.2. Using OProfileUI
5.18. Maintaining Open Source License Compliance During Your Product's Lifecycle
5.18.1. Providing the Source Code
5.18.2. Providing License Text
5.18.3. Providing Compilation Scripts and Source Code Modifications