LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    initrd

    
    
    

    CONFIGURATION

           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
           commands:
    
                   mknod -m 400 /dev/initrd b 1 250
                   chown root:disk /dev/initrd
    
           Also,  support  for  both "RAM disk" and "Initial RAM disk" (e.g., CON-
           FIG_BLK_DEV_RAM=y  and  CONFIG_BLK_DEV_INITRD=y)   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.
    
    
    

    DESCRIPTION

           The special file /dev/initrd is a read-only block device.  This  device
           is  a  RAM  disk  that is initialized (e.g., loaded) by the boot loader
           before the kernel is started.  The kernel then  can  use  /dev/initrd's
           contents for a two-phase system boot-up.
    
           In  the first boot-up phase, the kernel starts up and mounts an initial
           root filesystem from the contents of /dev/initrd (e.g., RAM  disk  ini-
           tialized  by the boot loader).  In the second phase, additional drivers
           or other modules are loaded from the initial  root  device's  contents.
           After  loading the additional modules, a new root filesystem (i.e., the
           normal root filesystem) is mounted from a different device.
    
       Boot-up operation
           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 the device /dev/ram0 as the ini-
              tial root filesystem.
    
           4. If the indicated normal root filesystem is  also  the  initial  root
              filesystem  (e.g., /dev/ram0) then the kernel skips to the last step
              for the usual boot sequence.
    
           5. If the executable file /linuxrc  is  present  in  the  initial  root
              filesystem,  /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 terminates, the normal
              root filesystem is mounted.  (If /linuxrc exits with any filesystems
    
           8. The  usual  boot  sequence  (e.g., invocation of /sbin/init) is per-
              formed on the normal root filesystem.
    
       Options
           The following boot loader options, when used with  initrd,  affect  the
           kernel's boot-up operation:
    
           initrd=filename
                  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 filesystem image.
    
           noinitrd
                  This  boot 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 filesystem image.  However,  device
                  /dev/initrd  is  read-only  and  can be read only one time after
                  system startup.
    
           root=device-name
                  Specifies the device to be used as the normal  root  filesystem.
                  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 filesystem.
    
       Changing the normal root filesystem
           By  default,  the  kernel's settings (e.g., set in the kernel file with
           rdev(8) or compiled into the kernel file), or the  boot  loader  option
           setting  is  used  for the normal root filesystems.  For an NFS-mounted
           normal  root  filesystem,  one  has  to  use  the   nfs_root_name   and
           nfs_root_addrs  boot options to give the NFS settings.  For more infor-
           mation on NFS-mounted root see the kernel documentation file Documenta-
           tion/filesystems/nfsroot.txt.  For more information on setting the root
           filesystem see also 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 /lin-
           uxrc write the new root filesystem device  number  into  /proc/sys/ker-
           nel/real-root-dev.   For  an  NFS  root  filesystem, the root device is
           changed  by  having  /linuxrc  write  the  NFS   setting   into   files
           /proc/sys/kernel/nfs-root-name  and /proc/sys/kernel/nfs-root-addrs and
               echo 255 >/proc/sys/kernel/real-root-dev
    
           Note:  The  use  of  /proc/sys/kernel/real-root-dev  to change the root
           filesystem is obsolete.  See the Linux kernel  source  file  Documenta-
           tion/initrd.txt as well as pivot_root(2) and pivot_root(8) for informa-
           tion on the modern method of changing the root filesystem.
    
       Usage
           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
              filesystem) and loads /dev/initrd with a gzipped version of the ini-
              tial filesystem.
    
           2. The executable /linuxrc determines what is needed to (1)  mount  the
              normal  root filesystem (i.e., device type, device drivers, filesys-
              tem) 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 filesystem.
    
           4. The  executable  /linuxrc creates and populates the root filesystem.
              (At this stage the normal root filesystem does not have to be a com-
              pleted system yet.)
    
           5. The executable /linuxrc sets /proc/sys/kernel/real-root-dev, unmount
              /proc, the normal root filesystem and any other filesystems  it  has
              mounted, and then terminates.
    
           6. The kernel then mounts the normal root filesystem.
    
           7. Now  that  the  filesystem is accessible and intact, the boot loader
              can be installed.
    
           8. The boot loader is configured to load into /dev/initrd a  filesystem
              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 installation tasks can be
              performed.
    
           The key role of /dev/initrd in the above is to reuse the  configuration
           data  during  normal  system operation without requiring initial kernel
           selection, a large generic kernel or, recompiling the kernel.
    
           easy installation from the CD-ROM.  The distribution 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.
    
    
    

    FILES

           /dev/initrd
           /dev/ram0
           /linuxrc
           /initrd
    
    
    

    NOTES

           1. With  the  current  kernel, any filesystems 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 filesystem 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.
    
    
    

    SEE ALSO

           chown(1), mknod(1), ram(4), freeramdisk(8), rdev(8)
    
           Documentation/initrd.txt in the Linux kernel source tree, the LILO doc-
           umentation, the LOADLIN documentation, the SYSLINUX documentation
    
    
    

    Linux 2010-09-04 INITRD(4)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz