A root filesystem must contain everything needed to support a full Linux system. To be able to do this, the disk must include the minimum requirements for a Linux system:

• The basic file system structure,
• Minimum set of directories: /dev, /proc, /bin, /etc, /lib, /usr, /tmp,
• Basic set of utilities: sh, ls, cp, mv, etc.,
• Minimum set of config files: rc, inittab, fstab, etc.,
• Devices: /dev/hd*, /dev/tty*, /dev/fd0, etc.,
• Runtime library to provide basic functions used by utilities.

Of course, any system only becomes useful when you can run something on it, and a root diskette usually only becomes useful when you can do something like:

• Check a file system on another drive, for example to check your root file system on your hard drive, you need to be able to boot Linux from another drive, as you can with a root diskette system. Then you can run fsck on your original root drive while it is not mounted.
• Restore all or part of your original root drive from backup using archive and compression utilities such as cpio, tar, gzip and ftape.

We will describe how to build a compressed filesystem, so called because it is compressed on disk and, when booted, is uncompressed onto a ramdisk. compressed root filesystem/ With a compressed filesystem you can fit many files (approximately two megabytes) onto a standard 1440K diskette. Because the filesystem is much larger than a diskette, it cannot be built on the diskette. We have to build it elsewhere, compress it, then copy it to the diskette.

In order to build such a root filesystem, you need a spare device that is large enough to hold all the files before compression. You will need a device capable of holding about four megabytes. There are several choices:

• Use a ramdisk (DEVICE = /dev/ram0). In this case, memory is used to simulate a disk drive. The ramdisk must be large enough to hold a filesystem of the appropriate size. If you use LILO, check your configuration file (/etc/lilo.conf) for a line like:

          RAMDISK_SIZE = nnn
  

  RAMDISK_SIZE, LILO parameter/ which determines how much RAM will be allocated. The default is 4096K, which should be sufficient. You should probably not try to use such a ramdisk on a machine with less than 8MB of RAM. Check to make sure you have a device like /dev/ram0, /dev/ram or /dev/ramdisk. If not, create /dev/ram0 with mknod (major number 1, minor 0).
• If you have an unused hard disk partition that is large enough (several megabytes), this is a good solution. If you have enough physical RAM you can turn off swapping and build the filesystem in your swap partition.
• Use a loopback device, which allows a disk file to be treated as a device. Using a loopback device you can create a three megabyte file on your hard disk and build the filesystem on it. In order to use loopback devices you need specially modified mount and unmount programs. You can find these in the directory: ftp://ftp.win.tue.nl:/pub/linux/util/mount/

  If you do not have a loop device (/dev/loop0, /dev/loop1, etc.) on your system, you will have to create one with ``mknod /dev/loop0 b 7 0''. One you've installed these special mount and umount binaries, create a temporary file on a hard disk with enough capacity (eg, /tmp/fsfile). You can use a command like

  dd if=/dev/zero of=/tmp/fsfile bs=1k count=nnn

  to create an nnn-block file.

  Use the file name in place of DEVICE below. When you issue a mount command you must include the option ``-o loop'' to tell mount to use a loopback device. loopback device/ For example:

          mount -o loop -t ext2 /tmp/fsfile /mnt
  

  will mount /tmp/fsfile (via a loopback device) at the mount point /mnt. A df will confirm this.

After you've chosen one of these options, prepare the DEVICE with:

        dd if=/dev/zero of=DEVICE bs=1k count=3000

This command zeroes out the device. This step is important because the filesystem on the device will be compressed later, so all unused portions should be filled with zeroes to achieve maximum compression.

inodes, allocation/ Next, create the filesystem. The Linux kernel recognizes two file system types for root disks to be automatically copied to ramdisk. These are minix and ext2, of which ext2 is the preferred file system. If using ext2, you may find it useful to use the -i option to specify more inodes than the default; -i 2000 is suggested so that you don't run out of inodes. Alternatively, you can save on inodes by removing lots of unnecessary /dev files. mke2fs will by default create 360 inodes on a 1.44Mb diskette. I find that 120 inodes is ample on my current rescue root diskette, but if you include all the devices in the /dev directory then you will easily exceed 360. Using a compressed root filesystem allows a larger filesystem, and hence more inodes by default, but you may still need to either reduce the number of files or increase the number of inodes.

