2.2.1. Simplification

Take a moment to skim through the Bootdisk-HOWTO or the From-PowerUp-to-BASH-Prompt-HOWTO. These HOWTO documents can be found online at http://www.tldp.org/docs.html#howto. Both documents offer an excellent view of what it takes to get a GNU/Linux system up and running. There is also a lot of information to digest. Remember that one of our goals is, "keep it simple to avoid stressing out," so we want to ignore everything but the absolutely critical pieces of a boot / root diskset.

Basically it boils down to the following required items:

• A boot loader

• The Linux kernel

• A shell

• Some /dev files

We don't even need an init daemon. The kernel can be told to run the shell directly by passing it an option through the boot loader.

For easy construction we will build a two-disk boot / root set rather than trying to get everything onto a single diskette. The boot loader and kernel will go on the boot disk and the shell will reside on the root disk. Both disks will need device files to function properly.

2.2.2. Boot Disk

For the boot disk we'll want to use a kernel that does not require modules for the hardware we need to access. Mainly, it should have compiled-in support for the floppy drive, ram disk, second extended filesystem and a text-based console. If such a kernel is not available, it will need to be built from source code using the Kernel-HOWTO as a guide. Once the kernel is ready we can copy it to a diskette that has been prepared with a filesystem (a.k.a. formatted). The diskette will need a few /dev files and a lilo.conf file in order to get LILO installed. The Bootdisk-HOWTO and the lilo.conf(5) manpage will be helpful in designing the lilo.conf file.

It is also possible to build a boot disk using GRUB instead of LILO. For more information, visit the resource site and look under "related projects" for Rick Stocker's instructions on using GRUB.

2.2.3. Root Disk

For the root disk we will need a floppy that has been prepared with a filesystem. We will also need a BASH shell that is statically-linked so we can avoid the additional complexities of shared libraries. The configure program in the BASH source code recognizes the --enable-static-link option for this feature. We will also be using the --enable-minimal-config option to keep the BASH binary down to a manageable size. Additional requirements for the root disk are a /dev directory and a device file for the console. The console device is required for BASH to be able to communicate with the keyboard and video display.

2.2.4. CPU Compatibility

There is one other, less obvious requirement to keep in mind and that is CPU compatibility. Each generation of CPU features a more complex architecture than its predecessor. Late generation chips have additional registers and instructions when compared to an older 486 or 386. So a kernel optimized for a new, fast 6x86 machine will not run on an older boxes. (See the README file in the Linux kernel source code for details.) A BASH shell built for a 6x86 will probably not run on an older processor either. To avoid this problem, we can choose the 386 as a lowest common denominator CPU and build all the code for that architecture.

2.3.1. Prepare the boot disk floppy

Insert a blank diskette labeled "boot disk".

It may be necessary to erase the "blank" diskette if it comes factory pre-formatted for another, non-Linux operating system. This can be done using the command dd if=/dev/zero of=/dev/fd0 bs=1k count=1440

bash# mke2fs -m0 /dev/fd0 bash# mount /dev/fd0 /mnt

2.3.2. Build the kernel

The steps for building the kernel were tested using Linux kernel version 2.4.18 and should work any 2.4.x kernel. The latest version of the kernel source code may be downloaded from http://www.kernel.org or one of its mirrors.

bash# cd /usr/src/linux bash# make menuconfig

Be sure to configure support for the following:

• 386 processor

• Floppy disk

• RAM disk

• Second extended (ext2) filesystem

• Console on virtual terminal

bash# make dep bash# make clean bash# make bzImage

2.3.3. Copy the kernel to diskette

bash# mkdir /mnt/boot bash# cp /usr/src/linux/arch/i386/boot/bzImage /mnt/boot/vmlinuz

2.3.4. Copy the LILO boot loader

bash# cp /boot/boot.b /mnt/boot/boot.b

2.3.5. Create device files that LILO needs

bash# mkdir /mnt/dev bash# cd /mnt/dev bash# mknod fd0 b 2 0 bash# mknod console c 5 1

2.3.6. Write a simple lilo.conf

bash# mkdir /mnt/etc bash# cd /mnt/etc

Use an editor like vi, emacs or pico to create the following lilo.conf file:

# /etc/lilo.conf - boot loader configuration file # boot=/dev/fd0 compact prompt read-only vga=normal image=/boot/vmlinuz label=bootdisk append="load_ramdisk=1 prompt_ramdisk=1" root=/dev/fd0 # # end of /etc/lilo.conf

2.3.7. Install the LILO boot loader

bash# lilo -r /mnt

2.3.8. Unmount the boot disk

bash# cd / bash# umount /mnt

2.3.9. Prepare the root disk floppy

Insert a blank diskette labeled "root disk".

bash# mke2fs -m0 /dev/fd0 bash# mount /dev/fd0 /mnt

2.3.10. Build BASH

Get the bash-2.05 source code package from ftp://ftp.gnu.org/gnu/bash/ and untar it into the /usr/src directory.

BASH version 2.05b, the latest version at the time of this writing, will not build successfully when using the --enable-minimal-config option. This leaves two choices. We can either fix 2.05b by applying the patch posted on news://gnu.bash.bug under the subject, "Compile error in execute_cmd.c with --enable-minimal-config" or we can simply use the 2.05a version.

Build BASH for an i386 CPU with the following commands:

bash# cd /usr/src/bash-2.05a bash# export CC="gcc -mcpu=i386" bash# ./configure --enable-static-link \ --enable-minimal-config --host=i386-pc-linux-gnu bash# make bash# strip bash

2.3.11. Copy BASH to the root disk

bash# mkdir /mnt/bin bash# cp bash /mnt/bin/bash bash# ln -s bash /mnt/bin/sh

2.3.12. Create device files that BASH needs

bash# mkdir /mnt/dev bash# mknod /mnt/dev/console c 5 1

2.3.13. Unmount the root disk

bash# cd / bash# umount /mnt

2.4.1. System startup

Follow these steps to boot the system:

• Restart the PC with the boot disk in the floppy drive.

• When the LILO prompt appears, type bootdisk init=/bin/sh and press Enter.

• Insert the root disk when prompted.

If all goes well the screen should look something like the example shown below.

