yocto assignment operators

QE Development

Yocto: How to assign variables with examples

• = A hard assignment. The variable is assigned as soon as the statement is evaluated. If the assignment contains a reference to another variable then that reference will be included in the assignment rather that the value of the reference.
• ?= Defines a variable only if it is undefined at the time of parsing.
• ??= Assignment does not occur until the end of the parsing process.
• := Immediate variable expansion
• += Appending with spaces.
• =+ Prepending with spaces.
• .= Appending without spaces.
• =. Prepending without spaces.

Assignment Using Overrides

Variables can be appended or prepended using the override style syntax. In the example below B becomes equal to “bval additional data” and C becomes equal to “additional data cval”. Note that no additional spaces are include over what is in the original variable definitions.

Removal of data can also be accomplished. In the following example FOO becomes equal to “ghi abcdef”. Note that surrounding spaces are also removed.

In the following example the value of A is set to “aval”. The value of B is set to “pre${A}post”. In other words the value of B becomes dependent on the value of A at the times it is referenced. If the value of A changes between references to B the value of B will be different at those times.

The following code includes some immediate variable assignment. The value of A becomes “test 123” as the values of A and B are unassigned at the time of As assignment.

The following code uses a soft assignment. A is only assigned if the value is currently unassigned. The code therefore results in A being given the value of “one”

The following code uses weak assignment. A is not assigned until the end of the parsing process and is therefore given a value of “two”

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

One-Stop Repository for all that wish to skim through or deep-dive into Yocto Project

shantanoo-desai/yoctoproject-cheatsheet

Folders and files, repository files navigation, yocto project cheatsheet.

A summary of all things one might need to work with Yocto Project . One stop repository for Yocto since there are so many variables and CLIs to work with.

Contributing

Please feel free to add / adapt the list accordingly via PRs. As OE/Yocto Project still has a steep learning-curve, a better way would be to share resources with the community.

All hints for CLIs like bitbake , bitbake-layers , devtool etc. used within common Yocto Project development

Configuration

All variables that can be added to files like bblayers.conf or local.conf or other configuration files in Yocto.

All miscellaneous resources once can find for understanding the Yocto Project and working with it.

Documentation / Websites

• repo Command Reference
• OpenEmbedded Layers Index
• OpenEmbedded Errors Index

Repositories

• yocto-research by @davisRoman
• meta-diet layer, part of Blog by Johan Thelin (@e8johan)
• Yocto part I – baseline boot time
• Yocto part II – baseline image size
• Yocto part III – a custom meta layer
• Yocto part IV – going on a diet
• Bake 64-bit Raspberry Pi 3 images with Yocto, Openembedded
• Yocto Project YouTube Channel
• Live Coding with Yocto Project Playlist
• Paul Barker's YouTube Channel/ Rust with Yocto Project

• Runtime Protection
• Continuous Monitoring
• Threat Detection
• Sternum Labs
• Fundamentals
• Case Studies

SUGGESTED READ

Learn more about Sternum

Get the latest

Join our team

• Free Evaluation Kit

Experience all platform features

• Book a demo

Yocto Project: Components, Use Cases, and a Quick Tutorial

Igal Zeifman

8  min read | min read | 01/08/2023

What Is the Yocto Project

The Yocto Project is an open-source initiative that enables developers to create custom Linux distributions, commonly used for embedded systems and IoT devices. It provides a flexible framework that simplifies the process of developing and maintaining custom Linux distributions.

The Yocto Project is not a Linux distribution itself, but a tool to create one. It’s built from the ground up to support embedded systems development, providing developers with a high degree of control over their software stack. This is particularly advantageous for developers working on devices with specific hardware requirements or performance constraints.

The Yocto Project supports numerous hardware architectures, including x86, ARM, MIPS, and PowerPC. Its standardized build system and extensive cross-compiling support make it an ideal choice for multi-platform development.

Yocto Project Architecture and Components

Here are the primary components that make up the Yocto project framework.

At the heart of the Yocto Project is BitBake, a powerful task executor and scheduler. BitBake reads and interprets metadata, then executes the necessary tasks to build a Linux distribution, such as compiling source code and packaging software.

OpenEmbedded-Core

