Initramfs/Guide/en

More and more systems require an initramfs to boot up properly. In this guide, we tackle the concepts of the initramfs as well as how to properly create and manage initramfs instances.

Introduction
For many users, an initramfs system is of no concern. Their system uses a simple partitioning schema with no exotic drivers or setups (like encrypted file systems), so the Linux kernel is well able to hand over control to the  binary on their system. But for many systems, an initramfs is almost mandatory.

The key concept to understanding what an initramfs is (or is needed for) is to understand how the Linux boot process works, even in a high-level approach.

Linux boot process
Once the Linux kernel has control over the system (which it gets after being loaded by the boot loader), it prepares its memory structures and drivers as well as it can. It then hands over control to an application (usually ) whose task it is to further prepare the system and make sure that, at the end of the boot process, all necessary services are running and the user is able to log on. The  application does that by launching, among other services, the   daemon who will further load up and prepare the system based on the detected devices. When  is launched, all remaining file systems that have not been mounted are mounted, and the remainder of services is started.

For systems where all necessary files and tools reside on the same file system, the  application can perfectly control the further boot process. But when multiple file systems are defined (or more exotic installations are done), this might become a bit more tricky:


 * When the partition is on a separate file system, tools and drivers that have files stored within  cannot be used unless  is available. If those tools are needed to make  available, then we cannot boot up the system.


 * If the root file system is encrypted, then the Linux kernel will not be able to find the  application, resulting in an unbootable system.

The solution for this problem has since long been to use an initrd (initial root device).

The initial root disk
The initrd is an in-memory disk structure (ramdisk) that contains the necessary tools and scripts to mount the needed file systems before control is handed over to the  application on the root file system. The Linux kernel triggers the setup script (usually called  but that is not mandatory) on this root disk, which prepares the system, switches to the real root file system and then calls.

Although the initrd method is all that is needed, it had a few drawbacks:


 * It is a full-fledged block device, requiring the overhead of an entire file system on it, and has a fixed size. Choose an initrd that is too small, and you won't be able to fit in all needed scripts. Make it too big, and you're wasting memory.


 * Because it is a real device, it also consumes cache memory in the Linux kernel and is prone to the memory- and file management methods in use (such as paging), making it even worse in memory consumption.

To resolve these (for some perhaps hardly called) problems, the initramfs was created.

The initial ram file system
An initramfs is an initial ram file system based on tmpfs (a size-flexible, in-memory lightweight file system), which also didn't use a separate block device (so no caching was done and all overhead mentioned earlier disappears). Just like the initrd, it contains the tools and scripts needed to mount the file systems before the  binary on the real root file system is called. These tools can be decryption abstraction layers (for encrypted file systems), logical volume managers, software raid, bluetooth driver based file system loaders, etc.

The content of the initramfs is made by creating a cpio archive. is an old (but proven) file archiver solution (and its resulting archive files are called cpio files). You can definitely compare it to. The choice of  here was because it is easier to implement (code-wise) and supported (back then) device files (which   couldn't).

All files, tools, libraries, configuration settings (if applicable), etc. are put into the cpio archive. This archive is then compressed using the  utility and stored alongside the Linux kernel. The boot loader will then offer it to the Linux kernel at boot time so the kernel knows an initramfs is needed.

Once detected, the Linux kernel will create a tmpfs file system, extract the contents of the archive on it, and then launches the  script located in the root of the tmpfs file system. This script will then mount the real root file system (after making sure it can mount it, for instance by loading additional modules, preparing an encryption abstraction layer, etc.) as well as vital other file systems (such as and  ).

Once the root file system and the other vital file systems are mounted, the  script from the initramfs will switch the root towards the real root file system and finally call the   on that system to continue the boot process.

Introduction and bootloader configuration
To create an initramfs, it is important that you know what additional drivers, scripts and tools you need to boot your system. For instance, if you use LVM, then you will need to support LVM tools on the initramfs. Likewise, if you use software RAID, you need, etc.

Some tools exist that help you create initramfs' (compressed  archives) for your system. But for those that want total control, you can easily create your own initramfs as well.

Once created, you will need to adjust the bootloader configuration to tell it that an initramfs is to be used. For instance, if the initramfs file is stored as, then the configuration in  could look like so:

Using genkernel
Gentoo's kernel building utility,, can be used to generate an initramfs, even if you didn't use   to configure and build your kernel.

To use  for generating an initramfs, it is recommended that you include all necessary drivers and code that is needed to mount your  and  file systems in the kernel (and not as modules). Then, call genkernel as follows:

Depending on your system, you might want to add one or more of the following options:

When finished, the resulting initramfs file will be stored in your.

Using dracut
The  utility is created for the sole purpose of managing initramfs files. It uses a highly modular approach on which support you want to include and which not.

When you install, you will need to take care to include support for the correct. This is a variable you can set in to include support for specific setups:

It is advisable to set (or unset) those modules you need (and don't need). Afterwards, emerge dracut to install the Dracut utility on your system.

The next step is to configure  by editing. In the configuration file, which is well commented, you can add in support for specific modules where needed.

Once configured, create an initramfs by calling dracut as follows:

The resulting image supports generic system boots based on the configuration in. You can also opt to generate an initramfs specifically tailored to your system (in which  tries to detect the needed tools, drivers, etc. from your existing system). If you know that the needed support (code and drivers) is built into your kernel (and not as module), then you can add the --no-kernel option:

For more information, check out the  and   manual pages.

Gentoo-specific

 * Initramfs on the official Gentoo Wiki
 * Dracut on the official Gentoo Wiki