boot: bootdisk init=/bin/sh Loading bootdisk Uncompressing Linux... Ok, booting kernel. .. .. [various kernel messages] .. VFS: Insert root floppy disk to be loaded into RAM disk and press ENTER RAMDISK: ext2 filesystem found at block 0 RAMDISK: Loading 1440 blocks [1 disk] into ram disk... done. VFS: Mounted root (ext2 filesystem) readonly. Freeing unused kernel memory: 178k freed # _

2.4.2. Testing what works

Try out a few of BASH's built-in commands to see if things are working properly.

bash# echo "Hello World" bash# cd / bash# pwd bash# echo *

2.4.3. Noting what does not work

Try out a few other familiar commands.

bash# ls /var bash# mkdir /var/tmp

Notice that only commands internal to BASH actually work and that external commands like ls and mkdir do not work at all. This shortcoming is something that can be addressed in a future phase of the project. For now we should just enjoy the fact that our prototype boot / root diskset works and that it was not all that hard to build.

2.4.4. System shutdown

Remove the diskette from fd0 and restart the system using CTRL-ALT-DELETE.

3.2.1. Shared Libraries

First, in order to use shared libraries we will need to rebuild the BASH shell. This time we will configure it without using the --enable-static-link option. Once BASH is rebuilt we need to figure out which libraries it is linked with and be sure to include them on the root disk. The ldd command makes this job easy. By typing ldd bash on the command-line we can see a list of all the shared libraries that BASH uses. As long as all these libraries are copied to the root disk, the new BASH build should work fine.

3.2.2. Stripped Binaries

Next, we should strip any binaries that get copied to the root disk. The manpage for strip does not give much description of what it does other than to say, "strip discards all symbols from the object files." It seems like removing pieces of a binary would render it useless, but this is not the case. The reason it works is because a large number of these discarded symbols are used for debugging. While debugging symbols are very helpful to programmers working to improve the code, they do not do much for the average end-user other than take up more disk space. And since space is at a premium, we should definitely remove as many symbols as possible from BASH and any other binaries before we copy over them to the ramdisk.

The process of stripping files to save space also works with shared library files. But when stripping libraries it is important to use the --strip-unneeded option so as not to break them. Using --strip-unneeded shrinks the file size, but leaves the symbols needed for relocation intact which is something that shared libraries need to function properly.

3.2.3. Compressed Root Filesystem

Finally, we can tackle the problem of how to build a compressed root filesystem. The Bootdisk-HOWTO suggests three ways of constructing a compressed root filesystem using either a ramdisk, a spare hard drive partition or a loopback device. This project will concentrate on using the ramdisk approach. It seems logical that if the root filesystem is going to be run from a ramdisk, it may as well be built on a ramdisk. All we have to do is create a second extended filesystem on a ramdisk device, mount it and copy files to it. Once the filesystem is populated with all the files that the root disk needs, we simply unmount it, compress it and write it out to floppy.

For this to work, we need to make sure the kernel is configured with ramdisk support and a default size of 4,096K. If the ramdisk size is something other than 4096K this can be fixed by adding the line "ramdisk=4096" to the development system's lilo.conf file. The lilo.conf(5) man page provides additional information.

3.3.1. Create a ramdisk

bash# dd if=/dev/zero of=/dev/ram7 bs=1k count=4096 bash# mke2fs -m0 /dev/ram7 bash# mount /dev/ram7 /mnt

3.3.2. Rebuild the BASH shell

bash# cd /usr/src/bash-2.05a bash# make distclean bash# export CC="gcc -mcpu=i386" bash# ./configure --enable-minimal-config --host=i386-pc-linux-gnu bash# make bash# strip bash

3.3.3. Determine which libraries are required

bash# ldd bash

Note the output from the ldd command. It should look similar to the example below.

bash# ldd bash
  libdl.so.2 => /lib/libdl.so.2 (0x4001d000)
  libc.so.6 => /lib/libc.so.6 (0x40020000)
  /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

3.3.4. Copy BASH and its libraries to the ramdisk

bash# mkdir /mnt/bin bash# cp bash /mnt/bin bash# ln -s bash /mnt/bin/sh bash# mkdir /mnt/lib bash# strip --strip-unneeded -o /mnt/lib/libdl.so.2 /lib/libdl.so.2 bash# strip --strip-unneeded -o /mnt/lib/libc.so.6 /lib/libc.so.6 bash# strip --strip-unneeded -o /mnt/lib/ld-linux.so.2 /lib/ld-linux.so.2 bash# chmod +x /mnt/lib/*

Using strip -o might seem an odd way to copy library files from the development system to the ramdisk. What it does is strip the symbols while the file is in transit from the source location to the destination. This has the effect of stripping symbols from the library on the ramdisk without altering the libraries on the development system. Unfortunately file permissions are lost when copying libraries this way which is why the chmod +x command is then used to set the execute flag on all of the libraries on the rootdisk.

3.3.5. Create a console device

bash# mkdir /mnt/dev bash# mknod /mnt/dev/console c 5 1

3.3.6. Compress the ramdisk image

bash# cd / bash# umount /dev/ram7 bash# dd if=/dev/ram7 of=~/phase2-image bs=1k bash# gzip -9 ~/phase2-image

3.3.7. Copy the compressed image to diskette

Insert the floppy labeled "root disk" into drive fd0.

bash# dd if=~/phase2-image.gz of=/dev/fd0 bs=1k

3.4.1. System startup

Follow these steps to boot:

• Restart the PC using the lilo boot disk from the previous chapter.

• At the LILO prompt, type bootdisk init=/bin/sh and press Enter.

• Insert the new, compressed root disk when prompted.

The screen output should be similar to the following example:

boot: bootdisk init=/bin/sh Loading bootdisk Uncompressing Linux... Ok, booting kernel. .. .. [various kernel messages] .. VFS: Insert root floppy to be loaded into RAM disk and press ENTER RAMDISK: Compressed image found at block 0 VFS: Mounted root (ext2 filesystem) read-write. Freeing unused kernel memory: 178k freed # _

3.4.2. Verify results

If the implementation was successful, this new root disk should behave exactly like the root disk from the previous chapter. The key difference is that this compressed root disk has much more room to grow and we will put this extra space to good use in the next phase of the project.

3.4.3. System shutdown

Remove the diskette from fd0 and restart the system using CTRL-ALT-DELETE.

4.2.1. Determining Required Commands

