diff options
Diffstat (limited to 'poky/documentation/kernel-dev/advanced.rst')
| -rw-r--r-- | poky/documentation/kernel-dev/advanced.rst | 151 |
1 files changed, 61 insertions, 90 deletions
diff --git a/poky/documentation/kernel-dev/advanced.rst b/poky/documentation/kernel-dev/advanced.rst index fb6dfca85..871ec8ae7 100644 --- a/poky/documentation/kernel-dev/advanced.rst +++ b/poky/documentation/kernel-dev/advanced.rst @@ -21,7 +21,7 @@ is the ``yocto-kernel-cache`` Git repository. You can find this repository grouped under the "Yocto Linux Kernel" heading in the :yocto_git:`Yocto Project Source Repositories <>`. -Kernel development tools ("kern-tools") exist also in the Yocto Project +Kernel development tools ("kern-tools") are also available in the Yocto Project Source Repositories under the "Yocto Linux Kernel" heading in the ``yocto-kernel-tools`` Git repository. The recipe that builds these tools is ``meta/recipes-kernel/kern-tools/kern-tools-native_git.bb`` in @@ -46,15 +46,15 @@ linux-yocto recipe. Every linux-yocto style recipe must define the :term:`KMACHINE` variable. This -variable is typically set to the same value as the ``MACHINE`` variable, +variable is typically set to the same value as the :term:`MACHINE` variable, which is used by :term:`BitBake`. However, in some cases, the variable might instead refer to the -underlying platform of the ``MACHINE``. +underlying platform of the :term:`MACHINE`. -Multiple BSPs can reuse the same ``KMACHINE`` name if they are built +Multiple BSPs can reuse the same :term:`KMACHINE` name if they are built using the same BSP description. Multiple Corei7-based BSPs could share -the same "intel-corei7-64" value for ``KMACHINE``. It is important to -realize that ``KMACHINE`` is just for kernel mapping, while ``MACHINE`` +the same "intel-corei7-64" value for :term:`KMACHINE`. It is important to +realize that :term:`KMACHINE` is just for kernel mapping, while :term:`MACHINE` is the machine type within a BSP Layer. Even with this distinction, however, these two variables can hold the same value. See the ":ref:`kernel-dev/advanced:bsp descriptions`" section for more information. @@ -66,9 +66,8 @@ to indicate the branch. .. note:: - You can use the ``KBRANCH`` value to define an alternate branch typically - with a machine override as shown here from the ``meta-yocto-bsp`` layer: - :: + You can use the :term:`KBRANCH` value to define an alternate branch typically + with a machine override as shown here from the ``meta-yocto-bsp`` layer:: KBRANCH_edgerouter = "standard/edgerouter" @@ -82,8 +81,8 @@ variables: :term:`LINUX_KERNEL_TYPE` defines the kernel type to be used in assembling the configuration. If -you do not specify a ``LINUX_KERNEL_TYPE``, it defaults to "standard". -Together with ``KMACHINE``, ``LINUX_KERNEL_TYPE`` defines the search +you do not specify a :term:`LINUX_KERNEL_TYPE`, it defaults to "standard". +Together with :term:`KMACHINE`, :term:`LINUX_KERNEL_TYPE` defines the search arguments used by the kernel tools to find the appropriate description within the kernel Metadata with which to build out the sources and configuration. The linux-yocto recipes define "standard", "tiny", and @@ -91,35 +90,33 @@ configuration. The linux-yocto recipes define "standard", "tiny", and section for more information on kernel types. During the build, the kern-tools search for the BSP description file -that most closely matches the ``KMACHINE`` and ``LINUX_KERNEL_TYPE`` +that most closely matches the :term:`KMACHINE` and :term:`LINUX_KERNEL_TYPE` variables passed in from the recipe. The tools use the first BSP description they find that matches both variables. If the tools cannot find a match, they issue a warning. -The tools first search for the ``KMACHINE`` and then for the -``LINUX_KERNEL_TYPE``. If the tools cannot find a partial match, they -will use the sources from the ``KBRANCH`` and any configuration +The tools first search for the :term:`KMACHINE` and then for the +:term:`LINUX_KERNEL_TYPE`. If the tools cannot find a partial match, they +will use the sources from the :term:`KBRANCH` and any configuration specified in the :term:`SRC_URI`. You can use the :term:`KERNEL_FEATURES` variable to include features (configuration fragments, patches, or both) -that are not already included by the ``KMACHINE`` and -``LINUX_KERNEL_TYPE`` variable combination. For example, to include a -feature specified as "features/netfilter/netfilter.scc", specify: -:: +that are not already included by the :term:`KMACHINE` and +:term:`LINUX_KERNEL_TYPE` variable combination. For example, to include a +feature specified as "features/netfilter/netfilter.scc", specify:: KERNEL_FEATURES += "features/netfilter/netfilter.scc" To include a feature called "cfg/sound.scc" just for the ``qemux86`` machine, -specify: -:: +specify:: KERNEL_FEATURES_append_qemux86 = " cfg/sound.scc" The value of -the entries in ``KERNEL_FEATURES`` are dependent on their location +the entries in :term:`KERNEL_FEATURES` are dependent on their location within the kernel Metadata itself. The examples here are taken from the ``yocto-kernel-cache`` repository. Each branch of this repository contains "features" and "cfg" subdirectories at the top-level. For more @@ -157,8 +154,7 @@ types to form the final description of what will be assembled and built. While the kernel Metadata syntax does not enforce any logical separation of configuration fragments, patches, features or kernel types, best practices dictate a logical separation of these types of Metadata. The -following Metadata file hierarchy is recommended: -:: +following Metadata file hierarchy is recommended:: base/ bsp/ @@ -222,8 +218,7 @@ used with the ``linux-yocto-4.12`` kernel as defined outside of the recipe space (i.e. ``yocto-kernel-cache``). This Metadata consists of two files: ``smp.scc`` and ``smp.cfg``. You can find these files in the ``cfg`` directory of the ``yocto-4.12`` branch in the -``yocto-kernel-cache`` Git repository: -:: +``yocto-kernel-cache`` Git repository:: cfg/smp.scc: define KFEATURE_DESCRIPTION "Enable SMP for 32 bit builds" @@ -265,8 +260,7 @@ non-hardware fragment. As described in the ":ref:`kernel-dev/common:validating configuration`" section, you can -use the following BitBake command to audit your configuration: -:: +use the following BitBake command to audit your configuration:: $ bitbake linux-yocto -c kernel_configcheck -f @@ -287,8 +281,7 @@ in the ``patches/build`` directory of the ``yocto-4.12`` branch in the ``yocto-kernel-cache`` Git repository. The following listings show the ``build.scc`` file and part of the -``modpost-mask-trivial-warnings.patch`` file: -:: +``modpost-mask-trivial-warnings.patch`` file:: patches/build/build.scc: patch arm-serialize-build-targets.patch @@ -320,7 +313,7 @@ The following listings show the ``build.scc`` file and part of the The description file can include multiple patch statements where each statement handles a single -patch. In the example ``build.scc`` file, five patch statements exist +patch. In the example ``build.scc`` file, there are five patch statements for the five patches in the directory. You can create a typical ``.patch`` file using ``diff -Nurp`` or @@ -334,8 +327,7 @@ Features Features are complex kernel Metadata types that consist of configuration fragments, patches, and possibly other feature description files. As an -example, consider the following generic listing: -:: +example, consider the following generic listing:: features/myfeature.scc define KFEATURE_DESCRIPTION "Enable myfeature" @@ -352,7 +344,7 @@ as how an additional feature description file is included with the Typically, features are less granular than configuration fragments and are more likely than configuration fragments and patches to be the types -of things you want to specify in the ``KERNEL_FEATURES`` variable of the +of things you want to specify in the :term:`KERNEL_FEATURES` variable of the Linux kernel recipe. See the ":ref:`kernel-dev/advanced:using kernel metadata in a recipe`" section earlier in the manual. @@ -371,15 +363,13 @@ the ``linux-yocto_4.12.bb`` kernel recipe found in ``poky/meta/recipes-kernel/linux``, a :ref:`require <bitbake:bitbake-user-manual/bitbake-user-manual-metadata:\`\`require\`\` directive>` directive includes the ``poky/meta/recipes-kernel/linux/linux-yocto.inc`` file, -which has the following statement that defines the default kernel type: -:: +which has the following statement that defines the default kernel type:: LINUX_KERNEL_TYPE ??= "standard" Another example would be the real-time kernel (i.e. ``linux-yocto-rt_4.12.bb``). This kernel recipe directly sets the kernel -type as follows: -:: +type as follows:: LINUX_KERNEL_TYPE = "preempt-rt" @@ -412,8 +402,7 @@ for Linux Yocto kernels: For any given kernel type, the Metadata is defined by the ``.scc`` (e.g. ``standard.scc``). Here is a partial listing for the ``standard.scc`` file, which is found in the ``ktypes/standard`` directory of the -``yocto-kernel-cache`` Git repository: -:: +``yocto-kernel-cache`` Git repository:: # Include this kernel type fragment to get the standard features and # configuration values. @@ -482,15 +471,13 @@ Description Overview For simplicity, consider the following root BSP layer description files for the BeagleBone board. These files employ both a structure and naming convention for consistency. The naming convention for the file is as -follows: -:: +follows:: bsp_root_name-kernel_type.scc Here are some example root layer BSP filenames for the BeagleBone Board BSP, which is supported by the -Yocto Project: -:: +Yocto Project:: beaglebone-standard.scc beaglebone-preempt-rt.scc @@ -498,8 +485,7 @@ Yocto Project: Each file uses the root name (i.e "beaglebone") BSP name followed by the kernel type. -Examine the ``beaglebone-standard.scc`` file: -:: +Examine the ``beaglebone-standard.scc`` file:: define KMACHINE beaglebone define KTYPE standard @@ -523,18 +509,17 @@ description as meeting the criteria set by the recipe being built. This example supports the "beaglebone" machine for the "standard" kernel and the "arm" architecture. -Be aware that a hard link between the ``KTYPE`` variable and a kernel -type description file does not exist. Thus, if you do not have the +Be aware that there is no hard link between the :term:`KTYPE` variable and a kernel +type description file. Thus, if you do not have the kernel type defined in your kernel Metadata as it is here, you only need to ensure that the :term:`LINUX_KERNEL_TYPE` -variable in the kernel recipe and the ``KTYPE`` variable in the BSP +variable in the kernel recipe and the :term:`KTYPE` variable in the BSP description file match. To separate your kernel policy from your hardware configuration, you include a kernel type (``ktype``), such as "standard". In the previous -example, this is done using the following: -:: +example, this is done using the following:: include ktypes/standard/standard.scc @@ -544,13 +529,11 @@ policy. See the ":ref:`kernel-dev/advanced:kernel types`" section for more information. To aggregate common configurations and features specific to the kernel -for `mybsp`, use the following: -:: +for `mybsp`, use the following:: include mybsp.scc -You can see that in the BeagleBone example with the following: -:: +You can see that in the BeagleBone example with the following:: include beaglebone.scc @@ -558,15 +541,13 @@ For information on how to break a complete ``.config`` file into the various configuration fragments, see the ":ref:`kernel-dev/common:creating configuration fragments`" section. Finally, if you have any configurations specific to the hardware that -are not in a ``*.scc`` file, you can include them as follows: -:: +are not in a ``*.scc`` file, you can include them as follows:: kconf hardware mybsp-extra.cfg The BeagleBone example does not include these types of configurations. However, the Malta 32-bit board does -("mti-malta32"). Here is the ``mti-malta32-le-standard.scc`` file: -:: +("mti-malta32"). Here is the ``mti-malta32-le-standard.scc`` file:: define KMACHINE mti-malta32-le define KMACHINE qemumipsel @@ -623,8 +604,7 @@ found on the machine. This ``minnow.scc`` description file is then included in each of the three "minnow" description files for the supported kernel types (i.e. "standard", "preempt-rt", and "tiny"). Consider the "minnow" description for the "standard" kernel type (i.e. -``minnow-standard.scc``): -:: +``minnow-standard.scc``):: define KMACHINE minnow define KTYPE standard @@ -656,8 +636,7 @@ that defines all enabled hardware for the BSP that is common to all kernel types. Using this command significantly reduces duplication. Now consider the "minnow" description for the "tiny" kernel type (i.e. -``minnow-tiny.scc``): -:: +``minnow-tiny.scc``):: define KMACHINE minnow define KTYPE tiny @@ -678,7 +657,7 @@ Notice again the three critical variables: :term:`KMACHINE`, :term:`KTYPE`, and :term:`KARCH`. Of these variables, only -``KTYPE`` has changed to specify the "tiny" kernel type. +:term:`KTYPE` has changed to specify the "tiny" kernel type. Kernel Metadata Location ======================== @@ -714,14 +693,13 @@ directory hierarchy below a linux-yocto recipe or for a Linux kernel recipe derived by copying and modifying ``oe-core/meta-skeleton/recipes-kernel/linux/linux-yocto-custom.bb`` to -a recipe in your layer, ``FILESEXTRAPATHS`` is typically set to +a recipe in your layer, :term:`FILESEXTRAPATHS` is typically set to ``${``\ :term:`THISDIR`\ ``}/${``\ :term:`PN`\ ``}``. See the ":ref:`kernel-dev/common:modifying an existing recipe`" section for more information. Here is an example that shows a trivial tree of kernel Metadata stored -in recipe-space within a BSP layer: -:: +in recipe-space within a BSP layer:: meta-my_bsp_layer/ `-- recipes-kernel @@ -740,12 +718,11 @@ and fetches any files referenced in the ``.scc`` files by the ``include``, ``patch``, or ``kconf`` commands. Because of this, it is necessary to bump the recipe :term:`PR` value when changing the content of files not explicitly listed in the -``SRC_URI``. +:term:`SRC_URI`. If the BSP description is in recipe space, you cannot simply list the -``*.scc`` in the ``SRC_URI`` statement. You need to use the following -form from your kernel append file: -:: +``*.scc`` in the :term:`SRC_URI` statement. You need to use the following +form from your kernel append file:: SRC_URI_append_myplatform = " \ file://myplatform;type=kmeta;destsuffix=myplatform \ @@ -758,9 +735,8 @@ When stored outside of the recipe-space, the kernel Metadata files reside in a separate repository. The OpenEmbedded build system adds the Metadata to the build as a "type=kmeta" repository through the :term:`SRC_URI` variable. As an -example, consider the following ``SRC_URI`` statement from the -``linux-yocto_4.12.bb`` kernel recipe: -:: +example, consider the following :term:`SRC_URI` statement from the +``linux-yocto_4.12.bb`` kernel recipe:: SRC_URI = "git://git.yoctoproject.org/linux-yocto-4.12.git;name=machine;branch=${KBRANCH}; \ git://git.yoctoproject.org/yocto-kernel-cache;type=kmeta;name=meta;branch=yocto-4.12;destsuffix=${KMETA}" @@ -768,20 +744,20 @@ example, consider the following ``SRC_URI`` statement from the ``${KMETA}``, in this context, is simply used to name the directory into which the Git fetcher places the Metadata. This behavior is no different -than any multi-repository ``SRC_URI`` statement used in a recipe (e.g. +than any multi-repository :term:`SRC_URI` statement used in a recipe (e.g. see the previous section). You can keep kernel Metadata in a "kernel-cache", which is a directory containing configuration fragments. As with any Metadata kept outside -the recipe-space, you simply need to use the ``SRC_URI`` statement with +the recipe-space, you simply need to use the :term:`SRC_URI` statement with the "type=kmeta" attribute. Doing so makes the kernel Metadata available during the configuration phase. -If you modify the Metadata, you must not forget to update the ``SRCREV`` +If you modify the Metadata, you must not forget to update the :term:`SRCREV` statements in the kernel's recipe. In particular, you need to update the ``SRCREV_meta`` variable to match the commit in the ``KMETA`` branch you wish to use. Changing the data in these branches and not updating the -``SRCREV`` statements to match will cause the build to fetch an older +:term:`SRCREV` statements to match will cause the build to fetch an older commit. Organizing Your Source @@ -800,8 +776,8 @@ patches in every kernel you build (i.e. have the patches as part of the lone "master" branch). It is situations like these that give rise to multiple branches used within a Linux kernel sources Git repository. -Repository organization strategies exist that maximize source reuse, -remove redundancy, and logically order your changes. This section +Here are repository organization strategies maximizing source reuse, +removing redundancy, and logically ordering your changes. This section presents strategies for the following cases: - Encapsulating patches in a feature description and only including the @@ -844,14 +820,12 @@ patches into a feature. Once you have a new branch, you can set up your kernel Metadata to use the branch a couple different ways. In the recipe, you can specify the -new branch as the ``KBRANCH`` to use for the board as follows: -:: +new branch as the :term:`KBRANCH` to use for the board as follows:: KBRANCH = "mynewbranch" Another method is to use the ``branch`` command in the BSP -description: -:: +description:: mybsp.scc: define KMACHINE mybsp @@ -865,15 +839,13 @@ description: If you find yourself with numerous branches, you might consider using a hierarchical branching system similar to what the Yocto Linux Kernel Git -repositories use: -:: +repositories use:: common/kernel_type/machine If you had two kernel types, "standard" and "small" for instance, three machines, and common as ``mydir``, the branches in your Git repository -might look like this: -:: +might look like this:: mydir/base mydir/standard/base @@ -905,8 +877,7 @@ that have to be regularly updated. The Yocto Project Linux kernel tools provide for this with the ``git merge`` command. To merge a feature branch into a BSP, insert the ``git merge`` command -after any ``branch`` commands: -:: +after any ``branch`` commands:: mybsp.scc: define KMACHINE mybsp |