The OpenEmbedded-Core (OE-Core) is a layer in the Yocto Project that provides the basic functionality for building a Linux distribution. It contains essential metadata, such as machine configurations, distro configurations, and class definitions.

Layers are a fundamental aspect of the Yocto Project’s architecture. They allow developers to organize and separate different parts of a Linux distribution, such as system software, applications, and device drivers.

Poky serves as the reference system of the Yocto Project. It’s a pre-configured build environment that includes BitBake, OE-Core, and a selection of metadata to help developers get started with the Yocto Project.

Metadata in the Yocto Project describes everything needed to build a Linux distribution. This includes information about software packages, configurations, dependencies, and build instructions.

Recipes are one of the most critical types of metadata in the Yocto Project. A recipe describes how to build a software package, including where to fetch the source code, how to configure and compile it, and how to package the resulting binaries.

In the context of the Yocto Project, a toolchain refers to a set of tools used to compile, link, and debug software. The Yocto Project can generate custom toolchains tailored to specific hardware architectures and software configurations.

Use Cases and Applications of the Yocto Project

The Yocto Project is commonly used for:

• Customized Linux distribution development: Yocto provides developers with the tools and resources they need to build a Linux distribution from scratch, tailored to their specific requirements. This is particularly useful in scenarios where commercial Linux distributions are either too bloated or lack the necessary features.
• Embedded systems development: Embedded systems have unique requirements, such as specific hardware compatibility, performance constraints, and limited resources. The Yocto Project supports these needs by supporting numerous hardware architectures and enabling minimal footprint, highly optimized Linux distributions.
• IoT devices: These have similar constraints as embedded systems, such as limited resources and specific performance requirements. The Yocto Project’s ability to create lightweight, customized Linux distributions makes it an excellent choice for IoT device development.
• Automotive systems: The automotive industry has specific requirements for software systems, such as real-time capabilities, robustness, and security. Yocto can support these environments with its flexible architecture and advanced customization.

Benefits and Challenges

Let’s start with the benefits:

• Exceptional flexibility and customizability: Enables the creation of unique Linux distributions tailored to project-specific needs. It lets you include or exclude individual software components to shape the operating system according to the specific hardware or application requirements.
• In-depth customization: Goes beyond software-level customizability by providing control over the configuration of the Linux kernel itself. This granular control is beneficial for projects with unique hardware specifications or distinct performance requirements.
• Adaptability: Allows for quick adjustments to changing project requirements. Users can iterate on their designs, adding or removing software components as the project’s needs evolve, contributing to the project’s success.
• Scalability: Can handle projects of any size, from single embedded device applications to large-scale deployments involving thousands of devices, providing a reliable platform for growth.
• Extensive hardware support: Works with a wide array of processors and devices, including ARM, x86, PowerPC, and MIPS, among others. This allows for the use of the same tool to create customized Linux distributions for diverse hardware architectures, enhancing development efficiency.
• Complex software stacks: Can manage intricate software stacks and applications, from simple web servers to sophisticated IoT devices, with all the necessary tools for complex development tasks.
• Community support: Backed by an active developer community that contributes to its evolution and offers valuable resources for new users. This community support plays a critical role in navigating the learning curve associated with the Yocto Project.
• Compatibility and interoperability: Designed to work seamlessly with a wide variety of open-source projects. This compatibility simplifies the development process and allows users to leverage the capabilities of other projects.

And here are some potential challenges:

• Learning curve: Despite its many benefits, the Yocto Project does come with a steep learning curve. Its complexity and flexibility mean that it can take some time to become comfortable with its usage.
• Time and resource intensive: Building a custom Linux distribution from scratch is not a trivial task. It requires a deep understanding of Linux and embedded systems, as well as significant time to configure and test your distribution.
• The complexity of customization: While the customization offered by the Yocto Project is one of its strengths, it can also be a source of complexity. You need to be careful when customizing your distribution, as changes can have unintended side effects. It requires careful planning and testing to ensure that your custom distribution works as expected.

Yocto Project Quick Start Tutorial

This tutorial is abbreviated from the official Yocto quick start tutorial .

Prerequisites

Your YOCTO build host must adhere to the following requisites:

• Minimum free disk space of 90 GB
• Minimum of 8 GB RAM.
• Multi-core processor is highly recommended.
• Ubuntu 18.04 (LTS), 20.04 (LTS), 22.04 (LTS)
• Fedora 36, Fedora 37
• AlmaLinux 8.7, 9.1
• Debian GNU/Linux 11.x (Bullseye)
• OpenSUSE Leap 15.3, 15.4
• Git 1.8.3.1 or newer
• tar 1.28  or newer
• Python 3.8.0  or newer
• gcc 8.0  or newer
• GNU make 4.0 or newer

In addition, you need to install some packages on your build host. See the official documentation for a command that will install the required packages on your Linux distribution.

Step 1: Cloning the Poky Repository

After getting your machine ready, you’ll need to get a clone of the Poky repository on your build host. Use the command below to clone the Poky repository:

The output looks like this:

Visit the Releases wiki page , and pick a release codename, aligning with either the latest stable release or a Long Term Support release. This tutorial will use the Mickledore release.

Navigate to the poky directory and look at existing branches:

Because this tutorial uses the Mickledore release, use this command to check out the Mickledore branch. This will generate a local branch labeled my-mickledore .

Note: You also should use git pull to regularly update your local files to remain in sync with the release branch by typing the following command in the same directory.

Step 2: Building Your Image

Follow these steps to building your operating system image:

• From within the poky directory, execute the oe-init-build-env environment setup script which establishes the Yocto Project’s build environment on your build host. Among several other tasks, the script generates the Build Directory, in this case called build , located in the source directory. After the execution of the script, your current working directory becomes the Build Directory.
• When you set up the build environment, a local configuration file named local.conf becomes accessible in the conf subdirectory of the Build Directory. This tutorial will use the default configuration, which builds a qemux86 target, suitable for emulation. By default, the RPM package manager is selected as the package manager.

Note: On Ubuntu, we need to install additional development libraries using these commands:

When you are done, you can exit QEMU by either clicking on the shutdown icon or pressing Ctrl-C.

Step 3: Tailoring the Build for Specific Hardware

Up to this point, we built an image that is suitable only for emulation. Let’s see how to tailor your build to specific hardware by integrating a hardware layer. Layers are repositories containing sets of directives and configurations that instruct the Yocto Project on how to proceed.

To integrate a hardware layer:

• Find the most appropriate layer for your needs. There are many hardware layers available in the Yocto Project Source Repositories . This tutorial will add the meta-alter a hardware layer, which integrates your operating system image with Intel Altera hardware.
• Clone the Layer: Utilize Git to make a local copy of the layer on your machine. You can place the copy at the top level of the Poky repository created earlier by running this command: cd pokygit clone https://github.com/kraj/meta-altera.git
• The hardware layer can now be found alongside other layers inside the Poky reference repository on your build host under the title meta-altera . It contains all the metadata needed to support Altera hardware.
• You can modify the configuration to build for a specific machine, using the MACHINE variable in the local.conf file. Let’s set this variable to cyclone5 , the machine configuration for Cyclone V SoC.

Step 4: Creating Your Own Layer

In the previous section, we showed how to create a hardware integration layer based on an existing layer from the Yocto community. In some cases, you might have an application or specific set of behaviors that require a custom layer.

You can use Yocto to create your own general layer. Yocto automates layer creation by setting up a subdirectory with a layer.conf configuration file, a recipes-example subdirectory that contains an example.bb recipe, a licensing file, and a README.

The following command creates a layer named meta-mylayer in the poky directory:

JUMP TO SECTION

Take Sternum for a Test Drive with a Free Evaluation Kit

Enter data to download case study.

By submitting this form, you agree to our Privacy Policy.

Related articles

Understanding and Preventing Memory Leaks with Examples

Lian Granot, Hadas Spektor

5  min read | 28/03/2024

Vulnerability Management: Key Components, Process, and Practices

Hadas spektor.

9  min read | 26/02/2024

NIST Cybersecurity Framework: Structure, Tiers, and What’s New in 2.0

8  min read | 21/02/2024

Looking to learn more? Book a demo with our experts ►►

Lorem ipsum dolor sit amet.

© Sternum 2024 · All rights reserved

• single 5.0.999
• Yocto Project and OpenEmbedded Contributor Guide »
• 3 Recipe Style Guide
• View page source

3 Recipe Style Guide 