The first question that might come to mind is, "How do we know which commands are needed?" It is possible to just start with cat and ls then install other commands as we discover a need for them. But this is terribly inefficient. We need a plan or a blueprint to work from. For this we can turn to the Filesystem Hierarchy Standard (FHS) available from http://www.pathname.com/fhs/. The FHS dictates which commands should be present on a Linux system and where they should be placed in the directory structure.

4.2.2. Locating Source Code

The next logical question is, "Now that we know what we need, where do we get the source code?" One way to find the answer to this question is to check the manpages. We can either search the manpages included with one of the popular GNU/Linux distributions or use one of the manpage search engines listed at http://www.tldp.org/docs.html#man. One thing that should tip us off as to where to find the source code for a particular command is the email address listed for reporting bugs. For example the cat manpage lists bug-textutils@gnu.org. From this email address we can deduce that cat is part of the textutils package from GNU.

4.2.3. Leveraging FHS

So let's look at the FHS requirements for the /bin directory. The first few commands in the list are cat, chgrp, chmod, chown and cp. We already know that cat is part of GNU's textutils. Using the next few commands as keywords in a manpage search we discover that we need GNU's fileutils package for chmod, chgrp, chown and cp. In fact quite a few of the commands in /bin come from GNU's fileutils. The date command also comes from a GNU package called sh-utils. So a good way to tackle the problem of finding source code might be to group the commands together by package as shown below.

• The BASH shell -- echo, false, pwd, sh, true

• GNU textutils -- cat

• GNU fileutils -- chgrp, chmod, chown, cp, dd, df, ln, ls, mkdir, mknod, mv, rm, rmdir, sync

• GNU sh-utils -- date, hostname, stty, su, uname

These four packages do not contain all of the commands in the /bin directory, but they do represent of over 70% of them. That should be enough to accomplish our goal of adding some of the commonly used external commands. We can worry about the other commands in later phases of the project.

4.2.4. Downloading Source Code

To fetch the source code we simply need to connect to GNU's FTP site and navigate to the appropriate package directory.

When we get to the directory for textutils there are several versions available. There is also a note informing us that the package has been renamed to coreutils. The same message about coreutils appears in the fileutils and sh-utils directories as well. So instead of downloading three separate packages we can get everything in one convenient bundle in the coreutils directory.

4.3.1. Create a staging area

bash# mkdir ~/staging bash# cd ~/staging bash# mkdir bin boot dev etc home lib mnt opt proc root sbin tmp usr var bash# mkdir var/log var/run

4.3.2. Copy contents of phase 2 rootdisk

bash# dd if=~/phase2-image.gz | gunzip -c > /dev/ram7 bash# mount /dev/ram7 /mnt bash# cp -dpR /mnt/* ~/staging bash# umount /dev/ram7 bash# rmdir ~/staging/lost+found

4.3.3. Install binaries from GNU coreutils

Download coreutils from ftp://ftp.gnu.org/gnu/coreutils

bash# cd /usr/src/coreutils-5.0 bash# export CC="gcc -mcpu=i386" bash# ./configure --host=i386-pc-linux-gnu bash# make bash# cd src bash# cp cat chgrp chmod chown cp date dd df ~/staging/bin bash# cp hostname ln ls mkdir mkfifo mknod ~/staging/bin bash# cp mv rm rmdir stty su sync uname ~/staging/bin

4.3.4. Copy additional libraries

Check library requirements by using ldd on some of the new binaries.

bash# ldd ~/staging/bin/cat bash# ldd ~/staging/bin/ls bash# ldd ~/staging/bin/su bash# ls ~/staging/lib

Note the differences in the required libraries, as shown by the ldd command, and the libraries present in the staging area, as shown by the ls command, then copy any missing libraries to the staging area.

bash# cp /lib/librt.so.1 ~/staging/lib bash# cp /lib/libpthread.so.0 ~/staging/lib bash# cp /lib/libcrypt.so.1 ~/staging/lib

4.3.5. Strip binaries and libraries

bash# strip ~/staging/bin/* bash# strip --strip-unneeded ~/staging/lib/*

4.3.6. Create a compressed root disk image

bash# cd / bash# dd if=/dev/zero of=/dev/ram7 bs=1k count=4096 bash# mke2fs -m0 /dev/ram7 bash# mount /dev/ram7 /mnt bash# cp -dpR ~/staging/* /mnt bash# umount /dev/ram7 bash# dd if=/dev/ram7 of=~/phase3-image bs=1k bash# gzip -9 ~/phase3-image

The process for creating the compressed root disk image will change very little throughout the remaining chapters. Writing a small script to handle this function can be a great time saver.

4.3.7. Write the root disk image to floppy

Insert the diskette labled "root disk" into drive fd0.

bash# dd if=~/phase3-image.gz of=/dev/fd0 bs=1k

4.4.1. Sytem startup

Follow these steps to get the system running.

• Boot the PC from using the LILO boot disk.

• At the LILO prompt, type bootdisk rw init=/bin/sh and press Enter.

• Insert the recently created root disk when prompted.

The terminal display should look similar to the example below.

boot: bootdisk rw init=/bin/sh Loading bootdisk Uncompressing Linux... Ok, booting kernel. .. .. [various kernel messages] .. VFS: Insert root floppy to be loaded into RAM disk and press ENTER RAMDISK: Compressed image found at block 0 VFS: Mounted root (ext2 filesystem). Freeing unused kernel memory: 178k freed # _

4.4.2. Testing new commands

Now that the system is up and running, try using some of the new commands.

bash# uname -a bash# ls /etc bash# echo "PocketLinux" > /etc/hostname bash# hostname $(cat /etc/hostname) bash# uname -n bash# mkdir /home/stuff bash# cd /home/stuff

If everything goes well the commands like cat, ls and hostname should work now. Even mkdir should work since the root filesystem is mounted read-write. Of course since we are using a ramdisk, any changes will be lost once the PC is reset.

4.4.3. System shutdown

Remove the diskette from fd0 and restart the system using CTRL-ALT-DELETE.

5.2.1. Determining necessary utilities.

We can use the Filesystem Hierarchy Standard (FHS) document to help find the names of utilities we need and where they reside in the directory structure. The FHS /sbin directory lists fsck and something called fsck.* for checking filesystems. Since we are using a Second Extended (ext2) filesystem the fsck.* becomes fsck.ext2 for our purposes. Mounting filesystems is done using the commands mount and umount in the /bin directory. However, the name of a script to automatically mount local filesystems cannot be found. On most systems this type of script is in the /etc directory, but while FHS does list requirements for /etc, it does not currently make recommendations for startup scripts. Several GNU/Linux distributions use /etc/init.d as the place to hold startup scripts so we will put our filesystem mounting script there.

