Kernel Development Test Cases

Kernel Development Test Cases

Setup

Common Prerequisites

1. Have a clone of poky:

$ git clone git://git.yoctoproject.org/poky

2. Check out the required commit using git:

$ git checkout [COMMIT_HASH]

3. Source the build environment to create the configuration files:

$ cd [POKY_PATH]

$ . oe-init-build-env

4. Open the conf/local.conf file:

$ vi build/local.conf

Set the machine to qemux86-64 by setting the line:

MACHINE = “qemux86-64”

5. Compile a minimal image:

$ bitbake core-image-minimal

6. Get and take note of the linux-yocto kernel version (only the first two numbers, for example: 4.10):

$ bitbake virtual/kernel -e | grep LINUX_VERSION

7. Create a layer to store kernel test metadata:

$ cd [POKY_PATH]

$ yocto-layer create [LAYER-NAME]

Note: In the rest of this document "meta-kerneltest" is used as the [LAYER-NAME]

8. Create the recipe directory structure inside the created layer:

$ mkdir -p meta-kerneltest/recipes-kernel/linux/

9. Create a recipe append file inside the directory:

$ touch meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend

10. Copy the recipe file corresponding to the linux-yocto version inside the directory:

$ cp meta/recipes-kernel/linux/linux-yocto_[VERSION].bb meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

11. Edit the linux-yocto-custo recipe:

$  vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

Set the PV variable with the LINUX_VERSION variable value:

PV = "${LINUX_VERSION}"

12. Create directory “linux-yocto”:

$ mkdir meta-kerneltest/recipes-kernel/linux/linux-yocto/

13. Create directory “linux-yocto-custom”:

$ mkdir meta-kerneltest/recipes-kernel/linux/linux-yocto-custom/

14. Add the created layer to bblayers.conf. For this task, you could use the bitbake-layers script and its default recipe values:

$ cd build

$ bitbake-layers add-layer ../meta-kerneltest

General Remarks

1. As a suggestion, open another terminal in order to perform git commands.

2. Remember to source the environment and ensure your current work directory is [POKY_PATH]/build before using bitbake scripts and tools.

3. You can edit any required file with vim, emacs, or your preferred text editor.

4. If there is not a proper response after building an image, be sure to clean the shared state, and try again. To clean it, you can use:

$ bitbake virtual/kernel -c cleansstate

5. Be careful with the information added to recipe and recipe append files, using the same values -- including spaces-- to set a recipe variable value.

To ensure all the sources are correctly downloaded and the required taks are executed, ensure no shared states proxies are set on conf/local.conf.

TC_KD_01 – Applying Patches

Use Case

As a developer, I want to be able to apply a single patch to the Linux kernel source.

Prerequisites

1. Generate the patch

1.1. Go to kernel source directory:

$ cd [POKY_PATH]/build/tmp/work-shared/qemux86-64/kernel-source

1.2. Add some information at the end of the README file:

$ echo This is a test to apply a patch to the kernel. >> README

1.3. Add the modified file to the patch:

$ git add README

1.4. Commit the change:

$ git commit -s -m "KERNEL DEV TEST CASE"

1.5. Format the patch:

$ git format-patch -1

Steps

1. Move the generated patch to the "linux-yocto" directory :

$ mv 0001-KERNEL-DEV-TEST-CASE.patch [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto/

2. Add the SRC_URI var with the patch to the linux-yocto_4%.bbappend file:

$ cd [POKY_PATH]

$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend

Add the following lines and save and close the file:

SRC_URI +=  "file://0001-KERNEL-DEV-TEST-CASE.patch"

FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:"

3. Delete the README file:

$ rm build/tmp/work-shared/qemux86-64/kernel-source/README

4. Bitbake the patch:

$ cd build

$ bitbake virtual/kernel -c cleansstate  # Clean the shared state

$ bitbake virtual/kernel -c patch

5. Verify the patch is applied properly.

$ tail tmp/work-shared/qemux86-64/kernel-source/README

Expected results

1. Bitbake should complete the build without errors.

2. The README file should exist.

3. The patch changes should be displayed at the end of the file.

TC_KD_02 – linux-yocto Local Source

Use Case

As a developer, I want to to be able to work with my own Linux kernel sources.

Prerequisites

1. Have a recipe append file for linux-yocto (created previously).

2. Clone in a specific directory (different of poky):

$ cd [KERNEL_REPOS_PATH]

$ git clone git://git.yoctoproject.org/yocto-kernel-cache

$ git clone git://git.yoctoproject.org/linux-yocto-[VERSION]

3. Go to the cloned yocto-kernel-cache directory.

$ cd [KERNEL_REPOS_PATH]/yocto-kernel-cache

Checkout the required yocto-version branch:

$ git checkout [yocto-version]  # For example: $ git checkout yocto-4.8

4. Go to the linux-yocto-[VERSION] directory.

$ cd [KERNEL_REPOS_PATH]/linux-yocto-[VERSION]

Checkout the standard/base branch:

$ git checkout standard/base

5. Edit the conf/local.conf file in the repository where are you working for execution:

$ cd [POKY_PATH]

$ vi build/conf/local.conf

Set the following line:

PREFERRED_VERSION_linux-yocto_qemux86-64="[VERSION]%"

Steps

1. Edit the linux-yocto recipe append file previously created at your "meta-kerneltest" directory:

$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto_4%.bbappend

Set the SRC_URI variable with the following information:

SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \

           git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"

2. Build the changes

$ bitbake virtual/kernel

3. Save the build results in a log

$ cd build

$ bitbake virtual/kernel -e > logkerneltest

4. Verify that the changes are saved properly

Expected Results

1. The changes should be performed successfully.

2. The build should be completed successfully.

3. The log should be saved.

4. The changes should display that the SRC_URI variable is now:

SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \

           git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"

Remarks

1. You can also verify the changes by doing:

$ bitbake virtual/kernel -e | grep “name=machine;branch”

2. Make sure to point to the correct linux-yocto version.

TC_KD_03 – linux-yocto Custom Local Source

Use Case

As a developer, I want to be able to work with my own local sources for a customized linux-yocto kernel.

Prerequisites

1. Make sure you have the custom recipe file corresponding to the latest linux-yocto version:

[POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

This file should originate from [POKY_PATH]/meta/recipes-kernel/linux/linux-yocto_[VERSION].bb

2. Edit the linux-yocto-custom recipe file:

$ cd [POKY_PATH]

$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

Set the SRC_URI variable with the following information:

SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \

           git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"

Steps

1. Go to the poky build directory:

$ cd [POKY_PATH]/build

2. At conf/local.conf add the following variable:

PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"

3. Compile the kernel:

$ bitbake virtual/kernel

Expected Results

1. The variable should be set successfully. It can be tested using:

$ bitbake virtual/kernel -e | grep PREFERRED_PROVIDER_virtual/kernel

2. Compilation process should be performed successfully.

TC_KD_04 – Local Parallel Meta

Use Case

As a developer, I want to be able to work with local source with parallel meta.

Prerequisites

1. Go to the poky build directory:

$ cd [POKY_PATH]/build

2. At conf/local.conf add the following variable:

PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"

3. Compile the kernel:

$ bitbake virtual/kernel -c kernel_configme

4. Verify that CONFIG_WIMAX option is not set at:

tmp/work/qemux86_64-poky-linux/linux-yocto-custom/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config

5. Make sure you have the recipe file corresponding to the latest linux-yocto version:

[POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

This file should originate from [POKY_PATH]/meta/recipes-kernel/linux/linux-yocto_[VERSION].bb

6. Set parallel-meta for linux-yocto-custom, adding specific fragment.

6.1. Create four directories “files”, "parallel-kmeta","features" and "wimax" to work with parallel meta:

$ cd [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/

$ mkdir -p files/parallel-kmeta/features/wimax

6.2. Inside "wimax" directory create two files: wimax.cfg and wimax.scc:

$ cd files/parallel-kmeta/features/wimax

$ touch wimax.cfg wimax.scc

6.3. Inside wimax.cfg add the following variables:

CONFIG_WIMAX=y

6.4. Inside wimax.scc add the following variables:

define KFEATURE_DESCRIPTION "WiMAX Wireless Broadband support"

define KFEATURE_COMPATIBILITY board

kconf hardware wimax.cfg

7. Edit the linux-yocto-custom recipe file:

$ cd [POKY_PATH]

$ vi meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

Set the SRC_URI variable with the following information:

SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \

           git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}"

Steps

1. Edit the linux-yocto-custom recipe file:

$ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

Add the fragment by setting the next line:

KERNEL_FEATURES_append = " features/wimax/wimax.scc"

2. Edit conf/local.conf

$ cd [POKY_PATH]/build/

$ vi conf/local.conf

Set the following variable:

PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-custom"

3. Compile in your build directory:

$ bitbake virtual/kernel -c kernel_configme

Note: The build should fail at this step with an error indicating the "wimax.scc" fragment is not found.

4. Edit the linux-yocto-custom recipe file:

$ vi [POKY_PATH]/meta-kerneltest/recipes-kernel/linux/linux-yocto-custom_[VERSION].bb

Set the SRC_URI variable with the following information:

SRC_URI = "git://[KERNEL_REPOS_PATH]/linux-yocto-[VERSION];protocol=file;name=machine;branch=${KBRANCH}; \

           git://[KERNEL_REPOS_PATH]/yocto-kernel-cache;protocol=file;type=kmeta;name=meta;branch=yocto-[VERSION];destsuffix=${KMETA}; \

           file://parallel-kmeta;protocol=file;type=kmeta;name=p-kmeta;destsuffix=parallel-kmeta"

5. Compile the kernel:

$ bitbake virtual/kernel -c kernel_configme

6. Verify that CONFIG_WIMAX=y option was set properly at:

tmp/work/qemux86_64-poky-linux/linux-yocto-custom/[VERSION_DESCRIPTOR]/linux-qemux86_64-standard-build/.config

Expected Results

1. The variables should be set successfully. They can be tested using:

$ bitbake virtual/kernel -e | grep -E "PREFERRED_PROVIDER_virtual/kernel|SRC_URI"

2. The fragment should be added properly.

3. Compilation process should be performed successfully.

4. CONFIG_WIMAX=y option should be set properly in the .config file after compilation.