Making initramfs image with Yocto

Embedded systems can have different types of persistent (non-volatile) storage, like eMMC, SD card, NOR or NAND flash memory. Each storage type has advantages and disadvantages with regards to the read/write speed, cost per amount of data that can be stored, number of write cycles, etc.

The non-volatile memory is needed to store the root filesystem, as well as certain configuration data. The root filesystem stored in the memory can be used in different ways. It can be used as read-write, in which case rootfs partition is modified directly and keeps the changes between the boots, but it can also be configured so rootfs contents are always the same on boot and every change that is made does not persist.

In the previous posts the rootfs was placed on the SD card and configured to have read-only and writable parts. Using the SD card image is practical, since it resembles the way development would be performed on the real hardware, and it also can have rather large sizes (we used 1GB and 2GB images, but much larger SD card images can be used).

Sometimes it is useful having a small footprint rootfs that can be stored in smaller capacity memory devices, like NAND or NOR flash memory. In this situation, bundling the minimal rootfs in an initramfs or using rootfs from ramdisk can be useful. Initramfs can also be bundled with the Linux kernel, while ramdisk has to be passed as a separate binary file from U-Boot (unless fitimage format is used).

In this post the steps for making a Linux kernel bundled with initramfs for Cubieboard using Yocto will be shown.

All of the changes that will be described, plus a few more which are required for this to work, are available in the scarthgap branch of meta-mistra repository in Github.

The following items will be covered in this post

• Yocto initramfs image
  • Init system
  • New DISTRO configuration
  • Reducing kernel size
  • Custom image
    • Init script
• Testing
• Summary

Yocto initramfs image

Yocto supports making an initramfs image and bundling it with the Linux kernel, as described in the official documentation. Since initramfs image is bundled with the kernel, once kernel image is loaded, it will also extract and mount the rootfs in RAM memory.

Certain configuration options have to be specified in one of the configuration files, either the global local.conf, or machine or distro specific configuration files.

Most of the instructions usually go for local.conf since it is the easiest, but it is also harder to maintain. Choosing either machine or distro configuration file is a better option, since it allows for fine grained control and configuration.

The configuration options to enable initramfs image creation and bundling with the kernel image are

• INITRAMFS_IMAGE - specifies image file to use for initramfs
• INITRAMFS_IMAGE_BUNDLE - can be set to 0 or 1, 1 indicates that the initramfs should be bundled

Additionally, the Linux kernel should support GZip compression for the initramfs, so following options need to be enabled

CONFIG_RD_GZIP=y
CONFIG_INITRAMFS_COMPRESSION_GZIP=y

and U-Boot should be configured to support bigger kernel image (since initramfs is bundled) using

CONFIG_SYS_BOOTM_LEN=0x1000000

The goal with the initramfs is to have a small size rootfs, so certain design choices have to be made.

Init system

In the previous posts, systemd was used as the init system. Systemd is a modern choice, used by many distributions and has various built-in features.

However, those built-in features come with high memory footprint. The systemd recipe in Yocto can be tweaked by removing unused features using PACKAGECONFIG to reduce size. However, it will still use more memory than some of the other init system approaches.

Another approach would be to skip adding the init system completely. The goal with the initramfs is to execute only predefined functions, so init system is not required. This, however, requires more effort from the initramfs designer, since some things that are usually handled by the init system will have to be done manually, like creation and mounting of standard filesystems at boot time, or device discovery using mdev or devtmpfs instead of udev.

In order to configure that no init system is used, following setting needs to be applied to a conf file

INIT_SYSTEM=none

Since we will have two different build variants, with different init systems, it makes sense to use different DISTROs for the regular and initramfs types of build.

New DISTRO configuration

In this post a new DISTRO configuration will be created for the initramfs build. The DISTRO is chosen since we are indeed creating a different configuration for this type of image, but it also comes with certain implications.

The excerpt of the new DISTRO configuration is shown below.

# Mistra Distro for initramfs
require conf/distro/include/mistra-base.inc

INIT_MANAGER = "none"

DISTRO = "mistra-recovery"
DISTRO_NAME = "Mistra Recovery"
DISTROOVERRIDES =. "mistra-recovery:"

# Remove conflicting backends.
DISTRO_FEATURES:remove = "x11 wayland directfb vulkan opengl"
# Add usrmerge to features
DISTRO_FEATURES:append = "\
    usrmerge \
"

# Bundle rootfs image with kernel
INITRAMFS_IMAGE_BUNDLE="1"
INITRAMFS_IMAGE="mistra-initramfs"

The biggest thing to keep in mind when using a new DISTRO is that the new build directory should be used, so more space will be used on the build machine.