5.2.2. Finding source code

In the previous chapter we used manpages to help us find source code. In this chapter we will use a tool called the Linux Software Map (LSM). LSM is a database of GNU/Linux software that tracks such things as package name, author, names of binaries that make up the package and download sites. Using an LSM search engine we can locate packages using command names as keywords.

If we search Ibiblio's Linux Software Map (LSM) at http://www.ibiblio.org/pub/Linux/ for the keyword "fsck" we get a large number of matches. Since we are using a Second Extended filesystem, called ext2 for short, we can refine the search using "ext2" as a keyword. Supplying both keywords to the LSM search engine comes up with a package called e2fsprogs. Looking at the LSM entry for e2fsprogs we find out that package contains the utilities e2fsck, mke2fs, dumpe2fs, fsck and more. We also find out that the LSM entry for e2fsprogs has not been updated for a while. There is almost certainly a newer version out there somewhere. Another good Internet resource for source code is SourceForge at http://sourceforge.net. Using the keyword "e2fsprogs" in the SourceForge search engine results in a much newer version of e2fsprogs.

Finding fsck was quite an adventure, but now we can move on to finding mount and umount. A search on LSM comes up with a number of matches, but most of them point to various versions of a package called util-linux. All we have to do is scroll through and pick the most recent release. The LSM entry for util-linux lists a lot of utilities besides just mount and umount. We should definitely scan through the list to see if any of the other util-linux commands show up in the FHS requirements for /bin and /sbin.

Below is a list of packages we have gathered so far and the utilities that match up with FHS.

• e2fsprogs -- fsck, fsck.ext2 (e2fsck), mkfs.ext2 (mke2fs)

• util-linux -- dmesg, getty (agetty), kill, login, mount, swapon, umount

5.2.3. Automating fsck and mount

Now that we have fsck and mount commands we need to come up with a shell script to automate checking and mounting the local filesystems. An easy way to do this would be to write a short, two line script that calls fsck and then mount. But, what if the filesystems are not clean? The system should definitely not try to mount a corrupted filesystem. Therefore we need to devise a way of determining the status of the filesystems before mounting them. The manpage for fsck gives some insight into how this can be accomplished using return codes. Basically, if fsck returns a code of zero or one it means the filesystem is okay and a return code of two or greater means some kind of manual intervention is needed. A simple if-then statement could evaluate the fsck return code to determine whether or not the filesystem should be mounted. For help on writing shell scripts we can turn to the BASH(1) manpage and the Advanced-BASH-Scripting-Guide. Both references are freely available from the Linux Documentation Project web site at http://www.tldp.org.

5.2.4. File dependencies

The last thing to do is to figure out if any other files besides the binaries are needed. We learned about using ldd to check for library dependencies in the last phase of the project and we will use it to check the utilities in this phase too. There are also some other files that fsck and mount will need and the fsck(8) and mount(8) manpages give some insight into what those files are. There is /etc/fstab that lists devices and their mount points, /etc/mtab that keeps track of what is mounted, and a number of /dev files that represent the various disks. We will need to include all of these to have everything work right.

5.3.1. Install utilities from e2fsprogs

bash# cd /usr/src/e2fsprogs-1.34 bash# export CC="gcc -mcpu=i386" bash# ./configure --host=i386-pc-linux-gnu bash# make bash# cd e2fsck bash# cp e2fsck.shared ~/staging/sbin/e2fsck bash# ln -s e2fsck ~/staging/sbin/fsck.ext2 bash# cd ../misc bash# cp fsck mke2fs ~/staging/sbin bash# ln -s mke2fs ~/staging/sbin/mkfs.ext2

5.3.2. Install utilities from util-linux

bash# cd /usr/src/util-linux-2.11z

Use a text editor to make the following changes to MCONFIG:

• Change "CPU=$(shell uname -m)" to "CPU=i386"

• Change "HAVE_SHADOW=yes" to "HAVE_SHADOW=no"

bash# ./configure bash# make bash# cp disk-utils/mkfs ~/staging/sbin bash# cp fdisk/fdisk ~/staging/sbin bash# cp login-utils/agetty ~/staging/sbin bash# ln -s agetty ~/staging/sbin/getty bash# cp login-utils/login ~/staging/bin bash# cp misc-utils/kill ~/staging/bin bash# cp mount/mount ~/staging/bin bash# cp mount/umount ~/staging/bin bash# cp mount/swapon ~/staging/sbin bash# cp sys-utils/dmesg ~/staging/bin

5.3.3. Check library requirements

bash# ldd ~/staging/bin/* | more bash# ldd ~/staging/sbin/* | more bash# ls ~/staging/lib

All of the dependencies revealed by the ldd command are for libraries already present in the staging area so there is no need to copy anything new.

5.3.4. Strip binaries to save space

bash# strip ~/staging/bin/* bash# strip ~/staging/sbin/*

5.3.5. Create additional device files

bash# mknod ~/staging/dev/ram0 b 1 0 bash# mknod ~/staging/dev/fd0 b 2 0 bash# mknod ~/staging/dev/null c 1 3

5.3.6. Create the fstab and mtab files

bash# cd ~/staging/etc

Use an editor like vi, emacs or pico to create the following file and save it as ~/staging/etc/fstab.

proc /proc proc defaults 0 0 /dev/ram0 / ext2 defaults 1 1

Create an empty mtab file.

bash# echo -n >mtab

5.3.7. Write a script to check and mount local filesystems

Use an editor to create the following shell script and save it as ~/staging/etc/init.d/local_fs:

#!/bin/sh # # local_fs - check and mount local filesystems # PATH=/sbin:/bin ; export PATH fsck -ATCp if [ $(($?)) -gt $((1)) ]; then echo "Filesystem errors still exist! Manual intervention required." /bin/sh else echo "Remounting / as read-write." mount -n -o remount,rw / echo -n >/etc/mtab mount -f -o remount,rw / echo "Mounting local filesystems." mount -a -t nonfs,nosmbfs fi # # end of local_fs

Set execute permissions on the script.

bash# chmod +x local_fs

