Introduction

Having used a number of different Linux distributions, I was never fully satisfied with any of those. I didn't like the way the bootscripts were arranged, or I didn't like the way certain programs were configured by default and more of those things. I came to realize that when I want to be totally satisfied with a Linux system, I have to build my own Linux system from scratch, ideally only using the source code. Not using pre-compiled packages of any kind. No help from some sort of cdrom or bootdisk that would install some basic utilities. You would use your current Linux system and use that one to build your own.

This, at one time, wild idea seemed very difficult and at times almost impossible. The reason for most problems were due to my lack of knowledge about certain programs and procedures. After sorting out all kinds of dependency problems, compilation problems, etcetera, a custom built Linux system was created and fully operational. I called this system an LFS system, which stands for LinuxFromScratch.

How things are going to be done

We are going to build the LFS system using an already installed Linux distribution such as Debian, SuSe, Slackware, Mandrake, RedHat, etc. You don't need to have any kind of bootdisk. We will use an existing Linux system as the base (since we need a compiler, linker, text editor and other tools).

If you don't have Linux installed yet, you won't be able to put this book to use right away. I suggest you first install a Linux distribution. It really doesn't matter which one you install. It also doesn't need to be the latest version, though it shouldn't be a too old one. If it is about a year old or newer it should do just fine. You will safe yourself a lot of trouble if your normal system uses glibc-2.0 or newer. Libc5 isn't supported by this book, though it isn't impossible to use a libc5 system if you have no choice.

Book versions

This is LFS-BOOK version 2.4.2-pre1 version dated October 11th, 2000. If this version is older than a month you definitely want to take a look at our website and download a newer version.

Below you will find a list of our current HTTP mirror sites as of September 18th, 2000. This list might not be accurate anymore. For the latest info check our website at http://www.linuxfromscratch.org

• Columbus, Ohio, United States [1] - http://www.linuxfromscratch.org/intro.php

• Columbus, Ohio, United States [2] - http://lfs.bcpub.com/intro.html

• United States - http://lfs.sourceforge.net/intro.php

• San Antonio, Texas, United States http://lfs.codecastle.com/intro.html

• Paris, France, Europe http://lfs.linuxien.com/intro.html

• Braunschweig, Niedersachsen, Germany - http://134.169.139.209/index2.html

Acknowledgements

I would like to thank the following people and organizations for their contributions towards the LinuxFromScratch project:

• Bryan Dumm for providing the hardware to run linuxfromscratch.org and for providing http://www.bcpub.com as the lfs.bcpub.com mirror

• Jan Niemann for providing http://helga.lk.etc.tu-bs.de as the 134.169.139.209 mirror

• Johan Lenglet for providing http://www.linuxien.com as the www.linuxien.com/lfs mirror

• David Downey for providing http://www.codecastle.com as the lfs.codecastle.com mirror

• Michael Peters for contributing the Apple PowerPC modifications

• VA Linux Systems who, on behalf of Linux.com, donated a VA Linux 420 (formerly StartX SP2) workstation towards this project

• Jesse Tie Ten Quee who donated a Yamaha CDRW 8824E CD-RW.

• DREAMWVR.COM for their ongoing sponsorhip.

• O'Reilly for donating books on SQL and PHP.

• Robert Briggs for donating the linuxfromscratch.org and linuxfromscratch.com domain names.

• Countless other people from the various LFS mailinglists who are making this book happen by making suggestions, testing and submitting bug reports.

Changelog

If, for example, a change is listed for chapter 5 it (usually) means the same change has been done in the chapters for the other architectures.

2.4.2-pre1 October 11th, 2000

• Chapter 3: Newer verions were mentioned, but the links were still pointing to the older versions. Besides that I forgot to put the newer package versions in the ftp archive. Both have been fixed now.

• Chapter 5: Instead of looking at the filename of the C library files to determine which C library your starting Linux system uses we'll obtain it by running "strings /lib/libc* | grep "release version"" instead.

• Chapter 5+6: The proc file system must be mounted in chapter 5 before we enter the chroot'ed environment since after chroot the mount program will not be available yet.

• Chapter 6: Fixed a HTML bug in the GCC installation which caused a CR character to appear in certain browser.

2.4.1 - October 10th, 2000

• Removed the bash prompts from the commands. This will make it much easier to copy & paste the commands from the book onto the command line. Typing them all out is great for the first few times, but it tends to get tedious after a while. You can of course use scripts to do this all, but that's not the goal of this book. That's part of a different project (alfs.linuxfromscratch.org).

• Swapped chapters 8 and 9. Now we first reboot and then setup networking. If done the other way around, networking programs won't work unless both the normal system and the LFS system are going to run the same kernel version, which often is not the case. Swapping the chapters eliminates that possible problem.

• Chapter 3: All packages have been moved to download.linuxfromscratch.org and the links are updated accordingly. The official download sites for all the packages are listed in Appendix C.

• Chapter 5+6: Moved the execution of localedef after Glibc in chapter 5 to after you entered chroot in chapter 6. It was a mistake (the only real bug in 2.4) to put it in chapter 5.

• Chapter 6: Installing Vim as the first program. In case you need to edit something you an editor available right away. This also caused a couple of other packages to be moved to satisfy depencies.

• Chapter 6: When we use sed to modify a Makefile file we now run make as "make -f Makefile2" instead of "mv Makefile2 Makefile && make".

• Chapter 6: Added the "publickey: files" line to the nsswitch.conf file. This is needed when you run a 2.4 kernel to login properly.

• Chapter 6: Added the /usr/bin/yacc script that runs bison with the -y switch to emulate yacc's output file name conventions. This is done because there are a few packages out there that rely on yacc and can't work with bison (yet).

• Chapter 6: Modified the /usr/sbin/makewhatis script after the installation of the man package. The /usr/sbin/makewhatis script needs the AWK= variable defined to /usr/bin/mawk.

• Chapter 7: Added the template script. This way you can easily add new bootscripts without having to write them from scratch.

2.4 - August 28th, 2000

• Split the book up into two differnet books for Intel and PPC.

• Chapter 4: Added the mail and dev/pts directories to the "Creating directories" section.

• Chapter 5: Everything from chroot and after has been put in a new chapter.

• Chapter 6: Moved the optimization part to the point just before you enter the chroot'ed environment. It's a waste to use compiler optimizations for the static packages since they will be replaced anyways.

• Chapter 6: To enter chroot we first cd to the $LFS/root directory. Some older chroot programs have problems when you enter chroot when your starting directory isn't inside the chroot environment. Also we don't execute bash directly in the chroot'ed environment, but we start the "env" program so we can enter with a clean environment that only has CFLAGS and CXXFLAGS set.

• Chapter 6: A few people have had problems compiling M4 in the chroot'ed enviroment. Instructions are provided how to install this package statically for the affected users.

• Chapter 6: We can't move the 'mv' program during the dynamic installation of the fileutils package with the mv program. So we copy it to /bin first, then remove the /usr/bin/mv one.