So the command you use will look like:

mke2fs -m 0 -i 2000 DEVICE

(If you're using a loopback device, the disk file you're using should be supplied in place of this DEVICE. loopback device/ In this case, mke2fs will ask if you really want to do this; say yes.)

The mke2fs command will automatically detect the space available and configure itself accordingly. The -m 0 parameter prevents it from reserving space for root, and hence provides more usable space on the disk.

Next, mount the device:

        mount -t ext2 DEVICE /mnt

(You must create a mount point /mnt if it does not already exist.) In the remaining sections, all destination directory names are assumed to be relative to /mnt.

Here is a reasonable minimum set of directories for your root filesystem:

• /dev --- Devices, required to perform I/O
• /proc --- Directory stub required by the proc filesystem
• /etc --- System configuration files
• /sbin --- Critical system binaries
• /bin --- Basic binaries considered part of the system
• /lib --- Shared libraries to provide run-time support
• /mnt --- A mount point for maintenance on other disks
• /usr --- Additional utilities and applications

(The directory structure presented here is for root diskette use only. Real Linux systems have a more complex and disciplined set of policies, called the File System Standard, for determining where files should go.)

proc/mnt/usr/

Three of these directories will be empty on the root filesystem, so they only need to be created with mkdir. The /proc directory is basically a stub under which the proc filesystem is placed. The directories /mnt and /usr are only mount points for use after the boot/root system is running. Hence again, these directories only need to be created.

The remaining four directories are described in the following sections.

/dev

device (dev) directory/

A /dev directory containing a special file for all devices to be used by the system is mandatory for any Linux system. The directory itself is a normal directory, and can be created with mkdir in the normal way. The device special files, however, must be created in a special way, using the mknod command.

There is a shortcut, though --- copy your existing /dev directory contents, and delete the ones you don't want. The only requirement is that you copy the device special files using -R option. This will copy the directory without attempting to copy the contents of the files. Be sure to use an upper case R. If you use the lower case switch -r, you will probably end up copying the entire contents of all of your hard disks --- or at least as much of them as will fit on a diskette! Therefore, take care, and use the command:

        cp -dpR /dev /mnt

assuming that the diskette is mounted at /mnt. The dp switches ensure that symbolic links are copied as links, rather than using the target file, and that the original file attributes are preserved, thus preserving ownership information.

Alternatively, you can use the cpio program with the -p option, because cpio handles device special files correctly, and will not try to copy the contents. For example, the commands:

cd /dev
find . -print | cpio -pmd /mnt/dev

will copy all device special files from /dev to /mnt/dev. In fact it will copy all files in the directory tree starting at /dev, and will create any required subdirectories in the target directory tree.

If you want to do it the hard way, use ls -l to display the major and minor device numbers for the devices you want, and create them on the diskette using mknod.

However the devices are copied, it is worth checking that any special devices you need have been placed on the rescue diskette. For example, ftape uses tape devices, so you will need to copy all of these if you intend to access your floppy tape drive from the bootdisk.

Note that one inode is required for each device special file, and inodes can at times be a scarce resource, especially on diskette filesystems. It therefore makes sense to remove any device special files that you don't need from the diskette /dev directory. Many devices are obviously unnecessary on specific systems. For example, if you do not have SCSI disks you can safely remove all the device files starting with sd. Similarly, if you don't intend to use your serial port then all device files starting with cua can go.

Be sure to include the following files from this directory: console, kmem, mem, null, ram, tty1.

/etc

etc directory/

This directory must contain a number of configuration files. On most systems, these can be divided into three groups:

1. Required at all times, e.g. rc, fstab, passwd. rc/fstab/passwd/
2. May be required, but no-one is too sure.
3. Junk that crept in.