5.3.8. Create a compressed root disk image

bash# cd / bash# dd if=/dev/zero of=/dev/ram7 bs=1k count=4096 bash# mke2fs -m0 /dev/ram7 bash# mount /dev/ram7 /mnt bash# cp -dpR ~/staging/* /mnt bash# umount /dev/ram7 bash# dd if=/dev/ram7 of=~/phase4-image bs=1k bash# gzip -9 ~/phase4-image

5.3.9. Write the root disk image to floppy

Insert the diskette labled "root disk" into drive fd0.

bash# dd if=~/phase4-image.gz of=/dev/fd0 bs=1k

5.4.1. System startup

Start the system using the following procedure:

• Boot the PC using the floppy labled "boot disk".

• Type bootdisk init=/bin/sh at the LILO prompt.

• Put in the recently created root disk when prompted.

The output should resemble the example below:

boot: bootdisk init=/bin/sh Loading bootdisk Uncompressing Linux... Ok, booting kernel. .. .. [various kernel messages] .. VFS: Insert root floppy to be loaded into RAM disk and press ENTER RAMDISK: Compressed image found at block 0 VFS: Mounted root (ext2 filesystem) readonly. Freeing unused kernel memory: 178k freed # _

5.4.2. Test the local_fs script

Run the script by typing the following commands at the shell prompt:

bash# PATH=/sbin:/bin:/etc/init.d ; export PATH bash# cat /etc/mtab bash# local_fs bash# cat /etc/mtab bash# df

If everything is working properly, then the screen output should look something like the example below.

bash# PATH=/sbin:/bin:/etc/init.d ; export PATH bash# cat /etc/mtab bash# local_fs /dev/ram0: clean 74/1024 files 3178/4096 blocks Remounting / as read-write. Mounting local filesystems. bash# cat /etc/mtab /dev/ram0 / ext2 rw 0 0 proc /proc proc rw 0 0 bash# df Filesystem 1k-blocks Used Available Use% Mounted on /dev/ram0 3963 3045 918 77% /

5.4.3. Create and mount additional filesystems

Remove the root disk floppy and insert a blank diskette labeled "home". Then type the following commands:

bash# mkfs -t ext2 /dev/fd0 bash# fsck /dev/fd0 bash# mount /dev/fd0 /home bash# mkdir /home/floyd bash# cd /home/floyd bash# echo "Goodbye cruel world." > goodbye.txt bash# cat goodbye.txt

5.4.4. System shutdown

bash# cd / bash# umount /home

Remove the diskette from fd0 and restart the system using CTRL-ALT-DELETE.

6.2.1. Determining necessary utilities

We need an init daemon to automate start-up. We know this because the Bootdisk-HOWTO and From-Powerup-To-BASH-Prompt-HOWTO both make mention of init as the first program to start after the kernel loads. The latter HOWTO also goes into some detail about the /etc/inittab file and the organization of startup scripts. This could be helpful since FHS, the blueprint we have used so far, makes no recommendation for init scripts.

We will also need to find the shutdown command to fulfill the second goal of graceful shutdown capability.

6.2.2. Obtaining source code

Searching the Linux Software Map on Ibiblio for the keyword "init" gives a large number of results. From reading the From-Powerup-To-BASH-Prompt-HOWTO however, we know that most Linux systems use a System V style init daemon. Narrowing the search with the additional key phrase of "System V" gives much better results. The sysvinit package contains init, shutdown, halt and reboot which is everything we need. The version listed in the LSM entry looks to be pretty old, but there is a primary-site URL that will probably lead to the latest version.

6.2.3. Checking Dependencies

The manpage for init mentions a FIFO called /dev/initctl that is required for init to communicate with other programs in the sysvinit package. We will have to create this file for init to function properly.

6.2.4. Outlining start-up scripts

Many of the popular GNU/Linux distributions use System V style init scripts. Since we are using a "sysvinit" daemon it makes since to use System V style scripts as well. The following documents all touch upon the System V style init scripts in some way and will serve as references when building the scripts for this project:

• The Debian Policy Manual -- available online at http://www.debian.org/doc/debian-policy.

• The Linux Standard Base specification -- downloadable in many formats from http://www.linuxbase.org/spec/index.shtml.

• Essential System Administration, 3rd Edition by Aeleen Frisch -- available at libraries, bookstores or directly from O'Reilly Publishing at http://www.oreilly.com/.

After glancing at one or two of the above references we should have a pretty good idea of how the System V style system initialization process works. We should also know what it takes to create System V style init scripts for the Pocket Linux project. Below is a brief list of what needs to be done:

• Create an inittab file to call an rc script with a numerical argument giving the runlevel.

• Write an rc script that use the runlevel argument to execute the appropriate "K" and "S" scripts.

• Modify the previously built local_fs script to take start and stop arguments.

• Create new scripts for shutdown and reboot.

• Set up /etc/rcN.d directories and links to scripts in /etc/init.d.

As always, the BASH(1) manpage and the Advanced BASH Scripting Guide are very helpful for writing and understanding shell scripts.

6.3.1. Install sysvinit utilities

bash# cd /usr/src/sysvinit-2.85/src bash# make CC="gcc -mcpu=i386" bash# cp halt init shutdown ~/staging/sbin bash# ln -s halt ~/staging/sbin/reboot bash# ln -s init ~/staging/sbin/telinit bash# mknod ~/staging/dev/initctl p

In the interest of speed we are skipping the steps for checking libraries and stripping binaries. The library requirements for sysvinit are very basic and the Makefile is configured to automatically strip the binaries.

6.3.2. Create /etc/inittab file

Use a text editor to create the following file and save it as ~/staging/etc/inittab

# /etc/inittab - init daemon configuration file # # Default runlevel id:1:initdefault: # # System initialization si:S:sysinit:/etc/init.d/rc S # # Runlevel scripts r0:0:wait:/etc/init.d/rc 0 r1:1:respawn:/bin/sh r2:2:wait:/etc/init.d/rc 2 r3:3:wait:/etc/init.d/rc 3 r4:4:wait:/etc/init.d/rc 4 r5:5:wait:/etc/init.d/rc 5 r6:6:wait:/etc/init.d/rc 6 # # end of /etc/inittab

6.3.3. Create /etc/init.d/rc script

Use a text editor to create the following file and save it as ~/staging/etc/init.d/rc