• Chapter 5: Added 'make localedata/install-locales' to the Glibc installation. This installs the locale files that various applications use (most notable GDK applications) if you have an NLS capable system (which LFS is, but with missing locales it's almost useless)

• Chapter 6: Moved vim's installation before Lilo since you might want to edit Lilo's Makefile file to add compiler optimization.

• Chapter 6: Moved the installatin of shadow password suit after sh-utils. Else sh-utils replaces the "su" version from shadow password with it's own version which shouldn't happen.

• Chapter 6: Changed the way we enter the chroot'ed environment. We use the "env" to create an empty enviroment so that enviroment variables from the normal Linux system won't interfer in the chroot enviroment. The only variable set when entering the chroot'ed environment is the HOME variable.

• Chapter 6: Because of the new way we enter chroot, the $LFS/root/.bash_profile file has been created that sets a few variables like TERM, CFLAGS, CXXFLAGS and whatever you deem necesarry.

2.3.7 - August 3rd, 2000

• All chapters: Removed the <blockquote> SGML tags so that the contents of files isn't indented anymore. This improves the easy of copy and pasting from the book into your files without needing to manually reformat the files to get rid of the indentations.

• Chapter 4: Added var/tmp to the "chmod 1777 tmp usr/tmp" command.

• Chapter 4: Made mkdir commands less repetitive by putting the creation of the directories in $LFS/usr and $LFS/usr/local in a for-loop.

• Chapter 5: Moved the chmod 754 command for MAKEDEV after the sed operation.

• Chapter 5: Changed the order in which packages are installed to conform more to a alphabetically ordering.

• Chapter 5: After console-tools has been installed the /usr/share/defkeymap.kmap.gz file is created which will be used by the loadkeys script.

• Chapter 5: Removed "gcc -c watch.c" from "Installing Procps". Please let us know if this is still needed on certain hardware.

• Chapter 5: Added the /usr/bin/install symbolic link as it seems that at least one package (sysklogd) has the install location hard coded in it's Makefile file.

• Chapter 5: After gettext has been installed, we have a file /po-mode.el. This file will be moved to /usr/share/gettext where it probably belongs.

• Chapter 5: Instead of passing --with-root-prefix=/ to e2fsprogs' configure script, we now pass --with-root-prefix=

• Chapter 5: When gzip is installed and the files moved to /bin the hard link between the files is removed. So we just move gzip to /bin and create a symlink between gzip and gunzip.

• Chapter 5: In the chroot environment: changed the installation order of a few packages who's dependencies have changed over time.

• Chapter 5: inittab file has been slightly updated to better support the single user run level. When you change to run level S, s or 1 it will do it's job properly now.

• Chapter 6: Fixed typo in the rc script (! -f sysinit_start -> ! -f $sysinit_start).

• Chapter 6: Changed the loadkeys command in the loadkeys script. New command is: loadkeys -d which loads the /usr/share/keymaps/defkeymap.kmap.gz file.

• Chapter 6: Changed ". /etc/init.d/functions" into "source /etc/init.d/functions".

• Chapter 6: Removed the "rm /fastboot" command from the checkfs script.

2.3.6 - July 19th, 2000

• Chapter 3: Re-ordered the software download list so it once again matches the order in which packages are used (the first package listed in the list is the first package that we will be using in the book, the second listed package will be the second package used in the book, etc).

• Chapter 3: Added the file sizes of the packages you have to download.

• Chapter 3: Removed the start-stop-daemon package.

• Chapter 3: Added the findutils and glibc patches to the package list.

• Chapter 3: Added the man-pages package to the package list.

• Chapter 4: Moved the creation of the $LFS/dev/ files to chapter 5 after we have entered the chroot environment. This is done because GID's on normal system and LFS system might differ and the MAKEDEV script depends on the GID's.

• Chapter 5: Added the installation of the man-pages package.

• Chapter 5: Added a few commonly used groups to the /etc/group file when it is created (these are the groups needed by the MAKEDEV script).

• Chapter 5: The /proc/devices file is copied to $LFS/proc for the benefit of the MAKEDEV script. The presence of this file ensures the proper creation of the device files.

• Chapter 5: Layout changes. Every package installation has it's own page now. Also the text from appendixa for every package is included with the installation instructions so you can read what a package is about during (or after or before) the installation of it.

• Chapter 5: Removed the patches for diffutils, grep, gzip and sed that used to fix static link problems. The problems can be fixed by passing compile arguments to the C pre-processor (cpp) instead.

• Chapter 5: Added the --disable-termcap option to configure to disable termcap backward compatibility (if you want to know why termcap isn't used anymore, please read the INSTALL file that comes with the Ncurses package).

• Chapter 5: Added a few missing files from the fileutils package to the "mv" commands.

• Chapter 5: Removed the installation of the start-stop-daemon package.

• Chapter 5: Removed the -e parameters from the make command lines.

• Chapter 5: Instead of editing the procinfo, procps and psmisc Makefile files with a text editor, the sed command it used.

• Chapter 6: Added the setclock script in case your hardware clock isn't set to GMT.

• Chapter 6: Removed the use of the start-stop-daemon program and replaced them with custom functions that use programs like pidof and kill to accomplish the same tasks but with more control over what happens.

• Chapter 6: Added the loadproc and killproc functions to the /etc/init.d/functions file that take over the functions the start-stop-daemon program used to perform.

• Chapter 6: When the checkfs script runs without errors it now prints a green OK.

• Chapter 6: When /fastboot or /forcefsck exist, they won't be deleted from within the checkfs script but from within the mountfs script as soon as the root partition has been remounted in read-write mode.

• Chapter 6 & 7: Instead of sourcing a file with ". /etc/init.d/functions", "source /etc/init.d/functions" is now used. This makes it easier to read and is clearer for persons who don't know much about scripting.

• Appendix A: removed start-stop-daemon.

• Appendix B: Removed a few unrelated items from the book and howto sections (the references to Sendmail and ISP-Hookup-HOWTO).

2.3.5 - June 19th, 2000

• Chapter 3: Updated LILO download location

• Chapter 3: Updated Shadow Password Suite download location

• Chapter 3: Updated the Flex download location

• Chapter 3: Updated the File download location

• Chapter 3: Added netkit-base and net-tools to the mandatory packages section

• Chapter 5: A glibc-2.1.3 patch is available if you have problems compiling glibc on a bash-2.04 machine.

• Chapter 5: Added compiler optimization

• Chapter 5: Added the creation of the root password to "Configuring essential software"

• Chapter 5: The Linux86 package has been replaced by the Bin86 package.

• Chapter 5: Included information on how to optimize compilations.

• Chapter 5: Moved installation of Groff and Man before Perl. This way Perl known how to install man pages and where to install them.

• Chapter 5: Changed GCC's local-prefix option to /usr/local instead of /usr (this was still a residue from the time where /usr/local was a symbolic link to /usr)

• Chaper 5: Fixed the commands when a patch is used and the patch filename contained the .gz suffix.

• Chapter 5: Added --disable-nls to every configure command in the "Perparing the LFS system..." section which didn't have it yet.

• Chapter 5: Added the installation of bash-2.03 so you have a shell that can be used to compile packages that violate POSIX standards regarding valid characters in variable names

• Chapter 5: Added the installation of console-tools and console-data for people who have non-US keyboards

• Chapter 5: Moved the ed program to the /bin directory conforming the FHS standard

• Chapter 6 & 7: Implemented LSB recommended run level scheme.

• Chapter 6 & 7: Implemented "fancy bootscripts". When something fails in a bootscript it still says FAILED but the text red. When something succeeded it still will print OK but the text is green.

• Chater 6: Added the loadkeys scripts for people with non-US keyboards

• Chapter 6: Added the /etc/sysconfig directory to "Creating directories"

• Chapter 6: Renamed the checkroot boot script into checkfs. The script also checks other file systems now.

• Chapter 6: Updated the mountfs boot script to mount all file systems that are mentioned in the /etc/fstab file and don't have the noauto option set.

• Chapter 6: After checkfs evaluated the existence of /fastboot or /forcecheck it will remove those files.

• Chapter 6 & 7: Changed the mode of the boot scripts from 755 to 754

• Chapter 7: Moved system specific information for hostname and ethernet configuration to the /etc/sysconfig/network file

• Chapter 7: Removed the default gateway command

• Chapter 7: Fixed the typo in the ethnet script (NETMAKSK -> NETMASK)

• Chapter 7: A net-tools patch is available to fix a minor bug in the package (illegal variable names that bash-2.04 will complain about)

2.3.4 - June 5th, 2000

• Chapter 5: Fixed the kernel header files configuration

• Chapter 5: Fixed the lilo configuration

2.3.3 - May 15th, 2000

• Changed the default mount point from /mnt/xxx to /mnt/lfs (where xxx used to be the partition's designation like hda5, sda5 and others). The reason for the change is to make cross-platform instructions easier.

• Chapter 4: Changed the default modes for the $LFS/root and $LFS/tmp directory to respectively 0750 and 1777.

• Chapter 5: Removed the encoded password from the passwd file. Instead a file with no set password is created. The root password can be set by the user when the system is rebooted into the LFS system (after chapter 8).

• Chapter 5: Fixed the procps compile command for watch.c. It should compile properly now.

• Chapter 5: Fixed gzip patch installation (used the wrong filename in the patch command

• Chapter 5: Changed 'entering the chroot'ed environment' to make bash a login shell.

• Chapter 5: Configuring the kernel has been moved to this chapter because it needs to be done before programs like e2fsprogs and lilo are compiled.

• Chapter 6: Fixed the rc script. It now checks to see if the previous run level starts a service before attempting to stop it in the new run level. Also, if a service is already started in the previous run level it won't attempt to start the service in the new run level again. Thanks to Jason Pearce for providing this fixed script.

• Chapter 7: Fixed the ethnet script - removed paratheses from the environment variables and removed the command to add a route. The ifconfig command used to bring the eth device up already sets this route.

2.3.2 - April 18th, 2000

• Chapter 4.7: Change only the owner of the $LFS/dev/* files

• Fixed a large amount of typo's that occured during the transistion from the LinuxDoc DTD (2.2 and lower) to the DocBook DTD (2.3.1 and higher).

• Moved chapters around quite a bit and applied a new structure in the book. Installations for Intel, Apple PowerPC and future systems will be put in their own dedicated part of the book.

• After the system is prepared to install the basic system software, we no longer reboot the system but instead we setup a chroot'ed environment. This will have the same effect without having to reboot.

• Apple PowerPC has it's own dedicated chapters now. This should increase readability a lot

• All optional chapters have been removed. LFS follows a "we provide the foundation, it's up to you to build the rest of the house" philosophy.

• Replaced the fixed packages by patch files. This way you can see what needs to be changed in a package in order to get it to compile properly.

2.3.1 - April 12th, 2000

• Chapter 4.4: Added the $LFS/usr/info symlink which points to $LFS/usr/share/info

• Chapter 7.3.1: Added a second variation to a 'swap-line' in a fstab file.

• Chapter 7.3.2: Removed $LFS from the commands.

• Chapter 7.4.43: Added the vi symlink

• Chapter 9.2.5: Improved ethnet script to include routing information

• Chapter 10.1.2: Fixed missing subdirectory 'mqueue' in mkdir /var/spool -> /mkdir /var/spool/mqueue

• Chapter 10.1.4: Updated the sendmail configuration file with a few necessary options

• Chapter 10.1.7: Fixed wrong directory path /etc/init.d/rc2.d -> /etc/rc2.d

Mailinglists and archives

The linuxfromscratch.org server is hosting the following public accessible mailinglists:

• lfs-discuss

• lfs-config

• lfs-apps

• lfs-announce

• linux

• alfs-discuss

• alfs-docs

• alfs-ipc

• alfs-license

• alfs-pr

• alfs-profile

Contact information

Direct all your emails to the lfs-discuss mailinglist preferably.

If you need to reach Gerard Beekmans personally, send an email to gerard@linuxfromscratch.org

If you need to reach Michael Peters, Apple PPC maintainer of this book, personally, send an email to mpters@mac.com

About $LFS

Please read the following carefully: throughout this document you will frequently see the variable name $LFS. $LFS must at all times be replaced by the directory where the partition that contains the LFS system is mounted. How to create and where to mount the partition will be explained later on in full detail in chapter 4. In my case the LFS partition is mounted on /mnt/lfs. If I read this document myself and I see $LFS somewhere, I will pretend that I read /mnt/lfs. If I read that I have to run this command: cp inittab $LFS/etc I actually will run this: cp inittab /mnt/lfs/etc

It's important that you do this no matter where you read it; be it in commands you enter on the prompt, or in some file you edit or create.

If you want, you can set the environment variable LFS. This way you can literally enter $LFS instead of replacing it by something like /mnt/lfs. This is accomplished by running: export LFS=/mnt/lfs

If I read cp inittab $LFS/etc, I literally can type cp inittab $LFS/etc and the shell will replace this command by cp inittab /mnt/lfs/etc automatically.

Do not forget to set the $LFS variable at all times. If you haven't set the variable and you use it in a command, $LFS will be ignored and whatever is left will be executed. The command cp inittab $LFS/etc without the LFS variable set, will result in copying the inittab file to the /etc directory which will overwrite your system's inittab. A file like inittab isn't that big a problem as it can easily be restored, but if you would make this mistake during the installation of the C Library, you can break your system badly and might have to reinstall it if you don't know how to repair it.

How to download the software

Throughout this document I will assume that you have stored all the packages you have downloaded somewhere in $LFS/usr/src.

I use the convention of having a $LFS/usr/src/sources directory. Under sources you'll find the directory 0-9 and the directories a through z. A package as sysvinit-2.78.tar.gz is stored under $LFS/usr/src/sources/s/ A package as bash-2.04.tar.gz is stored under $LFS/usr/src/sources/b/ and so forth. You don't have to follow this convention of course, I was just giving an example. It's better to keep the packages out of $LFS/usr/src and move them to a subdirectory, so we'll have a clean $LFS/usr/src directory in which we will unpack the packages and work with them.

The next chapter contains the list of all the packages you need to download, but the partition that is going to contain our LFS system isn't created yet. Therefore store the files temporarily somewhere where you want and remember to copy them to $LFS/usr/src/ when you have finished the chapter in which you prepare a new partition (which chapter exactly depends on your architecture).

How to install the software

Before you can actually start doing something with a package, you need to unpack it first. Often you will find the package files being tar'ed and gzip'ed (you can see this from a .tar.gz or .tgz extension). I'm not going to write down every time how to ungzip and how to untar an archive. I will tell you how to do that once, in this paragraph. There is also the possibility that you have the ability of downloading a .tar.bz2 file. Such a file is tar'ed and compressed with the bzip2 program. Bzip2 achieves a better compression than the commonly used gzip does. In order to use bz2 archives you need to have the bzip2 program installed. Most if not every distribution comes with this program so chances are high it is already installed on your system. If not, install it using your distribution's installation tool.

To start with, change to the $LFS/usr/src directory by running:

        cd $LFS/usr/src

When you have a file that is tar'ed and gzip'ed, you unpack it by running either one of the following two commands, depending on the filename format:

        tar xvfz filename.tar.gz
        tar xvfz filename.tgz

When you have a file that is tar'ed and bzip'ed, you unpack it by running:

        bzcat filename.tar.bz2 | tar xv

Some tar programs (most of them nowadays but not all of them) are slightly modified to be able to use bzip2 files directly using either the I or the y tar parameter which works the same as the z tar parameter to handle gzip archives.

When you have a file that is tar'ed, you unpack it by running:

        tar xvf filename.tar

When the archive is unpacked a new directory will be created under the current directory (and this document assumes that you unpack the archives under the $LFS/usr/src directory). You have to enter that new directory before you continue with the installation instructions. So everytime the book is going to install a program, it's up to you to unpack the source archive.

After you have installed a package you can do two things with it. You can either delete the directory that contains the sources or you can keep it. If you decide to keep it, that's fine by me. But if you need the same package again in a later chapter you need to delete the directory first before using it again. If you don't do this, you might end up in trouble because old settings will be used (settings that apply to your normal Linux system but which don't always apply to your LFS system). Doing a simple make clean does not always guarantee a totally clean source tree. The configure script can also have files lying around in various subdirectories which aren't always removed by a make clean process.

There is on exception to that rule: don't remove the linux kernel source tree. A lot of programs need the kernel headers, so that's the only directory you don't even want to remove, unless you are not going to compile any software anymore.

Introduction

In this chapter the partition that is going to host the LFS system is going to be prepared. A new partition will be created, an ext2 file system will be created on it and the directory structure will be created. When this is done, we can move on to the next chapter and start building a new Linux system from scratch.

Creating a new partition

Before we can build our new Linux system, we need to have an empty Linux partition on which we can build our new system. I recommend a partition size of around 750 MB. This gives you enough space to store all the tarballs and to compile all packages without worrying running out of the necessary temporary disk space. If you already have a Linux Native partition available, you can skip this subsection.

Start the fdisk program (or some other fdisk program you prefer) with the appropriate hard disk as the option (like /dev/hda if you want to create a new partition on the primary master IDE disk). Create a Linux Native partition, write the partition table and exit the fdisk program. If you get the message that you need to reboot your system to ensure that that partition table is updated, then please reboot your system now before continuing. Remember what your new partition's designation is. It could be something like hda11 (as it is in my case). This newly created partition will be referred to as the LFS partition in this book.

Creating a ext2 file system on the new partition

Once the partition is created, we have to create a new ext2 file system on that partition. To create a new ext2 file system we use the mke2fs command. Enter the new partition as the only option and the file system will be created. If your partition is hda11, you would run:

mke2fs /dev/hda11

Mounting the new partition

Now that we have created the ext2 file system, it is ready for use. All we have to do to be able to access it (as in reading from and writing date to it) is mounting it. If you mount it under /mnt/lfs, you can access this partition by going to the /mnt/lfs directory and then do whatever you need to do. This document will assume that you have mounted the partition on a subdirectory under /mnt. It doesn't matter which directory you choose (or you can use just the /mnt directory as the mount point) but this book will assume /mnt/lfs in the commands it tells you to execute.

Create the /mnt/lfs directory by runnning:

mkdir -p /mnt/lfs

Now mount the LFS partition by running:

mount /dev/xxx /mnt/lfs

Replace "xxx" by your partition's designation.

This directory (/mnt/lfs) is the $LFS variable you have read about earlier. So if you read somewhere to "cp inittab $LFS/etc" you actually will type "cp inittab /mnt/lfs/etc". Or if you want to use the $LFS environment variable, execute export LFS=/mnt/lfs now.

Creating directories

Let's create the directory tree on the LFS partition according to the FHS standard which can be found at http://www.pathname.com/fhs/. Issuing the following commands will create the necessary directories:

cd $LFS
mkdir bin boot dev dev/pts etc home lib mnt proc root sbin tmp var
for dirname in $LFS/usr $LFS/usr/local
   do
   mkdir $dirname
   cd $dirname
   mkdir bin etc include lib sbin share src tmp var
   ln -s share/man man
   ln -s share/doc doc
   ln -s share/info info
   cd $dirname/share
   mkdir dict doc info locale man nls misc terminfo zoneinfo
   cd $dirname/share/man
   mkdir man1 man2 man3 man4 man5 man6 man7 man8
done
cd $LFS/var
mkdir lock log mail run spool tmp

Normally directories are created with permission mode 755, which isn't desired for all directories. I haven't checked the FHS if they suggest default modes for certain directories, so I'll just change the modes for two directories. The first change is a mode 0750 for the $LFS/root directory. This is to make sure that not just everybody can enter the /root directory (the same you would do with /home/username directories). The second change is a mode 1777 for the $LFS/tmp directory. This way every user can write stuff to the /tmp directory if they need to. The sticky (1) bit makes sure users can't delete other user's file which they normally can do because the directory is set in such a way that every body (owner, group, world) can write to that directory.

root:~# cd $LFS
root:lfs# chmod 0750 root
root:lfs# chmod 1777 tmp usr/tmp var/tmp

Now that the directories are created, copy the source files you have downloaded in chapter 3 to some subdirectory under $LFS/usr/src (you will need to create this subdirectory yourself).

Introduction

In this chapter we will install all the software that belongs to a basic Linux system. After you're done with this chapter you have a fully working Linux system. The remaining chapters deal with setting up networking, creating the boot scripts and adding an entry to lilo.conf so that you can boot your LFS system.

The software in this chapter will be linked statically. These programs will be re-installed in the next chapter and linked dynamically. The reason for the static version first is that there is a chance that our normal Linux system and your LFS system aren't using the same C Library versions. If the programs in the first part are linked against an older C library version, those programs might not work well on the LFS system.

The key to learn what makes Linux tick is to know exactly what packages are used for and why you or the system needs them. In depth descriptions of the package are provided after the Installation subsection of each package and in Appendix A as well.

We're about to start with installing the first set of packages. These packages will be, as previously explained, linked statically.

During the installation of various packages you will most likely see compiler warnings scrolling by on your screen. These are normal and can be safely ignored. They are just that, warnings (mostly about improper use of the C or C++ syntax, but not illegal use. It's just that often C standards changed and packages still use the old standard which is not a problem).

Before we start, make sure you have the LFS environment variable setup if you plan on using it, by running the following command:

root:~# echo $LFS

Installing Bash

Installing Binutils

Installing Bzip2

Installing Diffutils

Installing Fileutils

Installing GCC on the normal system if necessary

Installing GCC on the LFS system

Installing Linux Kernel

Installing Glibc

Installing Grep

Installing Gzip

Installing Make

Installing Sed

Installing Shellutils

Installing Tar

Installing Textutils

Creating passwd and group files

In order for user and group root to be recognized and to be able to logon it needs an entry in the /etc/passwd and /etc/group file. Besides the group root a couple of other groups are recommended and needed by packages. The groups with their GID's below aren't part of any standard. The LSB only recommends besides a group root a group bin to be present with GID 1. Other group names and GID's can be chosen by yourself. Well written packages don't depend on GID numbers but just use the group name, it doesn't matter all that much what GID a group has. Since there aren't any standards for groups I won't follow any conventions used by Debian, RedHat and others. The groups added here are the groups the MAKEDEV script (the script that creates the device files in the /dev directory) mentions.

Create a new file $LFS/etc/passwd by running the following command:

echo "root:x:0:0:root:/root:/bin/bash" > $LFS/etc/passwd

Create a new file $LFS/etc/group by running the following command:

echo "root:x:0:" > $LFS/etc/group &&
echo "bin:x:1:" >> $LFS/etc/group &&
echo "sys:x:2:" >> $LFS/etc/group &&
echo "kmem:x:3:" >> $LFS/etc/group &&
echo "tty:x:4:" >> $LFS/etc/group &&
echo "uucp:x:5:" >> $LFS/etc/group &&
echo "daemon:x:6:" >> $LFS/etc/group &&
echo "floppy:x:7:" >> $LFS/etc/group &&
echo "disk:x:8:" >> $LFS/etc/group

Mounting $LFS/proc file system

In order for certain programs to function properly the proc file system must be mounted and available from within the chroot'ed environment as well. It's not a problem to mount the proc file system twice or even more than that, since it's a virtual file system maintained by the kernel itself.

Mount the proc file system under $LFS/proc by running the following command:

mount proc $LFS/proc -t proc

Introduction

The installation of all the software is pretty straightforward and you'll think it's so much easier and shorter to give the generic installation instructions for each package and only explain how to install something if a certain package requires an alternate installation method. Although I agree with you on that, I, however, choose to give the full instructions for each and every package. This is simply to avoid any possible confusion and errors.

Debugging symbols and compiler optimizations

Most programs and libraries by default are compiled with debugging symbols and optimizing level 2 (gcc options -g and -O2) and are compiled for a specific CPU. On Intel platforms software is compiled for i386 processors by default. If you don't wish to run software on other machines other than your own, you might want to change the default compiler options so that they will be compiled with a higher optimization level, no debugging symbols and generate code for your specific architecture. Let me first explain what debugging symbols are.

A program compiled with debugging symbols means you can run a program or library through a debugger and the debugger's output will be user friendlier. These debugging symbols also enlarge the program or library significantly.

To remove debugging symbols from a binary (must be an a.out or ELF binary) run strip --strip-debug filename You can use wild cards if you need to strip debugging symbols from multiple files (use something like strip --strip-debug $LFS/usr/bin/*). Another, easier, options is just not to compile programs with debugging symbols. Most people will probably never use a debugger on software, so by leaving those symbols out you can save a lot of diskspace.

Before you wonder if these debugging symbols would make a big difference, here are some statistics:

• A dynamic Bash binary with debugging symbols: 1.2MB

• A dynamic Bash binary without debugging symbols: 478KB

• /lib and /usr/lib (glibc and gcc files) with debugging symbols: 87MB

• /lib and /usr/lib (glibc and gcc files) without debugging symbols: 16MB

Sizes may vary depending on which compiler was used and which C library version was used to link dynamic programs against, but your results will be similar if you compare programs with and without debugging symbols. After I was done with this chapter and stripped all debugging symbols from all LFS binaries and libraries I regained a little over 102 MB of disk space. Quite the difference.

There are a few ways to change the default compiler options. One way is to edit every Makefile file you can find in a package, look for the CFLAGS and CXXFLAGS variables (a well designed package uses the CFLAGS variable to define gcc compiler options and CXXFLAGS to define g++ compiler options) and change their values. Packages like binutils, gcc, glibc and others have a lot of Makefile files in a lot of subdirectories so this would take a lot of time to do. Instead there's an easier way to do things: create the CFLAGS and CXXFLAGS environment variables. Most configure scripts read the CFLAGS and CXXFLAGS variables and use them in the Makefile files. A few packages don't follow this convention and those package require manual editing.

In the next section we'll create the $LFS/root/.bash_profile that will contain the following optimization:

CFLAGS="-O3 -mcpu=xxx -march=xxx"
CXXFLAGS=$CFLAGS

This is a minimal set of optimizations that ensures it works on almost all platforms. These two options (mcpu and march) will compile the binaries with specific instructions for that CPU you have specified. This means you can't copy this binary to a lower class CPU and execute it. It will either work very unreliable or not at all (it will give errors like Illegal Instruction, core dumped). You'll have to read the GCC Info page to find more possible optimization flags. In the above environment variable you have to replace xxx and yyy with the appropriate CPU identifiers such as i586, i686, powerpc and others.

Please keep in mind that if you find that a package doesn't compile and gives errors like "segmentation fault, core dumped" it's most likely got to do with these compiler optimizations. Try lowering the optimizing level by changing -O3 to -O2. If that doesn't work try -O or leave it out all together. Also try changing the -mcpu and -march variables. Compilers are very sensitive to certain hardware too. Bad memory can cause compilation problems when a high level of optimization is used, like the -O3 setting. The fact that I don't have any problems compiling everything with -O3 doesn't mean you won't have any problems either. Another problem can be the Binutils version that's installed on your system which often causes compilation problems in Glibc (most noticable in RedHat because RedHat often uses beta software which aren't always very stable. "RedHat likes living on the bleeding edge, but leaves the bleeding up to you" (quoted from somebody on the lfs-discuss mailinglist).

Creating $LFS/root/.bash_profile

When we have entered the chroot'ed environment in the next section we want to export a couple of environment variables in that shell such as TERM, CFLAGS, CXXFLAGS and others variables you want to have set. For that purpose we'll create the $LFS/root/.bash_profile file and "source" it after we have entered the chroot'ed environment.

Create a new file $LFS/root/.bash_profile containing the following. Replace -mcpu=xxx and -march=yyy with the proper values for your machine:

# Begin /root/.bash_profile

TERM=linux
CFLAGS="-O3 -mcpu=xxx -march=yyy"
CXXFLAGS=$CFLAGS

export TERM CFLAGS CXXFLAGS

# End /root/.bash_profile

You can add more environment variables at your own discretion as you deem them necesarry.

Entering the chroot'ed environment

It's time to enter our chroot'ed environment in order to install the rest of the software we need.

Enter the following command to enter the chroot'ed environment. From this point on there's no need to use the $LFS variable anymore, because everything you do will be restricted to the LFS partition (since / is actually /mnt/lfs but the shell doesn't know that).

cd $LFS
chroot $LFS env -i HOME=/root bash --login

Now that we are inside a chroot'ed environment, we can continue to install all the basic system software. Make sure you execute all the following commands in this chapter from within the chroot'ed environment.

Setting up locale

If you plan on using a non-English language you have to setup your locale to match your desired language. You do that by running the localedef command with the proper values. You can find the desired files in the /usr/share/i18n directory.

localedef -i en_US -f ISO-8859-1 en_US

Creating device files

Installing Ed

Installing Patch

Installing Findutils

Installing Mawk

Installing Ncurses

Installing Vim

Installing GCC

Installing Bison

Installing Less

Installing Groff

Installing Man

Installing Perl

Installing M4

Installing Texinfo

Installing Autoconf

Installing Automake

Installing Bash

Installing Flex

Installing File

Installing Libtool

Installing Bin86

Installing Binutils

Installing Bzip2

Installing Gettext

Installing Consoletools

Installing Consoledata

Installing Diffutils

Installing E2fsprogs

Installing Fileutils

Installing Grep

Installing Gzip

Installing Ldso

Installing Lilo

Installing Make

Installing Modutils

Installing Procinfo

Installing Procps

Installing Psmisc

Installing Sed

Installing Shellutils

Installing Shadowpwd

Installing Sysklogd

Installing Sysvinit

Installing Tar

Installing Textutils

Installing Utillinux

Installing Man-pages

Removing old NSS library files

If you have copied the NSS Library files from your normal Linux system to the LFS system (because your normal system runs glibc-2.0) it's time to remove them now by running:

rm /lib/libnss*.so.1 /lib/libnss*2.0*

Configuring essential software

Now that all software is installed, all that we need to do to get a few programs running properly is to create their configuration files.

Introduction

This chapter will create the necessary scripts that are run at boottime. These scripts perform tasks such as remounting the root file system mounted read-only by the kernel into read-write mode, activiating the swap partition(s), running a check on the root file system to make sure it's intact and starting the daemons that the system uses.

Creating directories

We need to start by creating a few extra directories that are used by the boot scripts. Create these directories by running:

cd /etc &&
mkdir sysconfig rc0.d rc1.d rc2.d rc3.d &&
mkdir rc4.d rc5.d rc6.d init.d rcS.d

Creating the rc script

The first main bootscript is the /etc/init.d/rc script. Create a new file /etc/init.d/rc containing the following:

#!/bin/sh
# Begin /etc/init.d/rc
#
# By Jason Pearce  - jason.pearce@linux.org
# Modified by Gerard Beekmans - gerard@linuxfromscratch.org
# print_error_msg based on ideas by Simon Perreault - nomis80@yahoo.com

source /etc/init.d/functions

print_error_msg()
{

        echo
        $FAILURE
        echo -n "You should not read this error message. It means "
        echo "that an unforseen error "
        echo -n "took place and subscript $i exited with "
        echo "a return value "
        echo -n "of $error_value for an unknown reason. If you're able "
        echo "to trace this error down "
        echo -n "to a bug in one of the files provided by this book, "
        echo "please be so kind to "
        echo -n "inform us at lfs-discuss@linuxfromscratch.org"
        $NORMAL
        echo
}


# Un-comment the following for debugging.
# debug=echo

#
# Start script or program.
# 
startup() {
case "$1" in
        *.sh)
                $debug sh "$@"
                ;;
        *)
                $debug "$@"
                ;;
esac
}   

# Ignore CTRL-C only in this shell, so we can interrupt subprocesses.
trap ":" INT QUIT TSTP

# Set onlcr to avoid staircase effect.
stty onlcr 0>&1

# Now find out what the current and what the previous runlevel are.
runlevel=$RUNLEVEL
# Get first argument. Set new runlevel to this argument.

[ "$1" != "" ] && runlevel=$1
if [ "$runlevel" = "" ]
then
        echo "Usage: $0 <runlevel>" >&2
        exit 1
fi

previous=$PREVLEVEL
[ "$previous" = "" ] && previous=N

export runlevel previous

# Is there an rc directory for this new runlevel?

if [ -d /etc/rc$runlevel.d ]
then
        # First, run the KILL scripts for this runlevel.
        if [ $previous != N ]
        then
                for i in /etc/rc$runlevel.d/K*
                do
                [ ! -f $i ] && continue

                        suffix=${i#/etc/rc$runlevel.d/K[0-9][0-9]}
                        previous_start=/etc/rc$previous.d/S[0-9][0-9]$suffix
                        sysinit_start=/etc/rcS.d/S[0-9][0-9]$suffix

                        # Stop the service if there is a start script
                        # in the previous run level.
                        [ ! -f $previous_start ] && 
                        [ ! -f $sysinit_start ] && continue

                        startup $i stop
                        error_value=$?
                        if [ $error_value != 0 ]
                        then
                                print_error_msg 
                        fi

                done
        fi

        # Now run the START scripts for this runlevel.
        for i in /etc/rc$runlevel.d/S*
        do
                [ ! -f $i ] && continue

                if [ $previous != N ]
        then
                        # Find start script in previous runlevel and
                        # stop script in this runlevel.
                        suffix=${i#/etc/rc$runlevel.d/S[0-9][0-9]}
                        stop=/etc/rc$runlevel.d/K[0-9][0-9]$suffix
                        previous_start=/etc/rc$previous.d/S[0-9][0-9]$suffix

                        # If there is a start script in the previous
                        # level
                        # and _no_ stop script in this level, we don't
                        # have to re-start the service.
                        [ -f $previous_start ] && [ ! -f $stop ] && 
                        continue
                fi

                case "$runlevel" in
                        0|6)
                                startup $i stop
                                error_value=$?
                                if [ $error_value != 0 ]
                                then
                                        print_error_msg
                                fi
                                ;;
                        *)
                                startup $i start
                                error_value=$?
                                if [ $error_value != 0 ]
                                then
                                        print_error_msg
                                fi
                                ;;
                esac
        done
fi

# End /etc/init.d/rc

Creating the rcS script

The second main bootscript is the rcS script. Create a new file /etc/init.d/rcS containing the following:

#!/bin/sh
# Begin /etc/init.d/rcS

runlevel=S
prevlevel=N
umask 022
export runlevel prevlevel

trap ":" INT QUIT TSTP

for i in /etc/rcS.d/S??*
do
        [ ! -f  "$i" ] && continue;
                $i start
done

# End /etc/init.d/rcS

Creating the functions script

Create a new file /etc/init.d/functions containing the following:

#!/bin/sh
# Begin /etc/init.d/functions

COL=70
SET_COL="echo -en \\033[${COL}G"
NORMAL="echo -en \\033[0;39m"
SUCCESS="echo -en \\033[1;32m"
FAILURE="echo -en \\033[1;31m"

evaluate_retval()
{
        if [ $? = 0 ]
        then
                print_status success
        else
                print_status failure
        fi
}

print_status()
{
        if [ $# = 0 ]
        then
                echo "Usage: print_status {success|failure}"
                exit 1
        fi

        case "$1" in
                success)
                        $SET_COL
                        echo -n "[  "
                        $SUCCESS
                        echo -n "OK"
                        $NORMAL
                        echo "  ]"
                        ;;
                failure)
                        $SET_COL
                        echo -n "["
                        $FAILURE
                        echo -n "FAILED"
                        $NORMAL
                        echo "]"
                        ;;
        esac

}

loadproc()
{
        if [ $# = 0 ]
        then
                echo "Usage: loadproc {program}"
                exit 1
        fi

        base=`basename $1`

        pidlist=`pidof -o $$ -o $PPID -o %PPID -x $base`

        pid=""

        for apid in $pidlist
        do
                if [ -d /proc/$apid ]
                then
                        pid="$pid $apid"
                fi
        done

        if [ ! -n "$pid" ]
        then
                $*
                evaluate_retval
        else
                print_status failure
        fi

}

killproc()
{

        if [ $# = 0 ]
        then
                echo "Usage: killproc {program} [signal]"
                exit 1
        fi

        base=`basename $1`

        if [ "$2" != "" ]
        then
                killlevel=$2
        else
                nolevel=1
        fi

        pidlist=`pidof -o $$ -o $PPID -o %PPID -x $base`

        pid=""

        for apid in $pidlist
        do
                if [ -d /proc/$apid ]
                then
                        pid="$pid $apid"
                fi
        done

        if [ -n "$pid" ]
        then
                if [ "$nolevel" = 1 ]
                then
                        kill -TERM $pid
                        if ps h $pid >/dev/null 2>&1
                        then
                                kill -KILL $pid
                        fi
                        ps h $pid >/dev/null 2>&1
                        if [ $? = 0 ]
                        then
                                print_status failure
                        else
                                rm -f /var/run/$base.pid
                                print_status success
                        fi
                else
                        kill $killlevel $pid
                        ps h $pid >/dev/null 2>&1
                        if [ $? = 0 ]
                        then
                                print_status failure
                        else
                                rm -f /var/run/$base.pid
                                print_status success
                        fi
                fi
        else
                print_status failure
        fi
}

reloadproc()
{
        if [ $# = 0 ]
        then
                echo "Usage: reloadproc {program} [signal]"
                exit 1
        fi

        base=`basename $1`

        if [ -n "$2" ]
        then
                killlevel=-$2
        else
                nolevel=1
        fi

        pidlist=`pidof -o $$ -o $PPID -o %PPID -x $base`

        pid=""

        for apid in $pidlist
        do
                if [ -d /proc/$apid ]
                then
                        pid="$pid $apid"
                fi
        done

        if [ -n "$pid" ]
        then
                if [ "$nolevel" = 1 ]
                then
                        kill -SIGHUP $pid
                        evaluate_retval
                else
                        kill -$killlevel $pid
                        evaluate_retval
                fi
        else
                print_status failure
        fi
}

statusproc()
{
        if [ $# = 0 ]
        then
                echo "Usage: status {program}"
                return 1
        fi

        pid=`pidof -o $$ -o $PPID -o %PPID -x $1`
        if [ -n "$pid" ]
        then
                echo "$1 running with Process ID $pid"
                return 0
        fi

        if [ -f /var/run/$1.pid ]
        then
                pid=`head -1 /var/run/$1.pid`
                if [ -n "$pid" ]
                then
                        echo "$1 not running but /var/run/$1.pid exists"
                        return 1
                fi
        fi

}

# End /etc/init.d/functions

Creating the checkfs script

Create a new file /etc/init.d/checkfs containing the following:

#!/bin/sh
# Begin /etc/init.d/checkfs

source /etc/init.d/functions

echo -n "Activating swap..."
/sbin/swapon -a
evaluate_retval

if [ -f /fastboot ]
then
        echo "Fast boot, no file system check"
else
        /bin/mount -n -o remount,ro /
        if [ $? = 0 ]
        then
                if [ -f /forcefsck ]
                then
                        echo -n "/forcefsck exists, forcing "
                        echo "file system check"
                        force="-f"
                else
                        force=""
                fi

                echo "Checking file systems..."
                /sbin/fsck $force -a -A -C -T

                if [ $? -gt 1 ]
                then
                        $FAILURE
                        echo
                        echo -n "fsck failed. Please repair your file "
                        echo "systems manually by running /sbin/fsck"
                        echo "without the -a option"
                        echo
                        echo -n "Please note that the root file system " 
                        echo "is currently mounted in read-only mode."
                        echo
                        echo -n "I will start sulogin now. When you  "
                        echo "logout I will reboot your system."
                        echo
                        $NORMAL
                        /sbin/sulogin
                        /sbin/reboot -f
                else
                        print_status success
                fi

        else
                echo -n "Cannot check root file system because it "
                echo "could not be mounted in read-only mode."
        fi
fi

# End /etc/init.d/checkfs

Creating the halt script

Create a new file /etc/init.d/halt containing the following:

#!/bin/sh
# Begin /etc/init.d/halt

/sbin/halt -d -f -i -p

# End /etc/init.d/halt

Creating the loadkeys script

You only need to create this script if you don't have a default 101 keys US keyboard layout. Create a new file /etc/init.d/loadkeys containing the following:

#!/bin/sh
# Begin /etc/init.d/loadkeys

source /etc/init.d/functions

echo -n "Loading keymap..."
/usr/bin/loadkeys -d >/dev/null
evaluate_retval

# End /etc/init.d/loadkeys

Creating the mountfs script

Create a new file /etc/init.d/mountfs containing the following:

#!/bin/sh
# Begin /etc/init.d/mountfs

source /etc/init.d/functions

echo -n "Remounting root file system in read-write mode..."
/bin/mount -n -o remount,rw /
evaluate_retval

echo > /etc/mtab
/bin/mount -f -o remount,rw /

/bin/rm -f /fastboot /forcefsck

echo -n "Mounting other file systems..."
/bin/mount -a
evaluate_retval

# End /etc/init.d/mountfs

Creating the reboot script

Create a new file /etc/init.d/reboot containing the following:

#!/bin/sh
# Begin /etc/init.d/reboot

echo "System reboot in progress..."

/sbin/reboot -d -f -i

# End /etc/init.d/reboot

Creating the sendsignals script

Create a new file /etc/init.d/sendsignals containing the following:

#!/bin/sh
# Begin /etc/init.d/sendsignals

source /etc/init.d/functions

echo -n "Sending all processes the TERM signal..."
/sbin/killall5 -15
evaluate_retval

echo -n "Sending all processes the KILL signal..."
/sbin/killall5 -9
evaluate_retval

# End /etc/init.d/sendsignals

Creating the setclock script

The following script is only for real use when your hardware clock (also known as BIOS or CMOS clock) isn't set to GMT time. The recommended setup is setting your hardware clock to GMT and have the time converted to localtime using the /etc/localtime symbolic link. But if you run an OS that doesn't understand a clock set to GMT (most notable are Microsoft OS'es) you might want to set your clock to localtime so that the time is properly displayed on those OS'es. This script will reset the kernel time to the hardware clock without converting the time using the /etc/localtime symlink.

If you want to use this script on your system even if you have your hardware clock set to GMT, then change the UTC variable below to the value of 1.

#!/bin/sh
# Begin /etc/init.d/setclock

source /etc/init.d/functions
source /etc/sysconfig/clock

CLOCKPARAMS="--hctosys"

case "$UTC" in
        yes|true|1)
                CLOCKPARAMS="$CLOCKPARAMS -u"
                ;;
esac

echo -n "Setting clock..."
/sbin/hwclock $CLOCKPARAMS
evaluate_retval

# End /etc/init.d/setclock

Creating the sysklogd script

Create a new file /etc/init.d/sysklogd containing the following:

#!/bin/sh
# Begin /etc/init.d/sysklogd

source /etc/init.d/functions

case "$1" in
        start)
                echo -n "Starting system log daemon..."
                loadproc /usr/sbin/syslogd -m 0

                echo -n "Starting kernel log daemon..."
                loadproc /usr/sbin/klogd
                ;;

        stop)
                echo -n "Stopping kernel log daemon..."
                killproc klogd

                echo -n "Stopping system log daemon..."
                killproc syslogd
                ;;

        reload)
        echo -n "Reloading system log daemon configuration file..."
                reloadproc syslogd 1
                ;;

        restart)
                $0 stop
                sleep 1
                $0 start
                ;;

        status)
                statusproc /usr/sbin/syslogd
                statusproc /usr/sbin/klogd
                ;;

        *)
                echo "Usage: $0 {start|stop|reload|restart|status}"
                exit 1
        ;;

esac

# End /etc/init.d/sysklogd

Creating the template script

Create a new file /etc/init.d/template containing the following:

#!/bin/sh
# Begin /etc/init.d/

source /etc/init.d/functions

case "$1" in
        start)
                echo -n "Starting ..."
                loadproc
                ;;

        stop)
                echo -n "Stopping ..."
                killproc
                ;;

        reload)
                echo -n "Reloading ..."
                reloadproc
                ;;

        restart)
                $0 stop
                sleep 1
                $0 start
                ;;

        status)
                statusproc
                ;;

        *)
                echo "Usage: $0 {start|stop|reload|restart|status}"
                exit 1
        ;;

esac

# End /etc/init.d/

Creating the umountfs script

Create a new file /etc/init.d/umountfs containing the following:

#!/bin/sh
# Begin /etc/init.d/umountfs

source /etc/init.d/functions

echo -n "Deactivating swap..."
/sbin/swapoff -a
evaluate_retval

echo -n "Unmounting file systems..."
/bin/umount -a -r
evaluate_retval

# End /etc/init.d/umountfs

Setting up symlinks and permissions

Give these files the proper permissions and create the necessary symlinks by running the following commands. If you did not create the loadkeys and setclock scripts, make sure you don't type them in the commands below.

cd /etc/init.d &&
chmod 754 rc rcS functions checkfs halt loadkeys mountfs reboot &&
chmod 754 sendsignals setclock sysklogd template umountfs &&
cd ../rc0.d &&
ln -s ../init.d/sysklogd K90sysklogd &&
ln -s ../init.d/sendsignals S80sendsignals &&
ln -s ../init.d/umountfs S90umountfs &&
ln -s ../init.d/halt S99halt &&
cd ../rc6.d &&
ln -s ../init.d/sysklogd K90sysklogd &&
ln -s ../init.d/sendsignals S80sendsignals &&
ln -s ../init.d/umountfs S90umountfs &&
ln -s ../init.d/reboot S99reboot &&
cd ../rcS.d &&
ln -s ../init.d/checkfs S05checkfs &&
ln -s ../init.d/mountfs S10mountfs &&
ln -s ../init.d/setclock S20setclock &&
ln -s ../init.d/loadkeys S30loadkeys &&
cd ../rc1.d &&
ln -s ../init.d/sysklogd K90sysklogd &&
cd ../rc2.d &&
ln -s ../init.d/sysklogd S03sysklogd &&
cd ../rc3.d &&
ln -s ../init.d/sysklogd S03sysklogd &&
cd ../rc4.d &&
ln -s ../init.d/sysklogd S03sysklogd &&
cd ../rc5.d &&
ln -s ../init.d/sysklogd S03sysklogd

Creating the /etc/fstab file

In order for certain programs to be able to determine where certain partitions are supposed to be mounted by default, the /etc/fstab file is used. Create a new file /etc/fstab containing the following:

# Begin /etc/fstab

/dev/<LFS-partition designation> / ext2 defaults 1 1
/dev/<swap-partition designation> swap swap defaults 0 0
none /proc proc defaults 0 0

# End /etc/fstab

Replace <LFS-partition designation> and <swap-partition designation> with the appropriate devices (/dev/hda5 and /dev/hda6 in my case).

Introduction

This chapter will make LFS bootable. This chapter deals with building a new kernel for our new LFS system and adding the proper entries to LILO so that you can select to boot the LFS system at the LILO: prompt.

Installing a kernel

A kernel is the heart of a Linux system. We could use the kernel image from our normal system, but we might as well compile a new kernel from the most recent kernel sources available.

Building the kernel involves a few steps: configuring it and compiling it. There are a few ways to configure the kernel. If you don't like the way this book does it, read the README file and find out what your other options are. Run the following commands to build the kernel:

cd /usr/src/linux &&
make mrproper &&
make menuconfig &&
make dep &&
make bzImage &&
make modules &&
make modules_install &&
cp arch/i386/boot/bzImage /boot/lfskernel &&
cp System.map /boot

Adding an entry to LILO

In order to being able to boot from this partition, we need to update our /etc/lilo.conf file. Add the following lines to lilo.conf:

image=/boot/lfskernel
        label=lfs
        root=<partition>
        read-only

<partition> must be replaced by your partition's designation (which would be /dev/hda5 in my case).

Now update the boot loader by running:

/sbin/lilo

Rebooting the system

Now that all software has been installed, bootscripts have been created, it's time for you to reboot your computer. Shutdown your system with shutdown -r now and reboot into LFS. After the reboot you will have a normal login prompt like you have on your normal Linux system (unless you use XDM or some sort of other Display Manger (like KDM - KDE's version of XDM).

One thing remains to be done and that's setting up networking. After you rebooted and finished the next chapter of this book your LFS system is ready for use and you can do with it whatever you want.

Introduction

This chapter will setup basic networking. Although you might not be connected to a network, Linux software uses network functions anyway. We'll be installing at least the local loopback device and a network card as well if applicable. Also the proper bootscripts will be created so that networking will be enabled during boot time.