3.1 recipe naming conventions .

In general, most recipes should follow the naming convention recipes-category/recipename/recipename_version.bb . Recipes for related projects may share the same recipe directory. recipename and category may contain hyphens, but hyphens are not allowed in version .

If the recipe is tracking a Git revision that does not correspond to a released version of the software, version may be git (e.g. recipename_git.bb ) and the recipe would set PV .

3.2 Version Policy 

Our versions follow the form <epoch>:<version>-<revision> or in BitBake variable terms ${ PE }:${ PV }-${ PR }. We generally follow the Debian version policy which defines these terms.

In most cases the version PV will be set automatically from the recipe file name. It is recommended to use released versions of software as these are revisions that upstream are expecting people to use.

Recipe versions should always compare and sort correctly so that upgrades work as expected. With conventional versions such as 1.4 upgrading to 1.5 this happens naturally, but some versions don’t sort. For example, 1.5 Release Candidate 2 could be written as 1.5rc2 but this sorts after 1.5 , so upgrades from feeds won’t happen correctly.

Instead the tilde ( ~ ) operator can be used, which sorts before the empty string so 1.5~rc2 comes before 1.5 . There is a historical syntax which may be found where PV is set as a combination of the prior version + the pre-release version, for example PV=1.4+1.5rc2 . This is a valid syntax but the tilde form is preferred.

For version comparisons, the opkg-compare-versions program from opkg-utils can be useful when attempting to determine how two version numbers compare to each other. Our definitive version comparison algorithm is the one within bitbake which aims to match those of the package managers and Debian policy closely.

When a recipe references a git revision that does not correspond to a released version of software (e.g. is not a tagged version), the PV variable should include the Git revision using the following to make the version clear:

In this case, <version> should be the most recently released version of the software from the current source revision ( git describe can be useful for determining this). Whilst not recommended for published layers, this format is also useful when using AUTOREV to set the recipe to increment source control revisions automatically, which can be useful during local development.

3.3 Version Number Changes 

The PR variable is used to indicate different revisions of a recipe that reference the same upstream source version. It can be used to force a new version of a recipe to be installed onto a device from a package feed. These once had to be set manually but in most cases these can now be set and incremented automatically by a PR Server connected with a package feed.

When PV increases, any existing PR value can and should be removed.

If PV changes in such a way that it does not increase with respect to the previous value, you need to increase PE to ensure package managers will upgrade it correctly. If unset you should set PE to “1” since the default of empty is easily confused with “0” depending on the package manager. PE can only have an integer value.

3.4 Recipe formatting 

3.4.1 variable formatting .

Variable assignment should a space around each side of the operator, e.g. FOO = "bar" , not FOO="bar" .

Double quotes should be used on the right-hand side of the assignment, e.g. FOO = "bar" not FOO = 'bar'

Spaces should be used for indenting variables, with 4 spaces per tab

Long variables should be split over multiple lines when possible by using the continuation character ( \ )

When splitting a long variable over multiple lines, all continuation lines should be indented (with spaces) to align with the start of the quote on the first line:

Instead of:

3.4.2 Python Function formatting 

Spaces must be used for indenting Python code, with 4 spaces per tab

3.4.3 Shell Function formatting 

The formatting of shell functions should be consistent within layers. Some use tabs, some use spaces.

3.5 Recipe metadata 

3.5.1 required variables .

The following variables should be included in all recipes:

SUMMARY : a one line description of the upstream project

DESCRIPTION : an extended description of the upstream project, possibly with multiple lines. If no reasonable description can be written, this may be omitted as it defaults to SUMMARY .

HOMEPAGE : the URL to the upstream projects homepage.

BUGTRACKER : the URL upstream projects bug tracking website, if applicable.

3.5.2 Recipe Ordering 

When a variable is defined in recipes and classes, variables should follow the general order when possible:

DESCRIPTION

LIC_FILES_CHKSUM

inherit ...

PACKAGECONFIG

Build class specific variables such as EXTRA_QMAKEVARS_POST and EXTRA_OECONF

Tasks such as do_configure

PACKAGE_ARCH

RRECOMMENDS

BBCLASSEXTEND

There are some cases where ordering is important and these cases would override this default order. Examples include:

PACKAGE_ARCH needing to be set before inherit packagegroup