#!/bin/sh # # /etc/init.d/rc - runlevel change script # PATH=/sbin:/bin SCRIPT_DIR="/etc/rc$1.d" # # Check that the rcN.d directory really exists. if [ -d $SCRIPT_DIR ]; then # # Execute the kill scripts first. for SCRIPT in $SCRIPT_DIR/K*; do if [ -x "$SCRIPT" ]; then $SCRIPT stop; fi; done; # # Do the Start scripts last. for SCRIPT in $SCRIPT_DIR/S*; do if [ -x $SCRIPT ]; then $SCRIPT start; fi; done; fi # # end of /etc/init.d/rc

Make the file executable.

bash# chmod +x ~/staging/etc/init.d/rc

6.3.4. Modify /etc/init.d/local_fs script

A case statement is added to allow the script to either mount or dismount local filesystems depending on the command-line argument given. The original script is contained inside the "start" portion of the case statement. The "stop" portion is new.

#!/bin/sh # # local_fs - check and mount local filesystems # PATH=/sbin:/bin ; export PATH case $1 in start) echo "Checking local filesystem integrity." fsck -ATCp if [ $(($?)) -gt $((1)) ]; then echo "Filesystem errors still exist! Manual intervention required." /bin/sh else echo "Remounting / as read-write." mount -n -o remount,rw / echo -n > /etc/mtab mount -f -o remount,rw / echo "Mounting local filesystems." mount -a -t nonfs,smbfs fi ;; stop) echo "Unmounting local filesystems." umount -a -r ;; *) echo "usage: $0 start|stop"; ;; esac # # end of local_fs

6.3.5. Create a hostname script

Use a text editor to create the following script and save it as ~/staging/etc/init.d/hostname

#!/bin/sh # # hostname - set the system name to the name stored in /etc/hostname # PATH=/sbin:/bin ; export PATH echo "Setting hostname." if [ -f /etc/hostname ]; then hostname $(cat /etc/hostname) else hostname gnu-linux fi # # end of hostname

6.3.6. Create halt & reboot scripts

Use a text editor to create ~/staging/etc/init.d/halt as shown below.

#!/bin/sh # # halt - halt the system # PATH=/sbin:/bin ; export PATH echo "Initiating system halt." halt # # end of /etc/init.d/halt

Create the following script and save it as ~/staging/etc/init.d/reboot

#!/bin/sh # # reboot - reboot the system # PATH=/sbin:/bin ; export PATH echo "Initiating system reboot." reboot # # end of /etc/init.d/reboot

Flag all script files as executable.

bash# chmod +x ~/staging/etc/init.d/*

6.3.7. Create rcN.d directories and links

bash# cd ~/staging/etc bash# mkdir rc0.d rc1.d rc2.d rc3.d rc4.d rc5.d rc6.d rcS.d bash# cd ~/staging/etc/rcS.d bash# ln -s ../init.d/local_fs S20local_fs bash# ln -s ../init.d/hostname S30hostname bash# cd ~/staging/etc/rc0.d bash# ln -s ../init.d/local_fs K10local_fs bash# ln -s ../init.d/halt K90halt bash# cd ~/staging/etc/rc6.d bash# ln -s ../init.d/local_fs K10local_fs bash# ln -s ../init.d/reboot K90reboot

6.3.8. Create the root disk image

bash# cd / bash# dd if=/dev/zero of=/dev/ram7 bs=1k count=4096 bash# mke2fs -m0 /dev/ram7 bash# mount /dev/ram7 /mnt bash# cp -dpR ~/staging/* /mnt bash# umount /dev/ram7 bash# dd if=/dev/ram7 of=~/phase5-image bs=1k bash# gzip -9 ~/phase5-image

6.3.9. Copy the image to diskette

Insert the diskette labled "root disk" into drive fd0.

bash# dd if=~/phase5-image.gz of=/dev/fd0 bs=1k

6.4.1. System Startup

Boot the PC using the floppy labled "boot disk" and press Enter at the LILO prompt. Place the recently created root disk in fd0 when prompted. The output should resemble the example below:

boot: bootdisk Loading bootdisk Uncompressing Linux... Ok, booting kernel. .. .. [various kernel messages] .. VFS: Insert root floppy to be loaded into RAM disk and press ENTER RAMDISK: Compressed image found at block 0 VFS: Mounted root (ext2 filesystem) readonly. Freeing unused kernel memory: 178k freed Checking local filesystem integrity. /dev/ram0: clean 105/1024 files 2842/4096 blocks Remounting / as read-write. Mounting local filesystems. Setting the hostname. INIT: Entering runlevel: 1 # _

6.4.2. Verify success of startup scripts

Use the mount command to check that local filesystems are mounted as read-write. The output should look like the example below.

bash# mount /dev/root on / type ext2 (rw) proc on /proc type proc (rw)

Check the hostname.

bash# uname -n gnu-linux

6.4.3. System shutdown

Bring the system down gracefully with the shutdown command.

bash# shutdown -h now

We should see the following output from init and the shutdown scripts:

INIT: Switching to runlevel: 0 INIT: Sending processes the TERM signal Terminated INIT: Sending processes the KILL signal Unmounting local filesystems. Remounting / as read-only. Initiating system halt. System halted.

7.2.1. The login process

The From-Powerup-To-BASH-Prompt-HOWTO does a good job of outlining the steps in the login process. Basically it works like this.

1. The init daemon starts a getty process on the terminal.

2. The getty program displays the contents of /etc/issue and prompts for a user name.

3. When the user name is entered, control is handed off to the login program.

4. The login program asks for a password and verifies the credentials using /etc/passwd, /etc/group and possibly /etc/shadow.

5. If everything is okay the user's shell is started.

7.2.2. Obtaining source code

The getty and login programs were already installed as part of util-linux.

7.2.3. Creating support files

7.2.4. Dependencies

Running ldd on the login program from util-linux will reveal that it is linked to the library libcrypt.so.1. In addition to libcrypt, there is another, less obvious library dependency on libnss_files.so.2 and the configuration file /etc/nsswitch.conf. The name service switch library libnss_files.so.2 and nsswitch.conf are required for the login program to access the /etc/passwd file. Without libnss and its configuration file, all logins will mysteriously fail. More information about the name service switch libraries can be found by searching the libc info page for the keyword "nss". The same information is also available online at http://www.gnu.org/manual/glibc-2.2.5/libc.html.

