# /initrd

    initrd provides the capability to load a RAM disk by the boot
    loader. This RAM disk can then be mounted as the root file
    system and programs can be run from it. Afterwards, a new
    root file system can be mounted from a different device. The
    previous root (from initrd) is then moved to a directory and
    can be subsequently unmounted.

    initrd is mainly designed to allow system startup to occur
    in two phases, where the kernel comes up with a minimum set
    of compiled-in drivers, and where additional modules are
    loaded from initrd.

    Operation
    ---------

    When using initrd, the system typically boots as follows:

     1) the boot loader loads the kernel and the initial RAM disk
     2) the kernel converts initrd into a "normal" RAM disk and
        frees the memory used by initrd
     3) initrd is mounted read-write as root
     4) /linuxrc is executed (this can be any valid executable,
     including shell scripts; it is run with uid 0 and can do
     basically everything init can do)
     5) linuxrc mounts the "real" root file system
     6) linuxrc places the root file system at the root directory
        using the pivot_root system call
     7) the usual boot sequence (e.g. invocation of /sbin/init) is
        performed on the root file system
     8) the initrd file system is removed

    Note that changing the root directory does not involve unmounting
    it. It is therefore possible to leave processes running on initrd
    during that procedure. Also note that file systems mounted under
    initrd continue to be accessible.

    Usage scenarios
    ---------------

    The main motivation for implementing initrd was to allow
    for modular kernel configuration at system installation.
    The procedure would work as follows:

     1) system boots from floppy or other media with a minimal kernel
        (e.g. support for RAM disks, initrd, a.out, and the Ext2 FS)
        and loads initrd
     2) /linuxrc determines what is needed to (1) mount the "real" root
        FS (i.e. device type, device drivers, file system) and (2) the
        distribution media (e.g. CD-ROM, network, tape, ...). This can
        be done by asking the user, by auto-probing, or by using a
        hybrid approach.
     3) /linuxrc loads the necessary kernel modules
     4) /linuxrc creates and populates the root file system (this
        doesn't have to be a very usable system yet)
     5) /linuxrc invokes pivot_root to change the root file system and
        execs - via chroot - a program that continues the installation
     6) the boot loader is installed
     7) the boot loader is configured to load an initrd with the set of
        modules that was used to bring up the system (e.g. /initrd can
        be modified, then unmounted, and finally, the image is written
        from /dev/ram0 or /dev/rd/0 to a file)
     8) now the system is bootable and additional installation tasks
        can be performed

    The key role of initrd here is to re-use the configuration data
    during normal system operation without requiring the use of a
    bloated "generic" kernel or re-compiling or re-linking the kernel.

    A second scenario is for installations where Linux runs on systems
    with different hardware configurations in a single administrative
    domain. In such cases, it is desirable to generate only a small set
    of kernels (ideally only one) and to keep the system-specific part
    of configuration information as small as possible. In this case, a
    common initrd could be generated with all the necessary modules.
    Then, only /linuxrc or a file read by it would have to be different.

    A third scenario are more convenient recovery disks, because
    information like the location of the root FS partition doesn't have
    to be provided at boot time, but the system loaded from initrd can
    invoke a user-friendly dialog and it can also perform some sanity
    checks (or even some form of auto-detection).

    Last not least, CD-ROM distributors may use it for better installation
    from CD, e.g. by using a boot floppy and bootstrapping a bigger RAM disk
    via initrd from CD; or by booting via a loader like LOADLIN or directly
    from the CD-ROM, and loading the RAM disk from CD without need of floppies.