Tasks should be ordered based on the order they generally execute. For commonly used tasks this would be:

do_prepare_recipe_sysroot

do_configure

do_populate_sysroot

Custom tasks should be sorted similarly.

Package specific variables are typically grouped together, e.g.:

3.5.3 Recipe License Fields 

Recipes need to define both the LICENSE and LIC_FILES_CHKSUM variables:

LICENSE : This variable specifies the license for the software. If you do not know the license under which the software you are building is distributed, you should go to the source code and look for that information. Typical files containing this information include COPYING , LICENSE , and README files. You could also find the information near the top of a source file. For example, given a piece of software licensed under the GNU General Public License version 2, you would set LICENSE as follows:

The licenses you specify within LICENSE can have any name as long as you do not use spaces, since spaces are used as separators between license names. For standard licenses, use the names of the files in meta/files/common-licenses/ or the SPDXLICENSEMAP flag names defined in meta/conf/licenses.conf .

LIC_FILES_CHKSUM : The OpenEmbedded build system uses this variable to make sure the license text has not changed. If it has, the build produces an error and it affords you the chance to figure it out and correct the problem.

You need to specify all applicable licensing files for the software. At the end of the configuration step, the build process will compare the checksums of the files to be sure the text has not changed. Any differences result in an error with the message containing the current checksum. For more explanation and examples of how to set the LIC_FILES_CHKSUM variable, see the “ Tracking License Changes ” section.

To determine the correct checksum string, you can list the appropriate files in the LIC_FILES_CHKSUM variable with incorrect md5 strings, attempt to build the software, and then note the resulting error messages that will report the correct md5 strings. See the “ Fetching Code ” section for additional information.

Here is an example that assumes the software has a COPYING file:

When you try to build the software, the build system will produce an error and give you the correct string that you can substitute into the recipe file for a subsequent build.

3.5.3.1 License Updates 

When you change the LICENSE or LIC_FILES_CHKSUM in the recipe you need to briefly explain the reason for the change via a License-Update: tag. Often it’s quite trivial, such as:

Less often, the actual licensing terms themselves will have changed. If so, do try to link to upstream making/justifying that decision.

3.5.4 Tips and Guidelines for Writing Recipes 

Use BBCLASSEXTEND instead of creating separate recipes such as -native and -nativesdk ones, whenever possible. This avoids having to maintain multiple recipe files at the same time.

Recipes should have tasks which are idempotent, i.e. that executing a given task multiple times shouldn’t change the end result. The build environment is built upon this assumption and breaking it can cause obscure build failures.

For idempotence when modifying files in tasks, it is usually best to:

copy a file X to X.orig (only if it doesn’t exist already)

then, copy X.orig back to X ,

and, finally, modify X .

This ensures if rerun the task always has the same end result and the original file can be preserved to reuse. It also guards against an interrupted build corrupting the file.

3.6 Patch Upstream Status 

In order to keep track of patches applied by recipes and ultimately reduce the number of patches that need maintaining, the OpenEmbedded build system requires information about the upstream status of each patch.

In its description, each patch should provide detailed information about the bug that it addresses, such as the URL in a bug tracking system and links to relevant mailing list archives.

Then, you should also add an Upstream-Status: tag containing one of the following status strings:

No determination has been made yet, or patch has not yet been submitted to upstream.

Keep in mind that every patch submitted upstream reduces the maintainance burden in OpenEmbedded and Yocto Project in the long run, so this patch status should only be used in exceptional cases if there are genuine obstacles to submitting a patch upstream; the reason for that should be included in the patch.

Submitted to upstream, waiting for approval. Optionally include where it was submitted, such as the author, mailing list, etc.

Accepted upstream and included in the next release, or backported from newer upstream version, because we are at a fixed version. Include upstream version info (e.g. commit ID or next expected version).

Not accepted by upstream, include reason in patch.

The upstream is no longer available. This typically means a defunct project where no activity has happened for a long time — measured in years. To make that judgement, it is recommended to look at not only when the last release happened, but also when the last commit happened, and whether newly made bug reports and merge requests since that time receive no reaction. It is also recommended to add to the patch description any relevant links where the inactivity can be clearly seen.