7.2.5. Assigning ownership and permissions

Previously, with the single user system, there was no need to worry about permissions when installing directories, files and device nodes. The shell was effectively operating as root, so everything was accessible. Things become more complex with the addition of multiple user capability. Now we need to make sure that every user has access to what they need and at the same time gets blocked from what they do not need.

A good guideline for assigning ownership and permissions would be to give the minimum level of access required. Take the /bin directory as an example. The Filesystem Hierarchy (FHS) document says, "/bin contains commands that may be used by both the system administrator and by users". From that statement we can infer that /bin should have read and execute permission for everyone. On the other hand, the /boot directory contains files for the boot loader. Chances are good that regular users will not need to access anything in the /boot directory. So the minimum level of access would be read permission for the root user and other administrators who are members of the root group. Normal users would have no permissions assigned on the /boot directory.

Most of the time we can assign similar permissions to all the commands in a directory, but there are some programs that prove to be exceptions to the rule. The su command is a good example. Other commands in the /bin directory have a minimum requirement of read and execute, but the su command needs to be setuid root in order to run correctly. Since it is a setuid binary, it might not be a good idea to allow just anyone to run it. Ownership of 0:0 (root user, root group) and permissions of rwsr-x--- (octal 4750) would be a good fit for su.

The same logic can be applied to other directories and files in the root filesystem using the following steps:

1. Assign ownership to the root user and root group.

2. Set the most restrictive permissions possible.

3. Adjust ownership and permissions on an "as needed" basis.

7.3.1. Verify presence of getty and login

bash# ls ~/staging/sbin/getty bash# ls ~/staging/bin/login

7.3.2. Modify inittab for multi-user mode

Modify ~/staging/etc/inittab by changing the default runlevel and adding getty entries as shown below.

# /etc/inittab - init daemon configuration file # # Default runlevel id:2:initdefault: # # System initialization si:S:sysinit:/etc/init.d/rc S # # Runlevel scripts r0:0:wait:/etc/init.d/rc 0 r1:1:respawn:/bin/sh r2:2:wait:/etc/init.d/rc 2 r3:3:wait:/etc/init.d/rc 3 r4:4:wait:/etc/init.d/rc 4 r5:5:wait:/etc/init.d/rc 5 r6:6:wait:/etc/init.d/rc 6 # # Spawn virtual terminals 1:235:respawn:/sbin/getty 9600 tty1 linux 2:235:respawn:/sbin/getty 9600 tty2 linux 3:235:respawn:/sbin/getty 9600 tty3 linux 4:235:respawn:/sbin/getty 9600 tty4 linux 5:235:respawn:/sbin/getty 9600 tty5 linux 6:2345:respawn:/sbin/getty 9600 tty6 linux # # end of /etc/inittab

7.3.3. Create tty devices

bash# cd ~/staging/dev bash# mknod tty0 c 4 0 bash# mknod tty1 c 4 1 bash# mknod tty2 c 4 2 bash# mknod tty3 c 4 3 bash# mknod tty4 c 4 4 bash# mknod tty5 c 4 5 bash# mknod tty6 c 4 6 bash# mknod tty c 5 0

7.3.4. Create support files in /etc

7.3.5. Copy required libraries

bash# cp /lib/libnss_files.so.2 ~/staging/lib

7.3.6. Set directory and file permissions

Set minimal privileges on all files and directories under ~/staging. Everything is owned by the root user and the root group. Permissions are read-write for the owner and read-only for the group. Exceptions to the blanket permissions are handled case-by-case.

bash# cd ~/staging bash# chown -R 0:0 * bash# chmod -R 640 *

Set execute permission on all directories. (Note the capital "X")

bash# chmod -R +X *

Files in /bin are read and execute for all, but su is an exception.

bash# chmod 755 bin/* bash# chmod 4750 bin/su

Files in /dev have various permissions. Disk devices should be accessible to administrators only. Other files like /dev/null should have full privileges granted to everyone.

bash# chmod 660 dev/fd0 dev/ram0 bash# chmod 666 dev/null bash# chmod 622 dev/console bash# chmod 600 dev/initctl bash# chmod 622 dev/tty bash# chmod 622 dev/tty?

The passwd and group files must be world readable.

bash# chmod 644 etc/passwd bash# chmod 644 etc/group

The scripts in /etc/init.d are read and execute for administrators.

bash# chmod 750 etc/init.d/*

Libraries need read and execute permissions for everyone.

bash# chmod 755 lib/*

Only root should have access to the /root directory.

bash# chmod 700 root

Make files in /sbin read and execute for administrators.

bash# chmod 750 sbin/*

Temp should be read-write for all with the sticky bit set.

bash# chmod 1777 tmp

7.3.7. Create the root disk image

bash# cd / bash# dd if=/dev/zero of=/dev/ram7 bs=1k count=4096 bash# mke2fs -m0 /dev/ram7 bash# mount /dev/ram7 /mnt bash# cp -dpR ~/staging/* /mnt bash# umount /dev/ram7 bash# dd if=/dev/ram7 of=~/phase6-image bs=1k bash# gzip -9 ~/phase6-image

7.3.8. Copy the image to diskette

Insert the diskette labled "root disk" into drive fd0.

bash# dd if=~/phase6-image.gz of=/dev/fd0 bs=1k

7.4.1. System Startup

If everything goes well, the virtual console display should look similar to the following example:

Connected to tty1 at 9600 bps. gnu-linux login:

7.4.2. Add a new user to the system

Log in as root.

Create a new, unprivileged user and new group by appending a line to the /etc/passwd and /etc/group files, respectively. Be sure to use a double greater-than (>>) to avoid accidentally overwriting the files.

bash# echo "floyd::501:500:User:/home/floyd:/bin/sh" >>/etc/passwd bash# echo "users::500:" >>/etc/group bash# mkdir /home/floyd bash# chown floyd.users /home/floyd bash# chmod 700 /home/floyd

7.4.3. Test the new user's ability to use the system

Switch to virtual terminal tty2 by pressing ALT+F2.

Log in as floyd.

Try the following commands and verify that they work.

bash$ pwd bash$ ls -l / bash$ cat /etc/passwd

Try the following commands and verify that they do not work.

bash$ ls /root bash$ /sbin/shutdown -h now bash$ su -

7.4.4. System shutdown

Switch back to tty1 where root is logged in.

