diff options
Diffstat (limited to 'poky/bitbake/doc')
7 files changed, 248 insertions, 243 deletions
diff --git a/poky/bitbake/doc/Makefile b/poky/bitbake/doc/Makefile index d40f390e2..996f01b7d 100644 --- a/poky/bitbake/doc/Makefile +++ b/poky/bitbake/doc/Makefile @@ -3,7 +3,7 @@ # You can set these variables from the command line, and also # from the environment for the first two. -SPHINXOPTS ?= -j auto +SPHINXOPTS ?= -W --keep-going -j auto SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build diff --git a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-execution.rst b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-execution.rst index 84d65fa9c..a6ef90db1 100644 --- a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-execution.rst +++ b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-execution.rst @@ -40,7 +40,7 @@ the BitBake command and its options, see ":ref:`The BitBake Command the number of processors, which takes into account hyper-threading. Thus, a quad-core build host with hyper-threading most likely shows eight processors, which is the value you would then assign to - ``BB_NUMBER_THREADS``. + :term:`BB_NUMBER_THREADS`. A possibly simpler solution is that some Linux distributions (e.g. Debian and Ubuntu) provide the ``ncpus`` command. @@ -65,13 +65,13 @@ data itself is of various types: The ``layer.conf`` files are used to construct key variables such as :term:`BBPATH` and :term:`BBFILES`. -``BBPATH`` is used to search for configuration and class files under the -``conf`` and ``classes`` directories, respectively. ``BBFILES`` is used +:term:`BBPATH` is used to search for configuration and class files under the +``conf`` and ``classes`` directories, respectively. :term:`BBFILES` is used to locate both recipe and recipe append files (``.bb`` and ``.bbappend``). If there is no ``bblayers.conf`` file, it is assumed the -user has set the ``BBPATH`` and ``BBFILES`` directly in the environment. +user has set the :term:`BBPATH` and :term:`BBFILES` directly in the environment. -Next, the ``bitbake.conf`` file is located using the ``BBPATH`` variable +Next, the ``bitbake.conf`` file is located using the :term:`BBPATH` variable that was just constructed. The ``bitbake.conf`` file may also include other configuration files using the ``include`` or ``require`` directives. @@ -104,7 +104,7 @@ BitBake first searches the current working directory for an optional contain a :term:`BBLAYERS` variable that is a space-delimited list of 'layer' directories. Recall that if BitBake cannot find a ``bblayers.conf`` file, then it is assumed the user has -set the ``BBPATH`` and ``BBFILES`` variables directly in the +set the :term:`BBPATH` and :term:`BBFILES` variables directly in the environment. For each directory (layer) in this list, a ``conf/layer.conf`` file is @@ -114,7 +114,7 @@ files automatically set up :term:`BBPATH` and other variables correctly for a given build directory. BitBake then expects to find the ``conf/bitbake.conf`` file somewhere in -the user-specified ``BBPATH``. That configuration file generally has +the user-specified :term:`BBPATH`. That configuration file generally has include directives to pull in any other metadata such as files specific to the architecture, the machine, the local environment, and so forth. @@ -135,7 +135,7 @@ The ``base.bbclass`` file is always included. Other classes that are specified in the configuration using the :term:`INHERIT` variable are also included. BitBake searches for class files in a ``classes`` subdirectory under the paths -in ``BBPATH`` in the same way as configuration files. +in :term:`BBPATH` in the same way as configuration files. A good way to get an idea of the configuration files and the class files used in your execution environment is to run the following BitBake @@ -184,13 +184,13 @@ Locating and Parsing Recipes During the configuration phase, BitBake will have set :term:`BBFILES`. BitBake now uses it to construct a list of recipes to parse, along with any append files (``.bbappend``) to -apply. ``BBFILES`` is a space-separated list of available files and +apply. :term:`BBFILES` is a space-separated list of available files and supports wildcards. An example would be:: BBFILES = "/path/to/bbfiles/*.bb /path/to/appends/*.bbappend" BitBake parses each -recipe and append file located with ``BBFILES`` and stores the values of +recipe and append file located with :term:`BBFILES` and stores the values of various variables into the datastore. .. note:: @@ -201,7 +201,7 @@ For each file, a fresh copy of the base configuration is made, then the recipe is parsed line by line. Any inherit statements cause BitBake to find and then parse class files (``.bbclass``) using :term:`BBPATH` as the search path. Finally, BitBake -parses in order any append files found in ``BBFILES``. +parses in order any append files found in :term:`BBFILES`. One common convention is to use the recipe filename to define pieces of metadata. For example, in ``bitbake.conf`` the recipe name and version @@ -212,7 +212,7 @@ are used to set the variables :term:`PN` and PV = "${@bb.parse.BBHandler.vars_from_file(d.getVar('FILE', False),d)[1] or '1.0'}" In this example, a recipe called "something_1.2.3.bb" would set -``PN`` to "something" and ``PV`` to "1.2.3". +:term:`PN` to "something" and :term:`PV` to "1.2.3". By the time parsing is complete for a recipe, BitBake has a list of tasks that the recipe defines and a set of data consisting of keys and @@ -260,21 +260,21 @@ Providers Assuming BitBake has been instructed to execute a target and that all the recipe files have been parsed, BitBake starts to figure out how to -build the target. BitBake looks through the ``PROVIDES`` list for each -of the recipes. A ``PROVIDES`` list is the list of names by which the -recipe can be known. Each recipe's ``PROVIDES`` list is created +build the target. BitBake looks through the :term:`PROVIDES` list for each +of the recipes. A :term:`PROVIDES` list is the list of names by which the +recipe can be known. Each recipe's :term:`PROVIDES` list is created implicitly through the recipe's :term:`PN` variable and explicitly through the recipe's :term:`PROVIDES` variable, which is optional. -When a recipe uses ``PROVIDES``, that recipe's functionality can be -found under an alternative name or names other than the implicit ``PN`` +When a recipe uses :term:`PROVIDES`, that recipe's functionality can be +found under an alternative name or names other than the implicit :term:`PN` name. As an example, suppose a recipe named ``keyboard_1.0.bb`` contained the following:: PROVIDES += "fullkeyboard" -The ``PROVIDES`` +The :term:`PROVIDES` list for this recipe becomes "keyboard", which is implicit, and "fullkeyboard", which is explicit. Consequently, the functionality found in ``keyboard_1.0.bb`` can be found under two different names. @@ -284,12 +284,12 @@ in ``keyboard_1.0.bb`` can be found under two different names. Preferences =========== -The ``PROVIDES`` list is only part of the solution for figuring out a +The :term:`PROVIDES` list is only part of the solution for figuring out a target's recipes. Because targets might have multiple providers, BitBake needs to prioritize providers by determining provider preferences. A common example in which a target has multiple providers is -"virtual/kernel", which is on the ``PROVIDES`` list for each kernel +"virtual/kernel", which is on the :term:`PROVIDES` list for each kernel recipe. Each machine often selects the best kernel provider by using a line similar to the following in the machine configuration file:: @@ -309,10 +309,10 @@ specify a particular version. You can influence the order by using the :term:`DEFAULT_PREFERENCE` variable. By default, files have a preference of "0". Setting -``DEFAULT_PREFERENCE`` to "-1" makes the recipe unlikely to be used -unless it is explicitly referenced. Setting ``DEFAULT_PREFERENCE`` to -"1" makes it likely the recipe is used. ``PREFERRED_VERSION`` overrides -any ``DEFAULT_PREFERENCE`` setting. ``DEFAULT_PREFERENCE`` is often used +:term:`DEFAULT_PREFERENCE` to "-1" makes the recipe unlikely to be used +unless it is explicitly referenced. Setting :term:`DEFAULT_PREFERENCE` to +"1" makes it likely the recipe is used. :term:`PREFERRED_VERSION` overrides +any :term:`DEFAULT_PREFERENCE` setting. :term:`DEFAULT_PREFERENCE` is often used to mark newer and more experimental recipe versions until they have undergone sufficient testing to be considered stable. @@ -394,7 +394,7 @@ ready to run, those tasks have all their dependencies met, and the thread threshold has not been exceeded. It is worth noting that you can greatly speed up the build time by -properly setting the ``BB_NUMBER_THREADS`` variable. +properly setting the :term:`BB_NUMBER_THREADS` variable. As each task completes, a timestamp is written to the directory specified by the :term:`STAMP` variable. On subsequent @@ -561,7 +561,7 @@ behavior is unchanged from previous versions. ``OE-Core`` uses the BB_SIGNATURE_HANDLER ?= "OEBasicHash" -The "OEBasicHash" ``BB_SIGNATURE_HANDLER`` is the same as the "OEBasic" +The "OEBasicHash" :term:`BB_SIGNATURE_HANDLER` is the same as the "OEBasic" version but adds the task hash to the stamp files. This results in any metadata change that changes the task hash, automatically causing the task to be run again. This removes the need to bump @@ -581,7 +581,7 @@ the build. This information includes: - ``BBHASHDEPS_``\ *filename:taskname*: The task dependencies for each task. -- ``BB_TASKHASH``: The hash of the currently running task. +- :term:`BB_TASKHASH`: The hash of the currently running task. It is worth noting that BitBake's "-S" option lets you debug BitBake's processing of signatures. The options passed to -S allow different diff --git a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-fetching.rst b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-fetching.rst index bd1fb4fc7..593de61f2 100644 --- a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-fetching.rst +++ b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-fetching.rst @@ -51,7 +51,7 @@ This code unpacks the downloaded files to the specified by ``WORKDIR``. examine the OpenEmbedded class file ``base.bbclass`` . -The ``SRC_URI`` and ``WORKDIR`` variables are not hardcoded into the +The :term:`SRC_URI` and ``WORKDIR`` variables are not hardcoded into the fetcher, since those fetcher methods can be (and are) called with different variable names. In OpenEmbedded for example, the shared state (sstate) code uses the fetch module to fetch the sstate files. @@ -64,14 +64,14 @@ URLs by looking for source files in a specific search order: :term:`PREMIRRORS` variable. - *Source URI:* If pre-mirrors fail, BitBake uses the original URL (e.g - from ``SRC_URI``). + from :term:`SRC_URI`). - *Mirror Sites:* If fetch failures occur, BitBake next uses mirror locations as defined by the :term:`MIRRORS` variable. For each URL passed to the fetcher, the fetcher calls the submodule that handles that particular URL type. This behavior can be the source of -some confusion when you are providing URLs for the ``SRC_URI`` variable. +some confusion when you are providing URLs for the :term:`SRC_URI` variable. Consider the following two URLs:: http://git.yoctoproject.org/git/poky;protocol=git @@ -110,14 +110,14 @@ which is specified by the :term:`DL_DIR` variable. File integrity is of key importance for reproducing builds. For non-local archive downloads, the fetcher code can verify SHA-256 and MD5 checksums to ensure the archives have been downloaded correctly. You can -specify these checksums by using the ``SRC_URI`` variable with the +specify these checksums by using the :term:`SRC_URI` variable with the appropriate varflags as follows:: SRC_URI[md5sum] = "value" SRC_URI[sha256sum] = "value" You can also specify the checksums as -parameters on the ``SRC_URI`` as shown below:: +parameters on the :term:`SRC_URI` as shown below:: SRC_URI = "http://example.com/foobar.tar.bz2;md5sum=4a8e0f237e961fd7785d19d07fdb994d" @@ -129,7 +129,7 @@ shows how you name the URIs:: SRC_URI[foo.md5sum] = 4a8e0f237e961fd7785d19d07fdb994d After a file has been downloaded and -has had its checksum checked, a ".done" stamp is placed in ``DL_DIR``. +has had its checksum checked, a ".done" stamp is placed in :term:`DL_DIR`. BitBake uses this stamp during subsequent builds to avoid downloading or comparing a checksum for the file again. @@ -438,7 +438,7 @@ Here are some example URLs:: .. note:: Specifying passwords directly in ``git://`` urls is not supported. - There are several reasons: ``SRC_URI`` is often written out to logs and + There are several reasons: :term:`SRC_URI` is often written out to logs and other places, and that could easily leak passwords; it is also all too easy to share metadata without removing passwords. SSH keys, ``~/.netrc`` and ``~/.ssh/config`` files can be used as alternatives. @@ -487,7 +487,7 @@ To use this fetcher, make sure your recipe has proper The fetcher uses the ``rcleartool`` or ``cleartool`` remote client, depending on which one is available. -Following are options for the ``SRC_URI`` statement: +Following are options for the :term:`SRC_URI` statement: - *vob*: The name, which must include the prepending "/" character, of the ClearCase VOB. This option is required. @@ -549,7 +549,7 @@ password if you do not wish to keep those values in a recipe itself. If you choose not to use ``P4CONFIG``, or to explicitly set variables that ``P4CONFIG`` can contain, you can specify the ``P4PORT`` value, which is the server's URL and port number, and you can specify a username and -password directly in your recipe within ``SRC_URI``. +password directly in your recipe within :term:`SRC_URI`. Here is an example that relies on ``P4CONFIG`` to specify the server URL and port, username, and password, and fetches the Head Revision:: @@ -680,4 +680,4 @@ submodules. However, you might find the code helpful and readable. Auto Revisions ============== -We need to document ``AUTOREV`` and ``SRCREV_FORMAT`` here. +We need to document ``AUTOREV`` and :term:`SRCREV_FORMAT` here. diff --git a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-hello.rst b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-hello.rst index a9c33709a..c5a4ce60b 100644 --- a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-hello.rst +++ b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-hello.rst @@ -145,23 +145,23 @@ Following is the complete "Hello World" example. The majority of this output is specific to environment variables that are not directly relevant to BitBake. However, the very first - message regarding the ``BBPATH`` variable and the + message regarding the :term:`BBPATH` variable and the ``conf/bblayers.conf`` file is relevant. When you run BitBake, it begins looking for metadata files. The :term:`BBPATH` variable is what tells BitBake where - to look for those files. ``BBPATH`` is not set and you need to set - it. Without ``BBPATH``, BitBake cannot find any configuration files + to look for those files. :term:`BBPATH` is not set and you need to set + it. Without :term:`BBPATH`, BitBake cannot find any configuration files (``.conf``) or recipe files (``.bb``) at all. BitBake also cannot find the ``bitbake.conf`` file. -#. **Setting BBPATH:** For this example, you can set ``BBPATH`` in +#. **Setting BBPATH:** For this example, you can set :term:`BBPATH` in the same manner that you set ``PATH`` earlier in the appendix. You should realize, though, that it is much more flexible to set the - ``BBPATH`` variable up in a configuration file for each project. + :term:`BBPATH` variable up in a configuration file for each project. From your shell, enter the following commands to set and export the - ``BBPATH`` variable:: + :term:`BBPATH` variable:: $ BBPATH="projectdirectory" $ export BBPATH @@ -175,7 +175,7 @@ Following is the complete "Hello World" example. ("~") character as BitBake does not expand that character as the shell would. -#. **Run BitBake:** Now that you have ``BBPATH`` defined, run the +#. **Run BitBake:** Now that you have :term:`BBPATH` defined, run the ``bitbake`` command again:: $ bitbake diff --git a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-intro.rst b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-intro.rst index b3cea61ff..76c8e3dac 100644 --- a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-intro.rst +++ b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-intro.rst @@ -27,7 +27,7 @@ Linux software stacks using a task-oriented approach. Conceptually, BitBake is similar to GNU Make in some regards but has significant differences: -- BitBake executes tasks according to provided metadata that builds up +- BitBake executes tasks according to the provided metadata that builds up the tasks. Metadata is stored in recipe (``.bb``) and related recipe "append" (``.bbappend``) files, configuration (``.conf``) and underlying include (``.inc``) files, and in class (``.bbclass``) @@ -417,8 +417,8 @@ Following is the usage and syntax for BitBake:: -l DEBUG_DOMAINS, --log-domains=DEBUG_DOMAINS Show debug logging for the specified logging domains -P, --profile Profile the command and save reports. - -u UI, --ui=UI The user interface to use (knotty, ncurses or taskexp - - default knotty). + -u UI, --ui=UI The user interface to use (knotty, ncurses, taskexp or + teamcity - default knotty). --token=XMLRPCTOKEN Specify the connection token to be used when connecting to a remote server. --revisions-changed Set the exit code depending on whether upstream @@ -433,6 +433,9 @@ Following is the usage and syntax for BitBake:: Environment variable BB_SERVER_TIMEOUT. --no-setscene Do not run any setscene tasks. sstate will be ignored and everything needed, built. + --skip-setscene Skip setscene tasks if they would be executed. Tasks + previously restored from sstate will be kept, unlike + --no-setscene --setscene-only Only run setscene tasks, don't run any real tasks. --remote-server=REMOTE_SERVER Connect to the specified server. @@ -537,7 +540,7 @@ current working directory: To stop depending on common depends, use the "-I" depend option and BitBake omits them from the graph. Leaving this information out can produce more readable graphs. This way, you can remove from the graph -``DEPENDS`` from inherited classes such as ``base.bbclass``. +:term:`DEPENDS` from inherited classes such as ``base.bbclass``. Here are two examples that create dependency graphs. The second example omits depends common in OpenEmbedded from the graph:: @@ -564,7 +567,7 @@ for two separate targets: .. image:: figures/bb_multiconfig_files.png :align: center -The reason for this required file hierarchy is because the ``BBPATH`` +The reason for this required file hierarchy is because the :term:`BBPATH` variable is not constructed until the layers are parsed. Consequently, using the configuration file as a pre-configuration file is not possible unless it is located in the current working directory. diff --git a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-metadata.rst b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-metadata.rst index 20c330e6a..b0494d080 100644 --- a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-metadata.rst +++ b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-metadata.rst @@ -91,9 +91,10 @@ level changes: Variables that are exported to the environment are preceded by the string "export" in the command's output. -- For recipe changes, use the following:: +- To find changes to a given variable in a specific recipe, use the + following:: - $ bitbake recipe -e \| grep VARIABLE=" + $ bitbake recipename -e | grep VARIABLENAME=\" This command checks to see if the variable actually makes it into a specific recipe. @@ -225,7 +226,7 @@ immediately, rather than when the variable is actually used:: C := "${C}append" In this example, ``A`` contains "test 123", even though the final value -of ``T`` is "456". The variable ``B`` will end up containing "456 +of :term:`T` is "456". The variable :term:`B` will end up containing "456 cvalappend". This is because references to undefined variables are preserved as is during (immediate)expansion. This is in contrast to GNU Make, where undefined variables expand to nothing. The variable ``C`` @@ -248,7 +249,7 @@ examples:: C = "cval" C =+ "test" -The variable ``B`` contains "bval additionaldata" and ``C`` contains "test +The variable :term:`B` contains "bval additionaldata" and ``C`` contains "test cval". .. _appending-and-prepending-without-spaces: @@ -267,7 +268,7 @@ examples:: C = "cval" C =. "test" -The variable ``B`` contains "bvaladditionaldata" and ``C`` contains +The variable :term:`B` contains "bvaladditionaldata" and ``C`` contains "testcval". Appending and Prepending (Override Style Syntax) @@ -281,13 +282,13 @@ operators in that their effects are applied at variable expansion time rather than being immediately applied. Here are some examples:: B = "bval" - B_append = " additional data" + B:append = " additional data" C = "cval" - C_prepend = "additional data " + C:prepend = "additional data " D = "dval" - D_append = "additional data" + D:append = "additional data" -The variable ``B`` +The variable :term:`B` becomes "bval additional data" and ``C`` becomes "additional data cval". The variable ``D`` becomes "dvaladditional data". @@ -312,10 +313,10 @@ When you use this syntax, BitBake expects one or more strings. Surrounding spaces and spacing are preserved. Here is an example:: FOO = "123 456 789 123456 123 456 123 456" - FOO_remove = "123" - FOO_remove = "456" + FOO:remove = "123" + FOO:remove = "456" FOO2 = " abc def ghi abcdef abc def abc def def" - FOO2_remove = "\ + FOO2:remove = "\ def \ abc \ ghi \ @@ -324,14 +325,14 @@ Surrounding spaces and spacing are preserved. Here is an example:: The variable ``FOO`` becomes " 789 123456 " and ``FOO2`` becomes " abcdef ". -Like "_append" and "_prepend", "_remove" is applied at variable +Like ":append" and ":prepend", ":remove" is applied at variable expansion time. Override Style Operation Advantages ----------------------------------- -An advantage of the override style operations "_append", "_prepend", and -"_remove" as compared to the "+=" and "=+" operators is that the +An advantage of the override style operations ":append", ":prepend", and +":remove" as compared to the "+=" and "=+" operators is that the override style operators provide guaranteed operations. For example, consider a class ``foo.bbclass`` that needs to add the value "val" to the variable ``FOO``, and a recipe that uses ``foo.bbclass`` as follows:: @@ -346,18 +347,18 @@ not what is desired:: FOO += "val" If, on the other hand, ``foo.bbclass`` -uses the "_append" operator, then the final value of ``FOO`` will be +uses the ":append" operator, then the final value of ``FOO`` will be "initial val", as intended:: - FOO_append = " val" + FOO:append = " val" .. note:: - It is never necessary to use "+=" together with "_append". The following + It is never necessary to use "+=" together with ":append". The following sequence of assignments appends "barbaz" to FOO:: - FOO_append = "bar" - FOO_append = "baz" + FOO:append = "bar" + FOO:append = "baz" The only effect of changing the second assignment in the previous @@ -378,8 +379,8 @@ You can find more out about variable flags in general in the You can define, append, and prepend values to variable flags. All the standard syntax operations previously mentioned work for variable flags -except for override style syntax (i.e. "_prepend", "_append", and -"_remove"). +except for override style syntax (i.e. ":prepend", ":append", and +":remove"). Here are some examples showing how to set variable flags:: @@ -496,14 +497,14 @@ Conditional Syntax (Overrides) BitBake uses :term:`OVERRIDES` to control what variables are overridden after BitBake parses recipes and configuration -files. This section describes how you can use ``OVERRIDES`` as +files. This section describes how you can use :term:`OVERRIDES` as conditional metadata, talks about key expansion in relationship to -``OVERRIDES``, and provides some examples to help with understanding. +:term:`OVERRIDES`, and provides some examples to help with understanding. Conditional Metadata -------------------- -You can use ``OVERRIDES`` to conditionally select a specific version of +You can use :term:`OVERRIDES` to conditionally select a specific version of a variable and to conditionally append or prepend the value of a variable. @@ -513,10 +514,10 @@ variable. underscores are not permitted in override names as they are used to separate overrides from each other and from the variable name. -- *Selecting a Variable:* The ``OVERRIDES`` variable is a +- *Selecting a Variable:* The :term:`OVERRIDES` variable is a colon-character-separated list that contains items for which you want to satisfy conditions. Thus, if you have a variable that is - conditional on "arm", and "arm" is in ``OVERRIDES``, then the + conditional on "arm", and "arm" is in :term:`OVERRIDES`, then the "arm"-specific version of the variable is used rather than the non-conditional version. Here is an example:: @@ -525,7 +526,7 @@ variable. TEST_os = "osspecific" TEST_nooverride = "othercondvalue" - In this example, the ``OVERRIDES`` + In this example, the :term:`OVERRIDES` variable lists three overrides: "architecture", "os", and "machine". The variable ``TEST`` by itself has a default value of "default". You select the os-specific version of the ``TEST`` variable by appending @@ -538,36 +539,36 @@ variable. that value based on the architecture of the build:: KBRANCH = "standard/base" - KBRANCH_qemuarm = "standard/arm-versatile-926ejs" - KBRANCH_qemumips = "standard/mti-malta32" - KBRANCH_qemuppc = "standard/qemuppc" - KBRANCH_qemux86 = "standard/common-pc/base" - KBRANCH_qemux86-64 = "standard/common-pc-64/base" - KBRANCH_qemumips64 = "standard/mti-malta64" + KBRANCH:qemuarm = "standard/arm-versatile-926ejs" + KBRANCH:qemumips = "standard/mti-malta32" + KBRANCH:qemuppc = "standard/qemuppc" + KBRANCH:qemux86 = "standard/common-pc/base" + KBRANCH:qemux86-64 = "standard/common-pc-64/base" + KBRANCH:qemumips64 = "standard/mti-malta64" - *Appending and Prepending:* BitBake also supports append and prepend operations to variable values based on whether a specific item is - listed in ``OVERRIDES``. Here is an example:: + listed in :term:`OVERRIDES`. Here is an example:: DEPENDS = "glibc ncurses" OVERRIDES = "machine:local" - DEPENDS_append_machine = "libmad" + DEPENDS:append:machine = "libmad" - In this example, ``DEPENDS`` becomes "glibc ncurses libmad". + In this example, :term:`DEPENDS` becomes "glibc ncurses libmad". Again, using an OpenEmbedded metadata-based kernel recipe file as an example, the following lines will conditionally append to the ``KERNEL_FEATURES`` variable based on the architecture:: - KERNEL_FEATURES_append = " ${KERNEL_EXTRA_FEATURES}" - KERNEL_FEATURES_append_qemux86=" cfg/sound.scc cfg/paravirt_kvm.scc" - KERNEL_FEATURES_append_qemux86-64=" cfg/sound.scc cfg/paravirt_kvm.scc" + KERNEL_FEATURES:append = " ${KERNEL_EXTRA_FEATURES}" + KERNEL_FEATURES:append:qemux86=" cfg/sound.scc cfg/paravirt_kvm.scc" + KERNEL_FEATURES:append:qemux86-64=" cfg/sound.scc cfg/paravirt_kvm.scc" - *Setting a Variable for a Single Task:* BitBake supports setting a variable just for the duration of a single task. Here is an example:: FOO_task-configure = "val 1" - FOO_task-compile = "val 2" + FOO:task-compile = "val 2" In the previous example, ``FOO`` has the value "val 1" while the @@ -580,9 +581,9 @@ variable. ``do_compile`` task. You can also use this syntax with other combinations (e.g. - "``_prepend``") as shown in the following example:: + "``:prepend``") as shown in the following example:: - EXTRA_OEMAKE_prepend_task-compile = "${PARALLEL_MAKE} " + EXTRA_OEMAKE:prepend:task-compile = "${PARALLEL_MAKE} " Key Expansion ------------- @@ -612,33 +613,33 @@ users. There is often confusion concerning the order in which overrides and various "append" operators take effect. Recall that an append or prepend -operation using "_append" and "_prepend" does not result in an immediate +operation using ":append" and ":prepend" does not result in an immediate assignment as would "+=", ".=", "=+", or "=.". Consider the following example:: OVERRIDES = "foo" A = "Z" - A_foo_append = "X" + A:foo:append = "X" For this case, ``A`` is unconditionally set to "Z" and "X" is unconditionally and -immediately appended to the variable ``A_foo``. Because overrides have -not been applied yet, ``A_foo`` is set to "X" due to the append and +immediately appended to the variable ``A:foo``. Because overrides have +not been applied yet, ``A:foo`` is set to "X" due to the append and ``A`` simply equals "Z". Applying overrides, however, changes things. Since "foo" is listed in -``OVERRIDES``, the conditional variable ``A`` is replaced with the "foo" -version, which is equal to "X". So effectively, ``A_foo`` replaces +:term:`OVERRIDES`, the conditional variable ``A`` is replaced with the "foo" +version, which is equal to "X". So effectively, ``A:foo`` replaces ``A``. This next example changes the order of the override and the append:: OVERRIDES = "foo" A = "Z" - A_append_foo = "X" + A:append:foo = "X" For this case, before -overrides are handled, ``A`` is set to "Z" and ``A_append_foo`` is set +overrides are handled, ``A`` is set to "Z" and ``A:append:foo`` is set to "X". Once the override for "foo" is applied, however, ``A`` gets appended with "X". Consequently, ``A`` becomes "ZX". Notice that spaces are not appended. @@ -648,21 +649,21 @@ back as in the first example:: OVERRIDES = "foo" A = "Y" - A_foo_append = "Z" - A_foo_append = "X" + A:foo:append = "Z" + A:foo:append = "X" For this case, before any overrides are resolved, ``A`` is set to "Y" using an immediate assignment. After this immediate -assignment, ``A_foo`` is set to "Z", and then further appended with "X" +assignment, ``A:foo`` is set to "Z", and then further appended with "X" leaving the variable set to "ZX". Finally, applying the override for "foo" results in the conditional variable ``A`` becoming "ZX" (i.e. -``A`` is replaced with ``A_foo``). +``A`` is replaced with ``A:foo``). This final example mixes in some varying operators:: A = "1" - A_append = "2" - A_append = "3" + A:append = "2" + A:append = "3" A += "4" A .= "5" @@ -670,7 +671,7 @@ For this case, the type of append operators are affecting the order of assignments as BitBake passes through the code multiple times. Initially, ``A`` is set to "1 45" because of the three statements that use immediate operators. After -these assignments are made, BitBake applies the "_append" operations. +these assignments are made, BitBake applies the ":append" operations. Those operations result in ``A`` becoming "1 4523". Sharing Functionality @@ -686,7 +687,7 @@ share the task. This section presents the mechanisms BitBake provides to allow you to share functionality between recipes. Specifically, the mechanisms -include ``include``, ``inherit``, ``INHERIT``, and ``require`` +include ``include``, ``inherit``, :term:`INHERIT`, and ``require`` directives. Locating Include and Class Files @@ -702,7 +703,7 @@ current directory for ``include`` and ``require`` directives. In order for include and class files to be found by BitBake, they need to be located in a "classes" subdirectory that can be found in -``BBPATH``. +:term:`BBPATH`. ``inherit`` Directive --------------------- @@ -725,7 +726,7 @@ functionality for using Autotools that could be shared across recipes:: inherit autotools In this case, BitBake would search for the directory -``classes/autotools.bbclass`` in ``BBPATH``. +``classes/autotools.bbclass`` in :term:`BBPATH`. .. note:: @@ -752,7 +753,7 @@ parsed. One way to achieve a conditional inherit in this case is to use overrides:: VARIABLE = "" - VARIABLE_someoverride = "myclass" + VARIABLE:someoverride = "myclass" Another method is by using anonymous Python. Here is an example:: @@ -780,7 +781,7 @@ BitBake understands the ``include`` directive. This directive causes BitBake to parse whatever file you specify, and to insert that file at that location. The directive is much like its equivalent in Make except that if the path specified on the include line is a relative path, -BitBake locates the first file it can find within ``BBPATH``. +BitBake locates the first file it can find within :term:`BBPATH`. The include directive is a more generic method of including functionality as compared to the :ref:`inherit <bitbake-user-manual/bitbake-user-manual-metadata:\`\`inherit\`\` directive>` @@ -822,7 +823,7 @@ does not suit a ``.bbclass`` file. Similar to how BitBake handles :ref:`include <bitbake-user-manual/bitbake-user-manual-metadata:\`\`include\`\` directive>`, if the path specified on the require line is a relative path, BitBake -locates the first file it can find within ``BBPATH``. +locates the first file it can find within :term:`BBPATH`. As an example, suppose you have two versions of a recipe (e.g. ``foo_1.2.2.bb`` and ``foo_2.0.0.bb``) where each version contains some @@ -851,7 +852,7 @@ As an example, suppose you needed to inherit a class file called This configuration directive causes the named class to be inherited at the point of the directive during parsing. As with the ``inherit`` directive, the ``.bbclass`` file must be located in a "classes" -subdirectory in one of the directories specified in ``BBPATH``. +subdirectory in one of the directories specified in :term:`BBPATH`. .. note:: @@ -907,7 +908,7 @@ rules. The scripts are executed by ``/bin/sh``, which may not be a bash shell but might be something such as ``dash``. You should not use Bash-specific script (bashisms). -Overrides and override-style operators like ``_append`` and ``_prepend`` +Overrides and override-style operators like ``:append`` and ``:prepend`` can also be applied to shell functions. Most commonly, this application would be used in a ``.bbappend`` file to modify functions in the main recipe. It can also be used to modify functions inherited from classes. @@ -919,7 +920,7 @@ As an example, consider the following:: fn } - fn_prepend() { + fn:prepend() { bbplain second } @@ -927,7 +928,7 @@ As an example, consider the following:: bbplain third } - do_foo_append() { + do_foo:append() { bbplain fourth } @@ -977,7 +978,7 @@ override-style operators to BitBake-style Python functions. As an example, consider the following:: - python do_foo_prepend() { + python do_foo:prepend() { bb.plain("first") } @@ -985,7 +986,7 @@ As an example, consider the following:: bb.plain("second") } - python do_foo_append() { + python do_foo:append() { bb.plain("third") } @@ -1015,7 +1016,7 @@ is an example:: SOMECONDITION = "1" DEPENDS = "${@get_depends(d)}" -This would result in ``DEPENDS`` containing ``dependencywithcond``. +This would result in :term:`DEPENDS` containing ``dependencywithcond``. Here are some things to know about Python functions: @@ -1134,12 +1135,12 @@ equivalent to the following snippet:: values set for the variables within the anonymous functions become available to tasks, which always run after parsing. -Overrides and override-style operators such as "``_append``" are applied +Overrides and override-style operators such as "``:append``" are applied before anonymous functions run. In the following example, ``FOO`` ends up with the value "foo from anonymous":: FOO = "foo" - FOO_append = " from outside" + FOO:append = " from outside" python () { d.setVar("FOO", "foo from anonymous") @@ -1164,7 +1165,7 @@ To understand the benefits of this feature, consider the basic scenario where a class defines a task function and your recipe inherits the class. In this basic scenario, your recipe inherits the task function as defined in the class. If desired, your recipe can add to the start and -end of the function by using the "_prepend" or "_append" operations +end of the function by using the ":prepend" or ":append" operations respectively, or it can redefine the function completely. However, if it redefines the function, there is no means for it to call the class version of the function. ``EXPORT_FUNCTIONS`` provides a mechanism that @@ -1382,7 +1383,7 @@ Sometimes, it is useful to be able to obtain information from the original execution environment. BitBake saves a copy of the original environment into a special variable named :term:`BB_ORIGENV`. -The ``BB_ORIGENV`` variable returns a datastore object that can be +The :term:`BB_ORIGENV` variable returns a datastore object that can be queried using the standard datastore operators such as ``getVar(, False)``. The datastore object is useful, for example, to find the original ``DISPLAY`` variable. Here is an example:: @@ -1467,7 +1468,7 @@ functionality of the task: can result in unpredictable behavior. - Setting the varflag to a value greater than the value used in - the ``BB_NUMBER_THREADS`` variable causes ``number_threads`` to + the :term:`BB_NUMBER_THREADS` variable causes ``number_threads`` to have no effect. - ``[postfuncs]``: List of functions to call after the completion of @@ -1537,7 +1538,7 @@ intent is to make it easy to do things like email notification on build failures. Following is an example event handler that prints the name of the event -and the content of the ``FILE`` variable:: +and the content of the :term:`FILE` variable:: addhandler myclass_eventhandler python myclass_eventhandler() { @@ -1576,7 +1577,7 @@ might have an interest in viewing: - ``bb.event.ConfigParsed()``: Fired when the base configuration; which consists of ``bitbake.conf``, ``base.bbclass`` and any global - ``INHERIT`` statements; has been parsed. You can see multiple such + :term:`INHERIT` statements; has been parsed. You can see multiple such events when each of the workers parse the base configuration or if the server changes configuration and reparses. Any given datastore only has one such event executed against it, however. If @@ -1733,13 +1734,13 @@ Build Dependencies BitBake uses the :term:`DEPENDS` variable to manage build time dependencies. The ``[deptask]`` varflag for tasks signifies -the task of each item listed in ``DEPENDS`` that must complete before +the task of each item listed in :term:`DEPENDS` that must complete before that task can be executed. Here is an example:: do_configure[deptask] = "do_populate_sysroot" In this example, the ``do_populate_sysroot`` task -of each item in ``DEPENDS`` must complete before ``do_configure`` can +of each item in :term:`DEPENDS` must complete before ``do_configure`` can execute. Runtime Dependencies @@ -1748,8 +1749,8 @@ Runtime Dependencies BitBake uses the :term:`PACKAGES`, :term:`RDEPENDS`, and :term:`RRECOMMENDS` variables to manage runtime dependencies. -The ``PACKAGES`` variable lists runtime packages. Each of those packages -can have ``RDEPENDS`` and ``RRECOMMENDS`` runtime dependencies. The +The :term:`PACKAGES` variable lists runtime packages. Each of those packages +can have :term:`RDEPENDS` and :term:`RRECOMMENDS` runtime dependencies. The ``[rdeptask]`` flag for tasks is used to signify the task of each item runtime dependency which must have completed before that task can be executed. :: @@ -1757,9 +1758,9 @@ executed. :: do_package_qa[rdeptask] = "do_packagedata" In the previous -example, the ``do_packagedata`` task of each item in ``RDEPENDS`` must +example, the ``do_packagedata`` task of each item in :term:`RDEPENDS` must have completed before ``do_package_qa`` can execute. -Although ``RDEPENDS`` contains entries from the +Although :term:`RDEPENDS` contains entries from the runtime dependency namespace, BitBake knows how to map them back to the build-time dependency namespace, in which the tasks are defined. @@ -1802,7 +1803,7 @@ Inter-Task Dependencies BitBake uses the ``[depends]`` flag in a more generic form to manage inter-task dependencies. This more generic form allows for inter-dependency checks for specific tasks rather than checks for the -data in ``DEPENDS``. Here is an example:: +data in :term:`DEPENDS`. Here is an example:: do_patch[depends] = "quilt-native:do_populate_sysroot" diff --git a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-ref-variables.rst b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-ref-variables.rst index 2dca52c4a..6283c2654 100644 --- a/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-ref-variables.rst +++ b/poky/bitbake/doc/bitbake-user-manual/bitbake-user-manual-ref-variables.rst @@ -24,13 +24,14 @@ overview of their function and contents. described here in this glossary. .. glossary:: + :sorted: :term:`ASSUME_PROVIDED` Lists recipe names (:term:`PN` values) BitBake does not attempt to build. Instead, BitBake assumes these recipes have already been built. - In OpenEmbedded-Core, ``ASSUME_PROVIDED`` mostly specifies native + In OpenEmbedded-Core, :term:`ASSUME_PROVIDED` mostly specifies native tools that should not be built. An example is ``git-native``, which when specified allows for the Git binary from the host to be used rather than building ``git-native``. @@ -83,14 +84,14 @@ overview of their function and contents. - Attempts to access networks not in the host list cause a failure. - Using ``BB_ALLOWED_NETWORKS`` in conjunction with + Using :term:`BB_ALLOWED_NETWORKS` in conjunction with :term:`PREMIRRORS` is very useful. Adding the - host you want to use to ``PREMIRRORS`` results in the source code + host you want to use to :term:`PREMIRRORS` results in the source code being fetched from an allowed location and avoids raising an error when a host that is not allowed is in a :term:`SRC_URI` statement. This is because the - fetcher does not attempt to use the host listed in ``SRC_URI`` after - a successful fetch from the ``PREMIRRORS`` occurs. + fetcher does not attempt to use the host listed in :term:`SRC_URI` after + a successful fetch from the :term:`PREMIRRORS` occurs. :term:`BB_CONSOLELOG` Specifies the path to a log file into which BitBake's user interface @@ -177,7 +178,7 @@ overview of their function and contents. issues a warning when the disk space in the ``${SSTATE_DIR}`` directory drops below 1 Gbyte or the number of free inodes drops below 100 Kbytes. Subsequent warnings are issued during intervals as - defined by the ``BB_DISKMON_WARNINTERVAL`` variable. + defined by the :term:`BB_DISKMON_WARNINTERVAL` variable. The second example stops the build after all currently executing tasks complete when the minimum disk space in the ``${TMPDIR}`` @@ -191,14 +192,14 @@ overview of their function and contents. :term:`BB_DISKMON_WARNINTERVAL` Defines the disk space and free inode warning intervals. - If you are going to use the ``BB_DISKMON_WARNINTERVAL`` variable, you + If you are going to use the :term:`BB_DISKMON_WARNINTERVAL` variable, you must also use the :term:`BB_DISKMON_DIRS` variable and define its action as "WARN". During the build, subsequent warnings are issued each time disk space or number of free inodes further reduces by the respective interval. - If you do not provide a ``BB_DISKMON_WARNINTERVAL`` variable and you - do use ``BB_DISKMON_DIRS`` with the "WARN" action, the disk + If you do not provide a :term:`BB_DISKMON_WARNINTERVAL` variable and you + do use :term:`BB_DISKMON_DIRS` with the "WARN" action, the disk monitoring interval defaults to the following: BB_DISKMON_WARNINTERVAL = "50M,5K" @@ -231,23 +232,23 @@ overview of their function and contents. based on the interval occur each time a respective interval is reached beyond the initial warning (i.e. 1 Gbytes and 100 Kbytes). - :term:`BB_ENV_WHITELIST` - Specifies the internal whitelist of variables to allow through from - the external environment into BitBake's datastore. If the value of - this variable is not specified (which is the default), the following - list is used: :term:`BBPATH`, :term:`BB_PRESERVE_ENV`, - :term:`BB_ENV_WHITELIST`, and :term:`BB_ENV_EXTRAWHITE`. + :term:`BB_ENV_EXTRAWHITE` + Specifies an additional set of variables to allow through (whitelist) + from the external environment into BitBake's datastore. This list of + variables are on top of the internal list set in + :term:`BB_ENV_WHITELIST`. .. note:: You must set this variable in the external environment in order for it to work. - :term:`BB_ENV_EXTRAWHITE` - Specifies an additional set of variables to allow through (whitelist) - from the external environment into BitBake's datastore. This list of - variables are on top of the internal list set in - :term:`BB_ENV_WHITELIST`. + :term:`BB_ENV_WHITELIST` + Specifies the internal whitelist of variables to allow through from + the external environment into BitBake's datastore. If the value of + this variable is not specified (which is the default), the following + list is used: :term:`BBPATH`, :term:`BB_PRESERVE_ENV`, + :term:`BB_ENV_WHITELIST`, and :term:`BB_ENV_EXTRAWHITE`. .. note:: @@ -263,7 +264,7 @@ overview of their function and contents. :term:`BB_FILENAME` Contains the filename of the recipe that owns the currently running task. For example, if the ``do_fetch`` task that resides in the - ``my-recipe.bb`` is executing, the ``BB_FILENAME`` variable contains + ``my-recipe.bb`` is executing, the :term:`BB_FILENAME` variable contains "/foo/path/my-recipe.bb". :term:`BB_GENERATE_MIRROR_TARBALLS` @@ -276,18 +277,6 @@ overview of their function and contents. BB_GENERATE_MIRROR_TARBALLS = "1" - :term:`BB_HASHCONFIG_WHITELIST` - Lists variables that are excluded from base configuration checksum, - which is used to determine if the cache can be reused. - - One of the ways BitBake determines whether to re-parse the main - metadata is through checksums of the variables in the datastore of - the base configuration data. There are variables that you typically - want to exclude when checking whether or not to re-parse and thus - rebuild the cache. As an example, you would usually exclude ``TIME`` - and ``DATE`` because these variables are always changing. If you did - not exclude them, BitBake would never reuse the cache. - :term:`BB_HASHBASE_WHITELIST` Lists variables that are excluded from checksum and dependency data. Variables that are excluded can therefore change without affecting @@ -309,6 +298,18 @@ overview of their function and contents. However, the more accurate the data returned, the more efficient the build will be. + :term:`BB_HASHCONFIG_WHITELIST` + Lists variables that are excluded from base configuration checksum, + which is used to determine if the cache can be reused. + + One of the ways BitBake determines whether to re-parse the main + metadata is through checksums of the variables in the datastore of + the base configuration data. There are variables that you typically + want to exclude when checking whether or not to re-parse and thus + rebuild the cache. As an example, you would usually exclude ``TIME`` + and ``DATE`` because these variables are always changing. If you did + not exclude them, BitBake would never reuse the cache. + :term:`BB_HASHSERVE` Specifies the Hash Equivalence server to use. @@ -333,7 +334,7 @@ overview of their function and contents. :term:`BB_LOGFMT` Specifies the name of the log files saved into - ``${``\ :term:`T`\ ``}``. By default, the ``BB_LOGFMT`` + ``${``\ :term:`T`\ ``}``. By default, the :term:`BB_LOGFMT` variable is undefined and the log file names get created using the following form:: @@ -357,15 +358,15 @@ overview of their function and contents. running builds when not connected to the Internet, and when operating in certain kinds of firewall environments. + :term:`BB_NUMBER_PARSE_THREADS` + Sets the number of threads BitBake uses when parsing. By default, the + number of threads is equal to the number of cores on the system. + :term:`BB_NUMBER_THREADS` The maximum number of tasks BitBake should run in parallel at any one time. If your host development system supports multiple cores, a good rule of thumb is to set this variable to twice the number of cores. - :term:`BB_NUMBER_PARSE_THREADS` - Sets the number of threads BitBake uses when parsing. By default, the - number of threads is equal to the number of cores on the system. - :term:`BB_ORIGENV` Contains a copy of the original external environment in which BitBake was run. The copy is taken before any whitelisted variable values are @@ -388,7 +389,7 @@ overview of their function and contents. :term:`BB_RUNFMT` Specifies the name of the executable script files (i.e. run files) saved into ``${``\ :term:`T`\ ``}``. By default, the - ``BB_RUNFMT`` variable is undefined and the run file names get + :term:`BB_RUNFMT` variable is undefined and the run file names get created using the following form:: run.{task}.{pid} @@ -454,7 +455,7 @@ overview of their function and contents. :term:`BB_SRCREV_POLICY` Defines the behavior of the fetcher when it interacts with source control systems and dynamic source revisions. The - ``BB_SRCREV_POLICY`` variable is useful when working without a + :term:`BB_SRCREV_POLICY` variable is useful when working without a network. The variable can be set using one of two policies: @@ -498,7 +499,7 @@ overview of their function and contents. Allows adjustment of a task's Input/Output priority. During Autobuilder testing, random failures can occur for tasks due to I/O starvation. These failures occur during various QEMU runtime - timeouts. You can use the ``BB_TASK_IONICE_LEVEL`` variable to adjust + timeouts. You can use the :term:`BB_TASK_IONICE_LEVEL` variable to adjust the I/O priority of these tasks. .. note:: @@ -572,13 +573,13 @@ overview of their function and contents. .. note:: - Internally, the ``BBCLASSEXTEND`` mechanism generates recipe + Internally, the :term:`BBCLASSEXTEND` mechanism generates recipe variants by rewriting variable values and applying overrides such as ``_class-native``. For example, to generate a native version of a recipe, a :term:`DEPENDS` on "foo" is - rewritten to a ``DEPENDS`` on "foo-native". + rewritten to a :term:`DEPENDS` on "foo-native". - Even when using ``BBCLASSEXTEND``, the recipe is only parsed once. + Even when using :term:`BBCLASSEXTEND`, the recipe is only parsed once. Parsing once adds some limitations. For example, it is not possible to include a different file depending on the variant, since ``include`` statements are processed when the recipe is @@ -614,14 +615,14 @@ overview of their function and contents. - effectively letting you control the precedence for the multiple layers. The precedence established through this variable stands regardless of a recipe's version (:term:`PV` variable). - For example, a layer that has a recipe with a higher ``PV`` value but - for which the ``BBFILE_PRIORITY`` is set to have a lower precedence + For example, a layer that has a recipe with a higher :term:`PV` value but + for which the :term:`BBFILE_PRIORITY` is set to have a lower precedence still has a lower precedence. - A larger value for the ``BBFILE_PRIORITY`` variable results in a + A larger value for the :term:`BBFILE_PRIORITY` variable results in a higher precedence. For example, the value 6 has a higher precedence - than the value 5. If not specified, the ``BBFILE_PRIORITY`` variable - is set based on layer dependencies (see the ``LAYERDEPENDS`` variable + than the value 5. If not specified, the :term:`BBFILE_PRIORITY` variable + is set based on layer dependencies (see the :term:`LAYERDEPENDS` variable for more information. The default priority, if unspecified for a layer with no dependencies, is the lowest defined priority + 1 (or 1 if no priorities are defined). @@ -644,7 +645,7 @@ overview of their function and contents. Activates content depending on presence of identified layers. You identify the layers by the collections that the layers define. - Use the ``BBFILES_DYNAMIC`` variable to avoid ``.bbappend`` files whose + Use the :term:`BBFILES_DYNAMIC` variable to avoid ``.bbappend`` files whose corresponding ``.bb`` file is in a layer that attempts to modify other layers through ``.bbappend`` but does not want to introduce a hard dependency on those other layers. @@ -653,7 +654,7 @@ overview of their function and contents. ``.bb`` files in case a layer is not present. Use this avoid hard dependency on those other layers. - Use the following form for ``BBFILES_DYNAMIC``:: + Use the following form for :term:`BBFILES_DYNAMIC`:: collection_name:filename_pattern @@ -690,7 +691,7 @@ overview of their function and contents. :term:`BBINCLUDELOGS_LINES` If :term:`BBINCLUDELOGS` is set, specifies the maximum number of lines from the task log file to print when - reporting a failed task. If you do not set ``BBINCLUDELOGS_LINES``, + reporting a failed task. If you do not set :term:`BBINCLUDELOGS_LINES`, the entire log is printed. :term:`BBLAYERS` @@ -716,7 +717,7 @@ overview of their function and contents. :term:`BBMASK` Prevents BitBake from processing recipes and recipe append files. - You can use the ``BBMASK`` variable to "hide" these ``.bb`` and + You can use the :term:`BBMASK` variable to "hide" these ``.bb`` and ``.bbappend`` files. BitBake ignores any recipe or recipe append files that match any of the expressions. It is as if BitBake does not see them at all. Consequently, matching files are not parsed or @@ -753,7 +754,7 @@ overview of their function and contents. Enables BitBake to perform multiple configuration builds and lists each separate configuration (multiconfig). You can use this variable to cause BitBake to build multiple targets where each target has a - separate configuration. Define ``BBMULTICONFIG`` in your + separate configuration. Define :term:`BBMULTICONFIG` in your ``conf/local.conf`` configuration file. As an example, the following line specifies three multiconfigs, each @@ -765,7 +766,7 @@ overview of their function and contents. build directory within a directory named ``conf/multiconfig`` (e.g. build_directory\ ``/conf/multiconfig/configA.conf``). - For information on how to use ``BBMULTICONFIG`` in an environment + For information on how to use :term:`BBMULTICONFIG` in an environment that supports building targets with multiple configurations, see the ":ref:`bitbake-user-manual/bitbake-user-manual-intro:executing a multiple configuration build`" section. @@ -776,7 +777,7 @@ overview of their function and contents. variable. If you run BitBake from a directory outside of the build directory, - you must be sure to set ``BBPATH`` to point to the build directory. + you must be sure to set :term:`BBPATH` to point to the build directory. Set the variable as you would any environment variable and then run BitBake:: @@ -823,7 +824,7 @@ overview of their function and contents. The most common usage of this is variable is to set it to "-1" within a recipe for a development version of a piece of software. Using the variable in this way causes the stable version of the recipe to build - by default in the absence of ``PREFERRED_VERSION`` being used to + by default in the absence of :term:`PREFERRED_VERSION` being used to build the development version. .. note:: @@ -836,7 +837,7 @@ overview of their function and contents. Lists a recipe's build-time dependencies (i.e. other recipe files). Consider this simple example for two recipes named "a" and "b" that - produce similarly named packages. In this example, the ``DEPENDS`` + produce similarly named packages. In this example, the :term:`DEPENDS` statement appears in the "a" recipe:: DEPENDS = "b" @@ -854,7 +855,7 @@ overview of their function and contents. :term:`DL_DIR` The central download directory used by the build process to store - downloads. By default, ``DL_DIR`` gets files suitable for mirroring for + downloads. By default, :term:`DL_DIR` gets files suitable for mirroring for everything except Git repositories. If you want tarballs of Git repositories, use the :term:`BB_GENERATE_MIRROR_TARBALLS` variable. @@ -869,14 +870,14 @@ overview of their function and contents. .. note:: - Recipes added to ``EXCLUDE_FROM_WORLD`` may still be built during a world + Recipes added to :term:`EXCLUDE_FROM_WORLD` may still be built during a world build in order to satisfy dependencies of other recipes. Adding a - recipe to ``EXCLUDE_FROM_WORLD`` only ensures that the recipe is not + recipe to :term:`EXCLUDE_FROM_WORLD` only ensures that the recipe is not explicitly added to the list of build targets in a world build. :term:`FAKEROOT` Contains the command to use when running a shell script in a fakeroot - environment. The ``FAKEROOT`` variable is obsolete and has been + environment. The :term:`FAKEROOT` variable is obsolete and has been replaced by the other ``FAKEROOT*`` variables. See these entries in the glossary for more information. @@ -939,9 +940,9 @@ overview of their function and contents. Causes the named class or classes to be inherited globally. Anonymous functions in the class or classes are not executed for the base configuration and in each individual recipe. The OpenEmbedded build - system ignores changes to ``INHERIT`` in individual recipes. + system ignores changes to :term:`INHERIT` in individual recipes. - For more information on ``INHERIT``, see the + For more information on :term:`INHERIT`, see the ":ref:`bitbake-user-manual/bitbake-user-manual-metadata:\`\`inherit\`\` configuration directive`" section. @@ -989,7 +990,7 @@ overview of their function and contents. the build system searches for source code, it first tries the local download directory. If that location fails, the build system tries locations defined by :term:`PREMIRRORS`, the - upstream source, and then locations specified by ``MIRRORS`` in that + upstream source, and then locations specified by :term:`MIRRORS` in that order. :term:`MULTI_PROVIDER_WHITELIST` @@ -1006,12 +1007,12 @@ overview of their function and contents. ``virtual/kernel``, and so forth). :term:`OVERRIDES` - BitBake uses ``OVERRIDES`` to control what variables are overridden + BitBake uses :term:`OVERRIDES` to control what variables are overridden after BitBake parses recipes and configuration files. Following is a simple example that uses an overrides list based on machine architectures: OVERRIDES = "arm:x86:mips:powerpc" You can - find information on how to use ``OVERRIDES`` in the + find information on how to use :term:`OVERRIDES` in the ":ref:`bitbake-user-manual/bitbake-user-manual-metadata:conditional syntax (overrides)`" section. @@ -1025,11 +1026,11 @@ overview of their function and contents. :term:`PACKAGES_DYNAMIC` A promise that your recipe satisfies runtime dependencies for optional modules that are found in other recipes. - ``PACKAGES_DYNAMIC`` does not actually satisfy the dependencies, it + :term:`PACKAGES_DYNAMIC` does not actually satisfy the dependencies, it only states that they should be satisfied. For example, if a hard, runtime dependency (:term:`RDEPENDS`) of another package is satisfied during the build through the - ``PACKAGES_DYNAMIC`` variable, but a package with the module name is + :term:`PACKAGES_DYNAMIC` variable, but a package with the module name is never actually produced, then the other package will be broken. :term:`PE` @@ -1068,8 +1069,8 @@ overview of their function and contents. :term:`PREFERRED_PROVIDERS` Determines which recipe should be given preference for cases where multiple recipes provide the same item. Functionally, - ``PREFERRED_PROVIDERS`` is identical to - :term:`PREFERRED_PROVIDER`. However, the ``PREFERRED_PROVIDERS`` variable + :term:`PREFERRED_PROVIDERS` is identical to + :term:`PREFERRED_PROVIDER`. However, the :term:`PREFERRED_PROVIDERS` variable lets you define preferences for multiple situations using the following form:: @@ -1087,7 +1088,7 @@ overview of their function and contents. select, and you should set :term:`PV` accordingly for precedence. - The ``PREFERRED_VERSION`` variable supports limited wildcard use + The :term:`PREFERRED_VERSION` variable supports limited wildcard use through the "``%``" character. You can use the character to match any number of characters, which can be useful when specifying versions that contain long revision numbers that potentially change. Here are @@ -1110,14 +1111,14 @@ overview of their function and contents. Specifies additional paths from which BitBake gets source code. When the build system searches for source code, it first tries the local download directory. If that location fails, the build system tries - locations defined by ``PREMIRRORS``, the upstream source, and then + locations defined by :term:`PREMIRRORS`, the upstream source, and then locations specified by :term:`MIRRORS` in that order. Typically, you would add a specific server for the build system to attempt before any others by adding something like the following to your configuration:: - PREMIRRORS_prepend = "\ + PREMIRRORS:prepend = "\ git://.*/.* http://www.yoctoproject.org/sources/ \n \ ftp://.*/.* http://www.yoctoproject.org/sources/ \n \ http://.*/.* http://www.yoctoproject.org/sources/ \n \ @@ -1130,25 +1131,25 @@ overview of their function and contents. :term:`PROVIDES` A list of aliases by which a particular recipe can be known. By - default, a recipe's own ``PN`` is implicitly already in its - ``PROVIDES`` list. If a recipe uses ``PROVIDES``, the additional + default, a recipe's own :term:`PN` is implicitly already in its + :term:`PROVIDES` list. If a recipe uses :term:`PROVIDES`, the additional aliases are synonyms for the recipe and can be useful satisfying dependencies of other recipes during the build as specified by - ``DEPENDS``. + :term:`DEPENDS`. - Consider the following example ``PROVIDES`` statement from a recipe + Consider the following example :term:`PROVIDES` statement from a recipe file ``libav_0.8.11.bb``:: PROVIDES += "libpostproc" - The ``PROVIDES`` statement results in the "libav" recipe also being known + The :term:`PROVIDES` statement results in the "libav" recipe also being known as "libpostproc". In addition to providing recipes under alternate names, the - ``PROVIDES`` mechanism is also used to implement virtual targets. A + :term:`PROVIDES` mechanism is also used to implement virtual targets. A virtual target is a name that corresponds to some particular functionality (e.g. a Linux kernel). Recipes that provide the - functionality in question list the virtual target in ``PROVIDES``. + functionality in question list the virtual target in :term:`PROVIDES`. Recipes that depend on the functionality in question can include the virtual target in :term:`DEPENDS` to leave the choice of provider open. @@ -1160,12 +1161,12 @@ overview of their function and contents. :term:`PRSERV_HOST` The network based :term:`PR` service host and port. - Following is an example of how the ``PRSERV_HOST`` variable is set:: + Following is an example of how the :term:`PRSERV_HOST` variable is set:: PRSERV_HOST = "localhost:0" You must set the variable if you want to automatically start a local PR - service. You can set ``PRSERV_HOST`` to other values to use a remote PR + service. You can set :term:`PRSERV_HOST` to other values to use a remote PR service. :term:`PV` @@ -1177,24 +1178,24 @@ overview of their function and contents. a package in this list cannot be found during the build, you will get a build error. - Because the ``RDEPENDS`` variable applies to packages being built, + Because the :term:`RDEPENDS` variable applies to packages being built, you should always use the variable in a form with an attached package name. For example, suppose you are building a development package that depends on the ``perl`` package. In this case, you would use the - following ``RDEPENDS`` statement:: + following :term:`RDEPENDS` statement:: - RDEPENDS_${PN}-dev += "perl" + RDEPENDS:${PN}-dev += "perl" In the example, the development package depends on the ``perl`` package. - Thus, the ``RDEPENDS`` variable has the ``${PN}-dev`` package name as part + Thus, the :term:`RDEPENDS` variable has the ``${PN}-dev`` package name as part of the variable. BitBake supports specifying versioned dependencies. Although the syntax varies depending on the packaging format, BitBake hides these differences from you. Here is the general syntax to specify versions - with the ``RDEPENDS`` variable:: + with the :term:`RDEPENDS` variable:: - RDEPENDS_${PN} = "package (operator version)" + RDEPENDS:${PN} = "package (operator version)" For ``operator``, you can specify the following:: @@ -1207,7 +1208,7 @@ overview of their function and contents. For example, the following sets up a dependency on version 1.2 or greater of the package ``foo``:: - RDEPENDS_${PN} = "foo (>= 1.2)" + RDEPENDS:${PN} = "foo (>= 1.2)" For information on build-time dependencies, see the :term:`DEPENDS` variable. @@ -1218,39 +1219,39 @@ overview of their function and contents. :term:`REQUIRED_VERSION` If there are multiple versions of a recipe available, this variable - determines which version should be given preference. ``REQUIRED_VERSION`` + determines which version should be given preference. :term:`REQUIRED_VERSION` works in exactly the same manner as :term:`PREFERRED_VERSION`, except that if the specified version is not available then an error message is shown and the build fails immediately. - If both ``REQUIRED_VERSION`` and ``PREFERRED_VERSION`` are set for - the same recipe, the ``REQUIRED_VERSION`` value applies. + If both :term:`REQUIRED_VERSION` and :term:`PREFERRED_VERSION` are set for + the same recipe, the :term:`REQUIRED_VERSION` value applies. :term:`RPROVIDES` A list of package name aliases that a package also provides. These aliases are useful for satisfying runtime dependencies of other packages both during the build and on the target (as specified by - ``RDEPENDS``). + :term:`RDEPENDS`). As with all package-controlling variables, you must always use the variable in conjunction with a package name override. Here is an example:: - RPROVIDES_${PN} = "widget-abi-2" + RPROVIDES:${PN} = "widget-abi-2" :term:`RRECOMMENDS` A list of packages that extends the usability of a package being built. The package being built does not depend on this list of packages in order to successfully build, but needs them for the extended usability. To specify runtime dependencies for packages, see - the ``RDEPENDS`` variable. + the :term:`RDEPENDS` variable. BitBake supports specifying versioned recommends. Although the syntax varies depending on the packaging format, BitBake hides these differences from you. Here is the general syntax to specify versions - with the ``RRECOMMENDS`` variable:: + with the :term:`RRECOMMENDS` variable:: - RRECOMMENDS_${PN} = "package (operator version)" + RRECOMMENDS:${PN} = "package (operator version)" For ``operator``, you can specify the following:: @@ -1263,7 +1264,7 @@ overview of their function and contents. For example, the following sets up a recommend on version 1.2 or greater of the package ``foo``:: - RRECOMMENDS_${PN} = "foo (>= 1.2)" + RRECOMMENDS:${PN} = "foo (>= 1.2)" :term:`SECTION` The section in which packages should be categorized. @@ -1272,10 +1273,10 @@ overview of their function and contents. The list of source files - local or remote. This variable tells BitBake which bits to pull for the build and how to pull them. For example, if the recipe or append file needs to fetch a single tarball - from the Internet, the recipe or append file uses a ``SRC_URI`` entry + from the Internet, the recipe or append file uses a :term:`SRC_URI` entry that specifies that tarball. On the other hand, if the recipe or append file needs to fetch a tarball and include a custom file, the - recipe or append file needs an ``SRC_URI`` variable that specifies + recipe or append file needs an :term:`SRC_URI` variable that specifies all those sources. The following list explains the available URI protocols: @@ -1328,8 +1329,8 @@ overview of their function and contents. subdirectory within the archive. - ``name`` : Specifies a name to be used for association with - ``SRC_URI`` checksums when you have more than one file specified - in ``SRC_URI``. + :term:`SRC_URI` checksums when you have more than one file specified + in :term:`SRC_URI`. - ``downloadfilename`` : Specifies the filename used when storing the downloaded file. @@ -1344,7 +1345,7 @@ overview of their function and contents. variable applies only when using Subversion, Git, Mercurial and Bazaar. If you want to build a fixed revision and you want to avoid performing a query on the remote repository every time BitBake parses - your recipe, you should specify a ``SRCREV`` that is a full revision + your recipe, you should specify a :term:`SRCREV` that is a full revision identifier and not just a tag. :term:`SRCREV_FORMAT` @@ -1353,10 +1354,10 @@ overview of their function and contents. :term:`SRC_URI`. The system needs help constructing these values under these - circumstances. Each component in the ``SRC_URI`` is assigned a name - and these are referenced in the ``SRCREV_FORMAT`` variable. Consider + circumstances. Each component in the :term:`SRC_URI` is assigned a name + and these are referenced in the :term:`SRCREV_FORMAT` variable. Consider an example with URLs named "machine" and "meta". In this case, - ``SRCREV_FORMAT`` could look like "machine_meta" and those names + :term:`SRCREV_FORMAT` could look like "machine_meta" and those names would have the SCM versions substituted into each position. Only one ``AUTOINC`` placeholder is added and if needed. And, this placeholder is placed at the start of the returned string. @@ -1368,7 +1369,7 @@ overview of their function and contents. :term:`STAMPCLEAN` Specifies the base path used to create recipe stamp files. Unlike the - :term:`STAMP` variable, ``STAMPCLEAN`` can contain + :term:`STAMP` variable, :term:`STAMPCLEAN` can contain wildcards to match the range of files a clean operation should remove. BitBake uses a clean operation to remove any other stamps it should be removing when creating a new stamp. |