dracut uses a modular system to build and extend the initramfs image.
All modules are located in /usr/lib/dracut/modules.d or in
<git-src>/modules.d. The most basic dracut module is 99base. In
99base the initial shell script init is defined, which gets run by
the kernel after initramfs loading. Although you can replace init
with your own version of 99base, this is not encouraged. Instead you
should use, if possible, the hooks of dracut. All hooks, and the
point of time in which they are executed, are described in the
section called “BOOT PROCESS STAGES”.
The main script, which creates the initramfs is dracut itself. It
parses all arguments and sets up the directory, in which everything
is installed. It then executes all check, install, installkernel
scripts found in the modules, which are to be processed. After
everything is installed, the install directory is archived and
compressed to the final initramfs image. All helper functions used by
check, install and installkernel are found in in the file
dracut-functions. These shell functions are available to all module
installer (install, installkernel) scripts, without the need to
A module can check the preconditions for install and installkernel
with the check script. Also dependencies can be expressed with check.
If a module passed check, install and installkernel will be called to
install all of the necessary files for the module. To split between
kernel and non-kernel parts of the installation, all kernel module
related parts have to be in installkernel. All other files found in a
module directory are module specific and mostly are hook scripts and
dracut modules can insert custom script at various points, to control
the boot process. These hooks are plain directories containing shell
scripts ending with ".sh", which are sourced by init. Common used
functions are in dracut-lib.sh, which can be sourced by any script.
The cmdline hook is a place to insert scripts to parse the kernel
command line and prepare the later actions, like setting up udev
rules and configuration files.
In this hook the most important environment variable is defined:
root. The second one is rootok, which indicates, that a module
claimed to be able to parse the root defined. So for example,
root=iscsi:.... will be claimed by the iscsi dracut module, which
then sets rootok.
This hook is executed right after the cmdline hook and a check if
root and rootok were set. Here modules can take action with the final
root, and before udev has been run.
Now udev is started and the logging for udev is setup.
In this hook, you can set udev environment variables with udevadmcontrol --property=KEY=value or control the further execution of udev
udev is triggered by calling udevadm trigger, which sends add events
for all devices and subsystems.
In the main loop of dracut loops until udev has settled and all
scripts in initqueue/finished returned true. In this loop there are
three hooks, where scripts can be inserted by calling
This hook gets executed every time a script is inserted here,
regardless of the udev state.
This hooks (initqueue/settled) gets executed every time udev has
This hooks (initqueue/timeout) gets executed, when the main loop
counter becomes half of the rd.retry counter.
This hook (initqueue/finished) is called after udev has settled
and if all scripts herein return 0 the main loop will be ended.
Abritary scripts can be added here, to loop in the initqueue
until something happens, which a dracut module wants to wait for.
Before the root device is mounted all scripts in the hook pre-mount
are executed. In some cases (e.g. NFS) the real root device is
already mounted, though.
This hook is mainly to mount the real root device.
This hook is called before cleanup hook, This is a good place for
actions other than cleanups which need to be called before pivot.
This hook is the last hook and is called before init finally switches
root to the real root device. This is a good place to clean up and
kill processes not needed anymore.
Cleanup and switch_root
Init (or systemd) kills all udev processes, cleans up the
environment, sets up the arguments for the real init process and
finally calls switch_root. switch_root removes the whole filesystem
hierarchy of the initramfs, chroot()s to the real root device and
calls /sbin/init with the specified arguments.
To ensure all files in the initramfs hierarchy can be removed, all
processes still running from the initramfs should not have any open
file descriptors left.
A simple example module is 96insmodpost, which modprobes a kernel
module after udev has settled and the basic device drivers have been
All module installation information is in the file module-setup.sh.
First we create a check() function, which just exits with 0
indicating that this module should be included by default.
The we create the install() function, which installs a cmdline hook
with priority number 20 called parse-insmodpost.sh. It also installs
the insmodpost.sh script in /sbin.
inst_hook cmdline 20 "$moddir/parse-insmodpost.sh"
inst_simple "$moddir/insmodpost.sh" /sbin/insmodpost.sh
The parse-instmodpost.sh parses the kernel command line for a
argument rd.driver.post, blacklists the module from being autoloaded
and installs the hook insmodpost.sh in the initqueue/settled.
for p in $(getargs rd.driver.post=); do
echo "blacklist $p" >> /etc/modprobe.d/initramfsblacklist.conf
[ -n "$_do_insmodpost" ] && /sbin/initqueue --settled --unique --onetime /sbin/insmodpost.sh
insmodpost.sh, which is called in the initqueue/settled hook will
just modprobe the kernel modules specified in all rd.driver.post
kernel command line parameters. It runs after udev has settled and is
only called once (--onetime).
for p in $(getargs rd.driver.post=); do
module-setup.sh: check()check() is called by dracut to evaluate the inclusion of a dracut
module in the initramfs.
If the $hostonly variable is set, then the module check()
function should be in "hostonly" mode, which means, that the
check() should only return 0, if the module is really needed to
boot this specific host.
check() should return with:
Include the dracut module in the initramfs.
Do not include the dracut module. The requirements are not
fullfilled (missing tools, etc.)
Only include the dracut module, if another module requires it or
if explicitly specified in the config file or on the argument
The function depends() should echo all other dracut module names the
module depends on.
This function should print the kernel command line options needed to
boot the current machine setup. It should start with a space and
should not print a newline.
The install() function is called to install everything non-kernel
related. To install binaries, scripts, and other files, you can use
the functions mentioned in [creation].
To address a file in the current module directory, use the variable
In installkernel() all kernel related files should be installed. You
can use all of the functions mentioned in [creation] to install
Creation Functionsinst_multiple [-o] <file> [ <file> ...]
installs multiple binaries and files. If executables are
specified without a path, dracut will search the path
PATH=/usr/sbin:/sbin:/usr/bin:/bin for the binary. If the option
"-o" is given as the first parameter, a missing file does not
lead to an error.
inst <src> [<dst>]
installs one file <src> either to the same place in the initramfs
or to an optional <dst>.
inst_hook <hookdir> <prio> <src>
installs an executable/script <src> in the dracut hook <hookdir>
with priority <prio>.
inst_rules <udevrule> [ <udevrule> ...]
installs one ore more udev rules. Non-existant udev rules are
reported, but do not let dracut fail.
instmods <kernelmodule> [ <kernelmodule> ... ]
instmods should be used only in the installkernel() function.
instmods installs one or more kernel modules in the initramfs.
<kernelmodule> can also be a whole subsystem, if prefixed with a
"=", like "=drivers/net/team".
instmods will not install the kernel module, if $hostonly is set
and the kernel module is not currently needed by any
/sys/.../uevent MODALIAS. To install a kernel module regardless
of the hostonly mode use the form:
hostonly='' instmods <kernelmodule>
This page is part of the dracut (event driven initramfs
infrastructure) project. Information about the project can be found
at ⟨https://dracut.wiki.kernel.org/index.php/Main_Page⟩. If you have
a bug report for this manual page, send it to
email@example.com. This page was obtained from the project's
upstream Git repository
⟨git://git.kernel.org/pub/scm/boot/dracut/dracut.git⟩ on 2017-04-25.
If you discover any rendering problems in this HTML version of the
page, or you believe there is a better or more up-to-date source for
the page, or you have corrections or improvements to the information
in this COLOPHON (which is not part of the original manual page),
send a mail to firstname.lastname@example.org
dracut 02/18/2017 DRACUT.MODULES(7)