bash# shutdown -h now

8.2.1. more

There is a more command that comes with util-linux, but it will not work for this project. The reason is because of library dependencies and space constraints. The util-linux supplied more needs either the libncurses or libtermcap to work and there just is not enough space on the root disk floppy to fit everything in. So, in order to have a more command we will have to get creative.

The more command is used to display a file page-by-page. It's a little like having a cat command that pauses every twenty-five lines. The basic logic is outlined below.

• Read one line of the file.

• Display the line on the screen.

• If 25 lines have been displayed, pause.

• Loop and do it again.

Of course there are some details left out like what to do if the screen dimensions are not what we anticipated, but overall it is a fair representation of what more does. Given this simple program logic, it should not be hard to put together a short shell script that emulates the basic functionality of more. The BASH(1) manpage and Adv-BASH-Scripting-Guide will serve as references.

8.2.2. More device files

The more script will need access to device files that are not on the root disk yet. Specifically more needs to have stdin, stdout and stderr, but while we are at it we should check for any other missing /dev files. The Linux Standard Base requires null, zero and tty to be present in the /dev directory. Files for null and tty already exist from previous phases of the project, but we still need /dev/zero. We can refer to devices.txt in the Linux source code Documentation directory for major and minor numbers.

8.2.3. ps, sed & ed

These three packages can be found by using the Internet resources we have used before plus one new site. The "sed" and "ed" packages can be found at the same place we found BASH, on the GNU FTP server. The procps package shows up in an Ibiblio LSM search, but it is an old version. In order to find the latest version we can go to the Freshmeat website at http://freshmeat.net and search for "procps" in projects.

Both "sed" and "ed" packages feature GNU's familiar configure script and are therefore very easy to build. There is no configure script for "procps" but this does not make things too difficult. We can just read the package's README file to find out about how to set various configuration options. We can use one of these options to avoid the complexity of using and installing libproc. Setting SHARED=0 makes libproc an integrated part of ps rather than a separate, shared library.

8.3.1. Write a "more" script

Create the following script with a text editor and save it as ~/staging/bin/more.sh

#!/bin/sh # # more.sh - emulates the basic functions of the "more" binary without # requiring ncurses or termcap libraries. # # Assume input is coming from STDIN unless a valid file is given as # a command-line argument. if [ -f "$1" ]; then INPUT="$1" else INPUT="/dev/stdin" fi # # Set IFS to newline only. See BASH(1) manpage for details on IFS. IFS=$'\n' # # If terminal dimensions are not already set as shell variables, take # a guess of 80x25. if [ "$COLS" = "" ]; then COLS=80; fi if [ "$ROWS" = "" ]; then ROWS=25; fi # # Initialize line counter variable ROW_COUNTER=$ROWS # # Read the input file one line at a time and display on STDOUT until # the page fills up. Display "Press <Enter>" message on STDERR and wait # for keypress from STDERR. Continue until the end of the input file. # Any input line greater than $COLS characters in length is wrapped and # counts as multiple lines. # while read -n $COLS LINE_BUFFER; do echo "$LINE_BUFFER" ROW_COUNTER=$(($ROW_COUNTER - 1)) if [ $ROW_COUNTER -le 1 ]; then echo "Press <ENTER> for next page or <CTRL>+C to quit.">/dev/stderr read</dev/stderr ROW_COUNTER=$ROWS fi done<$INPUT # # end of more.sh

Create a symbolic link for more

bash# ln -s more.sh ~/staging/bin/more

8.3.2. Create additional device files

bash# ln -s /proc/self/fd ~/staging/dev/fd bash# ln -s fd/0 ~/staging/dev/stdin bash# ln -s fd/1 ~/staging/dev/stdout bash# ln -s fd/2 ~/staging/dev/stderr bash# mknod -m644 ~/staging/dev/zero c 1 5

8.3.3. Install ps

bash# cd /usr/src/procps-3.1.14 bash# make SHARED=0 CC="gcc -mcpu=i386" bash# cd ps bash# cp ps ~/staging/bin

8.3.4. Install sed

bash# cd /usr/src/sed-4.07 bash# export CC="gcc -mcpu=i386" bash# ./configure --host=i386-pc-linux-gnu bash# make bash# cd sed bash# cp sed ~/staging/bin

8.3.5. Install ed

bash# cd /usr/src/ed-0.2 bash# ./configure --host=i386-pc-linux-gnu bash# make bash# cp ed ~/staging/bin

8.3.6. Strip binaries to save space

bash# strip ~/staging/bin/*

8.3.7. Ensure proper permissions

bash# chown 0:0 ~/staging/bin/* bash# chmod -R 755 ~/staging/bin bash# chmod 4750 ~/staging/bin/su

8.3.8. Create the root disk image

bash# cd / bash# dd if=/dev/zero of=/dev/ram7 bs=1k count=4096 bash# mke2fs -m0 /dev/ram7 bash# mount /dev/ram7 /mnt bash# cp -dpR ~/staging/* /mnt bash# umount /dev/ram7 bash# dd if=/dev/ram7 of=~/phase7-image bs=1k bash# gzip -9 ~/phase7-image

8.3.9. Copy the image to diskette

Insert the diskette labled "root disk" into drive fd0.

bash# dd if=~/phase7-image.gz of=/dev/fd0 bs=1k

8.4.1. System startup

Boot from the diskset in the usual way and log in as root.

8.4.2. Test the "more" script

Display kernel messages by piping the output of dmesg to more.

bash# dmesg | more

Examine the local_fs script by using more with a command-line argument.

bash# more /etc/init.d/local_fs

8.4.3. Use ps to show running processes

Display processes for the user currently logged in.

bash# ps

Display all available information about all running processes.

bash# ps -ef

8.4.4. Run a simple sed script

Use sed to display an alternate version of /etc/passwd.

bash# sed -e "s/Legacy/Old School/" /etc/passwd

Verify that sed did not make the changes permanent.

bash# cat /etc/passwd

8.4.5. Test the "ed" editor

Use ed to change properties on the "daemon" user.

bash# ed -p* ed* r /etc/passwd ed* %p ed* /daemon/s/Legacy/Old School/ ed* %p ed* w ed* q

Verify that the changes are permanent (at least until the system is restarted.)

bash# cat /etc/passwd

8.4.6. System shutdown

Bring the system down gracefully with the shutdown command.