The patch is not appropriate for upstream, include a brief reason on the same line enclosed with [] . In the past, there were several different reasons not to submit patches upstream, but we have to consider that every non-upstreamed patch means a maintainance burden for recipe maintainers. Currently, the only reasons to mark patches as inappropriate for upstream submission are:

oe specific : the issue is specific to how OpenEmbedded performs builds or sets things up at runtime, and can be resolved only with a patch that is not however relevant or appropriate for general upstream submission.

upstream ticket <link> : the issue is not specific to Open-Embedded and should be fixed upstream, but the patch in its current form is not suitable for merging upstream, and the author lacks sufficient expertise to develop a proper patch. Instead the issue is handled via a bug report (include link).

Of course, if another person later takes care of submitting this patch upstream, the status should be changed to Submitted [where] , and an additional Signed-off-by: line should be added to the patch by the person claiming responsibility for upstreaming.

3.6.1 Examples 

Here’s an example of a patch that has been submitted upstream:

A future update can change the value to Backport or Denied as appropriate.

Another example of a patch that is specific to OpenEmbedded:

Here’s a patch that has been backported from an upstream commit:

3.7 CVE patches 

In order to have a better control of vulnerabilities, patches that fix CVEs must contain a CVE: tag. This tag list all CVEs fixed by the patch. If more than one CVE is fixed, separate them using spaces.

3.7.1 CVE Examples 

This should be the header of patch that fixes CVE-2015-8370 in GRUB2:

AVSIM Library System Version 2.00 -- 2004-May-01 © 2001-2024 AVSIM Online All Rights Reserved

Related Guides:

Moscow Maps and Orientation

(moscow, central federal district, russia), maps and orientation of the city.

• Cehov - south
• Dmitrov - north
• Domodedovkiy Rayon - south
• Klimovsk - south
• Krasnogorsk - west
• Krasnogorskiy Rayon - west
• Leninskiy Rayon - south
• Likino Dulevo - east
• Lyuberetskiy Rayon - south
• Mytisci - north-east
• Naro-Fominsk - south-west
• Odincovo - west
• Odintsovkiy Rayon - west
• Orehovo Zuevo - east
• Podol'skiy Rayon - south
• Shchyolkovskiy Rayon - north-east
• Zelenograd - north-west

Map of Russia

Map of moscow.

© Copyright TravelSmart Ltd

I'm looking for:

Hotel Search

• Travel Guide
• Information and Tourism
• Maps and Orientation
• Transport and Car Rental
• SVO Airport Information
• History Facts
• Weather and Climate
• Life and Travel Tips
• Accommodation
• Hotels and Accommodation
• Property and Real Estate
• Popular Attractions
• Tourist Attractions
• Landmarks and Monuments
• Art Galleries
• Attractions Nearby
• Parks and Gardens
• Golf Courses
• Things to Do
• Events and Festivals
• Restaurants and Dining
• Your Reviews of Moscow
• Russia World Guide
• Guide Disclaimer
• Privacy Policy / Disclaimer

This project is part of the thriving Moscow City mixed-use district—centrally located within the sprawling Russian metropolis—the design of which is similar to London’s Canary Wharf and Paris’s La Défense. An 85-story skyscraper and a 49-story office tower soar from a 7-story transparent crystalline base, gradually tapering away from each other as they rise. Designed by US-based architectural and engineering firm Skidmore, Owings & Merrill—renowned for its iconic towers, including Burj Khalifa, the world’s tallest building—the OKO Tower complex laid the groundwork for a new era in contemporary Russian development. At 1,150 feet high, and with a total area of 4,300,000 square feet, the OKO South Tower is not only the largest skyscraper in Moscow, but also the highest residential tower in Europe. The complex also has the biggest parking area in Moscow, with 15 levels for 3,500 parking spaces.

Residential and office lobbies have elegant interiors by Italy-based designer Massimo Iosa Ghini. With leading engineering solutions and security systems, 24/7 services, restaurants and bars, a private cinema hall, a luxurious spa and fitness center, and a private landscaped park, OKO Tower offers the ultimate in comfort and activity. The key-ready residential apartments boast designer interiors and stunning panoramic views of the Moskva River, the Vorobyovy Gory (Sparrow Hills) park, the Kremlin and the skyscrapers of Moscow City.