This version of the project is now considered obsolete, please select and use a more recent version.

Yocto Project Reference Manual

Richard Purdie

Linux Foundation

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

For the latest version of this manual associated with this Yocto Project release, see the Yocto Project Reference Manual from the Yocto Project website.
Revision History
Revision 4.0+git24 November 2010
Released with the Yocto Project 0.9 Release
Revision 1.06 April 2011
Released with the Yocto Project 1.0 Release.
Revision 1.0.123 May 2011
Released with the Yocto Project 1.0.1 Release.
Revision 1.16 October 2011
Released with the Yocto Project 1.1 Release.
Revision 1.2April 2012
Released with the Yocto Project 1.2 Release.
Revision 1.3October 2012
Released with the Yocto Project 1.3 Release.
Revision 1.4April 2013
Released with the Yocto Project 1.4 Release.
Revision 1.5October 2013
Released with the Yocto Project 1.5 Release.
Revision 1.5.1January 2014
Released with the Yocto Project 1.5.1 Release.
Revision 1.6April 2014
Released with the Yocto Project 1.6 Release.
Revision 1.7October 2014
Released with the Yocto Project 1.7 Release.
Revision 1.8April 2015
Released with the Yocto Project 1.8 Release.
Revision 2.0October 2015
Released with the Yocto Project 2.0 Release.
Revision 2.1April 2016
Released with the Yocto Project 2.1 Release.
Revision 2.2October 2016
Released with the Yocto Project 2.2 Release.

Table of Contents

1. Introduction
1.1. Introduction
1.2. Documentation Overview
1.3. System Requirements
1.3.1. Supported Linux Distributions
1.3.2. Required Packages for the Host Development System
1.3.3. Required Git, tar, and Python Versions
1.4. Obtaining the Yocto Project
1.5. Development Checkouts
2. Using the Yocto Project
2.1. Running a Build
2.1.1. Build Overview
2.1.2. Building an Image Using GPL Components
2.2. Installing and Using the Result
2.3. Debugging Tools and Techniques
2.3.1. Viewing Logs from Failed Tasks
2.3.2. Viewing Variable Values
2.3.3. Viewing Package Information with oe-pkgdata-util
2.3.4. Viewing Dependencies Between Recipes and Tasks
2.3.5. Viewing Task Variable Dependencies
2.3.6. Running Specific Tasks
2.3.7. Checking for Missing Build-Time Dependencies
2.3.8. General BitBake Problems
2.3.9. Development Host System Issues
2.3.10. Building with No Dependencies
2.3.11. Recipe Logging Mechanisms
2.3.12. Other Tips
2.4. Maintaining Build Output Quality
2.4.1. Enabling and Disabling Build History
2.4.2. Understanding What the Build History Contains
2.5. Speeding Up the Build
3. A Closer Look at the Yocto Project Development Environment
3.1. User Configuration
3.2. Metadata, Machine Configuration, and Policy Configuration
3.2.1. Distro Layer
3.2.2. BSP Layer
3.2.3. Software Layer
3.3. Sources
3.3.1. Upstream Project Releases
3.3.2. Local Projects
3.3.3. Source Control Managers (Optional)
3.3.4. Source Mirror(s)
3.4. Package Feeds
3.5. BitBake
3.5.1. Source Fetching
3.5.2. Patching
3.5.3. Configuration and Compilation
3.5.4. Package Splitting
3.5.5. Image Generation
3.5.6. SDK Generation
3.5.7. Stamp Files and the Rerunning of Tasks
3.5.8. Setscene Tasks and Shared State
3.6. Images
3.7. Application Development SDK
4. Technical Details
4.1. Yocto Project Components
4.1.1. BitBake
4.1.2. Metadata (Recipes)
4.1.3. Classes
4.1.4. Configuration
4.2. Cross-Development Toolchain Generation
4.3. Shared State Cache
4.3.1. Overall Architecture
4.3.2. Checksums (Signatures)
4.3.3. Shared State
4.3.4. Tips and Tricks
4.4. Automatically Added Runtime Dependencies
4.5. Fakeroot and Pseudo
4.6. x32
4.6.1. Support
4.6.2. Completing x32
4.6.3. Using x32 Right Now
4.7. Wayland
4.7.1. Support
4.7.2. Enabling Wayland in an Image
4.7.3. Running Weston
4.8. Licenses
4.8.1. Tracking License Changes
4.8.2. Enabling Commercially Licensed Recipes
5. Migrating to a Newer Yocto Project Release
5.1. General Migration Considerations
5.2. Moving to the Yocto Project 1.3 Release
5.2.1. Local Configuration
5.2.2. Recipes
5.2.3. Linux Kernel Naming
5.3. Moving to the Yocto Project 1.4 Release
5.3.1. BitBake
5.3.2. Build Behavior
5.3.3. Proxies and Fetching Source
5.3.4. Custom Interfaces File (netbase change)
5.3.5. Remote Debugging
5.3.6. Variables
5.3.7. Target Package Management with RPM
5.3.8. Recipes Moved
5.3.9. Removals and Renames
5.4. Moving to the Yocto Project 1.5 Release
5.4.1. Host Dependency Changes
5.4.2. atom-pc Board Support Package (BSP)
5.4.3. BitBake
5.4.4. QA Warnings
5.4.5. Directory Layout Changes
5.4.6. Shortened Git SRCREV Values
5.4.7. IMAGE_FEATURES
5.4.8. /run
5.4.9. Removal of Package Manager Database Within Image Recipes
5.4.10. Images Now Rebuild Only on Changes Instead of Every Time
5.4.11. Task Recipes
5.4.12. BusyBox
5.4.13. Automated Image Testing
5.4.14. Build History
5.4.15. udev
5.4.16. Removed and Renamed Recipes
5.4.17. Other Changes
5.5. Moving to the Yocto Project 1.6 Release
5.5.1. archiver Class
5.5.2. Packaging Changes
5.5.3. BitBake
5.5.4. Changes to Variables
5.5.5. Package Test (ptest)
5.5.6. Build Changes
5.5.7. qemu-native
5.5.8. core-image-basic
5.5.9. Licensing
5.5.10. CFLAGS Options
5.5.11. Custom Image Output Types
5.5.12. Tasks
5.5.13. update-alternative Provider
5.5.14. virtclass Overrides
5.5.15. Removed and Renamed Recipes
5.5.16. Removed Classes
5.5.17. Reference Board Support Packages (BSPs)
5.6. Moving to the Yocto Project 1.7 Release
5.6.1. Changes to Setting QEMU PACKAGECONFIG Options in local.conf
5.6.2. Minimum Git version
5.6.3. Autotools Class Changes
5.6.4. Binary Configuration Scripts Disabled
5.6.5. eglibc 2.19 Replaced with glibc 2.20
5.6.6. Kernel Module Autoloading
5.6.7. QA Check Changes
5.6.8. Removed Recipes
5.6.9. Miscellaneous Changes
5.7. Moving to the Yocto Project 1.8 Release
5.7.1. Removed Recipes
5.7.2. BlueZ 4.x / 5.x Selection
5.7.3. Kernel Build Changes
5.7.4. SSL 3.0 is Now Disabled in OpenSSL
5.7.5. Default Sysroot Poisoning
5.7.6. Rebuild Improvements
5.7.7. QA Check and Validation Changes
5.7.8. Miscellaneous Changes
5.8. Moving to the Yocto Project 2.0 Release
5.8.1. GCC 5
5.8.2. Gstreamer 0.10 Removed
5.8.3. Removed Recipes
5.8.4. BitBake datastore improvements
5.8.5. Shell Message Function Changes
5.8.6. Extra Development/Debug Package Cleanup
5.8.7. Recipe Maintenance Tracking Data Moved to OE-Core
5.8.8. Automatic Stale Sysroot File Cleanup
5.8.9. linux-yocto Kernel Metadata Repository Now Split from Source
5.8.10. Additional QA checks
5.8.11. Miscellaneous Changes
5.9. Moving to the Yocto Project 2.1 Release
5.9.1. Variable Expansion in Python Functions
5.9.2. Overrides Must Now be Lower-Case
5.9.3. Expand Parameter to getVar() and getVarFlag() is Now Mandatory
5.9.4. Makefile Environment Changes
5.9.5. libexecdir Reverted to ${prefix}/libexec
5.9.6. ac_cv_sizeof_off_t is No Longer Cached in Site Files
5.9.7. Image Generation is Now Split Out from Filesystem Generation
5.9.8. Removed Recipes
5.9.9. Class Changes
5.9.10. Build System User Interface Changes
5.9.11. ADT Removed
5.9.12. Poky Reference Distribution Changes
5.9.13. Packaging Changes
5.9.14. Tuning File Changes
5.9.15. Supporting GObject Introspection
5.9.16. Miscellaneous Changes
5.10. Moving to the Yocto Project 2.2 Release
5.10.1. Minimum Kernel Version
5.10.2. Staging Directories in Sysroot Has Been Simplified
5.10.3. Removal of Old Images and Other Files in tmp/deploy Now Enabled
5.10.4. Python Changes
5.10.5. uClibc Replaced by musl
5.10.6. ${B} No Longer Default Working Directory for Tasks
5.10.7. runqemu Ported to Python
5.10.8. Default Linker Hash Style Changed
5.10.9. KERNEL_IMAGE_BASE_NAME no Longer Uses KERNEL_IMAGETYPE
5.10.10. BitBake Changes
5.10.11. Swabber has Been Removed
5.10.12. Removed Recipes
5.10.13. Removed Classes
5.10.14. Minor Packaging Changes
5.10.15. Miscellaneous Changes
6. Source Directory Structure
6.1. Top-Level Core Components
6.1.1. bitbake/
6.1.2. build/
6.1.3. documentation/
6.1.4. meta/
6.1.5. meta-poky/
6.1.6. meta-yocto-bsp/
6.1.7. meta-selftest/
6.1.8. meta-skeleton/
6.1.9. scripts/
6.1.10. oe-init-build-env
6.1.11. oe-init-build-env-memres
6.1.12. LICENSE, README, and README.hardware
6.2. The Build Directory - build/
6.2.1. build/buildhistory
6.2.2. build/conf/local.conf
6.2.3. build/conf/bblayers.conf
6.2.4. build/conf/sanity_info
6.2.5. build/downloads/
6.2.6. build/sstate-cache/
6.2.7. build/tmp/
6.2.8. build/tmp/buildstats/
6.2.9. build/tmp/cache/
6.2.10. build/tmp/deploy/
6.2.11. build/tmp/deploy/deb/
6.2.12. build/tmp/deploy/rpm/
6.2.13. build/tmp/deploy/ipk/
6.2.14. build/tmp/deploy/licenses/
6.2.15. build/tmp/deploy/images/
6.2.16. build/tmp/deploy/sdk/
6.2.17. build/tmp/sstate-control/
6.2.18. build/tmp/sysroots/
6.2.19. build/tmp/stamps/
6.2.20. build/tmp/log/
6.2.21. build/tmp/work/
6.2.22. build/tmp/work-shared/
6.3. The Metadata - meta/
6.3.1. meta/classes/
6.3.2. meta/conf/
6.3.3. meta/conf/machine/
6.3.4. meta/conf/distro/
6.3.5. meta/conf/machine-sdk/
6.3.6. meta/files/
6.3.7. meta/lib/
6.3.8. meta/recipes-bsp/
6.3.9. meta/recipes-connectivity/
6.3.10. meta/recipes-core/
6.3.11. meta/recipes-devtools/
6.3.12. meta/recipes-extended/
6.3.13. meta/recipes-gnome/
6.3.14. meta/recipes-graphics/
6.3.15. meta/recipes-kernel/
6.3.16. meta/recipes-lsb4/
6.3.17. meta/recipes-multimedia/
6.3.18. meta/recipes-rt/
6.3.19. meta/recipes-sato/
6.3.20. meta/recipes-support/
6.3.21. meta/site/
6.3.22. meta/recipes.txt
7. Classes
7.1. allarch.bbclass
7.2. archiver.bbclass
7.3. autotools*.bbclass
7.4. base.bbclass
7.5. bash-completion.bbclass
7.6. bin_package.bbclass
7.7. binconfig.bbclass
7.8. binconfig-disabled.bbclass
7.9. blacklist.bbclass
7.10. bluetooth.bbclass
7.11. bugzilla.bbclass
7.12. buildhistory.bbclass
7.13. buildstats.bbclass
7.14. buildstats-summary.bbclass
7.15. ccache.bbclass
7.16. chrpath.bbclass
7.17. clutter.bbclass
7.18. cmake.bbclass
7.19. cml1.bbclass
7.20. compress_doc.bbclass
7.21. copyleft_compliance.bbclass
7.22. copyleft_filter.bbclass
7.23. core-image.bbclass
7.24. cpan*.bbclass
7.25. cross.bbclass
7.26. cross-canadian.bbclass
7.27. crosssdk.bbclass
7.28. debian.bbclass
7.29. deploy.bbclass
7.30. devshell.bbclass
7.31. distro_features_check.bbclass
7.32. distrodata.bbclass
7.33. distutils*.bbclass
7.34. distutils3*.bbclass
7.35. externalsrc.bbclass
7.36. extrausers.bbclass
7.37. fontcache.bbclass
7.38. fs-uuid.bbclass
7.39. gconf.bbclass
7.40. gettext.bbclass
7.41. gnome.bbclass
7.42. gnomebase.bbclass
7.43. gobject-introspection.bbclass
7.44. grub-efi.bbclass
7.45. gsettings.bbclass
7.46. gtk-doc.bbclass
7.47. gtk-icon-cache.bbclass
7.48. gtk-immodules-cache.bbclass
7.49. gzipnative.bbclass
7.50. icecc.bbclass
7.51. image.bbclass
7.52. image-buildinfo.bbclass
7.53. image_types.bbclass
7.54. image_types_uboot.bbclass
7.55. image-live.bbclass
7.56. image-mklibs.bbclass
7.57. image-prelink.bbclass
7.58. image-vm.bbclass
7.59. image-vmdk.bbclass
7.60. insane.bbclass
7.61. insserv.bbclass
7.62. kernel.bbclass
7.63. kernel-arch.bbclass
7.64. kernel-fitimage.bbclass
7.65. kernel-grub.bbclass
7.66. kernel-module-split.bbclass
7.67. kernel-uboot.bbclass
7.68. kernel-uimage.bbclass
7.69. kernel-yocto.bbclass
7.70. kernelsrc.bbclass
7.71. lib_package.bbclass
7.72. libc*.bbclass
7.73. license.bbclass
7.74. linux-kernel-base.bbclass
7.75. linuxloader.bbclass
7.76. logging.bbclass
7.77. meta.bbclass
7.78. metadata_scm.bbclass
7.79. migrate_localcount.bbclass
7.80. mime.bbclass
7.81. mirrors.bbclass
7.82. module.bbclass
7.83. module-base.bbclass
7.84. multilib*.bbclass
7.85. native.bbclass
7.86. nativesdk.bbclass
7.87. nopackages.bbclass
7.88. npm.bbclass
7.89. oelint.bbclass
7.90. own-mirrors.bbclass
7.91. package.bbclass
7.92. package_deb.bbclass
7.93. package_ipk.bbclass
7.94. package_rpm.bbclass
7.95. package_tar.bbclass
7.96. packagedata.bbclass
7.97. packagegroup.bbclass
7.98. patch.bbclass
7.99. perlnative.bbclass
7.100. pixbufcache.bbclass
7.101. pkgconfig.bbclass
7.102. populate_sdk.bbclass
7.103. populate_sdk_*.bbclass
7.104. prexport.bbclass
7.105. primport.bbclass
7.106. prserv.bbclass
7.107. ptest.bbclass
7.108. ptest-gnome.bbclass
7.109. python-dir.bbclass
7.110. python3native.bbclass
7.111. pythonnative.bbclass
7.112. qemu.bbclass
7.113. recipe_sanity.bbclass
7.114. relocatable.bbclass
7.115. remove-libtool.bbclass
7.116. report-error.bbclass
7.117. rm_work.bbclass
7.118. rootfs*.bbclass
7.119. sanity.bbclass
7.120. scons.bbclass
7.121. sdl.bbclass
7.122. setuptools.bbclass
7.123. setuptools3.bbclass
7.124. sign_rpm.bbclass
7.125. sip.bbclass
7.126. siteconfig.bbclass
7.127. siteinfo.bbclass
7.128. spdx.bbclass
7.129. sstate.bbclass
7.130. staging.bbclass
7.131. syslinux.bbclass
7.132. systemd.bbclass
7.133. systemd-boot.bbclass
7.134. terminal.bbclass
7.135. testimage*.bbclass
7.136. testsdk.bbclass
7.137. texinfo.bbclass
7.138. tinderclient.bbclass
7.139. toaster.bbclass
7.140. toolchain-scripts.bbclass
7.141. typecheck.bbclass
7.142. uboot-config.bbclass
7.143. uninative.bbclass
7.144. update-alternatives.bbclass
7.145. update-rc.d.bbclass
7.146. useradd*.bbclass
7.147. utility-tasks.bbclass
7.148. utils.bbclass
7.149. vala.bbclass
7.150. waf.bbclass
8. Tasks
8.1. Normal Recipe Build Tasks
8.1.1. do_build
8.1.2. do_compile
8.1.3. do_compile_ptest_base
8.1.4. do_configure
8.1.5. do_configure_ptest_base
8.1.6. do_deploy
8.1.7. do_distrodata
8.1.8. do_fetch
8.1.9. do_image
8.1.10. do_image_complete
8.1.11. do_install
8.1.12. do_install_ptest_base
8.1.13. do_package
8.1.14. do_package_qa
8.1.15. do_package_write_deb
8.1.16. do_package_write_ipk
8.1.17. do_package_write_rpm
8.1.18. do_package_write_tar
8.1.19. do_packagedata
8.1.20. do_patch
8.1.21. do_populate_lic
8.1.22. do_populate_sdk
8.1.23. do_populate_sysroot
8.1.24. do_rm_work
8.1.25. do_rm_work_all
8.1.26. do_unpack
8.2. Manually Called Tasks
8.2.1. do_checkpkg
8.2.2. do_checkuri
8.2.3. do_checkuriall
8.2.4. do_clean
8.2.5. do_cleanall
8.2.6. do_cleansstate
8.2.7. do_devpyshell
8.2.8. do_devshell
8.2.9. do_fetchall
8.2.10. do_listtasks
8.2.11. do_package_index
8.3. Image-Related Tasks
8.3.1. do_bootimg
8.3.2. do_bundle_initramfs
8.3.3. do_rootfs
8.3.4. do_testimage
8.3.5. do_testimage_auto
8.3.6. do_vmdkimg
8.4. Kernel-Related Tasks
8.4.1. do_compile_kernelmodules
8.4.2. do_diffconfig
8.4.3. do_kernel_checkout
8.4.4. do_kernel_configcheck
8.4.5. do_kernel_configme
8.4.6. do_kernel_link_vmlinux
8.4.7. do_kernel_metadata
8.4.8. do_menuconfig
8.4.9. do_savedefconfig
8.4.10. do_shared_workdir
8.4.11. do_sizecheck
8.4.12. do_strip
8.4.13. do_uboot_mkimage
8.4.14. do_validate_branches
8.5. Miscellaneous Tasks
8.5.1. do_spdx
9. devtool Quick Reference
9.1. Getting Help
9.2. The Workspace Layer Structure
9.3. Adding a New Recipe to the Workspace Layer
9.4. Extracting the Source for an Existing Recipe
9.5. Synchronizing a Recipe's Extracted Source Tree
9.6. Modifying an Existing Recipe
9.7. Edit an Existing Recipe
9.8. Updating a Recipe
9.9. Upgrading a Recipe
9.10. Resetting a Recipe
9.11. Building Your Recipe
9.12. Building Your Image
9.13. Deploying Your Software on the Target Machine
9.14. Removing Your Software from the Target Machine
9.15. Creating the Workspace Layer in an Alternative Location
9.16. Get the Status of the Recipes in Your Workspace
9.17. Search for Available Target Recipes
10. QA Error and Warning Messages
10.1. Introduction
10.2. Errors and Warnings
10.3. Configuring and Disabling QA Checks
11. Images
12. Features
12.1. Machine Features
12.2. Distro Features
12.3. Image Features
12.4. Feature Backfilling
13. Variables Glossary
Glossary
14. Variable Context
14.1. Configuration
14.1.1. Distribution (Distro)
14.1.2. Machine
14.1.3. Local
14.2. Recipes
14.2.1. Required
14.2.2. Dependencies
14.2.3. Paths
14.2.4. Extra Build Information
15. FAQ
16. Contributing to the Yocto Project
16.1. Introduction
16.2. Tracking Bugs
16.3. Mailing lists
16.4. Internet Relay Chat (IRC)
16.5. Links
16.6. Contributions

Chapter 1. Introduction

1.1. Introduction

This manual provides reference information for the current release of the Yocto Project. The Yocto Project is an open-source collaboration project focused on embedded Linux developers. Amongst other things, the Yocto Project uses the OpenEmbedded build system, which is based on the Poky project, to construct complete Linux images. You can find complete introductory and getting started information on the Yocto Project by reading the Yocto Project Quick Start.

For task-based information using the Yocto Project, see the Yocto Project Development Manual and the Yocto Project Linux Kernel Development Manual. For Board Support Package (BSP) structure information, see the Yocto Project Board Support Package (BSP) Developer's Guide. For information on how to use a Software Development Kit, (SDK), see the Yocto Project Software Development Kit (SDK) Developer's Guide. You can find information on tracing and profiling in the Yocto Project Profiling and Tracing Manual. For information on BitBake, which is the task execution tool the OpenEmbedded build system is based on, see the BitBake User Manual. Finally, you can also find lots of Yocto Project information on the Yocto Project website.

1.2. Documentation Overview

This reference manual consists of the following:

  • Using the Yocto Project: Provides an overview of the components that make up the Yocto Project followed by information about debugging images created in the Yocto Project.

  • A Closer Look at the Yocto Project Development Environment: Provides a more detailed look at the Yocto Project development environment within the context of development.

  • Technical Details: Describes fundamental Yocto Project components as well as an explanation behind how the Yocto Project uses shared state (sstate) cache to speed build time.

  • Migrating to a Newer Yocto Project Release: Describes release-specific information that helps you move from one Yocto Project Release to another.

  • Directory Structure: Describes the Source Directory created either by unpacking a released Yocto Project tarball on your host development system, or by cloning the upstream Poky Git repository.

  • Classes: Describes the classes used in the Yocto Project.

  • Tasks: Describes the tasks defined by the OpenEmbedded build system.

  • devtool Quick Reference: Provides a quick reference for the devtool command.

  • QA Error and Warning Messages: Lists and describes QA warning and error messages.

  • Images: Describes the standard images that the Yocto Project supports.

  • Features: Describes mechanisms for creating distribution, machine, and image features during the build process using the OpenEmbedded build system.

  • Variables Glossary: Presents most variables used by the OpenEmbedded build system, which uses BitBake. Entries describe the function of the variable and how to apply them.

  • Variable Context: Provides variable locality or context.

  • FAQ: Provides answers for commonly asked questions in the Yocto Project development environment.

  • Contributing to the Yocto Project: Provides guidance on how you can contribute back to the Yocto Project.

1.3. System Requirements

For general Yocto Project system requirements, see the "Setting Up to Use the Yocto Project" section in the Yocto Project Quick Start. The remainder of this section provides details on system requirements not covered in the Yocto Project Quick Start.

1.3.1. Supported Linux Distributions

Currently, the Yocto Project is supported on the following distributions:

Note

Yocto Project releases are tested against the stable Linux distributions in the following list. The Yocto Project should work on other distributions but validation is not performed against them.

In particular, the Yocto Project does not support and currently has no plans to support rolling-releases or development distributions due to their constantly changing nature. We welcome patches and bug reports, but keep in mind that our priority is on the supported platforms listed below.

If you encounter problems, please go to Yocto Project Bugzilla and submit a bug. We are interested in hearing about your experience.

  • Ubuntu 14.04 (LTS)

  • Ubuntu 14.10

  • Ubuntu 15.04

  • Ubuntu 15.10

  • Ubuntu 16.04

  • Fedora release 22

  • Fedora release 23

  • Fedora release 24

  • CentOS release 7.x

  • Debian GNU/Linux 8.x (Jessie)

  • openSUSE 13.2

  • openSUSE 42.1

Note

While the Yocto Project Team attempts to ensure all Yocto Project releases are one hundred percent compatible with each officially supported Linux distribution, instances might exist where you encounter a problem while using the Yocto Project on a specific distribution.

1.3.2. Required Packages for the Host Development System

The list of packages you need on the host development system can be large when covering all build scenarios using the Yocto Project. This section provides required packages according to Linux distribution and function.

1.3.2.1. Ubuntu and Debian

The following list shows the required packages by function given a supported Ubuntu or Debian Linux distribution:

Note

If your build system has the oss4-dev package installed, you might experience QEMU build failures due to the package installing its own custom /usr/include/linux/soundcard.h on the Debian system. If you run into this situation, either of the following solutions exist:
     $ sudo apt-get build-dep qemu
     $ sudo apt-get remove oss4-dev
                    

  • Essentials: Packages needed to build an image on a headless system:

         $ sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc-multilib \
         build-essential chrpath socat
                            
  • Graphical and Eclipse Plug-In Extras: Packages recommended if the host system has graphics support or if you are going to use the Eclipse IDE:

         $ sudo apt-get install libsdl1.2-dev xterm
                            
  • Documentation: Packages needed if you are going to build out the Yocto Project documentation manuals:

         $ sudo apt-get install make xsltproc docbook-utils fop dblatex xmlto
                            
  • OpenEmbedded Self-Test (oe-selftest): Packages needed if you are going to run oe-selftest:

         $ sudo apt-get install python-git
                            

1.3.2.2. Fedora Packages

The following list shows the required packages by function given a supported Fedora Linux distribution:

  • Essentials: Packages needed to build an image for a headless system:

         $ sudo dnf install gawk make wget tar bzip2 gzip python3 unzip perl patch \
         diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath \
         ccache perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue perl-bignum socat \
         findutils which
                            
  • Graphical and Eclipse Plug-In Extras: Packages recommended if the host system has graphics support or if you are going to use the Eclipse IDE:

         $ sudo dnf install SDL-devel xterm
                            
  • Documentation: Packages needed if you are going to build out the Yocto Project documentation manuals:

         $ sudo dnf install make docbook-style-dsssl docbook-style-xsl \
         docbook-dtds docbook-utils fop libxslt dblatex xmlto xsltproc
                            
  • OpenEmbedded Self-Test (oe-selftest): Packages needed if you are going to run oe-selftest:

         $ sudo dnf install python3-GitPython
                            

1.3.2.3. openSUSE Packages

The following list shows the required packages by function given a supported openSUSE Linux distribution:

  • Essentials: Packages needed to build an image for a headless system:

         $ sudo zypper install python gcc gcc-c++ git chrpath make wget python-xml \
         diffstat makeinfo python-curses patch socat
                            
  • Graphical and Eclipse Plug-In Extras: Packages recommended if the host system has graphics support or if you are going to use the Eclipse IDE:

         $ sudo zypper install libSDL-devel xterm
                            
  • Documentation: Packages needed if you are going to build out the Yocto Project documentation manuals:

         $ sudo zypper install make fop xsltproc dblatex xmlto
                            
  • OpenEmbedded Self-Test (oe-selftest): Packages needed if you are going to run oe-selftest:

         $ sudo zypper install python-GitPython
                            

1.3.2.4. CentOS Packages

The following list shows the required packages by function given a supported CentOS Linux distribution:

Note

For CentOS 6.x, some of the versions of the components provided by the distribution are too old (e.g. Git, Python, and tar). It is recommended that you install the buildtools in order to provide versions that will work with the OpenEmbedded build system. For information on how to install the buildtools tarball, see the "Required Git, Tar, and Python Versions" section.

  • Essentials: Packages needed to build an image for a headless system:

         $ sudo yum install gawk make wget tar bzip2 gzip python unzip perl patch \
         diffutils diffstat git cpp gcc gcc-c++ glibc-devel texinfo chrpath socat \
         perl-Data-Dumper perl-Text-ParseWords perl-Thread-Queue
                            
  • Graphical and Eclipse Plug-In Extras: Packages recommended if the host system has graphics support or if you are going to use the Eclipse IDE:

         $ sudo yum install SDL-devel xterm
                            
  • Documentation: Packages needed if you are going to build out the Yocto Project documentation manuals:

         $ sudo yum install make docbook-style-dsssl docbook-style-xsl \
         docbook-dtds docbook-utils fop libxslt dblatex xmlto xsltproc
                            
  • OpenEmbedded Self-Test (oe-selftest): Packages needed if you are going to run oe-selftest:

         $ sudo yum install GitPython
                            

1.3.3. Required Git, tar, and Python Versions

In order to use the build system, your host development system must meet the following version requirements for Git, tar, and Python:

  • Git 1.8.3.1 or greater

  • tar 1.24 or greater

  • Python 3.4.0 or greater

If your host development system does not meet all these requirements, you can resolve this by installing a buildtools tarball that contains these tools. You can get the tarball one of two ways: download a pre-built tarball or use BitBake to build the tarball.

1.3.3.1. Downloading a Pre-Built buildtools Tarball

Downloading and running a pre-built buildtools installer is the easiest of the two methods by which you can get these tools:

  1. Locate and download the *.sh at http://downloads.yoctoproject.org/releases/yocto/yocto-2.2/buildtools/.

  2. Execute the installation script. Here is an example:

         $ sh poky-glibc-x86_64-buildtools-tarball-x86_64-buildtools-nativesdk-standalone-2.2.sh
                            

    During execution, a prompt appears that allows you to choose the installation directory. For example, you could choose the following:

         /home/your-username/buildtools
                            

  3. Source the tools environment setup script by using a command like the following:

         $ source /home/your_username/buildtools/environment-setup-i586-poky-linux
                            

    Of course, you need to supply your installation directory and be sure to use the right file (i.e. i585 or x86-64).

    After you have sourced the setup script, the tools are added to PATH and any other environment variables required to run the tools are initialized. The results are working versions versions of Git, tar, Python and chrpath.

1.3.3.2. Building Your Own buildtools Tarball

Building and running your own buildtools installer applies only when you have a build host that can already run BitBake. In this case, you use that machine to build the .sh file and then take steps to transfer and run it on a machine that does not meet the minimal Git, tar, and Python requirements.

Here are the steps to take to build and run your own buildtools installer:

  1. On the machine that is able to run BitBake, be sure you have set up your build environment with the setup script (oe-init-build-env or oe-init-build-env-memres).

  2. Run the BitBake command to build the tarball:

         $ bitbake buildtools-tarball
                            

    Note

    The SDKMACHINE variable in your local.conf file determines whether you build tools for a 32-bit or 64-bit system.

    Once the build completes, you can find the .sh file that installs the tools in the tmp/deploy/sdk subdirectory of the Build Directory. The installer file has the string "buildtools" in the name.

  3. Transfer the .sh file from the build host to the machine that does not meet the Git, tar, or Python requirements.

  4. On the machine that does not meet the requirements, run the .sh file to install the tools. Here is an example:

         $ sh poky-glibc-x86_64-buildtools-tarball-x86_64-buildtools-nativesdk-standalone-2.2.sh
                           

    During execution, a prompt appears that allows you to choose the installation directory. For example, you could choose the following:

         /home/your_username/buildtools
                           

  5. Source the tools environment setup script by using a command like the following:

         $ source /home/your_username/buildtools/environment-setup-i586-poky-linux
                            

    Of course, you need to supply your installation directory and be sure to use the right file (i.e. i585 or x86-64).

    After you have sourced the setup script, the tools are added to PATH and any other environment variables required to run the tools are initialized. The results are working versions versions of Git, tar, Python and chrpath.

1.4. Obtaining the Yocto Project

The Yocto Project development team makes the Yocto Project available through a number of methods:

1.5. Development Checkouts

Development using the Yocto Project requires a local Source Directory. You can set up the Source Directory by cloning a copy of the upstream poky Git repository. For information on how to do this, see the "Getting Set Up" section in the Yocto Project Development Manual.

Chapter 2. Using the Yocto Project

This chapter describes common usage for the Yocto Project. The information is introductory in nature as other manuals in the Yocto Project documentation set provide more details on how to use the Yocto Project.

2.1. Running a Build

This section provides a summary of the build process and provides information for less obvious aspects of the build process. For general information on how to build an image using the OpenEmbedded build system, see the "Building Images" section of the Yocto Project Quick Start.

2.1.1. Build Overview

In the development environment you will need to build an image whenever you change hardware support, add or change system libraries, or add or change services that have dependencies.

Building an Image

The first thing you need to do is set up the OpenEmbedded build environment by sourcing an environment setup script (i.e. oe-init-build-env or oe-init-build-env-memres). Here is an example:

     $ source oe-init-build-env [build_dir]
            

The build_dir argument is optional and specifies the directory the OpenEmbedded build system uses for the build - the Build Directory. If you do not specify a Build Directory, it defaults to a directory named build in your current working directory. A common practice is to use a different Build Directory for different targets. For example, ~/build/x86 for a qemux86 target, and ~/build/arm for a qemuarm target.

Once the build environment is set up, you can build a target using:

     $ bitbake target
            

The target is the name of the recipe you want to build. Common targets are the images in meta/recipes-core/images, meta/recipes-sato/images, etc. all found in the Source Directory. Or, the target can be the name of a recipe for a specific piece of software such as BusyBox. For more details about the images the OpenEmbedded build system supports, see the "Images" chapter.

Note

Building an image without GNU General Public License Version 3 (GPLv3), or similarly licensed, components is supported for only minimal and base images. See the "Images" chapter for more information.

2.1.2. Building an Image Using GPL Components

When building an image using GPL components, you need to maintain your original settings and not switch back and forth applying different versions of the GNU General Public License. If you rebuild using different versions of GPL, dependency errors might occur due to some components not being rebuilt.

2.2. Installing and Using the Result

Once an image has been built, it often needs to be installed. The images and kernels built by the OpenEmbedded build system are placed in the Build Directory in tmp/deploy/images. For information on how to run pre-built images such as qemux86 and qemuarm, see the Yocto Project Software Development Kit (SDK) Developer's Guide. For information about how to install these images, see the documentation for your particular board or machine.

2.3. Debugging Tools and Techniques

The exact method for debugging build failures depends on the nature of the problem and on the system's area from which the bug originates. Standard debugging practices such as comparison against the last known working version with examination of the changes and the re-application of steps to identify the one causing the problem are valid for the Yocto Project just as they are for any other system. Even though it is impossible to detail every possible potential failure, this section provides some general tips to aid in debugging.

A useful feature for debugging is the error reporting tool. Configuring the Yocto Project to use this tool causes the OpenEmbedded build system to produce error reporting commands as part of the console output. You can enter the commands after the build completes to log error information into a common database, that can help you figure out what might be going wrong. For information on how to enable and use this feature, see the "Using the Error Reporting Tool" section in the Yocto Project Development Manual.

For discussions on debugging, see the "Debugging With the GNU Project Debugger (GDB) Remotely" section in the Yocto Project Developer's Manual and the "Working within Eclipse" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

Note

The remainder of this section presents many examples of the bitbake command. You can learn about BitBake by reading the BitBake User Manual.

2.3.1. Viewing Logs from Failed Tasks

You can find the log for a task in the file ${WORKDIR}/temp/log.do_taskname. For example, the log for the do_compile task of the QEMU minimal image for the x86 machine (qemux86) might be in tmp/work/qemux86-poky-linux/core-image-minimal/1.0-r0/temp/log.do_compile. To see the commands BitBake ran to generate a log, look at the corresponding run.do_taskname file in the same directory.

log.do_taskname and run.do_taskname are actually symbolic links to log.do_taskname.pid and log.run_taskname.pid, where pid is the PID the task had when it ran. The symlinks always point to the files corresponding to the most recent run.

2.3.2. Viewing Variable Values

BitBake's -e option is used to display variable values after parsing. The following command displays the variable values after the configuration files (i.e. local.conf, bblayers.conf, bitbake.conf and so forth) have been parsed:

     $ bitbake -e
            

The following command displays variable values after a specific recipe has been parsed. The variables include those from the configuration as well:

     $ bitbake -e recipename
            

Note

Each recipe has its own private set of variables (datastore). Internally, after parsing the configuration, a copy of the resulting datastore is made prior to parsing each recipe. This copying implies that variables set in one recipe will not be visible to other recipes.

Likewise, each task within a recipe gets a private datastore based on the recipe datastore, which means that variables set within one task will not be visible to other tasks.

In the output of bitbake -e, each variable is preceded by a description of how the variable got its value, including temporary values that were later overriden. This description also includes variable flags (varflags) set on the variable. The output can be very helpful during debugging.

Variables that are exported to the environment are preceded by export in the output of bitbake -e. See the following example:

     export CC="i586-poky-linux-gcc -m32 -march=i586 --sysroot=/home/ulf/poky/build/tmp/sysroots/qemux86"
            

In addition to variable values, the output of the bitbake -e and bitbake -e recipe commands includes the following information:

  • The output starts with a tree listing all configuration files and classes included globally, recursively listing the files they include or inherit in turn. Much of the behavior of the OpenEmbedded build system (including the behavior of the normal recipe build tasks) is implemented in the base class and the classes it inherits, rather than being built into BitBake itself.

  • After the variable values, all functions appear in the output. For shell functions, variables referenced within the function body are expanded. If a function has been modified using overrides or using override-style operators like _append and _prepend, then the final assembled function body appears in the output.

2.3.3. Viewing Package Information with oe-pkgdata-util

You can use the oe-pkgdata-util command-line utility to query PKGDATA_DIR and display various package-related information. When you use the utility, you must use it to view information on packages that have already been built.

Following are a few of the available oe-pkgdata-util subcommands.

Note

You can use the standard * and ? globbing wildcards as part of package names and paths.

  • oe-pkgdata-util list-pkgs [pattern]: Lists all packages that have been built, optionally limiting the match to packages that match pattern.

  • oe-pkgdata-util list-pkg-files package ...: Lists the files and directories contained in the given packages.

    Note

    A different way to view the contents of a package is to look at the ${WORKDIR}/packages-split directory of the recipe that generates the package. This directory is created by the do_package task and has one subdirectory for each package the recipe generates, which contains the files stored in that package.

    If you want to inspect the ${WORKDIR}/packages-split directory, make sure that rm_work is not enabled when you build the recipe.

  • oe-pkgdata-util find-path path ...: Lists the names of the packages that contain the given paths. For example, the following tells us that /usr/share/man/man1/make.1 is contained in the make-doc package:

         $ oe-pkgdata-util find-path /usr/share/man/man1/make.1
         make-doc: /usr/share/man/man1/make.1
                        

  • oe-pkgdata-util lookup-recipe package ...: Lists the name of the recipes that produce the given packages.

For more information on the oe-pkgdata-util command, use the help facility:

     $ oe-pkgdata-util ‐‐help
     $ oe-pkgdata-util subcommand --help
            

2.3.4. Viewing Dependencies Between Recipes and Tasks

Sometimes it can be hard to see why BitBake wants to build other recipes before the one you have specified. Dependency information can help you understand why a recipe is built.

To generate dependency information for a recipe, run the following command:

     $ bitbake -g recipename
            

This command writes the following files in the current directory:

  • pn-buildlist: A list of recipes/targets involved in building recipename. "Involved" here means that at least one task from the recipe needs to run when building recipename from scratch. Targets that are in ASSUME_PROVIDED are not listed.

  • pn-depends.dot: A graph showing dependencies between build-time targets (recipes).

  • package-depends.dot: A graph showing known dependencies between runtime targets.

  • task-depends.dot: A graph showing dependencies between tasks.

The graphs are in DOT format and can be converted to images (e.g. using the dot tool from Graphviz).

Notes

  • DOT files use a plain text format. The graphs generated using the bitbake -g command are often so large as to be difficult to read without special pruning (e.g. with Bitbake's -I option) and processing. Despite the form and size of the graphs, the corresponding .dot files can still be possible to read and provide useful information.

    As an example, the task-depends.dot file contains lines such as the following:

         "libxslt.do_configure" -> "libxml2.do_populate_sysroot"
                            

    The above example line reveals that the do_configure task in libxslt depends on the do_populate_sysroot task in libxml2, which is a normal DEPENDS dependency between the two recipes.

  • For an example of how .dot files can be processed, see the scripts/contrib/graph-tool Python script, which finds and displays paths between graph nodes.

You can use a different method to view dependency information by using the following command:

     $ bitbake -g -u depexp recipename
            

This command displays a GUI window from which you can view build-time and runtime dependencies for the recipes involved in building recipename.

2.3.5. Viewing Task Variable Dependencies

As mentioned in the "Checksums (Signatures)" section of the BitBake User Manual, BitBake tries to automatically determine what variables a task depends on so that it can rerun the task if any values of the variables change. This determination is usually reliable. However, if you do things like construct variable names at runtime, then you might have to manually declare dependencies on those variables using vardeps as described in the "Variable Flags" section of the BitBake User Manual.

If you are unsure whether a variable dependency is being picked up automatically for a given task, you can list the variable dependencies BitBake has determined by doing the following:

  1. Build the recipe containing the task:

         $ bitbake recipename
                        

  2. Inside the STAMPS_DIR directory, find the signature data (sigdata) file that corresponds to the task. The sigdata files contain a pickled Python database of all the metadata that went into creating the input checksum for the task. As an example, for the do_fetch task of the db recipe, the sigdata file might be found in the following location:

         ${BUILDDIR}/tmp/stamps/i586-poky-linux/db/6.0.30-r1.do_fetch.sigdata.7c048c18222b16ff0bcee2000ef648b1
                        

    For tasks that are accelerated through the shared state (sstate) cache, an additional siginfo file is written into SSTATE_DIR along with the cached task output. The siginfo files contain exactly the same information as sigdata files.

  3. Run bitbake-dumpsig on the sigdata or siginfo file. Here is an example:

         $ bitbake-dumpsig ${BUILDDIR}/tmp/stamps/i586-poky-linux/db/6.0.30-r1.do_fetch.sigdata.7c048c18222b16ff0bcee2000ef648b1
                        

    In the output of the above command, you will find a line like the following, which lists all the (inferred) variable dependencies for the task. This list also includes indirect dependencies from variables depending on other variables, recursively.

         Task dependencies: ['PV', 'SRCREV', 'SRC_URI', 'SRC_URI[md5sum]', 'SRC_URI[sha256sum]', 'base_do_fetch']
                        

    Note

    Functions (e.g. base_do_fetch) also count as variable dependencies. These functions in turn depend on the variables they reference.

    The output of bitbake-dumpsig also includes the value each variable had, a list of dependencies for each variable, and BB_HASHBASE_WHITELIST information.

There is also a bitbake-diffsigs command for comparing two siginfo or sigdata files. This command can be helpful when trying to figure out what changed between two versions of a task. If you call bitbake-diffsigs with just one file, the command behaves like bitbake-dumpsig.

You can also use BitBake to dump out the signature construction information without executing tasks by using either of the following BitBake command-line options:

     ‐‐dump-signatures=SIGNATURE_HANDLER
     -S SIGNATURE_HANDLER
            

Note

Two common values for SIGNATURE_HANDLER are "none" and "printdiff", which dump only the signature or compare the dumped signature with the cached one, respectively.

Using BitBake with either of these options causes BitBake to dump out sigdata files in the stamps directory for every task it would have executed instead of building the specified target package.

2.3.6. Running Specific Tasks

Any given recipe consists of a set of tasks. The standard BitBake behavior in most cases is: do_fetch, do_unpack, do_patch, do_configure, do_compile, do_install, do_package, do_package_write_*, and do_build. The default task is do_build and any tasks on which it depends build first. Some tasks, such as do_devshell, are not part of the default build chain. If you wish to run a task that is not part of the default build chain, you can use the -c option in BitBake. Here is an example:

     $ bitbake matchbox-desktop -c devshell
            

The -c option respects task dependencies, which means that all other tasks (including tasks from other recipes) that the specified task depends on will be run before the task. Even when you manually specify a task to run with -c, BitBake will only run the task if it considers it "out of date". See the "Stamp Files and the Rerunning of Tasks" section for how BitBake determines whether a task is "out of date".

If you want to force an up-to-date task to be rerun (e.g. because you made manual modifications to the recipe's WORKDIR that you want to try out), then you can use the -f option.

Note

The reason -f is never required when running the do_devshell task is because the [nostamp] variable flag is already set for the task.

The following example shows one way you can use the -f option:

     $ bitbake matchbox-desktop
               .
               .
     make some changes to the source code in the work directory
               .
               .
     $ bitbake matchbox-desktop -c compile -f
     $ bitbake matchbox-desktop
            

This sequence first builds and then recompiles matchbox-desktop. The last command reruns all tasks (basically the packaging tasks) after the compile. BitBake recognizes that the do_compile task was rerun and therefore understands that the other tasks also need to be run again.

Another, shorter way to rerun a task and all normal recipe build tasks that depend on it is to use the -C option.

Note

This option is upper-cased and is separate from the -c option, which is lower-cased.

Using this option invalidates the given task and then runs the do_build task, which is the default task if no task is given, and the tasks on which it depends. You could replace the final two commands in the previous example with the following single command:

     $ bitbake matchbox-desktop -C compile
            

Internally, the -f and -C options work by tainting (modifying) the input checksum of the specified task. This tainting indirectly causes the task and its dependent tasks to be rerun through the normal task dependency mechanisms.

Note

BitBake explicitly keeps track of which tasks have been tainted in this fashion, and will print warnings such as the following for builds involving such tasks:
     WARNING: /home/ulf/poky/meta/recipes-sato/matchbox-desktop/matchbox-desktop_2.1.bb.do_compile is tainted from a forced run
                
The purpose of the warning is to let you know that the work directory and build output might not be in the clean state they would be in for a "normal" build, depending on what actions you took. To get rid of such warnings, you can remove the work directory and rebuild the recipe, as follows:
     $ bitbake matchbox-desktop -c clean
     $ bitbake matchbox-desktop
                

You can view a list of tasks in a given package by running the do_listtasks task as follows:

     $ bitbake matchbox-desktop -c listtasks
            

The results appear as output to the console and are also in the file ${WORKDIR}/temp/log.do_listtasks.

2.3.7. Checking for Missing Build-Time Dependencies

A recipe might build successfully even though some of its build-time dependencies are missing from DEPENDS. Following are the two most common ways in which that can happen:

  • The build-time dependency just happens to already exist in the staging sysroot (STAGING_DIR_HOST) by the time the recipe is built. This situation occurs when the build-time dependency is built earlier during recipe processing.

  • The component built by the recipe conditionally enables functionality depending on whether it can find the build-time dependency in the staging sysroot. If the build-time dependency is missing, the corresponding functionality is disabled. This condition is known as a "floating dependency".

Because dealing with the second case is more complex, focus will be on the first case. The build-deps QA check checks that every library the component linked against is declared as a build-time dependency. If that is not the case, then the first situation described in the previous list exists, and build-deps reports a missing build-time dependency.

Another, more manual, way to check a recipe for missing build-time dependencies of the first type is to build with an empty staging sysroot. This method can also find missing build-time dependencies that are not in the form of libraries, which the build-deps QA check is unable to find.

An easy way to empty the staging sysroots is to simply remove TMPDIR, which is usually ${BUILDDIR}/tmp, as it includes the staging sysroots. Another, faster method to empty the staging sysroots is to use the scripts/wipe-sysroot script, which removes just the staging sysroots and keeps everything else in TMPDIR.

Note

The scripts/ directory appears in PATH after running the build environment initialization script (i.e. oe-init-build-env or oe-init-build-env-memres), which results in the ability to to run wipe-sysroot immediately.

2.3.8. General BitBake Problems

You can see debug output from BitBake by using the -D option. The debug output gives more information about what BitBake is doing and the reason behind it. Each -D option you use increases the logging level. The most common usage is -DDD.

The output from bitbake -DDD -v targetname can reveal why BitBake chose a certain version of a package or why BitBake picked a certain provider. This command could also help you in a situation where you think BitBake did something unexpected.

2.3.9. Development Host System Issues

Sometimes issues on the host development system can cause your build to fail. Following are known, host-specific problems. Be sure to always consult the Release Notes for a look at all release-related issues.

  • glibc-initial fails to build: If your development host system has the unpatched GNU Make 3.82, the do_install task fails for glibc-initial during the build.

    Typically, every distribution that ships GNU Make 3.82 as the default already has the patched version. However, some distributions, such as Debian, have GNU Make 3.82 as an option, which is unpatched. You will see this error on these types of distributions. Switch to GNU Make 3.81 or patch your make to solve the problem.

2.3.10. Building with No Dependencies

To build a specific recipe (.bb file), you can use the following command form:

     $ bitbake -b somepath/somerecipe.bb
            

This command form does not check for dependencies. Consequently, you should use it only when you know existing dependencies have been met.

Note

You can also specify fragments of the filename. In this case, BitBake checks for a unique match.

2.3.11. Recipe Logging Mechanisms

The Yocto Project provides several logging functions for producing debugging output and reporting errors and warnings. For Python functions, the following logging functions exist. All of these functions log to ${T}/log.do_task, and can also log to standard output (stdout) with the right settings:

  • bb.plain(msg): Writes msg as is to the log while also logging to stdout.

  • bb.note(msg): Writes "NOTE: msg" to the log. Also logs to stdout if BitBake is called with "-v".

  • bb.debug(levelmsg): Writes "DEBUG: msg" to the log. Also logs to stdout if the log level is greater than or equal to level. See the "-D" option in the BitBake User Manual for more information.

  • bb.warn(msg): Writes "WARNING: msg" to the log while also logging to stdout.

  • bb.error(msg): Writes "ERROR: msg" to the log while also logging to stdout.

    Note

    Calling this function does not cause the task to fail.

  • bb.fatal(msg): This logging function is similar to bb.error(msg) but also causes the calling task to fail.

    Note

    bb.fatal() raises an exception, which means you do not need to put a "return" statement after the function.

The same logging functions are also available in shell functions, under the names bbplain, bbnote, bbdebug, bbwarn, bberror, and bbfatal. The logging class implements these functions. See that class in the meta/classes folder of the Source Directory for information.

2.3.11.1. Logging With Python

When creating recipes using Python and inserting code that handles build logs, keep in mind the goal is to have informative logs while keeping the console as "silent" as possible. Also, if you want status messages in the log, use the "debug" loglevel.

Following is an example written in Python. The code handles logging for a function that determines the number of tasks needed to be run. See the "do_listtasks" section for additional information:

     python do_listtasks() {
         bb.debug(2, "Starting to figure out the task list")
         if noteworthy_condition:
             bb.note("There are 47 tasks to run")
         bb.debug(2, "Got to point xyz")
         if warning_trigger:
             bb.warn("Detected warning_trigger, this might be a problem later.")
         if recoverable_error:
             bb.error("Hit recoverable_error, you really need to fix this!")
         if fatal_error:
             bb.fatal("fatal_error detected, unable to print the task list")
         bb.plain("The tasks present are abc")
         bb.debug(2, "Finished figuring out the tasklist")
     }
                

2.3.11.2. Logging With Bash

When creating recipes using Bash and inserting code that handles build logs, you have the same goals - informative with minimal console output. The syntax you use for recipes written in Bash is similar to that of recipes written in Python described in the previous section.

Following is an example written in Bash. The code logs the progress of the do_my_function function.

     do_my_function() {
         bbdebug 2 "Running do_my_function"
         if [ exceptional_condition ]; then
             bbnote "Hit exceptional_condition"
         fi
         bbdebug 2  "Got to point xyz"
         if [ warning_trigger ]; then
             bbwarn "Detected warning_trigger, this might cause a problem later."
         fi
         if [ recoverable_error ]; then
             bberror "Hit recoverable_error, correcting"
         fi
         if [ fatal_error ]; then
             bbfatal "fatal_error detected"
         fi
         bbdebug 2 "Completed do_my_function"
     }
                

2.3.12. Other Tips

Here are some other tips that you might find useful:

  • When adding new packages, it is worth watching for undesirable items making their way into compiler command lines. For example, you do not want references to local system files like /usr/lib/ or /usr/include/.

  • If you want to remove the psplash boot splashscreen, add psplash=false to the kernel command line. Doing so prevents psplash from loading and thus allows you to see the console. It is also possible to switch out of the splashscreen by switching the virtual console (e.g. Fn+Left or Fn+Right on a Zaurus).

  • Removing TMPDIR (usually tmp/, within the Build Directory) can often fix temporary build issues. Removing TMPDIR is usually a relatively cheap operation, because task output will be cached in SSTATE_DIR (usually sstate-cache/, which is also in the Build Directory).

    Note

    Removing TMPDIR might be a workaround rather than a fix. Consequently, trying to determine the underlying cause of an issue before removing the directory is a good idea.

  • Understanding how a feature is used in practice within existing recipes can be very helpful. It is recommended that you configure some method that allows you to quickly search through files.

    Using GNU Grep, you can use the following shell function to recursively search through common recipe-related files, skipping binary files, .git directories, and the Build Directory (assuming its name starts with "build"):

         g() {
             grep -Ir \
                  --exclude-dir=.git \
                  --exclude-dir='build*' \
                  --include='*.bb*' \
                  --include='*.inc*' \
                  --include='*.conf*' \
                  --include='*.py*' \
                  "$@"
         }
                        

    Following are some usage examples:

         $ g FOO    # Search recursively for "FOO"
         $ g -i foo # Search recursively for "foo", ignoring case
         $ g -w FOO # Search recursively for "FOO" as a word, ignoring e.g. "FOOBAR"
                        

    If figuring out how some feature works requires a lot of searching, it might indicate that the documentation should be extended or improved. In such cases, consider filing a documentation bug using the Yocto Project implementation of Bugzilla. For general information on how to submit a bug against the Yocto Project, see the "Tracking Bugs" section in the Yocto Project Development Manual.

    Note

    The manuals might not be the right place to document variables that are purely internal and have a limited scope (e.g. internal variables used to implement a single .bbclass file).

2.4. Maintaining Build Output Quality

Many factors can influence the quality of a build. For example, if you upgrade a recipe to use a new version of an upstream software package or you experiment with some new configuration options, subtle changes can occur that you might not detect until later. Consider the case where your recipe is using a newer version of an upstream package. In this case, a new version of a piece of software might introduce an optional dependency on another library, which is auto-detected. If that library has already been built when the software is building, the software will link to the built library and that library will be pulled into your image along with the new software even if you did not want the library.

The buildhistory class exists to help you maintain the quality of your build output. You can use the class to highlight unexpected and possibly unwanted changes in the build output. When you enable build history, it records information about the contents of each package and image and then commits that information to a local Git repository where you can examine the information.

The remainder of this section describes the following:

  • How you can enable and disable build history

  • How to understand what the build history contains

  • How to limit the information used for build history

  • How to examine the build history from both a command-line and web interface

2.4.1. Enabling and Disabling Build History

Build history is disabled by default. To enable it, add the following INHERIT statement and set the BUILDHISTORY_COMMIT variable to "1" at the end of your conf/local.conf file found in the Build Directory:

     INHERIT += "buildhistory"
     BUILDHISTORY_COMMIT = "1"
            

Enabling build history as previously described causes the build process to collect build output information and commit it to a local Git repository.

Note

Enabling build history increases your build times slightly, particularly for images, and increases the amount of disk space used during the build.

You can disable build history by removing the previous statements from your conf/local.conf file.

2.4.2. Understanding What the Build History Contains

Build history information is kept in ${TOPDIR}/buildhistory in the Build Directory as defined by the BUILDHISTORY_DIR variable. The following is an example abbreviated listing:

At the top level, there is a metadata-revs file that lists the revisions of the repositories for the layers enabled when the build was produced. The rest of the data splits into separate packages, images and sdk directories, the contents of which are described below.

2.4.2.1. Build History Package Information

The history for each package contains a text file that has name-value pairs with information about the package. For example, buildhistory/packages/i586-poky-linux/busybox/busybox/latest contains the following:

     PV = 1.22.1
     PR = r32
     RPROVIDES =
     RDEPENDS = glibc (>= 2.20) update-alternatives-opkg
     RRECOMMENDS = busybox-syslog busybox-udhcpc update-rc.d
     PKGSIZE = 540168
     FILES = /usr/bin/* /usr/sbin/* /usr/lib/busybox/* /usr/lib/lib*.so.* \
        /etc /com /var /bin/* /sbin/* /lib/*.so.* /lib/udev/rules.d \
        /usr/lib/udev/rules.d /usr/share/busybox /usr/lib/busybox/* \
        /usr/share/pixmaps /usr/share/applications /usr/share/idl \
        /usr/share/omf /usr/share/sounds /usr/lib/bonobo/servers
     FILELIST = /bin/busybox /bin/busybox.nosuid /bin/busybox.suid /bin/sh \
        /etc/busybox.links.nosuid /etc/busybox.links.suid
                

Most of these name-value pairs correspond to variables used to produce the package. The exceptions are FILELIST, which is the actual list of files in the package, and PKGSIZE, which is the total size of files in the package in bytes.

There is also a file corresponding to the recipe from which the package came (e.g. buildhistory/packages/i586-poky-linux/busybox/latest):

     PV = 1.22.1
     PR = r32
     DEPENDS = initscripts kern-tools-native update-rc.d-native \
        virtual/i586-poky-linux-compilerlibs virtual/i586-poky-linux-gcc \
        virtual/libc virtual/update-alternatives
     PACKAGES = busybox-ptest busybox-httpd busybox-udhcpd busybox-udhcpc \
        busybox-syslog busybox-mdev busybox-hwclock busybox-dbg \
        busybox-staticdev busybox-dev busybox-doc busybox-locale busybox
                

Finally, for those recipes fetched from a version control system (e.g., Git), a file exists that lists source revisions that are specified in the recipe and lists the actual revisions used during the build. Listed and actual revisions might differ when SRCREV is set to ${AUTOREV}. Here is an example assuming buildhistory/packages/qemux86-poky-linux/linux-yocto/latest_srcrev):

     # SRCREV_machine = "38cd560d5022ed2dbd1ab0dca9642e47c98a0aa1"
     SRCREV_machine = "38cd560d5022ed2dbd1ab0dca9642e47c98a0aa1"
     # SRCREV_meta = "a227f20eff056e511d504b2e490f3774ab260d6f"
     SRCREV_meta = "a227f20eff056e511d504b2e490f3774ab260d6f"
                

You can use the buildhistory-collect-srcrevs command with the -a option to collect the stored SRCREV values from build history and report them in a format suitable for use in global configuration (e.g., local.conf or a distro include file) to override floating AUTOREV values to a fixed set of revisions. Here is some example output from this command:

     $ buildhistory-collect-srcrevs -a
     # i586-poky-linux
     SRCREV_pn-glibc = "b8079dd0d360648e4e8de48656c5c38972621072"
     SRCREV_pn-glibc-initial = "b8079dd0d360648e4e8de48656c5c38972621072"
     SRCREV_pn-opkg-utils = "53274f087565fd45d8452c5367997ba6a682a37a"
     SRCREV_pn-kmod = "fd56638aed3fe147015bfa10ed4a5f7491303cb4"
     # x86_64-linux
     SRCREV_pn-gtk-doc-stub-native = "1dea266593edb766d6d898c79451ef193eb17cfa"
     SRCREV_pn-dtc-native = "65cc4d2748a2c2e6f27f1cf39e07a5dbabd80ebf"
     SRCREV_pn-update-rc.d-native = "eca680ddf28d024954895f59a241a622dd575c11"
     SRCREV_glibc_pn-cross-localedef-native = "b8079dd0d360648e4e8de48656c5c38972621072"
     SRCREV_localedef_pn-cross-localedef-native = "c833367348d39dad7ba018990bfdaffaec8e9ed3"
     SRCREV_pn-prelink-native = "faa069deec99bf61418d0bab831c83d7c1b797ca"
     SRCREV_pn-opkg-utils-native = "53274f087565fd45d8452c5367997ba6a682a37a"
     SRCREV_pn-kern-tools-native = "23345b8846fe4bd167efdf1bd8a1224b2ba9a5ff"
     SRCREV_pn-kmod-native = "fd56638aed3fe147015bfa10ed4a5f7491303cb4"
     # qemux86-poky-linux
     SRCREV_machine_pn-linux-yocto = "38cd560d5022ed2dbd1ab0dca9642e47c98a0aa1"
     SRCREV_meta_pn-linux-yocto = "a227f20eff056e511d504b2e490f3774ab260d6f"
     # all-poky-linux
     SRCREV_pn-update-rc.d = "eca680ddf28d024954895f59a241a622dd575c11"
                

Note

Here are some notes on using the buildhistory-collect-srcrevs command:
  • By default, only values where the SRCREV was not hardcoded (usually when AUTOREV was used) are reported. Use the -a option to see all SRCREV values.

  • The output statements might not have any effect if overrides are applied elsewhere in the build system configuration. Use the -f option to add the forcevariable override to each output line if you need to work around this restriction.

  • The script does apply special handling when building for multiple machines. However, the script does place a comment before each set of values that specifies which triplet to which they belong as shown above (e.g., i586-poky-linux).

2.4.2.2. Build History Image Information

The files produced for each image are as follows:

  • image-files: A directory containing selected files from the root filesystem. The files are defined by BUILDHISTORY_IMAGE_FILES.

  • build-id.txt: Human-readable information about the build configuration and metadata source revisions. This file contains the full build header as printed by BitBake.

  • *.dot: Dependency graphs for the image that are compatible with graphviz.

  • files-in-image.txt: A list of files in the image with permissions, owner, group, size, and symlink information.

  • image-info.txt: A text file containing name-value pairs with information about the image. See the following listing example for more information.

  • installed-package-names.txt: A list of installed packages by name only.

  • installed-package-sizes.txt: A list of installed packages ordered by size.

  • installed-packages.txt: A list of installed packages with full package filenames.

Note

Installed package information is able to be gathered and produced even if package management is disabled for the final image.

Here is an example of image-info.txt:

     DISTRO = poky
     DISTRO_VERSION = 1.7
     USER_CLASSES = buildstats image-mklibs image-prelink
     IMAGE_CLASSES = image_types
     IMAGE_FEATURES = debug-tweaks
     IMAGE_LINGUAS =
     IMAGE_INSTALL = packagegroup-core-boot run-postinsts
     BAD_RECOMMENDATIONS =
     NO_RECOMMENDATIONS =
     PACKAGE_EXCLUDE =
     ROOTFS_POSTPROCESS_COMMAND = write_package_manifest; license_create_manifest; \
        write_image_manifest ; buildhistory_list_installed_image ; \
        buildhistory_get_image_installed ; ssh_allow_empty_password;  \
        postinst_enable_logging; rootfs_update_timestamp ; ssh_disable_dns_lookup ;
     IMAGE_POSTPROCESS_COMMAND =   buildhistory_get_imageinfo ;
     IMAGESIZE = 6900
                

Other than IMAGESIZE, which is the total size of the files in the image in Kbytes, the name-value pairs are variables that may have influenced the content of the image. This information is often useful when you are trying to determine why a change in the package or file listings has occurred.

2.4.2.3. Using Build History to Gather Image Information Only

As you can see, build history produces image information, including dependency graphs, so you can see why something was pulled into the image. If you are just interested in this information and not interested in collecting specific package or SDK information, you can enable writing only image information without any history by adding the following to your conf/local.conf file found in the Build Directory:

     INHERIT += "buildhistory"
     BUILDHISTORY_COMMIT = "0"
     BUILDHISTORY_FEATURES = "image"
                

Here, you set the BUILDHISTORY_FEATURES variable to use the image feature only.

2.4.2.4. Build History SDK Information

Build history collects similar information on the contents of SDKs (e.g. bitbake -c populate_sdk imagename) as compared to information it collects for images. Furthermore, this information differs depending on whether an extensible or standard SDK is being produced.

The following list shows the files produced for SDKs:

  • files-in-sdk.txt: A list of files in the SDK with permissions, owner, group, size, and symlink information. This list includes both the host and target parts of the SDK.

  • sdk-info.txt: A text file containing name-value pairs with information about the SDK. See the following listing example for more information.

  • sstate-task-sizes.txt: A text file containing name-value pairs with information about task group sizes (e.g. do_populate_sysroot tasks have a total size). The sstate-task-sizes.txt file exists only when an extensible SDK is created.

  • sstate-package-sizes.txt: A text file containing name-value pairs with information for the shared-state packages and sizes in the SDK. The sstate-package-sizes.txt file exists only when an extensible SDK is created.

  • sdk-files: A folder that contains copies of the files mentioned in BUILDHISTORY_SDK_FILES if the files are present in the output. Additionally, the default value of BUILDHISTORY_SDK_FILES is specific to the extensible SDK although you can set it differently if you would like to pull in specific files from the standard SDK.

    The default files are conf/local.conf, conf/bblayers.conf, conf/auto.conf, conf/locked-sigs.inc, and conf/devtool.conf. Thus, for an extensible SDK, these files get copied into the sdk-files directory.

  • The following information appears under each of the host and target directories for the portions of the SDK that run on the host and on the target, respectively:

    Note

    The following files for the most part are empty when producing an extensible SDK because this type of SDK is not constructed from packages as is the standard SDK.

    • depends.dot: Dependency graph for the SDK that is compatible with graphviz.

    • installed-package-names.txt: A list of installed packages by name only.

    • installed-package-sizes.txt: A list of installed packages ordered by size.

    • installed-packages.txt: A list of installed packages with full package filenames.

Here is an example of sdk-info.txt:

     DISTRO = poky
     DISTRO_VERSION = 1.3+snapshot-20130327
     SDK_NAME = poky-glibc-i686-arm
     SDK_VERSION = 1.3+snapshot
     SDKMACHINE =
     SDKIMAGE_FEATURES = dev-pkgs dbg-pkgs
     BAD_RECOMMENDATIONS =
     SDKSIZE = 352712
                

Other than SDKSIZE, which is the total size of the files in the SDK in Kbytes, the name-value pairs are variables that might have influenced the content of the SDK. This information is often useful when you are trying to determine why a change in the package or file listings has occurred.

2.4.2.5. Examining Build History Information

You can examine build history output from the command line or from a web interface.

To see any changes that have occurred (assuming you have BUILDHISTORY_COMMIT = "1"), you can simply use any Git command that allows you to view the history of a repository. Here is one method:

      $ git log -p
                

You need to realize, however, that this method does show changes that are not significant (e.g. a package's size changing by a few bytes).

A command-line tool called buildhistory-diff does exist, though, that queries the Git repository and prints just the differences that might be significant in human-readable form. Here is an example:

     $ ~/poky/poky/scripts/buildhistory-diff . HEAD^
     Changes to images/qemux86_64/glibc/core-image-minimal (files-in-image.txt):
        /etc/anotherpkg.conf was added
        /sbin/anotherpkg was added
        * (installed-package-names.txt):
        *   anotherpkg was added
     Changes to images/qemux86_64/glibc/core-image-minimal (installed-package-names.txt):
        anotherpkg was added
     packages/qemux86_64-poky-linux/v86d: PACKAGES: added "v86d-extras"
        * PR changed from "r0" to "r1"
        * PV changed from "0.1.10" to "0.1.12"
     packages/qemux86_64-poky-linux/v86d/v86d: PKGSIZE changed from 110579 to 144381 (+30%)
        * PR changed from "r0" to "r1"
        * PV changed from "0.1.10" to "0.1.12"
                

Note

The buildhistory-diff tool requires the GitPython package. Be sure to install it using Pip3 as follows:
   $ pip3 install GitPython --user
                    
Alternatively, you can install python3-git using the appropriate distribution package manager (e.g. apt-get, dnf, or zipper).

To see changes to the build history using a web interface, follow the instruction in the README file here. http://git.yoctoproject.org/cgit/cgit.cgi/buildhistory-web/.

Here is a sample screenshot of the interface:

2.5. Speeding Up the Build

Build time can be an issue. By default, the build system uses simple controls to try and maximize build efficiency. In general, the default settings for all the following variables result in the most efficient build times when dealing with single socket systems (i.e. a single CPU). If you have multiple CPUs, you might try increasing the default values to gain more speed. See the descriptions in the glossary for each variable for more information:

As mentioned, these variables all scale to the number of processor cores available on the build system. For single socket systems, this auto-scaling ensures that the build system fundamentally takes advantage of potential parallel operations during the build based on the build machine's capabilities.

Following are additional factors that can affect build speed:

  • File system type: The file system type that the build is being performed on can also influence performance. Using ext4 is recommended as compared to ext2 and ext3 due to ext4 improved features such as extents.

  • Disabling the updating of access time using noatime: The noatime mount option prevents the build system from updating file and directory access times.

  • Setting a longer commit: Using the "commit=" mount option increases the interval in seconds between disk cache writes. Changing this interval from the five second default to something longer increases the risk of data loss but decreases the need to write to the disk, thus increasing the build performance.

  • Choosing the packaging backend: Of the available packaging backends, IPK is the fastest. Additionally, selecting a singular packaging backend also helps.

  • Using tmpfs for TMPDIR as a temporary file system: While this can help speed up the build, the benefits are limited due to the compiler using -pipe. The build system goes to some lengths to avoid sync() calls into the file system on the principle that if there was a significant failure, the Build Directory contents could easily be rebuilt.

  • Inheriting the rm_work class: Inheriting this class has shown to speed up builds due to significantly lower amounts of data stored in the data cache as well as on disk. Inheriting this class also makes cleanup of TMPDIR faster, at the expense of being easily able to dive into the source code. File system maintainers have recommended that the fastest way to clean up large numbers of files is to reformat partitions rather than delete files due to the linear nature of partitions. This, of course, assumes you structure the disk partitions and file systems in a way that this is practical.

Aside from the previous list, you should keep some trade offs in mind that can help you speed up the build:

  • Remove items from DISTRO_FEATURES that you might not need.

  • Exclude debug symbols and other debug information: If you do not need these symbols and other debug information, disabling the *-dbg package generation can speed up the build. You can disable this generation by setting the INHIBIT_PACKAGE_DEBUG_SPLIT variable to "1".

  • Disable static library generation for recipes derived from autoconf or libtool: Following is an example showing how to disable static libraries and still provide an override to handle exceptions:

         STATICLIBCONF = "--disable-static"
         STATICLIBCONF_sqlite3-native = ""
         EXTRA_OECONF += "${STATICLIBCONF}"
                    

    Notes

    • Some recipes need static libraries in order to work correctly (e.g. pseudo-native needs sqlite3-native). Overrides, as in the previous example, account for these kinds of exceptions.

    • Some packages have packaging code that assumes the presence of the static libraries. If so, you might need to exclude them as well.

Chapter 3. A Closer Look at the Yocto Project Development Environment

This chapter takes a more detailed look at the Yocto Project development environment. The following diagram represents the development environment at a high level. The remainder of this chapter expands on the fundamental input, output, process, and Metadata) blocks in the Yocto Project development environment.

The generalized Yocto Project Development Environment consists of several functional areas:

  • User Configuration: Metadata you can use to control the build process.

  • Metadata Layers: Various layers that provide software, machine, and distro Metadata.

  • Source Files: Upstream releases, local projects, and SCMs.

  • Build System: Processes under the control of BitBake. This block expands on how BitBake fetches source, applies patches, completes compilation, analyzes output for package generation, creates and tests packages, generates images, and generates cross-development tools.

  • Package Feeds: Directories containing output packages (RPM, DEB or IPK), which are subsequently used in the construction of an image or SDK, produced by the build system. These feeds can also be copied and shared using a web server or other means to facilitate extending or updating existing images on devices at runtime if runtime package management is enabled.

  • Images: Images produced by the development process.

  • Application Development SDK: Cross-development tools that are produced along with an image or separately with BitBake.

3.1. User Configuration

User configuration helps define the build. Through user configuration, you can tell BitBake the target architecture for which you are building the image, where to store downloaded source, and other build properties.

The following figure shows an expanded representation of the "User Configuration" box of the general Yocto Project Development Environment figure:

BitBake needs some basic configuration files in order to complete a build. These files are *.conf files. The minimally necessary ones reside as example files in the Source Directory. For simplicity, this section refers to the Source Directory as the "Poky Directory."

When you clone the poky Git repository or you download and unpack a Yocto Project release, you can set up the Source Directory to be named anything you want. For this discussion, the cloned repository uses the default name poky.

Note

The Poky repository is primarily an aggregation of existing repositories. It is not a canonical upstream source.

The meta-poky layer inside Poky contains a conf directory that has example configuration files. These example files are used as a basis for creating actual configuration files when you source the build environment script (i.e. oe-init-build-env or oe-init-build-env-memres).

Sourcing the build environment script creates a Build Directory if one does not already exist. BitBake uses the Build Directory for all its work during builds. The Build Directory has a conf directory that contains default versions of your local.conf and bblayers.conf configuration files. These default configuration files are created only if versions do not already exist in the Build Directory at the time you source the build environment setup script.

Because the Poky repository is fundamentally an aggregation of existing repositories, some users might be familiar with running the oe-init-build-env or oe-init-build-env-memres script in the context of separate OpenEmbedded-Core and BitBake repositories rather than a single Poky repository. This discussion assumes the script is executed from within a cloned or unpacked version of Poky.

Depending on where the script is sourced, different sub-scripts are called to set up the Build Directory (Yocto or OpenEmbedded). Specifically, the script scripts/oe-setup-builddir inside the poky directory sets up the Build Directory and seeds the directory (if necessary) with configuration files appropriate for the Yocto Project development environment.

Note

The scripts/oe-setup-builddir script uses the $TEMPLATECONF variable to determine which sample configuration files to locate.

The local.conf file provides many basic variables that define a build environment. Here is a list of a few. To see the default configurations in a local.conf file created by the build environment script, see the local.conf.sample in the meta-poky layer:

Note

Configurations set in the conf/local.conf file can also be set in the conf/site.conf and conf/auto.conf configuration files.

The bblayers.conf file tells BitBake what layers you want considered during the build. By default, the layers listed in this file include layers minimally needed by the build system. However, you must manually add any custom layers you have created. You can find more information on working with the bblayers.conf file in the "Enabling Your Layer" section in the Yocto Project Development Manual.

The files site.conf and auto.conf are not created by the environment initialization script. If you want the site.conf file, you need to create that yourself. The auto.conf file is typically created by an autobuilder:

  • site.conf: You can use the conf/site.conf configuration file to configure multiple build directories. For example, suppose you had several build environments and they shared some common features. You can set these default build properties here. A good example is perhaps the packaging format to use through the PACKAGE_CLASSES variable.

    One useful scenario for using the conf/site.conf file is to extend your BBPATH variable to include the path to a conf/site.conf. Then, when BitBake looks for Metadata using BBPATH, it finds the conf/site.conf file and applies your common configurations found in the file. To override configurations in a particular build directory, alter the similar configurations within that build directory's conf/local.conf file.

  • auto.conf: The file is usually created and written to by an autobuilder. The settings put into the file are typically the same as you would find in the conf/local.conf or the conf/site.conf files.

You can edit all configuration files to further define any particular build environment. This process is represented by the "User Configuration Edits" box in the figure.

When you launch your build with the bitbake target command, BitBake sorts out the configurations to ultimately define your build environment. It is important to understand that the OpenEmbedded build system reads the configuration files in a specific order: site.conf, auto.conf, and local.conf. And, the build system applies the normal assignment statement rules. Because the files are parsed in a specific order, variable assignments for the same variable could be affected. For example, if the auto.conf file and the local.conf set variable1 to different values, because the build system parses local.conf after auto.conf, variable1 is assigned the value from the local.conf file.

3.2. Metadata, Machine Configuration, and Policy Configuration

The previous section described the user configurations that define BitBake's global behavior. This section takes a closer look at the layers the build system uses to further control the build. These layers provide Metadata for the software, machine, and policy.

In general, three types of layer input exist:

  • Policy Configuration: Distribution Layers provide top-level or general policies for the image or SDK being built. For example, this layer would dictate whether BitBake produces RPM or IPK packages.

  • Machine Configuration: Board Support Package (BSP) layers provide machine configurations. This type of information is specific to a particular target architecture.

  • Metadata: Software layers contain user-supplied recipe files, patches, and append files.

The following figure shows an expanded representation of the Metadata, Machine Configuration, and Policy Configuration input (layers) boxes of the general Yocto Project Development Environment figure:

In general, all layers have a similar structure. They all contain a licensing file (e.g. COPYING) if the layer is to be distributed, a README file as good practice and especially if the layer is to be distributed, a configuration directory, and recipe directories.

The Yocto Project has many layers that can be used. You can see a web-interface listing of them on the Source Repositories page. The layers are shown at the bottom categorized under "Yocto Metadata Layers." These layers are fundamentally a subset of the OpenEmbedded Metadata Index, which lists all layers provided by the OpenEmbedded community.

Note

Layers exist in the Yocto Project Source Repositories that cannot be found in the OpenEmbedded Metadata Index. These layers are either deprecated or experimental in nature.

BitBake uses the conf/bblayers.conf file, which is part of the user configuration, to find what layers it should be using as part of the build.

For more information on layers, see the "Understanding and Creating Layers" section in the Yocto Project Development Manual.

3.2.1. Distro Layer

The distribution layer provides policy configurations for your distribution. Best practices dictate that you isolate these types of configurations into their own layer. Settings you provide in conf/distro/distro.conf override similar settings that BitBake finds in your conf/local.conf file in the Build Directory.

The following list provides some explanation and references for what you typically find in the distribution layer:

  • classes: Class files (.bbclass) hold common functionality that can be shared among recipes in the distribution. When your recipes inherit a class, they take on the settings and functions for that class. You can read more about class files in the "Classes" section.

  • conf: This area holds configuration files for the layer (conf/layer.conf), the distribution (conf/distro/distro.conf), and any distribution-wide include files.

  • recipes-*: Recipes and append files that affect common functionality across the distribution. This area could include recipes and append files to add distribution-specific configuration, initialization scripts, custom image recipes, and so forth.

3.2.2. BSP Layer

The BSP Layer provides machine configurations. Everything in this layer is specific to the machine for which you are building the image or the SDK. A common structure or form is defined for BSP layers. You can learn more about this structure in the Yocto Project Board Support Package (BSP) Developer's Guide.

Note

In order for a BSP layer to be considered compliant with the Yocto Project, it must meet some structural requirements.

The BSP Layer's configuration directory contains configuration files for the machine (conf/machine/machine.conf) and, of course, the layer (conf/layer.conf).

The remainder of the layer is dedicated to specific recipes by function: recipes-bsp, recipes-core, recipes-graphics, and recipes-kernel. Metadata can exist for multiple formfactors, graphics support systems, and so forth.

Note

While the figure shows several recipes-* directories, not all these directories appear in all BSP layers.

3.2.3. Software Layer

The software layer provides the Metadata for additional software packages used during the build. This layer does not include Metadata that is specific to the distribution or the machine, which are found in their respective layers.

This layer contains any new recipes that your project needs in the form of recipe files.

3.3. Sources

In order for the OpenEmbedded build system to create an image or any target, it must be able to access source files. The general Yocto Project Development Environment figure represents source files using the "Upstream Project Releases", "Local Projects", and "SCMs (optional)" boxes. The figure represents mirrors, which also play a role in locating source files, with the "Source Mirror(s)" box.

The method by which source files are ultimately organized is a function of the project. For example, for released software, projects tend to use tarballs or other archived files that can capture the state of a release guaranteeing that it is statically represented. On the other hand, for a project that is more dynamic or experimental in nature, a project might keep source files in a repository controlled by a Source Control Manager (SCM) such as Git. Pulling source from a repository allows you to control the point in the repository (the revision) from which you want to build software. Finally, a combination of the two might exist, which would give the consumer a choice when deciding where to get source files.

BitBake uses the SRC_URI variable to point to source files regardless of their location. Each recipe must have a SRC_URI variable that points to the source.

Another area that plays a significant role in where source files come from is pointed to by the DL_DIR variable. This area is a cache that can hold previously downloaded source. You can also instruct the OpenEmbedded build system to create tarballs from Git repositories, which is not the default behavior, and store them in the DL_DIR by using the BB_GENERATE_MIRROR_TARBALLS variable.

Judicious use of a DL_DIR directory can save the build system a trip across the Internet when looking for files. A good method for using a download directory is to have DL_DIR point to an area outside of your Build Directory. Doing so allows you to safely delete the Build Directory if needed without fear of removing any downloaded source file.

The remainder of this section provides a deeper look into the source files and the mirrors. Here is a more detailed look at the source file area of the base figure:

3.3.1. Upstream Project Releases

Upstream project releases exist anywhere in the form of an archived file (e.g. tarball or zip file). These files correspond to individual recipes. For example, the figure uses specific releases each for BusyBox, Qt, and Dbus. An archive file can be for any released product that can be built using a recipe.

3.3.2. Local Projects

Local projects are custom bits of software the user provides. These bits reside somewhere local to a project - perhaps a directory into which the user checks in items (e.g. a local directory containing a development source tree used by the group).

The canonical method through which to include a local project is to use the externalsrc class to include that local project. You use either the local.conf or a recipe's append file to override or set the recipe to point to the local directory on your disk to pull in the whole source tree.

For information on how to use the externalsrc class, see the "externalsrc.bbclass" section.

3.3.3. Source Control Managers (Optional)

Another place the build system can get source files from is through an SCM such as Git or Subversion. In this case, a repository is cloned or checked out. The do_fetch task inside BitBake uses the SRC_URI variable and the argument's prefix to determine the correct fetcher module.

Note

For information on how to have the OpenEmbedded build system generate tarballs for Git repositories and place them in the DL_DIR directory, see the BB_GENERATE_MIRROR_TARBALLS variable.

When fetching a repository, BitBake uses the SRCREV variable to determine the specific revision from which to build.

3.3.4. Source Mirror(s)

Two kinds of mirrors exist: pre-mirrors and regular mirrors. The PREMIRRORS and MIRRORS variables point to these, respectively. BitBake checks pre-mirrors before looking upstream for any source files. Pre-mirrors are appropriate when you have a shared directory that is not a directory defined by the DL_DIR variable. A Pre-mirror typically points to a shared directory that is local to your organization.

Regular mirrors can be any site across the Internet that is used as an alternative location for source code should the primary site not be functioning for some reason or another.

3.4. Package Feeds

When the OpenEmbedded build system generates an image or an SDK, it gets the packages from a package feed area located in the Build Directory. The general Yocto Project Development Environment figure shows this package feeds area in the upper-right corner.

This section looks a little closer into the package feeds area used by the build system. Here is a more detailed look at the area:

Package feeds are an intermediary step in the build process. The OpenEmbedded build system provides classes to generate different package types, and you specify which classes to enable through the PACKAGE_CLASSES variable. Before placing the packages into package feeds, the build process validates them with generated output quality assurance checks through the insane class.

The package feed area resides in the Build Directory. The directory the build system uses to temporarily store packages is determined by a combination of variables and the particular package manager in use. See the "Package Feeds" box in the illustration and note the information to the right of that area. In particular, the following defines where package files are kept:

  • DEPLOY_DIR: Defined as tmp/deploy in the Build Directory.

  • DEPLOY_DIR_*: Depending on the package manager used, the package type sub-folder. Given RPM, IPK, or DEB packaging and tarball creation, the DEPLOY_DIR_RPM, DEPLOY_DIR_IPK, DEPLOY_DIR_DEB, or DEPLOY_DIR_TAR, variables are used, respectively.

  • PACKAGE_ARCH: Defines architecture-specific sub-folders. For example, packages could exist for the i586 or qemux86 architectures.

BitBake uses the do_package_write_* tasks to generate packages and place them into the package holding area (e.g. do_package_write_ipk for IPK packages). See the "do_package_write_deb", "do_package_write_ipk", "do_package_write_rpm", and "do_package_write_tar" sections for additional information. As an example, consider a scenario where an IPK packaging manager is being used and package architecture support for both i586 and qemux86 exist. Packages for the i586 architecture are placed in build/tmp/deploy/ipk/i586, while packages for the qemux86 architecture are placed in build/tmp/deploy/ipk/qemux86.

3.5. BitBake

The OpenEmbedded build system uses BitBake to produce images. You can see from the general Yocto Project Development Environment figure, the BitBake area consists of several functional areas. This section takes a closer look at each of those areas.

Separate documentation exists for the BitBake tool. See the BitBake User Manual for reference material on BitBake.

3.5.1. Source Fetching

The first stages of building a recipe are to fetch and unpack the source code:

The do_fetch and do_unpack tasks fetch the source files and unpack them into the work directory.

Note

For every local file (e.g. file://) that is part of a recipe's SRC_URI statement, the OpenEmbedded build system takes a checksum of the file for the recipe and inserts the checksum into the signature for the do_fetch. If any local file has been modified, the do_fetch task and all tasks that depend on it are re-executed.

By default, everything is accomplished in the Build Directory, which has a defined structure. For additional general information on the Build Directory, see the "build/" section.

Unpacked source files are pointed to by the S variable. Each recipe has an area in the Build Directory where the unpacked source code resides. The name of that directory for any given recipe is defined from several different variables. You can see the variables that define these directories by looking at the figure:

  • TMPDIR - The base directory where the OpenEmbedded build system performs all its work during the build.

  • PACKAGE_ARCH - The architecture of the built package or packages.

  • TARGET_OS - The operating system of the target device.

  • PN - The name of the built package.

  • PV - The version of the recipe used to build the package.

  • PR - The revision of the recipe used to build the package.

  • WORKDIR - The location within TMPDIR where a specific package is built.

  • S - Contains the unpacked source files for a given recipe.

3.5.2. Patching

Once source code is fetched and unpacked, BitBake locates patch files and applies them to the source files:

The do_patch task processes recipes by using the SRC_URI variable to locate applicable patch files, which by default are *.patch or *.diff files, or any file if "apply=yes" is specified for the file in SRC_URI.

BitBake finds and applies multiple patches for a single recipe in the order in which it finds the patches. Patches are applied to the recipe's source files located in the S directory.

For more information on how the source directories are created, see the "Source Fetching" section.

3.5.3. Configuration and Compilation

After source code is patched, BitBake executes tasks that configure and compile the source code:

This step in the build process consists of three tasks:

  • do_configure: This task configures the source by enabling and disabling any build-time and configuration options for the software being built. Configurations can come from the recipe itself as well as from an inherited class. Additionally, the software itself might configure itself depending on the target for which it is being built.

    The configurations handled by the do_configure task are specific to source code configuration for the source code being built by the recipe.

    If you are using the autotools class, you can add additional configuration options by using the EXTRA_OECONF or PACKAGECONFIG_CONFARGS variables. For information on how this variable works within that class, see the meta/classes/autotools.bbclass file.

  • do_compile: Once a configuration task has been satisfied, BitBake compiles the source using the do_compile task. Compilation occurs in the directory pointed to by the B variable. Realize that the B directory is, by default, the same as the S directory.

  • do_install: Once compilation is done, BitBake executes the do_install task. This task copies files from the B directory and places them in a holding area pointed to by the D variable.

3.5.4. Package Splitting

After source code is configured and compiled, the OpenEmbedded build system analyzes the results and splits the output into packages:

The do_package and do_packagedata tasks combine to analyze the files found in the D directory and split them into subsets based on available packages and files. The analyzing process involves the following as well as other items: splitting out debugging symbols, looking at shared library dependencies between packages, and looking at package relationships. The do_packagedata task creates package metadata based on the analysis such that the OpenEmbedded build system can generate the final packages. Working, staged, and intermediate results of the analysis and package splitting process use these areas:

  • PKGD - The destination directory for packages before they are split.

  • PKGDATA_DIR - A shared, global-state directory that holds data generated during the packaging process.

  • PKGDESTWORK - A temporary work area used by the do_package task.

  • PKGDEST - The parent directory for packages after they have been split.

The FILES variable defines the files that go into each package in PACKAGES. If you want details on how this is accomplished, you can look at the package class.

Depending on the type of packages being created (RPM, DEB, or IPK), the do_package_write_* task creates the actual packages and places them in the Package Feed area, which is ${TMPDIR}/deploy. You can see the "Package Feeds" section for more detail on that part of the build process.

Note

Support for creating feeds directly from the deploy/* directories does not exist. Creating such feeds usually requires some kind of feed maintenance mechanism that would upload the new packages into an official package feed (e.g. the Ångström distribution). This functionality is highly distribution-specific and thus is not provided out of the box.

3.5.5. Image Generation

Once packages are split and stored in the Package Feeds area, the OpenEmbedded build system uses BitBake to generate the root filesystem image:

The image generation process consists of several stages and depends on several tasks and variables. The do_rootfs task creates the root filesystem (file and directory structure) for an image. This task uses several key variables to help create the list of packages to actually install:

  • IMAGE_INSTALL: Lists out the base set of packages to install from the Package Feeds area.

  • PACKAGE_EXCLUDE: Specifies packages that should not be installed.

  • IMAGE_FEATURES: Specifies features to include in the image. Most of these features map to additional packages for installation.

  • PACKAGE_CLASSES: Specifies the package backend to use and consequently helps determine where to locate packages within the Package Feeds area.

  • IMAGE_LINGUAS: Determines the language(s) for which additional language support packages are installed.

  • PACKAGE_INSTALL: The final list of packages passed to the package manager for installation into the image.

With IMAGE_ROOTFS pointing to the location of the filesystem under construction and the PACKAGE_INSTALL variable providing the final list of packages to install, the root file system is created.

Package installation is under control of the package manager (e.g. smart/rpm, opkg, or apt/dpkg) regardless of whether or not package management is enabled for the target. At the end of the process, if package management is not enabled for the target, the package manager's data files are deleted from the root filesystem. As part of the final stage of package installation, postinstall scripts that are part of the packages are run. Any scripts that fail to run on the build host are run on the target when the target system is first booted. If you are using a read-only root filesystem, all the post installation scripts must succeed during the package installation phase since the root filesystem is read-only.

The final stages of the do_rootfs task handle post processing. Post processing includes creation of a manifest file and optimizations.

The manifest file (.manifest) resides in the same directory as the root filesystem image. This file lists out, line-by-line, the installed packages. The manifest file is useful for the testimage class, for example, to determine whether or not to run specific tests. See the IMAGE_MANIFEST variable for additional information.

Optimizing processes run across the image include mklibs, prelink, and any other post-processing commands as defined by the ROOTFS_POSTPROCESS_COMMAND variable. The mklibs process optimizes the size of the libraries, while the prelink process optimizes the dynamic linking of shared libraries to reduce start up time of executables.

After the root filesystem is built, processing begins on the image through the do_image task. The build system runs any pre-processing commands as defined by the IMAGE_PREPROCESS_COMMAND variable. This variable specifies a list of functions to call before the OpenEmbedded build system creates the final image output files.

The do_image task dynamically creates other do_image_* tasks as needed, which include compressing the root filesystem image to reduce the overall size of the image. The process turns everything into an image file or a set of image files. The formats used for the root filesystem depend on the IMAGE_FSTYPES variable.

The final task involved in image creation is the do_image_complete task. This task completes the image by applying any image post processing as defined through the IMAGE_POSTPROCESS_COMMAND variable. The variable specifies a list of functions to call once the OpenEmbedded build system has created the final image output files.

Note

The entire image generation process is run under Pseudo. Running under Pseudo ensures that the files in the root filesystem have correct ownership.

3.5.6. SDK Generation

The OpenEmbedded build system uses BitBake to generate the Software Development Kit (SDK) installer script for both the standard and extensible SDKs:

Note

For more information on the cross-development toolchain generation, see the "Cross-Development Toolchain Generation" section. For information on advantages gained when building a cross-development toolchain using the do_populate_sdk task, see the "Building an SDK Installer" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

Like image generation, the SDK script process consists of several stages and depends on many variables. The do_populate_sdk and do_populate_sdk_ext tasks use these key variables to help create the list of packages to actually install. For information on the variables listed in the figure, see the "Application Development SDK" section.

The do_populate_sdk task helps create the standard SDK and handles two parts: a target part and a host part. The target part is the part built for the target hardware and includes libraries and headers. The host part is the part of the SDK that runs on the SDKMACHINE.

The do_populate_sdk_ext task helps create the extensible SDK and handles host and target parts differently than its counter part does for the standard SDK. For the extensible SDK, the task encapsulates the build system, which includes everything needed (host and target) for the SDK.

Regardless of the type of SDK being constructed, the tasks perform some cleanup after which a cross-development environment setup script and any needed configuration files are created. The final output is the Cross-development toolchain installation script (.sh file), which includes the environment setup script.

3.5.7. Stamp Files and the Rerunning of Tasks

For each task that completes successfully, BitBake writes a stamp file into the STAMPS_DIR directory. The beginning of the stamp file's filename is determined by the STAMP variable, and the end of the name consists of the task's name and current input checksum.

Note

This naming scheme assumes that BB_SIGNATURE_HANDLER is "OEBasicHash", which is almost always the case in current OpenEmbedded.

To determine if a task needs to be rerun, BitBake checks if a stamp file with a matching input checksum exists for the task. If such a stamp file exists, the task's output is assumed to exist and still be valid. If the file does not exist, the task is rerun.

Note

The stamp mechanism is more general than the shared state (sstate) cache mechanism described in the "Setscene Tasks and Shared State" section. BitBake avoids rerunning any task that has a valid stamp file, not just tasks that can be accelerated through the sstate cache.

However, you should realize that stamp files only serve as a marker that some work has been done and that these files do not record task output. The actual task output would usually be somewhere in TMPDIR (e.g. in some recipe's WORKDIR.) What the sstate cache mechanism adds is a way to cache task output that can then be shared between build machines.

Since STAMPS_DIR is usually a subdirectory of TMPDIR, removing TMPDIR will also remove STAMPS_DIR, which means tasks will properly be rerun to repopulate TMPDIR.

If you want some task to always be considered "out of date", you can mark it with the nostamp varflag. If some other task depends on such a task, then that task will also always be considered out of date, which might not be what you want.

For details on how to view information about a task's signature, see the "Viewing Task Variable Dependencies" section.

3.5.8. Setscene Tasks and Shared State

The description of tasks so far assumes that BitBake needs to build everything and there are no prebuilt objects available. BitBake does support skipping tasks if prebuilt objects are available. These objects are usually made available in the form of a shared state (sstate) cache.

Note

For information on variables affecting sstate, see the SSTATE_DIR and SSTATE_MIRRORS variables.

The idea of a setscene task (i.e do_taskname_setscene) is a version of the task where instead of building something, BitBake can skip to the end result and simply place a set of files into specific locations as needed. In some cases, it makes sense to have a setscene task variant (e.g. generating package files in the do_package_write_* task). In other cases, it does not make sense, (e.g. a do_patch task or do_unpack task) since the work involved would be equal to or greater than the underlying task.

In the OpenEmbedded build system, the common tasks that have setscene variants are do_package, do_package_write_*, do_deploy, do_packagedata, and do_populate_sysroot. Notice that these are most of the tasks whose output is an end result.

The OpenEmbedded build system has knowledge of the relationship between these tasks and other tasks that precede them. For example, if BitBake runs do_populate_sysroot_setscene for something, there is little point in running any of the do_fetch, do_unpack, do_patch, do_configure, do_compile, and do_install tasks. However, if do_package needs to be run, BitBake would need to run those other tasks.

It becomes more complicated if everything can come from an sstate cache because some objects are simply not required at all. For example, you do not need a compiler or native tools, such as quilt, if there is nothing to compile or patch. If the do_package_write_* packages are available from sstate, BitBake does not need the do_package task data.

To handle all these complexities, BitBake runs in two phases. The first is the "setscene" stage. During this stage, BitBake first checks the sstate cache for any targets it is planning to build. BitBake does a fast check to see if the object exists rather than a complete download. If nothing exists, the second phase, which is the setscene stage, completes and the main build proceeds.

If objects are found in the sstate cache, the OpenEmbedded build system works backwards from the end targets specified by the user. For example, if an image is being built, the OpenEmbedded build system first looks for the packages needed for that image and the tools needed to construct an image. If those are available, the compiler is not needed. Thus, the compiler is not even downloaded. If something was found to be unavailable, or the download or setscene task fails, the OpenEmbedded build system then tries to install dependencies, such as the compiler, from the cache.

The availability of objects in the sstate cache is handled by the function specified by the BB_HASHCHECK_FUNCTION variable and returns a list of the objects that are available. The function specified by the BB_SETSCENE_DEPVALID variable is the function that determines whether a given dependency needs to be followed, and whether for any given relationship the function needs to be passed. The function returns a True or False value.

Once the setscene process completes, the OpenEmbedded build system has a list of tasks that it believes it can "accelerate" and therefore does not need to run. There is a final function call to the function specified by the BB_SETSCENE_VERIFY_FUNCTION2 variable that is able to require the tasks to be run that that the OpenEmbedded build system initially was going to skip.

3.6. Images

The images produced by the OpenEmbedded build system are compressed forms of the root filesystem that are ready to boot on a target device. You can see from the general Yocto Project Development Environment figure that BitBake output, in part, consists of images. This section is going to look more closely at this output:

For a list of example images that the Yocto Project provides, see the "Images" chapter.

Images are written out to the Build Directory inside the tmp/deploy/images/machine/ folder as shown in the figure. This folder contains any files expected to be loaded on the target device. The DEPLOY_DIR variable points to the deploy directory, while the DEPLOY_DIR_IMAGE variable points to the appropriate directory containing images for the current configuration.

  • kernel-image: A kernel binary file. The KERNEL_IMAGETYPE variable setting determines the naming scheme for the kernel image file. Depending on that variable, the file could begin with a variety of naming strings. The deploy/images/machine directory can contain multiple image files for the machine.

  • root-filesystem-image: Root filesystems for the target device (e.g. *.ext3 or *.bz2 files). The IMAGE_FSTYPES variable setting determines the root filesystem image type. The deploy/images/machine directory can contain multiple root filesystems for the machine.

  • kernel-modules: Tarballs that contain all the modules built for the kernel. Kernel module tarballs exist for legacy purposes and can be suppressed by setting the MODULE_TARBALL_DEPLOY variable to "0". The deploy/images/machine directory can contain multiple kernel module tarballs for the machine.

  • bootloaders: Bootloaders supporting the image, if applicable to the target machine. The deploy/images/machine directory can contain multiple bootloaders for the machine.

  • symlinks: The deploy/images/machine folder contains a symbolic link that points to the most recently built file for each machine. These links might be useful for external scripts that need to obtain the latest version of each file.

3.7. Application Development SDK

In the general Yocto Project Development Environment figure, the output labeled "Application Development SDK" represents an SDK. The SDK generation process differs depending on whether you build a standard SDK (e.g. bitbake -c populate_sdk imagename) or an extensible SDK (e.g. bitbake -c populate_sdk_ext imagename). This section is going to take a closer look at this output:

The specific form of this output is a self-extracting SDK installer (*.sh) that, when run, installs the SDK, which consists of a cross-development toolchain, a set of libraries and headers, and an SDK environment setup script. Running this installer essentially sets up your cross-development environment. You can think of the cross-toolchain as the "host" part because it runs on the SDK machine. You can think of the libraries and headers as the "target" part because they are built for the target hardware. The environment setup script is added so that you can initialize the environment before using the tools.

Note

The Yocto Project supports several methods by which you can set up this cross-development environment. These methods include downloading pre-built SDK installers or building and installing your own SDK installer.

For background information on cross-development toolchains in the Yocto Project development environment, see the "Cross-Development Toolchain Generation" section. For information on setting up a cross-development environment, see the Yocto Project Software Development Kit (SDK) Developer's Guide.

Once built, the SDK installers are written out to the deploy/sdk folder inside the Build Directory as shown in the figure at the beginning of this section. Depending on the type of SDK, several variables exist that help configure these files. The following list shows the variables associated with a standard SDK:

  • DEPLOY_DIR: Points to the deploy directory.

  • SDKMACHINE: Specifies the architecture of the machine on which the cross-development tools are run to create packages for the target hardware.

  • SDKIMAGE_FEATURES: Lists the features to include in the "target" part of the SDK.

  • TOOLCHAIN_HOST_TASK: Lists packages that make up the host part of the SDK (i.e. the part that runs on the SDKMACHINE). When you use bitbake -c populate_sdk imagename to create the SDK, a set of default packages apply. This variable allows you to add more packages.

  • TOOLCHAIN_TARGET_TASK: Lists packages that make up the target part of the SDK (i.e. the part built for the target hardware).

  • SDKPATH: Defines the default SDK installation path offered by the installation script.

This next list, shows the variables associated with an extensible SDK:

  • DEPLOY_DIR: Points to the deploy directory.

  • SDK_EXT_TYPE: Controls whether or not shared state artifacts are copied into the extensible SDK. By default, all required shared state artifacts are copied into the SDK.

  • SDK_INCLUDE_PKGDATA: Specifies whether or not packagedata will be included in the extensible SDK for all recipes in the "world" target.

  • SDK_INCLUDE_TOOLCHAIN: Specifies whether or not the toolchain will be included when building the extensible SDK.

  • SDK_LOCAL_CONF_WHITELIST: A list of variables allowed through from the build system configuration into the extensible SDK configuration.

  • SDK_LOCAL_CONF_BLACKLIST: A list of variables not allowed through from the build system configuration into the extensible SDK configuration.

  • SDK_INHERIT_BLACKLIST: A list of classes to remove from the INHERIT value globally within the extensible SDK configuration.

Chapter 4. Technical Details

This chapter provides technical details for various parts of the Yocto Project. Currently, topics include Yocto Project components, cross-toolchain generation, shared state (sstate) cache, x32, Wayland support, and Licenses.

4.1. Yocto Project Components

The BitBake task executor together with various types of configuration files form the OpenEmbedded Core. This section overviews these components by describing their use and how they interact.

BitBake handles the parsing and execution of the data files. The data itself is of various types:

  • Recipes: Provides details about particular pieces of software.

  • Class Data: Abstracts common build information (e.g. how to build a Linux kernel).

  • Configuration Data: Defines machine-specific settings, policy decisions, and so forth. Configuration data acts as the glue to bind everything together.

BitBake knows how to combine multiple data sources together and refers to each data source as a layer. For information on layers, see the "Understanding and Creating Layers" section of the Yocto Project Development Manual.

Following are some brief details on these core components. For additional information on how these components interact during a build, see the "A Closer Look at the Yocto Project Development Environment" Chapter.

4.1.1. BitBake

BitBake is the tool at the heart of the OpenEmbedded build system and is responsible for parsing the Metadata, generating a list of tasks from it, and then executing those tasks.

This section briefly introduces BitBake. If you want more information on BitBake, see the BitBake User Manual.

To see a list of the options BitBake supports, use either of the following commands:

     $ bitbake -h
     $ bitbake --help
            

The most common usage for BitBake is bitbake packagename, where packagename is the name of the package you want to build (referred to as the "target" in this manual). The target often equates to the first part of a recipe's filename (e.g. "foo" for a recipe named foo_1.3.0-r0.bb). So, to process the matchbox-desktop_1.2.3.bb recipe file, you might type the following:

     $ bitbake matchbox-desktop
            

Several different versions of matchbox-desktop might exist. BitBake chooses the one selected by the distribution configuration. You can get more details about how BitBake chooses between different target versions and providers in the "Preferences" section of the BitBake User Manual.

BitBake also tries to execute any dependent tasks first. So for example, before building matchbox-desktop, BitBake would build a cross compiler and glibc if they had not already been built.

A useful BitBake option to consider is the -k or --continue option. This option instructs BitBake to try and continue processing the job as long as possible even after encountering an error. When an error occurs, the target that failed and those that depend on it cannot be remade. However, when you use this option other dependencies can still be processed.

4.1.2. Metadata (Recipes)

Files that have the .bb suffix are "recipes" files. In general, a recipe contains information about a single piece of software. This information includes the location from which to download the unaltered source, any source patches to be applied to that source (if needed), which special configuration options to apply, how to compile the source files, and how to package the compiled output.

The term "package" is sometimes used to refer to recipes. However, since the word "package" is used for the packaged output from the OpenEmbedded build system (i.e. .ipk or .deb files), this document avoids using the term "package" when referring to recipes.

4.1.3. Classes

Class files (.bbclass) contain information that is useful to share between Metadata files. An example is the autotools class, which contains common settings for any application that Autotools uses. The "Classes" chapter provides details about classes and how to use them.

4.1.4. Configuration

The configuration files (.conf) define various configuration variables that govern the OpenEmbedded build process. These files fall into several areas that define machine configuration options, distribution configuration options, compiler tuning options, general common configuration options, and user configuration options in local.conf, which is found in the Build Directory.

4.2. Cross-Development Toolchain Generation

The Yocto Project does most of the work for you when it comes to creating cross-development toolchains. This section provides some technical background on how cross-development toolchains are created and used. For more information on toolchains, you can also see the Yocto Project Software Development Kit (SDK) Developer's Guide.

In the Yocto Project development environment, cross-development toolchains are used to build the image and applications that run on the target hardware. With just a few commands, the OpenEmbedded build system creates these necessary toolchains for you.

The following figure shows a high-level build environment regarding toolchain construction and use.

Most of the work occurs on the Build Host. This is the machine used to build images and generally work within the the Yocto Project environment. When you run BitBake to create an image, the OpenEmbedded build system uses the host gcc compiler to bootstrap a cross-compiler named gcc-cross. The gcc-cross compiler is what BitBake uses to compile source files when creating the target image. You can think of gcc-cross simply as an automatically generated cross-compiler that is used internally within BitBake only.

Note

The extensible SDK does not use gcc-cross-canadian since this SDK ships a copy of the OpenEmbedded build system and the sysroot within it contains gcc-cross.

The chain of events that occurs when gcc-cross is bootstrapped is as follows:

     gcc -> binutils-cross -> gcc-cross-initial -> linux-libc-headers -> glibc-initial -> glibc -> gcc-cross -> gcc-runtime
        

  • gcc: The build host's GNU Compiler Collection (GCC).

  • binutils-cross: The bare minimum binary utilities needed in order to run the gcc-cross-initial phase of the bootstrap operation.

  • gcc-cross-initial: An early stage of the bootstrap process for creating the cross-compiler. This stage builds enough of the gcc-cross, the C library, and other pieces needed to finish building the final cross-compiler in later stages. This tool is a "native" package (i.e. it is designed to run on the build host).

  • linux-libc-headers: Headers needed for the cross-compiler.

  • glibc-initial: An initial version of the Embedded GLIBC needed to bootstrap glibc.

  • gcc-cross: The final stage of the bootstrap process for the cross-compiler. This stage results in the actual cross-compiler that BitBake uses when it builds an image for a targeted device.

    Note

    If you are replacing this cross compiler toolchain with a custom version, you must replace gcc-cross.

    This tool is also a "native" package (i.e. it is designed to run on the build host).

  • gcc-runtime: Runtime libraries resulting from the toolchain bootstrapping process. This tool produces a binary that consists of the runtime libraries need for the targeted device.

You can use the OpenEmbedded build system to build an installer for the relocatable SDK used to develop applications. When you run the installer, it installs the toolchain, which contains the development tools (e.g., the gcc-cross-canadian), binutils-cross-canadian, and other nativesdk-* tools, which are tools native to the SDK (i.e. native to SDK_ARCH), you need to cross-compile and test your software. The figure shows the commands you use to easily build out this toolchain. This cross-development toolchain is built to execute on the SDKMACHINE, which might or might not be the same machine as the Build Host.

Note

If your target architecture is supported by the Yocto Project, you can take advantage of pre-built images that ship with the Yocto Project and already contain cross-development toolchain installers.

Here is the bootstrap process for the relocatable toolchain:

     gcc -> binutils-crosssdk -> gcc-crosssdk-initial -> linux-libc-headers ->
        glibc-initial -> nativesdk-glibc -> gcc-crosssdk -> gcc-cross-canadian
        

  • gcc: The build host's GNU Compiler Collection (GCC).

  • binutils-crosssdk: The bare minimum binary utilities needed in order to run the gcc-crosssdk-initial phase of the bootstrap operation.

  • gcc-crosssdk-initial: An early stage of the bootstrap process for creating the cross-compiler. This stage builds enough of the gcc-crosssdk and supporting pieces so that the final stage of the bootstrap process can produce the finished cross-compiler. This tool is a "native" binary that runs on the build host.

  • linux-libc-headers: Headers needed for the cross-compiler.

  • glibc-initial: An initial version of the Embedded GLIBC needed to bootstrap nativesdk-glibc.

  • nativesdk-glibc: The Embedded GLIBC needed to bootstrap the gcc-crosssdk.

  • gcc-crosssdk: The final stage of the bootstrap process for the relocatable cross-compiler. The gcc-crosssdk is a transitory compiler and never leaves the build host. Its purpose is to help in the bootstrap process to create the eventual relocatable gcc-cross-canadian compiler, which is relocatable. This tool is also a "native" package (i.e. it is designed to run on the build host).

  • gcc-cross-canadian: The final relocatable cross-compiler. When run on the SDKMACHINE, this tool produces executable code that runs on the target device. Only one cross-canadian compiler is produced per architecture since they can be targeted at different processor optimizations using configurations passed to the compiler through the compile commands. This circumvents the need for multiple compilers and thus reduces the size of the toolchains.

Note

For information on advantages gained when building a cross-development toolchain installer, see the "Building an SDK Installer" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

4.3. Shared State Cache

By design, the OpenEmbedded build system builds everything from scratch unless BitBake can determine that parts do not need to be rebuilt. Fundamentally, building from scratch is attractive as it means all parts are built fresh and there is no possibility of stale data causing problems. When developers hit problems, they typically default back to building from scratch so they know the state of things from the start.

Building an image from scratch is both an advantage and a disadvantage to the process. As mentioned in the previous paragraph, building from scratch ensures that everything is current and starts from a known state. However, building from scratch also takes much longer as it generally means rebuilding things that do not necessarily need to be rebuilt.

The Yocto Project implements shared state code that supports incremental builds. The implementation of the shared state code answers the following questions that were fundamental roadblocks within the OpenEmbedded incremental build support system:

  • What pieces of the system have changed and what pieces have not changed?

  • How are changed pieces of software removed and replaced?

  • How are pre-built components that do not need to be rebuilt from scratch used when they are available?

For the first question, the build system detects changes in the "inputs" to a given task by creating a checksum (or signature) of the task's inputs. If the checksum changes, the system assumes the inputs have changed and the task needs to be rerun. For the second question, the shared state (sstate) code tracks which tasks add which output to the build process. This means the output from a given task can be removed, upgraded or otherwise manipulated. The third question is partly addressed by the solution for the second question assuming the build system can fetch the sstate objects from remote locations and install them if they are deemed to be valid.

Note

The OpenEmbedded build system does not maintain PR information as part of the shared state packages. Consequently, considerations exist that affect maintaining shared state feeds. For information on how the OpenEmbedded build system works with packages and can track incrementing PR information, see the "Incrementing a Package Revision Number" section.

The rest of this section goes into detail about the overall incremental build architecture, the checksums (signatures), shared state, and some tips and tricks.

4.3.1. Overall Architecture

When determining what parts of the system need to be built, BitBake works on a per-task basis rather than a per-recipe basis. You might wonder why using a per-task basis is preferred over a per-recipe basis. To help explain, consider having the IPK packaging backend enabled and then switching to DEB. In this case, the do_install and do_package task outputs are still valid. However, with a per-recipe approach, the build would not include the .deb files. Consequently, you would have to invalidate the whole build and rerun it. Rerunning everything is not the best solution. Also, in this case, the core must be "taught" much about specific tasks. This methodology does not scale well and does not allow users to easily add new tasks in layers or as external recipes without touching the packaged-staging core.

4.3.2. Checksums (Signatures)

The shared state code uses a checksum, which is a unique signature of a task's inputs, to determine if a task needs to be run again. Because it is a change in a task's inputs that triggers a rerun, the process needs to detect all the inputs to a given task. For shell tasks, this turns out to be fairly easy because the build process generates a "run" shell script for each task and it is possible to create a checksum that gives you a good idea of when the task's data changes.

To complicate the problem, there are things that should not be included in the checksum. First, there is the actual specific build path of a given task - the WORKDIR. It does not matter if the work directory changes because it should not affect the output for target packages. Also, the build process has the objective of making native or cross packages relocatable.

Note

Both native and cross packages run on the build host. However, cross packages generate output for the target architecture.

The checksum therefore needs to exclude WORKDIR. The simplistic approach for excluding the work directory is to set WORKDIR to some fixed value and create the checksum for the "run" script.

Another problem results from the "run" scripts containing functions that might or might not get called. The incremental build solution contains code that figures out dependencies between shell functions. This code is used to prune the "run" scripts down to the minimum set, thereby alleviating this problem and making the "run" scripts much more readable as a bonus.

So far we have solutions for shell scripts. What about Python tasks? The same approach applies even though these tasks are more difficult. The process needs to figure out what variables a Python function accesses and what functions it calls. Again, the incremental build solution contains code that first figures out the variable and function dependencies, and then creates a checksum for the data used as the input to the task.

Like the WORKDIR case, situations exist where dependencies should be ignored. For these cases, you can instruct the build process to ignore a dependency by using a line like the following:

     PACKAGE_ARCHS[vardepsexclude] = "MACHINE"
            

This example ensures that the PACKAGE_ARCHS variable does not depend on the value of MACHINE, even if it does reference it.

Equally, there are cases where we need to add dependencies BitBake is not able to find. You can accomplish this by using a line like the following:

      PACKAGE_ARCHS[vardeps] = "MACHINE"
            

This example explicitly adds the MACHINE variable as a dependency for PACKAGE_ARCHS.

Consider a case with in-line Python, for example, where BitBake is not able to figure out dependencies. When running in debug mode (i.e. using -DDD), BitBake produces output when it discovers something for which it cannot figure out dependencies. The Yocto Project team has currently not managed to cover those dependencies in detail and is aware of the need to fix this situation.

Thus far, this section has limited discussion to the direct inputs into a task. Information based on direct inputs is referred to as the "basehash" in the code. However, there is still the question of a task's indirect inputs - the things that were already built and present in the Build Directory. The checksum (or signature) for a particular task needs to add the hashes of all the tasks on which the particular task depends. Choosing which dependencies to add is a policy decision. However, the effect is to generate a master checksum that combines the basehash and the hashes of the task's dependencies.

At the code level, there are a variety of ways both the basehash and the dependent task hashes can be influenced. Within the BitBake configuration file, we can give BitBake some extra information to help it construct the basehash. The following statement effectively results in a list of global variable dependency excludes - variables never included in any checksum:

     BB_HASHBASE_WHITELIST ?= "TMPDIR FILE PATH PWD BB_TASKHASH BBPATH DL_DIR \
         SSTATE_DIR THISDIR FILESEXTRAPATHS FILE_DIRNAME HOME LOGNAME SHELL TERM \
         USER FILESPATH STAGING_DIR_HOST STAGING_DIR_TARGET COREBASE PRSERV_HOST \
         PRSERV_DUMPDIR PRSERV_DUMPFILE PRSERV_LOCKDOWN PARALLEL_MAKE \
         CCACHE_DIR EXTERNAL_TOOLCHAIN CCACHE CCACHE_DISABLE LICENSE_PATH SDKPKGSUFFIX"
            

The previous example excludes WORKDIR since that variable is actually constructed as a path within TMPDIR, which is on the whitelist.

The rules for deciding which hashes of dependent tasks to include through dependency chains are more complex and are generally accomplished with a Python function. The code in meta/lib/oe/sstatesig.py shows two examples of this and also illustrates how you can insert your own policy into the system if so desired. This file defines the two basic signature generators OE-Core uses: "OEBasic" and "OEBasicHash". By default, there is a dummy "noop" signature handler enabled in BitBake. This means that behavior is unchanged from previous versions. OE-Core uses the "OEBasicHash" signature handler by default through this setting in the bitbake.conf file:

     BB_SIGNATURE_HANDLER ?= "OEBasicHash"
            

The "OEBasicHash" BB_SIGNATURE_HANDLER is the same as the "OEBasic" version but adds the task hash to the stamp files. This results in any Metadata change that changes the task hash, automatically causing the task to be run again. This removes the need to bump PR values, and changes to Metadata automatically ripple across the build.

It is also worth noting that the end result of these signature generators is to make some dependency and hash information available to the build. This information includes:

  • BB_BASEHASH_task-taskname: The base hashes for each task in the recipe.

  • BB_BASEHASH_filename:taskname: The base hashes for each dependent task.

  • BBHASHDEPS_filename:taskname: The task dependencies for each task.

  • BB_TASKHASH: The hash of the currently running task.

4.3.3. Shared State

Checksums and dependencies, as discussed in the previous section, solve half the problem of supporting a shared state. The other part of the problem is being able to use checksum information during the build and being able to reuse or rebuild specific components.

The sstate class is a relatively generic implementation of how to "capture" a snapshot of a given task. The idea is that the build process does not care about the source of a task's output. Output could be freshly built or it could be downloaded and unpacked from somewhere - the build process does not need to worry about its origin.

There are two types of output, one is just about creating a directory in WORKDIR. A good example is the output of either do_install or do_package. The other type of output occurs when a set of data is merged into a shared directory tree such as the sysroot.

The Yocto Project team has tried to keep the details of the implementation hidden in sstate class. From a user's perspective, adding shared state wrapping to a task is as simple as this do_deploy example taken from the deploy class:

     DEPLOYDIR = "${WORKDIR}/deploy-${PN}"
     SSTATETASKS += "do_deploy"
     do_deploy[sstate-inputdirs] = "${DEPLOYDIR}"
     do_deploy[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"

     python do_deploy_setscene () {
         sstate_setscene(d)
     }
     addtask do_deploy_setscene
     do_deploy[dirs] = "${DEPLOYDIR} ${B}"
            

The following list explains the previous example:

  • Adding "do_deploy" to SSTATETASKS adds some required sstate-related processing, which is implemented in the sstate class, to before and after the do_deploy task.

  • The do_deploy[sstate-inputdirs] = "${DEPLOYDIR}" declares that do_deploy places its output in ${DEPLOYDIR} when run normally (i.e. when not using the sstate cache). This output becomes the input to the shared state cache.

  • The do_deploy[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}" line causes the contents of the shared state cache to be copied to ${DEPLOY_DIR_IMAGE}.

    Note

    If do_deploy is not already in the shared state cache or if its input checksum (signature) has changed from when the output was cached, the task will be run to populate the shared state cache, after which the contents of the shared state cache is copied to ${DEPLOY_DIR_IMAGE}. If do_deploy is in the shared state cache and its signature indicates that the cached output is still valid (i.e. if no relevant task inputs have changed), then the contents of the shared state cache will be copied directly to ${DEPLOY_DIR_IMAGE} by the do_deploy_setscene task instead, skipping the do_deploy task.

  • The following task definition is glue logic needed to make the previous settings effective:

         python do_deploy_setscene () {
             sstate_setscene(d)
         }
         addtask do_deploy_setscene
                        

    sstate_setscene() takes the flags above as input and accelerates the do_deploy task through the shared state cache if possible. If the task was accelerated, sstate_setscene() returns True. Otherwise, it returns False, and the normal do_deploy task runs. For more information, see the "setscene" section in the BitBake User Manual.

  • The do_deploy[dirs] = "${DEPLOYDIR} ${B}" line creates ${DEPLOYDIR} and ${B} before the do_deploy task runs, and also sets the current working directory of do_deploy to ${B}. For more information, see the "Variable Flags" section in the BitBake User Manual.

    Note

    In cases where sstate-inputdirs and sstate-outputdirs would be the same, you can use sstate-plaindirs. For example, to preserve the ${PKGD} and ${PKGDEST} output from the do_package task, use the following:
         do_package[sstate-plaindirs] = "${PKGD} ${PKGDEST}"
                            

  • sstate-inputdirs and sstate-outputdirs can also be used with multiple directories. For example, the following declares PKGDESTWORK and SHLIBWORK as shared state input directories, which populates the shared state cache, and PKGDATA_DIR and SHLIBSDIR as the corresponding shared state output directories:

         do_package[sstate-inputdirs] = "${PKGDESTWORK} ${SHLIBSWORKDIR}"
         do_package[sstate-outputdirs] = "${PKGDATA_DIR} ${SHLIBSDIR}"
                         

  • These methods also include the ability to take a lockfile when manipulating shared state directory structures, for cases where file additions or removals are sensitive:

         do_package[sstate-lockfile] = "${PACKAGELOCK}"
                         

Behind the scenes, the shared state code works by looking in SSTATE_DIR and SSTATE_MIRRORS for shared state files. Here is an example:

     SSTATE_MIRRORS ?= "\
     file://.* http://someserver.tld/share/sstate/PATH;downloadfilename=PATH \n \
     file://.* file:///some/local/dir/sstate/PATH"
            

Note

The shared state directory (SSTATE_DIR) is organized into two-character subdirectories, where the subdirectory names are based on the first two characters of the hash. If the shared state directory structure for a mirror has the same structure as SSTATE_DIR, you must specify "PATH" as part of the URI to enable the build system to map to the appropriate subdirectory.

The shared state package validity can be detected just by looking at the filename since the filename contains the task checksum (or signature) as described earlier in this section. If a valid shared state package is found, the build process downloads it and uses it to accelerate the task.

The build processes use the *_setscene tasks for the task acceleration phase. BitBake goes through this phase before the main execution code and tries to accelerate any tasks for which it can find shared state packages. If a shared state package for a task is available, the shared state package is used. This means the task and any tasks on which it is dependent are not executed.

As a real world example, the aim is when building an IPK-based image, only the do_package_write_ipk tasks would have their shared state packages fetched and extracted. Since the sysroot is not used, it would never get extracted. This is another reason why a task-based approach is preferred over a recipe-based approach, which would have to install the output from every task.

4.3.4. Tips and Tricks

The code in the build system that supports incremental builds is not simple code. This section presents some tips and tricks that help you work around issues related to shared state code.

4.3.4.1. Debugging

Seeing what metadata went into creating the input signature of a shared state (sstate) task can be a useful debugging aid. This information is available in signature information (siginfo) files in SSTATE_DIR. For information on how to view and interpret information in siginfo files, see the "Viewing Task Variable Dependencies" section.

4.3.4.2. Invalidating Shared State

The OpenEmbedded build system uses checksums and shared state cache to avoid unnecessarily rebuilding tasks. Collectively, this scheme is known as "shared state code."

As with all schemes, this one has some drawbacks. It is possible that you could make implicit changes to your code that the checksum calculations do not take into account. These implicit changes affect a task's output but do not trigger the shared state code into rebuilding a recipe. Consider an example during which a tool changes its output. Assume that the output of rpmdeps changes. The result of the change should be that all the package and package_write_rpm shared state cache items become invalid. However, because the change to the output is external to the code and therefore implicit, the associated shared state cache items do not become invalidated. In this case, the build process uses the cached items rather than running the task again. Obviously, these types of implicit changes can cause problems.

To avoid these problems during the build, you need to understand the effects of any changes you make. Realize that changes you make directly to a function are automatically factored into the checksum calculation. Thus, these explicit changes invalidate the associated area of shared state cache. However, you need to be aware of any implicit changes that are not obvious changes to the code and could affect the output of a given task.

When you identify an implicit change, you can easily take steps to invalidate the cache and force the tasks to run. The steps you can take are as simple as changing a function's comments in the source code. For example, to invalidate package shared state files, change the comment statements of do_package or the comments of one of the functions it calls. Even though the change is purely cosmetic, it causes the checksum to be recalculated and forces the OpenEmbedded build system to run the task again.

Note

For an example of a commit that makes a cosmetic change to invalidate shared state, see this commit.

4.4. Automatically Added Runtime Dependencies

The OpenEmbedded build system automatically adds common types of runtime dependencies between packages, which means that you do not need to explicitly declare the packages using RDEPENDS. Three automatic mechanisms exist (shlibdeps, pcdeps, and depchains) that handle shared libraries, package configuration (pkg-config) modules, and -dev and -dbg packages, respectively. For other types of runtime dependencies, you must manually declare the dependencies.

  • shlibdeps: During the do_package task of each recipe, all shared libraries installed by the recipe are located. For each shared library, the package that contains the shared library is registered as providing the shared library. More specifically, the package is registered as providing the soname of the library. The resulting shared-library-to-package mapping is saved globally in PKGDATA_DIR by the do_packagedata task.

    Simultaneously, all executables and shared libraries installed by the recipe are inspected to see what shared libraries they link against. For each shared library dependency that is found, PKGDATA_DIR is queried to see if some package (likely from a different recipe) contains the shared library. If such a package is found, a runtime dependency is added from the package that depends on the shared library to the package that contains the library.

    The automatically added runtime dependency also includes a version restriction. This version restriction specifies that at least the current version of the package that provides the shared library must be used, as if "package (>= version)" had been added to RDEPENDS. This forces an upgrade of the package containing the shared library when installing the package that depends on the library, if needed.

    If you want to avoid a package being registered as providing a particular shared library (e.g. because the library is for internal use only), then add the library to PRIVATE_LIBS inside the package's recipe.

  • pcdeps: During the do_package task of each recipe, all pkg-config modules (*.pc files) installed by the recipe are located. For each module, the package that contains the module is registered as providing the module. The resulting module-to-package mapping is saved globally in PKGDATA_DIR by the do_packagedata task.

    Simultaneously, all pkg-config modules installed by the recipe are inspected to see what other pkg-config modules they depend on. A module is seen as depending on another module if it contains a "Requires:" line that specifies the other module. For each module dependency, PKGDATA_DIR is queried to see if some package contains the module. If such a package is found, a runtime dependency is added from the package that depends on the module to the package that contains the module.

    Note

    The pcdeps mechanism most often infers dependencies between -dev packages.

  • depchains: If a package foo depends on a package bar, then foo-dev and foo-dbg are also made to depend on bar-dev and bar-dbg, respectively. Taking the -dev packages as an example, the bar-dev package might provide headers and shared library symlinks needed by foo-dev, which shows the need for a dependency between the packages.

    The dependencies added by depchains are in the form of RRECOMMENDS.

    Note

    By default, foo-dev also has an RDEPENDS-style dependency on foo, because the default value of RDEPENDS_${PN}-dev (set in bitbake.conf) includes "${PN}".

    To ensure that the dependency chain is never broken, -dev and -dbg packages are always generated by default, even if the packages turn out to be empty. See the ALLOW_EMPTY variable for more information.

The do_package task depends on the do_packagedata task of each recipe in DEPENDS through use of a [deptask] declaration, which guarantees that the required shared-library/module-to-package mapping information will be available when needed as long as DEPENDS has been correctly set.

4.5. Fakeroot and Pseudo

Some tasks are easier to implement when allowed to perform certain operations that are normally reserved for the root user. For example, the do_install task benefits from being able to set the UID and GID of installed files to arbitrary values.

One approach to allowing tasks to perform root-only operations would be to require BitBake to run as root. However, this method is cumbersome and has security issues. The approach that is actually used is to run tasks that benefit from root privileges in a "fake" root environment. Within this environment, the task and its child processes believe that they are running as the root user, and see an internally consistent view of the filesystem. As long as generating the final output (e.g. a package or an image) does not require root privileges, the fact that some earlier steps ran in a fake root environment does not cause problems.

The capability to run tasks in a fake root environment is known as "fakeroot", which is derived from the BitBake keyword/variable flag that requests a fake root environment for a task. In current versions of the OpenEmbedded build system, the program that implements fakeroot is known as Pseudo.

Pseudo overrides system calls through the LD_PRELOAD mechanism to give the illusion of running as root. To keep track of "fake" file ownership and permissions resulting from operations that require root permissions, an sqlite3 database is used. This database is stored in ${WORKDIR}/pseudo/files.db for individual recipes. Storing the database in a file as opposed to in memory gives persistence between tasks, and even between builds.

Caution

If you add your own task that manipulates the same files or directories as a fakeroot task, then that task should also run under fakeroot. Otherwise, the task will not be able to run root-only operations, and will not see the fake file ownership and permissions set by the other task. You should also add a dependency on virtual/fakeroot-native:do_populate_sysroot, giving the following:
       fakeroot do_mytask () {
           ...
       }
       do_mytask[depends] += "virtual/fakeroot-native:do_populate_sysroot"
            

For more information, see the FAKEROOT* variables in the BitBake User Manual. You can also reference this Pseudo article.

4.6. x32

x32 is a processor-specific Application Binary Interface (psABI) for x86_64. An ABI defines the calling conventions between functions in a processing environment. The interface determines what registers are used and what the sizes are for various C data types.

Some processing environments prefer using 32-bit applications even when running on Intel 64-bit platforms. Consider the i386 psABI, which is a very old 32-bit ABI for Intel 64-bit platforms. The i386 psABI does not provide efficient use and access of the Intel 64-bit processor resources, leaving the system underutilized. Now consider the x86_64 psABI. This ABI is newer and uses 64-bits for data sizes and program pointers. The extra bits increase the footprint size of the programs, libraries, and also increases the memory and file system size requirements. Executing under the x32 psABI enables user programs to utilize CPU and system resources more efficiently while keeping the memory footprint of the applications low. Extra bits are used for registers but not for addressing mechanisms.

4.6.1. Support

This Yocto Project release supports the final specifications of x32 psABI. Support for x32 psABI exists as follows:

  • You can create packages and images in x32 psABI format on x86_64 architecture targets.

  • You can successfully build many recipes with the x32 toolchain.

  • You can create and boot core-image-minimal and core-image-sato images.

4.6.2. Completing x32

Future Plans for the x32 psABI in the Yocto Project include the following:

  • Enhance and fix the few remaining recipes so they work with and support x32 toolchains.

  • Enhance RPM Package Manager (RPM) support for x32 binaries.

  • Support larger images.

4.6.3. Using x32 Right Now

Follow these steps to use the x32 spABI:

  • Enable the x32 psABI tuning file for x86_64 machines by editing the conf/local.conf like this:

          MACHINE = "qemux86-64"
          DEFAULTTUNE = "x86-64-x32"
          baselib = "${@d.getVar('BASE_LIB_tune-' + (d.getVar('DEFAULTTUNE', True) \
             or 'INVALID'), True) or 'lib'}"
          #MACHINE = "genericx86"
          #DEFAULTTUNE = "core2-64-x32"
                        
  • As usual, use BitBake to build an image that supports the x32 psABI. Here is an example:

         $ bitbake core-image-sato
                        
  • As usual, run your image using QEMU:

         $ runqemu qemux86-64 core-image-sato
                        

4.7. Wayland

Wayland is a computer display server protocol that provides a method for compositing window managers to communicate directly with applications and video hardware and expects them to communicate with input hardware using other libraries. Using Wayland with supporting targets can result in better control over graphics frame rendering than an application might otherwise achieve.

The Yocto Project provides the Wayland protocol libraries and the reference Weston compositor as part of its release. This section describes what you need to do to implement Wayland and use the compositor when building an image for a supporting target.

4.7.1. Support

The Wayland protocol libraries and the reference Weston compositor ship as integrated packages in the meta layer of the Source Directory. Specifically, you can find the recipes that build both Wayland and Weston at meta/recipes-graphics/wayland.

You can build both the Wayland and Weston packages for use only with targets that accept the Mesa 3D and Direct Rendering Infrastructure, which is also known as Mesa DRI. This implies that you cannot build and use the packages if your target uses, for example, the Intel® Embedded Media and Graphics Driver (Intel® EMGD) that overrides Mesa DRI.

Note

Due to lack of EGL support, Weston 1.0.3 will not run directly on the emulated QEMU hardware. However, this version of Weston will run under X emulation without issues.

4.7.2. Enabling Wayland in an Image

To enable Wayland, you need to enable it to be built and enable it to be included in the image.

4.7.2.1. Building

To cause Mesa to build the wayland-egl platform and Weston to build Wayland with Kernel Mode Setting (KMS) support, include the "wayland" flag in the DISTRO_FEATURES statement in your local.conf file:

     DISTRO_FEATURES_append = " wayland"
                

Note

If X11 has been enabled elsewhere, Weston will build Wayland with X11 support

4.7.2.2. Installing

To install the Wayland feature into an image, you must include the following CORE_IMAGE_EXTRA_INSTALL statement in your local.conf file:

     CORE_IMAGE_EXTRA_INSTALL += "wayland weston"
                

4.7.3. Running Weston

To run Weston inside X11, enabling it as described earlier and building a Sato image is sufficient. If you are running your image under Sato, a Weston Launcher appears in the "Utility" category.

Alternatively, you can run Weston through the command-line interpretor (CLI), which is better suited for development work. To run Weston under the CLI, you need to do the following after your image is built:

  1. Run these commands to export XDG_RUNTIME_DIR:

         mkdir -p /tmp/$USER-weston
         chmod 0700 /tmp/$USER-weston
         export XDG_RUNTIME_DIR=/tmp/$USER-weston
                        
  2. Launch Weston in the shell:

         weston
                        

4.8. Licenses

This section describes the mechanism by which the OpenEmbedded build system tracks changes to licensing text. The section also describes how to enable commercially licensed recipes, which by default are disabled.

For information that can help you maintain compliance with various open source licensing during the lifecycle of the product, see the "Maintaining Open Source License Compliance During Your Project's Lifecycle" section in the Yocto Project Development Manual.

4.8.1. Tracking License Changes

The license of an upstream project might change in the future. In order to prevent these changes going unnoticed, the LIC_FILES_CHKSUM variable tracks changes to the license text. The checksums are validated at the end of the configure step, and if the checksums do not match, the build will fail.

4.8.1.1. Specifying the LIC_FILES_CHKSUM Variable

The LIC_FILES_CHKSUM variable contains checksums of the license text in the source code for the recipe. Following is an example of how to specify LIC_FILES_CHKSUM:

     LIC_FILES_CHKSUM = "file://COPYING;md5=xxxx \
                         file://licfile1.txt;beginline=5;endline=29;md5=yyyy \
                         file://licfile2.txt;endline=50;md5=zzzz \
                         ..."
                

The build system uses the S variable as the default directory when searching files listed in LIC_FILES_CHKSUM. The previous example employs the default directory.

Consider this next example:

     LIC_FILES_CHKSUM = "file://src/ls.c;beginline=5;endline=16;\
                                         md5=bb14ed3c4cda583abc85401304b5cd4e"
     LIC_FILES_CHKSUM = "file://${WORKDIR}/license.html;md5=5c94767cedb5d6987c902ac850ded2c6"
                

The first line locates a file in ${S}/src/ls.c. The second line refers to a file in WORKDIR.

Note that LIC_FILES_CHKSUM variable is mandatory for all recipes, unless the LICENSE variable is set to "CLOSED".

4.8.1.2. Explanation of Syntax

As mentioned in the previous section, the LIC_FILES_CHKSUM variable lists all the important files that contain the license text for the source code. It is possible to specify a checksum for an entire file, or a specific section of a file (specified by beginning and ending line numbers with the "beginline" and "endline" parameters, respectively). The latter is useful for source files with a license notice header, README documents, and so forth. If you do not use the "beginline" parameter, then it is assumed that the text begins on the first line of the file. Similarly, if you do not use the "endline" parameter, it is assumed that the license text ends with the last line of the file.

The "md5" parameter stores the md5 checksum of the license text. If the license text changes in any way as compared to this parameter then a mismatch occurs. This mismatch triggers a build failure and notifies the developer. Notification allows the developer to review and address the license text changes. Also note that if a mismatch occurs during the build, the correct md5 checksum is placed in the build log and can be easily copied to the recipe.

There is no limit to how many files you can specify using the LIC_FILES_CHKSUM variable. Generally, however, every project requires a few specifications for license tracking. Many projects have a "COPYING" file that stores the license information for all the source code files. This practice allows you to just track the "COPYING" file as long as it is kept up to date.

Tip

If you specify an empty or invalid "md5" parameter, BitBake returns an md5 mis-match error and displays the correct "md5" parameter value during the build. The correct parameter is also captured in the build log.

Tip

If the whole file contains only license text, you do not need to use the "beginline" and "endline" parameters.

4.8.2. Enabling Commercially Licensed Recipes

By default, the OpenEmbedded build system disables components that have commercial or other special licensing requirements. Such requirements are defined on a recipe-by-recipe basis through the LICENSE_FLAGS variable definition in the affected recipe. For instance, the poky/meta/recipes-multimedia/gstreamer/gst-plugins-ugly recipe contains the following statement:

     LICENSE_FLAGS = "commercial"
            

Here is a slightly more complicated example that contains both an explicit recipe name and version (after variable expansion):

     LICENSE_FLAGS = "license_${PN}_${PV}"
            

In order for a component restricted by a LICENSE_FLAGS definition to be enabled and included in an image, it needs to have a matching entry in the global LICENSE_FLAGS_WHITELIST variable, which is a variable typically defined in your local.conf file. For example, to enable the poky/meta/recipes-multimedia/gstreamer/gst-plugins-ugly package, you could add either the string "commercial_gst-plugins-ugly" or the more general string "commercial" to LICENSE_FLAGS_WHITELIST. See the "License Flag Matching" section for a full explanation of how LICENSE_FLAGS matching works. Here is the example:

     LICENSE_FLAGS_WHITELIST = "commercial_gst-plugins-ugly"
            

Likewise, to additionally enable the package built from the recipe containing LICENSE_FLAGS = "license_${PN}_${PV}", and assuming that the actual recipe name was emgd_1.10.bb, the following string would enable that package as well as the original gst-plugins-ugly package:

     LICENSE_FLAGS_WHITELIST = "commercial_gst-plugins-ugly license_emgd_1.10"
            

As a convenience, you do not need to specify the complete license string in the whitelist for every package. You can use an abbreviated form, which consists of just the first portion or portions of the license string before the initial underscore character or characters. A partial string will match any license that contains the given string as the first portion of its license. For example, the following whitelist string will also match both of the packages previously mentioned as well as any other packages that have licenses starting with "commercial" or "license".

     LICENSE_FLAGS_WHITELIST = "commercial license"
            

4.8.2.1. License Flag Matching

License flag matching allows you to control what recipes the OpenEmbedded build system includes in the build. Fundamentally, the build system attempts to match LICENSE_FLAGS strings found in recipes against LICENSE_FLAGS_WHITELIST strings found in the whitelist. A match causes the build system to include a recipe in the build, while failure to find a match causes the build system to exclude a recipe.

In general, license flag matching is simple. However, understanding some concepts will help you correctly and effectively use matching.

Before a flag defined by a particular recipe is tested against the contents of the whitelist, the expanded string _${PN} is appended to the flag. This expansion makes each LICENSE_FLAGS value recipe-specific. After expansion, the string is then matched against the whitelist. Thus, specifying LICENSE_FLAGS = "commercial" in recipe "foo", for example, results in the string "commercial_foo". And, to create a match, that string must appear in the whitelist.

Judicious use of the LICENSE_FLAGS strings and the contents of the LICENSE_FLAGS_WHITELIST variable allows you a lot of flexibility for including or excluding recipes based on licensing. For example, you can broaden the matching capabilities by using license flags string subsets in the whitelist.

Note

When using a string subset, be sure to use the part of the expanded string that precedes the appended underscore character (e.g. usethispart_1.3, usethispart_1.4, and so forth).

For example, simply specifying the string "commercial" in the whitelist matches any expanded LICENSE_FLAGS definition that starts with the string "commercial" such as "commercial_foo" and "commercial_bar", which are the strings the build system automatically generates for hypothetical recipes named "foo" and "bar" assuming those recipes simply specify the following:

     LICENSE_FLAGS = "commercial"
                

Thus, you can choose to exhaustively enumerate each license flag in the whitelist and allow only specific recipes into the image, or you can use a string subset that causes a broader range of matches to allow a range of recipes into the image.

This scheme works even if the LICENSE_FLAGS string already has _${PN} appended. For example, the build system turns the license flag "commercial_1.2_foo" into "commercial_1.2_foo_foo" and would match both the general "commercial" and the specific "commercial_1.2_foo" strings found in the whitelist, as expected.

Here are some other scenarios:

  • You can specify a versioned string in the recipe such as "commercial_foo_1.2" in a "foo" recipe. The build system expands this string to "commercial_foo_1.2_foo". Combine this license flag with a whitelist that has the string "commercial" and you match the flag along with any other flag that starts with the string "commercial".

  • Under the same circumstances, you can use "commercial_foo" in the whitelist and the build system not only matches "commercial_foo_1.2" but also matches any license flag with the string "commercial_foo", regardless of the version.

  • You can be very specific and use both the package and version parts in the whitelist (e.g. "commercial_foo_1.2") to specifically match a versioned recipe.

Other helpful variables related to commercial license handling exist and are defined in the poky/meta/conf/distro/include/default-distrovars.inc file:

     COMMERCIAL_AUDIO_PLUGINS ?= ""
     COMMERCIAL_VIDEO_PLUGINS ?= ""
                

If you want to enable these components, you can do so by making sure you have statements similar to the following in your local.conf configuration file:

     COMMERCIAL_AUDIO_PLUGINS = "gst-plugins-ugly-mad \
        gst-plugins-ugly-mpegaudioparse"
     COMMERCIAL_VIDEO_PLUGINS = "gst-plugins-ugly-mpeg2dec \
        gst-plugins-ugly-mpegstream gst-plugins-bad-mpegvideoparse"
     LICENSE_FLAGS_WHITELIST = "commercial_gst-plugins-ugly commercial_gst-plugins-bad commercial_qmmp"
                

Of course, you could also create a matching whitelist for those components using the more general "commercial" in the whitelist, but that would also enable all the other packages with LICENSE_FLAGS containing "commercial", which you may or may not want:

     LICENSE_FLAGS_WHITELIST = "commercial"
                

Specifying audio and video plug-ins as part of the COMMERCIAL_AUDIO_PLUGINS and COMMERCIAL_VIDEO_PLUGINS statements (along with the enabling LICENSE_FLAGS_WHITELIST) includes the plug-ins or components into built images, thus adding support for media formats or components.

Chapter 5. Migrating to a Newer Yocto Project Release

Table of Contents

5.1. General Migration Considerations
5.2. Moving to the Yocto Project 1.3 Release
5.2.1. Local Configuration
5.2.2. Recipes
5.2.3. Linux Kernel Naming
5.3. Moving to the Yocto Project 1.4 Release
5.3.1. BitBake
5.3.2. Build Behavior
5.3.3. Proxies and Fetching Source
5.3.4. Custom Interfaces File (netbase change)
5.3.5. Remote Debugging
5.3.6. Variables
5.3.7. Target Package Management with RPM
5.3.8. Recipes Moved
5.3.9. Removals and Renames
5.4. Moving to the Yocto Project 1.5 Release
5.4.1. Host Dependency Changes
5.4.2. atom-pc Board Support Package (BSP)
5.4.3. BitBake
5.4.4. QA Warnings
5.4.5. Directory Layout Changes
5.4.6. Shortened Git SRCREV Values
5.4.7. IMAGE_FEATURES
5.4.8. /run
5.4.9. Removal of Package Manager Database Within Image Recipes
5.4.10. Images Now Rebuild Only on Changes Instead of Every Time
5.4.11. Task Recipes
5.4.12. BusyBox
5.4.13. Automated Image Testing
5.4.14. Build History
5.4.15. udev
5.4.16. Removed and Renamed Recipes
5.4.17. Other Changes
5.5. Moving to the Yocto Project 1.6 Release
5.5.1. archiver Class
5.5.2. Packaging Changes
5.5.3. BitBake
5.5.4. Changes to Variables
5.5.5. Package Test (ptest)
5.5.6. Build Changes
5.5.7. qemu-native
5.5.8. core-image-basic
5.5.9. Licensing
5.5.10. CFLAGS Options
5.5.11. Custom Image Output Types
5.5.12. Tasks
5.5.13. update-alternative Provider
5.5.14. virtclass Overrides
5.5.15. Removed and Renamed Recipes
5.5.16. Removed Classes
5.5.17. Reference Board Support Packages (BSPs)
5.6. Moving to the Yocto Project 1.7 Release
5.6.1. Changes to Setting QEMU PACKAGECONFIG Options in local.conf
5.6.2. Minimum Git version
5.6.3. Autotools Class Changes
5.6.4. Binary Configuration Scripts Disabled
5.6.5. eglibc 2.19 Replaced with glibc 2.20
5.6.6. Kernel Module Autoloading
5.6.7. QA Check Changes
5.6.8. Removed Recipes
5.6.9. Miscellaneous Changes
5.7. Moving to the Yocto Project 1.8 Release
5.7.1. Removed Recipes
5.7.2. BlueZ 4.x / 5.x Selection
5.7.3. Kernel Build Changes
5.7.4. SSL 3.0 is Now Disabled in OpenSSL
5.7.5. Default Sysroot Poisoning
5.7.6. Rebuild Improvements
5.7.7. QA Check and Validation Changes
5.7.8. Miscellaneous Changes
5.8. Moving to the Yocto Project 2.0 Release
5.8.1. GCC 5
5.8.2. Gstreamer 0.10 Removed
5.8.3. Removed Recipes
5.8.4. BitBake datastore improvements
5.8.5. Shell Message Function Changes
5.8.6. Extra Development/Debug Package Cleanup
5.8.7. Recipe Maintenance Tracking Data Moved to OE-Core
5.8.8. Automatic Stale Sysroot File Cleanup
5.8.9. linux-yocto Kernel Metadata Repository Now Split from Source
5.8.10. Additional QA checks
5.8.11. Miscellaneous Changes
5.9. Moving to the Yocto Project 2.1 Release
5.9.1. Variable Expansion in Python Functions
5.9.2. Overrides Must Now be Lower-Case
5.9.3. Expand Parameter to getVar() and getVarFlag() is Now Mandatory
5.9.4. Makefile Environment Changes
5.9.5. libexecdir Reverted to ${prefix}/libexec
5.9.6. ac_cv_sizeof_off_t is No Longer Cached in Site Files
5.9.7. Image Generation is Now Split Out from Filesystem Generation
5.9.8. Removed Recipes
5.9.9. Class Changes
5.9.10. Build System User Interface Changes
5.9.11. ADT Removed
5.9.12. Poky Reference Distribution Changes
5.9.13. Packaging Changes
5.9.14. Tuning File Changes
5.9.15. Supporting GObject Introspection
5.9.16. Miscellaneous Changes
5.10. Moving to the Yocto Project 2.2 Release
5.10.1. Minimum Kernel Version
5.10.2. Staging Directories in Sysroot Has Been Simplified
5.10.3. Removal of Old Images and Other Files in tmp/deploy Now Enabled
5.10.4. Python Changes
5.10.5. uClibc Replaced by musl
5.10.6. ${B} No Longer Default Working Directory for Tasks
5.10.7. runqemu Ported to Python
5.10.8. Default Linker Hash Style Changed
5.10.9. KERNEL_IMAGE_BASE_NAME no Longer Uses KERNEL_IMAGETYPE
5.10.10. BitBake Changes
5.10.11. Swabber has Been Removed
5.10.12. Removed Recipes
5.10.13. Removed Classes
5.10.14. Minor Packaging Changes
5.10.15. Miscellaneous Changes

This chapter provides information you can use to migrate work to a newer Yocto Project release. You can find the same information in the release notes for a given release.

5.1. General Migration Considerations

Some considerations are not tied to a specific Yocto Project release. This section presents information you should consider when migrating to any new Yocto Project release.

  • Dealing with Customized Recipes: Issues could arise if you take older recipes that contain customizations and simply copy them forward expecting them to work after you migrate to new Yocto Project metadata. For example, suppose you have a recipe in your layer that is a customized version of a core recipe copied from the earlier release, rather than through the use of an append file. When you migrate to a newer version of Yocto Project, the metadata (e.g. perhaps an include file used by the recipe) could have changed in a way that would break the build. Say, for example, a function is removed from an include file and the customized recipe tries to call that function.

    You could "forward-port" all your customizations in your recipe so that everything works for the new release. However, this is not the optimal solution as you would have to repeat this process with each new release if changes occur that give rise to problems.

    The better solution (where practical) is to use append files (*.bbappend) to capture any customizations you want to make to a recipe. Doing so, isolates your changes from the main recipe making them much more manageable. However, sometimes it is not practical to use an append file. A good example of this is when introducing a newer or older version of a recipe in another layer.

  • Updating Append Files: Since append files generally only contain your customizations, they often do not need to be adjusted for new releases. However, if the .bbappend file is specific to a particular version of the recipe (i.e. its name does not use the % wildcard) and the version of the recipe to which it is appending has changed, then you will at a minimum need to rename the append file to match the name of the recipe file. A mismatch between an append file and its corresponding recipe file (.bb) will trigger an error during parsing.

    Depending on the type of customization the append file applies, other incompatibilities might occur when you upgrade. For example, if your append file applies a patch and the recipe to which it is appending is updated to a newer version, the patch might no longer apply. If this is the case and assuming the patch is still needed, you must modify the patch file so that it does apply.

5.2. Moving to the Yocto Project 1.3 Release

This section provides migration information for moving to the Yocto Project 1.3 Release from the prior release.

5.2.1. Local Configuration

Differences include changes for SSTATE_MIRRORS and bblayers.conf.

5.2.1.1. SSTATE_MIRRORS

The shared state cache (sstate-cache), as pointed to by SSTATE_DIR, by default now has two-character subdirectories to prevent issues arising from too many files in the same directory. Also, native sstate-cache packages, which are built to run on the host system, will go into a subdirectory named using the distro ID string. If you copy the newly structured sstate-cache to a mirror location (either local or remote) and then point to it in SSTATE_MIRRORS, you need to append "PATH" to the end of the mirror URL so that the path used by BitBake before the mirror substitution is appended to the path used to access the mirror. Here is an example:

     SSTATE_MIRRORS = "file://.* http://someserver.tld/share/sstate/PATH"
                

5.2.1.2. bblayers.conf

The meta-yocto layer consists of two parts that correspond to the Poky reference distribution and the reference hardware Board Support Packages (BSPs), respectively: meta-yocto and meta-yocto-bsp. When running BitBake for the first time after upgrading, your conf/bblayers.conf file will be updated to handle this change and you will be asked to re-run or restart for the changes to take effect.

5.2.2. Recipes

Differences include changes for the following:

  • Python function whitespace

  • proto= in SRC_URI

  • nativesdk

  • Task recipes

  • IMAGE_FEATURES

  • Removed recipes

5.2.2.1. Python Function Whitespace

All Python functions must now use four spaces for indentation. Previously, an inconsistent mix of spaces and tabs existed, which made extending these functions using _append or _prepend complicated given that Python treats whitespace as syntactically significant. If you are defining or extending any Python functions (e.g. populate_packages, do_unpack, do_patch and so forth) in custom recipes or classes, you need to ensure you are using consistent four-space indentation.

5.2.2.2. proto= in SRC_URI

Any use of proto= in SRC_URI needs to be changed to protocol=. In particular, this applies to the following URIs:

  • svn://

  • bzr://

  • hg://

  • osc://

Other URIs were already using protocol=. This change improves consistency.

5.2.2.3. nativesdk

The suffix nativesdk is now implemented as a prefix, which simplifies a lot of the packaging code for nativesdk recipes. All custom nativesdk recipes, which are relocatable packages that are native to SDK_ARCH, and any references need to be updated to use nativesdk-* instead of *-nativesdk.

5.2.2.4. Task Recipes

"Task" recipes are now known as "Package groups" and have been renamed from task-*.bb to packagegroup-*.bb. Existing references to the previous task-* names should work in most cases as there is an automatic upgrade path for most packages. However, you should update references in your own recipes and configurations as they could be removed in future releases. You should also rename any custom task-* recipes to packagegroup-*, and change them to inherit packagegroup instead of task, as well as taking the opportunity to remove anything now handled by packagegroup.bbclass, such as providing -dev and -dbg packages, setting LIC_FILES_CHKSUM, and so forth. See the "packagegroup.bbclass" section for further details.

5.2.2.5. IMAGE_FEATURES

Image recipes that previously included "apps-console-core" in IMAGE_FEATURES should now include "splash" instead to enable the boot-up splash screen. Retaining "apps-console-core" will still include the splash screen but generates a warning. The "apps-x11-core" and "apps-x11-games" IMAGE_FEATURES features have been removed.

5.2.2.6. Removed Recipes

The following recipes have been removed. For most of them, it is unlikely that you would have any references to them in your own Metadata. However, you should check your metadata against this list to be sure:

  • libx11-trim: Replaced by libx11, which has a negligible size difference with modern Xorg.

  • xserver-xorg-lite: Use xserver-xorg, which has a negligible size difference when DRI and GLX modules are not installed.

  • xserver-kdrive: Effectively unmaintained for many years.

  • mesa-xlib: No longer serves any purpose.

  • galago: Replaced by telepathy.

  • gail: Functionality was integrated into GTK+ 2.13.

  • eggdbus: No longer needed.

  • gcc-*-intermediate: The build has been restructured to avoid the need for this step.

  • libgsmd: Unmaintained for many years. Functionality now provided by ofono instead.

  • contacts, dates, tasks, eds-tools: Largely unmaintained PIM application suite. It has been moved to meta-gnome in meta-openembedded.

In addition to the previously listed changes, the meta-demoapps directory has also been removed because the recipes in it were not being maintained and many had become obsolete or broken. Additionally, these recipes were not parsed in the default configuration. Many of these recipes are already provided in an updated and maintained form within the OpenEmbedded community layers such as meta-oe and meta-gnome. For the remainder, you can now find them in the meta-extras repository, which is in the Yocto Project Source Repositories.

5.2.3. Linux Kernel Naming

The naming scheme for kernel output binaries has been changed to now include PE as part of the filename:

     KERNEL_IMAGE_BASE_NAME ?= "${KERNEL_IMAGETYPE}-${PE}-${PV}-${PR}-${MACHINE}-${DATETIME}"
            

Because the PE variable is not set by default, these binary files could result with names that include two dash characters. Here is an example:

     bzImage--3.10.9+git0+cd502a8814_7144bcc4b8-r0-qemux86-64-20130830085431.bin
            

5.3. Moving to the Yocto Project 1.4 Release

This section provides migration information for moving to the Yocto Project 1.4 Release from the prior release.

5.3.1. BitBake

Differences include the following:

  • Comment Continuation: If a comment ends with a line continuation (\) character, then the next line must also be a comment. Any instance where this is not the case, now triggers a warning. You must either remove the continuation character, or be sure the next line is a comment.

  • Package Name Overrides: The runtime package specific variables RDEPENDS, RRECOMMENDS, RSUGGESTS, RPROVIDES, RCONFLICTS, RREPLACES, FILES, ALLOW_EMPTY, and the pre, post, install, and uninstall script functions pkg_preinst, pkg_postinst, pkg_prerm, and pkg_postrm should always have a package name override. For example, use RDEPENDS_${PN} for the main package instead of RDEPENDS. BitBake uses more strict checks when it parses recipes.

5.3.2. Build Behavior

Differences include the following:

  • Shared State Code: The shared state code has been optimized to avoid running unnecessary tasks. For example, the following no longer populates the target sysroot since that is not necessary:

         $ bitbake -c rootfs some-image
                        

    Instead, the system just needs to extract the output package contents, re-create the packages, and construct the root filesystem. This change is unlikely to cause any problems unless you have missing declared dependencies.

  • Scanning Directory Names: When scanning for files in SRC_URI, the build system now uses FILESOVERRIDES instead of OVERRIDES for the directory names. In general, the values previously in OVERRIDES are now in FILESOVERRIDES as well. However, if you relied upon an additional value you previously added to OVERRIDES, you might now need to add it to FILESOVERRIDES unless you are already adding it through the MACHINEOVERRIDES or DISTROOVERRIDES variables, as appropriate. For more related changes, see the "Variables" section.

5.3.3. Proxies and Fetching Source

A new oe-git-proxy script has been added to replace previous methods of handling proxies and fetching source from Git. See the meta-yocto/conf/site.conf.sample file for information on how to use this script.

5.3.4. Custom Interfaces File (netbase change)

If you have created your own custom etc/network/interfaces file by creating an append file for the netbase recipe, you now need to create an append file for the init-ifupdown recipe instead, which you can find in the Source Directory at meta/recipes-core/init-ifupdown. For information on how to use append files, see the "Using .bbappend Files" in the Yocto Project Development Manual.

5.3.5. Remote Debugging

Support for remote debugging with the Eclipse IDE is now separated into an image feature (eclipse-debug) that corresponds to the packagegroup-core-eclipse-debug package group. Previously, the debugging feature was included through the tools-debug image feature, which corresponds to the packagegroup-core-tools-debug package group.

5.3.6. Variables

The following variables have changed:

  • SANITY_TESTED_DISTROS: This variable now uses a distribution ID, which is composed of the host distributor ID followed by the release. Previously, SANITY_TESTED_DISTROS was composed of the description field. For example, "Ubuntu 12.10" becomes "Ubuntu-12.10". You do not need to worry about this change if you are not specifically setting this variable, or if you are specifically setting it to "".

  • SRC_URI: The ${PN}, ${PF}, ${P}, and FILE_DIRNAME directories have been dropped from the default value of the FILESPATH variable, which is used as the search path for finding files referred to in SRC_URI. If you have a recipe that relied upon these directories, which would be unusual, then you will need to add the appropriate paths within the recipe or, alternatively, rearrange the files. The most common locations are still covered by ${BP}, ${BPN}, and "files", which all remain in the default value of FILESPATH.

5.3.7. Target Package Management with RPM

If runtime package management is enabled and the RPM backend is selected, Smart is now installed for package download, dependency resolution, and upgrades instead of Zypper. For more information on how to use Smart, run the following command on the target:

     smart --help
            

5.3.8. Recipes Moved

The following recipes were moved from their previous locations because they are no longer used by anything in the OpenEmbedded-Core:

  • clutter-box2d: Now resides in the meta-oe layer.

  • evolution-data-server: Now resides in the meta-gnome layer.

  • gthumb: Now resides in the meta-gnome layer.

  • gtkhtml2: Now resides in the meta-oe layer.

  • gupnp: Now resides in the meta-multimedia layer.

  • gypsy: Now resides in the meta-oe layer.

  • libcanberra: Now resides in the meta-gnome layer.

  • libgdata: Now resides in the meta-gnome layer.

  • libmusicbrainz: Now resides in the meta-multimedia layer.

  • metacity: Now resides in the meta-gnome layer.

  • polkit: Now resides in the meta-oe layer.

  • zeroconf: Now resides in the meta-networking layer.

5.3.9. Removals and Renames

The following list shows what has been removed or renamed:

  • evieext: Removed because it has been removed from xserver since 2008.

  • Gtk+ DirectFB: Removed support because upstream Gtk+ no longer supports it as of version 2.18.

  • libxfontcache / xfontcacheproto: Removed because they were removed from the Xorg server in 2008.

  • libxp / libxprintapputil / libxprintutil / printproto: Removed because the XPrint server was removed from Xorg in 2008.

  • libxtrap / xtrapproto: Removed because their functionality was broken upstream.

  • linux-yocto 3.0 kernel: Removed with linux-yocto 3.8 kernel being added. The linux-yocto 3.2 and linux-yocto 3.4 kernels remain as part of the release.

  • lsbsetup: Removed with functionality now provided by lsbtest.

  • matchbox-stroke: Removed because it was never more than a proof-of-concept.

  • matchbox-wm-2 / matchbox-theme-sato-2: Removed because they are not maintained. However, matchbox-wm and matchbox-theme-sato are still provided.

  • mesa-dri: Renamed to mesa.

  • mesa-xlib: Removed because it was no longer useful.

  • mutter: Removed because nothing ever uses it and the recipe is very old.

  • orinoco-conf: Removed because it has become obsolete.

  • update-modules: Removed because it is no longer used. The kernel module postinstall and postrm scripts can now do the same task without the use of this script.

  • web: Removed because it is not maintained. Superseded by web-webkit.

  • xf86bigfontproto: Removed because upstream it has been disabled by default since 2007. Nothing uses xf86bigfontproto.

  • xf86rushproto: Removed because its dependency in xserver was spurious and it was removed in 2005.

  • zypper / libzypp / sat-solver: Removed and been functionally replaced with Smart (python-smartpm) when RPM packaging is used and package management is enabled on the target.

5.4. Moving to the Yocto Project 1.5 Release

This section provides migration information for moving to the Yocto Project 1.5 Release from the prior release.

5.4.1. Host Dependency Changes

The OpenEmbedded build system now has some additional requirements on the host system:

  • Python 2.7.3+

  • Tar 1.24+

  • Git 1.7.8+

  • Patched version of Make if you are using 3.82. Most distributions that provide Make 3.82 use the patched version.

If the Linux distribution you are using on your build host does not provide packages for these, you can install and use the Buildtools tarball, which provides an SDK-like environment containing them.

For more information on this requirement, see the "Required Git, tar, and Python Versions" section.

5.4.2. atom-pc Board Support Package (BSP)

The atom-pc hardware reference BSP has been replaced by a genericx86 BSP. This BSP is not necessarily guaranteed to work on all x86 hardware, but it will run on a wider range of systems than the atom-pc did.

Note

Additionally, a genericx86-64 BSP has been added for 64-bit Atom systems.

5.4.3. BitBake

The following changes have been made that relate to BitBake:

  • BitBake now supports a _remove operator. The addition of this operator means you will have to rename any items in recipe space (functions, variables) whose names currently contain _remove_ or end with _remove to avoid unexpected behavior.

  • BitBake's global method pool has been removed. This method is not particularly useful and led to clashes between recipes containing functions that had the same name.

  • The "none" server backend has been removed. The "process" server backend has been serving well as the default for a long time now.

  • The bitbake-runtask script has been removed.

  • ${P} and ${PF} are no longer added to PROVIDES by default in bitbake.conf. These version-specific PROVIDES items were seldom used. Attempting to use them could result in two versions being built simultaneously rather than just one version due to the way BitBake resolves dependencies.

5.4.4. QA Warnings

The following changes have been made to the package QA checks:

  • If you have customized ERROR_QA or WARN_QA values in your configuration, check that they contain all of the issues that you wish to be reported. Previous Yocto Project versions contained a bug that meant that any item not mentioned in ERROR_QA or WARN_QA would be treated as a warning. Consequently, several important items were not already in the default value of WARN_QA. All of the possible QA checks are now documented in the "insane.bbclass" section.

  • An additional QA check has been added to check if /usr/share/info/dir is being installed. Your recipe should delete this file within do_install if "make install" is installing it.

  • If you are using the buildhistory class, the check for the package version going backwards is now controlled using a standard QA check. Thus, if you have customized your ERROR_QA or WARN_QA values and still wish to have this check performed, you should add "version-going-backwards" to your value for one or the other variables depending on how you wish it to be handled. See the documented QA checks in the "insane.bbclass" section.

5.4.5. Directory Layout Changes

The following directory changes exist:

  • Output SDK installer files are now named to include the image name and tuning architecture through the SDK_NAME variable.

  • Images and related files are now installed into a directory that is specific to the machine, instead of a parent directory containing output files for multiple machines. The DEPLOY_DIR_IMAGE variable continues to point to the directory containing images for the current MACHINE and should be used anywhere there is a need to refer to this directory. The runqemu script now uses this variable to find images and kernel binaries and will use BitBake to determine the directory. Alternatively, you can set the DEPLOY_DIR_IMAGE variable in the external environment.

  • When buildhistory is enabled, its output is now written under the Build Directory rather than TMPDIR. Doing so makes it easier to delete TMPDIR and preserve the build history. Additionally, data for produced SDKs is now split by IMAGE_NAME.

  • The pkgdata directory produced as part of the packaging process has been collapsed into a single machine-specific directory. This directory is located under sysroots and uses a machine-specific name (i.e. tmp/sysroots/machine/pkgdata).

5.4.6. Shortened Git SRCREV Values

BitBake will now shorten revisions from Git repositories from the normal 40 characters down to 10 characters within SRCPV for improved usability in path and file names. This change should be safe within contexts where these revisions are used because the chances of spatially close collisions is very low. Distant collisions are not a major issue in the way the values are used.

5.4.7. IMAGE_FEATURES

The following changes have been made that relate to IMAGE_FEATURES:

  • The value of IMAGE_FEATURES is now validated to ensure invalid feature items are not added. Some users mistakenly add package names to this variable instead of using IMAGE_INSTALL in order to have the package added to the image, which does not work. This change is intended to catch those kinds of situations. Valid IMAGE_FEATURES are drawn from PACKAGE_GROUP definitions, COMPLEMENTARY_GLOB and a new "validitems" varflag on IMAGE_FEATURES. The "validitems" varflag change allows additional features to be added if they are not provided using the previous two mechanisms.

  • The previously deprecated "apps-console-core" IMAGE_FEATURES item is no longer supported. Add "splash" to IMAGE_FEATURES if you wish to have the splash screen enabled, since this is all that apps-console-core was doing.

5.4.8. /run

The /run directory from the Filesystem Hierarchy Standard 3.0 has been introduced. You can find some of the implications for this change here. The change also means that recipes that install files to /var/run must be changed. You can find a guide on how to make these changes here.

5.4.9. Removal of Package Manager Database Within Image Recipes

The image core-image-minimal no longer adds remove_packaging_data_files to ROOTFS_POSTPROCESS_COMMAND. This addition is now handled automatically when "package-management" is not in IMAGE_FEATURES. If you have custom image recipes that make this addition, you should remove the lines, as they are not needed and might interfere with correct operation of postinstall scripts.

5.4.10. Images Now Rebuild Only on Changes Instead of Every Time

The do_rootfs and other related image construction tasks are no longer marked as "nostamp". Consequently, they will only be re-executed when their inputs have changed. Previous versions of the OpenEmbedded build system always rebuilt the image when requested rather when necessary.

5.4.11. Task Recipes

The previously deprecated task.bbclass has now been dropped. For recipes that previously inherited from this class, you should rename them from task-* to packagegroup-* and inherit packagegroup instead.

For more information, see the "packagegroup.bbclass" section.

5.4.12. BusyBox

By default, we now split BusyBox into two binaries: one that is suid root for those components that need it, and another for the rest of the components. Splitting BusyBox allows for optimization that eliminates the tinylogin recipe as recommended by upstream. You can disable this split by setting BUSYBOX_SPLIT_SUID to "0".

5.4.13. Automated Image Testing

A new automated image testing framework has been added through the testimage.bbclass class. This framework replaces the older imagetest-qemu framework.

You can learn more about performing automated image tests in the "Performing Automated Runtime Testing" section.

5.4.14. Build History

Following are changes to Build History:

  • Installed package sizes: installed-package-sizes.txt for an image now records the size of the files installed by each package instead of the size of each compressed package archive file.

  • The dependency graphs (depends*.dot) now use the actual package names instead of replacing dashes, dots and plus signs with underscores.

  • The buildhistory-diff and buildhistory-collect-srcrevs utilities have improved command-line handling. Use the --help option for each utility for more information on the new syntax.

For more information on Build History, see the "Maintaining Build Output Quality" section.

5.4.15. udev

Following are changes to udev:

  • udev no longer brings in udev-extraconf automatically through RRECOMMENDS, since this was originally intended to be optional. If you need the extra rules, then add udev-extraconf to your image.

  • udev no longer brings in pciutils-ids or usbutils-ids through RRECOMMENDS. These are not needed by udev itself and removing them saves around 350KB.

5.4.16. Removed and Renamed Recipes

  • The linux-yocto 3.2 kernel has been removed.

  • libtool-nativesdk has been renamed to nativesdk-libtool.

  • tinylogin has been removed. It has been replaced by a suid portion of Busybox. See the "BusyBox" section for more information.

  • external-python-tarball has been renamed to buildtools-tarball.

  • web-webkit has been removed. It has been functionally replaced by midori.

  • imake has been removed. It is no longer needed by any other recipe.

  • transfig-native has been removed. It is no longer needed by any other recipe.

  • anjuta-remote-run has been removed. Anjuta IDE integration has not been officially supported for several releases.

5.4.17. Other Changes

Following is a list of short entries describing other changes:

  • run-postinsts: Make this generic.

  • base-files: Remove the unnecessary media/xxx directories.

  • alsa-state: Provide an empty asound.conf by default.

  • classes/image: Ensure BAD_RECOMMENDATIONS supports pre-renamed package names.

  • classes/rootfs_rpm: Implement BAD_RECOMMENDATIONS for RPM.

  • systemd: Remove systemd_unitdir if systemd is not in DISTRO_FEATURES.

  • systemd: Remove init.d dir if systemd unit file is present and sysvinit is not a distro feature.

  • libpam: Deny all services for the OTHER entries.

  • image.bbclass: Move runtime_mapping_rename to avoid conflict with multilib. See YOCTO #4993 in Bugzilla for more information.

  • linux-dtb: Use kernel build system to generate the dtb files.

  • kern-tools: Switch from guilt to new kgit-s2q tool.

5.5. Moving to the Yocto Project 1.6 Release

This section provides migration information for moving to the Yocto Project 1.6 Release from the prior release.

5.5.1. archiver Class

The archiver class has been rewritten and its configuration has been simplified. For more details on the source archiver, see the "Maintaining Open Source License Compliance During Your Product's Lifecycle" section in the Yocto Project Development Manual.

5.5.2. Packaging Changes

The following packaging changes have been made:

  • The binutils recipe no longer produces a binutils-symlinks package. update-alternatives is now used to handle the preferred binutils variant on the target instead.

  • The tc (traffic control) utilities have been split out of the main iproute2 package and put into the iproute2-tc package.

  • The gtk-engines schemas have been moved to a dedicated gtk-engines-schemas package.

  • The armv7a with thumb package architecture suffix has changed. The suffix for these packages with the thumb optimization enabled is "t2" as it should be. Use of this suffix was not the case in the 1.5 release. Architecture names will change within package feeds as a result.

5.5.3. BitBake

The following changes have been made to BitBake.

5.5.3.1. Matching Branch Requirement for Git Fetching

When fetching source from a Git repository using SRC_URI, BitBake will now validate the SRCREV value against the branch. You can specify the branch using the following form:

     SRC_URI = "git://server.name/repository;branch=branchname"
                

If you do not specify a branch, BitBake looks in the default "master" branch.

Alternatively, if you need to bypass this check (e.g. if you are fetching a revision corresponding to a tag that is not on any branch), you can add ";nobranch=1" to the end of the URL within SRC_URI.

5.5.3.2. Python Definition substitutions

BitBake had some previously deprecated Python definitions within its bb module removed. You should use their sub-module counterparts instead:

  • bb.MalformedUrl: Use bb.fetch.MalformedUrl.

  • bb.encodeurl: Use bb.fetch.encodeurl.

  • bb.decodeurl: Use bb.fetch.decodeurl

  • bb.mkdirhier: Use bb.utils.mkdirhier.

  • bb.movefile: Use bb.utils.movefile.

  • bb.copyfile: Use bb.utils.copyfile.

  • bb.which: Use bb.utils.which.

  • bb.vercmp_string: Use bb.utils.vercmp_string.

  • bb.vercmp: Use bb.utils.vercmp.

5.5.3.3. SVK Fetcher

The SVK fetcher has been removed from BitBake.

5.5.3.4. Console Output Error Redirection

The BitBake console UI will now output errors to stderr instead of stdout. Consequently, if you are piping or redirecting the output of bitbake to somewhere else, and you wish to retain the errors, you will need to add 2>&1 (or something similar) to the end of your bitbake command line.

5.5.3.5. task-taskname Overrides

task-taskname overrides have been adjusted so that tasks whose names contain underscores have the underscores replaced by hyphens for the override so that they now function properly. For example, the task override for do_populate_sdk is task-populate-sdk.

5.5.4. Changes to Variables

The following variables have changed. For information on the OpenEmbedded build system variables, see the "Variables Glossary" Chapter.

5.5.4.1. TMPDIR

TMPDIR can no longer be on an NFS mount. NFS does not offer full POSIX locking and inode consistency and can cause unexpected issues if used to store TMPDIR.

The check for this occurs on startup. If TMPDIR is detected on an NFS mount, an error occurs.

5.5.4.2. PRINC

The PRINC variable has been deprecated and triggers a warning if detected during a build. For PR increments on changes, use the PR service instead. You can find out more about this service in the "Working With a PR Service" section in the Yocto Project Development Manual.

5.5.4.3. IMAGE_TYPES

The "sum.jffs2" option for IMAGE_TYPES has been replaced by the "jffs2.sum" option, which fits the processing order.

5.5.4.4. COPY_LIC_MANIFEST

The COPY_LIC_MANIFEST variable must now be set to "1" rather than any value in order to enable it.

5.5.4.5. COPY_LIC_DIRS

The COPY_LIC_DIRS variable must now be set to "1" rather than any value in order to enable it.

5.5.4.6. PACKAGE_GROUP

The PACKAGE_GROUP variable has been renamed to FEATURE_PACKAGES to more accurately reflect its purpose. You can still use PACKAGE_GROUP but the OpenEmbedded build system produces a warning message when it encounters the variable.

5.5.4.7. Preprocess and Post Process Command Variable Behavior

The following variables now expect a semicolon separated list of functions to call and not arbitrary shell commands:

     ROOTFS_PREPROCESS_COMMAND
     ROOTFS_POSTPROCESS_COMMAND
     SDK_POSTPROCESS_COMMAND
     POPULATE_SDK_POST_TARGET_COMMAND
     POPULATE_SDK_POST_HOST_COMMAND
     IMAGE_POSTPROCESS_COMMAND
     IMAGE_PREPROCESS_COMMAND
     ROOTFS_POSTUNINSTALL_COMMAND
     ROOTFS_POSTINSTALL_COMMAND
                

For migration purposes, you can simply wrap shell commands in a shell function and then call the function. Here is an example:

     my_postprocess_function() {
        echo "hello" > ${IMAGE_ROOTFS}/hello.txt
     }
     ROOTFS_POSTPROCESS_COMMAND += "my_postprocess_function; "
                

5.5.5. Package Test (ptest)

Package Tests (ptest) are built but not installed by default. For information on using Package Tests, see the "Setting up and running package test (ptest)" section in the Yocto Project Development Manual. For information on the ptest class, see the "ptest.bbclass" section.

5.5.6. Build Changes

Separate build and source directories have been enabled by default for selected recipes where it is known to work (a whitelist) and for all recipes that inherit the cmake class. In future releases the autotools class will enable a separate build directory by default as well. Recipes building Autotools-based software that fails to build with a separate build directory should be changed to inherit from the autotools-brokensep class instead of the autotools or autotools_stageclasses.

5.5.7. qemu-native

qemu-native now builds without SDL-based graphical output support by default. The following additional lines are needed in your local.conf to enable it:

     PACKAGECONFIG_pn-qemu-native = "sdl"
     ASSUME_PROVIDED += "libsdl-native"
            

Note

The default local.conf contains these statements. Consequently, if you are building a headless system and using a default local.conf file, you will need comment these two lines out.

5.5.8. core-image-basic

core-image-basic has been renamed to core-image-full-cmdline.

In addition to core-image-basic being renamed, packagegroup-core-basic has been renamed to packagegroup-core-full-cmdline to match.

5.5.9. Licensing

The top-level LICENSE file has been changed to better describe the license of the various components of OE-Core. However, the licensing itself remains unchanged.

Normally, this change would not cause any side-effects. However, some recipes point to this file within LIC_FILES_CHKSUM (as ${COREBASE}/LICENSE) and thus the accompanying checksum must be changed from 3f40d7994397109285ec7b81fdeb3b58 to 4d92cd373abda3937c2bc47fbc49d690. A better alternative is to have LIC_FILES_CHKSUM point to a file describing the license that is distributed with the source that the recipe is building, if possible, rather than pointing to ${COREBASE}/LICENSE.

5.5.10. CFLAGS Options

The "-fpermissive" option has been removed from the default CFLAGS value. You need to take action on individual recipes that fail when building with this option. You need to either patch the recipes to fix the issues reported by the compiler, or you need to add "-fpermissive" to CFLAGS in the recipes.

5.5.11. Custom Image Output Types

Custom image output types, as selected using IMAGE_FSTYPES, must declare their dependencies on other image types (if any) using a new IMAGE_TYPEDEP variable.

5.5.12. Tasks

The do_package_write task has been removed. The task is no longer needed.

5.5.13. update-alternative Provider

The default update-alternatives provider has been changed from opkg to opkg-utils. This change resolves some troublesome circular dependencies. The runtime package has also been renamed from update-alternatives-cworth to update-alternatives-opkg.

5.5.14. virtclass Overrides

The virtclass overrides are now deprecated. Use the equivalent class overrides instead (e.g. virtclass-native becomes class-native.)

5.5.15. Removed and Renamed Recipes

The following recipes have been removed:

  • packagegroup-toolset-native - This recipe is largely unused.

  • linux-yocto-3.8 - Support for the Linux yocto 3.8 kernel has been dropped. Support for the 3.10 and 3.14 kernels have been added with the linux-yocto-3.10 and linux-yocto-3.14 recipes.

  • ocf-linux - This recipe has been functionally replaced using cryptodev-linux.

  • genext2fs - genext2fs is no longer used by the build system and is unmaintained upstream.

  • js - This provided an ancient version of Mozilla's javascript engine that is no longer needed.

  • zaurusd - The recipe has been moved to the meta-handheld layer.

  • eglibc 2.17 - Replaced by the eglibc 2.19 recipe.

  • gcc 4.7.2 - Replaced by the now stable gcc 4.8.2.

  • external-sourcery-toolchain - this recipe is now maintained in the meta-sourcery layer.

  • linux-libc-headers-yocto 3.4+git - Now using version 3.10 of the linux-libc-headers by default.

  • meta-toolchain-gmae - This recipe is obsolete.

  • packagegroup-core-sdk-gmae - This recipe is obsolete.

  • packagegroup-core-standalone-gmae-sdk-target - This recipe is obsolete.

5.5.16. Removed Classes

The following classes have become obsolete and have been removed:

  • module_strip

  • pkg_metainfo

  • pkg_distribute

  • image-empty

5.5.17. Reference Board Support Packages (BSPs)

The following reference BSPs changes occurred:

  • The BeagleBoard (beagleboard) ARM reference hardware has been replaced by the BeagleBone (beaglebone) hardware.

  • The RouterStation Pro (routerstationpro) MIPS reference hardware has been replaced by the EdgeRouter Lite (edgerouter) hardware.

The previous reference BSPs for the beagleboard and routerstationpro machines are still available in a new meta-yocto-bsp-old layer in the Source Repositories at http://git.yoctoproject.org/cgit/cgit.cgi/meta-yocto-bsp-old/.

5.6. Moving to the Yocto Project 1.7 Release

This section provides migration information for moving to the Yocto Project 1.7 Release from the prior release.

5.6.1. Changes to Setting QEMU PACKAGECONFIG Options in local.conf

The QEMU recipe now uses a number of PACKAGECONFIG options to enable various optional features. The method used to set defaults for these options means that existing local.conf files will need to be be modified to append to PACKAGECONFIG for qemu-native and nativesdk-qemu instead of setting it. In other words, to enable graphical output for QEMU, you should now have these lines in local.conf:

     PACKAGECONFIG_append_pn-qemu-native = " sdl"
     PACKAGECONFIG_append_pn-nativesdk-qemu = " sdl"
            

5.6.2. Minimum Git version

The minimum Git version required on the build host is now 1.7.8 because the --list option is now required by BitBake's Git fetcher. As always, if your host distribution does not provide a version of Git that meets this requirement, you can use the buildtools-tarball that does. See the "Required Git, tar, and Python Versions" section for more information.

5.6.3. Autotools Class Changes

The following autotools class changes occurred:

  • A separate build directory is now used by default: The autotools class has been changed to use a directory for building (B), which is separate from the source directory (S). This is commonly referred to as B != S, or an out-of-tree build.

    If the software being built is already capable of building in a directory separate from the source, you do not need to do anything. However, if the software is not capable of being built in this manner, you will need to either patch the software so that it can build separately, or you will need to change the recipe to inherit the autotools-brokensep class instead of the autotools or autotools_stage classes.

  • The --foreign option is no longer passed to automake when running autoconf: This option tells automake that a particular software package does not follow the GNU standards and therefore should not be expected to distribute certain files such as ChangeLog, AUTHORS, and so forth. Because the majority of upstream software packages already tell automake to enable foreign mode themselves, the option is mostly superfluous. However, some recipes will need patches for this change. You can easily make the change by patching configure.ac so that it passes "foreign" to AM_INIT_AUTOMAKE(). See this commit for an example showing how to make the patch.

5.6.4. Binary Configuration Scripts Disabled

Some of the core recipes that package binary configuration scripts now disable the scripts due to the scripts previously requiring error-prone path substitution. Software that links against these libraries using these scripts should use the much more robust pkg-config instead. The list of recipes changed in this version (and their configuration scripts) is as follows:

     directfb (directfb-config)
     freetype (freetype-config)
     gpgme (gpgme-config)
     libassuan (libassuan-config)
     libcroco (croco-6.0-config)
     libgcrypt (libgcrypt-config)
     libgpg-error (gpg-error-config)
     libksba (ksba-config)
     libpcap (pcap-config)
     libpcre (pcre-config)
     libpng (libpng-config, libpng16-config)
     libsdl (sdl-config)
     libusb-compat (libusb-config)
     libxml2 (xml2-config)
     libxslt (xslt-config)
     ncurses (ncurses-config)
     neon (neon-config)
     npth (npth-config)
     pth (pth-config)
     taglib (taglib-config)
            

Additionally, support for pkg-config has been added to some recipes in the previous list in the rare cases where the upstream software package does not already provide it.

5.6.5. eglibc 2.19 Replaced with glibc 2.20

Because eglibc and glibc were already fairly close, this replacement should not require any significant changes to other software that links to eglibc. However, there were a number of minor changes in glibc 2.20 upstream that could require patching some software (e.g. the removal of the _BSD_SOURCE feature test macro).

glibc 2.20 requires version 2.6.32 or greater of the Linux kernel. Thus, older kernels will no longer be usable in conjunction with it.

For full details on the changes in glibc 2.20, see the upstream release notes here.

5.6.6. Kernel Module Autoloading

The module_autoload_* variable is now deprecated and a new KERNEL_MODULE_AUTOLOAD variable should be used instead. Also, module_conf_* must now be used in conjunction with a new KERNEL_MODULE_PROBECONF variable. The new variables no longer require you to specify the module name as part of the variable name. This change not only simplifies usage but also allows the values of these variables to be appropriately incorporated into task signatures and thus trigger the appropriate tasks to re-execute when changed. You should replace any references to module_autoload_* with KERNEL_MODULE_AUTOLOAD, and add any modules for which module_conf_* is specified to KERNEL_MODULE_PROBECONF.

For more information, see the KERNEL_MODULE_AUTOLOAD and KERNEL_MODULE_PROBECONF variables.

5.6.7. QA Check Changes

The following changes have occurred to the QA check process:

  • Additional QA checks file-rdeps and build-deps have been added in order to verify that file dependencies are satisfied (e.g. package contains a script requiring /bin/bash) and build-time dependencies are declared, respectively. For more information, please see the "QA Error and Warning Messages" chapter.

  • Package QA checks are now performed during a new do_package_qa task rather than being part of the do_package task. This allows more parallel execution. This change is unlikely to be an issue except for highly customized recipes that disable packaging tasks themselves by marking them as noexec. For those packages, you will need to disable the do_package_qa task as well.

  • Files being overwritten during the do_populate_sysroot task now trigger an error instead of a warning. Recipes should not be overwriting files written to the sysroot by other recipes. If you have these types of recipes, you need to alter them so that they do not overwrite these files.

    You might now receive this error after changes in configuration or metadata resulting in orphaned files being left in the sysroot. If you do receive this error, the way to resolve the issue is to delete your TMPDIR or to move it out of the way and then re-start the build. Anything that has been fully built up to that point and does not need rebuilding will be restored from the shared state cache and the rest of the build will be able to proceed as normal.

5.6.8. Removed Recipes

The following recipes have been removed:

  • x-load: This recipe has been superseded by U-boot SPL for all Cortex-based TI SoCs. For legacy boards, the meta-ti layer, which contains a maintained recipe, should be used instead.

  • ubootchart: This recipe is obsolete. A bootchart2 recipe has been added to functionally replace it.

  • linux-yocto 3.4: Support for the linux-yocto 3.4 kernel has been dropped. Support for the 3.10 and 3.14 kernels remains, while support for version 3.17 has been added.

  • eglibc has been removed in favor of glibc. See the "eglibc 2.19 Replaced with glibc 2.20" section for more information.

5.6.9. Miscellaneous Changes

The following miscellaneous change occurred:

  • The build history feature now writes build-id.txt instead of build-id. Additionally, build-id.txt now contains the full build header as printed by BitBake upon starting the build. You should manually remove old "build-id" files from your existing build history repositories to avoid confusion. For information on the build history feature, see the "Maintaining Build Output Quality" section.

5.7. Moving to the Yocto Project 1.8 Release

This section provides migration information for moving to the Yocto Project 1.8 Release from the prior release.

5.7.1. Removed Recipes

The following recipes have been removed:

  • owl-video: Functionality replaced by gst-player.

  • gaku: Functionality replaced by gst-player.

  • gnome-desktop: This recipe is now available in meta-gnome and is no longer needed.

  • gsettings-desktop-schemas: This recipe is now available in meta-gnome and is no longer needed.

  • python-argparse: The argparse module is already provided in the default Python distribution in a package named python-argparse. Consequently, the separate python-argparse recipe is no longer needed.

  • telepathy-python, libtelepathy, telepathy-glib, telepathy-idle, telepathy-mission-control: All these recipes have moved to meta-oe and are consequently no longer needed by any recipes in OpenEmbedded-Core.

  • linux-yocto_3.10 and linux-yocto_3.17: Support for the linux-yocto 3.10 and 3.17 kernels has been dropped. Support for the 3.14 kernel remains, while support for 3.19 kernel has been added.

  • poky-feed-config-opkg: This recipe has become obsolete and is no longer needed. Use distro-feed-config from meta-oe instead.

  • libav 0.8.x: libav 9.x is now used.

  • sed-native: No longer needed. A working version of sed is expected to be provided by the host distribution.

5.7.2. BlueZ 4.x / 5.x Selection

Proper built-in support for selecting BlueZ 5.x in preference to the default of 4.x now exists. To use BlueZ 5.x, simply add "bluez5" to your DISTRO_FEATURES value. If you had previously added append files (*.bbappend) to make this selection, you can now remove them.

Additionally, a bluetooth class has been added to make selection of the appropriate bluetooth support within a recipe a little easier. If you wish to make use of this class in a recipe, add something such as the following:

     inherit bluetooth
     PACKAGECONFIG ??= "${@bb.utils.contains('DISTRO_FEATURES', 'bluetooth', '${BLUEZ}', '', d)}
     PACKAGECONFIG[bluez4] = "--enable-bluetooth,--disable-bluetooth,bluez4"
     PACKAGECONFIG[bluez5] = "--enable-bluez5,--disable-bluez5,bluez5"
            

5.7.3. Kernel Build Changes

The kernel build process was changed to place the source in a common shared work area and to place build artifacts separately in the source code tree. In theory, migration paths have been provided for most common usages in kernel recipes but this might not work in all cases. In particular, users need to ensure that ${S} (source files) and ${B} (build artifacts) are used correctly in functions such as do_configure and do_install. For kernel recipes that do not inherit from kernel-yocto or include linux-yocto.inc, you might wish to refer to the linux.inc file in the meta-oe layer for the kinds of changes you need to make. For reference, here is the commit where the linux.inc file in meta-oe was updated.

Recipes that rely on the kernel source code and do not inherit the module classes might need to add explicit dependencies on the do_shared_workdir kernel task, for example:

     do_configure[depends] += "virtual/kernel:do_shared_workdir"
            

5.7.4. SSL 3.0 is Now Disabled in OpenSSL

SSL 3.0 is now disabled when building OpenSSL. Disabling SSL 3.0 avoids any lingering instances of the POODLE vulnerability. If you feel you must re-enable SSL 3.0, then you can add an append file (*.bbappend) for the openssl recipe to remove "-no-ssl3" from EXTRA_OECONF.

5.7.5. Default Sysroot Poisoning

gcc's default sysroot and include directories are now "poisoned". In other words, the sysroot and include directories are being redirected to a non-existent location in order to catch when host directories are being used due to the correct options not being passed. This poisoning applies both to the cross-compiler used within the build and to the cross-compiler produced in the SDK.

If this change causes something in the build to fail, it almost certainly means the various compiler flags and commands are not being passed correctly to the underlying piece of software. In such cases, you need to take corrective steps.

5.7.6. Rebuild Improvements

Changes have been made to the base, autotools, and cmake classes to clean out generated files when the do_configure task needs to be re-executed.

One of the improvements is to attempt to run "make clean" during the do_configure task if a Makefile exists. Some software packages do not provide a working clean target within their make files. If you have such recipes, you need to set CLEANBROKEN to "1" within the recipe, for example:

     CLEANBROKEN = "1"
            

5.7.7. QA Check and Validation Changes

The following QA Check and Validation Changes have occurred:

  • Usage of PRINC previously triggered a warning. It now triggers an error. You should remove any remaining usage of PRINC in any recipe or append file.

  • An additional QA check has been added to detect usage of ${D} in FILES values where D values should not be used at all. The same check ensures that $D is used in pkg_preinst/pkg_postinst/pkg_prerm/pkg_postrm functions instead of ${D}.

  • S now needs to be set to a valid value within a recipe. If S is not set in the recipe, the directory is not automatically created. If S does not point to a directory that exists at the time the do_unpack task finishes, a warning will be shown.

  • LICENSE is now validated for correct formatting of multiple licenses. If the format is invalid (e.g. multiple licenses are specified with no operators to specify how the multiple licenses interact), then a warning will be shown.

5.7.8. Miscellaneous Changes

The following miscellaneous changes have occurred:

  • The send-error-report script now expects a "-s" option to be specified before the server address. This assumes a server address is being specified.

  • The oe-pkgdata-util script now expects a "-p" option to be specified before the pkgdata directory, which is now optional. If the pkgdata directory is not specified, the script will run BitBake to query PKGDATA_DIR from the build environment.

5.8. Moving to the Yocto Project 2.0 Release

This section provides migration information for moving to the Yocto Project 2.0 Release from the prior release.

5.8.1. GCC 5

The default compiler is now GCC 5.2. This change has required fixes for compilation errors in a number of other recipes.

One important example is a fix for when the Linux kernel freezes at boot time on ARM when built with GCC 5. If you are using your own kernel recipe or source tree and building for ARM, you will likely need to apply this patch. The standard linux-yocto kernel source tree already has a workaround for the same issue.

For further details, see https://gcc.gnu.org/gcc-5/changes.html and the porting guide at https://gcc.gnu.org/gcc-5/porting_to.html.

Alternatively, you can switch back to GCC 4.9 or 4.8 by setting GCCVERSION in your configuration, as follows:

     GCCVERSION = "4.9%"
            

5.8.2. Gstreamer 0.10 Removed

Gstreamer 0.10 has been removed in favor of Gstreamer 1.x. As part of the change, recipes for Gstreamer 0.10 and related software are now located in meta-multimedia. This change results in Qt4 having Phonon and Gstreamer support in QtWebkit disabled by default.

5.8.3. Removed Recipes

The following recipes have been moved or removed:

  • bluez4: The recipe is obsolete and has been moved due to bluez5 becoming fully integrated. The bluez4 recipe now resides in meta-oe.

  • gamin: The recipe is obsolete and has been removed.

  • gnome-icon-theme: The recipe's functionally has been replaced by adwaita-icon-theme.

  • Gstreamer 0.10 Recipes: Recipes for Gstreamer 0.10 have been removed in favor of the recipes for Gstreamer 1.x.

  • insserv: The recipe is obsolete and has been removed.

  • libunique: The recipe is no longer used and has been moved to meta-oe.

  • midori: The recipe's functionally has been replaced by epiphany.

  • python-gst: The recipe is obsolete and has been removed since it only contains bindings for Gstreamer 0.10.

  • qt-mobility: The recipe is obsolete and has been removed since it requires Gstreamer 0.10, which has been replaced.

  • subversion: All 1.6.x versions of this recipe have been removed.

  • webkit-gtk: The older 1.8.3 version of this recipe has been removed in favor of webkitgtk.

5.8.4. BitBake datastore improvements

The method by which BitBake's datastore handles overrides has changed. Overrides are now applied dynamically and bb.data.update_data() is now a no-op. Thus, bb.data.update_data() is no longer required in order to apply the correct overrides. In practice, this change is unlikely to require any changes to Metadata. However, these minor changes in behavior exist:

  • All potential overrides are now visible in the variable history as seen when you run the following:

         $ bitbake -e
                        

  • d.delVar('VARNAME') and d.setVar('VARNAME', None) result in the variable and all of its overrides being cleared out. Before the change, only the non-overridden values were cleared.

5.8.5. Shell Message Function Changes

The shell versions of the BitBake message functions (i.e. bbdebug, bbnote, bbwarn, bbplain, bberror, and bbfatal) are now connected through to their BitBake equivalents bb.debug(), bb.note(), bb.warn(), bb.plain(), bb.error(), and bb.fatal(), respectively. Thus, those message functions that you would expect to be printed by the BitBake UI are now actually printed. In practice, this change means two things:

  • If you now see messages on the console that you did not previously see as a result of this change, you might need to clean up the calls to bbwarn, bberror, and so forth. Or, you might want to simply remove the calls.

  • The bbfatal message function now suppresses the full error log in the UI, which means any calls to bbfatal where you still wish to see the full error log should be replaced by die or bbfatal_log.

5.8.6. Extra Development/Debug Package Cleanup

The following recipes have had extra dev/dbg packages removed:

  • acl

  • apmd

  • aspell

  • attr

  • augeas

  • bzip2

  • cogl

  • curl

  • elfutils

  • gcc-target

  • libgcc

  • libtool

  • libxmu

  • opkg

  • pciutils

  • rpm

  • sysfsutils

  • tiff

  • xz

All of the above recipes now conform to the standard packaging scheme where a single -dev, -dbg, and -staticdev package exists per recipe.

5.8.7. Recipe Maintenance Tracking Data Moved to OE-Core

Maintenance tracking data for recipes that was previously part of meta-yocto has been moved to OE-Core. The change includes package_regex.inc and distro_alias.inc, which are typically enabled when using the distrodata class. Additionally, the contents of upstream_tracking.inc has now been split out to the relevant recipes.

5.8.8. Automatic Stale Sysroot File Cleanup

Stale files from recipes that no longer exist in the current configuration are now automatically removed from sysroot as well as removed from any other place managed by shared state. This automatic cleanup means that the build system now properly handles situations such as renaming the build system side of recipes, removal of layers from bblayers.conf, and DISTRO_FEATURES changes.

Additionally, work directories for old versions of recipes are now pruned. If you wish to disable pruning old work directories, you can set the following variable in your configuration:

     SSTATE_PRUNE_OBSOLETEWORKDIR = "0"
            

5.8.9. linux-yocto Kernel Metadata Repository Now Split from Source

The linux-yocto tree has up to now been a combined set of kernel changes and configuration (meta) data carried in a single tree. While this format is effective at keeping kernel configuration and source modifications synchronized, it is not always obvious to developers how to manipulate the Metadata as compared to the source.

Metadata processing has now been removed from the kernel-yocto class and the external Metadata repository yocto-kernel-cache, which has always been used to seed the linux-yocto "meta" branch. This separate linux-yocto cache repository is now the primary location for this data. Due to this change, linux-yocto is no longer able to process combined trees. Thus, if you need to have your own combined kernel repository, you must do the split there as well and update your recipes accordingly. See the meta/recipes-kernel/linux/linux-yocto_4.1.bb recipe for an example.

5.8.10. Additional QA checks

The following QA checks have been added:

  • Added a "host-user-contaminated" check for ownership issues for packaged files outside of /home. The check looks for files that are incorrectly owned by the user that ran BitBake instead of owned by a valid user in the target system.

  • Added an "invalid-chars" check for invalid (non-UTF8) characters in recipe metadata variable values (i.e. DESCRIPTION, SUMMARY, LICENSE, and SECTION). Some package managers do not support these characters.

  • Added an "invalid-packageconfig" check for any options specified in PACKAGECONFIG that do not match any PACKAGECONFIG option defined for the recipe.

5.8.11. Miscellaneous Changes

These additional changes exist:

  • gtk-update-icon-cache has been renamed to gtk-icon-utils.

  • The tools-profile IMAGE_FEATURES item as well as its corresponding packagegroup and packagegroup-core-tools-profile no longer bring in oprofile. Bringing in oprofile was originally added to aid compilation on resource-constrained targets. However, this aid has not been widely used and is not likely to be used going forward due to the more powerful target platforms and the existence of better cross-compilation tools.

  • The IMAGE_FSTYPES variable's default value now specifies ext4 instead of ext3.

  • All support for the PRINC variable has been removed.

  • The packagegroup-core-full-cmdline packagegroup no longer brings in lighttpd due to the fact that bringing in lighttpd is not really in line with the packagegroup's purpose, which is to add full versions of command-line tools that by default are provided by busybox.

5.9. Moving to the Yocto Project 2.1 Release

This section provides migration information for moving to the Yocto Project 2.1 Release from the prior release.

5.9.1. Variable Expansion in Python Functions

Variable expressions, such as ${VARNAME} no longer expand automatically within Python functions. Suppressing expansion was done to allow Python functions to construct shell scripts or other code for situations in which you do not want such expressions expanded. For any existing code that relies on these expansions, you need to change the expansions to expand the value of individual variables through d.getVar(). To alternatively expand more complex expressions, use d.expand().

5.9.2. Overrides Must Now be Lower-Case

The convention for overrides has always been for them to be lower-case characters. This practice is now a requirement as BitBake's datastore now assumes lower-case characters in order to give a slight performance boost during parsing. In practical terms, this requirement means that anything that ends up in OVERRIDES must now appear in lower-case characters (e.g. values for MACHINE, TARGET_ARCH, DISTRO, and also recipe names if _pn-recipename overrides are to be effective).

5.9.3. Expand Parameter to getVar() and getVarFlag() is Now Mandatory

The expand parameter to getVar() and getVarFlag() previously defaulted to False if not specified. Now, however, no default exists so one must be specified. You must change any getVar() calls that do not specify the final expand parameter to calls that do specify the parameter. You can run the following sed command at the base of a layer to make this change:

     sed -e 's:\(\.getVar([^,()]*\)):\1, False):g' -i `grep -ril getVar *`
     sed -e 's:\(\.getVarFlag([^,()]*, [^,()]*\)):\1, False):g' -i `grep -ril getVarFlag *`
            

Note

The reason for this change is that it prepares the way for changing the default to True in a future Yocto Project release. This future change is a much more sensible default than False. However, the change needs to be made gradually as a sudden change of the default would potentially cause side-effects that would be difficult to detect.

5.9.4. Makefile Environment Changes

EXTRA_OEMAKE now defaults to "" instead of "-e MAKEFLAGS=". Setting EXTRA_OEMAKE to "-e MAKEFLAGS=" by default was a historical accident that has required many classes (e.g. autotools, module) and recipes to override this default in order to work with sensible build systems. When upgrading to the release, you must edit any recipe that relies upon this old default by either setting EXTRA_OEMAKE back to "-e MAKEFLAGS=" or by explicitly setting any required variable value overrides using EXTRA_OEMAKE, which is typically only needed when a Makefile sets a default value for a variable that is inappropriate for cross-compilation using the "=" operator rather than the "?=" operator.

5.9.5. libexecdir Reverted to ${prefix}/libexec

The use of ${libdir}/${BPN} as libexecdir is different as compared to all other mainstream distributions, which either uses ${prefix}/libexec or ${libdir}. The use is also contrary to the GNU Coding Standards (i.e. https://www.gnu.org/prep/standards/html_node/Directory-Variables.html) that suggest ${prefix}/libexec and also notes that any package-specific nesting should be done by the package itself. Finally, having libexecdir change between recipes makes it very difficult for different recipes to invoke binaries that have been installed into libexecdir. The Filesystem Hierarchy Standard (i.e. http://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch04s07.html) now recognizes the use of ${prefix}/libexec/, giving distributions the choice between ${prefix}/lib or ${prefix}/libexec without breaking FHS.

5.9.6. ac_cv_sizeof_off_t is No Longer Cached in Site Files

For recipes inheriting the autotools class, ac_cv_sizeof_off_t is no longer cached in the site files for autoconf. The reason for this change is because the ac_cv_sizeof_off_t value is not necessarily static per architecture as was previously assumed. Rather, the value changes based on whether large file support is enabled. For most software that uses autoconf, this change should not be a problem. However, if you have a recipe that bypasses the standard do_configure task from the autotools class and the software the recipe is building uses a very old version of autoconf, the recipe might be incapable of determining the correct size of off_t during do_configure.

The best course of action is to patch the software as necessary to allow the default implementation from the autotools class to work such that autoreconf succeeds and produces a working configure script, and to remove the overridden do_configure task such that the default implementation does get used.

5.9.7. Image Generation is Now Split Out from Filesystem Generation

Previously, for image recipes the do_rootfs task assembled the filesystem and then from that filesystem generated images. With this Yocto Project release, image generation is split into separate do_image_* tasks for clarity both in operation and in the code.

For most cases, this change does not present any problems. However, if you have made customizations that directly modify the do_rootfs task or that mention do_rootfs, you might need to update those changes. In particular, if you had added any tasks after do_rootfs, you should make edits so that those tasks are after the do_image_complete task rather than after do_rootfs so that the your added tasks run at the correct time.

A minor part of this restructuring is that the post-processing definitions and functions have been moved from the image class to the rootfs-postcommands class. Functionally, however, they remain unchanged.

5.9.8. Removed Recipes

The following recipes have been removed in the 2.1 release:

  • gcc version 4.8: Versions 4.9 and 5.3 remain.

  • qt4: All support for Qt 4.x has been moved out to a separate meta-qt4 layer because Qt 4 is no longer supported upstream.

  • x11vnc: Moved to the meta-oe layer.

  • linux-yocto-3.14: No longer supported.

  • linux-yocto-3.19: No longer supported.

  • libjpeg: Replaced by the libjpeg-turbo recipe.

  • pth: Became obsolete.

  • liboil: Recipe is no longer needed and has been moved to the meta-multimedia layer.

  • gtk-theme-torturer: Recipe is no longer needed and has been moved to the meta-gnome layer.

  • gnome-mime-data: Recipe is no longer needed and has been moved to the meta-gnome layer.

  • udev: Replaced by the eudev recipe for compatibility when using sysvinit with newer kernels.

  • python-pygtk: Recipe became obsolete.

  • adt-installer: Recipe became obsolete. See the "ADT Removed" section for more information.

5.9.9. Class Changes

The following classes have changed:

  • autotools_stage: Removed because the autotools class now provides its functionality. Recipes that inherited from autotools_stage should now inherit from autotools instead.

  • boot-directdisk: Merged into the image-vm class. The boot-directdisk class was rarely directly used. Consequently, this change should not cause any issues.

  • bootimg: Merged into the image-live class. The bootimg class was rarely directly used. Consequently, this change should not cause any issues.

  • packageinfo: Removed due to its limited use by the Hob UI, which has itself been removed.

5.9.10. Build System User Interface Changes

The following changes have been made to the build system user interface:

  • Hob GTK+-based UI: Removed because it is unmaintained and based on the outdated GTK+ 2 library. The Toaster web-based UI is much more capable and is actively maintained. See the "Using the Toaster Web Interface" section in the Yocto Project Toaster User Manual for more information on this interface.

  • "puccho" BitBake UI: Removed because is unmaintained and no longer useful.

5.9.11. ADT Removed

The Application Development Toolkit (ADT) has been removed because its functionality almost completely overlapped with the standard SDK and the extensible SDK. For information on these SDKs and how to build and use them, see the Yocto Project Software Development Kit (SDK) Developer's Guide.

Note

The Yocto Project Eclipse IDE Plug-in is still supported and is not affected by this change.

5.9.12. Poky Reference Distribution Changes

The following changes have been made for the Poky distribution:

  • The meta-yocto layer has been renamed to meta-poky to better match its purpose, which is to provide the Poky reference distribution. The meta-yocto-bsp layer retains its original name since it provides reference machines for the Yocto Project and it is otherwise unrelated to Poky. References to meta-yocto in your conf/bblayers.conf should automatically be updated, so you should not need to change anything unless you are relying on this naming elsewhere.

  • The uninative class is now enabled by default in Poky. This class attempts to isolate the build system from the host distribution's C library and makes re-use of native shared state artifacts across different host distributions practical. With this class enabled, a tarball containing a pre-built C library is downloaded at the start of the build.

    The uninative class is enabled through the meta/conf/distro/include/yocto-uninative.inc file, which for those not using the Poky distribution, can include to easily enable the same functionality.

    Alternatively, if you wish to build your own uninative tarball, you can do so by building the uninative-tarball recipe, making it available to your build machines (e.g. over HTTP/HTTPS) and setting a similar configuration as the one set by yocto-uninative.inc.

  • Static library generation, for most cases, is now disabled by default in the Poky distribution. Disabling this generation saves some build time as well as the size used for build output artifacts.

    Disabling this library generation is accomplished through a meta/conf/distro/include/no-static-libs.inc, which for those not using the Poky distribution can easily include to enable the same functionality.

    Any recipe that needs to opt-out of having the "--disable-static" option specified on the configure command line either because it is not a supported option for the configure script or because static libraries are needed should set the following variable:

         DISABLE_STATIC = ""
                        

  • The separate poky-tiny distribution now uses the musl C library instead of a heavily pared down glibc. Using musl results in a smaller distribution and facilitates much greater maintainability because musl is designed to have a small footprint.

    If you have used poky-tiny and have customized the glibc configuration you will need to redo those customizations with musl when upgrading to the new release.

5.9.13. Packaging Changes

The following changes have been made to packaging:

  • The runuser and mountpoint binaries, which were previously in the main util-linux package, have been split out into the util-linux-runuser and util-linux-mountpoint packages, respectively.

  • The python-elementtree package has been merged into the python-xml package.

5.9.14. Tuning File Changes

The following changes have been made to the tuning files:

  • The "no-thumb-interwork" tuning feature has been dropped from the ARM tune include files. Because interworking is required for ARM EABI, attempting to disable it through a tuning feature no longer makes sense.

    Note

    Support for ARM OABI was deprecated in gcc 4.7.

  • The tune-cortexm*.inc and tune-cortexr4.inc files have been removed because they are poorly tested. Until the OpenEmbedded build system officially gains support for CPUs without an MMU, these tuning files would probably be better maintained in a separate layer if needed.

5.9.15. Supporting GObject Introspection

This release supports generation of GLib Introspective Repository (GIR) files through GObject introspection, which is the standard mechanism for accessing GObject-based software from runtime environments. You can enable, disable, and test the generation of this data. See the "Enabling GObject Introspection Support" section for more information.

5.9.16. Miscellaneous Changes

These additional changes exist:

  • The minimum Git version has been increased to 1.8.3.1. If your host distribution does not provide a sufficiently recent version, you can install the buildtools, which will provide it. See the "Required Git, tar, and Python Versions" section for more information on the buildtools tarball.

  • The buggy and incomplete support for the RPM version 4 package manager has been removed. The well-tested and maintained support for RPM version 5 remains.

  • Previously, the following list of packages were removed if package-management was not in IMAGE_FEATURES, regardless of any dependencies:

         update-rc.d
         base-passwd
         shadow
         update-alternatives
         run-postinsts
                        

    With the Yocto Project 2.1 release, these packages are only removed if "read-only-rootfs" is in IMAGE_FEATURES, since they might still be needed for a read-write image even in the absence of a package manager (e.g. if users need to be added, modified, or removed at runtime).

  • The devtool modify command now defaults to extracting the source since that is most commonly expected. The "-x" or "--extract" options are now no-ops. If you wish to provide your own existing source tree, you will now need to specify either the "-n" or "--no-extract" options when running devtool modify.

  • If the formfactor for a machine is either not supplied or does not specify whether a keyboard is attached, then the default is to assume a keyboard is attached rather than assume no keyboard. This change primarily affects the Sato UI.

  • The .debug directory packaging is now automatic. If your recipe builds software that installs binaries into directories other than the standard ones, you no longer need to take care of setting FILES_${PN}-dbg to pick up the resulting .debug directories as these directories are automatically found and added.

  • Inaccurate disk and CPU percentage data has been dropped from buildstats output. This data has been replaced with getrusage() data and corrected IO statistics. You will probably need to update any custom code that reads the buildstats data.

  • The meta/conf/distro/include/package_regex.inc is now deprecated. The contents of this file have been moved to individual recipes.

    Tip

    Because this file will likely be removed in a future Yocto Project release, it is suggested that you remove any references to the file that might be in your configuration.

  • The v86d/uvesafb has been removed from the genericx86 and genericx86-64 reference machines, which are provided by the meta-yocto-bsp layer. Most modern x86 boards do not rely on this file and it only adds kernel error messages during startup. If you do still need to support uvesafb, you can simply add v86d to your image.

  • Build sysroot paths are now removed from debug symbol files. Removing these paths means that remote GDB using an unstripped build system sysroot will no longer work (although this was never documented to work). The supported method to accomplish something similar is to set IMAGE_GEN_DEBUGFS to "1", which will generate a companion debug image containing unstripped binaries and associated debug sources alongside the image.

5.10. Moving to the Yocto Project 2.2 Release

This section provides migration information for moving to the Yocto Project 2.2 Release from the prior release.

5.10.1. Minimum Kernel Version

The minimum kernel version for the target system and for SDK is now 3.2.0, due to the upgrade to glibc 2.24. Specifically, for AArch64-based targets the version is 3.14. For Nios II-based targets, the minimum kernel version is 3.19.

Note

For x86 and x86_64, you can reset OLDEST_KERNEL to anything down to 2.6.32 if desired.

5.10.2. Staging Directories in Sysroot Has Been Simplified

The way directories are staged in sysroot has been simplified and introduces the new SYSROOT_DIRS, SYSROOT_DIRS_NATIVE, and SYSROOT_DIRS_BLACKLIST. See the v2 patch series on the OE-Core Mailing List for additional information.

5.10.3. Removal of Old Images and Other Files in tmp/deploy Now Enabled

Removal of old images and other files in tmp/deploy/ is now enabled by default due to a new staging method used for those files. As a result of this change, the RM_OLD_IMAGE variable is now redundant.

5.10.4. Python Changes

The following changes for Python occurred:

5.10.4.1. BitBake Now Requires Python 3.4+

BitBake requires Python 3.4 or greater.

5.10.4.2. UTF-8 Locale Required on Build Host

A UTF-8 locale is required on the build host due to Python 3. Since C.UTF-8 is not a standard, the default is en_US.UTF-8.

5.10.4.3. Metadata Must Now Use Python 3 Syntax

The metadata is now required to use Python 3 syntax. For help preparing metadata, see any of the many Python 3 porting guides available. Alternatively, you can reference the conversion commits for Bitbake and you can use OE-Core as a guide for changes. Following are particular areas of interest:

     * subprocess command-line pipes needing locale decoding
     * the syntax for octal values changed
     * the iter*() functions changed name
     * iterators now return views, not lists
     * changed names for Python modules
                

5.10.4.4. Target Python Recipes Switched to Python 3

Most target Python recipes have now been switched to Python 3. Unfortunately, systems using RPM as a package manager and providing online package-manager support through SMART still require Python 2.

Note

Python 2 and recipes that use it can still be built for the target as with previous versions.

5.10.4.5. buildtools-tarball Includes Python 3

buildtools-tarball now includes Python 3.

5.10.5. uClibc Replaced by musl

uClibc has been removed in favor of musl. Musl has matured, is better maintained, and is compatible with a wider range of applications as compared to uClibc.

5.10.6. ${B} No Longer Default Working Directory for Tasks

${B} is no longer the default working directory for tasks. Consequently, any custom tasks you define now need to either have the [dirs] flag set, or the task needs to change into the appropriate working directory manually (e.g using cd for a shell task).

Note

The preferred method is to use the [dirs] flag.

5.10.7. runqemu Ported to Python

runqemu has been ported to Python and has changed behavior in some cases. Previous usage patterns continue to be supported.

The new runqemu is a Python script. Machine knowledge is no longer hardcoded into runqemu. You can choose to use the qemuboot configuration file to define the BSP's own arguments and to make it bootable with runqemu. If you use a configuration file, use the following form:

     image-name-machine.qemuboot.conf
            

The configuration file enables fine-grained tuning of options passed to QEMU without the runqemu script hard-coding any knowledge about different machines. Using a configuration file is particularly convenient when trying to use QEMU with machines other than the qemu* machines in OE-Core. The qemuboot.conf file is generated by the qemuboot class when the root filesystem is being build (i.e. build rootfs). QEMU boot arguments can be set in BSP's configuration file and the qemuboot class will save them to qemuboot.conf.

If you want to use runqemu without a configuration file, use the following command form:

     $ runqemu machine rootfs kernel [options]
            

Supported machines are as follows:

     qemuarm
     qemuarm64
     qemux86
     qemux86-64
     qemuppc
     qemumips
     qemumips64
     qemumipsel
     qemumips64el
            

Consider the following example, which uses the qemux86-64 machine, provides a root filesystem, provides an image, and uses the nographic option:

$ runqemu qemux86-64 tmp/deploy/images/qemux86-64/core-image-minimal-qemux86-64.ext4 tmp/deploy/images/qemux86-64/bzImage nographic
            

Following is a list of variables that can be set in configuration files such as bsp.conf to enable the BSP to be booted by runqemu:

Note

"QB" means "QEMU Boot".

     QB_SYSTEM_NAME: QEMU name (e.g. "qemu-system-i386")
     QB_OPT_APPEND: Options to append to QEMU (e.g. "-show-cursor")
     QB_DEFAULT_KERNEL: Default kernel to boot (e.g. "bzImage")
     QB_DEFAULT_FSTYPE: Default FSTYPE to boot (e.g. "ext4")
     QB_MEM: Memory (e.g. "-m 512")
     QB_MACHINE: QEMU machine (e.g. "-machine virt")
     QB_CPU: QEMU cpu (e.g. "-cpu qemu32")
     QB_CPU_KVM: Similar to QB_CPU except used for kvm support (e.g. "-cpu kvm64")
     QB_KERNEL_CMDLINE_APPEND: Options to append to the kernel's -append
                               option (e.g. "console=ttyS0 console=tty")
     QB_DTB: QEMU dtb name
     QB_AUDIO_DRV: QEMU audio driver (e.g. "alsa", set it when support audio)
     QB_AUDIO_OPT: QEMU audio option (e.g. "-soundhw ac97,es1370"), which is used
                   when QB_AUDIO_DRV is set.
     QB_KERNEL_ROOT: Kernel's root (e.g. /dev/vda)
     QB_TAP_OPT: Network option for 'tap' mode (e.g.
                 "-netdev tap,id=net0,ifname=@TAP@,script=no,downscript=no -device virtio-net-device,netdev=net0").
                  runqemu will replace "@TAP@" with the one that is used, such as tap0, tap1 ...
     QB_SLIRP_OPT: Network option for SLIRP mode (e.g. "-netdev user,id=net0 -device virtio-net-device,netdev=net0")
     QB_ROOTFS_OPT: Used as rootfs (e.g.
                    "-drive id=disk0,file=@ROOTFS@,if=none,format=raw -device virtio-blk-device,drive=disk0").
                    runqemu will replace "@ROOTFS@" with the one which is used, such as
                    core-image-minimal-qemuarm64.ext4.
     QB_SERIAL_OPT: Serial port (e.g. "-serial mon:stdio")
     QB_TCPSERIAL_OPT: tcp serial port option (e.g.
                       " -device virtio-serial-device -chardev socket,id=virtcon,port=@PORT@,host=127.0.0.1 -device      virtconsole,chardev=virtcon"
                       runqemu will replace "@PORT@" with the port number which is used.
            

To use runqemu, set IMAGE_CLASSES as follows and run runqemu:

Note

For command-line syntax, use runqemu help.

     IMAGE_CLASSES += "qemuboot"
            

5.10.8. Default Linker Hash Style Changed

The default linker hash style for gcc-cross is now "sysv" in order to catch recipes that are building software without using the OpenEmbedded LDFLAGS. This change could result in seeing some "No GNU_HASH in the elf binary" QA issues when building such recipes. You need to fix these recipes so that they use the expected LDFLAGS. Depending on how the software is built, the build system used by the software (e.g. a Makefile) might need to be patched. However, sometimes making this fix is as simple as adding the following to the recipe:

     TARGET_CC_ARCH += "${LDFLAGS}"
            

5.10.9. KERNEL_IMAGE_BASE_NAME no Longer Uses KERNEL_IMAGETYPE

The KERNEL_IMAGE_BASE_NAME variable no longer uses the KERNEL_IMAGETYPE variable to create the image's base name. Because the OpenEmbedded build system can now build multiple kernel image types, this part of the kernel image base name as been removed leaving only the following:

     KERNEL_IMAGE_BASE_NAME ?= "${PKGE}-${PKGV}-${PKGR}-${MACHINE}-${DATETIME}
            

If you have recipes or classes that use KERNEL_IMAGE_BASE_NAME directly, you might need to update the references to ensure they continue to work.

5.10.10. BitBake Changes

The following changes took place for BitBake:

  • The "goggle" UI and standalone image-writer tool have been removed as they both require GTK+ 2.0 and were not being maintained.

  • The Perforce fetcher now supports SRCREV for specifying the source revision to use, be it ${AUTOREV}, changelist number, p4date, or label, in preference to separate SRC_URI parameters to specify these. This change is more in-line with how the other fetchers work for source control systems. Recipes that fetch from Perforce will need to be updated to use SRCREV in place of specifying the source revision within SRC_URI.

  • Some of BitBake's internal code structures for accessing the recipe cache needed to be changed to support the new multi-configuration functionality. These changes will affect external tools that use BitBake's tinfoil module. For information on these changes, see the changes made to the scripts supplied with OpenEmbedded-Core: 1 and 2.

  • The task management code has been rewritten to avoid using ID indirection in order to improve performance. This change is unlikely to cause any problems for most users. However, the setscene verification function as pointed to by BB_SETSCENE_VERIFY_FUNCTION needed to change signature. Consequently, a new variable named BB_SETSCENE_VERIFY_FUNCTION2 has been added allowing multiple versions of BitBake to work with suitably written metadata, which includes OpenEmbedded-Core and Poky. Anyone with custom BitBake task scheduler code might also need to update the code to handle the new structure.

5.10.11. Swabber has Been Removed

Swabber, a tool that was intended to detect host contamination in the build process, has been removed, as it has been unmaintained and unused for some time and was never particularly effective. The OpenEmbedded build system has since incorporated a number of mechanisms including enhanced QA checks that mean that there is less of a need for such a tool.

5.10.12. Removed Recipes

The following recipes have been removed:

  • augeas: No longer needed and has been moved to meta-oe.

  • directfb: Unmaintained and has been moved to meta-oe.

  • gcc: Removed 4.9 version. Versions 5.4 and 6.2 are still present.

  • gnome-doc-utils: No longer needed.

  • gtk-doc-stub: Replaced by gtk-doc.

  • gtk-engines: No longer needed and has been moved to meta-gnome.

  • gtk-sato-engine: Became obsolete.

  • libglade: No longer needed and has been moved to meta-oe.

  • libmad: Unmaintained and functionally replaced by libmpg123. libmad has been moved to meta-oe.

  • libowl: Became obsolete.

  • libxsettings-client: No longer needed.

  • oh-puzzles: Functionally replaced by puzzles.

  • oprofileui: Became obsolete. OProfile has been largely supplanted by perf.

  • packagegroup-core-directfb.bb: Removed.

  • core-image-directfb.bb: Removed.

  • pointercal: No longer needed and has been moved to meta-oe.

  • python-imaging: No longer needed and moved to meta-python

  • python-pyrex: No longer needed and moved to meta-python.

  • sato-icon-theme: Became obsolete.

  • swabber-native: Swabber has been removed. See the entry on Swabber.

  • tslib: No longer needed and has been moved to meta-oe.

  • uclibc: Removed in favor of musl.

  • xtscal: No longer needed and moved to meta-oe

5.10.13. Removed Classes

The following classes have been removed:

  • distutils-native-base: No longer needed.

  • distutils3-native-base: No longer needed.

  • sdl: Only set DEPENDS and SECTION, which are better set within the recipe instead.

  • sip: Mostly unused.

  • swabber: See the entry on Swabber.

5.10.14. Minor Packaging Changes

The following minor packaging changes have occurred:

  • grub: Split grub-editenv into its own package.

  • systemd: Split container and vm related units into a new package, systemd-container.

  • util-linux: Moved prlimit to a separate util-linux-prlimit package.

5.10.15. Miscellaneous Changes

The following miscellaneous changes have occurred:

  • package_regex.inc: Removed because the definitions package_regex.inc previously contained have been moved to their respective recipes.

  • Both devtool add and recipetool create now use a fixed SRCREV by default when fetching from a Git repository. You can override this in either case to use ${AUTOREV} instead by using the -a or ‐‐autorev command-line option

  • distcc: GTK+ UI is now disabled by default.

  • packagegroup-core-tools-testapps: Removed Piglit.

  • image.bbclass: Renamed COMPRESS(ION) to CONVERSION. This change means that COMPRESSIONTYPES, COMPRESS_DEPENDS and COMPRESS_CMD are deprecated in favor of CONVERSIONTYPES, CONVERSION_DEPENDS and CONVERSION_CMD. The COMPRESS* variable names will still work in the 2.2 release but metadata that does not need to be backwards-compatible should be changed to use the new names as the COMPRESS* ones will be removed in a future release.

  • gtk-doc: A full version of gtk-doc is now made available. However, some old software might not be capable of using the current version of gtk-doc to build documentation. You need to change recipes that build such software so that they explicitly disable building documentation with gtk-doc.

Chapter 6. Source Directory Structure

Table of Contents

6.1. Top-Level Core Components
6.1.1. bitbake/
6.1.2. build/
6.1.3. documentation/
6.1.4. meta/
6.1.5. meta-poky/
6.1.6. meta-yocto-bsp/
6.1.7. meta-selftest/
6.1.8. meta-skeleton/
6.1.9. scripts/
6.1.10. oe-init-build-env
6.1.11. oe-init-build-env-memres
6.1.12. LICENSE, README, and README.hardware
6.2. The Build Directory - build/
6.2.1. build/buildhistory
6.2.2. build/conf/local.conf
6.2.3. build/conf/bblayers.conf
6.2.4. build/conf/sanity_info
6.2.5. build/downloads/
6.2.6. build/sstate-cache/
6.2.7. build/tmp/
6.2.8. build/tmp/buildstats/
6.2.9. build/tmp/cache/
6.2.10. build/tmp/deploy/
6.2.11. build/tmp/deploy/deb/
6.2.12. build/tmp/deploy/rpm/
6.2.13. build/tmp/deploy/ipk/
6.2.14. build/tmp/deploy/licenses/
6.2.15. build/tmp/deploy/images/
6.2.16. build/tmp/deploy/sdk/
6.2.17. build/tmp/sstate-control/
6.2.18. build/tmp/sysroots/
6.2.19. build/tmp/stamps/
6.2.20. build/tmp/log/
6.2.21. build/tmp/work/
6.2.22. build/tmp/work-shared/
6.3. The Metadata - meta/
6.3.1. meta/classes/
6.3.2. meta/conf/
6.3.3. meta/conf/machine/
6.3.4. meta/conf/distro/
6.3.5. meta/conf/machine-sdk/
6.3.6. meta/files/
6.3.7. meta/lib/
6.3.8. meta/recipes-bsp/
6.3.9. meta/recipes-connectivity/
6.3.10. meta/recipes-core/
6.3.11. meta/recipes-devtools/
6.3.12. meta/recipes-extended/
6.3.13. meta/recipes-gnome/
6.3.14. meta/recipes-graphics/
6.3.15. meta/recipes-kernel/
6.3.16. meta/recipes-lsb4/
6.3.17. meta/recipes-multimedia/
6.3.18. meta/recipes-rt/
6.3.19. meta/recipes-sato/
6.3.20. meta/recipes-support/
6.3.21. meta/site/
6.3.22. meta/recipes.txt

The Source Directory consists of several components. Understanding them and knowing where they are located is key to using the Yocto Project well. This chapter describes the Source Directory and gives information about the various files and directories.

For information on how to establish a local Source Directory on your development system, see the "Getting Set Up" section in the Yocto Project Development Manual.

Note

The OpenEmbedded build system does not support file or directory names that contain spaces. Be sure that the Source Directory you use does not contain these types of names.

6.1. Top-Level Core Components

This section describes the top-level components of the Source Directory.

6.1.1. bitbake/

This directory includes a copy of BitBake for ease of use. The copy usually matches the current stable BitBake release from the BitBake project. BitBake, a Metadata interpreter, reads the Yocto Project Metadata and runs the tasks defined by that data. Failures are usually from the Metadata and not from BitBake itself. Consequently, most users do not need to worry about BitBake.

When you run the bitbake command, the main BitBake executable, which resides in the bitbake/bin/ directory, starts. Sourcing an environment setup script (e.g. oe-init-build-env or oe-init-build-env-memres) places the scripts and bitbake/bin directories (in that order) into the shell's PATH environment variable.

For more information on BitBake, see the BitBake User Manual.

6.1.2. build/

This directory contains user configuration files and the output generated by the OpenEmbedded build system in its standard configuration where the source tree is combined with the output. The Build Directory is created initially when you source the OpenEmbedded build environment setup script (i.e. oe-init-build-env or oe-init-build-env-memres).

It is also possible to place output and configuration files in a directory separate from the Source Directory by providing a directory name when you source the setup script. For information on separating output from your local Source Directory files, see the "oe-init-build-env and "oe-init-build-env-memres" sections.

6.1.3. documentation/

This directory holds the source for the Yocto Project documentation as well as templates and tools that allow you to generate PDF and HTML versions of the manuals. Each manual is contained in a sub-folder. For example, the files for this manual reside in the ref-manual/ directory.

6.1.4. meta/

This directory contains the OpenEmbedded Core metadata. The directory holds recipes, common classes, and machine configuration for emulated targets (qemux86, qemuarm, and so forth.)

6.1.5. meta-poky/

This directory contains the configuration for the Poky reference distribution.

6.1.6. meta-yocto-bsp/

This directory contains the Yocto Project reference hardware Board Support Packages (BSPs). For more information on BSPs, see the Yocto Project Board Support Package (BSP) Developer's Guide.

6.1.7. meta-selftest/

This directory adds additional recipes and append files used by the OpenEmbedded selftests to verify the behavior of the build system.

You do not have to add this layer to your bblayers.conf file unless you want to run the selftests.

6.1.8. meta-skeleton/

This directory contains template recipes for BSP and kernel development.

6.1.9. scripts/

This directory contains various integration scripts that implement extra functionality in the Yocto Project environment (e.g. QEMU scripts). The oe-init-build-env and oe-init-build-env-memres scripts append this directory to the shell's PATH environment variable.

The scripts directory has useful scripts that assist in contributing back to the Yocto Project, such as create-pull-request and send-pull-request.

6.1.10. oe-init-build-env

This script is one of two scripts that set up the OpenEmbedded build environment. For information on the other script, see the "oe-init-build-env-memres" section.

Running this script with the source command in a shell makes changes to PATH and sets other core BitBake variables based on the current working directory. You need to run an environment setup script before running BitBake commands. The script uses other scripts within the scripts directory to do the bulk of the work.

When you run this script, your Yocto Project environment is set up, a Build Directory is created, your working directory becomes the Build Directory, and you are presented with a list of common BitBake targets. Here is an example:

     $ source oe-init-build-env

     ### Shell environment set up for builds. ###

     You can now run 'bitbake <target>'

     Common targets are:
         core-image-minimal
         core-image-sato
         meta-toolchain
         meta-ide-support

     You can also run generated qemu images with a command like 'runqemu qemux86'
            

The script gets its default list of common targets from the conf-notes.txt file, which is found in the meta-poky directory within the Source Directory. Should you have custom distributions, it is very easy to modify this configuration file to include your targets for your distribution. See the "Creating a Custom Template Configuration Directory" section in the Yocto Project Development Manual for more information.

By default, running this script without a Build Directory argument creates the build directory in your current working directory. If you provide a Build Directory argument when you source the script, you direct the OpenEmbedded build system to create a Build Directory of your choice. For example, the following command creates a Build Directory named mybuilds that is outside of the Source Directory:

     $ source oe-init-build-env ~/mybuilds
            

The OpenEmbedded build system uses the template configuration files, which are found by default in the meta-poky/conf directory in the Source Directory. See the "Creating a Custom Template Configuration Directory" section in the Yocto Project Development Manual for more information.

Note

The OpenEmbedded build system does not support file or directory names that contain spaces. If you attempt to run the oe-init-build-env script from a Source Directory that contains spaces in either the filenames or directory names, the script returns an error indicating no such file or directory. Be sure to use a Source Directory free of names containing spaces.

6.1.11. oe-init-build-env-memres

This script is one of two scripts that set up the OpenEmbedded build environment. Aside from setting up the environment, this script starts a memory-resident BitBake server. For information on the other setup script, see the "oe-init-build-env" section.

Memory-resident BitBake resides in memory until you specifically remove it using the following BitBake command:

     $ bitbake -m
            

Running this script with the source command in a shell makes changes to PATH and sets other core BitBake variables based on the current working directory. One of these variables is the BBSERVER variable, which allows the OpenEmbedded build system to locate the server that is running BitBake.

You need to run an environment setup script before using BitBake commands. Following is the script syntax:

     $ source oe-init-build-env-memres port_number build_dir
            

Following are some considerations when sourcing this script:

  • The script uses other scripts within the scripts directory to do the bulk of the work.

  • If you do not provide a port number with the script, the BitBake server starts at a randomly selected port.

  • The script's parameters are positionally dependent. Consequently, you cannot run the script and provide a Build Directory name without also providing a port number. In other words, the following syntax is illegal:

         $ source oe-initbuild-env-memres build_dir
                        

    Note

    The previous restriction might be resolved in the future. See Bug 7555 for more information.

When you run this script, your Yocto Project environment is set up, a Build Directory is created, your working directory becomes the Build Directory, and you are presented with a list of common BitBake targets. Here is an example:

     $ source oe-init-build-env-memres
     No port specified, using dynamically selected port

     ### Shell environment set up for builds. ###

     You can now run 'bitbake <target>'

     Common targets are:
         core-image-minimal
         core-image-sato
         meta-toolchain
         meta-ide-support

     You can also run generated qemu images with a command like 'runqemu qemux86'
     Bitbake server address: 127.0.0.1, server port: 53995
     Bitbake server started on demand as needed, use bitbake -m to shut it down
            

The script gets its default list of common targets from the conf-notes.txt file, which is found in the meta-poky directory within the Source Directory. Should you have custom distributions, it is very easy to modify this configuration file to include your targets for your distribution. See the "Creating a Custom Template Configuration Directory" section in the Yocto Project Development Manual for more information.

By default, running this script without a Build Directory argument creates a build directory named build. If you provide a Build Directory argument and port number when you source the script, the Build Directory is created using that name. For example, the following command starts the BitBake server using port 53995 and creates a Build Directory named mybuilds that is outside of the Source Directory:

     $ source oe-init-build-env-memres 53995 ~/mybuilds
            

The oe-init-build-env-memres script starts a memory resident BitBake server. This BitBake instance uses the bitbake-cookerdaemon.log file, which is located in the Build Directory.

The OpenEmbedded build system uses the template configuration files, which are found by default in the meta-poky/conf directory in the Source Directory. See the "Creating a Custom Template Configuration Directory" section in the Yocto Project Development Manual for more information.

Note

The OpenEmbedded build system does not support file or directory names that contain spaces. If you attempt to run the oe-init-build-env-memres script from a Source Directory that contains spaces in either the filenames or directory names, the script returns an error indicating no such file or directory. Be sure to use a Source Directory free of names containing spaces.

6.1.12. LICENSE, README, and README.hardware

These files are standard top-level files.

6.2. The Build Directory - build/

The OpenEmbedded build system creates the Build Directory when you run one of the build environment setup scripts (i.e. oe-init-build-env or oe-init-build-env-memres).

If you do not give the Build Directory a specific name when you run a setup script, the name defaults to build.

The TOPDIR variable points to the Build Directory.

6.2.1. build/buildhistory

The OpenEmbedded build system creates this directory when you enable the build history feature. The directory tracks build information into image, packages, and SDK subdirectories. For information on the build history feature, see the "Maintaining Build Output Quality" section.

6.2.2. build/conf/local.conf

This configuration file contains all the local user configurations for your build environment. The local.conf file contains documentation on the various configuration options. Any variable set here overrides any variable set elsewhere within the environment unless that variable is hard-coded within a file (e.g. by using '=' instead of '?='). Some variables are hard-coded for various reasons but these variables are relatively rare.

Edit this file to set the MACHINE for which you want to build, which package types you wish to use (PACKAGE_CLASSES), and the location from which you want to access downloaded files (DL_DIR).

If local.conf is not present when you start the build, the OpenEmbedded build system creates it from local.conf.sample when you source the top-level build environment setup script (i.e. oe-init-build-env or oe-init-build-env-memres).

The source local.conf.sample file used depends on the $TEMPLATECONF script variable, which defaults to meta-poky/conf when you are building from the Yocto Project development environment and defaults to meta/conf when you are building from the OpenEmbedded Core environment. Because the script variable points to the source of the local.conf.sample file, this implies that you can configure your build environment from any layer by setting the variable in the top-level build environment setup script as follows:

     TEMPLATECONF=your_layer/conf
            

Once the build process gets the sample file, it uses sed to substitute final ${OEROOT} values for all ##OEROOT## values.

Note

You can see how the TEMPLATECONF variable is used by looking at the scripts/oe-setup-builddir script in the Source Directory. You can find the Yocto Project version of the local.conf.sample file in the meta-poky/conf directory.

6.2.3. build/conf/bblayers.conf

This configuration file defines layers, which are directory trees, traversed (or walked) by BitBake. The bblayers.conf file uses the BBLAYERS variable to list the layers BitBake tries to find.

If bblayers.conf is not present when you start the build, the OpenEmbedded build system creates it from bblayers.conf.sample when you source the top-level build environment setup script (i.e. oe-init-build-env or oe-init-build-env-memres).

The source bblayers.conf.sample file used depends on the $TEMPLATECONF script variable, which defaults to meta-poky/conf when you are building from the Yocto Project development environment and defaults to meta/conf when you are building from the OpenEmbedded Core environment. Because the script variable points to the source of the bblayers.conf.sample file, this implies that you can base your build from any layer by setting the variable in the top-level build environment setup script as follows:

     TEMPLATECONF=your_layer/conf
            

Once the build process gets the sample file, it uses sed to substitute final ${OEROOT} values for all ##OEROOT## values.

Note

You can see how the TEMPLATECONF variable scripts/oe-setup-builddir script in the Source Directory. You can find the Yocto Project version of the bblayers.conf.sample file in the meta-poky/conf directory.

6.2.4. build/conf/sanity_info

This file indicates the state of the sanity checks and is created during the build.

6.2.5. build/downloads/

This directory contains downloaded upstream source tarballs. You can reuse the directory for multiple builds or move the directory to another location. You can control the location of this directory through the DL_DIR variable.

6.2.6. build/sstate-cache/

This directory contains the shared state cache. You can reuse the directory for multiple builds or move the directory to another location. You can control the location of this directory through the SSTATE_DIR variable.

6.2.7. build/tmp/

The OpenEmbedded build system creates and uses this directory for all the build system's output. The TMPDIR variable points to this directory.

BitBake creates this directory if it does not exist. As a last resort, to clean up a build and start it from scratch (other than the downloads), you can remove everything in the tmp directory or get rid of the directory completely. If you do, you should also completely remove the build/sstate-cache directory.

6.2.8. build/tmp/buildstats/

This directory stores the build statistics.

6.2.9. build/tmp/cache/

When BitBake parses the metadata (recipes and configuration files), it caches the results in build/tmp/cache/ to speed up future builds. The results are stored on a per-machine basis.

During subsequent builds, BitBake checks each recipe (together with, for example, any files included or appended to it) to see if they have been modified. Changes can be detected, for example, through file modification time (mtime) changes and hashing of file contents. If no changes to the file are detected, then the parsed result stored in the cache is reused. If the file has changed, it is reparsed.

6.2.10. build/tmp/deploy/

This directory contains any "end result" output from the OpenEmbedded build process. The DEPLOY_DIR variable points to this directory. For more detail on the contents of the deploy directory, see the "Images" and "Application Development SDK" sections.

6.2.11. build/tmp/deploy/deb/

This directory receives any .deb packages produced by the build process. The packages are sorted into feeds for different architecture types.

6.2.12. build/tmp/deploy/rpm/

This directory receives any .rpm packages produced by the build process. The packages are sorted into feeds for different architecture types.

6.2.13. build/tmp/deploy/ipk/

This directory receives .ipk packages produced by the build process.

6.2.14. build/tmp/deploy/licenses/

This directory receives package licensing information. For example, the directory contains sub-directories for bash, busybox, and glibc (among others) that in turn contain appropriate COPYING license files with other licensing information. For information on licensing, see the "Maintaining Open Source License Compliance During Your Product's Lifecycle" section.

6.2.15. build/tmp/deploy/images/

This directory receives complete filesystem images. If you want to flash the resulting image from a build onto a device, look here for the image.

Be careful when deleting files in this directory. You can safely delete old images from this directory (e.g. core-image-*). However, the kernel (*zImage*, *uImage*, etc.), bootloader and other supplementary files might be deployed here prior to building an image. Because these files are not directly produced from the image, if you delete them they will not be automatically re-created when you build the image again.

If you do accidentally delete files here, you will need to force them to be re-created. In order to do that, you will need to know the target that produced them. For example, these commands rebuild and re-create the kernel files:

     $ bitbake -c clean virtual/kernel
     $ bitbake virtual/kernel
            

6.2.16. build/tmp/deploy/sdk/

The OpenEmbedded build system creates this directory to hold toolchain installer scripts, which when executed, install the sysroot that matches your target hardware. You can find out more about these installers in the "Building an SDK Installer" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

6.2.17. build/tmp/sstate-control/

The OpenEmbedded build system uses this directory for the shared state manifest files. The shared state code uses these files to record the files installed by each sstate task so that the files can be removed when cleaning the recipe or when a newer version is about to be installed. The build system also uses the manifests to detect and produce a warning when files from one task are overwriting those from another.

6.2.18. build/tmp/sysroots/

This directory contains shared header files and libraries as well as other shared data. Packages that need to share output with other packages do so within this directory. The directory is subdivided by architecture so multiple builds can run within the one Build Directory.

6.2.19. build/tmp/stamps/

This directory holds information that BitBake uses for accounting purposes to track what tasks have run and when they have run. The directory is sub-divided by architecture, package name, and version. Following is an example:

     stamps/all-poky-linux/distcc-config/1.0-r0.do_build-2fdd....2do
            

Although the files in the directory are empty of data, BitBake uses the filenames and timestamps for tracking purposes.

For information on how BitBake uses stamp files to determine if a task should be rerun, see the "Stamp Files and the Rerunning of Tasks" section.

6.2.20. build/tmp/log/

This directory contains general logs that are not otherwise placed using the package's WORKDIR. Examples of logs are the output from the do_check_pkg or do_distro_check tasks. Running a build does not necessarily mean this directory is created.

6.2.21. build/tmp/work/

This directory contains architecture-specific work sub-directories for packages built by BitBake. All tasks execute from the appropriate work directory. For example, the source for a particular package is unpacked, patched, configured and compiled all within its own work directory. Within the work directory, organization is based on the package group and version for which the source is being compiled as defined by the WORKDIR.

It is worth considering the structure of a typical work directory. As an example, consider linux-yocto-kernel-3.0 on the machine qemux86 built within the Yocto Project. For this package, a work directory of tmp/work/qemux86-poky-linux/linux-yocto/3.0+git1+<.....>, referred to as the WORKDIR, is created. Within this directory, the source is unpacked to linux-qemux86-standard-build and then patched by Quilt. (See the "Using Quilt in Your Workflow" section in the Yocto Project Development Manual for more information.) Within the linux-qemux86-standard-build directory, standard Quilt directories linux-3.0/patches and linux-3.0/.pc are created, and standard Quilt commands can be used.

There are other directories generated within WORKDIR. The most important directory is WORKDIR/temp/, which has log files for each task (log.do_*.pid) and contains the scripts BitBake runs for each task (run.do_*.pid). The WORKDIR/image/ directory is where "make install" places its output that is then split into sub-packages within WORKDIR/packages-split/.

6.2.22. build/tmp/work-shared/

For efficiency, the OpenEmbedded build system creates and uses this directory to hold recipes that share a work directory with other recipes. In practice, this is only used for gcc and its variants (e.g. gcc-cross, libgcc, gcc-runtime, and so forth).

6.3. The Metadata - meta/

As mentioned previously, Metadata is the core of the Yocto Project. Metadata has several important subdivisions:

6.3.1. meta/classes/

This directory contains the *.bbclass files. Class files are used to abstract common code so it can be reused by multiple packages. Every package inherits the base.bbclass file. Examples of other important classes are autotools.bbclass, which in theory allows any Autotool-enabled package to work with the Yocto Project with minimal effort. Another example is kernel.bbclass that contains common code and functions for working with the Linux kernel. Functions like image generation or packaging also have their specific class files such as image.bbclass, rootfs_*.bbclass and package*.bbclass.

For reference information on classes, see the "Classes" chapter.

6.3.2. meta/conf/

This directory contains the core set of configuration files that start from bitbake.conf and from which all other configuration files are included. See the include statements at the end of the bitbake.conf file and you will note that even local.conf is loaded from there. While bitbake.conf sets up the defaults, you can often override these by using the (local.conf) file, machine file or the distribution configuration file.

6.3.3. meta/conf/machine/

This directory contains all the machine configuration files. If you set MACHINE = "qemux86", the OpenEmbedded build system looks for a qemux86.conf file in this directory. The include directory contains various data common to multiple machines. If you want to add support for a new machine to the Yocto Project, look in this directory.

6.3.4. meta/conf/distro/

The contents of this directory controls any distribution-specific configurations. For the Yocto Project, the defaultsetup.conf is the main file here. This directory includes the versions and the SRCDATE definitions for applications that are configured here. An example of an alternative configuration might be poky-bleeding.conf. Although this file mainly inherits its configuration from Poky.

6.3.5. meta/conf/machine-sdk/

The OpenEmbedded build system searches this directory for configuration files that correspond to the value of SDKMACHINE. By default, 32-bit and 64-bit x86 files ship with the Yocto Project that support some SDK hosts. However, it is possible to extend that support to other SDK hosts by adding additional configuration files in this subdirectory within another layer.

6.3.6. meta/files/

This directory contains common license files and several text files used by the build system. The text files contain minimal device information and lists of files and directories with known permissions.

6.3.7. meta/lib/

This directory contains OpenEmbedded Python library code used during the build process.

6.3.8. meta/recipes-bsp/

This directory contains anything linking to specific hardware or hardware configuration information such as "u-boot" and "grub".

6.3.9. meta/recipes-connectivity/

This directory contains libraries and applications related to communication with other devices.

6.3.10. meta/recipes-core/

This directory contains what is needed to build a basic working Linux image including commonly used dependencies.

6.3.11. meta/recipes-devtools/

This directory contains tools that are primarily used by the build system. The tools, however, can also be used on targets.

6.3.12. meta/recipes-extended/

This directory contains non-essential applications that add features compared to the alternatives in core. You might need this directory for full tool functionality or for Linux Standard Base (LSB) compliance.

6.3.13. meta/recipes-gnome/

This directory contains all things related to the GTK+ application framework.

6.3.14. meta/recipes-graphics/

This directory contains X and other graphically related system libraries

6.3.15. meta/recipes-kernel/

This directory contains the kernel and generic applications and libraries that have strong kernel dependencies.

6.3.16. meta/recipes-lsb4/

This directory contains recipes specifically added to support the Linux Standard Base (LSB) version 4.x.

6.3.17. meta/recipes-multimedia/

This directory contains codecs and support utilities for audio, images and video.

6.3.18. meta/recipes-rt/

This directory contains package and image recipes for using and testing the PREEMPT_RT kernel.

6.3.19. meta/recipes-sato/

This directory contains the Sato demo/reference UI/UX and its associated applications and configuration data.

6.3.20. meta/recipes-support/

This directory contains recipes used by other recipes, but that are not directly included in images (i.e. dependencies of other recipes).

6.3.21. meta/site/

This directory contains a list of cached results for various architectures. Because certain "autoconf" test results cannot be determined when cross-compiling due to the tests not able to run on a live system, the information in this directory is passed to "autoconf" for the various architectures.

6.3.22. meta/recipes.txt

This file is a description of the contents of recipes-*.

Chapter 7. Classes

Table of Contents

7.1. allarch.bbclass
7.2. archiver.bbclass
7.3. autotools*.bbclass
7.4. base.bbclass
7.5. bash-completion.bbclass
7.6. bin_package.bbclass
7.7. binconfig.bbclass
7.8. binconfig-disabled.bbclass
7.9. blacklist.bbclass
7.10. bluetooth.bbclass
7.11. bugzilla.bbclass
7.12. buildhistory.bbclass
7.13. buildstats.bbclass
7.14. buildstats-summary.bbclass
7.15. ccache.bbclass
7.16. chrpath.bbclass
7.17. clutter.bbclass
7.18. cmake.bbclass
7.19. cml1.bbclass
7.20. compress_doc.bbclass
7.21. copyleft_compliance.bbclass
7.22. copyleft_filter.bbclass
7.23. core-image.bbclass
7.24. cpan*.bbclass
7.25. cross.bbclass
7.26. cross-canadian.bbclass
7.27. crosssdk.bbclass
7.28. debian.bbclass
7.29. deploy.bbclass
7.30. devshell.bbclass
7.31. distro_features_check.bbclass
7.32. distrodata.bbclass
7.33. distutils*.bbclass
7.34. distutils3*.bbclass
7.35. externalsrc.bbclass
7.36. extrausers.bbclass
7.37. fontcache.bbclass
7.38. fs-uuid.bbclass
7.39. gconf.bbclass
7.40. gettext.bbclass
7.41. gnome.bbclass
7.42. gnomebase.bbclass
7.43. gobject-introspection.bbclass
7.44. grub-efi.bbclass
7.45. gsettings.bbclass
7.46. gtk-doc.bbclass
7.47. gtk-icon-cache.bbclass
7.48. gtk-immodules-cache.bbclass
7.49. gzipnative.bbclass
7.50. icecc.bbclass
7.51. image.bbclass
7.52. image-buildinfo.bbclass
7.53. image_types.bbclass
7.54. image_types_uboot.bbclass
7.55. image-live.bbclass
7.56. image-mklibs.bbclass
7.57. image-prelink.bbclass
7.58. image-vm.bbclass
7.59. image-vmdk.bbclass
7.60. insane.bbclass
7.61. insserv.bbclass
7.62. kernel.bbclass
7.63. kernel-arch.bbclass
7.64. kernel-fitimage.bbclass
7.65. kernel-grub.bbclass
7.66. kernel-module-split.bbclass
7.67. kernel-uboot.bbclass
7.68. kernel-uimage.bbclass
7.69. kernel-yocto.bbclass
7.70. kernelsrc.bbclass
7.71. lib_package.bbclass
7.72. libc*.bbclass
7.73. license.bbclass
7.74. linux-kernel-base.bbclass
7.75. linuxloader.bbclass
7.76. logging.bbclass
7.77. meta.bbclass
7.78. metadata_scm.bbclass
7.79. migrate_localcount.bbclass
7.80. mime.bbclass
7.81. mirrors.bbclass
7.82. module.bbclass
7.83. module-base.bbclass
7.84. multilib*.bbclass
7.85. native.bbclass
7.86. nativesdk.bbclass
7.87. nopackages.bbclass
7.88. npm.bbclass
7.89. oelint.bbclass
7.90. own-mirrors.bbclass
7.91. package.bbclass
7.92. package_deb.bbclass
7.93. package_ipk.bbclass
7.94. package_rpm.bbclass
7.95. package_tar.bbclass
7.96. packagedata.bbclass
7.97. packagegroup.bbclass
7.98. patch.bbclass
7.99. perlnative.bbclass
7.100. pixbufcache.bbclass
7.101. pkgconfig.bbclass
7.102. populate_sdk.bbclass
7.103. populate_sdk_*.bbclass
7.104. prexport.bbclass
7.105. primport.bbclass
7.106. prserv.bbclass
7.107. ptest.bbclass
7.108. ptest-gnome.bbclass
7.109. python-dir.bbclass
7.110. python3native.bbclass
7.111. pythonnative.bbclass
7.112. qemu.bbclass
7.113. recipe_sanity.bbclass
7.114. relocatable.bbclass
7.115. remove-libtool.bbclass
7.116. report-error.bbclass
7.117. rm_work.bbclass
7.118. rootfs*.bbclass
7.119. sanity.bbclass
7.120. scons.bbclass
7.121. sdl.bbclass
7.122. setuptools.bbclass
7.123. setuptools3.bbclass
7.124. sign_rpm.bbclass
7.125. sip.bbclass
7.126. siteconfig.bbclass
7.127. siteinfo.bbclass
7.128. spdx.bbclass
7.129. sstate.bbclass
7.130. staging.bbclass
7.131. syslinux.bbclass
7.132. systemd.bbclass
7.133. systemd-boot.bbclass
7.134. terminal.bbclass
7.135. testimage*.bbclass
7.136. testsdk.bbclass
7.137. texinfo.bbclass
7.138. tinderclient.bbclass
7.139. toaster.bbclass
7.140. toolchain-scripts.bbclass
7.141. typecheck.bbclass
7.142. uboot-config.bbclass
7.143. uninative.bbclass
7.144. update-alternatives.bbclass
7.145. update-rc.d.bbclass
7.146. useradd*.bbclass
7.147. utility-tasks.bbclass
7.148. utils.bbclass
7.149. vala.bbclass
7.150. waf.bbclass

Class files are used to abstract common functionality and share it amongst multiple recipe (.bb) files. To use a class file, you simply make sure the recipe inherits the class. In most cases, when a recipe inherits a class it is enough to enable its features. There are cases, however, where in the recipe you might need to set variables or override some default behavior.

Any Metadata usually found in a recipe can also be placed in a class file. Class files are identified by the extension .bbclass and are usually placed in a classes/ directory beneath the meta*/ directory found in the Source Directory. Class files can also be pointed to by BUILDDIR (e.g. build/) in the same way as .conf files in the conf directory. Class files are searched for in BBPATH using the same method by which .conf files are searched.

This chapter discusses only the most useful and important classes. Other classes do exist within the meta/classes directory in the Source Directory. You can reference the .bbclass files directly for more information.

7.1. allarch.bbclass

The allarch class is inherited by recipes that do not produce architecture-specific output. The class disables functionality that is normally needed for recipes that produce executable binaries (such as building the cross-compiler and a C library as pre-requisites, and splitting out of debug symbols during packaging).

Note

Unlike some distro recipes (e.g. Debian), OpenEmbedded recipes that produce packages that depend on tunings through use of the RDEPENDS and TUNE_PKGARCH variables, should never be configured for all architectures using allarch. This is the case even if the recipes do not produce architecture-specific output.

Configuring such recipes for all architectures causes the do_package_write_* tasks to have different signatures for the machines with different tunings. Additionally, unnecessary rebuilds occur every time an image for a different MACHINE is built even when the recipe never changes.

By default, all recipes inherit the base and package classes, which enable functionality needed for recipes that produce executable output. If your recipe, for example, only produces packages that contain configuration files, media files, or scripts (e.g. Python and Perl), then it should inherit the allarch class.

7.2. archiver.bbclass

The archiver class supports releasing source code and other materials with the binaries.

For more details on the source archiver, see the "Maintaining Open Source License Compliance During Your Product's Lifecycle" section in the Yocto Project Development Manual. You can also see the ARCHIVER_MODE variable for information about the variable flags (varflags) that help control archive creation.

7.3. autotools*.bbclass

The autotools* classes support Autotooled packages.

The autoconf, automake, and libtool packages bring standardization. This class defines a set of tasks (e.g. configure, compile and so forth) that work for all Autotooled packages. It should usually be enough to define a few standard variables and then simply inherit autotools. These classes can also work with software that emulates Autotools. For more information, see the "Autotooled Package" section in the Yocto Project Development Manual.

By default, the autotools* classes use out-of-tree builds (i.e. autotools.bbclass). (B != S).

If the software being built by a recipe does not support using out-of-tree builds, you should have the recipe inherit the autotools-brokensep class. The autotools-brokensep class behaves the same as the autotools class but builds with B == S. This method is useful when out-of-tree build support is either not present or is broken.

Note

It is recommended that out-of-tree support be fixed and used if at all possible.

It's useful to have some idea of how the tasks defined by the autotools* classes work and what they do behind the scenes.

  • do_configure - Regenerates the configure script (using autoreconf) and then launches it with a standard set of arguments used during cross-compilation. You can pass additional parameters to configure through the EXTRA_OECONF or PACKAGECONFIG_CONFARGS variables.

  • do_compile - Runs make with arguments that specify the compiler and linker. You can pass additional arguments through the EXTRA_OEMAKE variable.

  • do_install - Runs make install and passes in ${D} as DESTDIR.

7.4. base.bbclass

The base class is special in that every .bb file implicitly inherits the class. This class contains definitions for standard basic tasks such as fetching, unpacking, configuring (empty by default), compiling (runs any Makefile present), installing (empty by default) and packaging (empty by default). These classes are often overridden or extended by other classes such as the autotools class or the package class.

The class also contains some commonly used functions such as oe_runmake, which runs make with the arguments specified in EXTRA_OEMAKE variable as well as the arguments passed directly to oe_runmake.

7.5. bash-completion.bbclass

Sets up packaging and dependencies appropriate for recipes that build software that includes bash-completion data.

7.6. bin_package.bbclass

The bin_package class is a helper class for recipes that extract the contents of a binary package (e.g. an RPM) and install those contents rather than building the binary from source. The binary package is extracted and new packages in the configured output package format are created. Extraction and installation of proprietary binaries is a good example use for this class.

Note

For RPMs and other packages that do not contain a subdirectory, you should specify an appropriate fetcher parameter to point to the subdirectory. For example, if BitBake is using the Git fetcher (git://), the "subpath" parameter limits the checkout to a specific subpath of the tree. Here is an example where ${BP} is used so that the files are extracted into the subdirectory expected by the default value of S:
     SRC_URI = "git://example.com/downloads/somepackage.rpm;subpath=${BP}"
            
See the "Fetchers" section in the BitBake User Manual for more information on supported BitBake Fetchers.

7.7. binconfig.bbclass

The binconfig class helps to correct paths in shell scripts.

Before pkg-config had become widespread, libraries shipped shell scripts to give information about the libraries and include paths needed to build software (usually named LIBNAME-config). This class assists any recipe using such scripts.

During staging, the OpenEmbedded build system installs such scripts into the sysroots/ directory. Inheriting this class results in all paths in these scripts being changed to point into the sysroots/ directory so that all builds that use the script use the correct directories for the cross compiling layout. See the BINCONFIG_GLOB variable for more information.

7.8. binconfig-disabled.bbclass

An alternative version of the binconfig class, which disables binary configuration scripts by making them return an error in favor of using pkg-config to query the information. The scripts to be disabled should be specified using the BINCONFIG variable within the recipe inheriting the class.

7.9. blacklist.bbclass

The blacklist class prevents the OpenEmbedded build system from building specific recipes (blacklists them). To use this class, inherit the class globally and set PNBLACKLIST for each recipe you wish to blacklist. Specify the PN value as a variable flag (varflag) and provide a reason, which is reported, if the package is requested to be built as the value. For example, if you want to blacklist a recipe called "exoticware", you add the following to your local.conf or distribution configuration:

     INHERIT += "blacklist"
     PNBLACKLIST[exoticware] = "Not supported by our organization."
        

7.10. bluetooth.bbclass

The bluetooth class defines a variable that expands to the recipe (package) providing core bluetooth support on the platform.

For details on how the class works, see the meta/classes/bluetooth.bbclass file in the Yocto Project Source Directory.

7.11. bugzilla.bbclass

The bugzilla class supports setting up an instance of Bugzilla in which you can automatically files bug reports in response to build failures. For this class to work, you need to enable the XML-RPC interface in the instance of Bugzilla.

7.12. buildhistory.bbclass

The buildhistory class records a history of build output metadata, which can be used to detect possible regressions as well as used for analysis of the build output. For more information on using Build History, see the "Maintaining Build Output Quality" section.

7.13. buildstats.bbclass

The buildstats class records performance statistics about each task executed during the build (e.g. elapsed time, CPU usage, and I/O usage).

When you use this class, the output goes into the BUILDSTATS_BASE directory, which defaults to ${TMPDIR}/buildstats/. You can analyze the elapsed time using scripts/pybootchartgui/pybootchartgui.py, which produces a cascading chart of the entire build process and can be useful for highlighting bottlenecks.

Collecting build statistics is enabled by default through the USER_CLASSES variable from your local.conf file. Consequently, you do not have to do anything to enable the class. However, if you want to disable the class, simply remove "buildstats" from the USER_CLASSES list.

7.14. buildstats-summary.bbclass

When inherited globally, prints statistics at the end of the build on sstate re-use. In order to function, this class requires the buildstats class be enabled.

7.15. ccache.bbclass

The ccache class enables the C/C++ Compiler Cache for the build. This class is used to give a minor performance boost during the build. However, using the class can lead to unexpected side-effects. Thus, it is recommended that you do not use this class. See http://ccache.samba.org/ for information on the C/C++ Compiler Cache.

7.16. chrpath.bbclass

The chrpath class is a wrapper around the "chrpath" utility, which is used during the build process for nativesdk, cross, and cross-canadian recipes to change RPATH records within binaries in order to make them relocatable.

7.17. clutter.bbclass

The clutter class consolidates the major and minor version naming and other common items used by Clutter and related recipes.

Note

Unlike some other classes related to specific libraries, recipes building other software that uses Clutter do not need to inherit this class unless they use the same recipe versioning scheme that the Clutter and related recipes do.

7.18. cmake.bbclass

The cmake class allows for recipes that need to build software using the CMake build system. You can use the EXTRA_OECMAKE variable to specify additional configuration options to be passed on the cmake command line.

7.19. cml1.bbclass

The cml1 class provides basic support for the Linux kernel style build configuration system.

7.20. compress_doc.bbclass

Enables compression for man pages and info pages. This class is intended to be inherited globally. The default compression mechanism is gz (gzip) but you can select an alternative mechanism by setting the DOC_COMPRESS variable.

7.21. copyleft_compliance.bbclass

The copyleft_compliance class preserves source code for the purposes of license compliance. This class is an alternative to the archiver class and is still used by some users even though it has been deprecated in favor of the archiver class.

7.22. copyleft_filter.bbclass

A class used by the archiver and copyleft_compliance classes for filtering licenses. The copyleft_filter class is an internal class and is not intended to be used directly.

7.23. core-image.bbclass

The core-image class provides common definitions for the core-image-* image recipes, such as support for additional IMAGE_FEATURES.

7.24. cpan*.bbclass

The cpan* classes support Perl modules.

Recipes for Perl modules are simple. These recipes usually only need to point to the source's archive and then inherit the proper class file. Building is split into two methods depending on which method the module authors used.

  • Modules that use old Makefile.PL-based build system require cpan.bbclass in their recipes.

  • Modules that use Build.PL-based build system require using cpan_build.bbclass in their recipes.

Both build methods inherit the cpan-base class for basic Perl support.

7.25. cross.bbclass

The cross class provides support for the recipes that build the cross-compilation tools.

7.26. cross-canadian.bbclass

The cross-canadian class provides support for the recipes that build the Canadian Cross-compilation tools for SDKs. See the "Cross-Development Toolchain Generation" section for more discussion on these cross-compilation tools.

7.27. crosssdk.bbclass

The crosssdk class provides support for the recipes that build the cross-compilation tools used for building SDKs. See the "Cross-Development Toolchain Generation" section for more discussion on these cross-compilation tools.

7.28. debian.bbclass

The debian class renames output packages so that they follow the Debian naming policy (i.e. glibc becomes libc6 and glibc-devel becomes libc6-dev.) Renaming includes the library name and version as part of the package name.

If a recipe creates packages for multiple libraries (shared object files of .so type), use the LEAD_SONAME variable in the recipe to specify the library on which to apply the naming scheme.

7.29. deploy.bbclass

The deploy class handles deploying files to the DEPLOY_DIR_IMAGE directory. The main function of this class is to allow the deploy step to be accelerated by shared state. Recipes that inherit this class should define their own do_deploy function to copy the files to be deployed to DEPLOYDIR, and use addtask to add the task at the appropriate place, which is usually after do_compile or do_install. The class then takes care of staging the files from DEPLOYDIR to DEPLOY_DIR_IMAGE.

7.30. devshell.bbclass

The devshell class adds the do_devshell task. Distribution policy dictates whether to include this class. See the "Using a Development Shell" section in the Yocto Project Development Manual for more information about using devshell.

7.31. distro_features_check.bbclass

The distro_features_check class allows individual recipes to check for required and conflicting DISTRO_FEATURES.

This class provides support for the REQUIRED_DISTRO_FEATURES and CONFLICT_DISTRO_FEATURES variables. If any conditions specified in the recipe using the above variables are not met, the recipe will be skipped.

7.32. distrodata.bbclass

The distrodata class provides for automatic checking for upstream recipe updates. The class creates a comma-separated value (CSV) spreadsheet that contains information about the recipes. The information provides the do_distrodata and do_distro_check tasks, which do upstream checking and also verify if a package is used in multiple major distributions.

The class is not included by default. To use it, you must set the INHERIT variable:

     INHERIT+= "distrodata"
        

The distrodata class also provides the do_checkpkg task, which can be used against a simple recipe or against an image to get all its recipe information.

7.33. distutils*.bbclass

The distutils* classes support recipes for Python version 2.x extensions, which are simple. These recipes usually only need to point to the source's archive and then inherit the proper class. Building is split into two methods depending on which method the module authors used.

  • Extensions that use an Autotools-based build system require Autotools and the classes based on distutils in their recipes.

  • Extensions that use build systems based on distutils require the distutils class in their recipes.

  • Extensions that use build systems based on setuptools require the setuptools class in their recipes.

The distutils-common-base class is required by some of the distutils* classes to provide common Python2 support.

The distutils-tools class supports recipes for additional "distutils" tools.

7.34. distutils3*.bbclass

The distutils3* classes support recipes for Python version 3.x extensions, which are simple. These recipes usually only need to point to the source's archive and then inherit the proper class. Building is split into three methods depending on which method the module authors used.

  • Extensions that use an Autotools-based build system require Autotools and distutils-based classes in their recipes.

  • Extensions that use distutils-based build systems require the distutils class in their recipes.

  • Extensions that use build systems based on setuptools3 require the setuptools3 class in their recipes.

The distutils3* classes either inherit their corresponding distutils* class or replicate them using a Python3 version instead (e.g. distutils3-base inherits distutils-common-base, which is the same as distutils-base but inherits python3native instead of pythonnative).

7.35. externalsrc.bbclass

The externalsrc class supports building software from source code that is external to the OpenEmbedded build system. Building software from an external source tree means that the build system's normal fetch, unpack, and patch process is not used.

By default, the OpenEmbedded build system uses the S and B variables to locate unpacked recipe source code and to build it, respectively. When your recipe inherits the externalsrc class, you use the EXTERNALSRC and EXTERNALSRC_BUILD variables to ultimately define S and B.

By default, this class expects the source code to support recipe builds that use the B variable to point to the directory in which the OpenEmbedded build system places the generated objects built from the recipes. By default, the B directory is set to the following, which is separate from the source directory (S):

     ${WORKDIR}/${BPN}/{PV}/
        

See these variables for more information: WORKDIR, BPN, and PV,

For more information on the externalsrc class, see the comments in meta/classes/externalsrc.bbclass in the Source Directory. For information on how to use the externalsrc class, see the "Building Software from an External Source" section in the Yocto Project Development Manual.

7.36. extrausers.bbclass

The extrausers class allows additional user and group configuration to be applied at the image level. Inheriting this class either globally or from an image recipe allows additional user and group operations to be performed using the EXTRA_USERS_PARAMS variable.

Note

The user and group operations added using the extrausers class are not tied to a specific recipe outside of the recipe for the image. Thus, the operations can be performed across the image as a whole. Use the useradd class to add user and group configuration to a specific recipe.

Here is an example that uses this class in an image recipe:

     inherit extrausers
     EXTRA_USERS_PARAMS = "\
         useradd -p '' tester; \
         groupadd developers; \
         userdel nobody; \
         groupdel -g video; \
         groupmod -g 1020 developers; \
         usermod -s /bin/sh tester; \
         "
        

Here is an example that adds two users named "tester-jim" and "tester-sue" and assigns passwords:

     inherit extrausers
     EXTRA_USERS_PARAMS = "\
         useradd -P tester01 tester-jim; \
         useradd -P tester01 tester-sue; \
         "
        

Finally, here is an example that sets the root password to "1876*18":

     inherit extrausers
     EXTRA_USERS_PARAMS = "\
         usermod -P 1876*18 root; \
         "
        

7.37. fontcache.bbclass

The fontcache class generates the proper post-install and post-remove (postinst and postrm) scriptlets for font packages. These scriptlets call fc-cache (part of Fontconfig) to add the fonts to the font information cache. Since the cache files are architecture-specific, fc-cache runs using QEMU if the postinst scriptlets need to be run on the build host during image creation.

If the fonts being installed are in packages other than the main package, set FONT_PACKAGES to specify the packages containing the fonts.

7.38. fs-uuid.bbclass

The fs-uuid class extracts UUID from ${ROOTFS}, which must have been built by the time that this function gets called. The fs-uuid class only works on ext file systems and depends on tune2fs.

7.39. gconf.bbclass

The gconf class provides common functionality for recipes that need to install GConf schemas. The schemas will be put into a separate package (${PN}-gconf) that is created automatically when this class is inherited. This package uses the appropriate post-install and post-remove (postinst/postrm) scriptlets to register and unregister the schemas in the target image.

7.40. gettext.bbclass

The gettext class provides support for building software that uses the GNU gettext internationalization and localization system. All recipes building software that use gettext should inherit this class.

7.41. gnome.bbclass

The gnome class supports recipes that build software from the GNOME stack. This class inherits the gnomebase, gtk-icon-cache, gconf and mime classes. The class also disables GObject introspection where applicable.

7.42. gnomebase.bbclass

The gnomebase class is the base class for recipes that build software from the GNOME stack. This class sets SRC_URI to download the source from the GNOME mirrors as well as extending FILES with the typical GNOME installation paths.

7.43. gobject-introspection.bbclass

Provides support for recipes building software that supports GObject introspection. This functionality is only enabled if the "gobject-introspection-data" feature is in DISTRO_FEATURES as well as "qemu-usermode" being in MACHINE_FEATURES.

Note

This functionality is backfilled by default and, if not applicable, should be disabled through DISTRO_FEATURES_BACKFILL_CONSIDERED or MACHINE_FEATURES_BACKFILL_CONSIDERED, respectively.

7.44. grub-efi.bbclass

The grub-efi class provides grub-efi-specific functions for building bootable images.

This class supports several variables:

  • INITRD: Indicates list of filesystem images to concatenate and use as an initial RAM disk (initrd) (optional).

  • ROOTFS: Indicates a filesystem image to include as the root filesystem (optional).

  • GRUB_GFXSERIAL: Set this to "1" to have graphics and serial in the boot menu.

  • LABELS: A list of targets for the automatic configuration.

  • APPEND: An override list of append strings for each LABEL.

  • GRUB_OPTS: Additional options to add to the configuration (optional). Options are delimited using semi-colon characters (;).

  • GRUB_TIMEOUT: Timeout before executing the default LABEL (optional).

7.45. gsettings.bbclass

The gsettings class provides common functionality for recipes that need to install GSettings (glib) schemas. The schemas are assumed to be part of the main package. Appropriate post-install and post-remove (postinst/postrm) scriptlets are added to register and unregister the schemas in the target image.

7.46. gtk-doc.bbclass

The gtk-doc class is a helper class to pull in the appropriate gtk-doc dependencies and disable gtk-doc.

7.47. gtk-icon-cache.bbclass

The gtk-icon-cache class generates the proper post-install and post-remove (postinst/postrm) scriptlets for packages that use GTK+ and install icons. These scriptlets call gtk-update-icon-cache to add the fonts to GTK+'s icon cache. Since the cache files are architecture-specific, gtk-update-icon-cache is run using QEMU if the postinst scriptlets need to be run on the build host during image creation.

7.48. gtk-immodules-cache.bbclass

The gtk-immodules-cache class generates the proper post-install and post-remove (postinst/postrm) scriptlets for packages that install GTK+ input method modules for virtual keyboards. These scriptlets call gtk-update-icon-cache to add the input method modules to the cache. Since the cache files are architecture-specific, gtk-update-icon-cache is run using QEMU if the postinst scriptlets need to be run on the build host during image creation.

If the input method modules being installed are in packages other than the main package, set GTKIMMODULES_PACKAGES to specify the packages containing the modules.

7.49. gzipnative.bbclass

The gzipnative class enables the use of different native versions of gzip and pigz rather than the versions of these tools from the build host.

7.50. icecc.bbclass

The icecc class supports Icecream, which facilitates taking compile jobs and distributing them among remote machines.

The class stages directories with symlinks from gcc and g++ to icecc, for both native and cross compilers. Depending on each configure or compile, the OpenEmbedded build system adds the directories at the head of the PATH list and then sets the ICECC_CXX and ICEC_CC variables, which are the paths to the g++ and gcc compilers, respectively.

For the cross compiler, the class creates a tar.gz file that contains the Yocto Project toolchain and sets ICECC_VERSION, which is the version of the cross-compiler used in the cross-development toolchain, accordingly.

The class handles all three different compile stages (i.e native ,cross-kernel and target) and creates the necessary environment tar.gz file to be used by the remote machines. The class also supports SDK generation.

If ICECC_PATH is not set in your local.conf file, then the class tries to locate the icecc binary using which. If ICECC_ENV_EXEC is set in your local.conf file, the variable should point to the icecc-create-env script provided by the user. If you do not point to a user-provided script, the build system uses the default script provided by the recipe icecc-create-env-native.bb.

Note

This script is a modified version and not the one that comes with icecc.

If you do not want the Icecream distributed compile support to apply to specific recipes or classes, you can effectively "blacklist" them by listing the recipes and classes using the ICECC_USER_PACKAGE_BL and ICECC_USER_CLASS_BL, variables, respectively, in your local.conf file. Doing so causes the OpenEmbedded build system to handle these compilations locally.

Additionally, you can list recipes using the ICECC_USER_PACKAGE_WL variable in your local.conf file to force icecc to be enabled for recipes using an empty PARALLEL_MAKE variable.

Inheriting the icecc class changes all sstate signatures. Consequently, if a development team has a dedicated build system that populates STATE_MIRRORS and they want to reuse sstate from STATE_MIRRORS, then all developers and the build system need to either inherit the icecc class or nobody should.

At the distribution level, you can inherit the icecc class to be sure that all builders start with the same sstate signatures. After inheriting the class, you can then disable the feature by setting the ICECC_DISABLED variable to "1" as follows:

     INHERIT_DISTRO_append = " icecc"
     ICECC_DISABLED ??= "1"
        

This practice makes sure everyone is using the same signatures but also requires individuals that do want to use Icecream to enable the feature individually as follows in your local.conf file:

     ICECC_DISABLED = ""
        

7.51. image.bbclass

The image class helps support creating images in different formats. First, the root filesystem is created from packages using one of the rootfs*.bbclass files (depending on the package format used) and then one or more image files are created.

  • The IMAGE_FSTYPES variable controls the types of images to generate.

  • The IMAGE_INSTALL variable controls the list of packages to install into the image.

For information on customizing images, see the "Customizing Images" section in the Yocto Project Development Manual. For information on how images are created, see the "Images" section elsewhere in this manual.

7.52. image-buildinfo.bbclass

The image-buildinfo class writes information to the target filesystem on /etc/build.

7.53. image_types.bbclass

The image_types class defines all of the standard image output types that you can enable through the IMAGE_FSTYPES variable. You can use this class as a reference on how to add support for custom image output types.

By default, this class is enabled through the IMAGE_CLASSES variable in image.bbclass. If you define your own image types using a custom BitBake class and then use IMAGE_CLASSES to enable it, the custom class must either inherit image_types or image_types must also appear in IMAGE_CLASSES.

7.54. image_types_uboot.bbclass

The image_types_uboot class defines additional image types specifically for the U-Boot bootloader.

7.55. image-live.bbclass

The image-live class supports building "live" images.

Normally, you do not use this class directly. Instead, you add "live" to IMAGE_FSTYPES. For example, if you were building an ISO image, you would add "live" to IMAGE_FSTYPES, set the NOISO variable to "0" and the build system would use the image-live class to build the ISO image.

7.56. image-mklibs.bbclass

The image-mklibs class enables the use of the mklibs utility during the do_rootfs task, which optimizes the size of libraries contained in the image.

By default, the class is enabled in the local.conf.template using the USER_CLASSES variable as follows:

     USER_CLASSES ?= "buildstats image-mklibs image-prelink"
        

The image-prelink class enables the use of the prelink utility during the do_rootfs task, which optimizes the dynamic linking of shared libraries to reduce executable startup time.

By default, the class is enabled in the local.conf.template using the USER_CLASSES variable as follows:

     USER_CLASSES ?= "buildstats image-mklibs image-prelink"
        

7.58. image-vm.bbclass

The image-vm class supports building VM images.

7.59. image-vmdk.bbclass

The image-vmdk class supports building VMware VMDK images. Normally, you do not use this class directly. Instead, you add "vmdk" to IMAGE_FSTYPES.

7.60. insane.bbclass

The insane class adds a step to the package generation process so that output quality assurance checks are generated by the OpenEmbedded build system. A range of checks are performed that check the build's output for common problems that show up during runtime. Distribution policy usually dictates whether to include this class.

You can configure the sanity checks so that specific test failures either raise a warning or an error message. Typically, failures for new tests generate a warning. Subsequent failures for the same test would then generate an error message once the metadata is in a known and good condition. See the "QA Error and Warning Messages" Chapter for a list of all the warning and error messages you might encounter using a default configuration.

Use the WARN_QA and ERROR_QA variables to control the behavior of these checks at the global level (i.e. in your custom distro configuration). However, to skip one or more checks in recipes, you should use INSANE_SKIP. For example, to skip the check for symbolic link .so files in the main package of a recipe, add the following to the recipe. You need to realize that the package name override, in this example ${PN}, must be used:

     INSANE_SKIP_${PN} += "dev-so"
        

Please keep in mind that the QA checks exist in order to detect real or potential problems in the packaged output. So exercise caution when disabling these checks.

The following list shows the tests you can list with the WARN_QA and ERROR_QA variables:

  • already-stripped: Checks that produced binaries have not already been stripped prior to the build system extracting debug symbols. It is common for upstream software projects to default to stripping debug symbols for output binaries. In order for debugging to work on the target using -dbg packages, this stripping must be disabled.

  • arch: Checks the Executable and Linkable Format (ELF) type, bit size, and endianness of any binaries to ensure they match the target architecture. This test fails if any binaries do not match the type since there would be an incompatibility. The test could indicate that the wrong compiler or compiler options have been used. Sometimes software, like bootloaders, might need to bypass this check.

  • buildpaths: Checks for paths to locations on the build host inside the output files. Currently, this test triggers too many false positives and thus is not normally enabled.

  • build-deps: Determines if a build-time dependency that is specified through DEPENDS, explicit RDEPENDS, or task-level dependencies exists to match any runtime dependency. This determination is particularly useful to discover where runtime dependencies are detected and added during packaging. If no explicit dependency has been specified within the metadata, at the packaging stage it is too late to ensure that the dependency is built, and thus you can end up with an error when the package is installed into the image during the do_rootfs task because the auto-detected dependency was not satisfied. An example of this would be where the update-rc.d class automatically adds a dependency on the initscripts-functions package to packages that install an initscript that refers to /etc/init.d/functions. The recipe should really have an explicit RDEPENDS for the package in question on initscripts-functions so that the OpenEmbedded build system is able to ensure that the initscripts recipe is actually built and thus the initscripts-functions package is made available.

  • compile-host-path: Checks the do_compile log for indications that paths to locations on the build host were used. Using such paths might result in host contamination of the build output.

  • debug-deps: Checks that all packages except -dbg packages do not depend on -dbg packages, which would cause a packaging bug.

  • debug-files: Checks for .debug directories in anything but the -dbg package. The debug files should all be in the -dbg package. Thus, anything packaged elsewhere is incorrect packaging.

  • dep-cmp: Checks for invalid version comparison statements in runtime dependency relationships between packages (i.e. in RDEPENDS, RRECOMMENDS, RSUGGESTS, RPROVIDES, RREPLACES, and RCONFLICTS variable values). Any invalid comparisons might trigger failures or undesirable behavior when passed to the package manager.

  • desktop: Runs the desktop-file-validate program against any .desktop files to validate their contents against the specification for .desktop files.

  • dev-deps: Checks that all packages except -dev or -staticdev packages do not depend on -dev packages, which would be a packaging bug.

  • dev-so: Checks that the .so symbolic links are in the -dev package and not in any of the other packages. In general, these symlinks are only useful for development purposes. Thus, the -dev package is the correct location for them. Some very rare cases do exist for dynamically loaded modules where these symlinks are needed instead in the main package.

  • file-rdeps: Checks that file-level dependencies identified by the OpenEmbedded build system at packaging time are satisfied. For example, a shell script might start with the line #!/bin/bash. This line would translate to a file dependency on /bin/bash. Of the three package managers that the OpenEmbedded build system supports, only RPM directly handles file-level dependencies, resolving them automatically to packages providing the files. However, the lack of that functionality in the other two package managers does not mean the dependencies do not still need resolving. This QA check attempts to ensure that explicitly declared RDEPENDS exist to handle any file-level dependency detected in packaged files.

  • files-invalid: Checks for FILES variable values that contain "//", which is invalid.

  • host-user-contaminated: Checks that no package produced by the recipe contains any files outside of /home with a user or group ID that matches the user running BitBake. A match usually indicates that the files are being installed with an incorrect UID/GID, since target IDs are independent from host IDs. For additional information, see the section describing the do_install task.

  • incompatible-license: Report when packages are excluded from being created due to being marked with a license that is in INCOMPATIBLE_LICENSE.

  • install-host-path: Checks the do_install log for indications that paths to locations on the build host were used. Using such paths might result in host contamination of the build output.

  • installed-vs-shipped: Reports when files have been installed within do_install but have not been included in any package by way of the FILES variable. Files that do not appear in any package cannot be present in an image later on in the build process. Ideally, all installed files should be packaged or not installed at all. These files can be deleted at the end of do_install if the files are not needed in any package.

  • invalid-chars: Checks that the recipe metadata variables DESCRIPTION, SUMMARY, LICENSE, and SECTION do not contain non-UTF-8 characters. Some package managers do not support such characters.

  • invalid-packageconfig: Checks that no undefined features are being added to PACKAGECONFIG. For example, any name "foo" for which the following form does not exist:

         PACKAGECONFIG[foo] = "..."
                    

  • la: Checks .la files for any TMPDIR paths. Any .la file containing these paths is incorrect since libtool adds the correct sysroot prefix when using the files automatically itself.

  • ldflags: Ensures that the binaries were linked with the LDFLAGS options provided by the build system. If this test fails, check that the LDFLAGS variable is being passed to the linker command.

  • libdir: Checks for libraries being installed into incorrect (possibly hardcoded) installation paths. For example, this test will catch recipes that install /lib/bar.so when ${base_libdir} is "lib32". Another example is when recipes install /usr/lib64/foo.so when ${libdir} is "/usr/lib".

  • libexec: Checks if a package contains files in /usr/libexec. This check is not performed if the libexecdir variable has been set explicitly to /usr/libexec.

  • packages-list: Checks for the same package being listed multiple times through the PACKAGES variable value. Installing the package in this manner can cause errors during packaging.

  • perm-config: Reports lines in fs-perms.txt that have an invalid format.

  • perm-line: Reports lines in fs-perms.txt that have an invalid format.

  • perm-link: Reports lines in fs-perms.txt that specify 'link' where the specified target already exists.

  • perms: Currently, this check is unused but reserved.

  • pkgconfig: Checks .pc files for any TMPDIR/WORKDIR paths. Any .pc file containing these paths is incorrect since pkg-config itself adds the correct sysroot prefix when the files are accessed.

  • pkgname: Checks that all packages in PACKAGES have names that do not contain invalid characters (i.e. characters other than 0-9, a-z, ., +, and -).

  • pkgv-undefined: Checks to see if the PKGV variable is undefined during do_package.

  • pkgvarcheck: Checks through the variables RDEPENDS, RRECOMMENDS, RSUGGESTS, RCONFLICTS, RPROVIDES, RREPLACES, FILES, ALLOW_EMPTY, pkg_preinst, pkg_postinst, pkg_prerm and pkg_postrm, and reports if there are variable sets that are not package-specific. Using these variables without a package suffix is bad practice, and might unnecessarily complicate dependencies of other packages within the same recipe or have other unintended consequences.

  • pn-overrides: Checks that a recipe does not have a name (PN) value that appears in OVERRIDES. If a recipe is named such that its PN value matches something already in OVERRIDES (e.g. PN happens to be the same as MACHINE or DISTRO), it can have unexpected consequences. For example, assignments such as FILES_${PN} = "xyz" effectively turn into FILES = "xyz".

  • rpaths: Checks for rpaths in the binaries that contain build system paths such as TMPDIR. If this test fails, bad -rpath options are being passed to the linker commands and your binaries have potential security issues.

  • split-strip: Reports that splitting or stripping debug symbols from binaries has failed.

  • staticdev: Checks for static library files (*.a) in non-staticdev packages.

  • symlink-to-sysroot: Checks for symlinks in packages that point into TMPDIR on the host. Such symlinks will work on the host, but are clearly invalid when running on the target.

  • textrel: Checks for ELF binaries that contain relocations in their .text sections, which can result in a performance impact at runtime. See the explanation for the ELF binary message for more information regarding runtime performance issues.

  • unsafe-references-in-binaries: Reports when a binary installed in ${base_libdir}, ${base_bindir}, or ${base_sbindir}, depends on another binary installed under ${exec_prefix}. This dependency is a concern if you want the system to remain basically operable if /usr is mounted separately and is not mounted.

    Note

    Defaults for binaries installed in ${base_libdir}, ${base_bindir}, and ${base_sbindir} are /lib, /bin, and /sbin, respectively. The default for a binary installed under ${exec_prefix} is /usr.

  • unsafe-references-in-scripts: Reports when a script file installed in ${base_libdir}, ${base_bindir}, or ${base_sbindir}, depends on files installed under ${exec_prefix}. This dependency is a concern if you want the system to remain basically operable if /usr is mounted separately and is not mounted.

    Note

    Defaults for binaries installed in ${base_libdir}, ${base_bindir}, and ${base_sbindir} are /lib, /bin, and /sbin, respectively. The default for a binary installed under ${exec_prefix} is /usr.

  • useless-rpaths: Checks for dynamic library load paths (rpaths) in the binaries that by default on a standard system are searched by the linker (e.g. /lib and /usr/lib). While these paths will not cause any breakage, they do waste space and are unnecessary.

  • var-undefined: Reports when variables fundamental to packaging (i.e. WORKDIR, DEPLOY_DIR, D, PN, and PKGD) are undefined during do_package.

  • version-going-backwards: If Build History is enabled, reports when a package being written out has a lower version than the previously written package under the same name. If you are placing output packages into a feed and upgrading packages on a target system using that feed, the version of a package going backwards can result in the target system not correctly upgrading to the "new" version of the package.

    Note

    If you are not using runtime package management on your target system, then you do not need to worry about this situation.

  • xorg-driver-abi: Checks that all packages containing Xorg drivers have ABI dependencies. The xserver-xorg recipe provides driver ABI names. All drivers should depend on the ABI versions that they have been built against. Driver recipes that include xorg-driver-input.inc or xorg-driver-video.inc will automatically get these versions. Consequently, you should only need to explicitly add dependencies to binary driver recipes.

7.61. insserv.bbclass

The insserv class uses the insserv utility to update the order of symbolic links in /etc/rc?.d/ within an image based on dependencies specified by LSB headers in the init.d scripts themselves.

7.62. kernel.bbclass

The kernel class handles building Linux kernels. The class contains code to build all kernel trees. All needed headers are staged into the STAGING_KERNEL_DIR directory to allow out-of-tree module builds using the module class.

This means that each built kernel module is packaged separately and inter-module dependencies are created by parsing the modinfo output. If all modules are required, then installing the kernel-modules package installs all packages with modules and various other kernel packages such as kernel-vmlinux.

Various other classes are used by the kernel and module classes internally including the kernel-arch, module-base, and linux-kernel-base classes.

7.63. kernel-arch.bbclass

The kernel-arch class sets the ARCH environment variable for Linux kernel compilation (including modules).

7.64. kernel-fitimage.bbclass

The kernel-fitimage class provides support to pack zImages.

7.65. kernel-grub.bbclass

The kernel-grub class updates the boot area and the boot menu with the kernel as the priority boot mechanism while installing a RPM to update the kernel on a deployed target.

7.66. kernel-module-split.bbclass

The kernel-module-split class provides common functionality for splitting Linux kernel modules into separate packages.

7.67. kernel-uboot.bbclass

The kernel-uboot class provides support for building from vmlinux-style kernel sources.

7.68. kernel-uimage.bbclass

The kernel-uimage class provides support to pack uImage.

7.69. kernel-yocto.bbclass

The kernel-yocto class provides common functionality for building from linux-yocto style kernel source repositories.

7.70. kernelsrc.bbclass

The kernelsrc class sets the Linux kernel source and version.

7.71. lib_package.bbclass

The lib_package class supports recipes that build libraries and produce executable binaries, where those binaries should not be installed by default along with the library. Instead, the binaries are added to a separate ${PN}-bin package to make their installation optional.

7.72. libc*.bbclass

The libc* classes support recipes that build packages with libc:

  • The libc-common class provides common support for building with libc.

  • The libc-package class supports packaging up glibc and eglibc.

7.73. license.bbclass

The license class provides license manifest creation and license exclusion. This class is enabled by default using the default value for the INHERIT_DISTRO variable.

7.74. linux-kernel-base.bbclass

The linux-kernel-base class provides common functionality for recipes that build out of the Linux kernel source tree. These builds goes beyond the kernel itself. For example, the Perf recipe also inherits this class.

7.75. linuxloader.bbclass

Provides the function linuxloader(), which gives the value of the dynamic loader/linker provided on the platform. This value is used by a number of other classes.

7.76. logging.bbclass

The logging class provides the standard shell functions used to log messages for various BitBake severity levels (i.e. bbplain, bbnote, bbwarn, bberror, bbfatal, and bbdebug).

This class is enabled by default since it is inherited by the base class.

7.77. meta.bbclass

The meta class is inherited by recipes that do not build any output packages themselves, but act as a "meta" target for building other recipes.

7.78. metadata_scm.bbclass

The metadata_scm class provides functionality for querying the branch and revision of a Source Code Manager (SCM) repository.

The base class uses this class to print the revisions of each layer before starting every build. The metadata_scm class is enabled by default because it is inherited by the base class.

7.79. migrate_localcount.bbclass

The migrate_localcount class verifies a recipe's localcount data and increments it appropriately.

7.80. mime.bbclass

The mime class generates the proper post-install and post-remove (postinst/postrm) scriptlets for packages that install MIME type files. These scriptlets call update-mime-database to add the MIME types to the shared database.

7.81. mirrors.bbclass

The mirrors class sets up some standard MIRRORS entries for source code mirrors. These mirrors provide a fall-back path in case the upstream source specified in SRC_URI within recipes is unavailable.

This class is enabled by default since it is inherited by the base class.

7.82. module.bbclass

The module class provides support for building out-of-tree Linux kernel modules. The class inherits the module-base and kernel-module-split classes, and implements the do_compile and do_install tasks. The class provides everything needed to build and package a kernel module.

For general information on out-of-tree Linux kernel modules, see the "Incorporating Out-of-Tree Modules" section in the Yocto Project Linux Kernel Development Manual.

7.83. module-base.bbclass

The module-base class provides the base functionality for building Linux kernel modules. Typically, a recipe that builds software that includes one or more kernel modules and has its own means of building the module inherits this class as opposed to inheriting the module class.

7.84. multilib*.bbclass

The multilib* classes provide support for building libraries with different target optimizations or target architectures and installing them side-by-side in the same image.

For more information on using the Multilib feature, see the "Combining Multiple Versions of Library Files into One Image" section in the Yocto Project Development Manual.

7.85. native.bbclass

The native class provides common functionality for recipes that wish to build tools to run on the build host (i.e. tools that use the compiler or other tools from the build host).

You can create a recipe that builds tools that run natively on the host a couple different ways:

  • Create a myrecipe-native.bb that inherits the native class. If you use this method, you must order the inherit statement in the recipe after all other inherit statements so that the native class is inherited last.

  • Create or modify a target recipe that contains the following:

         BBCLASSEXTEND = "native"
                    

    Inside the recipe, use _class-native and _class-target overrides to specify any functionality specific to the respective native or target case.

Although applied differently, the native class is used with both methods. The advantage of the second method is that you do not need to have two separate recipes (assuming you need both) for native and target. All common parts of the recipe are automatically shared.

7.86. nativesdk.bbclass

The nativesdk class provides common functionality for recipes that wish to build tools to run as part of an SDK (i.e. tools that run on SDKMACHINE).

You can create a recipe that builds tools that run on the SDK machine a couple different ways:

  • Create a nativesdk-myrecipe.bb recipe that inherits the nativesdk class. If you use this method, you must order the inherit statement in the recipe after all other inherit statements so that the nativesdk class is inherited last.

  • Create a nativesdk variant of any recipe by adding the following:

         BBCLASSEXTEND = "nativesdk"
                    

    Inside the recipe, use _class-nativesdk and _class-target overrides to specify any functionality specific to the respective SDK machine or target case.

Although applied differently, the nativesdk class is used with both methods. The advantage of the second method is that you do not need to have two separate recipes (assuming you need both) for the SDK machine and the target. All common parts of the recipe are automatically shared.

7.87. nopackages.bbclass

Disables packaging tasks for those recipes and classes where packaging is not needed.

7.88. npm.bbclass

Provides support for building Node.js software fetched using the npm package manager.

Note

Currently, recipes inheriting this class must use the npm:// fetcher to have dependencies fetched and packaged automatically.

7.89. oelint.bbclass

The oelint class is an obsolete lint checking tool that exists in meta/classes in the Source Directory.

A number of classes exist that could be generally useful in OE-Core but are never actually used within OE-Core itself. The oelint class is one such example. However, being aware of this class can reduce the proliferation of different versions of similar classes across multiple layers.

7.90. own-mirrors.bbclass

The own-mirrors class makes it easier to set up your own PREMIRRORS from which to first fetch source before attempting to fetch it from the upstream specified in SRC_URI within each recipe.

To use this class, inherit it globally and specify SOURCE_MIRROR_URL. Here is an example:

     INHERIT += "own-mirrors"
     SOURCE_MIRROR_URL = "http://example.com/my-source-mirror"
        

You can specify only a single URL in SOURCE_MIRROR_URL.

7.91. package.bbclass

The package class supports generating packages from a build's output. The core generic functionality is in package.bbclass. The code specific to particular package types resides in these package-specific classes: package_deb, package_rpm, package_ipk, and package_tar.

Warning

The package_tar class is broken and not supported. It is recommended that you do not use this class.

You can control the list of resulting package formats by using the PACKAGE_CLASSES variable defined in your conf/local.conf configuration file, which is located in the Build Directory. When defining the variable, you can specify one or more package types. Since images are generated from packages, a packaging class is needed to enable image generation. The first class listed in this variable is used for image generation.

If you take the optional step to set up a repository (package feed) on the development host that can be used by Smart, you can install packages from the feed while you are running the image on the target (i.e. runtime installation of packages). For more information, see the "Using Runtime Package Management" section in the Yocto Project Development Manual.

The package-specific class you choose can affect build-time performance and has space ramifications. In general, building a package with IPK takes about thirty percent less time as compared to using RPM to build the same or similar package. This comparison takes into account a complete build of the package with all dependencies previously built. The reason for this discrepancy is because the RPM package manager creates and processes more Metadata than the IPK package manager. Consequently, you might consider setting PACKAGE_CLASSES to "package_ipk" if you are building smaller systems.

Before making your package manager decision, however, you should consider some further things about using RPM:

  • RPM starts to provide more abilities than IPK due to the fact that it processes more Metadata. For example, this information includes individual file types, file checksum generation and evaluation on install, sparse file support, conflict detection and resolution for Multilib systems, ACID style upgrade, and repackaging abilities for rollbacks.

  • For smaller systems, the extra space used for the Berkeley Database and the amount of metadata when using RPM can affect your ability to perform on-device upgrades.

You can find additional information on the effects of the package class at these two Yocto Project mailing list links:

7.92. package_deb.bbclass

The package_deb class provides support for creating packages that use the Debian (i.e. .deb) file format. The class ensures the packages are written out in a .deb file format to the ${DEPLOY_DIR_DEB} directory.

This class inherits the package class and is enabled through the PACKAGE_CLASSES variable in the local.conf file.

7.93. package_ipk.bbclass

The package_ipk class provides support for creating packages that use the IPK (i.e. .ipk) file format. The class ensures the packages are written out in a .ipk file format to the ${DEPLOY_DIR_IPK} directory.

This class inherits the package class and is enabled through the PACKAGE_CLASSES variable in the local.conf file.

7.94. package_rpm.bbclass

The package_rpm class provides support for creating packages that use the RPM (i.e. .rpm) file format. The class ensures the packages are written out in a .rpm file format to the ${DEPLOY_DIR_RPM} directory.

This class inherits the package class and is enabled through the PACKAGE_CLASSES variable in the local.conf file.

7.95. package_tar.bbclass

The package_tar class provides support for creating tarballs. The class ensures the packages are written out in a tarball format to the ${DEPLOY_DIR_TAR} directory.

This class inherits the package class and is enabled through the PACKAGE_CLASSES variable in the local.conf file.

Note

You cannot specify the package_tar class first using the PACKAGE_CLASSES variable. You must use .deb, .ipk, or .rpm file formats for your image or SDK.

7.96. packagedata.bbclass

The packagedata class provides common functionality for reading pkgdata files found in PKGDATA_DIR. These files contain information about each output package produced by the OpenEmbedded build system.

This class is enabled by default because it is inherited by the package class.

7.97. packagegroup.bbclass

The packagegroup class sets default values appropriate for package group recipes (e.g. PACKAGES, PACKAGE_ARCH, ALLOW_EMPTY, and so forth). It is highly recommended that all package group recipes inherit this class.

For information on how to use this class, see the "Customizing Images Using Custom Package Groups" section in the Yocto Project Development Manual.

Previously, this class was called the task class.

7.98. patch.bbclass

The patch class provides all functionality for applying patches during the do_patch task.

This class is enabled by default because it is inherited by the base class.

7.99. perlnative.bbclass

When inherited by a recipe, the perlnative class supports using the native version of Perl built by the build system rather than using the version provided by the build host.

7.100. pixbufcache.bbclass

The pixbufcache class generates the proper post-install and post-remove (postinst/postrm) scriptlets for packages that install pixbuf loaders, which are used with gdk-pixbuf. These scriptlets call update_pixbuf_cache to add the pixbuf loaders to the cache. Since the cache files are architecture-specific, update_pixbuf_cache is run using QEMU if the postinst scriptlets need to be run on the build host during image creation.

If the pixbuf loaders being installed are in packages other than the recipe's main package, set PIXBUF_PACKAGES to specify the packages containing the loaders.

7.101. pkgconfig.bbclass

The pkgconfig class provides a standard way to get header and library information by using pkg-config. This class aims to smooth integration of pkg-config into libraries that use it.

During staging, BitBake installs pkg-config data into the sysroots/ directory. By making use of sysroot functionality within pkg-config, the pkgconfig class no longer has to manipulate the files.

7.102. populate_sdk.bbclass

The populate_sdk class provides support for SDK-only recipes. For information on advantages gained when building a cross-development toolchain using the do_populate_sdk task, see the "Building an SDK Installer" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

7.103. populate_sdk_*.bbclass

The populate_sdk_* classes support SDK creation and consist of the following classes:

  • populate_sdk_base: The base class supporting SDK creation under all package managers (i.e. DEB, RPM, and opkg).

  • populate_sdk_deb: Supports creation of the SDK given the Debian package manager.

  • populate_sdk_rpm: Supports creation of the SDK given the RPM package manager.

  • populate_sdk_ipk: Supports creation of the SDK given the opkg (IPK format) package manager.

  • populate_sdk_ext: Supports extensible SDK creation under all package managers.

The populate_sdk_base class inherits the appropriate populate_sdk_* (i.e. deb, rpm, and ipk) based on IMAGE_PKGTYPE.

The base class ensures all source and destination directories are established and then populates the SDK. After populating the SDK, the populate_sdk_base class constructs two sysroots: ${SDK_ARCH}-nativesdk, which contains the cross-compiler and associated tooling, and the target, which contains a target root filesystem that is configured for the SDK usage. These two images reside in SDK_OUTPUT, which consists of the following:

     ${SDK_OUTPUT}/${SDK_ARCH}-nativesdk-pkgs
     ${SDK_OUTPUT}/${SDKTARGETSYSROOT}/target-pkgs
        

Finally, the base populate SDK class creates the toolchain environment setup script, the tarball of the SDK, and the installer.

The respective populate_sdk_deb, populate_sdk_rpm, and populate_sdk_ipk classes each support the specific type of SDK. These classes are inherited by and used with the populate_sdk_base class.

For more information on the cross-development toolchain generation, see the "Cross-Development Toolchain Generation" section. For information on advantages gained when building a cross-development toolchain using the do_populate_sdk task, see the "Building an SDK Installer" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

7.104. prexport.bbclass

The prexport class provides functionality for exporting PR values.

Note

This class is not intended to be used directly. Rather, it is enabled when using "bitbake-prserv-tool export".

7.105. primport.bbclass

The primport class provides functionality for importing PR values.

Note

This class is not intended to be used directly. Rather, it is enabled when using "bitbake-prserv-tool import".

7.106. prserv.bbclass

The prserv class provides functionality for using a PR service in order to automatically manage the incrementing of the PR variable for each recipe.

This class is enabled by default because it is inherited by the package class. However, the OpenEmbedded build system will not enable the functionality of this class unless PRSERV_HOST has been set.

7.107. ptest.bbclass

The ptest class provides functionality for packaging and installing runtime tests for recipes that build software that provides these tests.

This class is intended to be inherited by individual recipes. However, the class' functionality is largely disabled unless "ptest" appears in DISTRO_FEATURES. See the "Testing Packages With ptest" section in the Yocto Project Development Manual for more information on ptest.

7.108. ptest-gnome.bbclass

Enables package tests (ptests) specifically for GNOME packages, which have tests intended to be executed with gnome-desktop-testing.

For information on setting up and running ptests, see the "Testing Packages With ptest" section in the Yocto Project Development Manual.

7.109. python-dir.bbclass

The python-dir class provides the base version, location, and site package location for Python.

7.110. python3native.bbclass

The python3native class supports using the native version of Python 3 built by the build system rather than support of the version provided by the build host.

7.111. pythonnative.bbclass

When inherited by a recipe, the pythonnative class supports using the native version of Python built by the build system rather than using the version provided by the build host.

7.112. qemu.bbclass

The qemu class provides functionality for recipes that either need QEMU or test for the existence of QEMU. Typically, this class is used to run programs for a target system on the build host using QEMU's application emulation mode.

7.113. recipe_sanity.bbclass

The recipe_sanity class checks for the presence of any host system recipe prerequisites that might affect the build (e.g. variables that are set or software that is present).

7.114. relocatable.bbclass

The relocatable class enables relocation of binaries when they are installed into the sysroot.

This class makes use of the chrpath class and is used by both the cross and native classes.

7.115. remove-libtool.bbclass

The remove-libtool class adds a post function to the do_install task to remove all .la files installed by libtool. Removing these files results in them being absent from both the sysroot and target packages.

If a recipe needs the .la files to be installed, then the recipe can override the removal by setting REMOVE_LIBTOOL_LA to "0" as follows:

     REMOVE_LIBTOOL_LA = "0"
        

Note

The remove-libtool class is not enabled by default.

7.116. report-error.bbclass

The report-error class supports enabling the error reporting tool, which allows you to submit build error information to a central database.

The class collects debug information for recipe, recipe version, task, machine, distro, build system, target system, host distro, branch, commit, and log. From the information, report files using a JSON format are created and stored in ${LOG_DIR}/error-report.

7.117. rm_work.bbclass

The rm_work class supports deletion of temporary workspace, which can ease your hard drive demands during builds.

The OpenEmbedded build system can use a substantial amount of disk space during the build process. A portion of this space is the work files under the ${TMPDIR}/work directory for each recipe. Once the build system generates the packages for a recipe, the work files for that recipe are no longer needed. However, by default, the build system preserves these files for inspection and possible debugging purposes. If you would rather have these files deleted to save disk space as the build progresses, you can enable rm_work by adding the following to your local.conf file, which is found in the Build Directory.

    INHERIT += "rm_work"
        

If you are modifying and building source code out of the work directory for a recipe, enabling rm_work will potentially result in your changes to the source being lost. To exclude some recipes from having their work directories deleted by rm_work, you can add the names of the recipe or recipes you are working on to the RM_WORK_EXCLUDE variable, which can also be set in your local.conf file. Here is an example:

    RM_WORK_EXCLUDE += "busybox glibc"
        

7.118. rootfs*.bbclass

The rootfs* classes support creating the root filesystem for an image and consist of the following classes:

  • The rootfs-postcommands class, which defines filesystem post-processing functions for image recipes.

  • The rootfs_deb class, which supports creation of root filesystems for images built using .deb packages.

  • The rootfs_rpm class, which supports creation of root filesystems for images built using .rpm packages.

  • The rootfs_ipk class, which supports creation of root filesystems for images built using .ipk packages.

  • The rootfsdebugfiles class, which installs additional files found on the build host directly into the root filesystem.

The root filesystem is created from packages using one of the rootfs*.bbclass files as determined by the PACKAGE_CLASSES variable.

For information on how root filesystem images are created, see the "Image Generation" section.

7.119. sanity.bbclass

The sanity class checks to see if prerequisite software is present on the host system so that users can be notified of potential problems that might affect their build. The class also performs basic user configuration checks from the local.conf configuration file to prevent common mistakes that cause build failures. Distribution policy usually determines whether to include this class.

7.120. scons.bbclass

The scons class supports recipes that need to build software that uses the SCons build system. You can use the EXTRA_OESCONS variable to specify additional configuration options you want to pass SCons command line.

7.121. sdl.bbclass

The sdl class supports recipes that need to build software that uses the Simple DirectMedia Layer (SDL) library.

7.122. setuptools.bbclass

The setuptools class supports Python version 2.x extensions that use build systems based on setuptools. If your recipe uses these build systems, the recipe needs to inherit the setuptools class.

7.123. setuptools3.bbclass

The setuptools3 class supports Python version 3.x extensions that use build systems based on setuptools3. If your recipe uses these build systems, the recipe needs to inherit the setuptools3 class.

7.124. sign_rpm.bbclass

The sign_rpm class supports generating signed RPM packages.

7.125. sip.bbclass

The sip class supports recipes that build or package SIP-based Python bindings.

7.126. siteconfig.bbclass

The siteconfig class provides functionality for handling site configuration. The class is used by the autotools class to accelerate the do_configure task.

7.127. siteinfo.bbclass

The siteinfo class provides information about the targets that might be needed by other classes or recipes.

As an example, consider Autotools, which can require tests that must execute on the target hardware. Since this is not possible in general when cross compiling, site information is used to provide cached test results so these tests can be skipped over but still make the correct values available. The meta/site directory contains test results sorted into different categories such as architecture, endianness, and the libc used. Site information provides a list of files containing data relevant to the current build in the CONFIG_SITE variable that Autotools automatically picks up.

The class also provides variables like SITEINFO_ENDIANNESS and SITEINFO_BITS that can be used elsewhere in the metadata.

Because the base class includes the siteinfo class, it is always active.

7.128. spdx.bbclass

The spdx class integrates real-time license scanning, generation of SPDX standard output, and verification of license information during the build.

Note

This class is currently at the prototype stage in the 1.6 release.

7.129. sstate.bbclass

The sstate class provides support for Shared State (sstate). By default, the class is enabled through the INHERIT_DISTRO variable's default value.

For more information on sstate, see the "Shared State Cache" section.

7.130. staging.bbclass

The staging class provides the do_populate_sysroot task, which stages files into the sysroot to make them available to other recipes at build time. The class is enabled by default because it is inherited by the base class.

7.131. syslinux.bbclass

The syslinux class provides syslinux-specific functions for building bootable images.

The class supports the following variables:

  • INITRD: Indicates list of filesystem images to concatenate and use as an initial RAM disk (initrd). This variable is optional.

  • ROOTFS: Indicates a filesystem image to include as the root filesystem. This variable is optional.

  • AUTO_SYSLINUXMENU: Enables creating an automatic menu when set to "1".

  • LABELS: Lists targets for automatic configuration.

  • APPEND: Lists append string overrides for each label.

  • SYSLINUX_OPTS: Lists additional options to add to the syslinux file. Semicolon characters separate multiple options.

  • SYSLINUX_SPLASH: Lists a background for the VGA boot menu when you are using the boot menu.

  • SYSLINUX_DEFAULT_CONSOLE: Set to "console=ttyX" to change kernel boot default console.

  • SYSLINUX_SERIAL: Sets an alternate serial port. Or, turns off serial when the variable is set with an empty string.

  • SYSLINUX_SERIAL_TTY: Sets an alternate "console=tty..." kernel boot argument.

7.132. systemd.bbclass

The systemd class provides support for recipes that install systemd unit files.

The functionality for this class is disabled unless you have "systemd" in DISTRO_FEATURES.

Under this class, the recipe or Makefile (i.e. whatever the recipe is calling during the do_install task) installs unit files into ${D}${systemd_unitdir}/system. If the unit files being installed go into packages other than the main package, you need to set SYSTEMD_PACKAGES in your recipe to identify the packages in which the files will be installed.

You should set SYSTEMD_SERVICE to the name of the service file. You should also use a package name override to indicate the package to which the value applies. If the value applies to the recipe's main package, use ${PN}. Here is an example from the connman recipe:

     SYSTEMD_SERVICE_${PN} = "connman.service"
        

Services are set up to start on boot automatically unless you have set SYSTEMD_AUTO_ENABLE to "disable".

For more information on systemd, see the "Selecting an Initialization Manager" section in the Yocto Project Development Manual.

7.133. systemd-boot.bbclass

The systemd-boot class provides functions specific to the systemd-boot bootloader for building bootable images. This is an internal class and is not intended to be used directly.

Note

The systemd-boot class is a result from merging the gummiboot class used in previous Yocto Project releases with the systemd project.

Set the EFI_PROVIDER variable to "systemd-boot" to use this class. Doing so creates a standalone EFI bootloader that is not dependent on systemd.

For information on more variables used and supported in this class, see the SYSTEMD_BOOT_CFG, SYSTEMD_BOOT_ENTRIES, and SYSTEMD_BOOT_TIMEOUT variables.

You can also see the Systemd-boot documentation for more information.

7.134. terminal.bbclass

The terminal class provides support for starting a terminal session. The OE_TERMINAL variable controls which terminal emulator is used for the session.

Other classes use the terminal class anywhere a separate terminal session needs to be started. For example, the patch class assuming PATCHRESOLVE is set to "user", the cml1 class, and the devshell class all use the terminal class.

7.135. testimage*.bbclass

The testimage* classes support running automated tests against images using QEMU and on actual hardware. The classes handle loading the tests and starting the image. To use the classes, you need to perform steps to set up the environment.

The tests are commands that run on the target system over ssh. Each test is written in Python and makes use of the unittest module.

The testimage.bbclass runs tests on an image when called using the following:

     $ bitbake -c testimage image
        

The testimage-auto class runs tests on an image after the image is constructed (i.e. TEST_IMAGE must be set to "1").

For information on how to enable, run, and create new tests, see the "Performing Automated Runtime Testing" section in the Yocto Project Development Manual.

7.136. testsdk.bbclass

This class supports running automated tests against software development kits (SDKs). The testsdk class runs tests on an SDK when called using the following:

     $ bitbake -c testsdk image
        

7.137. texinfo.bbclass

This class should be inherited by recipes whose upstream packages invoke the texinfo utilities at build-time. Native and cross recipes are made to use the dummy scripts provided by texinfo-dummy-native, for improved performance. Target architecture recipes use the genuine Texinfo utilities. By default, they use the Texinfo utilities on the host system.

Note

If you want to use the Texinfo recipe shipped with the build system, you can remove "texinfo-native" from ASSUME_PROVIDED and makeinfo from SANITY_REQUIRED_UTILITIES.

7.138. tinderclient.bbclass

The tinderclient class submits build results to an external Tinderbox instance.

Note

This class is currently unmaintained.

7.139. toaster.bbclass

The toaster class collects information about packages and images and sends them as events that the BitBake user interface can receive. The class is enabled when the Toaster user interface is running.

This class is not intended to be used directly.

7.140. toolchain-scripts.bbclass

The toolchain-scripts class provides the scripts used for setting up the environment for installed SDKs.

7.141. typecheck.bbclass

The typecheck class provides support for validating the values of variables set at the configuration level against their defined types. The OpenEmbedded build system allows you to define the type of a variable using the "type" varflag. Here is an example:

     IMAGE_FEATURES[type] = "list"
        

7.142. uboot-config.bbclass

The uboot-config class provides support for U-Boot configuration for a machine. Specify the machine in your recipe as follows:

     UBOOT_CONFIG ??= <default>
     UBOOT_CONFIG[foo] = "config,images"
        

You can also specify the machine using this method:

     UBOOT_MACHINE = "config"
        

See the UBOOT_CONFIG and UBOOT_MACHINE variables for additional information.

7.143. uninative.bbclass

Attempts to isolate the build system from the host distribution's C library in order to make re-use of native shared state artifacts across different host distributions practical. With this class enabled, a tarball containing a pre-built C library is downloaded at the start of the build. In the Poky reference distribution this is enabled by default through meta/conf/distro/include/yocto-uninative.inc. Other distributions that do not derive from poky can also "require conf/distro/include/yocto-uninative.inc" to use this. Alternatively if you prefer, you can build the uninative-tarball recipe yourself, publish the resulting tarball (e.g. via HTTP) and set UNINATIVE_URL and UNINATIVE_CHECKSUM appropriately. For an example, see the meta/conf/distro/include/yocto-uninative.inc.

7.144. update-alternatives.bbclass

The update-alternatives class helps the alternatives system when multiple sources provide the same command. This situation occurs when several programs that have the same or similar function are installed with the same name. For example, the ar command is available from the busybox, binutils and elfutils packages. The update-alternatives class handles renaming the binaries so that multiple packages can be installed without conflicts. The ar command still works regardless of which packages are installed or subsequently removed. The class renames the conflicting binary in each package and symlinks the highest priority binary during installation or removal of packages.

To use this class, you need to define a number of variables:

These variables list alternative commands needed by a package, provide pathnames for links, default links for targets, and so forth. For details on how to use this class, see the comments in the update-alternatives.bbclass.

Note

You can use the update-alternatives command directly in your recipes. However, this class simplifies things in most cases.

7.145. update-rc.d.bbclass

The update-rc.d class uses update-rc.d to safely install an initialization script on behalf of the package. The OpenEmbedded build system takes care of details such as making sure the script is stopped before a package is removed and started when the package is installed.

Three variables control this class: INITSCRIPT_PACKAGES, INITSCRIPT_NAME and INITSCRIPT_PARAMS. See the variable links for details.

7.146. useradd*.bbclass

The useradd* classes support the addition of users or groups for usage by the package on the target. For example, if you have packages that contain system services that should be run under their own user or group, you can use these classes to enable creation of the user or group. The meta-skeleton/recipes-skeleton/useradd/useradd-example.bb recipe in the Source Directory provides a simple example that shows how to add three users and groups to two packages. See the useradd-example.bb recipe for more information on how to use these classes.

The useradd_base class provides basic functionality for user or groups settings.

The useradd* classes support the USERADD_PACKAGES, USERADD_PARAM, GROUPADD_PARAM, and GROUPMEMS_PARAM variables.

The useradd-staticids class supports the addition of users or groups that have static user identification (uid) and group identification (gid) values.

The default behavior of the OpenEmbedded build system for assigning uid and gid values when packages add users and groups during package install time is to add them dynamically. This works fine for programs that do not care what the values of the resulting users and groups become. In these cases, the order of the installation determines the final uid and gid values. However, if non-deterministic uid and gid values are a problem, you can override the default, dynamic application of these values by setting static values. When you set static values, the OpenEmbedded build system looks in BBPATH for files/passwd and files/group files for the values.

To use static uid and gid values, you need to set some variables. See the USERADDEXTENSION, USERADD_UID_TABLES, USERADD_GID_TABLES, and USERADD_ERROR_DYNAMIC variables. You can also see the useradd class for additional information.

Notes

You do not use the useradd-staticids class directly. You either enable or disable the class by setting the USERADDEXTENSION variable. If you enable or disable the class in a configured system, TMPDIR might contain incorrect uid and gid values. Deleting the TMPDIR directory will correct this condition.

7.147. utility-tasks.bbclass

The utility-tasks class provides support for various "utility" type tasks that are applicable to all recipes, such as do_clean and do_listtasks.

This class is enabled by default because it is inherited by the base class.

7.148. utils.bbclass

The utils class provides some useful Python functions that are typically used in inline Python expressions (e.g. ${@...}). One example use is for bb.utils.contains().

This class is enabled by default because it is inherited by the base class.

7.149. vala.bbclass

The vala class supports recipes that need to build software written using the Vala programming language.

7.150. waf.bbclass

The waf class supports recipes that need to build software that uses the Waf build system. You can use the EXTRA_OECONF or PACKAGECONFIG_CONFARGS variables to specify additional configuration options to be passed on the Waf command line.

Chapter 8. Tasks

Tasks are units of execution for BitBake. Recipes (.bb files) use tasks to complete configuring, compiling, and packaging software. This chapter provides a reference of the tasks defined in the OpenEmbedded build system.

8.1. Normal Recipe Build Tasks

The following sections describe normal tasks associated with building a recipe. For more information on tasks and dependencies, see the "Tasks" and "Dependencies" sections in the BitBake User Manual.

8.1.1. do_build

The default task for all recipes. This task depends on all other normal tasks required to build a recipe.

8.1.2. do_compile

Compiles the source code. This task runs with the current working directory set to ${B}.

The default behavior of this task is to run the oe_runmake function if a makefile (Makefile, makefile, or GNUmakefile) is found. If no such file is found, the do_compile task does nothing.

8.1.3. do_compile_ptest_base

Compiles the runtime test suite included in the software being built.

8.1.4. do_configure

Configures the source by enabling and disabling any build-time and configuration options for the software being built. The task runs with the current working directory set to ${B}.

The default behavior of this task is to run oe_runmake clean if a makefile (Makefile, makefile, or GNUmakefile) is found and CLEANBROKEN is not set to "1". If no such file is found or the CLEANBROKEN variable is set to "1", the do_configure task does nothing.

8.1.5. do_configure_ptest_base

Configures the runtime test suite included in the software being built.

8.1.6. do_deploy

Writes output files that are to be deployed to ${DEPLOY_DIR_IMAGE}. The task runs with the current working directory set to ${B}.

Recipes implementing this task should inherit the deploy class and should write the output to ${DEPLOYDIR}, which is not to be confused with ${DEPLOY_DIR}. The deploy class sets up do_deploy as a shared state (sstate) task that can be accelerated through sstate use. The sstate mechanism takes care of copying the output from ${DEPLOYDIR} to ${DEPLOY_DIR_IMAGE}.

Caution

Do not write the output directly to ${DEPLOY_DIR_IMAGE}, as this causes the sstate mechanism to malfunction.

The do_deploy task is not added as a task by default and consequently needs to be added manually. If you want the task to run after do_compile, you can add it by doing the following:

     addtask deploy after do_compile
            

Adding do_deploy after other tasks works the same way.

Note

You do not need to add before do_build to the addtask command (though it is harmless), because the base class contains the following:
     do_build[recrdeptask] += "do_deploy"
                
See the "Dependencies" section in the BitBake User Manual for more information.

If the do_deploy task re-executes, any previous output is removed (i.e. "cleaned").

8.1.7. do_distrodata

Provides information about the recipe.

The distrodata task is included as part of the distrodata class.

To build the distrodata task, use the bitbake command with the "-c" option and task name:

     $ bitbake core-image-minimal -c distrodata
            

By default, the results are stored in $LOG_DIR (e.g. $BUILD_DIR/tmp/log).

8.1.8. do_fetch

Fetches the source code. This task uses the SRC_URI variable and the argument's prefix to determine the correct fetcher module.

8.1.9. do_image

Starts the image generation process. The do_image task runs after the OpenEmbedded build system has run the do_rootfs task during which packages are identified for installation into the image and the root filesystem is created, complete with post-processing.

The do_image task performs pre-processing on the image through the IMAGE_PREPROCESS_COMMAND and dynamically generates supporting do_image_* tasks as needed.

For more information on image creation, see the "Image Generation" section.

8.1.10. do_image_complete

Completes the image generation process. The do_image_complete task runs after the OpenEmbedded build system has run the do_image task during which image pre-processing occurs and through dynamically generated do_image_* tasks the image is constructed.

The do_image_complete task performs post-processing on the image through the IMAGE_POSTPROCESS_COMMAND.

For more information on image creation, see the "Image Generation" section.

8.1.11. do_install

Copies files that are to be packaged into the holding area ${D}. This task runs with the current working directory set to ${B}, which is the compilation directory. The do_install task, as well as other tasks that either directly or indirectly depend on the installed files (e.g. do_package, do_package_write_*, and do_rootfs), run under fakeroot.

Caution

When installing files, be careful not to set the owner and group IDs of the installed files to unintended values. Some methods of copying files, notably when using the recursive cp command, can preserve the UID and/or GID of the original file, which is usually not what you want. The host-user-contaminated QA check checks for files that probably have the wrong ownership.

Safe methods for installing files include the following:

  • The install utility. This utility is the preferred method.

  • The cp command with the "--no-preserve=ownership" option.

  • The tar command with the "--no-same-owner" option. See the bin_package.bbclass file in the meta/classes directory of the Source Directory for an example.

8.1.12. do_install_ptest_base

Copies the runtime test suite files from the compilation directory to a holding area.

8.1.13. do_package

Analyzes the content of the holding area ${D} and splits the content into subsets based on available packages and files. This task makes use of the PACKAGES and FILES variables.

The do_package task, in conjunction with the do_packagedata task, also saves some important package metadata. For additional information, see the PKGDESTWORK variable and the "Automatically Added Runtime Dependencies" section.

8.1.14. do_package_qa

Runs QA checks on packaged files. For more information on these checks, see the insane class.

8.1.15. do_package_write_deb

Creates Debian packages (i.e. *.deb files) and places them in the ${DEPLOY_DIR_DEB} directory in the package feeds area. For more information, see the "Package Feeds" section.

8.1.16. do_package_write_ipk

Creates IPK packages (i.e. *.ipk files) and places them in the ${DEPLOY_DIR_IPK} directory in the package feeds area. For more information, see the "Package Feeds" section.

8.1.17. do_package_write_rpm

Creates RPM packages (i.e. *.rpm files) and places them in the ${DEPLOY_DIR_RPM} directory in the package feeds area. For more information, see the "Package Feeds" section.

8.1.18. do_package_write_tar

Creates tarballs and places them in the ${DEPLOY_DIR_TAR} directory in the package feeds area. For more information, see the "Package Feeds" section.

8.1.19. do_packagedata

Saves package metadata generated by the do_package task in PKGDATA_DIR to make it available globally.

8.1.20. do_patch

Locates patch files and applies them to the source code. See the "Patching" section for more information.

8.1.21. do_populate_lic

Writes license information for the recipe that is collected later when the image is constructed.

8.1.22. do_populate_sdk

Creates the file and directory structure for an installable SDK. See the "SDK Generation" section for more information.

8.1.23. do_populate_sysroot

Stages (copies) a subset of the files installed by the do_install task into the appropriate sysroot. For information on how to access these files from other recipes, see the STAGING_DIR* variables. Directories that would typically not be needed by other recipes at build time (e.g. /etc) are not copied by default.

For information on what directories are copied by default, see the SYSROOT_DIRS* variables. You can change these variables inside your recipe if you need to make additional (or fewer) directories available to other recipes at build time.

The do_populate_sysroot task is a shared state (sstate) task, which means that the task can be accelerated through sstate use. Realize also that if the task is re-executed, any previous output is removed (i.e. "cleaned").

8.1.24. do_rm_work

Removes work files after the OpenEmbedded build system has finished with them. You can learn more by looking at the "rm_work.bbclass" section.

8.1.25. do_rm_work_all

Top-level task for removing work files after the build system has finished with them.

8.1.26. do_unpack

Unpacks the source code into a working directory pointed to by ${WORKDIR}. The S variable also plays a role in where unpacked source files ultimately reside. For more information on how source files are unpacked, see the "Source Fetching" section and the WORKDIR and S variable descriptions.

8.2. Manually Called Tasks

These tasks are typically manually triggered (e.g. by using the bitbake -c command-line option):

8.2.1. do_checkpkg

Provides information about the recipe including its upstream version and status. The upstream version and status reveals whether or not a version of the recipe exists upstream and a status of not updated, updated, or unknown.

The checkpkg task is included as part of the distrodata class.

To build the checkpkg task, use the bitbake command with the "-c" option and task name:

     $ bitbake core-image-minimal -c checkpkg
            

By default, the results are stored in $LOG_DIR (e.g. $BUILD_DIR/tmp/log).

8.2.2. do_checkuri

Validates the SRC_URI value.

8.2.3. do_checkuriall

Validates the SRC_URI value for all recipes required to build a target.

8.2.4. do_clean

Removes all output files for a target from the do_unpack task forward (i.e. do_unpack, do_configure, do_compile, do_install, and do_package).

You can run this task using BitBake as follows:

     $ bitbake -c clean recipe
            

Running this task does not remove the sstate) cache files. Consequently, if no changes have been made and the recipe is rebuilt after cleaning, output files are simply restored from the sstate cache. If you want to remove the sstate cache files for the recipe, you need to use the do_cleansstate task instead (i.e. bitbake -c cleansstate recipe).

8.2.5. do_cleanall

Removes all output files, shared state (sstate) cache, and downloaded source files for a target (i.e. the contents of DL_DIR). Essentially, the do_cleanall task is identical to the do_cleansstate task with the added removal of downloaded source files.

You can run this task using BitBake as follows:

     $ bitbake -c cleanall recipe
            

Typically, you would not normally use the cleanall task. Do so only if you want to start fresh with the do_fetch task.

8.2.6. do_cleansstate

Removes all output files and shared state (sstate) cache for a target. Essentially, the do_cleansstate task is identical to the do_clean task with the added removal of shared state (sstate) cache.

You can run this task using BitBake as follows:

     $ bitbake -c cleansstate recipe
            

When you run the do_cleansstate task, the OpenEmbedded build system no longer uses any sstate. Consequently, building the recipe from scratch is guaranteed.

Note

The do_cleansstate task cannot remove sstate from a remote sstate mirror. If you need to build a target from scratch using remote mirrors, use the "-f" option as follows:
     $ bitbake -f -c do_cleansstate target
                

8.2.7. do_devpyshell

Starts a shell in which an interactive Python interpreter allows you to interact with the BitBake build environment. From within this shell, you can directly examine and set bits from the data store and execute functions as if within the BitBake environment. See the "Using a Development Python Shell" section in the Yocto Project Development Manual for more information about using devpyshell.

8.2.8. do_devshell

Starts a shell whose environment is set up for development, debugging, or both. See the "Using a Development Shell" section in the Yocto Project Development Manual for more information about using devshell.

8.2.9. do_fetchall

Fetches all remote sources required to build a target.

8.2.10. do_listtasks

Lists all defined tasks for a target.

8.2.11. do_package_index

Creates or updates the index in the Package Feeds area.

Note

This task is not triggered with the bitbake -c command-line option as are the other tasks in this section. Because this task is specifically for the package-index recipe, you run it using bitbake package-index.

The following tasks are applicable to image recipes.

8.3.1. do_bootimg

Creates a bootable live image. See the IMAGE_FSTYPES variable for additional information on live image types.

8.3.2. do_bundle_initramfs

Combines an initial RAM disk (initramfs) image and kernel together to form a single image. The CONFIG_INITRAMFS_SOURCE variable has some more information about these types of images.

8.3.3. do_rootfs

Creates the root filesystem (file and directory structure) for an image. See the "Image Generation" section for more information on how the root filesystem is created.

8.3.4. do_testimage

Boots an image and performs runtime tests within the image. For information on automatically testing images, see the "Performing Automated Runtime Testing" section in the Yocto Project Development Manual.

8.3.5. do_testimage_auto

Boots an image and performs runtime tests within the image immediately after it has been built. This task is enabled when you set TEST_IMAGE equal to "1".

For information on automatically testing images, see the "Performing Automated Runtime Testing" section in the Yocto Project Development Manual.

8.3.6. do_vmdkimg

Creates a .vmdk image for use with VMware and compatible virtual machine hosts.

The following tasks are applicable to kernel recipes. Some of these tasks (e.g. the do_menuconfig task) are also applicable to recipes that use Linux kernel style configuration such as the BusyBox recipe.

8.4.1. do_compile_kernelmodules

Compiles loadable modules for the Linux kernel.

8.4.2. do_diffconfig

Compares the old and new config files after running the do_menuconfig task for the kernel.

8.4.3. do_kernel_checkout

Checks out source/meta branches for a linux-yocto style kernel.

8.4.4. do_kernel_configcheck

Validates the kernel configuration for a linux-yocto style kernel.

8.4.5. do_kernel_configme

Assembles the kernel configuration for a linux-yocto style kernel.

Creates a symbolic link in arch/$arch/boot for vmlinux kernel images.

8.4.7. do_kernel_metadata

Collects kernel metadata for a linux-yocto style kernel.

8.4.8. do_menuconfig

Runs make menuconfig for the kernel. For information on menuconfig, see the "Using  menuconfig" section in the Yocto Project Development Manual.

8.4.9. do_savedefconfig

Creates a minimal Linux kernel configuration file.

8.4.10. do_shared_workdir

Creates the shared working directory for the kernel.

8.4.11. do_sizecheck

Checks the size of the kernel image against KERNEL_IMAGE_MAXSIZE when set.

8.4.12. do_strip

Strips unneeded sections out of the Linux kernel image.

8.4.13. do_uboot_mkimage

Creates a uImage file from the kernel for the U-Boot bootloader.

8.4.14. do_validate_branches

Ensures that the source, metadata (or both) branches are on the locations specified by their SRCREV values for a linux-yocto style kernel.

8.5. Miscellaneous Tasks

The following sections describe miscellaneous tasks.

8.5.1. do_spdx

A build stage that takes the source code and scans it on a remote FOSSOLOGY server in order to produce an SPDX document. This task applies only to the spdx class.

Chapter 9. devtool Quick Reference

The devtool command-line tool provides a number of features that help you build, test, and package software. This command is available alongside the bitbake command. Additionally, the devtool command is a key part of the extensible SDK.

This chapter provides a Quick Reference for the devtool command. For more information on how to apply the command when using the extensible SDK, see the "Using the Extensible SDK" section in the Yocto Project Software Development Kit (SDK) Developer's Guide.

9.1. Getting Help

The devtool command line is organized similarly to Git in that it has a number of sub-commands for each function. You can run devtool --help to see all the commands:

     $ devtool --help
     usage: devtool [--basepath BASEPATH] [--bbpath BBPATH] [-d] [-q]
                    [--color COLOR] [-h]
                    <subcommand> ...

     OpenEmbedded development tool

     options:
       --basepath BASEPATH  Base directory of SDK / build directory
       --bbpath BBPATH      Explicitly specify the BBPATH, rather than getting it
                            from the metadata
       -d, --debug          Enable debug output
       -q, --quiet          Print only errors
       --color COLOR        Colorize output (where COLOR is auto, always, never)
       -h, --help           show this help message and exit

     subcommands:
       Beginning work on a recipe:
         add                  Add a new recipe
         modify               Modify the source for an existing recipe
         upgrade              Upgrade an existing recipe
       Getting information:
         status               Show workspace status
         search               Search available recipes
       Working on a recipe in the workspace:
         edit-recipe          Edit a recipe file in your workspace
         configure-help       Get help on configure script options
         build                Build a recipe
         update-recipe        Apply changes from external source tree to recipe
         reset                Remove a recipe from your workspace
         finish               Finish working on a recipe in your workspace
       Testing changes on target:
         deploy-target        Deploy recipe output files to live target machine
         undeploy-target      Undeploy recipe output files in live target machine
         build-image          Build image including workspace recipe packages
       Advanced:
         create-workspace     Set up workspace in an alternative location
         extract              Extract the source for an existing recipe
         sync                 Synchronize the source tree for an existing recipe
     Use devtool <subcommand> --help to get help on a specific command
            

As directed in the general help output, you can get more syntax on a specific command by providing the command name and using --help:

     $ devtool add --help
     usage: devtool add [-h] [--same-dir | --no-same-dir] [--fetch URI]
                        [--version VERSION] [--no-git] [--autorev] [--binary]
                        [--also-native] [--src-subdir SUBDIR]
                        [recipename] [srctree] [fetchuri]

     Adds a new recipe to the workspace to build a specified source tree. Can
     optionally fetch a remote URI and unpack it to create the source tree.

     arguments:
       recipename            Name for new recipe to add (just name - no version,
                             path or extension). If not specified, will attempt to
                             auto-detect it.
       srctree               Path to external source tree. If not specified, a
                             subdirectory of
                             /home/scottrif/poky/build/workspace/sources will be
                             used.
       fetchuri              Fetch the specified URI and extract it to create the
                             source tree

     options:
       -h, --help            show this help message and exit
       --same-dir, -s        Build in same directory as source
       --no-same-dir         Force build in a separate build directory
       --fetch URI, -f URI   Fetch the specified URI and extract it to create the
                             source tree (deprecated - pass as positional argument
                             instead)
       --version VERSION, -V VERSION
                             Version to use within recipe (PV)
       --no-git, -g          If fetching source, do not set up source tree as a git
                             repository
       --autorev, -a         When fetching from a git repository, set SRCREV in the
                             recipe to a floating revision instead of fixed
       --binary, -b          Treat the source tree as something that should be
                             installed verbatim (no compilation, same directory
                             structure). Useful with binary packages e.g. RPMs.
       --also-native         Also add native variant (i.e. support building recipe
                             for the build host as well as the target machine)
       --src-subdir SUBDIR   Specify subdirectory within source tree to use
            

9.2. The Workspace Layer Structure

devtool uses a "Workspace" layer in which to accomplish builds. This layer is not specific to any single devtool command but is rather a common working area used across the tool.

The following figure shows the workspace structure:

     attic - A directory created if devtool believes it preserve
             anything when you run "devtool reset".  For example, if you
             run "devtool add", make changes to the recipe, and then
             run "devtool reset", devtool takes notice that the file has
             been changed and moves it into the attic should you still
             want the recipe.

     README - Provides information on what is in workspace layer and how to
              manage it.

     .devtool_md5 - A checksum file used by devtool.

     appends - A directory that contains *.bbappend files, which point to
               external source.

     conf - A configuration directory that contains the layer.conf file.

     recipes - A directory containing recipes.  This directory contains a
               folder for each directory added whose name matches that of the
               added recipe.  devtool places the recipe.bb file
               within that sub-directory.

     sources - A directory containing a working copy of the source files used
               when building the recipe.  This is the default directory used
               as the location of the source tree when you do not provide a
               source tree path.  This directory contains a folder for each
               set of source files matched to a corresponding recipe.
            

9.3. Adding a New Recipe to the Workspace Layer

Use the devtool add command to add a new recipe to the workspace layer. The recipe you add should not exist - devtool creates it for you. The source files the recipe uses should exist in an external area.

The following example creates and adds a new recipe named jackson to a workspace layer the tool creates. The source code built by the recipes resides in /home/scottrif/sources/jackson:

     $ devtool add jackson /home/scottrif/sources/jackson
            

If you add a recipe and the workspace layer does not exist, the c