Provided by: dracut-core_048+80-2_amd64 bug


       dracut.modules - dracut modules


       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 source dracut-functions.

       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 udev rules.


       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, which can be sourced by any

   Hook: cmdline
       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

   Hook: pre-udev
       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.

   Start Udev
       Now udev is started and the logging for udev is setup.

   Hook: pre-trigger
       In this hook, you can set udev environment variables with udevadm control
       --property=KEY=value or control the further execution of udev with udevadm.

   Trigger Udev
       udev is triggered by calling udevadm trigger, which sends add events for all devices and

   Main Loop
       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 /sbin/initqueue.

           This hook gets executed every time a script is inserted here, regardless of the udev

       Initqueue settled
           This hooks (initqueue/settled) gets executed every time udev has settled.

       Initqueue timeout
           This hooks (initqueue/timeout) gets executed, when the main loop counter becomes half
           of the rd.retry counter.

       Initqueue finished
           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

   Hook: pre-mount
       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.

   Hook: mount
       This hook is mainly to mount the real root device.

   Hook: pre-pivot
       This hook is called before cleanup hook, This is a good place for actions other than
       cleanups which need to be called before pivot.

   Hook: cleanup
       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 loaded.

       All module installation information is in the file

       First we create a check() function, which just exits with 0 indicating that this module
       should be included by default.


           return 0

       The we create the install() function, which installs a cmdline hook with priority number
       20 called It also installs the script in /sbin.


           inst_hook cmdline 20 "$moddir/"
           inst_simple "$moddir/" /sbin/

       The parses the kernel command line for a argument,
       blacklists the module from being autoloaded and installs the hook in the

           for p in $(getargs; do
               echo "blacklist $p" >> /etc/modprobe.d/initramfsblacklist.conf

           [ -n "$_do_insmodpost" ] && /sbin/initqueue --settled --unique --onetime /sbin/
           unset _do_insmodpost, which is called in the initqueue/settled hook will just modprobe the kernel
       modules specified in all kernel command line parameters. It runs after udev
       has settled and is only called once (--onetime).

           . /lib/

           for p in $(getargs; do
               modprobe $p
           done 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,

           Only include the dracut module, if another module requires it or if explicitly
           specified in the config file or on the argument list. depends()
       The function depends() should echo all other dracut module names the module depends on. cmdline()
       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. install()
       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 "$moddir". installkernel()
       In installkernel() all kernel related files should be installed. You can use all of the
       functions mentioned in [creation] to install files.

   Creation Functions
       inst_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 with more than two arguments is treated the same as inst_multiple, all
           arguments are treated as files to install and none as install destinations.

       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>

   Initramfs Functions

   Network Modules


       Harald Hoyer