mirrors/poky
1
0
Fork 0
mirror of https://git.yoctoproject.org/poky synced 2026-05-09 17:39:31 +00:00
Code Issues Projects Releases Wiki Activity

sphinx: initial sphinx support

Browse Source 
This commit is autogenerated pandoc to generate an inital set
of reST files based on DocBook XML files.

A .rst file is generated for each .xml files in all manuals with this
command:

cd <manual>
for i in *.xml; do \
  pandoc -f docbook -t rst --shift-heading-level-by=-1 \
  $i -o $(basename $i .xml).rst \
done

The conversion was done with: pandoc 2.9.2.1-91 (Arch Linux).

Also created an initial top level index file for each document, and
added all 'books' to the top leve index.rst file.

The YP manuals layout is organized as:

Book
  Chapter
    Section
      Section
        Section

Sphinx uses section headers to create the document structure.
ReStructuredText defines sections headers like that:

   To break longer text up into sections, you use section headers. These
   are a single line of text (one or more words) with adornment: an
   underline alone, or an underline and an overline together, in dashes
   "-----", equals "======", tildes "~~~~~~" or any of the
   non-alphanumeric characters = - ` : ' " ~ ^ _ * + # < > that you feel
   comfortable with. An underline-only adornment is distinct from an
   overline-and-underline adornment using the same character. The
   underline/overline must be at least as long as the title text. Be
   consistent, since all sections marked with the same adornment style
   are deemed to be at the same level:

Let's define the following convention when converting from Docbook:

Book                => overline ===   (Title)
  Chapter           => overline ***   (1.)
    Section         => ====           (1.1)
      Section       => ----           (1.1.1)
        Section     => ~~~~           (1.1.1.1)
          Section   => ^^^^           (1.1.1.1.1)

During the conversion with pandoc, we used --shift-heading-level=-1 to
convert most of DocBook headings automatically. However with this
setting, the Chapter header was removed, so I added it back
manually. Without this setting all headings were off by one, which was
more difficult to manually fix.

At least with this change, we now have the same TOC with Sphinx and
DocBook.

(From yocto-docs rev: 3c73d64a476d4423ee4c6808c685fa94d88d7df8)

Signed-off-by: Nicolas Dechesne <nicolas.dechesne@linaro.org>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
This commit is contained in:
Nicolas Dechesne
2020-06-26 19:10:51 +02:00
committed by Richard Purdie
parent c40a8d5904
commit 9bd69b1f1d
66 changed files with 49599 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
documentation/ref-manual/faq.rst
+418
View File
@@ -0,0 +1,418 @@
***
FAQ
***
**Q:** How does Poky differ from `OpenEmbedded <&OE_HOME_URL;>`__?
**A:** The term "`Poky <#>`__" refers to the specific reference build
system that the Yocto Project provides. Poky is based on
`OE-Core <#oe-core>`__ and `BitBake <#bitbake-term>`__. Thus, the
generic term used here for the build system is the "OpenEmbedded build
system." Development in the Yocto Project using Poky is closely tied to
OpenEmbedded, with changes always being merged to OE-Core or BitBake
first before being pulled back into Poky. This practice benefits both
projects immediately.
**Q:** My development system does not meet the required Git, tar, and
Python versions. In particular, I do not have Python 3.5.0 or greater.
Can I still use the Yocto Project?
**A:** You can get the required tools on your host development system a
couple different ways (i.e. building a tarball or downloading a
tarball). See the "`Required Git, tar, Python and gcc
Versions <#required-git-tar-python-and-gcc-versions>`__" section for
steps on how to update your build tools.
**Q:** How can you claim Poky / OpenEmbedded-Core is stable?
**A:** There are three areas that help with stability;
- The Yocto Project team keeps `OE-Core <#oe-core>`__ small and
focused, containing around 830 recipes as opposed to the thousands
available in other OpenEmbedded community layers. Keeping it small
makes it easy to test and maintain.
- The Yocto Project team runs manual and automated tests using a small,
fixed set of reference hardware as well as emulated targets.
- The Yocto Project uses an autobuilder, which provides continuous
build and integration tests.
**Q:** How do I get support for my board added to the Yocto Project?
**A:** Support for an additional board is added by creating a Board
Support Package (BSP) layer for it. For more information on how to
create a BSP layer, see the "`Understanding and Creating
Layers <&YOCTO_DOCS_DEV_URL;#understanding-and-creating-layers>`__"
section in the Yocto Project Development Tasks Manual and the `Yocto
Project Board Support Package (BSP) Developer's
Guide <&YOCTO_DOCS_BSP_URL;>`__.
Usually, if the board is not completely exotic, adding support in the
Yocto Project is fairly straightforward.
**Q:** Are there any products built using the OpenEmbedded build system?
**A:** The software running on the `Vernier
LabQuest <http://vernier.com/labquest/>`__ is built using the
OpenEmbedded build system. See the `Vernier
LabQuest <http://www.vernier.com/products/interfaces/labq/>`__ website
for more information. There are a number of pre-production devices using
the OpenEmbedded build system and the Yocto Project team announces them
as soon as they are released.
**Q:** What does the OpenEmbedded build system produce as output?
**A:** Because you can use the same set of recipes to create output of
various formats, the output of an OpenEmbedded build depends on how you
start it. Usually, the output is a flashable image ready for the target
device.
**Q:** How do I add my package to the Yocto Project?
**A:** To add a package, you need to create a BitBake recipe. For
information on how to create a BitBake recipe, see the "`Writing a New
Recipe <&YOCTO_DOCS_DEV_URL;#new-recipe-writing-a-new-recipe>`__"
section in the Yocto Project Development Tasks Manual.
**Q:** Do I have to reflash my entire board with a new Yocto Project
image when recompiling a package?
**A:** The OpenEmbedded build system can build packages in various
formats such as IPK for OPKG, Debian package (``.deb``), or RPM. You can
then upgrade the packages using the package tools on the device, much
like on a desktop distribution such as Ubuntu or Fedora. However,
package management on the target is entirely optional.
**Q:** I see the error
'``chmod: XXXXX new permissions are r-xrwxrwx, not r-xr-xr-x``'. What is
wrong?
**A:** You are probably running the build on an NTFS filesystem. Use
``ext2``, ``ext3``, or ``ext4`` instead.
**Q:** I see lots of 404 responses for files when the OpenEmbedded build
system is trying to download sources. Is something wrong?
**A:** Nothing is wrong. The OpenEmbedded build system checks any
configured source mirrors before downloading from the upstream sources.
The build system does this searching for both source archives and
pre-checked out versions of SCM-managed software. These checks help in
large installations because it can reduce load on the SCM servers
themselves. The address above is one of the default mirrors configured
into the build system. Consequently, if an upstream source disappears,
the team can place sources there so builds continue to work.
**Q:** I have machine-specific data in a package for one machine only
but the package is being marked as machine-specific in all cases, how do
I prevent this?
**A:** Set ``SRC_URI_OVERRIDES_PACKAGE_ARCH`` = "0" in the ``.bb`` file
but make sure the package is manually marked as machine-specific for the
case that needs it. The code that handles
``SRC_URI_OVERRIDES_PACKAGE_ARCH`` is in the
``meta/classes/base.bbclass`` file.
**Q:** I'm behind a firewall and need to use a proxy server. How do I do
that?
**A:** Most source fetching by the OpenEmbedded build system is done by
``wget`` and you therefore need to specify the proxy settings in a
``.wgetrc`` file, which can be in your home directory if you are a
single user or can be in ``/usr/local/etc/wgetrc`` as a global user
file.
Following is the applicable code for setting various proxy types in the
``.wgetrc`` file. By default, these settings are disabled with comments.
To use them, remove the comments: # You can set the default proxies for
Wget to use for http, https, and ftp. # They will override the value in
the environment. #https_proxy = http://proxy.yoyodyne.com:18023/
#http_proxy = http://proxy.yoyodyne.com:18023/ #ftp_proxy =
http://proxy.yoyodyne.com:18023/ # If you do not want to use proxy at
all, set this to off. #use_proxy = on The Yocto Project also includes a
``meta-poky/conf/site.conf.sample`` file that shows how to configure CVS
and Git proxy servers if needed. For more information on setting up
various proxy types and configuring proxy servers, see the "`Working
Behind a Network
Proxy <&YOCTO_WIKI_URL;/wiki/Working_Behind_a_Network_Proxy>`__" Wiki
page.
**Q:** What’s the difference between target and target\ ``-native``?
**A:** The ``*-native`` targets are designed to run on the system being
used for the build. These are usually tools that are needed to assist
the build in some way such as ``quilt-native``, which is used to apply
patches. The non-native version is the one that runs on the target
device.
**Q:** I'm seeing random build failures. Help?!
**A:** If the same build is failing in totally different and random
ways, the most likely explanation is:
- The hardware you are running the build on has some problem.
- You are running the build under virtualization, in which case the
virtualization probably has bugs.
The OpenEmbedded build system processes a massive amount of data that
causes lots of network, disk and CPU activity and is sensitive to even
single-bit failures in any of these areas. True random failures have
always been traced back to hardware or virtualization issues.
**Q:** When I try to build a native recipe, the build fails with
``iconv.h`` problems.
**A:** If you get an error message that indicates GNU ``libiconv`` is
not in use but ``iconv.h`` has been included from ``libiconv``, you need
to check to see if you have a previously installed version of the header
file in ``/usr/local/include``. #error GNU libiconv not in use but
included iconv.h is from libiconv If you find a previously installed
file, you should either uninstall it or temporarily rename it and try
the build again.
This issue is just a single manifestation of "system leakage" issues
caused when the OpenEmbedded build system finds and uses previously
installed files during a native build. This type of issue might not be
limited to ``iconv.h``. Be sure that leakage cannot occur from
``/usr/local/include`` and ``/opt`` locations.
**Q:** What do we need to ship for license compliance?
**A:** This is a difficult question and you need to consult your lawyer
for the answer for your specific case. It is worth bearing in mind that
for GPL compliance, there needs to be enough information shipped to
allow someone else to rebuild and produce the same end result you are
shipping. This means sharing the source code, any patches applied to it,
and also any configuration information about how that package was
configured and built.
You can find more information on licensing in the
"`Licensing <&YOCTO_DOCS_OM_URL;#licensing>`__" section in the Yocto
Project Overview and Concepts Manual and also in the "`Maintaining Open
Source License Compliance During Your Product's
Lifecycle <&YOCTO_DOCS_DEV_URL;#maintaining-open-source-license-compliance-during-your-products-lifecycle>`__"
section in the Yocto Project Development Tasks Manual.
**Q:** How do I disable the cursor on my touchscreen device?
**A:** You need to create a form factor file as described in the
"`Miscellaneous BSP-Specific Recipe
Files <&YOCTO_DOCS_BSP_URL;#bsp-filelayout-misc-recipes>`__" section in
the Yocto Project Board Support Packages (BSP) Developer's Guide. Set
the ``HAVE_TOUCHSCREEN`` variable equal to one as follows:
HAVE_TOUCHSCREEN=1
**Q:** How do I make sure connected network interfaces are brought up by
default?
**A:** The default interfaces file provided by the netbase recipe does
not automatically bring up network interfaces. Therefore, you will need
to add a BSP-specific netbase that includes an interfaces file. See the
"`Miscellaneous BSP-Specific Recipe
Files <&YOCTO_DOCS_BSP_URL;#bsp-filelayout-misc-recipes>`__" section in
the Yocto Project Board Support Packages (BSP) Developer's Guide for
information on creating these types of miscellaneous recipe files.
For example, add the following files to your layer:
meta-MACHINE/recipes-bsp/netbase/netbase/MACHINE/interfaces
meta-MACHINE/recipes-bsp/netbase/netbase_5.0.bbappend
**Q:** How do I create images with more free space?
**A:** By default, the OpenEmbedded build system creates images that are
1.3 times the size of the populated root filesystem. To affect the image
size, you need to set various configurations:
- *Image Size:* The OpenEmbedded build system uses the
```IMAGE_ROOTFS_SIZE`` <#var-IMAGE_ROOTFS_SIZE>`__ variable to define
the size of the image in Kbytes. The build system determines the size
by taking into account the initial root filesystem size before any
modifications such as requested size for the image and any requested
additional free disk space to be added to the image.
- *Overhead:* Use the
```IMAGE_OVERHEAD_FACTOR`` <#var-IMAGE_OVERHEAD_FACTOR>`__ variable
to define the multiplier that the build system applies to the initial
image size, which is 1.3 by default.
- *Additional Free Space:* Use the
```IMAGE_ROOTFS_EXTRA_SPACE`` <#var-IMAGE_ROOTFS_EXTRA_SPACE>`__
variable to add additional free space to the image. The build system
adds this space to the image after it determines its
``IMAGE_ROOTFS_SIZE``.
**Q:** Why don't you support directories with spaces in the pathnames?
**A:** The Yocto Project team has tried to do this before but too many
of the tools the OpenEmbedded build system depends on, such as
``autoconf``, break when they find spaces in pathnames. Until that
situation changes, the team will not support spaces in pathnames.
**Q:** How do I use an external toolchain?
**A:** The toolchain configuration is very flexible and customizable. It
is primarily controlled with the ``TCMODE`` variable. This variable
controls which ``tcmode-*.inc`` file to include from the
``meta/conf/distro/include`` directory within the `Source
Directory <#source-directory>`__.
The default value of ``TCMODE`` is "default", which tells the
OpenEmbedded build system to use its internally built toolchain (i.e.
``tcmode-default.inc``). However, other patterns are accepted. In
particular, "external-*" refers to external toolchains. One example is
the Sourcery G++ Toolchain. The support for this toolchain resides in
the separate ``meta-sourcery`` layer at
` <http://github.com/MentorEmbedded/meta-sourcery/>`__.
In addition to the toolchain configuration, you also need a
corresponding toolchain recipe file. This recipe file needs to package
up any pre-built objects in the toolchain such as ``libgcc``,
``libstdcc++``, any locales, and ``libc``.
**Q:** How does the OpenEmbedded build system obtain source code and
will it work behind my firewall or proxy server?
**A:** The way the build system obtains source code is highly
configurable. You can setup the build system to get source code in most
environments if HTTP transport is available.
When the build system searches for source code, it first tries the local
download directory. If that location fails, Poky tries
```PREMIRRORS`` <#var-PREMIRRORS>`__, the upstream source, and then
```MIRRORS`` <#var-MIRRORS>`__ in that order.
Assuming your distribution is "poky", the OpenEmbedded build system uses
the Yocto Project source ``PREMIRRORS`` by default for SCM-based
sources, upstreams for normal tarballs, and then falls back to a number
of other mirrors including the Yocto Project source mirror if those
fail.
As an example, you could add a specific server for the build system to
attempt before any others by adding something like the following to the
``local.conf`` configuration file: PREMIRRORS_prepend = "\\ git://.*/.\*
http://www.yoctoproject.org/sources/ \\n \\ ftp://.*/.\*
http://www.yoctoproject.org/sources/ \\n \\ http://.*/.\*
http://www.yoctoproject.org/sources/ \\n \\ https://.*/.\*
http://www.yoctoproject.org/sources/ \\n"
These changes cause the build system to intercept Git, FTP, HTTP, and
HTTPS requests and direct them to the ``http://`` sources mirror. You
can use ``file://`` URLs to point to local directories or network shares
as well.
Aside from the previous technique, these options also exist:
BB_NO_NETWORK = "1" This statement tells BitBake to issue an error
instead of trying to access the Internet. This technique is useful if
you want to ensure code builds only from local sources.
Here is another technique: BB_FETCH_PREMIRRORONLY = "1" This statement
limits the build system to pulling source from the ``PREMIRRORS`` only.
Again, this technique is useful for reproducing builds.
Here is another technique: BB_GENERATE_MIRROR_TARBALLS = "1" This
statement tells the build system to generate mirror tarballs. This
technique is useful if you want to create a mirror server. If not,
however, the technique can simply waste time during the build.
Finally, consider an example where you are behind an HTTP-only firewall.
You could make the following changes to the ``local.conf`` configuration
file as long as the ``PREMIRRORS`` server is current: PREMIRRORS_prepend
= "\\ ftp://.*/.\* http://www.yoctoproject.org/sources/ \\n \\
http://.*/.\* http://www.yoctoproject.org/sources/ \\n \\ https://.*/.\*
http://www.yoctoproject.org/sources/ \\n" BB_FETCH_PREMIRRORONLY = "1"
These changes would cause the build system to successfully fetch source
over HTTP and any network accesses to anything other than the
``PREMIRRORS`` would fail.
The build system also honors the standard shell environment variables
``http_proxy``, ``ftp_proxy``, ``https_proxy``, and ``all_proxy`` to
redirect requests through proxy servers.
.. note::
You can find more information on the "
Working Behind a Network Proxy
" Wiki page.
**Q:** Can I get rid of build output so I can start over?
**A:** Yes - you can easily do this. When you use BitBake to build an
image, all the build output goes into the directory created when you run
the build environment setup script (i.e.
````` <#structure-core-script>`__). By default, this `Build
Directory <#build-directory>`__ is named ``build`` but can be named
anything you want.
Within the Build Directory, is the ``tmp`` directory. To remove all the
build output yet preserve any source code or downloaded files from
previous builds, simply remove the ``tmp`` directory.
**Q:** Why do ``${bindir}`` and ``${libdir}`` have strange values for
``-native`` recipes?
**A:** Executables and libraries might need to be used from a directory
other than the directory into which they were initially installed.
Complicating this situation is the fact that sometimes these executables
and libraries are compiled with the expectation of being run from that
initial installation target directory. If this is the case, moving them
causes problems.
This scenario is a fundamental problem for package maintainers of
mainstream Linux distributions as well as for the OpenEmbedded build
system. As such, a well-established solution exists. Makefiles,
Autotools configuration scripts, and other build systems are expected to
respect environment variables such as ``bindir``, ``libdir``, and
``sysconfdir`` that indicate where executables, libraries, and data
reside when a program is actually run. They are also expected to respect
a ``DESTDIR`` environment variable, which is prepended to all the other
variables when the build system actually installs the files. It is
understood that the program does not actually run from within
``DESTDIR``.
When the OpenEmbedded build system uses a recipe to build a
target-architecture program (i.e. one that is intended for inclusion on
the image being built), that program eventually runs from the root file
system of that image. Thus, the build system provides a value of
"/usr/bin" for ``bindir``, a value of "/usr/lib" for ``libdir``, and so
forth.
Meanwhile, ``DESTDIR`` is a path within the `Build
Directory <#build-directory>`__. However, when the recipe builds a
native program (i.e. one that is intended to run on the build machine),
that program is never installed directly to the build machine's root
file system. Consequently, the build system uses paths within the Build
Directory for ``DESTDIR``, ``bindir`` and related variables. To better
understand this, consider the following two paths where the first is
relatively normal and the second is not:
.. note::
Due to these lengthy examples, the paths are artificially broken
across lines for readability.
/home/maxtothemax/poky-bootchart2/build/tmp/work/i586-poky-linux/zlib/
1.2.8-r0/sysroot-destdir/usr/bin
/home/maxtothemax/poky-bootchart2/build/tmp/work/x86_64-linux/
zlib-native/1.2.8-r0/sysroot-destdir/home/maxtothemax/poky-bootchart2/
build/tmp/sysroots/x86_64-linux/usr/bin Even if the paths look unusual,
they both are correct - the first for a target and the second for a
native recipe. These paths are a consequence of the ``DESTDIR``
mechanism and while they appear strange, they are correct and in
practice very effective.
**Q:** The files provided by my ``*-native`` recipe do not appear to be
available to other recipes. Files are missing from the native sysroot,
my recipe is installing to the wrong place, or I am getting permissions
errors during the do_install task in my recipe! What is wrong?
**A:** This situation results when a build system does not recognize the
environment variables supplied to it by `BitBake <#bitbake-term>`__. The
incident that prompted this FAQ entry involved a Makefile that used an
environment variable named ``BINDIR`` instead of the more standard
variable ``bindir``. The makefile's hardcoded default value of
"/usr/bin" worked most of the time, but not for the recipe's ``-native``
variant. For another example, permissions errors might be caused by a
Makefile that ignores ``DESTDIR`` or uses a different name for that
environment variable. Check the the build system to see if these kinds
of issues exist.
documentation/ref-manual/migration.rst
+5081
View File
File diff suppressed because it is too large Load Diff
documentation/ref-manual/ref-classes.rst
+2881
View File
File diff suppressed because it is too large Load Diff
documentation/ref-manual/ref-devtool-reference.rst
+533
View File
@@ -0,0 +1,533 @@
***************************
``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 <&YOCTO_DOCS_SDK_URL;#sdk-extensible>`__" chapter in the Yocto
Project Application Development and the Extensible Software Development
Kit (eSDK) manual.
.. _devtool-getting-help:
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 -h NOTE: Starting
bitbake server... 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 latest-version Report the latest version of an existing recipe
check-upgrade-status Report upgradability for multiple (or all) recipes
Working on a recipe in the workspace: build Build a recipe rename Rename
a recipe file in the workspace edit-recipe Edit a recipe file
find-recipe Find a recipe file configure-help Get help on configure
script options 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 export Export workspace into a
tar archive import Import exported tar archive into workspace 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 NOTE: Starting bitbake server...
usage: devtool add [-h] [--same-dir \| --no-same-dir] [--fetch URI]
[--fetch-dev] [--version VERSION] [--no-git] [--srcrev SRCREV \|
--autorev] [--srcbranch SRCBRANCH] [--binary] [--also-native]
[--src-subdir SUBDIR] [--mirrors] [--provides PROVIDES] [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) --fetch-dev For npm, also fetch
devDependencies --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 --srcrev SRCREV, -S SRCREV Source revision to fetch
if fetching from an SCM such as git (default latest) --autorev, -a When
fetching from a git repository, set SRCREV in the recipe to a floating
revision instead of fixed --srcbranch SRCBRANCH, -B SRCBRANCH Branch in
source repository if fetching from an SCM such as git (default master)
--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
--mirrors Enable PREMIRRORS and MIRRORS for source tree fetching
(disable by default). --provides PROVIDES, -p PROVIDES Specify an alias
for the item provided by the recipe. E.g. virtual/libgl
.. _devtool-the-workspace-layer-structure:
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 must 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.
.. _devtool-adding-a-new-recipe-to-the-workspace:
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/user/sources/jackson``: $ devtool add jackson
/home/user/sources/jackson
If you add a recipe and the workspace layer does not exist, the command
creates the layer and populates it as described in "`The Workspace Layer
Structure <#devtool-the-workspace-layer-structure>`__" section.
Running ``devtool add`` when the workspace layer exists causes the tool
to add the recipe, append files, and source files into the existing
workspace layer. The ``.bbappend`` file is created to point to the
external source tree.
.. note::
If your recipe has runtime dependencies defined, you must be sure
that these packages exist on the target hardware before attempting to
run your application. If dependent packages (e.g. libraries) do not
exist on the target, your application, when run, will fail to find
those functions. For more information, see the "
Deploying Your Software on the Target Machine
" section.
By default, ``devtool add`` uses the latest revision (i.e. master) when
unpacking files from a remote URI. In some cases, you might want to
specify a source revision by branch, tag, or commit hash. You can
specify these options when using the ``devtool add`` command:
- To specify a source branch, use the ``--srcbranch`` option: $ devtool
add --srcbranch DISTRO_NAME_NO_CAP jackson /home/user/sources/jackson
In the previous example, you are checking out the DISTRO_NAME_NO_CAP
branch.
- To specify a specific tag or commit hash, use the ``--srcrev``
option: $ devtool add --srcrev DISTRO_REL_TAG jackson
/home/user/sources/jackson $ devtool add --srcrev some_commit_hash
/home/user/sources/jackson The previous examples check out the
DISTRO_REL_TAG tag and the commit associated with the
some_commit_hash hash.
.. note::
If you prefer to use the latest revision every time the recipe is
built, use the options
--autorev
or
-a
.
.. _devtool-extracting-the-source-for-an-existing-recipe:
Extracting the Source for an Existing Recipe
============================================
Use the ``devtool extract`` command to extract the source for an
existing recipe. When you use this command, you must supply the root
name of the recipe (i.e. no version, paths, or extensions), and you must
supply the directory to which you want the source extracted.
Additional command options let you control the name of a development
branch into which you can checkout the source and whether or not to keep
a temporary directory, which is useful for debugging.
.. _devtool-synchronizing-a-recipes-extracted-source-tree:
Synchronizing a Recipe's Extracted Source Tree
==============================================
Use the ``devtool sync`` command to synchronize a previously extracted
source tree for an existing recipe. When you use this command, you must
supply the root name of the recipe (i.e. no version, paths, or
extensions), and you must supply the directory to which you want the
source extracted.
Additional command options let you control the name of a development
branch into which you can checkout the source and whether or not to keep
a temporary directory, which is useful for debugging.
.. _devtool-modifying-a-recipe:
Modifying an Existing Recipe
============================
Use the ``devtool modify`` command to begin modifying the source of an
existing recipe. This command is very similar to the
```add`` <#devtool-adding-a-new-recipe-to-the-workspace>`__ command
except that it does not physically create the recipe in the workspace
layer because the recipe already exists in an another layer.
The ``devtool modify`` command extracts the source for a recipe, sets it
up as a Git repository if the source had not already been fetched from
Git, checks out a branch for development, and applies any patches from
the recipe as commits on top. You can use the following command to
checkout the source files: $ devtool modify recipe Using the above
command form, ``devtool`` uses the existing recipe's
```SRC_URI`` <#var-SRC_URI>`__ statement to locate the upstream source,
extracts the source into the default sources location in the workspace.
The default development branch used is "devtool".
.. _devtool-edit-an-existing-recipe:
Edit an Existing Recipe
=======================
Use the ``devtool edit-recipe`` command to run the default editor, which
is identified using the ``EDITOR`` variable, on the specified recipe.
When you use the ``devtool edit-recipe`` command, you must supply the
root name of the recipe (i.e. no version, paths, or extensions). Also,
the recipe file itself must reside in the workspace as a result of the
``devtool add`` or ``devtool upgrade`` commands. However, you can
override that requirement by using the "-a" or "--any-recipe" option.
Using either of these options allows you to edit any recipe regardless
of its location.
.. _devtool-updating-a-recipe:
Updating a Recipe
=================
Use the ``devtool update-recipe`` command to update your recipe with
patches that reflect changes you make to the source files. For example,
if you know you are going to work on some code, you could first use the
```devtool modify`` <#devtool-modifying-a-recipe>`__ command to extract
the code and set up the workspace. After which, you could modify,
compile, and test the code.
When you are satisfied with the results and you have committed your
changes to the Git repository, you can then run the
``devtool update-recipe`` to create the patches and update the recipe: $
devtool update-recipe recipe If you run the ``devtool update-recipe``
without committing your changes, the command ignores the changes.
Often, you might want to apply customizations made to your software in
your own layer rather than apply them to the original recipe. If so, you
can use the ``-a`` or ``--append`` option with the
``devtool update-recipe`` command. These options allow you to specify
the layer into which to write an append file: $ devtool update-recipe
recipe -a base-layer-directory The ``*.bbappend`` file is created at the
appropriate path within the specified layer directory, which may or may
not be in your ``bblayers.conf`` file. If an append file already exists,
the command updates it appropriately.
.. _devtool-checking-on-the-upgrade-status-of-a-recipe:
Checking on the Upgrade Status of a Recipe
==========================================
Upstream recipes change over time. Consequently, you might find that you
need to determine if you can upgrade a recipe to a newer version.
To check on the upgrade status of a recipe, use the
``devtool check-upgrade-status`` command. The command displays a table
of your current recipe versions, the latest upstream versions, the email
address of the recipe's maintainer, and any additional information such
as commit hash strings and reasons you might not be able to upgrade a
particular recipe.
.. note::
- For the ``oe-core`` layer, recipe maintainers come from the
```maintainers.inc`` <http://git.yoctoproject.org/cgit/cgit.cgi/poky/tree/meta/conf/distro/include/maintainers.inc>`__
file.
- If the recipe is using the `Git
fetcher <&YOCTO_DOCS_BB_URL;#git-fetcher>`__ rather than a
tarball, the commit hash points to the commit that matches the
recipe's latest version tag.
As with all ``devtool`` commands, you can get help on the individual
command: $ devtool check-upgrade-status -h NOTE: Starting bitbake
server... usage: devtool check-upgrade-status [-h] [--all] [recipe
[recipe ...]] Prints a table of recipes together with versions currently
provided by recipes, and latest upstream versions, when there is a later
version available arguments: recipe Name of the recipe to report (omit
to report upgrade info for all recipes) options: -h, --help show this
help message and exit --all, -a Show all recipes, not just recipes
needing upgrade
Unless you provide a specific recipe name on the command line, the
command checks all recipes in all configured layers.
Following is a partial example table that reports on all the recipes.
Notice the reported reason for not upgrading the ``base-passwd`` recipe.
In this example, while a new version is available upstream, you do not
want to use it because the dependency on ``cdebconf`` is not easily
satisfied.
.. note::
When a reason for not upgrading displays, the reason is usually
written into the recipe using the
RECIPE_NO_UPDATE_REASON
variable. See the
base-passwd.bb
recipe for an example.
$ devtool check-upgrade-status ... NOTE: acpid 2.0.30 2.0.31 Ross Burton
<ross.burton@intel.com> NOTE: u-boot-fw-utils 2018.11 2019.01 Marek
Vasut <marek.vasut@gmail.com> d3689267f92c5956e09cc7d1baa4700141662bff
NOTE: u-boot-tools 2018.11 2019.01 Marek Vasut <marek.vasut@gmail.com>
d3689267f92c5956e09cc7d1baa4700141662bff . . . NOTE: base-passwd 3.5.29
3.5.45 Anuj Mittal <anuj.mittal@intel.com> cannot be updated due to:
Version 3.5.38 requires cdebconf for update-passwd utility NOTE: busybox
1.29.2 1.30.0 Andrej Valek <andrej.valek@siemens.com> NOTE: dbus-test
1.12.10 1.12.12 Chen Qi <Qi.Chen@windriver.com>
.. _devtool-upgrading-a-recipe:
Upgrading a Recipe
==================
As software matures, upstream recipes are upgraded to newer versions. As
a developer, you need to keep your local recipes up-to-date with the
upstream version releases. Several methods exist by which you can
upgrade recipes. You can read about them in the "`Upgrading
Recipes <&YOCTO_DOCS_DEV_URL;#gs-upgrading-recipes>`__" section of the
Yocto Project Development Tasks Manual. This section overviews the
``devtool upgrade`` command.
.. note::
Before you upgrade a recipe, you can check on its upgrade status. See
the "
Checking on the Upgrade Status of a Recipe
" for more information.
The ``devtool upgrade`` command upgrades an existing recipe to a more
recent version of the recipe upstream. The command puts the upgraded
recipe file along with any associated files into a "workspace" and, if
necessary, extracts the source tree to a specified location. During the
upgrade, patches associated with the recipe are rebased or added as
needed.
When you use the ``devtool upgrade`` command, you must supply the root
name of the recipe (i.e. no version, paths, or extensions), and you must
supply the directory to which you want the source extracted. Additional
command options let you control things such as the version number to
which you want to upgrade (i.e. the ```PV`` <#var-PV>`__), the source
revision to which you want to upgrade (i.e. the
```SRCREV`` <#var-SRCREV>`__), whether or not to apply patches, and so
forth.
You can read more on the ``devtool upgrade`` workflow in the "`Use
``devtool upgrade`` to Create a Version of the Recipe that Supports a
Newer Version of the
Software <&YOCTO_DOCS_SDK_URL;#sdk-devtool-use-devtool-upgrade-to-create-a-version-of-the-recipe-that-supports-a-newer-version-of-the-software>`__"
section in the Yocto Project Application Development and the Extensible
Software Development Kit (eSDK) manual. You can also see an example of
how to use ``devtool upgrade`` in the "`Using
``devtool upgrade`` <&YOCTO_DOCS_DEV_URL;#gs-using-devtool-upgrade>`__"
section in the Yocto Project Development Tasks Manual.
.. _devtool-resetting-a-recipe:
Resetting a Recipe
==================
Use the ``devtool reset`` command to remove a recipe and its
configuration (e.g. the corresponding ``.bbappend`` file) from the
workspace layer. Realize that this command deletes the recipe and the
append file. The command does not physically move them for you.
Consequently, you must be sure to physically relocate your updated
recipe and the append file outside of the workspace layer before running
the ``devtool reset`` command.
If the ``devtool reset`` command detects that the recipe or the append
files have been modified, the command preserves the modified files in a
separate "attic" subdirectory under the workspace layer.
Here is an example that resets the workspace directory that contains the
``mtr`` recipe: $ devtool reset mtr NOTE: Cleaning sysroot for recipe
mtr... NOTE: Leaving source tree
/home/scottrif/poky/build/workspace/sources/mtr as-is; if you no longer
need it then please delete it manually $
.. _devtool-building-your-recipe:
Building Your Recipe
====================
Use the ``devtool build`` command to build your recipe. The
``devtool build`` command is equivalent to the
``bitbake -c populate_sysroot`` command.
When you use the ``devtool build`` command, you must supply the root
name of the recipe (i.e. do not provide versions, paths, or extensions).
You can use either the "-s" or the "--disable-parallel-make" options to
disable parallel makes during the build. Here is an example: $ devtool
build recipe
.. _devtool-building-your-image:
Building Your Image
===================
Use the ``devtool build-image`` command to build an image, extending it
to include packages from recipes in the workspace. Using this command is
useful when you want an image that ready for immediate deployment onto a
device for testing. For proper integration into a final image, you need
to edit your custom image recipe appropriately.
When you use the ``devtool build-image`` command, you must supply the
name of the image. This command has no command line options: $ devtool
build-image image
.. _devtool-deploying-your-software-on-the-target-machine:
Deploying Your Software on the Target Machine
=============================================
Use the ``devtool deploy-target`` command to deploy the recipe's build
output to the live target machine: $ devtool deploy-target recipe target
The target is the address of the target machine, which must be running
an SSH server (i.e. ``user@hostname[:destdir]``).
This command deploys all files installed during the
```do_install`` <#ref-tasks-install>`__ task. Furthermore, you do not
need to have package management enabled within the target machine. If
you do, the package manager is bypassed.
.. note::
The ``deploy-target`` functionality is for development only. You
should never use it to update an image that will be used in
production.
Some conditions exist that could prevent a deployed application from
behaving as expected. When both of the following conditions exist, your
application has the potential to not behave correctly when run on the
target:
- You are deploying a new application to the target and the recipe you
used to build the application had correctly defined runtime
dependencies.
- The target does not physically have the packages on which the
application depends installed.
If both of these conditions exist, your application will not behave as
expected. The reason for this misbehavior is because the
``devtool deploy-target`` command does not deploy the packages (e.g.
libraries) on which your new application depends. The assumption is that
the packages are already on the target. Consequently, when a runtime
call is made in the application for a dependent function (e.g. a library
call), the function cannot be found.
To be sure you have all the dependencies local to the target, you need
to be sure that the packages are pre-deployed (installed) on the target
before attempting to run your application.
.. _devtool-removing-your-software-from-the-target-machine:
Removing Your Software from the Target Machine
==============================================
Use the ``devtool undeploy-target`` command to remove deployed build
output from the target machine. For the ``devtool undeploy-target``
command to work, you must have previously used the
```devtool deploy-target`` <#devtool-deploying-your-software-on-the-target-machine>`__
command. $ devtool undeploy-target recipe target The target is the
address of the target machine, which must be running an SSH server (i.e.
``user@hostname``).
.. _devtool-creating-the-workspace:
Creating the Workspace Layer in an Alternative Location
=======================================================
Use the ``devtool create-workspace`` command to create a new workspace
layer in your `Build Directory <#build-directory>`__. When you create a
new workspace layer, it is populated with the ``README`` file and the
``conf`` directory only.
The following example creates a new workspace layer in your current
working and by default names the workspace layer "workspace": $ devtool
create-workspace
You can create a workspace layer anywhere by supplying a pathname with
the command. The following command creates a new workspace layer named
"new-workspace": $ devtool create-workspace /home/scottrif/new-workspace
.. _devtool-get-the-status-of-the-recipes-in-your-workspace:
Get the Status of the Recipes in Your Workspace
===============================================
Use the ``devtool status`` command to list the recipes currently in your
workspace. Information includes the paths to their respective external
source trees.
The ``devtool status`` command has no command-line options: $ devtool
status Following is sample output after using
```devtool add`` <#devtool-adding-a-new-recipe-to-the-workspace>`__ to
create and add the ``mtr_0.86.bb`` recipe to the ``workspace``
directory: $ devtool status mtr:
/home/scottrif/poky/build/workspace/sources/mtr
(/home/scottrif/poky/build/workspace/recipes/mtr/mtr_0.86.bb) $
.. _devtool-search-for-available-target-recipes:
Search for Available Target Recipes
===================================
Use the ``devtool search`` command to search for available target
recipes. The command matches the recipe name, package name, description,
and installed files. The command displays the recipe name as a result of
a match.
When you use the ``devtool search`` command, you must supply a keyword.
The command uses the keyword when searching for a match.
documentation/ref-manual/ref-features.rst
+353
View File
@@ -0,0 +1,353 @@
********
Features
********
This chapter provides a reference of shipped machine and distro features
you can include as part of your image, a reference on image features you
can select, and a reference on feature backfilling.
Features provide a mechanism for working out which packages should be
included in the generated images. Distributions can select which
features they want to support through the ``DISTRO_FEATURES`` variable,
which is set or appended to in a distribution's configuration file such
as ``poky.conf``, ``poky-tiny.conf``, ``poky-lsb.conf`` and so forth.
Machine features are set in the ``MACHINE_FEATURES`` variable, which is
set in the machine configuration file and specifies the hardware
features for a given machine.
These two variables combine to work out which kernel modules, utilities,
and other packages to include. A given distribution can support a
selected subset of features so some machine features might not be
included if the distribution itself does not support them.
One method you can use to determine which recipes are checking to see if
a particular feature is contained or not is to ``grep`` through the
`Metadata <#metadata>`__ for the feature. Here is an example that
discovers the recipes whose build is potentially changed based on a
given feature: $ cd poky $ git grep
'contains.*MACHINE_FEATURES.*feature'
.. _ref-features-machine:
Machine Features
================
The items below are features you can use with
```MACHINE_FEATURES`` <#var-MACHINE_FEATURES>`__. Features do not have a
one-to-one correspondence to packages, and they can go beyond simply
controlling the installation of a package or packages. Sometimes a
feature can influence how certain recipes are built. For example, a
feature might determine whether a particular configure option is
specified within the ```do_configure`` <#ref-tasks-configure>`__ task
for a particular recipe.
This feature list only represents features as shipped with the Yocto
Project metadata:
- *acpi:* Hardware has ACPI (x86/x86_64 only)
- *alsa:* Hardware has ALSA audio drivers
- *apm:* Hardware uses APM (or APM emulation)
- *bluetooth:* Hardware has integrated BT
- *efi:* Support for booting through EFI
- *ext2:* Hardware HDD or Microdrive
- *keyboard:* Hardware has a keyboard
- *pcbios:* Support for booting through BIOS
- *pci:* Hardware has a PCI bus
- *pcmcia:* Hardware has PCMCIA or CompactFlash sockets
- *phone:* Mobile phone (voice) support
- *qvga:* Machine has a QVGA (320x240) display
- *rtc:* Machine has a Real-Time Clock
- *screen:* Hardware has a screen
- *serial:* Hardware has serial support (usually RS232)
- *touchscreen:* Hardware has a touchscreen
- *usbgadget:* Hardware is USB gadget device capable
- *usbhost:* Hardware is USB Host capable
- *vfat:* FAT file system support
- *wifi:* Hardware has integrated WiFi
.. _ref-features-distro:
Distro Features
===============
The items below are features you can use with
```DISTRO_FEATURES`` <#var-DISTRO_FEATURES>`__ to enable features across
your distribution. Features do not have a one-to-one correspondence to
packages, and they can go beyond simply controlling the installation of
a package or packages. In most cases, the presence or absence of a
feature translates to the appropriate option supplied to the configure
script during the ```do_configure`` <#ref-tasks-configure>`__ task for
the recipes that optionally support the feature.
Some distro features are also machine features. These select features
make sense to be controlled both at the machine and distribution
configuration level. See the
```COMBINED_FEATURES`` <#var-COMBINED_FEATURES>`__ variable for more
information.
This list only represents features as shipped with the Yocto Project
metadata:
- *alsa:* Include ALSA support (OSS compatibility kernel modules
installed if available).
- *api-documentation:* Enables generation of API documentation during
recipe builds. The resulting documentation is added to SDK tarballs
when the ``bitbake -c populate_sdk`` command is used. See the
"`Adding API Documentation to the Standard
SDK <&YOCTO_DOCS_SDK_URL;#adding-api-documentation-to-the-standard-sdk>`__"
section in the Yocto Project Application Development and the
Extensible Software Development Kit (eSDK) manual.
- *bluetooth:* Include bluetooth support (integrated BT only).
- *cramfs:* Include CramFS support.
- *directfb:* Include DirectFB support.
- *ext2:* Include tools for supporting for devices with internal
HDD/Microdrive for storing files (instead of Flash only devices).
- *ipsec:* Include IPSec support.
- *ipv6:* Include IPv6 support.
- *keyboard:* Include keyboard support (e.g. keymaps will be loaded
during boot).
- *ldconfig:* Include support for ldconfig and ``ld.so.conf`` on the
target.
- *nfs:* Include NFS client support (for mounting NFS exports on
device).
- *opengl:* Include the Open Graphics Library, which is a
cross-language, multi-platform application programming interface used
for rendering two and three-dimensional graphics.
- *pci:* Include PCI bus support.
- *pcmcia:* Include PCMCIA/CompactFlash support.
- *ppp:* Include PPP dialup support.
- *ptest:* Enables building the package tests where supported by
individual recipes. For more information on package tests, see the
"`Testing Packages With
ptest <&YOCTO_DOCS_DEV_URL;#testing-packages-with-ptest>`__" section
in the Yocto Project Development Tasks Manual.
- *smbfs:* Include SMB networks client support (for mounting
Samba/Microsoft Windows shares on device).
- *systemd:* Include support for this ``init`` manager, which is a full
replacement of for ``init`` with parallel starting of services,
reduced shell overhead, and other features. This ``init`` manager is
used by many distributions.
- *usbgadget:* Include USB Gadget Device support (for USB
networking/serial/storage).
- *usbhost:* Include USB Host support (allows to connect external
keyboard, mouse, storage, network etc).
- *usrmerge:* Merges the ``/bin``, ``/sbin``, ``/lib``, and ``/lib64``
directories into their respective counterparts in the ``/usr``
directory to provide better package and application compatibility.
- *wayland:* Include the Wayland display server protocol and the
library that supports it.
- *wifi:* Include WiFi support (integrated only).
- *x11:* Include the X server and libraries.
.. _ref-features-image:
Image Features
==============
The contents of images generated by the OpenEmbedded build system can be
controlled by the ```IMAGE_FEATURES`` <#var-IMAGE_FEATURES>`__ and
```EXTRA_IMAGE_FEATURES`` <#var-EXTRA_IMAGE_FEATURES>`__ variables that
you typically configure in your image recipes. Through these variables,
you can add several different predefined packages such as development
utilities or packages with debug information needed to investigate
application problems or profile applications.
The following image features are available for all images:
- *allow-empty-password:* Allows Dropbear and OpenSSH to accept root
logins and logins from accounts having an empty password string.
- *dbg-pkgs:* Installs debug symbol packages for all packages installed
in a given image.
- *debug-tweaks:* Makes an image suitable for development (e.g. allows
root logins without passwords and enables post-installation logging).
See the 'allow-empty-password', 'empty-root-password', and
'post-install-logging' features in this list for additional
information.
- *dev-pkgs:* Installs development packages (headers and extra library
links) for all packages installed in a given image.
- *doc-pkgs:* Installs documentation packages for all packages
installed in a given image.
- *empty-root-password:* Sets the root password to an empty string,
which allows logins with a blank password.
- *package-management:* Installs package management tools and preserves
the package manager database.
- *post-install-logging:* Enables logging postinstall script runs to
the ``/var/log/postinstall.log`` file on first boot of the image on
the target system.
.. note::
To make the
/var/log
directory on the target persistent, use the
VOLATILE_LOG_DIR
variable by setting it to "no".
- *ptest-pkgs:* Installs ptest packages for all ptest-enabled recipes.
- *read-only-rootfs:* Creates an image whose root filesystem is
read-only. See the "`Creating a Read-Only Root
Filesystem <&YOCTO_DOCS_DEV_URL;#creating-a-read-only-root-filesystem>`__"
section in the Yocto Project Development Tasks Manual for more
information.
- *splash:* Enables showing a splash screen during boot. By default,
this screen is provided by ``psplash``, which does allow
customization. If you prefer to use an alternative splash screen
package, you can do so by setting the ``SPLASH`` variable to a
different package name (or names) within the image recipe or at the
distro configuration level.
- *staticdev-pkgs:* Installs static development packages, which are
static libraries (i.e. ``*.a`` files), for all packages installed in
a given image.
Some image features are available only when you inherit the
```core-image`` <#ref-classes-core-image>`__ class. The current list of
these valid features is as follows:
- *hwcodecs:* Installs hardware acceleration codecs.
- *nfs-server:* Installs an NFS server.
- *perf:* Installs profiling tools such as ``perf``, ``systemtap``, and
``LTTng``. For general information on user-space tools, see the
`Yocto Project Application Development and the Extensible Software
Development Kit (eSDK) <&YOCTO_DOCS_SDK_URL;>`__ manual.
- *ssh-server-dropbear:* Installs the Dropbear minimal SSH server.
- *ssh-server-openssh:* Installs the OpenSSH SSH server, which is more
full-featured than Dropbear. Note that if both the OpenSSH SSH server
and the Dropbear minimal SSH server are present in
``IMAGE_FEATURES``, then OpenSSH will take precedence and Dropbear
will not be installed.
- *tools-debug:* Installs debugging tools such as ``strace`` and
``gdb``. For information on GDB, see the "`Debugging With the GNU
Project Debugger (GDB)
Remotely <&YOCTO_DOCS_DEV_URL;#platdev-gdb-remotedebug>`__" section
in the Yocto Project Development Tasks Manual. For information on
tracing and profiling, see the `Yocto Project Profiling and Tracing
Manual <&YOCTO_DOCS_PROF_URL;>`__.
- *tools-sdk:* Installs a full SDK that runs on the device.
- *tools-testapps:* Installs device testing tools (e.g. touchscreen
debugging).
- *x11:* Installs the X server.
- *x11-base:* Installs the X server with a minimal environment.
- *x11-sato:* Installs the OpenedHand Sato environment.
.. _ref-features-backfill:
Feature Backfilling
===================
Sometimes it is necessary in the OpenEmbedded build system to extend
```MACHINE_FEATURES`` <#var-MACHINE_FEATURES>`__ or
```DISTRO_FEATURES`` <#var-DISTRO_FEATURES>`__ to control functionality
that was previously enabled and not able to be disabled. For these
cases, we need to add an additional feature item to appear in one of
these variables, but we do not want to force developers who have
existing values of the variables in their configuration to add the new
feature in order to retain the same overall level of functionality.
Thus, the OpenEmbedded build system has a mechanism to automatically
"backfill" these added features into existing distro or machine
configurations. You can see the list of features for which this is done
by finding the
```DISTRO_FEATURES_BACKFILL`` <#var-DISTRO_FEATURES_BACKFILL>`__ and
```MACHINE_FEATURES_BACKFILL`` <#var-MACHINE_FEATURES_BACKFILL>`__
variables in the ``meta/conf/bitbake.conf`` file.
Because such features are backfilled by default into all configurations
as described in the previous paragraph, developers who wish to disable
the new features need to be able to selectively prevent the backfilling
from occurring. They can do this by adding the undesired feature or
features to the
```DISTRO_FEATURES_BACKFILL_CONSIDERED`` <#var-DISTRO_FEATURES_BACKFILL_CONSIDERED>`__
or
```MACHINE_FEATURES_BACKFILL_CONSIDERED`` <#var-MACHINE_FEATURES_BACKFILL_CONSIDERED>`__
variables for distro features and machine features respectively.
Here are two examples to help illustrate feature backfilling:
- *The "pulseaudio" distro feature option*: Previously, PulseAudio
support was enabled within the Qt and GStreamer frameworks. Because
of this, the feature is backfilled and thus enabled for all distros
through the ``DISTRO_FEATURES_BACKFILL`` variable in the
``meta/conf/bitbake.conf`` file. However, your distro needs to
disable the feature. You can disable the feature without affecting
other existing distro configurations that need PulseAudio support by
adding "pulseaudio" to ``DISTRO_FEATURES_BACKFILL_CONSIDERED`` in
your distro's ``.conf`` file. Adding the feature to this variable
when it also exists in the ``DISTRO_FEATURES_BACKFILL`` variable
prevents the build system from adding the feature to your
configuration's ``DISTRO_FEATURES``, effectively disabling the
feature for that particular distro.
- *The "rtc" machine feature option*: Previously, real time clock (RTC)
support was enabled for all target devices. Because of this, the
feature is backfilled and thus enabled for all machines through the
``MACHINE_FEATURES_BACKFILL`` variable in the
``meta/conf/bitbake.conf`` file. However, your target device does not
have this capability. You can disable RTC support for your device
without affecting other machines that need RTC support by adding the
feature to your machine's ``MACHINE_FEATURES_BACKFILL_CONSIDERED``
list in the machine's ``.conf`` file. Adding the feature to this
variable when it also exists in the ``MACHINE_FEATURES_BACKFILL``
variable prevents the build system from adding the feature to your
configuration's ``MACHINE_FEATURES``, effectively disabling RTC
support for that particular machine.
documentation/ref-manual/ref-images.rst
+137
View File
@@ -0,0 +1,137 @@
******
Images
******
The OpenEmbedded build system provides several example images to satisfy
different needs. When you issue the ``bitbake`` command you provide a
“top-level” recipe that essentially begins the build for the type of
image you want.
.. note::
Building an image without GNU General Public License Version 3
(GPLv3), GNU Lesser General Public License Version 3 (LGPLv3), and
the GNU Affero General Public License Version 3 (AGPL-3.0) components
is only supported for minimal and base images. Furthermore, if you
are going to build an image using non-GPLv3 and similarly licensed
components, you must make the following changes in the
local.conf
file before using the BitBake command to build the minimal or base
image:
::
1. Comment out the EXTRA_IMAGE_FEATURES line
2. Set INCOMPATIBLE_LICENSE = "GPL-3.0 LGPL-3.0 AGPL-3.0"
From within the ``poky`` Git repository, you can use the following
command to display the list of directories within the `Source
Directory <#source-directory>`__ that contain image recipe files: $ ls
meta*/recipes*/images/*.bb
Following is a list of supported recipes:
- ``build-appliance-image``: An example virtual machine that contains
all the pieces required to run builds using the build system as well
as the build system itself. You can boot and run the image using
either the `VMware
Player <http://www.vmware.com/products/player/overview.html>`__ or
`VMware
Workstation <http://www.vmware.com/products/workstation/overview.html>`__.
For more information on this image, see the `Build
Appliance <&YOCTO_HOME_URL;/software-item/build-appliance/>`__ page
on the Yocto Project website.
- ``core-image-base``: A console-only image that fully supports the
target device hardware.
- ``core-image-clutter``: An image with support for the Open GL-based
toolkit Clutter, which enables development of rich and animated
graphical user interfaces.
- ``core-image-full-cmdline``: A console-only image with more
full-featured Linux system functionality installed.
- ``core-image-lsb``: An image that conforms to the Linux Standard Base
(LSB) specification. This image requires a distribution configuration
that enables LSB compliance (e.g. ``poky-lsb``). If you build
``core-image-lsb`` without that configuration, the image will not be
LSB-compliant.
- ``core-image-lsb-dev``: A ``core-image-lsb`` image that is suitable
for development work using the host. The image includes headers and
libraries you can use in a host development environment. This image
requires a distribution configuration that enables LSB compliance
(e.g. ``poky-lsb``). If you build ``core-image-lsb-dev`` without that
configuration, the image will not be LSB-compliant.
- ``core-image-lsb-sdk``: A ``core-image-lsb`` that includes everything
in the cross-toolchain but also includes development headers and
libraries to form a complete standalone SDK. This image requires a
distribution configuration that enables LSB compliance (e.g.
``poky-lsb``). If you build ``core-image-lsb-sdk`` without that
configuration, the image will not be LSB-compliant. This image is
suitable for development using the target.
- ``core-image-minimal``: A small image just capable of allowing a
device to boot.
- ``core-image-minimal-dev``: A ``core-image-minimal`` image suitable
for development work using the host. The image includes headers and
libraries you can use in a host development environment.
- ``core-image-minimal-initramfs``: A ``core-image-minimal`` image that
has the Minimal RAM-based Initial Root Filesystem (initramfs) as part
of the kernel, which allows the system to find the first “init”
program more efficiently. See the
```PACKAGE_INSTALL`` <#var-PACKAGE_INSTALL>`__ variable for
additional information helpful when working with initramfs images.
- ``core-image-minimal-mtdutils``: A ``core-image-minimal`` image that
has support for the Minimal MTD Utilities, which let the user
interact with the MTD subsystem in the kernel to perform operations
on flash devices.
- ``core-image-rt``: A ``core-image-minimal`` image plus a real-time
test suite and tools appropriate for real-time use.
- ``core-image-rt-sdk``: A ``core-image-rt`` image that includes
everything in the cross-toolchain. The image also includes
development headers and libraries to form a complete stand-alone SDK
and is suitable for development using the target.
- ``core-image-sato``: An image with Sato support, a mobile environment
and visual style that works well with mobile devices. The image
supports X11 with a Sato theme and applications such as a terminal,
editor, file manager, media player, and so forth.
- ``core-image-sato-dev``: A ``core-image-sato`` image suitable for
development using the host. The image includes libraries needed to
build applications on the device itself, testing and profiling tools,
and debug symbols. This image was formerly ``core-image-sdk``.
- ``core-image-sato-sdk``: A ``core-image-sato`` image that includes
everything in the cross-toolchain. The image also includes
development headers and libraries to form a complete standalone SDK
and is suitable for development using the target.
- ``core-image-testmaster``: A "master" image designed to be used for
automated runtime testing. Provides a "known good" image that is
deployed to a separate partition so that you can boot into it and use
it to deploy a second image to be tested. You can find more
information about runtime testing in the "`Performing Automated
Runtime
Testing <&YOCTO_DOCS_DEV_URL;#performing-automated-runtime-testing>`__"
section in the Yocto Project Development Tasks Manual.
- ``core-image-testmaster-initramfs``: A RAM-based Initial Root
Filesystem (initramfs) image tailored for use with the
``core-image-testmaster`` image.
- ``core-image-weston``: A very basic Wayland image with a terminal.
This image provides the Wayland protocol libraries and the reference
Weston compositor. For more information, see the "`Using Wayland and
Weston <&YOCTO_DOCS_DEV_URL;#dev-using-wayland-and-weston>`__"
section in the Yocto Project Development Tasks Manual.
- ``core-image-x11``: A very basic X11 image with a terminal.
documentation/ref-manual/ref-kickstart.rst
+205
View File
@@ -0,0 +1,205 @@
*******************************************
OpenEmbedded Kickstart (``.wks``) Reference
*******************************************
.. _openembedded-kickstart-wks-reference:
Introduction
============
The current Wic implementation supports only the basic kickstart
partitioning commands: ``partition`` (or ``part`` for short) and
``bootloader``.
.. note::
Future updates will implement more commands and options. If you use
anything that is not specifically supported, results can be
unpredictable.
This chapter provides a reference on the available kickstart commands.
The information lists the commands, their syntax, and meanings.
Kickstart commands are based on the Fedora kickstart versions but with
modifications to reflect Wic capabilities. You can see the original
documentation for those commands at the following link:
http://pykickstart.readthedocs.io/en/latest/kickstart-docs.html
Command: part or partition
==========================
Either of these commands creates a partition on the system and uses the
following syntax: part [mntpoint] partition [mntpoint] If you do not
provide mntpoint, Wic creates a partition but does not mount it.
The ``mntpoint`` is where the partition is mounted and must be in one of
the following forms:
- ``/path``: For example, "/", "/usr", or "/home"
- ``swap``: The created partition is used as swap space
Specifying a mntpoint causes the partition to automatically be mounted.
Wic achieves this by adding entries to the filesystem table (fstab)
during image generation. In order for Wic to generate a valid fstab, you
must also provide one of the ``--ondrive``, ``--ondisk``, or
``--use-uuid`` partition options as part of the command.
.. note::
The mount program must understand the PARTUUID syntax you use with
--use-uuid
and non-root
mountpoint
, including swap. The busybox versions of these application are
currently excluded.
Here is an example that uses "/" as the mountpoint. The command uses
``--ondisk`` to force the partition onto the ``sdb`` disk: part /
--source rootfs --ondisk sdb --fstype=ext3 --label platform --align 1024
Here is a list that describes other supported options you can use with
the ``part`` and ``partition`` commands:
- *``--size``:* The minimum partition size in MBytes. Specify an
integer value such as 500. Do not append the number with "MB". You do
not need this option if you use ``--source``.
- *``--fixed-size``:* The exact partition size in MBytes. You cannot
specify with ``--size``. An error occurs when assembling the disk
image if the partition data is larger than ``--fixed-size``.
- *``--source``:* This option is a Wic-specific option that names the
source of the data that populates the partition. The most common
value for this option is "rootfs", but you can use any value that
maps to a valid source plugin. For information on the source plugins,
see the "`Using the Wic Plugins
Interface <&YOCTO_DOCS_DEV_URL;#wic-using-the-wic-plugin-interface>`__"
section in the Yocto Project Development Tasks Manual.
If you use ``--source rootfs``, Wic creates a partition as large as
needed and fills it with the contents of the root filesystem pointed
to by the ``-r`` command-line option or the equivalent rootfs derived
from the ``-e`` command-line option. The filesystem type used to
create the partition is driven by the value of the ``--fstype``
option specified for the partition. See the entry on ``--fstype``
that follows for more information.
If you use ``--source plugin-name``, Wic creates a partition as large
as needed and fills it with the contents of the partition that is
generated by the specified plugin name using the data pointed to by
the ``-r`` command-line option or the equivalent rootfs derived from
the ``-e`` command-line option. Exactly what those contents are and
filesystem type used are dependent on the given plugin
implementation.
If you do not use the ``--source`` option, the ``wic`` command
creates an empty partition. Consequently, you must use the ``--size``
option to specify the size of the empty partition.
- *``--ondisk`` or ``--ondrive``:* Forces the partition to be created
on a particular disk.
- *``--fstype``:* Sets the file system type for the partition. Valid
values are:
- ``ext4``
- ``ext3``
- ``ext2``
- ``btrfs``
- ``squashfs``
- ``swap``
- *``--fsoptions``:* Specifies a free-form string of options to be used
when mounting the filesystem. This string is copied into the
``/etc/fstab`` file of the installed system and should be enclosed in
quotes. If not specified, the default string is "defaults".
- *``--label label``:* Specifies the label to give to the filesystem to
be made on the partition. If the given label is already in use by
another filesystem, a new label is created for the partition.
- *``--active``:* Marks the partition as active.
- *``--align (in KBytes)``:* This option is a Wic-specific option that
says to start partitions on boundaries given x KBytes.
- *``--no-table``:* This option is a Wic-specific option. Using the
option reserves space for the partition and causes it to become
populated. However, the partition is not added to the partition
table.
- *``--exclude-path``:* This option is a Wic-specific option that
excludes the given relative path from the resulting image. This
option is only effective with the rootfs source plugin.
- *``--extra-space``:* This option is a Wic-specific option that adds
extra space after the space filled by the content of the partition.
The final size can exceed the size specified by the ``--size``
option. The default value is 10 Mbytes.
- *``--overhead-factor``:* This option is a Wic-specific option that
multiplies the size of the partition by the option's value. You must
supply a value greater than or equal to "1". The default value is
"1.3".
- *``--part-name``:* This option is a Wic-specific option that
specifies a name for GPT partitions.
- *``--part-type``:* This option is a Wic-specific option that
specifies the partition type globally unique identifier (GUID) for
GPT partitions. You can find the list of partition type GUIDs at
` <http://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs>`__.
- *``--use-uuid``:* This option is a Wic-specific option that causes
Wic to generate a random GUID for the partition. The generated
identifier is used in the bootloader configuration to specify the
root partition.
- *``--uuid``:* This option is a Wic-specific option that specifies the
partition UUID.
- *``--fsuuid``:* This option is a Wic-specific option that specifies
the filesystem UUID. You can generate or modify
```WKS_FILE`` <#var-WKS_FILE>`__ with this option if a preconfigured
filesystem UUID is added to the kernel command line in the bootloader
configuration before you run Wic.
- *``--system-id``:* This option is a Wic-specific option that
specifies the partition system ID, which is a one byte long,
hexadecimal parameter with or without the 0x prefix.
- *``--mkfs-extraopts``:* This option specifies additional options to
pass to the ``mkfs`` utility. Some default options for certain
filesystems do not take effect. See Wic's help on kickstart (i.e.
``wic help kickstart``).
Command: bootloader
===================
This command specifies how the bootloader should be configured and
supports the following options:
.. note::
Bootloader functionality and boot partitions are implemented by the
various
--source
plugins that implement bootloader functionality. The bootloader
command essentially provides a means of modifying bootloader
configuration.
- *``--timeout``:* Specifies the number of seconds before the
bootloader times out and boots the default option.
- *``--append``:* Specifies kernel parameters. These parameters will be
added to the syslinux ``APPEND`` or ``grub`` kernel command line.
- *``--configfile``:* Specifies a user-defined configuration file for
the bootloader. You can provide a full pathname for the file or a
file that exists in the ``canned-wks`` folder. This option overrides
all other bootloader options.
documentation/ref-manual/ref-manual.rst
+24
View File
@@ -0,0 +1,24 @@
==============================
Yocto Project Reference Manual
==============================
.. toctree::
:caption: Table of Contents
:numbered:
ref-system-requirements
ref-terms
ref-release-process
migration
ref-structure
ref-classes
ref-tasks
ref-devtool-reference
ref-kickstart
ref-qa-checks
ref-images
ref-features
ref-variables
ref-varlocality
faq
resources
documentation/ref-manual/ref-qa-checks.rst
+524
View File
@@ -0,0 +1,524 @@
*****************************
QA Error and Warning Messages
*****************************
.. _qa-introduction:
Introduction
============
When building a recipe, the OpenEmbedded build system performs various
QA checks on the output to ensure that common issues are detected and
reported. Sometimes when you create a new recipe to build new software,
it will build with no problems. When this is not the case, or when you
have QA issues building any software, it could take a little time to
resolve them.
While it is tempting to ignore a QA message or even to disable QA
checks, it is best to try and resolve any reported QA issues. This
chapter provides a list of the QA messages and brief explanations of the
issues you could encounter so that you can properly resolve problems.
The next section provides a list of all QA error and warning messages
based on a default configuration. Each entry provides the message or
error form along with an explanation.
.. note::
- At the end of each message, the name of the associated QA test (as
listed in the "```insane.bbclass`` <#ref-classes-insane>`__"
section) appears within square brackets.
- As mentioned, this list of error and warning messages is for QA
checks only. The list does not cover all possible build errors or
warnings you could encounter.
- Because some QA checks are disabled by default, this list does not
include all possible QA check errors and warnings.
.. _qa-errors-and-warnings:
Errors and Warnings
===================
- ``<packagename>: <path> is using libexec please relocate to <libexecdir> [libexec]``
The specified package contains files in ``/usr/libexec`` when the
distro configuration uses a different path for ``<libexecdir>`` By
default, ``<libexecdir>`` is ``$prefix/libexec``. However, this
default can be changed (e.g. ``${libdir}``).
 
- ``package <packagename> contains bad RPATH <rpath> in file <file> [rpaths]``
The specified binary produced by the recipe contains dynamic library
load paths (rpaths) that contain build system paths such as
```TMPDIR`` <#var-TMPDIR>`__, which are incorrect for the target and
could potentially be a security issue. Check for bad ``-rpath``
options being passed to the linker in your
```do_compile`` <#ref-tasks-compile>`__ log. Depending on the build
system used by the software being built, there might be a configure
option to disable rpath usage completely within the build of the
software.
 
- ``<packagename>: <file> contains probably-redundant RPATH <rpath> [useless-rpaths]``
The specified binary produced by the recipe contains dynamic library
load paths (rpaths) that on a standard system are searched by default
by the linker (e.g. ``/lib`` and ``/usr/lib``). While these paths
will not cause any breakage, they do waste space and are unnecessary.
Depending on the build system used by the software being built, there
might be a configure option to disable rpath usage completely within
the build of the software.
 
- ``<packagename> requires <files>, but no providers in its RDEPENDS [file-rdeps]``
A file-level dependency has been identified from the specified
package on the specified files, but there is no explicit
corresponding entry in ```RDEPENDS`` <#var-RDEPENDS>`__. If
particular files are required at runtime then ``RDEPENDS`` should be
declared in the recipe to ensure the packages providing them are
built.
 
- ``<packagename1> rdepends on <packagename2>, but it isn't a build dependency? [build-deps]``
A runtime dependency exists between the two specified packages, but
there is nothing explicit within the recipe to enable the
OpenEmbedded build system to ensure that dependency is satisfied.
This condition is usually triggered by an
```RDEPENDS`` <#var-RDEPENDS>`__ value being added at the packaging
stage rather than up front, which is usually automatic based on the
contents of the package. In most cases, you should change the recipe
to add an explicit ``RDEPENDS`` for the dependency.
 
- ``non -dev/-dbg/nativesdk- package contains symlink .so: <packagename> path '<path>' [dev-so]``
Symlink ``.so`` files are for development only, and should therefore
go into the ``-dev`` package. This situation might occur if you add
``*.so*`` rather than ``*.so.*`` to a non-dev package. Change
```FILES`` <#var-FILES>`__ (and possibly
```PACKAGES`` <#var-PACKAGES>`__) such that the specified ``.so``
file goes into an appropriate ``-dev`` package.
 
- ``non -staticdev package contains static .a library: <packagename> path '<path>' [staticdev]``
Static ``.a`` library files should go into a ``-staticdev`` package.
Change ```FILES`` <#var-FILES>`__ (and possibly
```PACKAGES`` <#var-PACKAGES>`__) such that the specified ``.a`` file
goes into an appropriate ``-staticdev`` package.
 
- ``<packagename>: found library in wrong location [libdir]``
The specified file may have been installed into an incorrect
(possibly hardcoded) installation path. 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". False
positives occasionally exist. For these cases add "libdir" to
```INSANE_SKIP`` <#var-INSANE_SKIP>`__ for the package.
 
- ``non debug package contains .debug directory: <packagename> path <path> [debug-files]``
The specified package contains a ``.debug`` directory, which should
not appear in anything but the ``-dbg`` package. This situation might
occur if you add a path which contains a ``.debug`` directory and do
not explicitly add the ``.debug`` directory to the ``-dbg`` package.
If this is the case, add the ``.debug`` directory explicitly to
``FILES_${PN}-dbg``. See ```FILES`` <#var-FILES>`__ for additional
information on ``FILES``.
 
- ``Architecture did not match (<machine_arch> to <file_arch>) on <file> [arch]``
By default, the OpenEmbedded build system 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. If the file you receive
the error for is firmware that is not intended to be executed within
the target operating system or is intended to run on a separate
processor within the device, you can add "arch" to
```INSANE_SKIP`` <#var-INSANE_SKIP>`__ for the package. Another
option is to check the ```do_compile`` <#ref-tasks-compile>`__ log
and verify that the compiler options being used are correct.
 
- ``Bit size did not match (<machine_bits> to <file_bits>) <recipe> on <file> [arch]``
By default, the OpenEmbedded build system 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. If the file you receive
the error for is firmware that is not intended to be executed within
the target operating system or is intended to run on a separate
processor within the device, you can add "arch" to
```INSANE_SKIP`` <#var-INSANE_SKIP>`__ for the package. Another
option is to check the ```do_compile`` <#ref-tasks-compile>`__ log
and verify that the compiler options being used are correct.
 
- ``Endianness did not match (<machine_endianness> to <file_endianness>) on <file> [arch]``
By default, the OpenEmbedded build system 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. If the file you receive
the error for is firmware that is not intended to be executed within
the target operating system or is intended to run on a separate
processor within the device, you can add "arch" to
```INSANE_SKIP`` <#var-INSANE_SKIP>`__ for the package. Another
option is to check the ```do_compile`` <#ref-tasks-compile>`__ log
and verify that the compiler options being used are correct.
 
- ``ELF binary '<file>' has relocations in .text [textrel]``
The specified ELF binary contains relocations in its ``.text``
sections. This situation can result in a performance impact at
runtime.
Typically, the way to solve this performance issue is to add "-fPIC"
or "-fpic" to the compiler command-line options. For example, given
software that reads ```CFLAGS`` <#var-CFLAGS>`__ when you build it,
you could add the following to your recipe: CFLAGS_append = " -fPIC "
For more information on text relocations at runtime, see
` <http://www.akkadia.org/drepper/textrelocs.html>`__.
 
- ``No GNU_HASH in the elf binary: '<file>' [ldflags]``
This indicates that binaries produced when building the recipe have
not been linked with the ```LDFLAGS`` <#var-LDFLAGS>`__ options
provided by the build system. Check to be sure that the ``LDFLAGS``
variable is being passed to the linker command. A common workaround
for this situation is to pass in ``LDFLAGS`` using
```TARGET_CC_ARCH`` <#var-TARGET_CC_ARCH>`__ within the recipe as
follows: TARGET_CC_ARCH += "${LDFLAGS}"
 
- ``Package <packagename> contains Xorg driver (<driver>) but no xorg-abi- dependencies [xorg-driver-abi]``
The specified package contains an Xorg driver, but does not have a
corresponding ABI package dependency. 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.
 
- ``The /usr/share/info/dir file is not meant to be shipped in a particular package. [infodir]``
The ``/usr/share/info/dir`` should not be packaged. Add the following
line to your ```do_install`` <#ref-tasks-install>`__ task or to your
``do_install_append`` within the recipe as follows: rm
${D}${infodir}/dir
 
- ``Symlink <path> in <packagename> points to TMPDIR [symlink-to-sysroot]``
The specified symlink points into ```TMPDIR`` <#var-TMPDIR>`__ on the
host. Such symlinks will work on the host. However, they are clearly
invalid when running on the target. You should either correct the
symlink to use a relative path or remove the symlink.
 
- ``<file> failed sanity test (workdir) in path <path> [la]``
The specified ``.la`` file contains ```TMPDIR`` <#var-TMPDIR>`__
paths. Any ``.la`` file containing these paths is incorrect since
``libtool`` adds the correct sysroot prefix when using the files
automatically itself.
 
- ``<file> failed sanity test (tmpdir) in path <path> [pkgconfig]``
The specified ``.pc`` file contains
```TMPDIR`` <#var-TMPDIR>`__\ ``/``\ ```WORKDIR`` <#var-WORKDIR>`__
paths. Any ``.pc`` file containing these paths is incorrect since
``pkg-config`` itself adds the correct sysroot prefix when the files
are accessed.
 
- ``<packagename> rdepends on <debug_packagename> [debug-deps]``
A dependency exists between the specified non-dbg package (i.e. a
package whose name does not end in ``-dbg``) and a package that is a
``dbg`` package. The ``dbg`` packages contain debug symbols and are
brought in using several different methods:
- Using the ``dbg-pkgs``
```IMAGE_FEATURES`` <#var-IMAGE_FEATURES>`__ value.
- Using ```IMAGE_INSTALL`` <#var-IMAGE_INSTALL>`__.
- As a dependency of another ``dbg`` package that was brought in
using one of the above methods.
The dependency might have been automatically added because the
``dbg`` package erroneously contains files that it should not contain
(e.g. a non-symlink ``.so`` file) or it might have been added
manually (e.g. by adding to ```RDEPENDS`` <#var-RDEPENDS>`__).
 
- ``<packagename> rdepends on <dev_packagename> [dev-deps]``
A dependency exists between the specified non-dev package (a package
whose name does not end in ``-dev``) and a package that is a ``dev``
package. The ``dev`` packages contain development headers and are
usually brought in using several different methods:
- Using the ``dev-pkgs``
```IMAGE_FEATURES`` <#var-IMAGE_FEATURES>`__ value.
- Using ```IMAGE_INSTALL`` <#var-IMAGE_INSTALL>`__.
- As a dependency of another ``dev`` package that was brought in
using one of the above methods.
The dependency might have been automatically added (because the
``dev`` package erroneously contains files that it should not have
(e.g. a non-symlink ``.so`` file) or it might have been added
manually (e.g. by adding to ```RDEPENDS`` <#var-RDEPENDS>`__).
 
- ``<var>_<packagename> is invalid: <comparison> (<value>) only comparisons <, =, >, <=, and >= are allowed [dep-cmp]``
If you are adding a versioned dependency relationship to one of the
dependency variables (```RDEPENDS`` <#var-RDEPENDS>`__,
```RRECOMMENDS`` <#var-RRECOMMENDS>`__,
```RSUGGESTS`` <#var-RSUGGESTS>`__,
```RPROVIDES`` <#var-RPROVIDES>`__,
```RREPLACES`` <#var-RREPLACES>`__, or
```RCONFLICTS`` <#var-RCONFLICTS>`__), you must only use the named
comparison operators. Change the versioned dependency values you are
adding to match those listed in the message.
 
- ``<recipename>: The compile log indicates that host include and/or library paths were used. Please check the log '<logfile>' for more information. [compile-host-path]``
The log for the ```do_compile`` <#ref-tasks-compile>`__ task
indicates that paths on the host were searched for files, which is
not appropriate when cross-compiling. Look for "is unsafe for
cross-compilation" or "CROSS COMPILE Badness" in the specified log
file.
 
- ``<recipename>: The install log indicates that host include and/or library paths were used. Please check the log '<logfile>' for more information. [install-host-path]``
The log for the ```do_install`` <#ref-tasks-install>`__ task
indicates that paths on the host were searched for files, which is
not appropriate when cross-compiling. Look for "is unsafe for
cross-compilation" or "CROSS COMPILE Badness" in the specified log
file.
 
- ``This autoconf log indicates errors, it looked at host include and/or library paths while determining system capabilities. Rerun configure task after fixing this. The path was '<path>'``
The log for the ```do_configure`` <#ref-tasks-configure>`__ task
indicates that paths on the host were searched for files, which is
not appropriate when cross-compiling. Look for "is unsafe for
cross-compilation" or "CROSS COMPILE Badness" in the specified log
file.
 
- ``<packagename> doesn't match the [a-z0-9.+-]+ regex [pkgname]``
The convention within the OpenEmbedded build system (sometimes
enforced by the package manager itself) is to require that package
names are all lower case and to allow a restricted set of characters.
If your recipe name does not match this, or you add packages to
```PACKAGES`` <#var-PACKAGES>`__ that do not conform to the
convention, then you will receive this error. Rename your recipe. Or,
if you have added a non-conforming package name to ``PACKAGES``,
change the package name appropriately.
 
- ``<recipe>: configure was passed unrecognized options: <options> [unknown-configure-option]``
The configure script is reporting that the specified options are
unrecognized. This situation could be because the options were
previously valid but have been removed from the configure script. Or,
there was a mistake when the options were added and there is another
option that should be used instead. If you are unsure, consult the
upstream build documentation, the ``./configure --help`` output, and
the upstream change log or release notes. Once you have worked out
what the appropriate change is, you can update
```EXTRA_OECONF`` <#var-EXTRA_OECONF>`__,
```PACKAGECONFIG_CONFARGS`` <#var-PACKAGECONFIG_CONFARGS>`__, or the
individual ```PACKAGECONFIG`` <#var-PACKAGECONFIG>`__ option values
accordingly.
 
- ``Recipe <recipefile> has PN of "<recipename>" which is in OVERRIDES, this can result in unexpected behavior. [pn-overrides]``
The specified recipe has a name (```PN`` <#var-PN>`__) value that
appears in ```OVERRIDES`` <#var-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`` <#var-MACHINE>`__
or ```DISTRO`` <#var-DISTRO>`__), it can have unexpected
consequences. For example, assignments such as
``FILES_${PN} = "xyz"`` effectively turn into ``FILES = "xyz"``.
Rename your recipe (or if ``PN`` is being set explicitly, change the
``PN`` value) so that the conflict does not occur. See
```FILES`` <#var-FILES>`__ for additional information.
 
- ``<recipefile>: Variable <variable> is set as not being package specific, please fix this. [pkgvarcheck]``
Certain variables (```RDEPENDS`` <#var-RDEPENDS>`__,
```RRECOMMENDS`` <#var-RRECOMMENDS>`__,
```RSUGGESTS`` <#var-RSUGGESTS>`__,
```RCONFLICTS`` <#var-RCONFLICTS>`__,
```RPROVIDES`` <#var-RPROVIDES>`__,
```RREPLACES`` <#var-RREPLACES>`__, ```FILES`` <#var-FILES>`__,
``pkg_preinst``, ``pkg_postinst``, ``pkg_prerm``, ``pkg_postrm``, and
```ALLOW_EMPTY`` <#var-ALLOW_EMPTY>`__) should always be set specific
to a package (i.e. they should be set with a package name override
such as ``RDEPENDS_${PN} = "value"`` rather than
``RDEPENDS = "value"``). If you receive this error, correct any
assignments to these variables within your recipe.
 
- ``File '<file>' from <recipename> was already stripped, this will prevent future debugging! [already-stripped]``
Produced binaries have 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.
Depending on the build system used by the software being built,
disabling this stripping could be as easy as specifying an additional
configure option. If not, disabling stripping might involve patching
the build scripts. In the latter case, look for references to "strip"
or "STRIP", or the "-s" or "-S" command-line options being specified
on the linker command line (possibly through the compiler command
line if preceded with "-Wl,").
.. note::
Disabling stripping here does not mean that the final packaged
binaries will be unstripped. Once the OpenEmbedded build system
splits out debug symbols to the
-dbg
package, it will then strip the symbols from the binaries.
 
- ``<packagename> is listed in PACKAGES multiple times, this leads to packaging errors. [packages-list]``
Package names must appear only once in the
```PACKAGES`` <#var-PACKAGES>`__ variable. You might receive this
error if you are attempting to add a package to ``PACKAGES`` that is
already in the variable's value.
 
- ``FILES variable for package <packagename> contains '//' which is invalid. Attempting to fix this but you should correct the metadata. [files-invalid]``
The string "//" is invalid in a Unix path. Correct all occurrences
where this string appears in a ```FILES`` <#var-FILES>`__ variable so
that there is only a single "/".
 
- ``<recipename>: Files/directories were installed but not shipped in any package [installed-vs-shipped]``
Files have been installed within the
```do_install`` <#ref-tasks-install>`__ task but have not been
included in any package by way of the ```FILES`` <#var-FILES>`__
variable. Files that do not appear in any package cannot be present
in an image later on in the build process. You need to do one of the
following:
- Add the files to ``FILES`` for the package you want them to appear
in (e.g. ``FILES_${``\ ```PN`` <#var-PN>`__\ ``}`` for the main
package).
- Delete the files at the end of the ``do_install`` task if the
files are not needed in any package.
 
- ``<oldpackage>-<oldpkgversion> was registered as shlib provider for <library>, changing it to <newpackage>-<newpkgversion> because it was built later``
This message means that both ``<oldpackage>`` and ``<newpackage>``
provide the specified shared library. You can expect this message
when a recipe has been renamed. However, if that is not the case, the
message might indicate that a private version of a library is being
erroneously picked up as the provider for a common library. If that
is the case, you should add the library's ``.so`` file name to
```PRIVATE_LIBS`` <#var-PRIVATE_LIBS>`__ in the recipe that provides
the private version of the library.
- ``LICENSE_<packagename> includes licenses (<licenses>) that are not listed in LICENSE [unlisted-pkg-lics]``
The ```LICENSE`` <#var-LICENSE>`__ of the recipe should be a superset
of all the licenses of all packages produced by this recipe. In other
words, any license in ``LICENSE_*`` should also appear in
```LICENSE`` <#var-LICENSE>`__.
 
Configuring and Disabling QA Checks
===================================
You can configure the QA checks globally so that specific check failures
either raise a warning or an error message, using the
```WARN_QA`` <#var-WARN_QA>`__ and ```ERROR_QA`` <#var-ERROR_QA>`__
variables, respectively. You can also disable checks within a particular
recipe using ```INSANE_SKIP`` <#var-INSANE_SKIP>`__. For information on
how to work with the QA checks, see the
"```insane.bbclass`` <#ref-classes-insane>`__" section.
.. note::
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.
documentation/ref-manual/ref-release-process.rst
+182
View File
@@ -0,0 +1,182 @@
*****************************************************
Yocto Project Releases and the Stable Release Process
*****************************************************
The Yocto Project release process is predictable and consists of both
major and minor (point) releases. This brief chapter provides
information on how releases are named, their life cycle, and their
stability.
Major and Minor Release Cadence
===============================
The Yocto Project delivers major releases (e.g. DISTRO) using a six
month cadence roughly timed each April and October of the year.
Following are examples of some major YP releases with their codenames
also shown. See the "`Major Release
Codenames <#major-release-codenames>`__" section for information on
codenames used with major releases. 2.2 (Morty) 2.1 (Krogoth) 2.0
(Jethro) While the cadence is never perfect, this timescale facilitates
regular releases that have strong QA cycles while not overwhelming users
with too many new releases. The cadence is predictable and avoids many
major holidays in various geographies.
The Yocto project delivers minor (point) releases on an unscheduled
basis and are usually driven by the accumulation of enough significant
fixes or enhancements to the associated major release. Following are
some example past point releases: 2.1.1 2.1.2 2.2.1 The point release
indicates a point in the major release branch where a full QA cycle and
release process validates the content of the new branch.
.. note::
Realize that there can be patches merged onto the stable release
branches as and when they become available.
Major Release Codenames
=======================
Each major release receives a codename that identifies the release in
the `Yocto Project Source
Repositories <&YOCTO_DOCS_OM_URL;#yocto-project-repositories>`__. The
concept is that branches of `Metadata <#metadata>`__ with the same
codename are likely to be compatible and thus work together.
.. note::
Codenames are associated with major releases because a Yocto Project
release number (e.g. DISTRO) could conflict with a given layer or
company versioning scheme. Codenames are unique, interesting, and
easily identifiable.
Releases are given a nominal release version as well but the codename is
used in repositories for this reason. You can find information on Yocto
Project releases and codenames at
` <https://wiki.yoctoproject.org/wiki/Releases>`__.
Stable Release Process
======================
Once released, the release enters the stable release process at which
time a person is assigned as the maintainer for that stable release.
This maintainer monitors activity for the release by investigating and
handling nominated patches and backport activity. Only fixes and
enhancements that have first been applied on the "master" branch (i.e.
the current, in-development branch) are considered for backporting to a
stable release.
.. note::
The current Yocto Project policy regarding backporting is to consider
bug fixes and security fixes only. Policy dictates that features are
not backported to a stable release. This policy means generic recipe
version upgrades are unlikely to be accepted for backporting. The
exception to this policy occurs when a strong reason exists such as
the fix happens to also be the preferred upstream approach.
Stable release branches have strong maintenance for about a year after
their initial release. Should significant issues be found for any
release regardless of its age, fixes could be backported to older
releases. For issues that are not backported given an older release,
Community LTS trees and branches exist where community members share
patches for older releases. However, these types of patches do not go
through the same release process as do point releases. You can find more
information about stable branch maintenance at
` <https://wiki.yoctoproject.org/wiki/Stable_branch_maintenance>`__.
Testing and Quality Assurance
=============================
Part of the Yocto Project development and release process is quality
assurance through the execution of test strategies. Test strategies
provide the Yocto Project team a way to ensure a release is validated.
Additionally, because the test strategies are visible to you as a
developer, you can validate your projects. This section overviews the
available test infrastructure used in the Yocto Project. For information
on how to run available tests on your projects, see the "`Performing
Automated Runtime
Testing <&YOCTO_DOCS_DEV_URL;#performing-automated-runtime-testing>`__"
section in the Yocto Project Development Tasks Manual.
The QA/testing infrastructure is woven into the project to the point
where core developers take some of it for granted. The infrastructure
consists of the following pieces:
- ``bitbake-selftest``: A standalone command that runs unit tests on
key pieces of BitBake and its fetchers.
- ```sanity.bbclass`` <#ref-classes-sanity>`__: This automatically
included class checks the build environment for missing tools (e.g.
``gcc``) or common misconfigurations such as
```MACHINE`` <#var-MACHINE>`__ set incorrectly.
- ```insane.bbclass`` <#ref-classes-insane>`__: This class checks the
generated output from builds for sanity. For example, if building for
an ARM target, did the build produce ARM binaries. If, for example,
the build produced PPC binaries then there is a problem.
- ```testimage.bbclass`` <#ref-classes-testimage*>`__: This class
performs runtime testing of images after they are built. The tests
are usually used with `QEMU <&YOCTO_DOCS_DEV_URL;#dev-manual-qemu>`__
to boot the images and check the combined runtime result boot
operation and functions. However, the test can also use the IP
address of a machine to test.
- ```ptest`` <&YOCTO_DOCS_DEV_URL;#testing-packages-with-ptest>`__:
Runs tests against packages produced during the build for a given
piece of software. The test allows the packages to be be run within a
target image.
- ``oe-selftest``: Tests combination BitBake invocations. These tests
operate outside the OpenEmbedded build system itself. The
``oe-selftest`` can run all tests by default or can run selected
tests or test suites.
.. note::
Running
oe-selftest
requires host packages beyond the "Essential" grouping. See the "
Required Packages for the Build Host
" section for more information.
Originally, much of this testing was done manually. However, significant
effort has been made to automate the tests so that more people can use
them and the Yocto Project development team can run them faster and more
efficiently.
The Yocto Project's main Autobuilder (``autobuilder.yoctoproject.org``)
publicly tests each Yocto Project release's code in the
`OE-Core <#oe-core>`__, Poky, and BitBake repositories. The testing
occurs for both the current state of the "master" branch and also for
submitted patches. Testing for submitted patches usually occurs in the
"ross/mut" branch in the ``poky-contrib`` repository (i.e. the
master-under-test branch) or in the "master-next" branch in the ``poky``
repository.
.. note::
You can find all these branches in the Yocto Project
Source Repositories
.
Testing within these public branches ensures in a publicly visible way
that all of the main supposed architectures and recipes in OE-Core
successfully build and behave properly.
Various features such as ``multilib``, sub architectures (e.g. ``x32``,
``poky-tiny``, ``musl``, ``no-x11`` and and so forth),
``bitbake-selftest``, and ``oe-selftest`` are tested as part of the QA
process of a release. Complete testing and validation for a release
takes the Autobuilder workers several hours.
.. note::
The Autobuilder workers are non-homogeneous, which means regular
testing across a variety of Linux distributions occurs. The
Autobuilder is limited to only testing QEMU-based setups and not real
hardware.
Finally, in addition to the Autobuilder's tests, the Yocto Project QA
team also performs testing on a variety of platforms, which includes
actual hardware, to ensure expected results.
documentation/ref-manual/ref-structure.rst
+871
View File
@@ -0,0 +1,871 @@
**************************
Source Directory Structure
**************************
The `Source Directory <#source-directory>`__ consists of numerous files,
directories and subdirectories; understanding their locations and
contents is key to using the Yocto Project effectively. This chapter
describes the Source Directory and gives information about those files
and directories.
For information on how to establish a local Source Directory on your
development system, see the "`Locating Yocto Project Source
Files <&YOCTO_DOCS_DEV_URL;#locating-yocto-project-source-files>`__"
section in the Yocto Project Development Tasks 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.
.. _structure-core:
Top-Level Core Components
=========================
This section describes the top-level components of the `Source
Directory <#source-directory>`__.
.. _structure-core-bitbake:
``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 <#metadata>`__ interpreter, reads the
Yocto Project Metadata and runs the tasks defined by that data. Failures
are usually caused by errors in your 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 the
environment setup script (i.e. ````` <#structure-core-script>`__) 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 <&YOCTO_DOCS_BB_URL;>`__.
.. _structure-core-build:
``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 <#build-directory>`__ is created initially when you ``source``
the OpenEmbedded build environment setup script (i.e.
````` <#structure-core-script>`__).
It is also possible to place output and configuration files in a
directory separate from the `Source Directory <#source-directory>`__ by
providing a directory name when you ``source`` the setup script. For
information on separating output from your local Source Directory files
(commonly described as an "out of tree" build), see the
"````` <#structure-core-script>`__" section.
.. _handbook:
``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 its own sub-folder;
for example, the files for this reference manual reside in the
``ref-manual/`` directory.
.. _structure-core-meta:
``meta/``
---------
This directory contains the minimal, underlying OpenEmbedded-Core
metadata. The directory holds recipes, common classes, and machine
configuration for strictly emulated targets (``qemux86``, ``qemuarm``,
and so forth.)
.. _structure-core-meta-poky:
``meta-poky/``
--------------
Designed above the ``meta/`` content, this directory adds just enough
metadata to define the Poky reference distribution.
.. _structure-core-meta-yocto-bsp:
``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 <&YOCTO_DOCS_BSP_URL;>`__.
.. _structure-meta-selftest:
``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.
.. _structure-meta-skeleton:
``meta-skeleton/``
------------------
This directory contains template recipes for BSP and kernel development.
.. _structure-core-scripts:
``scripts/``
------------
This directory contains various integration scripts that implement extra
functionality in the Yocto Project environment (e.g. QEMU scripts). The
````` <#structure-core-script>`__ script prepends 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``.
.. _structure-core-script:
````
----
This script sets up the OpenEmbedded build environment. 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 <#build-directory>`__ is created, your working
directory becomes the Build Directory, and you are presented with some
simple suggestions as to what to do next, including a list of some
possible targets to build. 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-64' The
default output of the ``oe-init-build-env`` script is from the
``conf-notes.txt`` file, which is found in the ``meta-poky`` directory
within the `Source Directory <#source-directory>`__. If you design a
custom distribution, you can include your own version of this
configuration file to mention the targets defined by your distribution.
See the "`Creating a Custom Template Configuration
Directory <&YOCTO_DOCS_DEV_URL;#creating-a-custom-template-configuration-directory>`__"
section in the Yocto Project Development Tasks 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-directory>`__: $ source OE_INIT_FILE ~/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 <&YOCTO_DOCS_DEV_URL;#creating-a-custom-template-configuration-directory>`__"
section in the Yocto Project Development Tasks 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_FILE
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.
.. _structure-basic-top-level:
``LICENSE, README, and README.hardware``
----------------------------------------
These files are standard top-level files.
.. _structure-build:
The Build Directory - ``build/``
================================
The OpenEmbedded build system creates the `Build
Directory <#build-directory>`__ when you run the build environment setup
script ````` <#structure-core-script>`__. If you do not give the Build
Directory a specific name when you run the setup script, the name
defaults to ``build/``.
For subsequent parsing and processing, the name of the Build directory
is available via the ```TOPDIR`` <#var-TOPDIR>`__ variable.
.. _structure-build-buildhistory:
``build/buildhistory/``
-----------------------
The OpenEmbedded build system creates this directory when you enable
build history via the ``buildhistory`` class file. The directory
organizes build information into image, packages, and SDK
subdirectories. For information on the build history feature, see the
"`Maintaining Build Output
Quality <&YOCTO_DOCS_DEV_URL;#maintaining-build-output-quality>`__"
section in the Yocto Project Development Tasks Manual.
.. _structure-build-conf-local.conf:
``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 such variables are
relatively rare.
At a minimum, you would normally edit this file to select the target
``MACHINE``, which package types you wish to use
(```PACKAGE_CLASSES`` <#var-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
````` <#structure-core-script>`__.
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 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`` <#var-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.
.. _structure-build-conf-bblayers.conf:
``build/conf/bblayers.conf``
----------------------------
This configuration file defines
`layers <&YOCTO_DOCS_DEV_URL;#understanding-and-creating-layers>`__,
which are directory trees, traversed (or walked) by BitBake. The
``bblayers.conf`` file uses the ```BBLAYERS`` <#var-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.
````` <#structure-core-script>`__).
As with the ``local.conf`` file, 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 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`` <#var-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.
.. _structure-build-conf-sanity_info:
``build/cache/sanity_info``
---------------------------
This file indicates the state of the sanity checks and is created during
the build.
.. _structure-build-downloads:
``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.
.. _structure-build-sstate-cache:
``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.
.. _structure-build-tmp:
``build/tmp/``
--------------
The OpenEmbedded build system creates and uses this directory for all
the build system's output. The ```TMPDIR`` <#var-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.
.. _structure-build-tmp-buildstats:
``build/tmp/buildstats/``
-------------------------
This directory stores the build statistics.
.. _structure-build-tmp-cache:
``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.
.. _structure-build-tmp-deploy:
``build/tmp/deploy/``
---------------------
This directory contains any "end result" output from the OpenEmbedded
build process. The ```DEPLOY_DIR`` <#var-DEPLOY_DIR>`__ variable points
to this directory. For more detail on the contents of the ``deploy``
directory, see the
"`Images <&YOCTO_DOCS_OM_URL;#images-dev-environment>`__" and
"`Application Development
SDK <&YOCTO_DOCS_OM_URL;#sdk-dev-environment>`__" sections in the Yocto
Project Overview and Concepts Manual.
.. _structure-build-tmp-deploy-deb:
``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.
.. _structure-build-tmp-deploy-rpm:
``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.
.. _structure-build-tmp-deploy-ipk:
``build/tmp/deploy/ipk/``
-------------------------
This directory receives ``.ipk`` packages produced by the build process.
.. _structure-build-tmp-deploy-licenses:
``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 <&YOCTO_DOCS_DEV_URL;#maintaining-open-source-license-compliance-during-your-products-lifecycle>`__"
section in the Yocto Project Development Tasks Manual.
.. _structure-build-tmp-deploy-images:
``build/tmp/deploy/images/``
----------------------------
This directory is populated with the basic output objects of the build
(think of them as the "generated artifacts" of the build process),
including things like the boot loader image, kernel, root filesystem and
more. If you want to flash the resulting image from a build onto a
device, look here for the necessary components.
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
.. _structure-build-tmp-deploy-sdk:
``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 <&YOCTO_DOCS_SDK_URL;#sdk-building-an-sdk-installer>`__"
section in the Yocto Project Application Development and the Extensible
Software Development Kit (eSDK) manual.
.. _structure-build-tmp-sstate-control:
``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.
.. _structure-build-tmp-sysroots-components:
``build/tmp/sysroots-components/``
----------------------------------
This directory is the location of the sysroot contents that the task
```do_prepare_recipe_sysroot`` <#ref-tasks-prepare_recipe_sysroot>`__
links or copies into the recipe-specific sysroot for each recipe listed
in ```DEPENDS`` <#var-DEPENDS>`__. Population of this directory is
handled through shared state, while the path is specified by the
```COMPONENTS_DIR`` <#var-COMPONENTS_DIR>`__ variable. Apart from a few
unusual circumstances, handling of the ``sysroots-components`` directory
should be automatic, and recipes should not directly reference
``build/tmp/sysroots-components``.
.. _structure-build-tmp-sysroots:
``build/tmp/sysroots/``
-----------------------
Previous versions of the OpenEmbedded build system used to create a
global shared sysroot per machine along with a native sysroot. Beginning
with the DISTRO version of the Yocto Project, sysroots exist in
recipe-specific ```WORKDIR`` <#var-WORKDIR>`__ directories. Thus, the
``build/tmp/sysroots/`` directory is unused.
.. note::
The
build/tmp/sysroots/
directory can still be populated using the
bitbake build-sysroots
command and can be used for compatibility in some cases. However, in
general it is not recommended to populate this directory. Individual
recipe-specific sysroots should be used.
.. _structure-build-tmp-stamps:
``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 <&YOCTO_DOCS_OM_URL;#stamp-files-and-the-rerunning-of-tasks>`__"
section in the Yocto Project Overview and Concepts Manual.
.. _structure-build-tmp-log:
``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.
.. _structure-build-tmp-work:
``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`` <#var-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 <&YOCTO_DOCS_DEV_URL;#using-a-quilt-workflow>`__" section in
the Yocto Project Development Tasks 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/``.
.. _structure-build-tmp-work-tunearch-recipename-version:
``build/tmp/work/tunearch/recipename/version/``
-----------------------------------------------
The recipe work directory - ``${WORKDIR}``.
As described earlier in the
"```build/tmp/sysroots/`` <#structure-build-tmp-sysroots>`__" section,
beginning with the DISTRO release of the Yocto Project, the OpenEmbedded
build system builds each recipe in its own work directory (i.e.
```WORKDIR`` <#var-WORKDIR>`__). The path to the work directory is
constructed using the architecture of the given build (e.g.
```TUNE_PKGARCH`` <#var-TUNE_PKGARCH>`__,
```MACHINE_ARCH`` <#var-MACHINE_ARCH>`__, or "allarch"), the recipe
name, and the version of the recipe (i.e.
```PE`` <#var-PE>`__\ ``:``\ ```PV`` <#var-PV>`__\ ``-``\ ```PR`` <#var-PR>`__).
A number of key subdirectories exist within each recipe work directory:
- ``${WORKDIR}/temp``: Contains the log files of each task executed for
this recipe, the "run" files for each executed task, which contain
the code run, and a ``log.task_order`` file, which lists the order in
which tasks were executed.
- ``${WORKDIR}/image``: Contains the output of the
```do_install`` <#ref-tasks-install>`__ task, which corresponds to
the ``${``\ ```D`` <#var-D>`__\ ``}`` variable in that task.
- ``${WORKDIR}/pseudo``: Contains the pseudo database and log for any
tasks executed under pseudo for the recipe.
- ``${WORKDIR}/sysroot-destdir``: Contains the output of the
```do_populate_sysroot`` <#ref-tasks-populate_sysroot>`__ task.
- ``${WORKDIR}/package``: Contains the output of the
```do_package`` <#ref-tasks-package>`__ task before the output is
split into individual packages.
- ``${WORKDIR}/packages-split``: Contains the output of the
``do_package`` task after the output has been split into individual
packages. Subdirectories exist for each individual package created by
the recipe.
- ``${WORKDIR}/recipe-sysroot``: A directory populated with the target
dependencies of the recipe. This directory looks like the target
filesystem and contains libraries that the recipe might need to link
against (e.g. the C library).
- ``${WORKDIR}/recipe-sysroot-native``: A directory populated with the
native dependencies of the recipe. This directory contains the tools
the recipe needs to build (e.g. the compiler, Autoconf, libtool, and
so forth).
- ``${WORKDIR}/build``: This subdirectory applies only to recipes that
support builds where the source is separate from the build artifacts.
The OpenEmbedded build system uses this directory as a separate build
directory (i.e. ``${``\ ```B`` <#var-B>`__\ ``}``).
.. _structure-build-work-shared:
``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).
.. _structure-meta:
The Metadata - ``meta/``
========================
As mentioned previously, `Metadata <#metadata>`__ is the core of the
Yocto Project. Metadata has several important subdivisions:
.. _structure-meta-classes:
``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 <#ref-classes>`__" chapter.
.. _structure-meta-conf:
``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.
.. _structure-meta-conf-machine:
``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.
.. _structure-meta-conf-distro:
``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.
.. _structure-meta-conf-machine-sdk:
``meta/conf/machine-sdk/``
--------------------------
The OpenEmbedded build system searches this directory for configuration
files that correspond to the value of
```SDKMACHINE`` <#var-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.
.. _structure-meta-files:
``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.
.. _structure-meta-lib:
``meta/lib/``
-------------
This directory contains OpenEmbedded Python library code used during the
build process.
.. _structure-meta-recipes-bsp:
``meta/recipes-bsp/``
---------------------
This directory contains anything linking to specific hardware or
hardware configuration information such as "u-boot" and "grub".
.. _structure-meta-recipes-connectivity:
``meta/recipes-connectivity/``
------------------------------
This directory contains libraries and applications related to
communication with other devices.
.. _structure-meta-recipes-core:
``meta/recipes-core/``
----------------------
This directory contains what is needed to build a basic working Linux
image including commonly used dependencies.
.. _structure-meta-recipes-devtools:
``meta/recipes-devtools/``
--------------------------
This directory contains tools that are primarily used by the build
system. The tools, however, can also be used on targets.
.. _structure-meta-recipes-extended:
``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.
.. _structure-meta-recipes-gnome:
``meta/recipes-gnome/``
-----------------------
This directory contains all things related to the GTK+ application
framework.
.. _structure-meta-recipes-graphics:
``meta/recipes-graphics/``
--------------------------
This directory contains X and other graphically related system
libraries.
.. _structure-meta-recipes-kernel:
``meta/recipes-kernel/``
------------------------
This directory contains the kernel and generic applications and
libraries that have strong kernel dependencies.
.. _structure-meta-recipes-lsb4:
``meta/recipes-lsb4/``
----------------------
This directory contains recipes specifically added to support the Linux
Standard Base (LSB) version 4.x.
.. _structure-meta-recipes-multimedia:
``meta/recipes-multimedia/``
----------------------------
This directory contains codecs and support utilities for audio, images
and video.
.. _structure-meta-recipes-rt:
``meta/recipes-rt/``
--------------------
This directory contains package and image recipes for using and testing
the ``PREEMPT_RT`` kernel.
.. _structure-meta-recipes-sato:
``meta/recipes-sato/``
----------------------
This directory contains the Sato demo/reference UI/UX and its associated
applications and configuration data.
.. _structure-meta-recipes-support:
``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).
.. _structure-meta-site:
``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.
.. _structure-meta-recipes-txt:
``meta/recipes.txt``
--------------------
This file is a description of the contents of ``recipes-*``.
documentation/ref-manual/ref-system-requirements.rst
+378
View File
@@ -0,0 +1,378 @@
*******************
System Requirements
*******************
Welcome to the Yocto Project Reference Manual! This manual provides
reference information for the current release of the Yocto Project, and
is most effectively used after you have an understanding of the basics
of the Yocto Project. The manual is neither meant to be read as a
starting point to the Yocto Project, nor read from start to finish.
Rather, use this manual to find variable definitions, class
descriptions, and so forth as needed during the course of using the
Yocto Project.
For introductory information on the Yocto Project, see the `Yocto
Project Website <&YOCTO_HOME_URL;>`__ and the "`Yocto Project
Development
Environment <&YOCTO_DOCS_OM_URL;#overview-development-environment>`__"
chapter in the Yocto Project Overview and Concepts Manual.
If you want to use the Yocto Project to quickly build an image without
having to understand concepts, work through the `Yocto Project Quick
Build <&YOCTO_DOCS_BRIEF_URL;>`__ document. You can find "how-to"
information in the `Yocto Project Development Tasks
Manual <&YOCTO_DOCS_DEV_URL;>`__. You can find Yocto Project overview
and conceptual information in the `Yocto Project Overview and Concepts
Manual <&YOCTO_DOCS_OM_URL;>`__.
.. note::
For more information about the Yocto Project Documentation set, see
the "
Links and Related Documentation
" section.
.. _detailed-supported-distros:
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.
- You may use Windows Subsystem For Linux v2 to set up a build host
using Windows 10, but validation is not performed against build
hosts using WSLv2.
.. note::
The Yocto Project is not compatible with WSLv1, it is
compatible but not officially supported nor validated with
WSLv2, if you still decide to use WSL please upgrade to WSLv2.
- If you encounter problems, please go to `Yocto Project
Bugzilla <&YOCTO_BUGZILLA_URL;>`__ and submit a bug. We are
interested in hearing about your experience. For information on
how to submit a bug, see the Yocto Project `Bugzilla wiki
page <&YOCTO_WIKI_URL;/wiki/Bugzilla_Configuration_and_Bug_Tracking>`__
and the "`Submitting a Defect Against the Yocto
Project <&YOCTO_DOCS_DEV_URL;#submitting-a-defect-against-the-yocto-project>`__"
section in the Yocto Project Development Tasks Manual.
- Ubuntu 16.04 (LTS)
- Ubuntu 18.04 (LTS)
- Ubuntu 20.04
- Fedora 30
- Fedora 31
- Fedora 32
- CentOS 7.x
- CentOS 8.x
- Debian GNU/Linux 8.x (Jessie)
- Debian GNU/Linux 9.x (Stretch)
- Debian GNU/Linux 10.x (Buster)
- OpenSUSE Leap 15.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.
Required Packages for the Build Host
====================================
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 describes required packages according to Linux distribution and
function.
.. _ubuntu-packages:
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
- For Debian-8, ``python3-git`` and ``pylint3`` are no longer
available via ``apt-get``. $ sudo pip3 install GitPython
pylint==1.9.5
- *Essentials:* Packages needed to build an image on a headless system:
$ sudo apt-get install UBUNTU_HOST_PACKAGES_ESSENTIAL
- *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
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 FEDORA_HOST_PACKAGES_ESSENTIAL
- *Documentation:* Packages needed if you are going to build out the
Yocto Project documentation manuals: $ sudo dnf install
docbook-style-dsssl docbook-style-xsl \\ docbook-dtds docbook-utils
fop libxslt dblatex xmlto
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 OPENSUSE_HOST_PACKAGES_ESSENTIAL
- *Documentation:* Packages needed if you are going to build out the
Yocto Project documentation manuals: $ sudo zypper install dblatex
xmlto
CentOS-7 Packages
-----------------
The following list shows the required packages by function given a
supported CentOS-7 Linux distribution:
- *Essentials:* Packages needed to build an image for a headless
system: $ sudo yum install CENTOS7_HOST_PACKAGES_ESSENTIAL
.. note::
- Extra Packages for Enterprise Linux (i.e. ``epel-release``) is
a collection of packages from Fedora built on RHEL/CentOS for
easy installation of packages not included in enterprise Linux
by default. You need to install these packages separately.
- The ``makecache`` command consumes additional Metadata from
``epel-release``.
- *Documentation:* Packages needed if you are going to build out the
Yocto Project documentation manuals: $ sudo yum install
docbook-style-dsssl docbook-style-xsl \\ docbook-dtds docbook-utils
fop libxslt dblatex xmlto
CentOS-8 Packages
-----------------
The following list shows the required packages by function given a
supported CentOS-8 Linux distribution:
- *Essentials:* Packages needed to build an image for a headless
system: $ sudo dnf install CENTOS8_HOST_PACKAGES_ESSENTIAL
.. note::
- Extra Packages for Enterprise Linux (i.e. ``epel-release``) is
a collection of packages from Fedora built on RHEL/CentOS for
easy installation of packages not included in enterprise Linux
by default. You need to install these packages separately.
- The ``PowerTools`` repo provides additional packages such as
``rpcgen`` and ``texinfo``.
- The ``makecache`` command consumes additional Metadata from
``epel-release``.
- *Documentation:* Packages needed if you are going to build out the
Yocto Project documentation manuals: $ sudo dnf install
docbook-style-dsssl docbook-style-xsl \\ docbook-dtds docbook-utils
fop libxslt dblatex xmlto
Required Git, tar, Python and gcc 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.28 or greater
- Python 3.5.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.
In addition, your host development system must meet the following
version requirement for gcc:
- gcc 5.0 or greater
If your host development system does not meet this requirement, you can
resolve this by installing a ``buildtools-extended`` tarball that
contains additional tools, the equivalent of ``buildtools-essential``.
Installing a Pre-Built ``buildtools`` Tarball with ``install-buildtools`` script
--------------------------------------------------------------------------------
The ``install-buildtools`` script is the easiest of the three methods by
which you can get these tools. It downloads a pre-built buildtools
installer and automatically installs the tools for you:
1. Execute the ``install-buildtools`` script. Here is an example: $ cd
poky $ scripts/install-buildtools --without-extended-buildtools \\
--base-url YOCTO_DL_URL/releases/yocto \\ --release yocto-DISTRO \\
--installer-version DISTRO
During execution, the buildtools tarball will be downloaded, the
checksum of the download will be verified, the installer will be run
for you, and some basic checks will be run to to make sure the
installation is functional.
To avoid the need of ``sudo`` privileges, the ``install-buildtools``
script will by default tell the installer to install in:
/path/to/poky/buildtools
If your host development system needs the additional tools provided
in the ``buildtools-extended`` tarball, you can instead execute the
``install-buildtools`` script with the default parameters: $ cd poky
$ scripts/install-buildtools
2. Source the tools environment setup script by using a command like the
following: $ source
/path/to/poky/buildtools/environment-setup-x86_64-pokysdk-linux Of
course, you need to supply your installation directory and be sure to
use the right file (i.e. i586 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``. And in the case of the
``buildtools-extended`` tarball, additional working versions of tools
including ``gcc``, ``make`` and the other tools included in
``packagegroup-core-buildessential``.
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
` <&YOCTO_RELEASE_DL_URL;/buildtools/>`__.
2. Execute the installation script. Here is an example for the
traditional installer: $ sh
~/Downloads/x86_64-buildtools-nativesdk-standalone-DISTRO.sh Here is
an example for the extended installer: $ sh
~/Downloads/x86_64-buildtools-extended-nativesdk-standalone-DISTRO.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``. And in the case of the
``buildtools-extended`` tarball, additional working versions of tools
including ``gcc``, ``make`` and the other tools included in
``packagegroup-core-buildessential``.
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 (or gcc) 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
(````` <#structure-core-script>`__).
2. Run the BitBake command to build the tarball: $ bitbake
buildtools-tarball or run the BitBake command to build the extended
tarball: $ bitbake buildtools-extended-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 <#build-directory>`__. The installer file has the string
"buildtools" (or "buildtools-extended") in the name.
3. Transfer the ``.sh`` file from the build host to the machine that
does not meet the Git, tar, or Python (or gcc) requirements.
4. On the machine that does not meet the requirements, run the ``.sh``
file to install the tools. Here is an example for the traditional
installer: $ sh
~/Downloads/x86_64-buildtools-nativesdk-standalone-DISTRO.sh Here is
an example for the extended installer: $ sh
~/Downloads/x86_64-buildtools-extended-nativesdk-standalone-DISTRO.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-x86_64-poky-linux Of
course, you need to supply your installation directory and be sure to
use the right file (i.e. i586 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``. And in the case of the
``buildtools-extended`` tarball, additional working versions of tools
including ``gcc``, ``make`` and the other tools included in
``packagegroup-core-buildessential``.
documentation/ref-manual/ref-tasks.rst
+834
View File
@@ -0,0 +1,834 @@
*****
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.
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 <&YOCTO_DOCS_BB_URL;#tasks>`__" and
"`Dependencies <&YOCTO_DOCS_BB_URL;#dependencies>`__" sections in the
BitBake User Manual.
.. _ref-tasks-build:
``do_build``
------------
The default task for all recipes. This task depends on all other normal
tasks required to build a recipe.
.. _ref-tasks-compile:
``do_compile``
--------------
Compiles the source code. This task runs with the current working
directory set to ``${``\ ```B`` <#var-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.
.. _ref-tasks-compile_ptest_base:
``do_compile_ptest_base``
-------------------------
Compiles the runtime test suite included in the software being built.
.. _ref-tasks-configure:
``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`` <#var-B>`__\ ``}``.
The default behavior of this task is to run ``oe_runmake clean`` if a
makefile (``Makefile``, ``makefile``, or ``GNUmakefile``) is found and
```CLEANBROKEN`` <#var-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.
.. _ref-tasks-configure_ptest_base:
``do_configure_ptest_base``
---------------------------
Configures the runtime test suite included in the software being built.
.. _ref-tasks-deploy:
``do_deploy``
-------------
Writes output files that are to be deployed to
``${``\ ```DEPLOY_DIR_IMAGE`` <#var-DEPLOY_DIR_IMAGE>`__\ ``}``. The
task runs with the current working directory set to
``${``\ ```B`` <#var-B>`__\ ``}``.
Recipes implementing this task should inherit the
```deploy`` <#ref-classes-deploy>`__ class and should write the output
to ``${``\ ```DEPLOYDIR`` <#var-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}``.
.. note::
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`` <#ref-tasks-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").
.. _ref-tasks-fetch:
``do_fetch``
------------
Fetches the source code. This task uses the
```SRC_URI`` <#var-SRC_URI>`__ variable and the argument's prefix to
determine the correct `fetcher <&YOCTO_DOCS_BB_URL;#bb-fetchers>`__
module.
.. _ref-tasks-image:
``do_image``
------------
Starts the image generation process. The ``do_image`` task runs after
the OpenEmbedded build system has run the
```do_rootfs`` <#ref-tasks-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`` <#var-IMAGE_PREPROCESS_COMMAND>`__ and
dynamically generates supporting ``do_image_*`` tasks as needed.
For more information on image creation, see the "`Image
Generation <&YOCTO_DOCS_OM_URL;#image-generation-dev-environment>`__"
section in the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-image-complete:
``do_image_complete``
---------------------
Completes the image generation process. The ``do_image_complete`` task
runs after the OpenEmbedded build system has run the
```do_image`` <#ref-tasks-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`` <#var-IMAGE_POSTPROCESS_COMMAND>`__.
For more information on image creation, see the "`Image
Generation <&YOCTO_DOCS_OM_URL;#image-generation-dev-environment>`__"
section in the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-install:
``do_install``
--------------
Copies files that are to be packaged into the holding area
``${``\ ```D`` <#var-D>`__\ ``}``. This task runs with the current
working directory set to ``${``\ ```B`` <#var-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`` <#ref-tasks-package>`__,
```do_package_write_*`` <#ref-tasks-package_write_deb>`__, and
```do_rootfs`` <#ref-tasks-rootfs>`__), run under
`fakeroot <&YOCTO_DOCS_OM_URL;#fakeroot-and-pseudo>`__.
.. note::
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`` <#insane-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 <#source-directory>`__ for an example.
.. _ref-tasks-install_ptest_base:
``do_install_ptest_base``
-------------------------
Copies the runtime test suite files from the compilation directory to a
holding area.
.. _ref-tasks-package:
``do_package``
--------------
Analyzes the content of the holding area
``${``\ ```D`` <#var-D>`__\ ``}`` and splits the content into subsets
based on available packages and files. This task makes use of the
```PACKAGES`` <#var-PACKAGES>`__ and ```FILES`` <#var-FILES>`__
variables.
The ``do_package`` task, in conjunction with the
```do_packagedata`` <#ref-tasks-packagedata>`__ task, also saves some
important package metadata. For additional information, see the
```PKGDESTWORK`` <#var-PKGDESTWORK>`__ variable and the "`Automatically
Added Runtime
Dependencies <&YOCTO_DOCS_OM_URL;#automatically-added-runtime-dependencies>`__"
section in the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-package_qa:
``do_package_qa``
-----------------
Runs QA checks on packaged files. For more information on these checks,
see the ```insane`` <#ref-classes-insane>`__ class.
.. _ref-tasks-package_write_deb:
``do_package_write_deb``
------------------------
Creates Debian packages (i.e. ``*.deb`` files) and places them in the
``${``\ ```DEPLOY_DIR_DEB`` <#var-DEPLOY_DIR_DEB>`__\ ``}`` directory in
the package feeds area. For more information, see the "`Package
Feeds <&YOCTO_DOCS_OM_URL;#package-feeds-dev-environment>`__" section in
the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-package_write_ipk:
``do_package_write_ipk``
------------------------
Creates IPK packages (i.e. ``*.ipk`` files) and places them in the
``${``\ ```DEPLOY_DIR_IPK`` <#var-DEPLOY_DIR_IPK>`__\ ``}`` directory in
the package feeds area. For more information, see the "`Package
Feeds <&YOCTO_DOCS_OM_URL;#package-feeds-dev-environment>`__" section in
the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-package_write_rpm:
``do_package_write_rpm``
------------------------
Creates RPM packages (i.e. ``*.rpm`` files) and places them in the
``${``\ ```DEPLOY_DIR_RPM`` <#var-DEPLOY_DIR_RPM>`__\ ``}`` directory in
the package feeds area. For more information, see the "`Package
Feeds <&YOCTO_DOCS_OM_URL;#package-feeds-dev-environment>`__" section in
the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-package_write_tar:
``do_package_write_tar``
------------------------
Creates tarballs and places them in the
``${``\ ```DEPLOY_DIR_TAR`` <#var-DEPLOY_DIR_TAR>`__\ ``}`` directory in
the package feeds area. For more information, see the "`Package
Feeds <&YOCTO_DOCS_OM_URL;#package-feeds-dev-environment>`__" section in
the Yocto Project Overview and Concepts Manual.
.. _ref-tasks-packagedata:
``do_packagedata``
------------------
Saves package metadata generated by the
```do_package`` <#ref-tasks-package>`__ task in
```PKGDATA_DIR`` <#var-PKGDATA_DIR>`__ to make it available globally.
.. _ref-tasks-patch:
``do_patch``
------------
Locates patch files and applies them to the source code.
After fetching and unpacking source files, the build system uses the
recipe's ```SRC_URI`` <&YOCTO_DOCS_REF_URL;#var-SRC_URI>`__ statements
to locate and apply patch files to the source code.
.. note::
The build system uses the
FILESPATH
variable to determine the default set of directories when searching
for patches.
Patch files, by default, are ``*.patch`` and ``*.diff`` files created
and kept in a subdirectory of the directory holding the recipe file. For
example, consider the
```bluez5`` <&YOCTO_GIT_URL;/cgit/cgit.cgi/poky/tree/meta/recipes-connectivity/bluez5>`__
recipe from the OE-Core layer (i.e. ``poky/meta``):
poky/meta/recipes-connectivity/bluez5 This recipe has two patch files
located here: poky/meta/recipes-connectivity/bluez5/bluez5
In the ``bluez5`` recipe, the ``SRC_URI`` statements point to the source
and patch files needed to build the package.
.. note::
In the case for the
bluez5_5.48.bb
recipe, the
SRC_URI
statements are from an include file
bluez5.inc
.
As mentioned earlier, the build system treats files whose file types are
``.patch`` and ``.diff`` as patch files. However, you can use the
"apply=yes" parameter with the ``SRC_URI`` statement to indicate any
file as a patch file: SRC_URI = " \\ git://path_to_repo/some_package \\
file://file;apply=yes \\ "
Conversely, if you have a directory full of patch files and you want to
exclude some so that the ``do_patch`` task does not apply them during
the patch phase, you can use the "apply=no" parameter with the
``SRC_URI`` statement: SRC_URI = " \\ git://path_to_repo/some_package \\
file://path_to_lots_of_patch_files \\
file://path_to_lots_of_patch_files/patch_file5;apply=no \\ " In the
previous example, assuming all the files in the directory holding the
patch files end with either ``.patch`` or ``.diff``, every file would be
applied as a patch by default except for the patch_file5 patch.
You can find out more about the patching process in the
"`Patching <&YOCTO_DOCS_OM_URL;#patching-dev-environment>`__" section in
the Yocto Project Overview and Concepts Manual and the "`Patching
Code <&YOCTO_DOCS_DEV_URL;#new-recipe-patching-code>`__" section in the
Yocto Project Development Tasks Manual.
.. _ref-tasks-populate_lic:
``do_populate_lic``
-------------------
Writes license information for the recipe that is collected later when
the image is constructed.
.. _ref-tasks-populate_sdk:
``do_populate_sdk``
-------------------
Creates the file and directory structure for an installable SDK. See the
"`SDK
Generation <&YOCTO_DOCS_OM_URL;#sdk-generation-dev-environment>`__"
section in the Yocto Project Overview and Concepts Manual for more
information.
.. _ref-tasks-populate_sysroot:
``do_populate_sysroot``
-----------------------
Stages (copies) a subset of the files installed by the
```do_install`` <#ref-tasks-install>`__ task into the appropriate
sysroot. For information on how to access these files from other
recipes, see the ```STAGING_DIR*`` <#var-STAGING_DIR_HOST>`__ 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*`` <#var-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").
.. _ref-tasks-prepare_recipe_sysroot:
``do_prepare_recipe_sysroot``
-----------------------------
Installs the files into the individual recipe specific sysroots (i.e.
``recipe-sysroot`` and ``recipe-sysroot-native`` under
``${``\ ```WORKDIR`` <#var-WORKDIR>`__\ ``}`` based upon the
dependencies specified by ```DEPENDS`` <#var-DEPENDS>`__). See the
"```staging`` <#ref-classes-staging>`__" class for more information.
.. _ref-tasks-rm_work:
``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`` <#ref-classes-rm-work>`__" section.
.. _ref-tasks-unpack:
``do_unpack``
-------------
Unpacks the source code into a working directory pointed to by
``${``\ ```WORKDIR`` <#var-WORKDIR>`__\ ``}``. The ```S`` <#var-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 <&YOCTO_DOCS_OM_URL;#source-fetching-dev-environment>`__"
section in the Yocto Project Overview and Concepts Manual and also see
the ``WORKDIR`` and ``S`` variable descriptions.
Manually Called Tasks
=====================
These tasks are typically manually triggered (e.g. by using the
``bitbake -c`` command-line option):
.. _ref-tasks-checkpkg:
``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.
To check the upstream version and status of a recipe, use the following
devtool commands: $ devtool latest-version $ devtool
check-upgrade-status See the "```devtool`` Quick
Reference <#ref-devtool-reference>`__" chapter for more information on
``devtool``. See the "`Checking on the Upgrade Status of a
Recipe <&YOCTO_DOCS_REF_URL;#devtool-checking-on-the-upgrade-status-of-a-recipe>`__"
section for information on checking the upgrade status of a recipe.
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`` <#var-LOG_DIR>`__ (e.g.
``$BUILD_DIR/tmp/log``).
.. _ref-tasks-checkuri:
``do_checkuri``
---------------
Validates the ```SRC_URI`` <#var-SRC_URI>`__ value.
.. _ref-tasks-clean:
``do_clean``
------------
Removes all output files for a target from the
```do_unpack`` <#ref-tasks-unpack>`__ task forward (i.e. ``do_unpack``,
```do_configure`` <#ref-tasks-configure>`__,
```do_compile`` <#ref-tasks-compile>`__,
```do_install`` <#ref-tasks-install>`__, and
```do_package`` <#ref-tasks-package>`__).
You can run this task using BitBake as follows: $ bitbake -c clean
recipe
Running this task does not remove the
`sstate <&YOCTO_DOCS_OM_URL;#shared-state-cache>`__ 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`` <#ref-tasks-cleansstate>`__ task instead
(i.e. ``bitbake -c cleansstate`` recipe).
.. _ref-tasks-cleanall:
``do_cleanall``
---------------
Removes all output files, shared state
(`sstate <&YOCTO_DOCS_OM_URL;#shared-state-cache>`__) cache, and
downloaded source files for a target (i.e. the contents of
```DL_DIR`` <#var-DL_DIR>`__). Essentially, the ``do_cleanall`` task is
identical to the ```do_cleansstate`` <#ref-tasks-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`` <#ref-tasks-fetch>`__
task.
.. _ref-tasks-cleansstate:
``do_cleansstate``
------------------
Removes all output files and shared state
(`sstate <&YOCTO_DOCS_OM_URL;#shared-state-cache>`__) cache for a
target. Essentially, the ``do_cleansstate`` task is identical to the
```do_clean`` <#ref-tasks-clean>`__ task with the added removal of
shared state (`sstate <&YOCTO_DOCS_OM_URL;#shared-state-cache>`__)
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
.. _ref-tasks-devpyshell:
``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 <&YOCTO_DOCS_DEV_URL;#platdev-appdev-devpyshell>`__" section in
the Yocto Project Development Tasks Manual for more information about
using ``devpyshell``.
.. _ref-tasks-devshell:
``do_devshell``
---------------
Starts a shell whose environment is set up for development, debugging,
or both. See the "`Using a Development
Shell <&YOCTO_DOCS_DEV_URL;#platdev-appdev-devshell>`__" section in the
Yocto Project Development Tasks Manual for more information about using
``devshell``.
.. _ref-tasks-listtasks:
``do_listtasks``
----------------
Lists all defined tasks for a target.
.. _ref-tasks-package_index:
``do_package_index``
--------------------
Creates or updates the index in the `Package
Feeds <&YOCTO_DOCS_OM_URL;#package-feeds-dev-environment>`__ 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
.
Image-Related Tasks
===================
The following tasks are applicable to image recipes.
.. _ref-tasks-bootimg:
``do_bootimg``
--------------
Creates a bootable live image. See the
```IMAGE_FSTYPES`` <#var-IMAGE_FSTYPES>`__ variable for additional
information on live image types.
.. _ref-tasks-bundle_initramfs:
``do_bundle_initramfs``
-----------------------
Combines an initial RAM disk (initramfs) image and kernel together to
form a single image. The
```CONFIG_INITRAMFS_SOURCE`` <#var-CONFIG_INITRAMFS_SOURCE>`__ variable
has some more information about these types of images.
.. _ref-tasks-rootfs:
``do_rootfs``
-------------
Creates the root filesystem (file and directory structure) for an image.
See the "`Image
Generation <&YOCTO_DOCS_OM_URL;#image-generation-dev-environment>`__"
section in the Yocto Project Overview and Concepts Manual for more
information on how the root filesystem is created.
.. _ref-tasks-testimage:
``do_testimage``
----------------
Boots an image and performs runtime tests within the image. For
information on automatically testing images, see the "`Performing
Automated Runtime
Testing <&YOCTO_DOCS_DEV_URL;#performing-automated-runtime-testing>`__"
section in the Yocto Project Development Tasks Manual.
.. _ref-tasks-testimage_auto:
``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
```TESTIMAGE_AUTO`` <#var-TESTIMAGE_AUTO>`__ equal to "1".
For information on automatically testing images, see the "`Performing
Automated Runtime
Testing <&YOCTO_DOCS_DEV_URL;#performing-automated-runtime-testing>`__"
section in the Yocto Project Development Tasks Manual.
Kernel-Related Tasks
====================
The following tasks are applicable to kernel recipes. Some of these
tasks (e.g. the ```do_menuconfig`` <#ref-tasks-menuconfig>`__ task) are
also applicable to recipes that use Linux kernel style configuration
such as the BusyBox recipe.
.. _ref-tasks-compile_kernelmodules:
``do_compile_kernelmodules``
----------------------------
Runs the step that builds the kernel modules (if needed). Building a
kernel consists of two steps: 1) the kernel (``vmlinux``) is built, and
2) the modules are built (i.e. ``make modules``).
.. _ref-tasks-diffconfig:
``do_diffconfig``
-----------------
When invoked by the user, this task creates a file containing the
differences between the original config as produced by
```do_kernel_configme`` <#ref-tasks-kernel_configme>`__ task and the
changes made by the user with other methods (i.e. using
(```do_kernel_menuconfig`` <#ref-tasks-kernel_menuconfig>`__). Once the
file of differences is created, it can be used to create a config
fragment that only contains the differences. You can invoke this task
from the command line as follows: $ bitbake linux-yocto -c diffconfig
For more information, see the "`Creating Configuration
Fragments <&YOCTO_DOCS_KERNEL_DEV_URL;#creating-config-fragments>`__"
section in the Yocto Project Linux Kernel Development Manual.
.. _ref-tasks-kernel_checkout:
``do_kernel_checkout``
----------------------
Converts the newly unpacked kernel source into a form with which the
OpenEmbedded build system can work. Because the kernel source can be
fetched in several different ways, the ``do_kernel_checkout`` task makes
sure that subsequent tasks are given a clean working tree copy of the
kernel with the correct branches checked out.
.. _ref-tasks-kernel_configcheck:
``do_kernel_configcheck``
-------------------------
Validates the configuration produced by the
```do_kernel_menuconfig`` <#ref-tasks-kernel_menuconfig>`__ task. The
``do_kernel_configcheck`` task produces warnings when a requested
configuration does not appear in the final ``.config`` file or when you
override a policy configuration in a hardware configuration fragment.
You can run this task explicitly and view the output by using the
following command: $ bitbake linux-yocto -c kernel_configcheck -f For
more information, see the "`Validating
Configuration <&YOCTO_DOCS_KERNEL_DEV_URL;#validating-configuration>`__"
section in the Yocto Project Linux Kernel Development Manual.
.. _ref-tasks-kernel_configme:
``do_kernel_configme``
----------------------
After the kernel is patched by the ```do_patch`` <#ref-tasks-patch>`__
task, the ``do_kernel_configme`` task assembles and merges all the
kernel config fragments into a merged configuration that can then be
passed to the kernel configuration phase proper. This is also the time
during which user-specified defconfigs are applied if present, and where
configuration modes such as ``--allnoconfig`` are applied.
.. _ref-tasks-kernel_menuconfig:
``do_kernel_menuconfig``
------------------------
Invoked by the user to manipulate the ``.config`` file used to build a
linux-yocto recipe. This task starts the Linux kernel configuration
tool, which you then use to modify the kernel configuration.
.. note::
You can also invoke this tool from the command line as follows:
::
$ bitbake linux-yocto -c menuconfig
See the "`Using
``menuconfig`` <&YOCTO_DOCS_KERNEL_DEV_URL;#using-menuconfig>`__"
section in the Yocto Project Linux Kernel Development Manual for more
information on this configuration tool.
.. _ref-tasks-kernel_metadata:
``do_kernel_metadata``
----------------------
Collects all the features required for a given kernel build, whether the
features come from ```SRC_URI`` <#var-SRC_URI>`__ or from Git
repositories. After collection, the ``do_kernel_metadata`` task
processes the features into a series of config fragments and patches,
which can then be applied by subsequent tasks such as
```do_patch`` <#ref-tasks-patch>`__ and
```do_kernel_configme`` <#ref-tasks-kernel_configme>`__.
.. _ref-tasks-menuconfig:
``do_menuconfig``
-----------------
Runs ``make menuconfig`` for the kernel. For information on
``menuconfig``, see the
"`Using  ``menuconfig`` <&YOCTO_DOCS_KERNEL_DEV_URL;#using-menuconfig>`__"
section in the Yocto Project Linux Kernel Development Manual.
.. _ref-tasks-savedefconfig:
``do_savedefconfig``
--------------------
When invoked by the user, creates a defconfig file that can be used
instead of the default defconfig. The saved defconfig contains the
differences between the default defconfig and the changes made by the
user using other methods (i.e. the
```do_kernel_menuconfig`` <#ref-tasks-kernel_menuconfig>`__ task. You
can invoke the task using the following command: $ bitbake linux-yocto
-c savedefconfig
.. _ref-tasks-shared_workdir:
``do_shared_workdir``
---------------------
After the kernel has been compiled but before the kernel modules have
been compiled, this task copies files required for module builds and
which are generated from the kernel build into the shared work
directory. With these copies successfully copied, the
```do_compile_kernelmodules`` <#ref-tasks-compile_kernelmodules>`__ task
can successfully build the kernel modules in the next step of the build.
.. _ref-tasks-sizecheck:
``do_sizecheck``
----------------
After the kernel has been built, this task checks the size of the
stripped kernel image against
```KERNEL_IMAGE_MAXSIZE`` <#var-KERNEL_IMAGE_MAXSIZE>`__. If that
variable was set and the size of the stripped kernel exceeds that size,
the kernel build produces a warning to that effect.
.. _ref-tasks-strip:
``do_strip``
------------
If ``KERNEL_IMAGE_STRIP_EXTRA_SECTIONS`` is defined, this task strips
the sections named in that variable from ``vmlinux``. This stripping is
typically used to remove nonessential sections such as ``.comment``
sections from a size-sensitive configuration.
.. _ref-tasks-validate_branches:
``do_validate_branches``
------------------------
After the kernel is unpacked but before it is patched, this task makes
sure that the machine and metadata branches as specified by the
```SRCREV`` <#var-SRCREV>`__ variables actually exist on the specified
branches. If these branches do not exist and
```AUTOREV`` <#var-AUTOREV>`__ is not being used, the
``do_validate_branches`` task fails during the build.
Miscellaneous Tasks
===================
The following sections describe miscellaneous tasks.
.. _ref-tasks-spdx:
``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`` <#ref-classes-spdx>`__ class.
documentation/ref-manual/ref-terms.rst
+369
View File
@@ -0,0 +1,369 @@
*******************
Yocto Project Terms
*******************
Following is a list of terms and definitions users new to the Yocto
Project development environment might find helpful. While some of these
terms are universal, the list includes them just in case:
- *Append Files:* Files that append build information to a recipe file.
Append files are known as BitBake append files and ``.bbappend``
files. The OpenEmbedded build system expects every append file to
have a corresponding recipe (``.bb``) file. Furthermore, the append
file and corresponding recipe file must use the same root filename.
The filenames can differ only in the file type suffix used (e.g.
``formfactor_0.0.bb`` and ``formfactor_0.0.bbappend``).
Information in append files extends or overrides the information in
the similarly-named recipe file. For an example of an append file in
use, see the "`Using .bbappend Files in Your
Layer <&YOCTO_DOCS_DEV_URL;#using-bbappend-files>`__" section in the
Yocto Project Development Tasks Manual.
When you name an append file, you can use the "``%``" wildcard
character to allow for matching recipe names. For example, suppose
you have an append file named as follows: busybox_1.21.%.bbappend
That append file would match any ``busybox_1.21.``\ x\ ``.bb``
version of the recipe. So, the append file would match any of the
following recipe names: busybox_1.21.1.bb busybox_1.21.2.bb
busybox_1.21.3.bb busybox_1.21.10.bb busybox_1.21.25.bb
.. note::
The use of the "
%
" character is limited in that it only works directly in front of
the
.bbappend
portion of the append file's name. You cannot use the wildcard
character in any other location of the name.
- *BitBake:* The task executor and scheduler used by the OpenEmbedded
build system to build images. For more information on BitBake, see
the `BitBake User Manual <&YOCTO_DOCS_BB_URL;>`__.
- *Board Support Package (BSP):* A group of drivers, definitions, and
other components that provide support for a specific hardware
configuration. For more information on BSPs, see the `Yocto Project
Board Support Package (BSP) Developer's
Guide <&YOCTO_DOCS_BSP_URL;>`__.
- *Build Directory:* This term refers to the area used by the
OpenEmbedded build system for builds. The area is created when you
``source`` the setup environment script that is found in the Source
Directory (i.e. ````` <#structure-core-script>`__). The
```TOPDIR`` <#var-TOPDIR>`__ variable points to the Build Directory.
You have a lot of flexibility when creating the Build Directory.
Following are some examples that show how to create the directory.
The examples assume your `Source Directory <#source-directory>`__ is
named ``poky``:
- Create the Build Directory inside your Source Directory and let
the name of the Build Directory default to ``build``: $ cd
$HOME/poky $ source OE_INIT_FILE
- Create the Build Directory inside your home directory and
specifically name it ``test-builds``: $ cd $HOME $ source
poky/OE_INIT_FILE test-builds
- Provide a directory path and specifically name the Build
Directory. Any intermediate folders in the pathname must exist.
This next example creates a Build Directory named
``YP-POKYVERSION`` in your home directory within the existing
directory ``mybuilds``: $ cd $HOME $ source
$HOME/poky/OE_INIT_FILE $HOME/mybuilds/YP-POKYVERSION
.. note::
By default, the Build Directory contains
TMPDIR
, which is a temporary directory the build system uses for its
work.
TMPDIR
cannot be under NFS. Thus, by default, the Build Directory cannot
be under NFS. However, if you need the Build Directory to be under
NFS, you can set this up by setting
TMPDIR
in your
local.conf
file to use a local drive. Doing so effectively separates
TMPDIR
from
TOPDIR
, which is the Build Directory.
- *Build Host:* The system used to build images in a Yocto Project
Development environment. The build system is sometimes referred to as
the development host.
- *Classes:* Files that provide for logic encapsulation and inheritance
so that commonly used patterns can be defined once and then easily
used in multiple recipes. For reference information on the Yocto
Project classes, see the "`Classes <#ref-classes>`__" chapter. Class
files end with the ``.bbclass`` filename extension.
- *Configuration File:* Files that hold global definitions of
variables, user-defined variables, and hardware configuration
information. These files tell the OpenEmbedded build system what to
build and what to put into the image to support a particular
platform.
Configuration files end with a ``.conf`` filename extension. The
``conf/local.conf`` configuration file in the `Build
Directory <#build-directory>`__ contains user-defined variables that
affect every build. The ``meta-poky/conf/distro/poky.conf``
configuration file defines Yocto "distro" configuration variables
used only when building with this policy. Machine configuration
files, which are located throughout the `Source
Directory <#source-directory>`__, define variables for specific
hardware and are only used when building for that target (e.g. the
``machine/beaglebone.conf`` configuration file defines variables for
the Texas Instruments ARM Cortex-A8 development board).
- *Container Layer:* Layers that hold other layers. An example of a
container layer is OpenEmbedded's
```meta-openembedded`` <https://github.com/openembedded/meta-openembedded>`__
layer. The ``meta-openembedded`` layer contains many ``meta-*``
layers.
- *Cross-Development Toolchain:* In general, a cross-development
toolchain is a collection of software development tools and utilities
that run on one architecture and allow you to develop software for a
different, or targeted, architecture. These toolchains contain
cross-compilers, linkers, and debuggers that are specific to the
target architecture.
The Yocto Project supports two different cross-development
toolchains:
- A toolchain only used by and within BitBake when building an image
for a target architecture.
- A relocatable toolchain used outside of BitBake by developers when
developing applications that will run on a targeted device.
Creation of these toolchains is simple and automated. For information
on toolchain concepts as they apply to the Yocto Project, see the
"`Cross-Development Toolchain
Generation <&YOCTO_DOCS_OM_URL;#cross-development-toolchain-generation>`__"
section in the Yocto Project Overview and Concepts Manual. You can
also find more information on using the relocatable toolchain in the
`Yocto Project Application Development and the Extensible Software
Development Kit (eSDK) <&YOCTO_DOCS_SDK_URL;>`__ manual.
- *Extensible Software Development Kit (eSDK):* A custom SDK for
application developers. This eSDK allows developers to incorporate
their library and programming changes back into the image to make
their code available to other application developers.
For information on the eSDK, see the `Yocto Project Application
Development and the Extensible Software Development Kit
(eSDK) <&YOCTO_DOCS_SDK_URL;>`__ manual.
- *Image:* An image is an artifact of the BitBake build process given a
collection of recipes and related Metadata. Images are the binary
output that run on specific hardware or QEMU and are used for
specific use-cases. For a list of the supported image types that the
Yocto Project provides, see the "`Images <#ref-images>`__" chapter.
- *Layer:* A collection of related recipes. Layers allow you to
consolidate related metadata to customize your build. Layers also
isolate information used when building for multiple architectures.
Layers are hierarchical in their ability to override previous
specifications. You can include any number of available layers from
the Yocto Project and customize the build by adding your layers after
them. You can search the Layer Index for layers used within Yocto
Project.
For introductory information on layers, see the "`The Yocto Project
Layer Model <&YOCTO_DOCS_OM_URL;#the-yocto-project-layer-model>`__"
section in the Yocto Project Overview and Concepts Manual. For more
detailed information on layers, see the "`Understanding and Creating
Layers <&YOCTO_DOCS_DEV_URL;#understanding-and-creating-layers>`__"
section in the Yocto Project Development Tasks Manual. For a
discussion specifically on BSP Layers, see the "`BSP
Layers <&YOCTO_DOCS_BSP_URL;#bsp-layers>`__" section in the Yocto
Project Board Support Packages (BSP) Developer's Guide.
- *Metadata:* A key element of the Yocto Project is the Metadata that
is used to construct a Linux distribution and is contained in the
files that the `OpenEmbedded build system <#build-system-term>`__
parses when building an image. In general, Metadata includes recipes,
configuration files, and other information that refers to the build
instructions themselves, as well as the data used to control what
things get built and the effects of the build. Metadata also includes
commands and data used to indicate what versions of software are
used, from where they are obtained, and changes or additions to the
software itself (patches or auxiliary files) that are used to fix
bugs or customize the software for use in a particular situation.
OpenEmbedded-Core is an important set of validated metadata.
In the context of the kernel ("kernel Metadata"), the term refers to
the kernel config fragments and features contained in the
```yocto-kernel-cache`` <&YOCTO_GIT_URL;/cgit/cgit.cgi/yocto-kernel-cache>`__
Git repository.
- *OpenEmbedded-Core (OE-Core):* OE-Core is metadata comprised of
foundational recipes, classes, and associated files that are meant to
be common among many different OpenEmbedded-derived systems,
including the Yocto Project. OE-Core is a curated subset of an
original repository developed by the OpenEmbedded community that has
been pared down into a smaller, core set of continuously validated
recipes. The result is a tightly controlled and an quality-assured
core set of recipes.
You can see the Metadata in the ``meta`` directory of the Yocto
Project `Source
Repositories <http://git.yoctoproject.org/cgit/cgit.cgi>`__.
- *OpenEmbedded Build System:* The build system specific to the Yocto
Project. The OpenEmbedded build system is based on another project
known as "Poky", which uses `BitBake <#bitbake-term>`__ as the task
executor. Throughout the Yocto Project documentation set, the
OpenEmbedded build system is sometimes referred to simply as "the
build system". If other build systems, such as a host or target build
system are referenced, the documentation clearly states the
difference.
.. note::
For some historical information about Poky, see the
Poky
term.
- *Package:* In the context of the Yocto Project, this term refers to a
recipe's packaged output produced by BitBake (i.e. a "baked recipe").
A package is generally the compiled binaries produced from the
recipe's sources. You "bake" something by running it through BitBake.
It is worth noting that the term "package" can, in general, have
subtle meanings. For example, the packages referred to in the
"`Required Packages for the Build
Host <#required-packages-for-the-build-host>`__" section are compiled
binaries that, when installed, add functionality to your Linux
distribution.
Another point worth noting is that historically within the Yocto
Project, recipes were referred to as packages - thus, the existence
of several BitBake variables that are seemingly mis-named, (e.g.
```PR`` <#var-PR>`__, ```PV`` <#var-PV>`__, and
```PE`` <#var-PE>`__).
- *Package Groups:* Arbitrary groups of software Recipes. You use
package groups to hold recipes that, when built, usually accomplish a
single task. For example, a package group could contain the recipes
for a company’s proprietary or value-add software. Or, the package
group could contain the recipes that enable graphics. A package group
is really just another recipe. Because package group files are
recipes, they end with the ``.bb`` filename extension.
- *Poky:* Poky, which is pronounced *Pock*-ee, is a reference embedded
distribution and a reference test configuration. Poky provides the
following:
- A base-level functional distro used to illustrate how to customize
a distribution.
- A means by which to test the Yocto Project components (i.e. Poky
is used to validate the Yocto Project).
- A vehicle through which you can download the Yocto Project.
Poky is not a product level distro. Rather, it is a good starting
point for customization.
.. note::
Poky began as an open-source project initially developed by
OpenedHand. OpenedHand developed Poky from the existing
OpenEmbedded build system to create a commercially supportable
build system for embedded Linux. After Intel Corporation acquired
OpenedHand, the poky project became the basis for the Yocto
Project's build system.
- *Recipe:* A set of instructions for building packages. A recipe
describes where you get source code, which patches to apply, how to
configure the source, how to compile it and so on. Recipes also
describe dependencies for libraries or for other recipes. Recipes
represent the logical unit of execution, the software to build, the
images to build, and use the ``.bb`` file extension.
- *Reference Kit:* A working example of a system, which includes a
`BSP <#board-support-package-bsp-term>`__ as well as a `build
host <#hardware-build-system-term>`__ and other components, that can
work on specific hardware.
- *Source Directory:* This term refers to the directory structure
created as a result of creating a local copy of the ``poky`` Git
repository ``git://git.yoctoproject.org/poky`` or expanding a
released ``poky`` tarball.
.. note::
Creating a local copy of the
poky
Git repository is the recommended method for setting up your
Source Directory.
Sometimes you might hear the term "poky directory" used to refer to
this directory structure.
.. 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.
The Source Directory contains BitBake, Documentation, Metadata and
other files that all support the Yocto Project. Consequently, you
must have the Source Directory in place on your development system in
order to do any development using the Yocto Project.
When you create a local copy of the Git repository, you can name the
repository anything you like. Throughout much of the documentation,
"poky" is used as the name of the top-level folder of the local copy
of the poky Git repository. So, for example, cloning the ``poky`` Git
repository results in a local Git repository whose top-level folder
is also named "poky".
While it is not recommended that you use tarball expansion to set up
the Source Directory, if you do, the top-level directory name of the
Source Directory is derived from the Yocto Project release tarball.
For example, downloading and unpacking ```` results in a Source
Directory whose root folder is named ````.
It is important to understand the differences between the Source
Directory created by unpacking a released tarball as compared to
cloning ``git://git.yoctoproject.org/poky``. When you unpack a
tarball, you have an exact copy of the files based on the time of
release - a fixed release point. Any changes you make to your local
files in the Source Directory are on top of the release and will
remain local only. On the other hand, when you clone the ``poky`` Git
repository, you have an active development repository with access to
the upstream repository's branches and tags. In this case, any local
changes you make to the local Source Directory can be later applied
to active development branches of the upstream ``poky`` Git
repository.
For more information on concepts related to Git repositories,
branches, and tags, see the "`Repositories, Tags, and
Branches <&YOCTO_DOCS_OM_URL;#repositories-tags-and-branches>`__"
section in the Yocto Project Overview and Concepts Manual.
- *Task:* A unit of execution for BitBake (e.g.
```do_compile`` <#ref-tasks-compile>`__,
```do_fetch`` <#ref-tasks-fetch>`__,
```do_patch`` <#ref-tasks-patch>`__, and so forth).
- *Toaster:* A web interface to the Yocto Project's `OpenEmbedded Build
System <#build-system-term>`__. The interface enables you to
configure and run your builds. Information about builds is collected
and stored in a database. For information on Toaster, see the
`Toaster User Manual <&YOCTO_DOCS_TOAST_URL;>`__.
- *Upstream:* A reference to source code or repositories that are not
local to the development system but located in a master area that is
controlled by the maintainer of the source code. For example, in
order for a developer to work on a particular piece of code, they
need to first get a copy of it from an "upstream" source.
documentation/ref-manual/ref-variables.rst
+7924
View File
File diff suppressed because it is too large Load Diff
documentation/ref-manual/ref-varlocality.rst
+164
View File
@@ -0,0 +1,164 @@
****************
Variable Context
****************
While you can use most variables in almost any context such as
``.conf``, ``.bbclass``, ``.inc``, and ``.bb`` files, some variables are
often associated with a particular locality or context. This chapter
describes some common associations.
.. _ref-varlocality-configuration:
Configuration
=============
The following subsections provide lists of variables whose context is
configuration: distribution, machine, and local.
.. _ref-varlocality-config-distro:
Distribution (Distro)
---------------------
This section lists variables whose configuration context is the
distribution, or distro.
- ``DISTRO``
- ``DISTRO_NAME``
- ``DISTRO_VERSION``
- ``MAINTAINER``
- ``PACKAGE_CLASSES``
- ``TARGET_OS``
- ``TARGET_FPU``
- ``TCMODE``
- ``TCLIBC``
.. _ref-varlocality-config-machine:
Machine
-------
This section lists variables whose configuration context is the machine.
- ``TARGET_ARCH``
- ``SERIAL_CONSOLES``
- ``PACKAGE_EXTRA_ARCHS``
- ``IMAGE_FSTYPES``
- ``MACHINE_FEATURES``
- ``MACHINE_EXTRA_RDEPENDS``
- ``MACHINE_EXTRA_RRECOMMENDS``
- ``MACHINE_ESSENTIAL_EXTRA_RDEPENDS``
- ``MACHINE_ESSENTIAL_EXTRA_RRECOMMENDS``
.. _ref-varlocality-config-local:
Local
-----
This section lists variables whose configuration context is the local
configuration through the ``local.conf`` file.
- ``DISTRO``
- ``MACHINE``
- ``DL_DIR``
- ``BBFILES``
- ``EXTRA_IMAGE_FEATURES``
- ``PACKAGE_CLASSES``
- ``BB_NUMBER_THREADS``
- ``BBINCLUDELOGS``
- ``ENABLE_BINARY_LOCALE_GENERATION``
.. _ref-varlocality-recipes:
Recipes
=======
The following subsections provide lists of variables whose context is
recipes: required, dependencies, path, and extra build information.
.. _ref-varlocality-recipe-required:
Required
--------
This section lists variables that are required for recipes.
- ``LICENSE``
- ``LIC_FILES_CHKSUM``
- ``SRC_URI`` - used in recipes that fetch local or remote files.
.. _ref-varlocality-recipe-dependencies:
Dependencies
------------
This section lists variables that define recipe dependencies.
- ``DEPENDS``
- ``RDEPENDS``
- ``RRECOMMENDS``
- ``RCONFLICTS``
- ``RREPLACES``
.. _ref-varlocality-recipe-paths:
Paths
-----
This section lists variables that define recipe paths.
- ``WORKDIR``
- ``S``
- ``FILES``
.. _ref-varlocality-recipe-build:
Extra Build Information
-----------------------
This section lists variables that define extra build information for
recipes.
- ``DEFAULT_PREFERENCE``
- ``EXTRA_OECMAKE``
- ``EXTRA_OECONF``
- ``EXTRA_OEMAKE``
- ``PACKAGECONFIG_CONFARGS``
- ``PACKAGES``
documentation/ref-manual/resources.rst
+207
View File
@@ -0,0 +1,207 @@
****************************************
Contributions and Additional Information
****************************************
.. _resources-intro:
Introduction
============
The Yocto Project team is happy for people to experiment with the Yocto
Project. A number of places exist to find help if you run into
difficulties or find bugs. This presents information about contributing
and participating in the Yocto Project.
.. _resources-contributions:
Contributions
=============
The Yocto Project gladly accepts contributions. You can submit changes
to the project either by creating and sending pull requests, or by
submitting patches through email. For information on how to do both as
well as information on how to identify the maintainer for each area of
code, see the "`Submitting a Change to the Yocto
Project <&YOCTO_DOCS_DEV_URL;#how-to-submit-a-change>`__" section in the
Yocto Project Development Tasks Manual.
.. _resources-bugtracker:
Yocto Project Bugzilla
======================
The Yocto Project uses its own implementation of
`Bugzilla <&YOCTO_BUGZILLA_URL;>`__ to track defects (bugs).
Implementations of Bugzilla work well for group development because they
track bugs and code changes, can be used to communicate changes and
problems with developers, can be used to submit and review patches, and
can be used to manage quality assurance.
Sometimes it is helpful to submit, investigate, or track a bug against
the Yocto Project itself (e.g. when discovering an issue with some
component of the build system that acts contrary to the documentation or
your expectations).
A general procedure and guidelines exist for when you use Bugzilla to
submit a bug. For information on how to use Bugzilla to submit a bug
against the Yocto Project, see the following:
- The "`Submitting a Defect Against the Yocto
Project <&YOCTO_DOCS_DEV_URL;#submitting-a-defect-against-the-yocto-project>`__"
section in the Yocto Project Development Tasks Manual.
- The Yocto Project `Bugzilla wiki
page <&YOCTO_WIKI_URL;/wiki/Bugzilla_Configuration_and_Bug_Tracking>`__
For information on Bugzilla in general, see
` <http://www.bugzilla.org/about/>`__.
.. _resources-mailinglist:
Mailing lists
=============
A number of mailing lists maintained by the Yocto Project exist as well
as related OpenEmbedded mailing lists for discussion, patch submission
and announcements. To subscribe to one of the following mailing lists,
click on the appropriate URL in the following list and follow the
instructions:
- ` <&YOCTO_LISTS_URL;/listinfo/yocto>`__ - General Yocto Project
discussion mailing list.
- ` <&OE_LISTS_URL;/listinfo/openembedded-core>`__ - Discussion mailing
list about OpenEmbedded-Core (the core metadata).
- ` <&OE_LISTS_URL;/listinfo/openembedded-devel>`__ - Discussion
mailing list about OpenEmbedded.
- ` <&OE_LISTS_URL;/listinfo/bitbake-devel>`__ - Discussion mailing
list about the `BitBake <#bitbake-term>`__ build tool.
- ` <&YOCTO_LISTS_URL;/listinfo/poky>`__ - Discussion mailing list
about `Poky <#poky>`__.
- ` <&YOCTO_LISTS_URL;/listinfo/yocto-announce>`__ - Mailing list to
receive official Yocto Project release and milestone announcements.
For more Yocto Project-related mailing lists, see the
Yocto Project Website
.
.. _resources-irc:
Internet Relay Chat (IRC)
=========================
Two IRC channels on freenode are available for the Yocto Project and
Poky discussions:
- ``#yocto``
- ``#poky``
.. _resources-links-and-related-documentation:
Links and Related Documentation
===============================
Here is a list of resources you might find helpful:
- `The Yocto Project website <&YOCTO_HOME_URL;>`__\ *:* The home site
for the Yocto Project.
- `The Yocto Project Main Wiki
Page <&YOCTO_WIKI_URL;/wiki/Main_Page>`__\ *:* The main wiki page for
the Yocto Project. This page contains information about project
planning, release engineering, QA & automation, a reference site map,
and other resources related to the Yocto Project.
- `OpenEmbedded <&OE_HOME_URL;>`__\ *:* The build system used by the
Yocto Project. This project is the upstream, generic, embedded
distribution from which the Yocto Project derives its build system
(Poky) and to which it contributes.
- `BitBake <http://www.openembedded.org/wiki/BitBake>`__\ *:* The tool
used to process metadata.
- `BitBake User Manual <&YOCTO_DOCS_BB_URL;>`__\ *:* A comprehensive
guide to the BitBake tool. If you want information on BitBake, see
this manual.
- `Yocto Project Quick Build <&YOCTO_DOCS_BRIEF_URL;>`__\ *:* This
short document lets you experience building an image using the Yocto
Project without having to understand any concepts or details.
- `Yocto Project Overview and Concepts
Manual <&YOCTO_DOCS_OM_URL;>`__\ *:* This manual provides overview
and conceptual information about the Yocto Project.
- `Yocto Project Development Tasks
Manual <&YOCTO_DOCS_DEV_URL;>`__\ *:* This manual is a "how-to" guide
that presents procedures useful to both application and system
developers who use the Yocto Project.
- `Yocto Project Application Development and the Extensible Software
Development Kit (eSDK) <&YOCTO_DOCS_SDK_URL;>`__\ *manual:* This
guide provides information that lets you get going with the standard
or extensible SDK. An SDK, with its cross-development toolchains,
allows you to develop projects inside or outside of the Yocto Project
environment.
- `Yocto Project Board Support Package (BSP) Developer's
Guide <&YOCTO_DOCS_BSP_URL;>`__\ *:* This guide defines the structure
for BSP components. Having a commonly understood structure encourages
standardization.
- `Yocto Project Linux Kernel Development
Manual <&YOCTO_DOCS_KERNEL_DEV_URL;>`__\ *:* This manual describes
how to work with Linux Yocto kernels as well as provides a bit of
conceptual information on the construction of the Yocto Linux kernel
tree.
- `Yocto Project Reference Manual <&YOCTO_DOCS_REF_URL;>`__\ *:* This
manual provides reference material such as variable, task, and class
descriptions.
- `Yocto Project Mega-Manual <&YOCTO_DOCS_MM_URL;>`__\ *:* This manual
is simply a single HTML file comprised of the bulk of the Yocto
Project manuals. The Mega-Manual primarily exists as a vehicle by
which you can easily search for phrases and terms used in the Yocto
Project documentation set.
- `Yocto Project Profiling and Tracing
Manual <&YOCTO_DOCS_PROF_URL;>`__\ *:* This manual presents a set of
common and generally useful tracing and profiling schemes along with
their applications (as appropriate) to each tool.
- `Toaster User Manual <&YOCTO_DOCS_TOAST_URL;>`__\ *:* This manual
introduces and describes how to set up and use Toaster. Toaster is an
Application Programming Interface (API) and web-based interface to
the `OpenEmbedded Build System <#build-system-term>`__, which uses
BitBake, that reports build information.
- `FAQ <&YOCTO_WIKI_URL;/wiki/FAQ>`__\ *:* A list of commonly asked
questions and their answers.
- *Release Notes:* Features, updates and known issues for the current
release of the Yocto Project. To access the Release Notes, go to the
`Downloads <&YOCTO_HOME_URL;/software-overview/downloads/>`__ page on
the Yocto Project website and click on the "RELEASE INFORMATION" link
for the appropriate release.
- `Bugzilla <&YOCTO_BUGZILLA_URL;>`__\ *:* The bug tracking application
the Yocto Project uses. If you find problems with the Yocto Project,
you should report them using this application.
- `Bugzilla Configuration and Bug Tracking Wiki
Page <&YOCTO_WIKI_URL;/wiki/Bugzilla_Configuration_and_Bug_Tracking>`__\ *:*
Information on how to get set up and use the Yocto Project
implementation of Bugzilla for logging and tracking Yocto Project
defects.
- *Internet Relay Chat (IRC):* Two IRC channels on freenode are
available for Yocto Project and Poky discussions: ``#yocto`` and
``#poky``, respectively.
- `Quick EMUlator (QEMU) <http://wiki.qemu.org/Index.html>`__\ *:* An
open-source machine emulator and virtualizer.