Documentation/filesystems/ramfs-rootfs-initramfs.txt

   1 ramfs, rootfs and initramfs
   2 October 17, 2005
   3 Rob Landley <rob@landley.net>
   4 =============================
   5
   6 What is ramfs?
   7 --------------
   8
   9 Ramfs is a very simple filesystem that exports Linux's disk caching
  10 mechanisms (the page cache and dentry cache) as a dynamically resizable
  11 ram-based filesystem.
  12
  13 Normally all files are cached in memory by Linux.  Pages of data read from
  14 backing store (usually the block device the filesystem is mounted on) are kept
  15 around in case it's needed again, but marked as clean (freeable) in case the
  16 Virtual Memory system needs the memory for something else.  Similarly, data
  17 written to files is marked clean as soon as it has been written to backing
  18 store, but kept around for caching purposes until the VM reallocates the
  19 memory.  A similar mechanism (the dentry cache) greatly speeds up access to
  20 directories.
  21
  22 With ramfs, there is no backing store.  Files written into ramfs allocate
  23 dentries and page cache as usual, but there's nowhere to write them to.
  24 This means the pages are never marked clean, so they can't be freed by the
  25 VM when it's looking to recycle memory.
  26
  27 The amount of code required to implement ramfs is tiny, because all the
  28 work is done by the existing Linux caching infrastructure.  Basically,
  29 you're mounting the disk cache as a filesystem.  Because of this, ramfs is not
  30 an optional component removable via menuconfig, since there would be negligible
  31 space savings.
  32
  33 ramfs and ramdisk:
  34 ------------------
  35
  36 The older "ram disk" mechanism created a synthetic block device out of
  37 an area of ram and used it as backing store for a filesystem.  This block
  38 device was of fixed size, so the filesystem mounted on it was of fixed
  39 size.  Using a ram disk also required unnecessarily copying memory from the
  40 fake block device into the page cache (and copying changes back out), as well
  41 as creating and destroying dentries.  Plus it needed a filesystem driver
  42 (such as ext2) to format and interpret this data.
  43
  44 Compared to ramfs, this wastes memory (and memory bus bandwidth), creates
  45 unnecessary work for the CPU, and pollutes the CPU caches.  (There are tricks
  46 to avoid this copying by playing with the page tables, but they're unpleasantly
  47 complicated and turn out to be about as expensive as the copying anyway.)
  48 More to the point, all the work ramfs is doing has to happen _anyway_,
  49 since all file access goes through the page and dentry caches.  The ram
  50 disk is simply unnecessary, ramfs is internally much simpler.
  51
  52 Another reason ramdisks are semi-obsolete is that the introduction of
  53 loopback devices offered a more flexible and convenient way to create
  54 synthetic block devices, now from files instead of from chunks of memory.
  55 See losetup (8) for details.
  56
  57 ramfs and tmpfs:
  58 ----------------
  59
  60 One downside of ramfs is you can keep writing data into it until you fill
  61 up all memory, and the VM can't free it because the VM thinks that files
  62 should get written to backing store (rather than swap space), but ramfs hasn't
  63 got any backing store.  Because of this, only root (or a trusted user) should
  64 be allowed write access to a ramfs mount.
  65
  66 A ramfs derivative called tmpfs was created to add size limits, and the ability
  67 to write the data to swap space.  Normal users can be allowed write access to
  68 tmpfs mounts.  See Documentation/filesystems/tmpfs.txt for more information.
  69
  70 What is rootfs?
  71 ---------------
  72
  73 Rootfs is a special instance of ramfs, which is always present in 2.6 systems.
  74 (It's used internally as the starting and stopping point for searches of the
  75 kernel's doubly-linked list of mount points.)
  76
  77 Most systems just mount another filesystem over it and ignore it.  The
  78 amount of space an empty instance of ramfs takes up is tiny.
  79
  80 What is initramfs?
  81 ------------------
  82
  83 All 2.6 Linux kernels contain a gzipped "cpio" format archive, which is
  84 extracted into rootfs when the kernel boots up.  After extracting, the kernel
  85 checks to see if rootfs contains a file "init", and if so it executes it as PID
  86 1.  If found, this init process is responsible for bringing the system the
  87 rest of the way up, including locating and mounting the real root device (if
  88 any).  If rootfs does not contain an init program after the embedded cpio
  89 archive is extracted into it, the kernel will fall through to the older code
  90 to locate and mount a root partition, then exec some variant of /sbin/init
  91 out of that.
  92
  93 All this differs from the old initrd in several ways:
  94
  95   - The old initrd was a separate file, while the initramfs archive is linked
  96     into the linux kernel image.  (The directory linux-*/usr is devoted to
  97     generating this archive during the build.)
  98
  99   - The old initrd file was a gzipped filesystem image (in some file format,
 100     such as ext2, that had to be built into the kernel), while the new
 101     initramfs archive is a gzipped cpio archive (like tar only simpler,
 102     see cpio(1) and Documentation/early-userspace/buffer-format.txt).
 103
 104   - The program run by the old initrd (which was called /initrd, not /init) did
 105     some setup and then returned to the kernel, while the init program from
 106     initramfs is not expected to return to the kernel.  (If /init needs to hand
 107     off control it can overmount / with a new root device and exec another init
 108     program.  See the switch_root utility, below.)
 109
 110   - When switching another root device, initrd would pivot_root and then
 111     umount the ramdisk.  But initramfs is rootfs: you can neither pivot_root
 112     rootfs, nor unmount it.  Instead delete everything out of rootfs to
 113     free up the space (find -xdev / -exec rm '{}' ';'), overmount rootfs
 114     with the new root (cd /newmount; mount --move . /; chroot .), attach
 115     stdin/stdout/stderr to the new /dev/console, and exec the new init.
 116
 117     Since this is a remarkably persnickity process (and involves deleting
 118     commands before you can run them), the klibc package introduced a helper
 119     program (utils/run_init.c) to do all this for you.  Most other packages
 120     (such as busybox) have named this command "switch_root".
 121
 122 Populating initramfs:
 123 ---------------------
 124
 125 The 2.6 kernel build process always creates a gzipped cpio format initramfs
 126 archive and links it into the resulting kernel binary.  By default, this
 127 archive is empty (consuming 134 bytes on x86).  The config option
 128 CONFIG_INITRAMFS_SOURCE (for some reason buried under devices->block devices
 129 in menuconfig, and living in usr/Kconfig) can be used to specify a source for
 130 the initramfs archive, which will automatically be incorporated into the
 131 resulting binary.  This option can point to an existing gzipped cpio archive, a
 132 directory containing files to be archived, or a text file specification such
 133 as the following example:
 134
 135   dir /dev 755 0 0
 136   nod /dev/console 644 0 0 c 5 1
 137   nod /dev/loop0 644 0 0 b 7 0
 138   dir /bin 755 1000 1000
 139   slink /bin/sh busybox 777 0 0
 140   file /bin/busybox initramfs/busybox 755 0 0
 141   dir /proc 755 0 0
 142   dir /sys 755 0 0
 143   dir /mnt 755 0 0
 144   file /init initramfs/init.sh 755 0 0
 145
 146 One advantage of the text file is that root access is not required to
 147 set permissions or create device nodes in the new archive.  (Note that those
 148 two example "file" entries expect to find files named "init.sh" and "busybox" in
 149 a directory called "initramfs", under the linux-2.6.* directory.  See
 150 Documentation/early-userspace/README for more details.)
 151
 152 If you don't already understand what shared libraries, devices, and paths
 153 you need to get a minimal root filesystem up and running, here are some
 154 references:
 155 http://www.tldp.org/HOWTO/Bootdisk-HOWTO/
 156 http://www.tldp.org/HOWTO/From-PowerUp-To-Bash-Prompt-HOWTO.html
 157 http://www.linuxfromscratch.org/lfs/view/stable/
 158
 159 The "klibc" package (http://www.kernel.org/pub/linux/libs/klibc) is
 160 designed to be a tiny C library to statically link early userspace
 161 code against, along with some related utilities.  It is BSD licensed.
 162
 163 I use uClibc (http://www.uclibc.org) and busybox (http://www.busybox.net)
 164 myself.  These are LGPL and GPL, respectively.
 165
 166 In theory you could use glibc, but that's not well suited for small embedded
 167 uses like this.  (A "hello world" program statically linked against glibc is
 168 over 400k.  With uClibc it's 7k.  Also note that glibc dlopens libnss to do
 169 name lookups, even when otherwise statically linked.)
 170
 171 Future directions:
 172 ------------------
 173
 174 Today (2.6.14), initramfs is always compiled in, but not always used.  The
 175 kernel falls back to legacy boot code that is reached only if initramfs does
 176 not contain an /init program.  The fallback is legacy code, there to ensure a
 177 smooth transition and allowing early boot functionality to gradually move to
 178 "early userspace" (I.E. initramfs).
 179
 180 The move to early userspace is necessary because finding and mounting the real
 181 root device is complex.  Root partitions can span multiple devices (raid or
 182 separate journal).  They can be out on the network (requiring dhcp, setting a
 183 specific mac address, logging into a server, etc).  They can live on removable
 184 media, with dynamically allocated major/minor numbers and persistent naming
 185 issues requiring a full udev implementation to sort out.  They can be
 186 compressed, encrypted, copy-on-write, loopback mounted, strangely partitioned,
 187 and so on.
 188
 189 This kind of complexity (which inevitably includes policy) is rightly handled
 190 in userspace.  Both klibc and busybox/uClibc are working on simple initramfs
 191 packages to drop into a kernel build, and when standard solutions are ready
 192 and widely deployed, the kernel's legacy early boot code will become obsolete
 193 and a candidate for the feature removal schedule.
 194
 195 But that's a while off yet.