Introduction to Kernel Development

Environment setup

Before one starts any deployment, you need to set an environment up. The environment dedicated to Linux development is quite simple, at least, on Debian based systems:

$ sudo apt-get update

$ sudo apt-get install gawk wget git diffstat unzip texinfo gcc-multilib build-essesntial chrpatch socat libsdl1.2-dev \

xterm ncurses-dev lzop

I f you are working with ARM System On Chip (SoC), you should install gcc-arm as well:

$ sudo apt-get install gcc-arm gcc-arm-linux-gnueabihf

Getting the sources

In early kernel days (until 2003), ood-even versioning styles were used; where odd numbers were stable, even numbers were unstable. When the 2.6 was released, the versioning scheme switched to X.Y.Z, where:

• X: This was the actual kernel's version, also called major, it incremented when there were backwards-incompatible API changes.
• Y: This was the minor revision, it incremented after adding functionality in a backwards-compatible manner.
• Z: This is also called PATCH, represented the version relative to bug fixes.

This is called semantic versioning, and has been used until the 2.6.39 version; when Linux Trovalds decided to bump the version 3.0, which also meant the end of the semantic versioning in 2011, and then, an X.Y scheme was adopted.

Now the kernel uses an arbitrary X.Y versioning scheme, which has nothing to do with semantic versioning.

Source organization

An easy way it is to use Linux Torvald's Github repository: https://github.com/torvalds/linux

$ git clone https://github.com/torvalds/linux

$ git checkout last_release

• arch/: The Linux kernel is a fast growing project that supports more and more architectures. The kernel wants to be as generic as possible. Architecture specific code is separated from the rest, and falls in this directory. This directory contains processor-specific subdirectories such as alpha/, arm/, mips/, blackfin/, and so on.
• block/: This directory contains codes for block storage devices, actually the scheduling algorithm.
• crypto/: This directory contains the cryptographic API and the encryption algorithms code.
• Documentation/: This should be your favourite directory. It contains the description of APIs used for different kernel frameworks and subsystems. Yous should look here prior to asking any questions on forums.
• drivers/: This is the heaviest directory, continuously growing as device drivers get merged. It contains every device driver organized in various subdirectories.
• fs/: This directory contains the implementation of different filesystems that the kernel actually supports, such as NTFS, FAT, EXT{2, 3, 4}, sysfs, procfs, NFS, and son on.
• include/: This contains header files.
• init/: This directory contains the initialization and startup code.
• ipc/: This contains implementation of the Inter-Porcess Communication (IPC) mechanisms, such a messages queues, semaphores, and shared memory.
• kernel/: This directory contains architecture-independent portions of the base kernel.
• lib/: Library routines and some helper functions live here. They are: generic kernel objects (kobject) handlers and Cyclic Redundancy Code (CRC) computation functions, asn so on.
• mm/: This contains memory management code.
• net/: This contains networking protocols code.
• scripts/: This contains scripts and tools used during the kernel development.
• security/: This directory contains the security framework code.
• sound/: Audio subsystems code fall here.
• usr/: This currently contains the initramfs implementation.

Kernel configuration

In most of the cases, there will be no need to start a configuration from scratch. There are default and useful configuration files available in each arch directory, which you can use as a start point:

$ ls arch/<your:arch>/configs/

Example:

$ make x86_64_defconfig

$ make zImage -j16

$ make modules

$ sudo make INSTALL_MOD_PATH="/where/to/install" madules_install

If you want to use xconfig, first af all you will have to install QT4 tools:

$ sudo apt-get install qt4-dev-tools qt4-qmake

Build your Kernel

Building your kernel requires you to specify the architecture for which it is built for, as well as the compiler. That says, it is not necessary for a native build.

$ ARCH=arm make imx_v6_v7_defconfig

$ ARCH= arm CROSS_COMPILE=arm-linux-gnueabihf- make zImage -j16

From the kernel build, the result will be a single binary image, located in arch/arm/boot/. Modules are built with the following command:

$ ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make modules

You can install them using the following command:

$ sudo ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make modules_install

The modules_install target expects an enviroment variable, INSTALL_MOD_PATH, which specifies where you should install the modules. If not set, the modules will be installed at /lib/modules/$(KERNELRELEASE)/kernel/.

i.MX6 processors support device trees, which are files you use to describe the hardware. However, to compile every ARCH device tree, you can run the following command:

$ sudo ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make dtbs

The dtbs option, is not available on all platforms that support device tree. To build a standalone DTB, you should use:

$ sudo ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make imx6-sabrelite.dtb

Coding style

Yuo should always refere to the kernel codig style manual, at Documentation/CodingStyle in the kernel source tree. Most popular ones are:

• Always use tab indentation of 8 characters and the line should be 80 columns long. One can size the tabs and verify the line size using scripts/cleanfile script in from the kernel source:

$ scrpits/cleanfile my_module.c

• You can also indent the code correctly using the indent tool:

$ sudo apt-get install indent

$ scripts/indent mymodule.c

• Every function/variable that is not exported should be declared as static.
• No spaces should be added around (inside) parenthesized expressions.
• Using typedefs is forbidden.
• Always use /* this */ comment style, not //this.
• You should capitalise macros, but functional macros can be in lowercase.