Reducing kernel size

Compared to the standard distribution which should support many functionalities and different hardware drivers and functions, the initramfs distribution can fulfill it’s purpose with much less hardware support. Therefore, kernel configuration for the use with initramfs image can be customized.

Yocto provides convenience options for editing the kernel configuration. The following command

bitbake virtual/kernel -c menuconfig

opens the ncurses menuconfig window, same as if the make menuconfig were executed from the kernel source code directory.

After the configuration is ready, the defconfig file which can be included in the layer recipes can be generated using

bitbake virtual/kernel -c savedefconfig

This command will print a path information on where the defconfig file is saved so it can be used later on.

For the purpose of this post, several kernel configuration options are disabled, like Video/Graphics and USB support.

The defconfig file is placed in the recipes-kernel/linux/linux-mainline/mistra-recovery/ directory, so it will be used only when the initramfs image is built.

Custom image

Same as with the kernel, the image recipe that will be used for the initramfs image needs only the necessary items. The recipe is shown here and it is based on the core-image-minimal-initramfs.

require recipes-core/images/core-image-minimal.bb
INITRAMFS_SCRIPTS ?= "\
    initramfs-boot \
"
PACKAGE_INSTALL = " \
    ${INITRAMFS_SCRIPTS} \
    ${VIRTUAL-RUNTIME_base-utils} \
    base-passwd \
    ${ROOTFS_BOOTSTRAP_INSTALL} \
"
# Do not pollute the initrd image with rootfs features
IMAGE_FEATURES = ""
# Don't allow the initramfs to contain a kernel
PACKAGE_EXCLUDE = "kernel-image-*"
IMAGE_NAME_SUFFIX ?= ""
IMAGE_LINGUAS = ""
LICENSE = "MIT"
IMAGE_FSTYPES = "${INITRAMFS_FSTYPES}"
inherit core-image
IMAGE_ROOTFS_SIZE = "8192"
IMAGE_ROOTFS_EXTRA_SPACE = "0"

One thing to note is that the kernel image is removed from the initramfs image, since initramfs will be bundled with the kernel.

Init script

Initramfs requires a init file placed in /init, which will be executed automatically on boot. That file needs to contain commands for different configuration, like creating and mounting filesystems, etc.

In our case we will use the script already provided with Yocto for the simple boot to shell.

#!/bin/sh

PATH=/sbin:/bin:/usr/sbin:/usr/bin

mkdir /proc
mkdir /sys
mount -t proc proc /proc
mount -t sysfs sysfs /sys

exec sh

Essentially, when the system boots it will drop into a shell. There will be no init system nor job control, so exiting the shell will cause kernel panic.

Testing

For testing we are going to build the initramfs and then run it in QEMU. Since new DISTRO is defined, we need to create a new build directory, so the steps for triggering a build would be

. ./setup-environment build_recovery
DISTRO=mistra-recovery MACHINE=cubieboard-ng bitbake mistra-initramfs

Once build is complete, the kernel image with bundled initramfs will be in tmp/deploy/images/mistra-recovery/uImage-initramfs-cubieboard-ng.bin

For testing we just need to use that initramfs bundle as the -kernel parameter and configure console parameter to be passed to the kernel.

qemu-system-arm \
  -M cubieboard \
  -m 1G \
  -kernel uImage-initramfs-cubieboard-ng.bin \
  -dtb sun4i-a10-cubieboard.dtb \
  -nographic \
  -append "console=ttyS0"

[    0.000000] Booting Linux on physical CPU 0x0
[    0.000000] Linux version 6.6.28 (oe-user@oe-host) (arm-mistra-linux-gnueabi-gcc (GCC) 13.3.0, GNU ld (GNU Binutils) 2.42.0.20240620) #1 SMP Wed Apr 17 09:19:38 UTC 2024
[    0.000000] CPU: ARMv7 Processor [410fc080] revision 0 (ARMv7), cr=10c5387d
...
[    0.722588] Freeing unused kernel image (initmem) memory: 3072K
[    0.724355] Run /init as init process
sh: can't access tty; job control turned off
~ # uname -a
Linux (none) 6.6.28 #1 SMP Wed Apr 17 09:19:38 UTC 2024 armv7l GNU/Linux

Summary

In this post the Yocto configuration for building a simple initramfs image is shown. The kernel image with the rootfs is loaded in the QEMU using the -kernel parameter.

The init script that is used is basic, only used to execute the shell. In the real use case the script would do some specific work and could either reboot the system or load a rootfs from another storage.

The initramfs image also takes up only 6MB (1.2MB rootfs and the rest is kernel, which can be further optimized), so it is suitable for use in cases where small amount of memory is available.