Files which are not essential can be identified with the command:

        ls -ltru

This lists files in reverse order of date last accessed, so if any files are not being accessed, they can be omitted from a root diskette.

On my root diskettes, I have the number of config files down to 15. This reduces my work to dealing with three sets of files:

1. The ones I must configure for a boot/root system:
   1. rc.d/* --- system startup and run level change scripts
   2. fstab --- list of file systems to be mounted
   3. inittab --- parameters for the init process, the first process started at boot time. init/
2. The ones I should tidy up for a boot/root system:
   1. passwd --- list of users, home directories, etc.
   2. group --- user groups. user groups/
   3. shadow --- passwords of users. You may not have this. shadow passwords/
   If security is important, passwd and shadow should be pruned to avoid copying user passwords off the system, and so that when you boot from diskette, unwanted logins are rejected. However, there is a reason not to prune passwd and group. tar (and probably other archivers) stores user and group names with files. If you restore files to your hard disk from tape, the files will be restored with their original names. If these names do not exist in passwd/group when they are restored, the UIDs/GIDs will not be correct. restoring files/ Be sure that passwd contains at least root. If you intend other users to login, be sure their home directories and shells exist.
3. The rest. They work at the moment, so I leave them alone.

Out of this, I only really have to configure two files, and what they should contain is surprisingly small.

• rc should contain:

          #!/bin/sh
          /bin/mount -av
          /bin/hostname Kangaroo
  

  Be sure the directories are right. You don't really need to run hostname --- it just looks nicer if you do.
• fstab should contain at least:

          /dev/ram0       /               ext2    defaults
          /dev/fd0        /               ext2    defaults
          /proc           /proc           proc    defaults
  

  You can copy entries from your existing fstab, but you should not automatically mount any of your hard disk partitions; use the noauto keyword with them. Your hard disk may be damaged or dead when the bootdisk is used.

Your inittab should be changed so that its sysinit line runs rc or whatever basic boot script will be used. Also, if you want to ensure that users on serial ports cannot login, comment out all the entries for getty which include a ttys or ttyS device at the end of the line. Leave in the tty ports so that you can login at the console.

A minimal inittab file looks like this:

        id:2:initdefault:
        si::sysinit:/etc/rc
        1:2345:respawn:/sbin/getty 9600 tty1
        2:23:respawn:/sbin/getty 9600 tty2

modules/

If you have a modular kernel, you must consider which modules you may want to load from your bootdisk after booting. You might want to include ftape and zftape modules if your backup tapes are on floppy tape, modules for SCSI devices if you have them, and possibly modules for PPP or SLIP support if you want to access the net in an emergency.ftape/

These modules may be placed in /lib/modules. You should also include insmod, rmmod and lsmod. Depending on whether you want to load modules automatically, you might also include modprobe, depmod and swapout. If you use kerneld, include it along with /etc/conf.modules.

However, the main advantage to using modules is that you can move non-critical modules to a utility disk and load them when needed, thus using less space on your root disk. If you may have to deal with many different devices, this approach is preferable to building one huge kernel with many drivers built in. utility diskette/

Note that in order to boot a compressed ext2 filesystem, you must have ramdisk and ext2 support built-in. They cannot be supplied as modules.

Some system programs, such as login, complain if the file /var/run/utmp and the directory /var/log do not exist.utmp/ So:

        mkdir -p /mnt/var/{log,run}
        touch /mnt/var/run/utmp

Finally, after you have set up all the libraries you need, run ldconfig to remake /etc/ld.so.cache on the root filesystem. The cache tells the loader where to find the libraries. To remake ld.so.cache, issue the following commands:ldconfig/ld.so.cache/

        chdir /mnt; chroot /mnt /sbin/ldconfig

The chroot is necessary because ldconfig always remakes the cache for the root filesystem.

Once you have finished constructing the root filesystem, unmount it, copy it to a file and compress it:

        umount /mnt
        dd if=DEVICE bs=1k | gzip -v9 > rootfs.gz