INITRD(4)           Linux Programmer's Manual           INITRD(4)

       initrd - boot loader initialized RAM disk

       The  special file /dev/initrd is a read-only block device.
       Device /dev/initrd is a RAM disk that is initialized (e.g.
       loaded)  by  the boot loader before the kernel is started.
       The kernel then can use the the block device /dev/initrd's
       contents for a two phased system boot-up.

       In  the  first  boot-up  phase,  the  kernel starts up and
       mounts an initial root file-system from  the  contents  of
       /dev/initrd   (e.g.  RAM  disk  initialized  by  the  boot
       loader).  In the second phase, additional drivers or other
       modules  are  loaded  from  the initial root device's con-
       tents.  After loading the additional modules, a  new  root
       file  system (i.e. the normal root file system) is mounted
       from a different device.

       When booting up with initrd, the system boots as follows:

         1.  The  boot  loader  loads  the  kernel  program   and
         /dev/initrd's contents into memory.

         2. On kernel startup, the kernel uncompresses and copies
         the contents  of  the  device  /dev/initrd  onto  device
         /dev/ram0 and then frees the memory used by /dev/initrd.

         3. The kernel then read-write mounts device /dev/ram0 as
         the initial root file system.

         4.  If the indicated normal root file system is also the
         initial root file-system (e.g.   /dev/ram0  )  then  the
         kernel  skips  to  the  last  step  for  the  usual boot

         5. If the executable file /linuxrc  is  present  in  the
         initial  root file-system, /linuxrc is executed with uid
         0.  (The file /linuxrc must have executable  permission.
         The file /linuxrc can be any valid executable, including
         a shell script.)

         6. If /linuxrc is not executed or when  /linuxrc  termi-
         nates,  the  normal  root  file  system is mounted.  (If
         /linuxrc exits with any file-systems mounted on the ini-
         tial  root  file-system, then the behavior of the kernel
         is UNSPECIFIED.  See the NOTES section for  the  current
         kernel behavior.)

         7. If the normal root file has directory /initrd, device
         /dev/ram0 is moved from  /  to  /initrd.   Otherwise  if
         directory  /initrd  does  not  exist device /dev/ram0 is
         unmounted.  (When moved from / to /initrd, /dev/ram0  is
         not unmounted and therefore processes can remain running
         from /dev/ram0.  If directory /initrd does not exist  on
         the  normal  root  file-system  and any processes remain
         running from /dev/ram0 when /linuxrc exits, the behavior
         of the kernel is UNSPECIFIED.  See the NOTES section for
         the current kernel behavior.)

         8.  The  usual  boot  sequence   (e.g.   invocation   of
         /sbin/init) is performed on the normal root file system.

       The following boot loader options when used  with  initrd,
       affect the kernel's boot-up operation:

              Specifies  the  file  to  load  as  the contents of
              /dev/initrd.  For LOADLIN this is  a  command  line
              option.   For  LILO you have to use this command in
              the LILO configuration file /etc/lilo.config.   The
              filename  specified with this option will typically
              be a gzipped file-system image.

              This boot time option disables the two phase  boot-
              up  operation.   The kernel performs the usual boot
              sequence as if  /dev/initrd  was  not  initialized.
              With  this  option,  any  contents  of  /dev/initrd
              loaded into memory by the boot loader contents  are
              preserved.   This  option  permits  the contents of
              /dev/initrd to be any data and need not be  limited
              to  a file system image.  However, device /dev/ini-
              trd is read-only and can  be  read  only  one  time
              after system startup.

              Specifies  the device to be used as the normal root
              file system.  For LOADLIN this is  a  command  line
              option.  For LILO this is a boot time option or can
              be used as an option line in the LILO configuration
              file /etc/lilo.config.  The device specified by the
              this option must be a  mountable  device  having  a
              suitable root file-system.

       By  default, the kernel's settings (e.g. set in the kernel
       file with rdev or compiled into the kernel file),  or  the
       boot  loader  option  setting  is used for the normal root
       file systems.  For a NFS-mounted normal root file  system,
       one  has  to use the nfs_root_name and nfs_root_addrs boot
       options to give the NFS settings.  For more information on
       NSF-mounted  root  see  the kernel documentation file nfs-
       root.txt.  For more information on setting the  root  file
       system also see the LILO and LOADLIN documentation.

       It  is also possible for the /linuxrc executable to change
       the normal root device.  For /linuxrc to change the normal
       root device, /proc must be mounted.  After mounting /proc,
       /linuxrc changes the normal root device  by  writing  into
       the     proc     files     /proc/sys/kernel/real-root-dev,
       /proc/sys/kernel/nfs-root-name, and  /proc/sys/kernel/nfs-
       root-addrs.   For  a physical root device, the root device
       is changed by having /linuxrc write the new root file sys-
       tem  device  number  into  /proc/sys/kernel/real-root-dev.
       For a NSF root file system, the root device is changed  by
       having   /linuxrc   write   the  NSF  setting  into  files
       /proc/sys/kernel/nfs-root-name  and  /proc/sys/kernel/nfs-
       root-addrs  and  then  writing  0xff (e.g. the pseudo-NFS-
       device number) into  file  /proc/sys/kernel/real-root-dev.
       For example, the following shell command line would change
       the normal root device to /dev/hdb1:
               echo 0x365 >/proc/sys/kernel/real-root-dev
       For a NSF example, the following shell command lines would
       change  the  normal  root  device  to  the  NSF  directory
       /var/nfsroot on a local networked NSF server with IP  num-
       ber  for  a system with IP number
       and named 'idefix':
            echo /var/nfsroot >/proc/sys/kernel/nfs-root-name
            echo \
            echo 255 >/proc/sys/kernel/real-root-dev

       The main motivation for implementing initrd was  to  allow
       for modular kernel configuration at system installation.

       A possible system installation scenario is as follows:

         1.  The  loader program boots from floppy or other media
         with  a  minimal  kernel  (e.g.  support  for  /dev/ram,
         /dev/initrd,   and   the  ext2  file-system)  and  loads
         /dev/initrd with a gzipped version of the initial  file-

         2.  The executable /linuxrc determines what is needed to
         (1) mount the normal root file-system (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. The executable /linuxrc loads the  necessary  modules
         from the initial root file-system.

         4.  The  executable  /linuxrc  creates and populates the
         root file system.  (At this stage the normal  root  file
         system does not have to be a completed system yet.)

         5.  The  executable /linuxrc sets /proc/sys/kernel/real-
         root-dev, unmount /proc, the normal root file system and
         any  other  file systems it has mounted, and then termi-

         6. The kernel then mounts the normal root file system.

         7. Now that the file system is  accessible  and  intact,
         the boot loader can be installed.

         8.  The boot loader is configured to load into /dev/ini-
         trd a file system with the set of modules that was  used
         to  bring  up the system.  (e.g. Device /dev/ram0 can be
         modified, then unmounted,  and  finally,  the  image  is
         written from /dev/ram0 to a file.)

         9.  The  system is now bootable and additional installa-
         tion tasks can be performed.

       The key role of /dev/initrd in the above is to re-use  the
       configuration  data during normal system operation without
       requiring initial kernel selection, a large generic kernel
       or, recompiling the kernel.

       A second scenario is for installations where Linux runs on
       systems with different hardware configurations in a single
       administrative  network.   In such cases, it may be desir-
       able to use 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, create  a
       common  file  with all needed modules.  Then, only the the
       /linuxrc file or a file executed by /linuxrc would be dif-

       A  third  scenario  is  more  convenient  recovery  disks.
       Because information like the location of  the  root  file-
       system  partition  is  not needed at boot time, the system
       loaded from /dev/initrd can  use  a  dialog  and/or  auto-
       detection followed by a possible sanity check.

       Last  but not least, Linux distributions on CD-ROM may use
       initrd for easy installation from the CD-ROM.  The distri-
       bution  can  use LOADLIN to directly load /dev/initrd from
       CD-ROM without the need of any floppies.  The distribution
       could  also  use  a  LILO boot floppy and then bootstrap a
       bigger ram disk via /dev/initrd from the CD-ROM.

       The /dev/initrd is a read-only block device assigned major
       number  1  and minor number 250.  Typically /dev/initrd is
       owned by root.disk with mode 0400  (read  access  by  root
       only).   If  the  Linux  system  does not have /dev/initrd
       already created, it can be created with the following com-

               mknod -m 400 /dev/initrd b 1 250
               chown root:disk /dev/initrd

       Also,  support  for both "RAM disk" and "Initial RAM disk"
       support must be compiled directly into the Linux kernel to
       use /dev/initrd.  When using  /dev/initrd,  the  RAM  disk
       driver cannot be loaded as a module.


       chown(1),  mknod(1), /dev/ram(4), freeramdisk(8), rdev(8),
       The documentation file initrd.txt  in  the  kernel  source
       package,  the  LILO  documentation, the LOADLIN documenta-
       tion, the SYSLINUX documentation.

       1. With the current kernel, any file systems  that  remain
       mounted when /dev/ram0 is moved from / to /initrd continue
       to be accessible.  However, the /proc/mounts  entries  are
       not updated.

       2.  With the current kernel, if directory /initrd does not
       exist, then /dev/ram0  will  NOT  be  fully  unmounted  if
       /dev/ram0  is  used  by any process or has any file-system
       mounted on it.  If /dev/ram0 is NOT fully unmounted,  then
       /dev/ram0 will remain in memory.

       3.  Users of /dev/initrd should not depend on the behavior
       give in the above  notes.   The  behavior  may  change  in
       future versions of the Linux kernel.

       The  kernel  code  for device initrd was written by Werner
       Almesberger <> and Hans  Lermen  <ler->.  The code for initrd was added to
       the baseline Linux kernel in development version 1.3.73.

Linux 2.0                6 November 1997                        1