diff options
Diffstat (limited to 'yocto-poky/documentation/ref-manual/technical-details.xml')
| -rw-r--r-- | yocto-poky/documentation/ref-manual/technical-details.xml | 1421 |
1 files changed, 1421 insertions, 0 deletions
diff --git a/yocto-poky/documentation/ref-manual/technical-details.xml b/yocto-poky/documentation/ref-manual/technical-details.xml new file mode 100644 index 000000000..2df36521c --- /dev/null +++ b/yocto-poky/documentation/ref-manual/technical-details.xml @@ -0,0 +1,1421 @@ +<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" +"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd" +[<!ENTITY % poky SYSTEM "../poky.ent"> %poky; ] > + +<chapter id='technical-details'> +<title>Technical Details</title> + + <para> + This chapter provides technical details for various parts of the + Yocto Project. + Currently, topics include Yocto Project components, + cross-toolchain generation, shared state (sstate) cache, + x32, Wayland support, and Licenses. + </para> + +<section id='usingpoky-components'> + <title>Yocto Project Components</title> + + <para> + The + <ulink url='&YOCTO_DOCS_DEV_URL;#bitbake-term'>BitBake</ulink> + task executor together with various types of configuration files form + the OpenEmbedded Core. + This section overviews these components by describing their use and + how they interact. + </para> + + <para> + BitBake handles the parsing and execution of the data files. + The data itself is of various types: + <itemizedlist> + <listitem><para><emphasis>Recipes:</emphasis> Provides details + about particular pieces of software. + </para></listitem> + <listitem><para><emphasis>Class Data:</emphasis> Abstracts + common build information (e.g. how to build a Linux kernel). + </para></listitem> + <listitem><para><emphasis>Configuration Data:</emphasis> Defines + machine-specific settings, policy decisions, and so forth. + Configuration data acts as the glue to bind everything + together. + </para></listitem> + </itemizedlist> + </para> + + <para> + BitBake knows how to combine multiple data sources together and refers + to each data source as a layer. + For information on layers, see the + "<ulink url='&YOCTO_DOCS_DEV_URL;#understanding-and-creating-layers'>Understanding and + Creating Layers</ulink>" section of the Yocto Project Development Manual. + </para> + + <para> + Following are some brief details on these core components. + For additional information on how these components interact during + a build, see the + "<link linkend='closer-look'>A Closer Look at the Yocto Project Development Environment</link>" + Chapter. + </para> + + <section id='usingpoky-components-bitbake'> + <title>BitBake</title> + + <para> + BitBake is the tool at the heart of the OpenEmbedded build system + and is responsible for parsing the + <ulink url='&YOCTO_DOCS_DEV_URL;#metadata'>Metadata</ulink>, + generating a list of tasks from it, and then executing those tasks. + </para> + + <para> + This section briefly introduces BitBake. + If you want more information on BitBake, see the + <ulink url='&YOCTO_DOCS_BB_URL;#bitbake-user-manual'>BitBake User Manual</ulink>. + </para> + + <para> + To see a list of the options BitBake supports, use either of + the following commands: + <literallayout class='monospaced'> + $ bitbake -h + $ bitbake --help + </literallayout> + </para> + + <para> + The most common usage for BitBake is <filename>bitbake <replaceable>packagename</replaceable></filename>, where + <filename>packagename</filename> is the name of the package you want to build + (referred to as the "target" in this manual). + The target often equates to the first part of a recipe's filename + (e.g. "foo" for a recipe named + <filename>foo_1.3.0-r0.bb</filename>). + So, to process the <filename>matchbox-desktop_1.2.3.bb</filename> recipe file, you + might type the following: + <literallayout class='monospaced'> + $ bitbake matchbox-desktop + </literallayout> + Several different versions of <filename>matchbox-desktop</filename> might exist. + BitBake chooses the one selected by the distribution configuration. + You can get more details about how BitBake chooses between different + target versions and providers in the + "<ulink url='&YOCTO_DOCS_BB_URL;#bb-bitbake-preferences'>Preferences</ulink>" + section of the BitBake User Manual. + </para> + + <para> + BitBake also tries to execute any dependent tasks first. + So for example, before building <filename>matchbox-desktop</filename>, BitBake + would build a cross compiler and <filename>glibc</filename> if they had not already + been built. + </para> + + <para> + A useful BitBake option to consider is the <filename>-k</filename> or + <filename>--continue</filename> option. + This option instructs BitBake to try and continue processing the job + as long as possible even after encountering an error. + When an error occurs, the target that + failed and those that depend on it cannot be remade. + However, when you use this option other dependencies can still be + processed. + </para> + </section> + + <section id='usingpoky-components-metadata'> + <title>Metadata (Recipes)</title> + + <para> + Files that have the <filename>.bb</filename> suffix are "recipes" + files. + In general, a recipe contains information about a single piece of + software. + This information includes the location from which to download the + unaltered source, any source patches to be applied to that source + (if needed), which special configuration options to apply, + how to compile the source files, and how to package the compiled + output. + </para> + + <para> + The term "package" is sometimes used to refer to recipes. However, + since the word "package" is used for the packaged output from the OpenEmbedded + build system (i.e. <filename>.ipk</filename> or <filename>.deb</filename> files), + this document avoids using the term "package" when referring to recipes. + </para> + </section> + + <section id='usingpoky-components-classes'> + <title>Classes</title> + + <para> + Class files (<filename>.bbclass</filename>) contain information that + is useful to share between + <ulink url='&YOCTO_DOCS_DEV_URL;#metadata'>Metadata</ulink> files. + An example is the + <link linkend='ref-classes-autotools'><filename>autotools</filename></link> + class, which contains common settings for any application that + Autotools uses. + The "<link linkend='ref-classes'>Classes</link>" chapter provides + details about classes and how to use them. + </para> + </section> + + <section id='usingpoky-components-configuration'> + <title>Configuration</title> + + <para> + The configuration files (<filename>.conf</filename>) define various configuration variables + that govern the OpenEmbedded build process. + These files fall into several areas that define machine configuration options, + distribution configuration options, compiler tuning options, general common configuration + options, and user configuration options in <filename>local.conf</filename>, which is found + in the + <ulink url='&YOCTO_DOCS_DEV_URL;#build-directory'>Build Directory</ulink>. + </para> + </section> +</section> + +<section id="cross-development-toolchain-generation"> + <title>Cross-Development Toolchain Generation</title> + + <para> + The Yocto Project does most of the work for you when it comes to + creating + <ulink url='&YOCTO_DOCS_DEV_URL;#cross-development-toolchain'>cross-development toolchains</ulink>. + This section provides some technical background on how + cross-development toolchains are created and used. + For more information on toolchains, you can also see the + <ulink url='&YOCTO_DOCS_ADT_URL;'>Yocto Project Application Developer's Guide</ulink>. + </para> + + <para> + In the Yocto Project development environment, cross-development + toolchains are used to build the image and applications that run on the + target hardware. + With just a few commands, the OpenEmbedded build system creates + these necessary toolchains for you. + </para> + + <para> + The following figure shows a high-level build environment regarding + toolchain construction and use. + </para> + + <para> + <imagedata fileref="figures/cross-development-toolchains.png" width="8in" depth="6in" align="center" /> + </para> + + <para> + Most of the work occurs on the Build Host. + This is the machine used to build images and generally work within the + the Yocto Project environment. + When you run BitBake to create an image, the OpenEmbedded build system + uses the host <filename>gcc</filename> compiler to bootstrap a + cross-compiler named <filename>gcc-cross</filename>. + The <filename>gcc-cross</filename> compiler is what BitBake uses to + compile source files when creating the target image. + You can think of <filename>gcc-cross</filename> simply as an + automatically generated cross-compiler that is used internally within + BitBake only. + </para> + + <para> + The chain of events that occurs when <filename>gcc-cross</filename> is + bootstrapped is as follows: + <literallayout class='monospaced'> + gcc -> binutils-cross -> gcc-cross-initial -> linux-libc-headers -> glibc-initial -> glibc -> gcc-cross -> gcc-runtime + </literallayout> + <itemizedlist> + <listitem><para><filename>gcc</filename>: + The build host's GNU Compiler Collection (GCC). + </para></listitem> + <listitem><para><filename>binutils-cross</filename>: + The bare minimum binary utilities needed in order to run + the <filename>gcc-cross-initial</filename> phase of the + bootstrap operation. + </para></listitem> + <listitem><para><filename>gcc-cross-initial</filename>: + An early stage of the bootstrap process for creating + the cross-compiler. + This stage builds enough of the <filename>gcc-cross</filename>, + the C library, and other pieces needed to finish building the + final cross-compiler in later stages. + This tool is a "native" package (i.e. it is designed to run on + the build host). + </para></listitem> + <listitem><para><filename>linux-libc-headers</filename>: + Headers needed for the cross-compiler. + </para></listitem> + <listitem><para><filename>glibc-initial</filename>: + An initial version of the Embedded GLIBC needed to bootstrap + <filename>glibc</filename>. + </para></listitem> + <listitem><para><filename>gcc-cross</filename>: + The final stage of the bootstrap process for the + cross-compiler. + This stage results in the actual cross-compiler that + BitBake uses when it builds an image for a targeted + device. + <note> + If you are replacing this cross compiler toolchain + with a custom version, you must replace + <filename>gcc-cross</filename>. + </note> + This tool is also a "native" package (i.e. it is + designed to run on the build host). + </para></listitem> + <listitem><para><filename>gcc-runtime</filename>: + Runtime libraries resulting from the toolchain bootstrapping + process. + This tool produces a binary that consists of the + runtime libraries need for the targeted device. + </para></listitem> + </itemizedlist> + </para> + + <para> + You can use the OpenEmbedded build system to build an installer for + the relocatable SDK used to develop applications. + When you run the installer, it installs the toolchain, which contains + the development tools (e.g., the + <filename>gcc-cross-canadian</filename>), + <filename>binutils-cross-canadian</filename>, and other + <filename>nativesdk-*</filename> tools you need to cross-compile and + test your software. + The figure shows the commands you use to easily build out this + toolchain. + This cross-development toolchain is built to execute on the + <link linkend='var-SDKMACHINE'><filename>SDKMACHINE</filename></link>, + which might or might not be the same + machine as the Build Host. + <note> + If your target architecture is supported by the Yocto Project, + you can take advantage of pre-built images that ship with the + Yocto Project and already contain cross-development toolchain + installers. + </note> + </para> + + <para> + Here is the bootstrap process for the relocatable toolchain: + <literallayout class='monospaced'> + gcc -> binutils-crosssdk -> gcc-crosssdk-initial -> linux-libc-headers -> + glibc-initial -> nativesdk-glibc -> gcc-crosssdk -> gcc-cross-canadian + </literallayout> + <itemizedlist> + <listitem><para><filename>gcc</filename>: + The build host's GNU Compiler Collection (GCC). + </para></listitem> + <listitem><para><filename>binutils-crosssdk</filename>: + The bare minimum binary utilities needed in order to run + the <filename>gcc-crosssdk-initial</filename> phase of the + bootstrap operation. + </para></listitem> + <listitem><para><filename>gcc-crosssdk-initial</filename>: + An early stage of the bootstrap process for creating + the cross-compiler. + This stage builds enough of the + <filename>gcc-crosssdk</filename> and supporting pieces so that + the final stage of the bootstrap process can produce the + finished cross-compiler. + This tool is a "native" binary that runs on the build host. + </para></listitem> + <listitem><para><filename>linux-libc-headers</filename>: + Headers needed for the cross-compiler. + </para></listitem> + <listitem><para><filename>glibc-initial</filename>: + An initial version of the Embedded GLIBC needed to bootstrap + <filename>nativesdk-glibc</filename>. + </para></listitem> + <listitem><para><filename>nativesdk-glibc</filename>: + The Embedded GLIBC needed to bootstrap the + <filename>gcc-crosssdk</filename>. + </para></listitem> + <listitem><para><filename>gcc-crosssdk</filename>: + The final stage of the bootstrap process for the + relocatable cross-compiler. + The <filename>gcc-crosssdk</filename> is a transitory compiler + and never leaves the build host. + Its purpose is to help in the bootstrap process to create the + eventual relocatable <filename>gcc-cross-canadian</filename> + compiler, which is relocatable. + This tool is also a "native" package (i.e. it is + designed to run on the build host). + </para></listitem> + <listitem><para><filename>gcc-cross-canadian</filename>: + The final relocatable cross-compiler. + When run on the + <link linkend='var-SDKMACHINE'><filename>SDKMACHINE</filename></link>, + this tool + produces executable code that runs on the target device. + Only one cross-canadian compiler is produced per architecture + since they can be targeted at different processor optimizations + using configurations passed to the compiler through the + compile commands. + This circumvents the need for multiple compilers and thus + reduces the size of the toolchains. + </para></listitem> + </itemizedlist> + </para> + + <note> + For information on advantages gained when building a + cross-development toolchain installer, see the + "<ulink url='&YOCTO_DOCS_ADT_URL;#optionally-building-a-toolchain-installer'>Optionally Building a Toolchain Installer</ulink>" + section in the Yocto Project Application Developer's Guide. + </note> +</section> + +<section id="shared-state-cache"> + <title>Shared State Cache</title> + + <para> + By design, the OpenEmbedded build system builds everything from scratch unless + BitBake can determine that parts do not need to be rebuilt. + Fundamentally, building from scratch is attractive as it means all parts are + built fresh and there is no possibility of stale data causing problems. + When developers hit problems, they typically default back to building from scratch + so they know the state of things from the start. + </para> + + <para> + Building an image from scratch is both an advantage and a disadvantage to the process. + As mentioned in the previous paragraph, building from scratch ensures that + everything is current and starts from a known state. + However, building from scratch also takes much longer as it generally means + rebuilding things that do not necessarily need to be rebuilt. + </para> + + <para> + The Yocto Project implements shared state code that supports incremental builds. + The implementation of the shared state code answers the following questions that + were fundamental roadblocks within the OpenEmbedded incremental build support system: + <itemizedlist> + <listitem><para>What pieces of the system have changed and what pieces have + not changed?</para></listitem> + <listitem><para>How are changed pieces of software removed and replaced?</para></listitem> + <listitem><para>How are pre-built components that do not need to be rebuilt from scratch + used when they are available?</para></listitem> + </itemizedlist> + </para> + + <para> + For the first question, the build system detects changes in the "inputs" to a given task by + creating a checksum (or signature) of the task's inputs. + If the checksum changes, the system assumes the inputs have changed and the task needs to be + rerun. + For the second question, the shared state (sstate) code tracks which tasks add which output + to the build process. + This means the output from a given task can be removed, upgraded or otherwise manipulated. + The third question is partly addressed by the solution for the second question + assuming the build system can fetch the sstate objects from remote locations and + install them if they are deemed to be valid. + </para> + + <note> + The OpenEmbedded build system does not maintain + <link linkend='var-PR'><filename>PR</filename></link> information + as part of the shared state packages. + Consequently, considerations exist that affect maintaining shared + state feeds. + For information on how the OpenEmbedded build system + works with packages and can + track incrementing <filename>PR</filename> information, see the + "<ulink url='&YOCTO_DOCS_DEV_URL;#incrementing-a-package-revision-number'>Incrementing a Package Revision Number</ulink>" + section. + </note> + + <para> + The rest of this section goes into detail about the overall incremental build + architecture, the checksums (signatures), shared state, and some tips and tricks. + </para> + + <section id='overall-architecture'> + <title>Overall Architecture</title> + + <para> + When determining what parts of the system need to be built, BitBake + works on a per-task basis rather than a per-recipe basis. + You might wonder why using a per-task basis is preferred over a per-recipe basis. + To help explain, consider having the IPK packaging backend enabled and then switching to DEB. + In this case, the + <link linkend='ref-tasks-install'><filename>do_install</filename></link> + and + <link linkend='ref-tasks-package'><filename>do_package</filename></link> + task outputs are still valid. + However, with a per-recipe approach, the build would not include the + <filename>.deb</filename> files. + Consequently, you would have to invalidate the whole build and rerun it. + Rerunning everything is not the best solution. + Also, in this case, the core must be "taught" much about specific tasks. + This methodology does not scale well and does not allow users to easily add new tasks + in layers or as external recipes without touching the packaged-staging core. + </para> + </section> + + <section id='checksums'> + <title>Checksums (Signatures)</title> + + <para> + The shared state code uses a checksum, which is a unique signature of a task's + inputs, to determine if a task needs to be run again. + Because it is a change in a task's inputs that triggers a rerun, the process + needs to detect all the inputs to a given task. + For shell tasks, this turns out to be fairly easy because + the build process generates a "run" shell script for each task and + it is possible to create a checksum that gives you a good idea of when + the task's data changes. + </para> + + <para> + To complicate the problem, there are things that should not be included in + the checksum. + First, there is the actual specific build path of a given task - + the <link linkend='var-WORKDIR'><filename>WORKDIR</filename></link>. + It does not matter if the work directory changes because it should not + affect the output for target packages. + Also, the build process has the objective of making native or cross packages relocatable. + The checksum therefore needs to exclude <filename>WORKDIR</filename>. + The simplistic approach for excluding the work directory is to set + <filename>WORKDIR</filename> to some fixed value and create the checksum + for the "run" script. + </para> + + <para> + Another problem results from the "run" scripts containing functions that + might or might not get called. + The incremental build solution contains code that figures out dependencies + between shell functions. + This code is used to prune the "run" scripts down to the minimum set, + thereby alleviating this problem and making the "run" scripts much more + readable as a bonus. + </para> + + <para> + So far we have solutions for shell scripts. + What about Python tasks? + The same approach applies even though these tasks are more difficult. + The process needs to figure out what variables a Python function accesses + and what functions it calls. + Again, the incremental build solution contains code that first figures out + the variable and function dependencies, and then creates a checksum for the data + used as the input to the task. + </para> + + <para> + Like the <filename>WORKDIR</filename> case, situations exist where dependencies + should be ignored. + For these cases, you can instruct the build process to ignore a dependency + by using a line like the following: + <literallayout class='monospaced'> + PACKAGE_ARCHS[vardepsexclude] = "MACHINE" + </literallayout> + This example ensures that the + <link linkend='var-PACKAGE_ARCHS'><filename>PACKAGE_ARCHS</filename></link> + variable does not + depend on the value of + <link linkend='var-MACHINE'><filename>MACHINE</filename></link>, + even if it does reference it. + </para> + + <para> + Equally, there are cases where we need to add dependencies BitBake is not able to find. + You can accomplish this by using a line like the following: + <literallayout class='monospaced'> + PACKAGE_ARCHS[vardeps] = "MACHINE" + </literallayout> + This example explicitly adds the <filename>MACHINE</filename> variable as a + dependency for <filename>PACKAGE_ARCHS</filename>. + </para> + + <para> + Consider a case with in-line Python, for example, where BitBake is not + able to figure out dependencies. + When running in debug mode (i.e. using <filename>-DDD</filename>), BitBake + produces output when it discovers something for which it cannot figure out + dependencies. + The Yocto Project team has currently not managed to cover those dependencies + in detail and is aware of the need to fix this situation. + </para> + + <para> + Thus far, this section has limited discussion to the direct inputs into a task. + Information based on direct inputs is referred to as the "basehash" in the + code. + However, there is still the question of a task's indirect inputs - the + things that were already built and present in the + <ulink url='&YOCTO_DOCS_DEV_URL;#build-directory'>Build Directory</ulink>. + The checksum (or signature) for a particular task needs to add the hashes + of all the tasks on which the particular task depends. + Choosing which dependencies to add is a policy decision. + However, the effect is to generate a master checksum that combines the basehash + and the hashes of the task's dependencies. + </para> + + <para> + At the code level, there are a variety of ways both the basehash and the + dependent task hashes can be influenced. + Within the BitBake configuration file, we can give BitBake some extra information + to help it construct the basehash. + The following statement effectively results in a list of global variable + dependency excludes - variables never included in any checksum: + <literallayout class='monospaced'> + BB_HASHBASE_WHITELIST ?= "TMPDIR FILE PATH PWD BB_TASKHASH BBPATH DL_DIR \ + SSTATE_DIR THISDIR FILESEXTRAPATHS FILE_DIRNAME HOME LOGNAME SHELL TERM \ + USER FILESPATH STAGING_DIR_HOST STAGING_DIR_TARGET COREBASE PRSERV_HOST \ + PRSERV_DUMPDIR PRSERV_DUMPFILE PRSERV_LOCKDOWN PARALLEL_MAKE \ + CCACHE_DIR EXTERNAL_TOOLCHAIN CCACHE CCACHE_DISABLE LICENSE_PATH SDKPKGSUFFIX" + </literallayout> + The previous example excludes + <link linkend='var-WORKDIR'><filename>WORKDIR</filename></link> + since that variable is actually constructed as a path within + <link linkend='var-TMPDIR'><filename>TMPDIR</filename></link>, which is on + the whitelist. + </para> + + <para> + The rules for deciding which hashes of dependent tasks to include through + dependency chains are more complex and are generally accomplished with a + Python function. + The code in <filename>meta/lib/oe/sstatesig.py</filename> shows two examples + of this and also illustrates how you can insert your own policy into the system + if so desired. + This file defines the two basic signature generators <filename>OE-Core</filename> + uses: "OEBasic" and "OEBasicHash". + By default, there is a dummy "noop" signature handler enabled in BitBake. + This means that behavior is unchanged from previous versions. + <filename>OE-Core</filename> uses the "OEBasicHash" signature handler by default + through this setting in the <filename>bitbake.conf</filename> file: + <literallayout class='monospaced'> + BB_SIGNATURE_HANDLER ?= "OEBasicHash" + </literallayout> + The "OEBasicHash" <filename>BB_SIGNATURE_HANDLER</filename> is the same as the + "OEBasic" version but adds the task hash to the stamp files. + This results in any + <ulink url='&YOCTO_DOCS_DEV_URL;#metadata'>Metadata</ulink> + change that changes the task hash, automatically + causing the task to be run again. + This removes the need to bump <link linkend='var-PR'><filename>PR</filename></link> + values, and changes to Metadata automatically ripple across the build. + </para> + + <para> + It is also worth noting that the end result of these signature generators is to + make some dependency and hash information available to the build. + This information includes: + <itemizedlist> + <listitem><para><filename>BB_BASEHASH_task-</filename><replaceable>taskname</replaceable>: + The base hashes for each task in the recipe. + </para></listitem> + <listitem><para><filename>BB_BASEHASH_</filename><replaceable>filename</replaceable><filename>:</filename><replaceable>taskname</replaceable>: + The base hashes for each dependent task. + </para></listitem> + <listitem><para><filename>BBHASHDEPS_</filename><replaceable>filename</replaceable><filename>:</filename><replaceable>taskname</replaceable>: + The task dependencies for each task. + </para></listitem> + <listitem><para><filename>BB_TASKHASH</filename>: + The hash of the currently running task. + </para></listitem> + </itemizedlist> + </para> + </section> + + <section id='shared-state'> + <title>Shared State</title> + + <para> + Checksums and dependencies, as discussed in the previous section, solve half the + problem of supporting a shared state. + The other part of the problem is being able to use checksum information during the build + and being able to reuse or rebuild specific components. + </para> + + <para> + The + <link linkend='ref-classes-sstate'><filename>sstate</filename></link> + class is a relatively generic implementation of how to "capture" + a snapshot of a given task. + The idea is that the build process does not care about the source of a task's output. + Output could be freshly built or it could be downloaded and unpacked from + somewhere - the build process does not need to worry about its origin. + </para> + + <para> + There are two types of output, one is just about creating a directory + in <link linkend='var-WORKDIR'><filename>WORKDIR</filename></link>. + A good example is the output of either + <link linkend='ref-tasks-install'><filename>do_install</filename></link> + or + <link linkend='ref-tasks-package'><filename>do_package</filename></link>. + The other type of output occurs when a set of data is merged into a shared directory + tree such as the sysroot. + </para> + + <para> + The Yocto Project team has tried to keep the details of the + implementation hidden in <filename>sstate</filename> class. + From a user's perspective, adding shared state wrapping to a task + is as simple as this + <link linkend='ref-tasks-deploy'><filename>do_deploy</filename></link> + example taken from the + <link linkend='ref-classes-deploy'><filename>deploy</filename></link> + class: + <literallayout class='monospaced'> + DEPLOYDIR = "${WORKDIR}/deploy-${PN}" + SSTATETASKS += "do_deploy" + do_deploy[sstate-name] = "deploy" + do_deploy[sstate-inputdirs] = "${DEPLOYDIR}" + do_deploy[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}" + + python do_deploy_setscene () { + sstate_setscene(d) + } + addtask do_deploy_setscene + do_deploy[dirs] = "${DEPLOYDIR} ${B}" + </literallayout> + In this example, we add some extra flags to the task, a name field ("deploy"), an + input directory where the task sends data, and the output + directory where the data from the task should eventually be copied. + We also add a <filename>_setscene</filename> variant of the task and add the task + name to the <filename>SSTATETASKS</filename> list. + </para> + + <para> + If you have a directory whose contents you need to preserve, you can do this with + a line like the following: + <literallayout class='monospaced'> + do_package[sstate-plaindirs] = "${PKGD} ${PKGDEST}" + </literallayout> + This method, as well as the following example, also works for multiple directories. + <literallayout class='monospaced'> + do_package[sstate-inputdirs] = "${PKGDESTWORK} ${SHLIBSWORKDIR}" + do_package[sstate-outputdirs] = "${PKGDATA_DIR} ${SHLIBSDIR}" + do_package[sstate-lockfile] = "${PACKAGELOCK}" + </literallayout> + These methods also include the ability to take a lockfile when manipulating + shared state directory structures since some cases are sensitive to file + additions or removals. + </para> + + <para> + Behind the scenes, the shared state code works by looking in + <link linkend='var-SSTATE_DIR'><filename>SSTATE_DIR</filename></link> and + <link linkend='var-SSTATE_MIRRORS'><filename>SSTATE_MIRRORS</filename></link> + for shared state files. + Here is an example: + <literallayout class='monospaced'> + SSTATE_MIRRORS ?= "\ + file://.* http://someserver.tld/share/sstate/PATH \n \ + file://.* file:///some/local/dir/sstate/PATH" + </literallayout> + <note> + The shared state directory (<filename>SSTATE_DIR</filename>) is + organized into two-character subdirectories, where the subdirectory + names are based on the first two characters of the hash. + If the shared state directory structure for a mirror has the + same structure as <filename>SSTATE_DIR</filename>, you must + specify "PATH" as part of the URI to enable the build system + to map to the appropriate subdirectory. + </note> + </para> + + <para> + The shared state package validity can be detected just by looking at the + filename since the filename contains the task checksum (or signature) as + described earlier in this section. + If a valid shared state package is found, the build process downloads it + and uses it to accelerate the task. + </para> + + <para> + The build processes use the <filename>*_setscene</filename> tasks + for the task acceleration phase. + BitBake goes through this phase before the main execution code and tries + to accelerate any tasks for which it can find shared state packages. + If a shared state package for a task is available, the shared state + package is used. + This means the task and any tasks on which it is dependent are not + executed. + </para> + + <para> + As a real world example, the aim is when building an IPK-based image, + only the + <link linkend='ref-tasks-package_write_ipk'><filename>do_package_write_ipk</filename></link> + tasks would have their + shared state packages fetched and extracted. + Since the sysroot is not used, it would never get extracted. + This is another reason why a task-based approach is preferred over a + recipe-based approach, which would have to install the output from every task. + </para> + </section> + + <section id='tips-and-tricks'> + <title>Tips and Tricks</title> + + <para> + The code in the build system that supports incremental builds is not + simple code. + This section presents some tips and tricks that help you work around + issues related to shared state code. + </para> + + <section id='debugging'> + <title>Debugging</title> + + <para> + When things go wrong, debugging needs to be straightforward. + Because of this, the Yocto Project includes strong debugging + tools: + <itemizedlist> + <listitem><para>Whenever a shared state package is written out, so is a + corresponding <filename>.siginfo</filename> file. + This practice results in a pickled Python database of all + the metadata that went into creating the hash for a given shared state + package.</para></listitem> + <listitem><para>If you run BitBake with the <filename>--dump-signatures</filename> + (or <filename>-S</filename>) option, BitBake dumps out + <filename>.siginfo</filename> files in + the stamp directory for every task it would have executed instead of + building the specified target package.</para></listitem> + <listitem><para>There is a <filename>bitbake-diffsigs</filename> command that + can process <filename>.siginfo</filename> files. + If you specify one of these files, BitBake dumps out the dependency + information in the file. + If you specify two files, BitBake compares the two files and dumps out + the differences between the two. + This more easily helps answer the question of "What + changed between X and Y?"</para></listitem> + </itemizedlist> + </para> + </section> + + <section id='invalidating-shared-state'> + <title>Invalidating Shared State</title> + + <para> + The OpenEmbedded build system uses checksums and shared state + cache to avoid unnecessarily rebuilding tasks. + Collectively, this scheme is known as "shared state code." + </para> + + <para> + As with all schemes, this one has some drawbacks. + It is possible that you could make implicit changes to your + code that the checksum calculations do not take into + account. + These implicit changes affect a task's output but do not trigger + the shared state code into rebuilding a recipe. + Consider an example during which a tool changes its output. + Assume that the output of <filename>rpmdeps</filename> changes. + The result of the change should be that all the + <filename>package</filename> and + <filename>package_write_rpm</filename> shared state cache + items become invalid. + However, because the change to the output is + external to the code and therefore implicit, + the associated shared state cache items do not become + invalidated. + In this case, the build process uses the cached items rather + than running the task again. + Obviously, these types of implicit changes can cause problems. + </para> + + <para> + To avoid these problems during the build, you need to + understand the effects of any changes you make. + Realize that changes you make directly to a function + are automatically factored into the checksum calculation. + Thus, these explicit changes invalidate the associated area of + shared state cache. + However, you need to be aware of any implicit changes that + are not obvious changes to the code and could affect the output + of a given task. + </para> + + <para> + When you identify an implicit change, you can easily take steps + to invalidate the cache and force the tasks to run. + The steps you can take are as simple as changing a function's + comments in the source code. + For example, to invalidate package shared state files, change + the comment statements of + <link linkend='ref-tasks-package'><filename>do_package</filename></link> + or the comments of one of the functions it calls. + Even though the change is purely cosmetic, it causes the + checksum to be recalculated and forces the OpenEmbedded build + system to run the task again. + </para> + + <note> + For an example of a commit that makes a cosmetic change to + invalidate shared state, see this + <ulink url='&YOCTO_GIT_URL;/cgit.cgi/poky/commit/meta/classes/package.bbclass?id=737f8bbb4f27b4837047cb9b4fbfe01dfde36d54'>commit</ulink>. + </note> + </section> + </section> +</section> + +<section id='x32'> + <title>x32</title> + + <para> + x32 is a processor-specific Application Binary Interface (psABI) for x86_64. + An ABI defines the calling conventions between functions in a processing environment. + The interface determines what registers are used and what the sizes are for various C data types. + </para> + + <para> + Some processing environments prefer using 32-bit applications even when running + on Intel 64-bit platforms. + Consider the i386 psABI, which is a very old 32-bit ABI for Intel 64-bit platforms. + The i386 psABI does not provide efficient use and access of the Intel 64-bit processor resources, + leaving the system underutilized. + Now consider the x86_64 psABI. + This ABI is newer and uses 64-bits for data sizes and program pointers. + The extra bits increase the footprint size of the programs, libraries, + and also increases the memory and file system size requirements. + Executing under the x32 psABI enables user programs to utilize CPU and system resources + more efficiently while keeping the memory footprint of the applications low. + Extra bits are used for registers but not for addressing mechanisms. + </para> + + <section id='support'> + <title>Support</title> + + <para> + This Yocto Project release supports the final specifications of x32 + psABI. + Support for x32 psABI exists as follows: + <itemizedlist> + <listitem><para>You can create packages and images in x32 psABI format on x86_64 architecture targets. + </para></listitem> + <listitem><para>You can successfully build many recipes with the x32 toolchain.</para></listitem> + <listitem><para>You can create and boot <filename>core-image-minimal</filename> and + <filename>core-image-sato</filename> images.</para></listitem> + </itemizedlist> + </para> + </section> + + <section id='completing-x32'> + <title>Completing x32</title> + + <para> + Future Plans for the x32 psABI in the Yocto Project include the following: + <itemizedlist> + <listitem><para>Enhance and fix the few remaining recipes so they + work with and support x32 toolchains.</para></listitem> + <listitem><para>Enhance RPM Package Manager (RPM) support for x32 binaries.</para></listitem> + <listitem><para>Support larger images.</para></listitem> + </itemizedlist> + </para> + </section> + + <section id='using-x32-right-now'> + <title>Using x32 Right Now</title> + + <para> + Follow these steps to use the x32 spABI: + <itemizedlist> + <listitem><para>Enable the x32 psABI tuning file for <filename>x86_64</filename> + machines by editing the <filename>conf/local.conf</filename> like this: + <literallayout class='monospaced'> + MACHINE = "qemux86-64" + DEFAULTTUNE = "x86-64-x32" + baselib = "${@d.getVar('BASE_LIB_tune-' + (d.getVar('DEFAULTTUNE', True) \ + or 'INVALID'), True) or 'lib'}" + #MACHINE = "genericx86" + #DEFAULTTUNE = "core2-64-x32" + </literallayout></para></listitem> + <listitem><para>As usual, use BitBake to build an image that supports the x32 psABI. + Here is an example: + <literallayout class='monospaced'> + $ bitbake core-image-sato + </literallayout></para></listitem> + <listitem><para>As usual, run your image using QEMU: + <literallayout class='monospaced'> + $ runqemu qemux86-64 core-image-sato + </literallayout></para></listitem> + </itemizedlist> + </para> + </section> +</section> + +<section id="wayland"> + <title>Wayland</title> + + <para> + <ulink url='http://en.wikipedia.org/wiki/Wayland_(display_server_protocol)'>Wayland</ulink> + is a computer display server protocol that + provides a method for compositing window managers to communicate + directly with applications and video hardware and expects them to + communicate with input hardware using other libraries. + Using Wayland with supporting targets can result in better control + over graphics frame rendering than an application might otherwise + achieve. + </para> + + <para> + The Yocto Project provides the Wayland protocol libraries and the + reference + <ulink url='http://en.wikipedia.org/wiki/Wayland_(display_server_protocol)#Weston'>Weston</ulink> + compositor as part of its release. + This section describes what you need to do to implement Wayland and + use the compositor when building an image for a supporting target. + </para> + + <section id="wayland-support"> + <title>Support</title> + + <para> + The Wayland protocol libraries and the reference Weston compositor + ship as integrated packages in the <filename>meta</filename> layer + of the + <ulink url='&YOCTO_DOCS_DEV_URL;#source-directory'>Source Directory</ulink>. + Specifically, you can find the recipes that build both Wayland + and Weston at <filename>meta/recipes-graphics/wayland</filename>. + </para> + + <para> + You can build both the Wayland and Weston packages for use only + with targets that accept the + <ulink url='http://dri.freedesktop.org/wiki/'>Mesa 3D and Direct Rendering Infrastructure</ulink>, + which is also known as Mesa DRI. + This implies that you cannot build and use the packages if your + target uses, for example, the + <trademark class='registered'>Intel</trademark> Embedded Media and + Graphics Driver (<trademark class='registered'>Intel</trademark> + EMGD) that overrides Mesa DRI. + </para> + + <note> + Due to lack of EGL support, Weston 1.0.3 will not run directly on + the emulated QEMU hardware. + However, this version of Weston will run under X emulation without + issues. + </note> + </section> + + <section id="enabling-wayland-in-an-image"> + <title>Enabling Wayland in an Image</title> + + <para> + To enable Wayland, you need to enable it to be built and enable + it to be included in the image. + </para> + + <section id="enable-building"> + <title>Building</title> + + <para> + To cause Mesa to build the <filename>wayland-egl</filename> + platform and Weston to build Wayland with Kernel Mode + Setting + (<ulink url='https://wiki.archlinux.org/index.php/Kernel_Mode_Setting'>KMS</ulink>) + support, include the "wayland" flag in the + <link linkend="var-DISTRO_FEATURES"><filename>DISTRO_FEATURES</filename></link> + statement in your <filename>local.conf</filename> file: + <literallayout class='monospaced'> + DISTRO_FEATURES_append = " wayland" + </literallayout> + </para> + + <note> + If X11 has been enabled elsewhere, Weston will build Wayland + with X11 support + </note> + </section> + + <section id="enable-installation-in-an-image"> + <title>Installing</title> + + <para> + To install the Wayland feature into an image, you must + include the following + <link linkend='var-CORE_IMAGE_EXTRA_INSTALL'><filename>CORE_IMAGE_EXTRA_INSTALL</filename></link> + statement in your <filename>local.conf</filename> file: + <literallayout class='monospaced'> + CORE_IMAGE_EXTRA_INSTALL += "wayland weston" + </literallayout> + </para> + </section> + </section> + + <section id="running-weston"> + <title>Running Weston</title> + + <para> + To run Weston inside X11, enabling it as described earlier and + building a Sato image is sufficient. + If you are running your image under Sato, a Weston Launcher appears + in the "Utility" category. + </para> + + <para> + Alternatively, you can run Weston through the command-line + interpretor (CLI), which is better suited for development work. + To run Weston under the CLI, you need to do the following after + your image is built: + <orderedlist> + <listitem><para>Run these commands to export + <filename>XDG_RUNTIME_DIR</filename>: + <literallayout class='monospaced'> + mkdir -p /tmp/$USER-weston + chmod 0700 /tmp/$USER-weston + export XDG_RUNTIME_DIR=/tmp/$USER-weston + </literallayout></para></listitem> + <listitem><para>Launch Weston in the shell: + <literallayout class='monospaced'> + weston + </literallayout></para></listitem> + </orderedlist> + </para> + </section> +</section> + +<section id="licenses"> + <title>Licenses</title> + + <para> + This section describes the mechanism by which the OpenEmbedded build system + tracks changes to licensing text. + The section also describes how to enable commercially licensed recipes, + which by default are disabled. + </para> + + <para> + For information that can help you maintain compliance with various open + source licensing during the lifecycle of the product, see the + "<ulink url='&YOCTO_DOCS_DEV_URL;#maintaining-open-source-license-compliance-during-your-products-lifecycle'>Maintaining Open Source License Compliance During Your Project's Lifecycle</ulink>" section + in the Yocto Project Development Manual. + </para> + + <section id="usingpoky-configuring-LIC_FILES_CHKSUM"> + <title>Tracking License Changes</title> + + <para> + The license of an upstream project might change in the future. + In order to prevent these changes going unnoticed, the + <filename><link linkend='var-LIC_FILES_CHKSUM'>LIC_FILES_CHKSUM</link></filename> + variable tracks changes to the license text. The checksums are validated at the end of the + configure step, and if the checksums do not match, the build will fail. + </para> + + <section id="usingpoky-specifying-LIC_FILES_CHKSUM"> + <title>Specifying the <filename>LIC_FILES_CHKSUM</filename> Variable</title> + + <para> + The <filename>LIC_FILES_CHKSUM</filename> + variable contains checksums of the license text in the source code for the recipe. + Following is an example of how to specify <filename>LIC_FILES_CHKSUM</filename>: + <literallayout class='monospaced'> + LIC_FILES_CHKSUM = "file://COPYING;md5=xxxx \ + file://licfile1.txt;beginline=5;endline=29;md5=yyyy \ + file://licfile2.txt;endline=50;md5=zzzz \ + ..." + </literallayout> + </para> + + <para> + The build system uses the + <filename><link linkend='var-S'>S</link></filename> variable as + the default directory when searching files listed in + <filename>LIC_FILES_CHKSUM</filename>. + The previous example employs the default directory. + </para> + + <para> + Consider this next example: + <literallayout class='monospaced'> + LIC_FILES_CHKSUM = "file://src/ls.c;beginline=5;endline=16;\ + md5=bb14ed3c4cda583abc85401304b5cd4e" + LIC_FILES_CHKSUM = "file://${WORKDIR}/license.html;md5=5c94767cedb5d6987c902ac850ded2c6" + </literallayout> + </para> + + <para> + The first line locates a file in + <filename>${S}/src/ls.c</filename>. + The second line refers to a file in + <filename><link linkend='var-WORKDIR'>WORKDIR</link></filename>. + </para> + <para> + Note that <filename>LIC_FILES_CHKSUM</filename> variable is + mandatory for all recipes, unless the + <filename>LICENSE</filename> variable is set to "CLOSED". + </para> + </section> + + <section id="usingpoky-LIC_FILES_CHKSUM-explanation-of-syntax"> + <title>Explanation of Syntax</title> + <para> + As mentioned in the previous section, the + <filename>LIC_FILES_CHKSUM</filename> variable lists all the + important files that contain the license text for the source code. + It is possible to specify a checksum for an entire file, or a specific section of a + file (specified by beginning and ending line numbers with the "beginline" and "endline" + parameters, respectively). + The latter is useful for source files with a license notice header, + README documents, and so forth. + If you do not use the "beginline" parameter, then it is assumed that the text begins on the + first line of the file. + Similarly, if you do not use the "endline" parameter, it is assumed that the license text + ends with the last line of the file. + </para> + + <para> + The "md5" parameter stores the md5 checksum of the license text. + If the license text changes in any way as compared to this parameter + then a mismatch occurs. + This mismatch triggers a build failure and notifies the developer. + Notification allows the developer to review and address the license text changes. + Also note that if a mismatch occurs during the build, the correct md5 + checksum is placed in the build log and can be easily copied to the recipe. + </para> + + <para> + There is no limit to how many files you can specify using the + <filename>LIC_FILES_CHKSUM</filename> variable. + Generally, however, every project requires a few specifications for license tracking. + Many projects have a "COPYING" file that stores the license information for all the source + code files. + This practice allows you to just track the "COPYING" file as long as it is kept up to date. + </para> + + <tip> + If you specify an empty or invalid "md5" parameter, BitBake returns an md5 mis-match + error and displays the correct "md5" parameter value during the build. + The correct parameter is also captured in the build log. + </tip> + + <tip> + If the whole file contains only license text, you do not need to use the "beginline" and + "endline" parameters. + </tip> + </section> + </section> + + <section id="enabling-commercially-licensed-recipes"> + <title>Enabling Commercially Licensed Recipes</title> + + <para> + By default, the OpenEmbedded build system disables + components that have commercial or other special licensing + requirements. + Such requirements are defined on a + recipe-by-recipe basis through the + <link linkend='var-LICENSE_FLAGS'><filename>LICENSE_FLAGS</filename></link> + variable definition in the affected recipe. + For instance, the + <filename>poky/meta/recipes-multimedia/gstreamer/gst-plugins-ugly</filename> + recipe contains the following statement: + <literallayout class='monospaced'> + LICENSE_FLAGS = "commercial" + </literallayout> + Here is a slightly more complicated example that contains both an + explicit recipe name and version (after variable expansion): + <literallayout class='monospaced'> + LICENSE_FLAGS = "license_${PN}_${PV}" + </literallayout> + In order for a component restricted by a <filename>LICENSE_FLAGS</filename> + definition to be enabled and included in an image, it + needs to have a matching entry in the global + <link linkend='var-LICENSE_FLAGS_WHITELIST'><filename>LICENSE_FLAGS_WHITELIST</filename></link> + variable, which is a variable + typically defined in your <filename>local.conf</filename> file. + For example, to enable + the <filename>poky/meta/recipes-multimedia/gstreamer/gst-plugins-ugly</filename> + package, you could add either the string + "commercial_gst-plugins-ugly" or the more general string + "commercial" to <filename>LICENSE_FLAGS_WHITELIST</filename>. + See the + "<link linkend='license-flag-matching'>License Flag Matching</link>" section + for a full explanation of how <filename>LICENSE_FLAGS</filename> matching works. + Here is the example: + <literallayout class='monospaced'> + LICENSE_FLAGS_WHITELIST = "commercial_gst-plugins-ugly" + </literallayout> + Likewise, to additionally enable the package built from the recipe containing + <filename>LICENSE_FLAGS = "license_${PN}_${PV}"</filename>, and assuming + that the actual recipe name was <filename>emgd_1.10.bb</filename>, + the following string would enable that package as well as + the original <filename>gst-plugins-ugly</filename> package: + <literallayout class='monospaced'> + LICENSE_FLAGS_WHITELIST = "commercial_gst-plugins-ugly license_emgd_1.10" + </literallayout> + As a convenience, you do not need to specify the complete license string + in the whitelist for every package. + You can use an abbreviated form, which consists + of just the first portion or portions of the license string before + the initial underscore character or characters. + A partial string will match + any license that contains the given string as the first + portion of its license. + For example, the following + whitelist string will also match both of the packages + previously mentioned as well as any other packages that have + licenses starting with "commercial" or "license". + <literallayout class='monospaced'> + LICENSE_FLAGS_WHITELIST = "commercial license" + </literallayout> + </para> + + <section id="license-flag-matching"> + <title>License Flag Matching</title> + + <para> + License flag matching allows you to control what recipes the + OpenEmbedded build system includes in the build. + Fundamentally, the build system attempts to match + <link linkend='var-LICENSE_FLAGS'><filename>LICENSE_FLAGS</filename></link> + strings found in recipes against + <link linkend='var-LICENSE_FLAGS_WHITELIST'><filename>LICENSE_FLAGS_WHITELIST</filename></link> + strings found in the whitelist. + A match causes the build system to include a recipe in the + build, while failure to find a match causes the build system to + exclude a recipe. + </para> + + <para> + In general, license flag matching is simple. + However, understanding some concepts will help you + correctly and effectively use matching. + </para> + + <para> + Before a flag + defined by a particular recipe is tested against the + contents of the whitelist, the expanded string + <filename>_${PN}</filename> is appended to the flag. + This expansion makes each <filename>LICENSE_FLAGS</filename> + value recipe-specific. + After expansion, the string is then matched against the + whitelist. + Thus, specifying + <filename>LICENSE_FLAGS = "commercial"</filename> + in recipe "foo", for example, results in the string + <filename>"commercial_foo"</filename>. + And, to create a match, that string must appear in the + whitelist. + </para> + + <para> + Judicious use of the <filename>LICENSE_FLAGS</filename> + strings and the contents of the + <filename>LICENSE_FLAGS_WHITELIST</filename> variable + allows you a lot of flexibility for including or excluding + recipes based on licensing. + For example, you can broaden the matching capabilities by + using license flags string subsets in the whitelist. + <note>When using a string subset, be sure to use the part of + the expanded string that precedes the appended underscore + character (e.g. <filename>usethispart_1.3</filename>, + <filename>usethispart_1.4</filename>, and so forth). + </note> + For example, simply specifying the string "commercial" in + the whitelist matches any expanded + <filename>LICENSE_FLAGS</filename> definition that starts with + the string "commercial" such as "commercial_foo" and + "commercial_bar", which are the strings the build system + automatically generates for hypothetical recipes named + "foo" and "bar" assuming those recipes simply specify the + following: + <literallayout class='monospaced'> + LICENSE_FLAGS = "commercial" + </literallayout> + Thus, you can choose to exhaustively + enumerate each license flag in the whitelist and + allow only specific recipes into the image, or + you can use a string subset that causes a broader range of + matches to allow a range of recipes into the image. + </para> + + <para> + This scheme works even if the + <filename>LICENSE_FLAGS</filename> string already + has <filename>_${PN}</filename> appended. + For example, the build system turns the license flag + "commercial_1.2_foo" into "commercial_1.2_foo_foo" and would + match both the general "commercial" and the specific + "commercial_1.2_foo" strings found in the whitelist, as + expected. + </para> + + <para> + Here are some other scenarios: + <itemizedlist> + <listitem><para>You can specify a versioned string in the + recipe such as "commercial_foo_1.2" in a "foo" recipe. + The build system expands this string to + "commercial_foo_1.2_foo". + Combine this license flag with a whitelist that has + the string "commercial" and you match the flag along + with any other flag that starts with the string + "commercial".</para></listitem> + <listitem><para>Under the same circumstances, you can + use "commercial_foo" in the whitelist and the + build system not only matches "commercial_foo_1.2" but + also matches any license flag with the string + "commercial_foo", regardless of the version. + </para></listitem> + <listitem><para>You can be very specific and use both the + package and version parts in the whitelist (e.g. + "commercial_foo_1.2") to specifically match a + versioned recipe.</para></listitem> + </itemizedlist> + </para> + </section> + + <section id="other-variables-related-to-commercial-licenses"> + <title>Other Variables Related to Commercial Licenses</title> + + <para> + Other helpful variables related to commercial + license handling exist and are defined in the + <filename>poky/meta/conf/distro/include/default-distrovars.inc</filename> file: + <literallayout class='monospaced'> + COMMERCIAL_AUDIO_PLUGINS ?= "" + COMMERCIAL_VIDEO_PLUGINS ?= "" + COMMERCIAL_QT = "" + </literallayout> + If you want to enable these components, you can do so by making sure you have + statements similar to the following + in your <filename>local.conf</filename> configuration file: + <literallayout class='monospaced'> + COMMERCIAL_AUDIO_PLUGINS = "gst-plugins-ugly-mad \ + gst-plugins-ugly-mpegaudioparse" + COMMERCIAL_VIDEO_PLUGINS = "gst-plugins-ugly-mpeg2dec \ + gst-plugins-ugly-mpegstream gst-plugins-bad-mpegvideoparse" + COMMERCIAL_QT ?= "qmmp" + LICENSE_FLAGS_WHITELIST = "commercial_gst-plugins-ugly commercial_gst-plugins-bad commercial_qmmp" + </literallayout> + Of course, you could also create a matching whitelist + for those components using the more general "commercial" + in the whitelist, but that would also enable all the + other packages with + <link linkend='var-LICENSE_FLAGS'><filename>LICENSE_FLAGS</filename></link> + containing "commercial", which you may or may not want: + <literallayout class='monospaced'> + LICENSE_FLAGS_WHITELIST = "commercial" + </literallayout> + </para> + + <para> + Specifying audio and video plug-ins as part of the + <filename>COMMERCIAL_AUDIO_PLUGINS</filename> and + <filename>COMMERCIAL_VIDEO_PLUGINS</filename> statements + or commercial Qt components as part of + the <filename>COMMERCIAL_QT</filename> statement (along + with the enabling <filename>LICENSE_FLAGS_WHITELIST</filename>) includes the + plug-ins or components into built images, thus adding + support for media formats or components. + </para> + </section> + </section> +</section> +</chapter> +<!-- +vim: expandtab tw=80 ts=4 +--> |
