If during the building of your LFS system you encounter any errors, or have any questions, or think you found a typo in the book, then please first consult the FAQ (Frequently Asked Questions) at http://www.linuxfromscratch.org/faq/.

Several members of the LFS community offer assistance on our community IRC (Internet Relay Chat) network. Before you utilize this mode of support, we ask that you've at least checked the LFS FAQ (see above) and the mailing list archives (see below) for the answer to your question. You can find the IRC network at irc.linuxfromscratch.org or irc.linux-phreak.net port 6667. The support channel is named #LFS-support.

The linuxfromscratch.org server is hosting a number of mailing lists used for the development of the LFS project. These lists include, among others, the main development and support lists.

For information on which lists are available, how to subscribe to them, their archive locations, and so on, visit http://www.linuxfromscratch.org/mail.html.

All the mailing lists hosted at linuxfromscratch.org are also accessible via the NNTP server. All messages posted to a mailing list are copied to the corresponding newsgroup, and vice versa.

The news server can be reached at news.linuxfromscratch.org.

For more information on a package, updated versions, tweaks, personal experiences, and so on, see the LFS Wiki at http://wiki.linuxfromscratch.org/. You can add information there yourself too, to help others.

If you need still more detailed information on the packages, you will find useful pointers on this page: http://www.109bean.org.uk/LFS-references.html.

The LFS project has a number of mirrors set up world-wide to make accessing the website and downloading the required packages more convenient. Please visit the website at http://www.linuxfromscratch.org/ for a list of current mirrors.

Please direct all your questions and comments to one of the LFS mailing lists (see above).

Apart from a brief explanation of the problem you're having, the essential things to include in your request are:

(Note that saying that you've deviated from the book doesn't mean that we won't help you. After all, LFS is about choice. It'll just help us to see other possible causes of your problem.)

When something goes wrong during the stage where the configure script is run, look through the config.log file. This file may contain errors encountered during configure which weren't printed to the screen. Include those relevant lines if you decide to ask for help.

To help us find the cause of the problem, both screen output and the contents of various files are useful. The screen output from both the ./configure script and the make run can be useful. Don't blindly include the whole thing but, on the other hand, don't include too little. As an example, here is some screen output from make:

gcc -DALIASPATH=\"/mnt/lfs/usr/share/locale:.\"
-DLOCALEDIR=\"/mnt/lfs/usr/share/locale\" -DLIBDIR=\"/mnt/lfs/usr/lib\"
-DINCLUDEDIR=\"/mnt/lfs/usr/include\" -DHAVE_CONFIG_H -I. -I.
-g -O2 -c getopt1.c
gcc -g -O2 -static -o make ar.o arscan.o commands.o dir.o expand.o file.o
function.o getopt.o implicit.o job.o main.o misc.o read.o remake.o rule.o
signame.o variable.o vpath.o default.o remote-stub.o version.o opt1.o
-lutil job.o: In function `load_too_high':
/lfs/tmp/make-3.79.1/job.c:1565: undefined reference to `getloadavg'
collect2: ld returned 1 exit status
make[2]: *** [make] Error 1
make[2]: Leaving directory `/lfs/tmp/make-3.79.1'
make[1]: *** [all-recursive] Error 1
make[1]: Leaving directory `/lfs/tmp/make-3.79.1'
make: *** [all-recursive-am] Error 2

In this case, many people just include the bottom section where it says:

make [2]: *** [make] Error 1

and onwards. This isn't enough for us to diagnose the problem because it only tells us that something went wrong, not what went wrong. The whole section, as in the example above, is what should be included to be helpful, because it includes the command that was executed and the command's error message(s).

An excellent article on asking for help on the Internet in general has been written by Eric S. Raymond. It is available online at http://catb.org/~esr/faqs/smart-questions.html. Read and follow the hints in that document and you are much more likely to get a response to start with and also to get the help you actually need.

Many packages provide a test suite which, depending on the importance of the package, we may encourage you to run. Sometimes packages will generate false or expected failures. If you encounter these, you can check the LFS Wiki page at http://wiki.linuxfromscratch.org/ to see whether we have already noted and investigated them. If we already know about them, then usually there is no need to be concerned.

Most programs have to perform, beside their specific task, many rather common and sometimes trivial operations. These include allocating memory, searching directories, reading and writing files, string handling, pattern matching, arithmetic and many other tasks. Instead of obliging each program to reinvent the wheel, the GNU system provides all these basic functions in ready-made libraries. The major library on any Linux system is Glibc.

There are two primary ways of linking the functions from a library to a program that uses them: statically or dynamically. When a program is linked statically, the code of the used functions is included in the executable, resulting in a rather bulky program. When a program is dynamically linked, what is included is a reference to the dynamic linker, the name of the library, and the name of the function, resulting in a much smaller executable. (A third way is to use the programming interface of the dynamic linker. See the dlopen man page for more information.)

Dynamic linking is the default on Linux and has three major advantages over static linking. First, you need only one copy of the executable library code on your hard disk, instead of having many copies of the same code included into a whole bunch of programs -- thus saving disk space. Second, when several programs use the same library function at the same time, only one copy of the function's code is required in core -- thus saving memory space. Third, when a library function gets a bug fixed or is otherwise improved, you only need to recompile this one library, instead of having to recompile all the programs that make use of the improved function.

If dynamic linking has several advantages, why then do we statically link the first two packages in this chapter? The reasons are threefold: historical, educational, and technical. Historical, because earlier versions of LFS statically linked every program in this chapter. Educational, because knowing the difference is useful. Technical, because we gain an element of independence from the host in doing so, meaning that those programs can be used independently of the host system. However, it's worth noting that an overall successful LFS build can still be achieved when the first two packages are built dynamically.

Approximate build time:  1.0 SBU
Required disk space:     170 MB

It is important that Binutils be the first package to get compiled, because both Glibc and GCC perform various tests on the available linker and assembler to determine which of their own features to enable.

This package is known to behave badly when you change its default optimization flags (including the -march and -mcpu options). Therefore, if you have defined any environment variables that override default optimizations, such as CFLAGS and CXXFLAGS, we recommend un-setting them when building Binutils.

The Binutils documentation recommends building Binutils outside of the source directory in a dedicated build directory:

mkdir ../binutils-build
cd ../binutils-build

Now prepare Binutils for compilation:

../binutils-2.14/configure --prefix=/tools --disable-nls

The meaning of the configure options:

Continue with compiling the package:

make configure-host
make LDFLAGS="-all-static"

The meaning of the make parameters:

Compilation is complete. Normally we would now run the test suite, but at this early stage the test suite framework (Tcl, Expect and DejaGnu) is not yet in place. And there would be little point in running the tests anyhow, since the programs from this first pass will soon be replaced by those from the second.

Now install the package:

make install

Now prepare the linker for the “Adjusting” phase later on:

make -C ld clean
make -C ld LDFLAGS="-all-static" LIB_PATH=/tools/lib

The meaning of the make parameters:

The details on this package are found in the section called “Contents of Binutils”.

Approximate build time:  4.4 SBU
Required disk space:     411.7 MB

Unpack only the GCC-core tarball, as we won't be needing the C++ compiler nor the test suite here.

This package is known to behave badly when you change its default optimization flags (including the -march and -mcpu options). Therefore, if you have defined any environment variables that override default optimizations, such as CFLAGS and CXXFLAGS, we recommend un-setting them when building GCC.

The GCC documentation recommends building GCC outside of the source directory in a dedicated build directory:

mkdir ../gcc-build
cd ../gcc-build

Prepare GCC for compilation:

../gcc-3.3.3/configure --prefix=/tools \
    --with-local-prefix=/tools \
    --disable-nls --enable-shared \
    --enable-languages=c

The meaning of the configure options:

Continue with compiling the package:

make BOOT_LDFLAGS="-static" bootstrap

The meaning of the make parameters:

Compilation is now complete, and at this point we would normally run the test suite. But, as mentioned before, the test suite framework is not in place yet. And there would be little point in running the tests anyhow, since the programs from this first pass will soon be replaced.

Now install the package:

make install

As a finishing touch we'll create a symlink. Many programs and scripts run cc instead of gcc, a thing meant to keep programs generic and therefore usable on all kinds of Unix systems. Not everybody has the GNU C compiler installed. Simply running cc leaves the system administrator free to decide what C compiler to install, as long as there's a symlink pointing to it:

ln -s gcc /tools/bin/cc

The details on this package are found in the section called “Contents of GCC”.

Approximate build time:  0.1 SBU
Required disk space:     192.5 MB

As some packages need to refer to the kernel header files, we're going to unpack the kernel archive now, set it up, and copy the required files to a place where gcc can later find them.

Prepare for the header installation with:

make mrproper

This ensures that the kernel tree is absolutely clean. The kernel team recommends that this command be issued prior to each kernel compilation. You shouldn't rely on the source tree being clean after un-tarring.

Create the include/linux/version.h file:

make include/linux/version.h

Create the platform-specific include/asm symlink:

make symlinks

Install the platform-specific header files:

mkdir /tools/include/asm
cp include/asm/* /tools/include/asm
cp -R include/asm-generic /tools/include

Finally, install the cross-platform kernel header files:

cp -R include/linux /tools/include

Approximate build time:  11.8 SBU
Required disk space:     734.2 MB

This package is known to behave badly when you change its default optimization flags (including the -march and -mcpu options). Therefore, if you have defined any environment variables that override default optimizations, such as CFLAGS and CXXFLAGS, we recommend un-setting them when building Glibc.

Basically, compiling Glibc in any other way than the book suggests is putting the stability of your system at risk.

The Glibc documentation recommends building Glibc outside of the source directory in a dedicated build directory:

mkdir ../glibc-build
cd ../glibc-build

Next, prepare Glibc for compilation:

../glibc-2.3.3-lfs-5.1/configure --prefix=/tools \
    --disable-profile --enable-add-ons=linuxthreads \
    --with-binutils=/tools/bin --with-headers=/tools/include \
    --without-gd --without-cvs

The meaning of the configure options:

During this stage you might see the following warning:

The missing or incompatible msgfmt program is generally harmless, but it's believed it can sometimes cause problems when running the test suite.

Compile the package:

make AUTOCONF=no

Compilation is now complete. As mentioned earlier, we don't recommend running the test suites for the temporary system here in this chapter. If you still want to run the Glibc test suite anyway, the following command will do so:

make check

The Glibc test suite is highly dependent on certain functions of your host system, in particular the kernel. Additionally, here in this chapter some tests can be adversely affected by existing tools or environmental issues on the host system. Of course, these won't be a problem when we run the Glibc test suite inside the chroot environment of Chapter 6. In general, the Glibc test suite is always expected to pass. However, as mentioned above, in certain circumstances some failures are unavoidable. Here is a list of the most common issues we are aware of:

In summary, don't worry too much if you see Glibc test suite failures here in this chapter. The Glibc in Chapter 6 is the one we'll ultimately end up using, so that is the one we would really like to see pass the tests (but even there some failures could still occur -- the math tests, for example). When experiencing a failure, make a note of it, then continue by reissuing the make check. The test suite should pick up where it left off and continue. You can circumvent this stop-start sequence by issuing a make -k check. But if you do that, be sure to log the output so that you can later peruse the log file and examine the total number of failures.

Though it is a harmless message, the install stage of Glibc will at the end complain about the absence of /tools/etc/ld.so.conf. Prevent this confusing little warning with:

mkdir /tools/etc
touch /tools/etc/ld.so.conf

Now install the package:

make install

Different countries and cultures have varying conventions for how to communicate. These conventions range from very simple ones, such as the format for representing dates and times, to very complex ones, such as the language spoken. The “internationalization” of GNU programs works by means of locales.

If you still want to install the Glibc locales anyway, the following command will do so:

make localedata/install-locales

An alternative to running the previous command is to install only those locales which you need or want. This can be achieved by using the localedef command. Information on this can be found in the INSTALL file in the Glibc source. However, there are a number of locales that are essential for the tests of future packages to pass, in particular, the libstdc++ tests from GCC. The following instructions, instead of the install-locales target above, will install the minimum set of locales necessary for the tests to run successfully:

mkdir -p /tools/lib/locale
localedef -i de_DE -f ISO-8859-1 de_DE
localedef -i de_DE@euro -f ISO-8859-15 de_DE@euro
localedef -i en_HK -f ISO-8859-1 en_HK
localedef -i en_PH -f ISO-8859-1 en_PH
localedef -i en_US -f ISO-8859-1 en_US
localedef -i es_MX -f ISO-8859-1 es_MX
localedef -i fa_IR -f UTF-8 fa_IR
localedef -i fr_FR -f ISO-8859-1 fr_FR
localedef -i fr_FR@euro -f ISO-8859-15 fr_FR@euro
localedef -i it_IT -f ISO-8859-1 it_IT
localedef -i ja_JP -f EUC-JP ja_JP

The details on this package are found in the section called “Contents of Glibc”.

Approximate build time:  0.9 SBU
Required disk space:     22.7 MB

This package and the next two are only installed to support running the test suites for GCC and Binutils. Installing three packages just for testing purposes may seem like overkill, but it is very reassuring, if not essential, to know that our most important tools are working properly. Even if the the test suites are not run in this chapter (we recommend not running them), these packages are still required to run the test suites in the next chapter.

Prepare Tcl for compilation:

cd unix
./configure --prefix=/tools

Build the package:

make

If you want to test the results, then issue: TZ=UTC make test. However, the Tcl test suite is known to experience failures under certain host conditions that are not fully understood. Therefore, test suite failures here are not surprising, and are not considered critical. The TZ=UTC parameter sets the time zone to Coordinated Universal Time (UTC) also known as Greenwich Mean Time (GMT), but only for the duration of the test suite run. This ensures the clock tests are exercised correctly. More information on the TZ environment variable will be given later on in Chapter 7.

Install the package:

make install

Now make a necessary symbolic link:

ln -s tclsh8.4 /tools/bin/tclsh

Installed programs: tclsh (link to tclsh8.4), tclsh8.4

Installed library: libtcl8.4.so

tclsh8.4 is the Tcl command shell.

libtcl8.4.so is the Tcl library.

Approximate build time:  0.1 SBU
Required disk space:     3.9 MB

First fix a bug that can result in bogus failures during the GCC test suite run:

patch -Np1 -i ../expect-5.41.0-spawn-1.patch

Now prepare Expect for compilation:

./configure --prefix=/tools --with-tcl=/tools/lib --with-x=no

The meaning of the configure options:

Build the package:

make

(If you insist on testing the results, then issue: make test. However, the Expect test suite is known to experience failures under certain host conditions that are not fully understood. Therefore, test suite failures here are not surprising, and are not considered critical.)

And install it:

make SCRIPTS="" install

The meaning of the make parameter:

You can now remove the source directories of both Tcl and Expect.

Installed program: expect

Installed library: libexpect5.41.0.a

expect “talks” to other interactive programs according to a script.

Approximate build time:  0.1 SBU
Required disk space:     6.1 MB

Prepare DejaGnu for compilation:

./configure --prefix=/tools

Build and install the package:

make install

Installed program: runtest

runtest is the wrapper script that finds the proper expect shell and then runs DejaGnu.

Approximate build time:  11.0 SBU
Required disk space:     332.7 MB

The tools required to test GCC and Binutils are installed now: Tcl, Expect and DejaGnu. Therefore we can now rebuild GCC and Binutils, linking them against the new Glibc, and test them properly (if running the test suites in this chapter). One thing to note, however, is that these test suites are highly dependent on properly functioning pseudo terminals (PTYs) which are provided by your host. These days, PTYs are most commonly implemented via the devpts file system. You can quickly check if your host system is set up correctly in this regard by performing a simple test:

expect -c "spawn ls"

The response might be:

If you receive the above message, your host doesn't have its PTYs set up properly. In this case there is no point in running the test suites for GCC and Binutils until you are able to resolve the issue. You can consult the LFS Wiki at http://wiki.linuxfromscratch.org/ for more information on how to get PTYs working.

This time we will build both the C and the C++ compilers, so you'll have to unpack both the core and the g++ tarballs (and testsuite too, if you want to run the tests). Unpacking them in your working directory, they will all unfold into a single gcc-3.3.3/ subdirectory.

First correct a problem and make an essential adjustment:

patch -Np1 -i ../gcc-3.3.3-no_fixincludes-1.patch
patch -Np1 -i ../gcc-3.3.3-specs-1.patch

The first patch disables the GCC “fixincludes” script. We mentioned this briefly earlier, but a slightly more in-depth explanation of the fixincludes process is warranted here. Under normal circumstances, the GCC fixincludes script scans your system for header files that need to be fixed. It might find that some Glibc header files on your host system need to be fixed, fix them and put them in the GCC private include directory. Then, later on in Chapter 6, after we've installed the newer Glibc, this private include directory would be searched before the system include directory, resulting in GCC finding the fixed headers from the host system, which would most likely not match the Glibc version actually used for the LFS system.

The second patch changes GCC's default location of the dynamic linker (typically ld-linux.so.2). It also removes /usr/include from GCC's include search path. Patching now rather than adjusting the specs file after installation ensures that our new dynamic linker gets used during the actual build of GCC. That is, all the final (and temporary) binaries created during the build will link against the new Glibc.

Create a separate build directory again:

mkdir ../gcc-build
cd ../gcc-build

Before starting to build GCC, remember to unset any environment variables that override the default optimization flags.

Now prepare GCC for compilation:

../gcc-3.3.3/configure --prefix=/tools \
    --with-local-prefix=/tools \
    --enable-clocale=gnu --enable-shared \
    --enable-threads=posix --enable-__cxa_atexit \
    --enable-languages=c,c++

The meaning of the new configure options:

Compile the package:

make

There is no need to use the bootstrap target now, as the compiler we're using to compile this GCC was built from the exact same version of the GCC sources we used earlier.

Compilation is now complete. As mentioned earlier, we don't recommend running the test suites for the temporary tools here in this chapter. If you still want to run the GCC test suite anyway, the following command will do so:

make -k check

The -k flag is used to make the test suite run through to completion and not stop at the first failure. The GCC test suite is very comprehensive and is almost guaranteed to generate a few failures. To get a summary of the test suite results, run this:

../gcc-3.3.3/contrib/test_summary

(For just the summaries, pipe the output through grep -A7 Summ.)

You can compare your results to those posted to the gcc-testresults mailing list for similar configurations to your own. For an example of how current GCC-3.3.3 should look on i686-pc-linux-gnu, see http://gcc.gnu.org/ml/gcc-testresults/2004-01/msg00826.html.

Note that the results contain:

* 1 XPASS (unexpected pass) for g++
* 1 FAIL (unexpected failure) for gcc
* 24 XPASS's for libstdc++

The unexpected pass for g++ is due to the use of --enable-__cxa_atexit. Apparently not all platforms supported by GCC have support for “__cxa_atexit” in their C libraries, so this test is not always expected to pass.

The 24 unexpected passes for libstdc++ are due to the use of --enable-clocale=gnu. This option, which is the correct choice on Glibc-based systems of versions 2.2.5 and above, enables in the GNU C library a locale support that is superior to the otherwise selected generic model (which may be applicable if for instance you were using Newlibc, Sun-libc or whatever other libc). The libstdc++ test suite is apparently expecting the generic model, hence those tests are not always expected to pass.

Having a few unexpected failures often cannot be avoided. The GCC developers are usually aware of these, but haven't yet gotten around to fixing them. One particular case in point is the filebuf_members test in the C++ standard library testsuite. This test has been observed to fail in some situations, but succeeed in others. In short, unless your results are vastly different from those at the above URL, it is safe to continue.

And finally install the package:

make install

The details on this package are found in the section called “Contents of GCC”.

Approximate build time:  1.5 SBU
Required disk space:     35.6 MB

Create a separate build directory again:

mkdir ../binutils-build
cd ../binutils-build

Now prepare Binutils for compilation:

../binutils-2.14/configure --prefix=/tools \
    --enable-shared --with-lib-path=/tools/lib

The meaning of the new configure option:

Before starting to build Binutils, remember to unset any environment variables that override the default optimization flags.

Compile the package:

make

Compilation is now complete. As discussed earlier, we don't recommend running the test suites for the temporary tools here in this chapter. If nevertheless you want to run the Binutils test suite, the following command will do so:

make check

There should be no unexpected failures here, expected failures are fine. Unfortunately, there is no easy way to view the test results summary like there was for the GCC package. However, if a failure occurs here, it should be easy to spot. The output shown will contain something like:

And install the package:

make install

Now prepare the linker for the "Re-adjusting" phase in the next chapter:

make -C ld clean
make -C ld LIB_PATH=/usr/lib:/lib

The details on this package are found in the section called “Contents of Binutils”.

Approximate build time:  0.2 SBU
Required disk space:     16.9 MB

Prepare Gawk for compilation:

./configure --prefix=/tools

Compile the package:

make

(If you insist on testing the results, then issue: make check.)

And install it:

make install

The details on this package are found in the section called “Contents of Gawk”.

Approximate build time:  0.9 SBU
Required disk space:     69 MB

Prepare Coreutils for compilation:

DEFAULT_POSIX2_VERSION=199209 ./configure --prefix=/tools

This package has an issue when compiled against versions of glibc later than 2.3.2. Some of the Coreutils utilities (such as head, tail and sort) will reject their traditional syntax, a syntax that has been in use for approximately 30 years. This old syntax is so pervasive that compatibility should be preserved until the many places where it is used can be updated. Backwards compatibility is achieved by setting the DEFAULT_POSIX2_VERSION environment variable to "199209" in the above command. If you don't want coreutils to be backwards compatible with the traditional syntax, then simply omit setting the DEFAULT_POSIX2_VERSION environment variable. Realise though, that doing so will mean you'll have to deal with the consequences yourself: patch the many packages that still use the old syntax. We therefore recommend using the instructions exactly as given above.

Compile the package:

make

(If you insist on testing the results, then issue: make RUN_EXPENSIVE_TESTS=yes check. The RUN_EXPENSIVE_TESTS=yes parameter tells the test suite to run several additional tests that are considered relatively expensive on some platforms but generally are not a problem on Linux.)

And install the package:

make install

The details on this package are found in the section called “Contents of Coreutils”.

Approximate build time:  0.1 SBU
Required disk space:     2.5 MB

The Bzip2 package doesn't contain a configure script. Compile and install it with a straightforward:

make PREFIX=/tools install

The details on this package are found in the section called “Contents of Bzip2”.

Approximate build time:  0.1 SBU
Required disk space:     2.6 MB

Prepare Gzip for compilation:

./configure --prefix=/tools

Compile the package:

make

And install it:

make install

The details on this package are found in the section called “Contents of Gzip”.

Approximate build time:  0.1 SBU
Required disk space:     7.5 MB

Prepare Diffutils for compilation:

./configure --prefix=/tools

Compile the package:

make

And install it:

make install

The details on this package are found in the section called “Contents of Diffutils”.

Approximate build time:  0.2 SBU
Required disk space:     7.5 MB

Prepare Findutils for compilation:

./configure --prefix=/tools

Compile the package:

make

(If you insist on testing the results, then issue: make check.)

And install the package:

make install

The details on this package are found in the section called “Contents of Findutils”.

Approximate build time:  0.2 SBU
Required disk space:     8.8 MB

Prepare Make for compilation:

./configure --prefix=/tools

Compile the program:

make

(If you insist on testing the results, then issue: make check.)

Then install it and its documentation:

make install

The details on this package are found in the section called “Contents of Make”.

Approximate build time:  0.1 SBU
Required disk space:     5.8 MB

Prepare Grep for compilation:

./configure --prefix=/tools \
    --disable-perl-regexp --with-included-regex

The meaning of the configure options:

Compile the programs:

make

(If you insist on testing the results, then issue: make check.)

Then install them and their documentation:

make install

The details on this package are found in the section called “Contents of Grep”.

Approximate build time:  0.2 SBU
Required disk space:     5.9 MB

Prepare Sed for compilation:

./configure --prefix=/tools

Compile the program:

make

(If you insist on testing the results, then issue: make check.)

Then install it and its documentation:

make install

The details on this package are found in the section called “Contents of Sed”.

Approximate build time:  0.5 SBU
Required disk space:     67.6 MB

Prepare Gettext for compilation:

./configure --prefix=/tools

Compile the programs:

make

(If you insist on testing the results, then issue: make check. This takes a very long time, around 7 SBUs. Moreover, the Gettext test suite is known to experience failures under certain host conditions -- for example when it finds a Java compiler on the host (but an experimental patch to disable Java is available from the LFS Patches project).)

And install the package:

make install

The details on this package are found in the section called “Contents of Gettext”.

Approximate build time:  0.7 SBU
Required disk space:     27.8 MB

Prepare Ncurses for compilation:

./configure --prefix=/tools --with-shared \
    --without-debug --without-ada --enable-overwrite

The meaning of the configure options:

Compile the programs and libraries:

make

Then install them and their documentation:

make install

The details on this package are found in the section called “Contents of Ncurses”.

Approximate build time:  0.1 SBU
Required disk space:     1.9 MB

Prepare Patch for compilation (the preprocessor flag -D_GNU_SOURCE is only needed on the PowerPC platform, on other architectures you can leave it out):

CPPFLAGS=-D_GNU_SOURCE ./configure --prefix=/tools

Compile the program:

make

Then install it and its documentation:

make install

The details on this package are found in the section called “Contents of Patch”.

Approximate build time:  0.2 SBU
Required disk space:     10.3 MB

Prepare Tar for compilation:

./configure --prefix=/tools

Compile the programs:

make

(If you insist on testing the results, then issue: make check.)

Then install them and their documentation:

make install

The details on this package are found in the section called “Contents of Tar”.

Approximate build time:  0.2 SBU
Required disk space:     16.3 MB

Prepare Texinfo for compilation:

./configure --prefix=/tools

Compile the programs:

make

(If you insist on testing the results, then issue: make check.)

Then install them and their documentation:

make install

The details on this package are found in the section called “Contents of Texinfo”.

Approximate build time:  1.2 SBU
Required disk space:     27 MB

Bash contains several known bugs. Fix these with the following patch:

patch -Np1 -i ../bash-2.05b-2.patch

Now prepare Bash for compilation:

./configure --prefix=/tools

Compile the program:

make

(If you insist on testing the results, then issue: make tests.)

Then install it and its documentation:

make install

And make a link for the programs that use sh for a shell:

ln -s bash /tools/bin/sh

The details on this package are found in the section called “Contents of Bash”.

Approximate build time:  0.2 SBU
Required disk space:     16 MB

Util-linux doesn't use the freshly installed headers and libraries from the /tools directory. This is fixed by altering the configure script:

cp configure configure.backup
sed "s@/usr/include@/tools/include@g" configure.backup > configure

Prepare Util-linux for compilation:

./configure

Compile some support routines:

make -C lib

Since you'll only need a couple of the utilities contained in this package, build just those:

make -C mount mount umount
make -C text-utils more

Now copy these programs to the temporary tools directory:

cp mount/{,u}mount text-utils/more /tools/bin

The details on this package are found in the section called “Contents of Util-linux”.

Approximate build time:  0.8 SBU
Required disk space:     74 MB

First adapt some hard-wired paths to the C library:

patch -Np1 -i ../perl-5.8.4-libc-1.patch

Perl insists on using the arch program to find out the machine type. Create a little script to mimic this command:

echo "uname -m" > /tools/bin/arch
chmod 755 /tools/bin/arch

Now prepare Perl for compilation (make sure you get the 'IO Fcntl POSIX' right, they are all letters):

./configure.gnu --prefix=/tools -Dstatic_ext='IO Fcntl POSIX'

The meaning of the configure option:

Compile only the required tools:

make perl utilities

Then copy these tools and their libraries:

cp perl pod/pod2man /tools/bin
mkdir -p /tools/lib/perl5/5.8.4
cp -R lib/* /tools/lib/perl5/5.8.4

The details on this package are found in the section called “Contents of Perl”.

mkdir -p /{bin,boot,dev/{pts,shm},etc/opt,home,lib,mnt,proc}
mkdir -p /{root,sbin,srv,tmp,usr/local,var,opt}
mkdir -p /media/{floppy,cdrom}
mkdir /usr/{bin,include,lib,sbin,share,src}
ln -s share/{man,doc,info} /usr
mkdir /usr/share/{doc,info,locale,man}
mkdir /usr/share/{misc,terminfo,zoneinfo}
mkdir /usr/share/man/man{1,2,3,4,5,6,7,8}
mkdir /usr/local/{bin,etc,include,lib,sbin,share,src}
ln -s share/{man,doc,info} /usr/local
mkdir /usr/local/share/{doc,info,locale,man}
mkdir /usr/local/share/{misc,terminfo,zoneinfo}
mkdir /usr/local/share/man/man{1,2,3,4,5,6,7,8}
mkdir /var/{lock,log,mail,run,spool}
mkdir -p /var/{tmp,opt,cache,lib/misc,local}
mkdir /opt/{bin,doc,include,info}
mkdir -p /opt/{lib,man/man{1,2,3,4,5,6,7,8}}

chmod 0750 /root
chmod 1777 /tmp /var/tmp

We have based our directory tree on the FHS standard (available at http://www.pathname.com/fhs/). Besides the above created tree this standard stipulates the existence of /usr/local/games and /usr/share/games, but we don't much like these for a base system. However, feel free to make your system FHS-compliant. As to the structure of the /usr/local/share subdirectory, the FHS isn't precise, so we created here the directories that we think are needed.

Approximate build time:  1 SBU
Required disk space:     160 KB

Note that unpacking the make_devices-1.2.bz2 file doesn't create a directory for you to cd into, as the file contains only a shell script.

Install the make_devices script:

bzcat make_devices-1.2.bz2 > /dev/make_devices
chmod 754 /dev/make_devices

Device nodes are special files: things that can generate or receive data. They usually correspond to physical pieces of hardware. Device nodes can be created by issuing commands of the form: mknod -m mode name type major minor. In such a command, mode is the usual octal read/write/execute permissions triplet, and name is the name of the device file to be created. It may seem surprising, but the device name is actually arbitrary, except that most programs rely on devices such as /dev/null having their usual names. The remaining three parameters tell the kernel what device the node actually refers to. The type is a letter, either b or c, indicating whether the device is accessed in blocks (such as a hard disk) or character by character (such as the console). And major and minor are numbers, together forming a code that identifies the device to the kernel. A list of the currently assigned device numbers for Linux can be found in the file devices.txt in the Documentation subdirectory of the kernel sources.

Note that the same major/minor combination is usually assigned to both a block and a character device. These are, however, completely unrelated devices that cannot be interchanged. A device is identified by the type/major/minor triple, not just the major/minor pair, so when creating a device node it is important to choose the correct type of device.

Because looking up the type/major/minor triples and using mknod manually is tedious and error-prone, the make_devices script has been created. It contains a whole series of mknod commands, one for each device, complete with recommended name, permissions and group assignment. It has been set up so that only a minimal set of commonly used devices is enabled and the other lines are commented out. You should open make_devices in an editor and customize it to your needs. This takes some time, but is very simple. When you are satisfied, run the script to create the device files:

cd /dev
./make_devices

If you had success with mounting the devpts file system earlier in the section called “Mounting the proc and devpts file systems”, you can continue with the next section. If you were unable to mount devpts, you will have to create a few static ptyXX and ttyXX device nodes instead. To do this, open make_devices in your editor, go to the section “Pseudo-TTY masters” and enable a few ptyXX devices -- a handful are enough to enable the test suites to run, but if you plan to run a kernel without devpts support you will probably need many more (every xterm, ssh connection, telnet connection, and the like, uses one of these pseudo terminals). In the immediately following section “Pseudo-TTY slaves”, enable the corresponding ttyXX devices. When you are done, rerun ./make_devices from inside /dev to have it create the new devices.

Installed script: make_devices

make_devices is a script for creating a basic set of static device nodes, usually residing in the /dev directory.

Approximate build time:  0.1 SBU
Required disk space:     186 MB

We won't be compiling a new kernel yet -- we'll do that when we have finished the installation of all the packages. But the libraries installed in the next section need to refer to the kernel header files in order to know how to interface with the kernel. Instead of unpacking the kernel sources again, making the version file and the symlinks and so on, we will simply copy the headers from the temporary tools directory in one swoop:

cp -a /tools/include/{asm,asm-generic,linux} /usr/include

A few kernel header files refer to the autoconf.h header file. Since we have not yet configured the kernel, we need to create this file ourselves in order to avoid a compilation failure of Sysklogd. Create an empty autoconf.h file with:

touch /usr/include/linux/autoconf.h

In the past it was common practice to symlink the /usr/include/{linux,asm} directories to /usr/src/linux/include/{linux,asm}. This was a bad practice, as the following extract from a post by Linus Torvalds to the Linux Kernel Mailing List points out:

I would suggest that people who compile new kernels should: 

 - not have a single symbolic link in sight (except the one that the 
   kernel build itself sets up, namely the “linux/include/asm”
   symlink that is only used for the internal kernel compile itself) 

And yes, this is what I do. My /usr/src/linux still has the old 2.2.13 
header files, even though I haven't run a 2.2.13 kernel in a _loong_ 
time. But those headers were what Glibc was compiled against, so those 
headers are what matches the library object files. 

And this is actually what has been the suggested environment for at 
least the last five years. I don't know why the symlink business keeps 
on living on, like a bad zombie. Pretty much every distribution still 
has that broken symlink, and people still remember that the linux 
sources should go into “/usr/src/linux” even though that hasn't
been true in a _loong_ time.

The essential part is where Linus states that the header files should be the ones which Glibc was compiled against. These are the headers that should be used when you later compile other packages, as they are the ones that match the object-code library files. By copying the headers, we ensure that they remain available if later you upgrade your kernel.

Note, by the way, that it is perfectly all right to have the kernel sources in /usr/src/linux, as long as you don't have the /usr/include/{linux,asm} symlinks.

Approximate build time:  0.1 SBU
Required disk space:     15 MB

Install Man-pages by running:

make install

Installed files: various manual pages

Examples of provided manual pages are the pages describing all the C and C++ functions, important device files, and important configuration files.

Approximate build time:  12.3 SBU
Required disk space:     784 MB

The Glibc build system is very well self-contained and will install perfectly, even though our compiler specs file and linker are still pointing at /tools. We cannot adjust the specs and linker before the Glibc install, because the Glibc autoconf tests would then give bogus results and thus defeat our goal of achieving a clean build.

Before starting to build Glibc, remember to unset any environment variables that override the default optimization flags.

The Glibc documentation recommends building Glibc outside of the source directory in a dedicated build directory:

mkdir ../glibc-build
cd ../glibc-build

Now prepare Glibc for compilation:

../glibc-2.3.3-lfs-5.1/configure --prefix=/usr \
    --disable-profile --enable-add-ons=linuxthreads \
    --libexecdir=/usr/lib --with-headers=/usr/include \
    --without-cvs

The meaning of the new configure options:

Compile the package:

make

Test the results:

make check

The test suite notes from the section called “Glibc-2.3.3-lfs-5.1” are still very much appropriate here. Be sure to refer back there should you have any doubts.

Though it is a harmless message, the install stage of Glibc will complain about the absence of /etc/ld.so.conf. Fix this annoying little warning with:

touch /etc/ld.so.conf

And install the package:

make install

The locales that can make your system respond in a different language weren't installed by the above command. Do it with this:

make localedata/install-locales

An alternative to running the previous command is to install only those locales which you need or want. This can be achieved by using the localedef command. Information on this can be found in the INSTALL file in the Glibc source. However, there are a number of locales that are essential for the tests of future packages to pass, in particular, the libstdc++ tests from GCC. The following instructions, instead of the install-locales target above, will install the minimum set of locales necessary for the tests to run successfully:

mkdir -p /usr/lib/locale
localedef -i de_DE -f ISO-8859-1 de_DE
localedef -i de_DE@euro -f ISO-8859-15 de_DE@euro
localedef -i en_HK -f ISO-8859-1 en_HK
localedef -i en_PH -f ISO-8859-1 en_PH
localedef -i en_US -f ISO-8859-1 en_US
localedef -i es_MX -f ISO-8859-1 es_MX
localedef -i fa_IR -f UTF-8 fa_IR
localedef -i fr_FR -f ISO-8859-1 fr_FR
localedef -i fr_FR@euro -f ISO-8859-15 fr_FR@euro
localedef -i it_IT -f ISO-8859-1 it_IT
localedef -i ja_JP -f EUC-JP ja_JP

Finally, build the linuxthreads man pages:

make -C ../glibc-2.3.3-lfs-5.1/linuxthreads/man

And install these pages:

make -C ../glibc-2.3.3-lfs-5.1/linuxthreads/man install

We need to create the /etc/nsswitch.conf file, because, although Glibc provides defaults when this file is missing or corrupt, the Glibc defaults don't work well with networking. Also, our time zone needs to be set up.

Create a new file /etc/nsswitch.conf by running the following:

cat > /etc/nsswitch.conf << "EOF"
# Begin /etc/nsswitch.conf

passwd: files
group: files
shadow: files

hosts: files dns
networks: files

protocols: files
services: files
ethers: files
rpc: files

# End /etc/nsswitch.conf
EOF

To find out what time zone you're in, run the following script:

tzselect

When you've answered a few questions about your location, the script will output the name of your time zone, something like EST5EDT or Canada/Eastern. Then create the /etc/localtime file by running:

cp --remove-destination /usr/share/zoneinfo/Canada/Eastern /etc/localtime

The meaning of the option:

Of course, instead of Canada/Eastern, fill in the name of the time zone that the tzselect script gave you.

By default, the dynamic loader (/lib/ld-linux.so.2) searches through /lib and /usr/lib for dynamic libraries that are needed by programs when you run them. However, if there are libraries in directories other than /lib and /usr/lib, you need to add them to the /etc/ld.so.conf file for the dynamic loader to find them. Two directories that are commonly known to contain additional libraries are /usr/local/lib and /opt/lib, so we add those directories to the dynamic loader's search path.

Create a new file /etc/ld.so.conf by running the following:

cat > /etc/ld.so.conf << "EOF"
# Begin /etc/ld.so.conf

/usr/local/lib
/opt/lib

# End /etc/ld.so.conf
EOF

Installed programs: catchsegv, gencat, getconf, getent, glibcbug, iconv, iconvconfig, ldconfig, ldd, lddlibc4, locale, localedef, mtrace, nscd, nscd_nischeck, pcprofiledump, pt_chown, rpcgen, rpcinfo, sln, sprof, tzselect, xtrace, zdump and zic

Installed libraries: ld.so, libBrokenLocale.[a,so], libSegFault.so, libanl.[a,so], libbsd-compat.a, libc.[a,so], libc_nonshared.a, libcrypt.[a,so], libdl.[a,so], libg.a, libieee.a, libm.[a,so], libmcheck.a, libmemusage.so, libnsl.a, libnss_compat.so, libnss_dns.so, libnss_files.so, libnss_hesiod.so, libnss_nis.so, libnss_nisplus.so, libpcprofile.so, libpthread.[a,so], libresolv.[a,so], librpcsvc.a, librt.[a,so], libthread_db.so and libutil.[a,so]

catchsegv can be used to create a stack trace when a program terminates with a segmentation fault.

gencat generates message catalogues.

getconf displays the system configuration values for file system specific variables.

getent gets entries from an administrative database.

glibcbug creates a bug report and mails it to the bug email address.

iconv performs character set conversion.

iconvconfig creates fastloading iconv module configuration file.

ldconfig configures the dynamic linker runtime bindings.

ldd reports which shared libraries are required by each given program or shared library.

lddlibc4 assists ldd with object files.

locale is a Perl program that tells the compiler to enable or disable the use of POSIX locales for built-in operations.

localedef compiles locale specifications.

mtrace...

nscd is a name service cache daemon providing a cache for the most common name service requests.

nscd_nischeck checks whether or not secure mode is necessary for NIS+ lookup.

pcprofiledump dumps information generated by PC profiling.

pt_chown is a helper program for grantpt to set the owner, group and access permissions of a slave pseudo terminal.

rpcgen generates C code to implement the RPC protocol.

rpcinfo makes an RPC call to an RPC server.

sln is used to make symbolic links. The program is statically linked, so it is useful for making symbolic links to dynamic libraries if the dynamic linking system for some reason is nonfunctional.

sprof reads and displays shared object profiling data.

tzselect asks the user about the location of the system and reports the corresponding time zone description.

xtrace traces the execution of a program by printing the currently executed function.

zdump is the time zone dumper.

zic is the time zone compiler.

ld.so is the helper program for shared library executables.

libBrokenLocale is used by programs, such as Mozilla, to solve broken locales.

libSegFault is a segmentation fault signal handler. It tries to catch segfaults.

libanl is an asynchronous name lookup library.

libbsd-compat provides the portability needed in order to run certain BSD programs under Linux.

libc is the main C library -- a collection of commonly used functions.

libcrypt is the cryptography library.

libdl is the dynamic linking interface library.

libg is a runtime library for g++.

libieee is the IEEE floating point library.

libm is the mathematical library.

libmcheck contains code run at boot.

libmemusage is used by memusage to help collect information about the memory usage of a program.

libnsl is the network services library.

libnss* are the Name Service Switch libraries, containing functions for resolving host names, user names, group names, aliases, services, protocols,and the like.

libpcprofile contains profiling functions used to track the amount of CPU time spent in which source code lines.

libpthread is the POSIX threads library.

libresolv contains functions for creating, sending, and interpreting packets to the Internet domain name servers.

librpcsvccontains functions providing miscellaneous RPC services.

librt contains functions providing most of the interfaces specified by the POSIX.1b Realtime Extension.

libthread_db contains functions useful for building debuggers for multi-threaded programs.

libutil contains code for "standard" functions used in many different Unix utilities.

Approximate build time:  1.4 SBU
Required disk space:     167 MB

Now is an appropriate time to verify that your pseudo terminals (PTYs) are working properly inside the chroot environment. We will again quickly check that everything is set up correctly by performing a simple test:

expect -c "spawn ls"

If you receive the message:

Your chroot environment is not set up for proper PTY operation. In this case there is no point in running the test suites for Binutils and GCC until you are able to resolve the issue. Please refer back to the section called “Mounting the proc and devpts file systems” and the Make_devices section and perform the recommended steps to fix the problem.

This package is known to behave badly when you have changed its default optimization flags (including the -march and -mcpu options). Therefore, if you have defined any environment variables that override default optimizations, such as CFLAGS and CXXFLAGS, we recommend un-setting or modifying them when building Binutils.

The Binutils documentation recommends building Binutils outside of the source directory in a dedicated build directory:

mkdir ../binutils-build
cd ../binutils-build

Now prepare Binutils for compilation:

../binutils-2.14/configure --prefix=/usr --enable-shared

Compile the package:

make tooldir=/usr

Normally, the tooldir (the directory where the executables end up) is set to $(exec_prefix)/$(target_alias), which expands into, for example, /usr/i686-pc-linux-gnu. Since we only build for our own system, we don't need this target specific directory in /usr. That setup would be used if the system was used to cross-compile (for example compiling a package on an Intel machine that generates code that can be executed on PowerPC machines).

Test the results:

make check

The test suite notes from the section called “Binutils-2.14 - Pass 2” are still very much appropriate here. Be sure to refer back there should you have any doubts.

Install the package:

make tooldir=/usr install

Install the libiberty header file that is needed by some packages:

cp ../binutils-2.14/include/libiberty.h /usr/include

Installed programs: addr2line, ar, as, c++filt, gprof, ld, nm, objcopy, objdump, ranlib, readelf, size, strings and strip

Installed libraries: libiberty.a, libbfd.[a,so] and libopcodes.[a,so]

addr2line translates program addresses to file names and line numbers. Given an address and the name of an executable, it uses the debugging information in the executable to figure out which source file and line number are associated with the address.

ar creates, modifies, and extracts from archives. An archive is a single file holding a collection of other files in a structure that makes it possible to retrieve the original individual files (called members of the archive).

as is an assembler. It assembles the output of gcc into object files.

c++filt is used by the linker to de-mangle C++ and Java symbols, to keep overloaded functions from clashing.

gprof displays call graph profile data.

ld is a linker. It combines a number of object and archive files into a single file, relocating their data and tying up symbol references.

nm lists the symbols occurring in a given object file.

objcopy is used to translate one type of object file into another.

objdump displays information about the given object file, with options controlling what particular information to display. The information shown is mostly only useful to programmers who are working on the compilation tools.

ranlib generates an index of the contents of an archive, and stores it in the archive. The index lists all the symbols defined by archive members that are relocatable object files.

readelf displays information about elf type binaries.

size lists the section sizes -- and the grand total -- for the given object files.

strings outputs, for each given file, the sequences of printable characters that are of at least the specified length (defaulting to 4). For object files it prints, by default, only the strings from the initializing and loading sections. For other types of files it scans the whole file.

strip discards symbols from object files.

libiberty contains routines used by various GNU programs, including getopt, obstack, strerror, strtol and strtoul.

libbfd is the Binary File Descriptor library.

libopcodes is a library for dealing with opcodes. It is used for building utilities like objdump. Opcodes are the “readable text” versions of instructions for the processor.

Approximate build time:  11.7 SBU
Required disk space:     294 MB

This package is known to behave badly when you have changed its default optimization flags (including the -march and -mcpu options). Therefore, if you have defined any environment variables that override default optimizations, such as CFLAGS and CXXFLAGS, we recommend un-setting or modifying them when building GCC.

Unpack the GCC-core and the GCC-g++ tarball -- they will unfold into the same directory. You should likewise extract the GCC-testsuite package. The full GCC package contains even more compilers. Instructions for building these can be found at http://www.linuxfromscratch.org/blfs/view/stable/general/gcc.html.

First apply only the No-Fixincludes patch (and not the Specs patch) also used in the previous chapter:

patch -Np1 -i ../gcc-3.3.3-no_fixincludes-1.patch

Now apply a sed substitution that will suppress the installation of libiberty.a. We want to use the version of libiberty.a provided by Binutils:

sed -i 's/install_to_$(INSTALL_DEST) //' libiberty/Makefile.in

The GCC documentation recommends building GCC outside of the source directory in a dedicated build directory:

mkdir ../gcc-build
cd ../gcc-build

Now prepare GCC for compilation:

../gcc-3.3.3/configure --prefix=/usr \
    --enable-shared --enable-threads=posix \
    --enable-__cxa_atexit --enable-clocale=gnu \
    --enable-languages=c,c++

Compile the package:

make

Test the results, but don't stop at errors (you'll remember the few known ones):

make -k check

The test suite notes from the section called “GCC-3.3.3 - Pass 2” are still very much appropriate here. Be sure to refer back there should you have any doubts.

Now install the package:

make install

Some packages expect the C PreProcessor to be installed in the /lib directory. To support those packages, create this symlink:

ln -s ../usr/bin/cpp /lib

Many packages use the name cc to call the C compiler. To satisfy those packages, create a symlink:

ln -s gcc /usr/bin/cc

Installed programs: c++, cc (link to gcc), cc1, cc1plus, collect2, cpp, g++, gcc, gccbug, and gcov

Installed libraries: libgcc.a, libgcc_eh.a, libgcc_s.so, libstdc++.[a,so] and libsupc++.a

cpp is the C preprocessor. It is used by the compiler to have the #include and #define and such statements expanded in the source files.

g++ is the C++ compiler.

gcc is the C compiler. It is used to translate the source code of a program into assembly code.

gccbug is a shell script used to help create good bug reports.

gcov is a coverage testing tool. It is used to analyze programs to find out where optimizations will have the most effect.

libgcc* contains run-time support for gcc.

libstdc++ is the standard C++ library. It contains many frequently-used functions.

libsupc++ provides supporting routines for the c++ programming language.

Approximate build time:  0.9 SBU
Required disk space:     69 MB

Normally the functionality of uname is somewhat broken, in that the -p switch always returns “unknown”. The following patch fixes this behavior for Intel architectures:

patch -Np1 -i ../coreutils-5.2.1-uname-1.patch

We do not want Coreutils to install its version of the hostname program, because it is inferior to the version provided by Net-tools. Prevent its installation by applying a patch:

patch -Np1 -i ../coreutils-5.2.1-hostname-1.patch

Now prepare Coreutils for compilation:

DEFAULT_POSIX2_VERSION=199209 ./configure --prefix=/usr

Compile the package:

make

The test suite of Coreutils makes several assumptions about the presence of files and users that aren't valid this early in the LFS build. We will therefore have to set up a few things before being able to run the tests. If you choose not to run these tests, skip down to “Install the package”.

To be able to run the full test suite, the su program needs to be installed. We didn't bother to install this little program in Chapter 5 because it requires root privileges, so do it now:

make install-root

Create a 'table of mounted filesystems' file with:

touch /etc/mtab

And create two dummy groups and a dummy user name:

echo "dummy1:x:1000" >> /etc/group
echo "dummy2:x:1001:dummy" >> /etc/group
echo "dummy:x:1000:1000:::/bin/bash" >> /etc/passwd

Now you're all set to run the test suite. First run the few tests that are meant to be run as root:

export NON_ROOT_USERNAME=dummy; make check-root

Then run the remainder of the tests as the dummy user:

su dummy -c "make RUN_EXPENSIVE_TESTS=yes check"

When you're done testing, remove the dummy user and groups:

sed -i.bak '/dummy/d' /etc/passwd /etc/group

Install the package:

make install

And move some programs to their proper locations:

mv /usr/bin/{basename,cat,chgrp,chmod,chown,cp,dd,df} /bin
mv /usr/bin/{date,echo,false,head,install,ln,ls} /bin
mv /usr/bin/{mkdir,mknod,mv,pwd,rm,rmdir,sync} /bin
mv /usr/bin/{sleep,stty,su,test,touch,true,uname} /bin
mv /usr/bin/chroot /usr/sbin

We'll be using the kill program from the Procps package (installed as /bin/kill later in the chapter). Remove the one installed by Coreutils:

rm /usr/bin/kill

Finally, create two symlinks to be FHS-compliant:

ln -s test /bin/[
ln -s ../../bin/install /usr/bin

Installed programs: basename, cat, chgrp, chmod, chown, chroot, cksum, comm, cp, csplit, cut, date, dd, df, dir, dircolors, dirname, du, echo, env, expand, expr, factor, false, fmt, fold, groups, head, hostid, hostname, id, install, join, link, ln, logname, ls, md5sum, mkdir, mkfifo, mknod, mv, nice, nl, nohup, od, paste, pathchk, pinky, pr, printenv, printf, ptx, pwd, readlink, rm, rmdir, seq, sha1sum, shred, sleep, sort, split, stat, stty, su, sum, sync, tac, tail, tee, test, touch, tr, true, tsort, tty, uname, unexpand, uniq, unlink, uptime, users, vdir, wc, who, whoami and yes

basename strips any path and a given suffix from the given file name.

cat concatenates files to standard output.

chgrp changes the group ownership of each given file to the given group. The group can be either given a a name or a numeric ID.

chmod changes the permissions of each given file to the given mode. The mode can be either a symbolic representation of the changes to make, or an octal number representing the new permissions.

chown changes the user and/or group ownership of each given file to the given user:group pair.

chroot runs a given command with the specified directory as the / directory. The given command can be an interactive shell. On most systems only root can do this.

cksum prints the CRC (Cyclic Redundancy Check) checksum and the byte counts of each specified file.

comm compares two sorted files, outputting in three columns the lines that are unique, and the lines that are common.

cp copies files.

csplit splits a given file into several new files, separating them according to given patterns or line numbers, and outputting the byte count of each new file.

cut prints parts of lines, selecting the parts according to given fields or positions.

date displays the current time in the given format, or sets the system date.

dd copies a file using the given block size and count, while optionally performing conversions on it.

df reports the amount of disk space available (and used) on all mounted file systems, or only on the file systems holding the given files.

dir is the same as ls.

dircolors outputs commands to set the LS_COLOR environment variable, to change the color scheme used by ls.

dirname strips the non-directory suffix from a given file name.

du reports the amount of disk space used by the current directory, or by each of the given directories including all their subdirectories, or by each of the given files.

echo displays the given strings.

env runs a command in a modified environment.

expand converts tabs to spaces.

expr evaluates expressions.

factor prints the prime factors of all specified integer numbers.

false does nothing, unsuccessfully. It always exits with a status code indicating failure.

fmt reformats the paragraphs in the given files.

fold wraps the lines in the given files.

groups reports a user's group memberships.

head prints the first ten lines (or the given number of lines) of each given file.

hostid reports the numeric identifier (in hexadecimal) of the host.

hostname reports or sets the name of the host.

id reports the effective user ID, group ID, and group memberships of the current user, or of a given user.

install copies files while setting their permission modes and, if possible, their owner and group.

join joins from two files the lines that have identical join fields.

link creates a hard link with the given name to the given file.

ln makes hard links or soft links between files.

logname reports the current user's login name.

ls lists the contents of each given directory. By default it orders the files and subdirectories alphabetically.

md5sum reports or checks MD5 (Message Digest 5) checksums.

mkdir creates directories with the given names.

mkfifo creates FIFOs (First-In, First-Out, a "named pipe" in UNIX parlance) with the given names.

mknod creates device nodes with the given names. A device node is a character special file, or a block special file, or a FIFO.

mv moves or renames files or directories.

nice runs a program with modified scheduling priority.

nl numbers the lines from the given files.

nohup runs a command immune to hangups, with output redirected to a log file.

od dumps files in octal and other formats.

paste merges the given files, joining sequentially corresponding lines side by side, separated by tab characters..

pathchk checks whether file names are valid or portable.

pinky is a lightweight finger. It reports some information about the given users.

pr paginates and columnates files for printing.

printenv prints the environment.

printf prints the given arguments according to the given format -- much like the C printf function.

ptx produces from the contents of the given files a permuted index, with each keyword in its context.

pwd reports the name of the current directory.

readlink reports the value of the given symbolic link.

rm removes files or directories.

rmdir removes directories, if they are empty.

seq prints a sequence of numbers, within a given range and with a given increment.

sha1sum prints or checks 160-bit SHA1 checksums.

shred overwrites the given files repeatedly with strange patterns, to make it real hard to recover the data.

sleep pauses for the given amount of time.

sort sorts the lines from the given files.

split splits the given file into pieces, by size or by numbspliter of lines.

stty sets or reports terminal line settings.

su runs a shell with substitute user and group IDs.

sum prints checksum and block counts for each given file.

sync flushes file system buffers. It forces changed blocks to disk and updates the super block.

tac concatenates the given files in reverse.

tail prints the last ten lines (or the given number of lines) of each given file.

tee reads from standard input while writing both to standard output and to the given files.

test compares values and checks file types.

touch changes file timestamps, setting the access and modification times of the given files to the current time. Files that do not exist are created with zero length.

tr translates, squeezes, and deletes the given characters from standard input.

true does nothing, successfully. It always exits with a status code indicating success.

tsort performs a topological sort. It writes a totally ordered list according to the partial ordering in a given file.

tty reports the file name of the terminal connected to standard input.

uname reports system information.

unexpand converts spaces to tabs.

uniq discards all but one of successive identical lines.

unlink removes the given file.

uptime reports how long the system has been running, how many users are logged on, and the system load averages.

users reports the names of the users currently logged on.

vdir is the same as ls -l.

wc reports the number of lines, words, and bytes for each given file, and a total line when more than one file is given.

who reports who is logged on.

whoami reports the user name associated with the current effective user ID.

yes outputs 'y' or a given string repeatedly, until killed.

Approximate build time:  0.1 SBU
Required disk space:     1.5 MB

Prepare Zlib for compilation:

./configure --prefix=/usr --shared

Compile the package:

make

To test the results, issue: make check.

Install the shared library:

make install

Now also build the non-shared (static) library:

make clean
./configure --prefix=/usr
make

To again test the results, issue: make check.

Install the static library:

make install

And fix the permissions on the static library:

chmod 644 /usr/lib/libz.a

It is good policy and common practice to place important libraries into the /lib directory. This matters most in scenarios where /usr is on a separate partition. Essentially, the run-time components of any libraries that are used by programs in /bin or /sbin should reside in /lib so that they are on the root partition and available in the event of /usr being inaccessible.

For the above reason we move the run-time components of the shared Zlib into /lib:

mv /usr/lib/libz.so.* /lib

Now we need to fix the /usr/lib/libz.so symlink because we just moved the file it points to:

ln -sf ../../lib/libz.so.1 /usr/lib/libz.so

Installed libraries: libz[a,so]

libz* contains compression and un-compression functions used by some programs.

Approximate build time:  0.1 SBU
Required disk space:     317 KB

Many scripts still use the deprecated tempfile program, which has functionality much the same as mktemp. Patch mktemp to include a tempfile wrapper:

patch -Np1 -i ../mktemp-1.5-add-tempfile.patch

Now prepare Mktemp for compilation:

./configure --prefix=/usr --with-libc

The meaning of the configure option:

Compile the package:

make

Now install it:

make install
make install-tempfile

Installed programs: mktemp, tempfile

mktemp creates temporary files in a secure manner. It is used in scripts.

tempfile creates temporary files in a less secure manner than mktemp. It is installed for backwards-compatibility.

Approximate build time:  0.1 SBU
Required disk space:     641 KB

Parse the data:

make

Now install it:

make install

Installed files: protocols, services

Approximate build time:  0.2 SBU
Required disk space:     7.5 MB

Prepare Findutils for compilation:

./configure --prefix=/usr --libexecdir=/usr/lib/locate \
        --localstatedir=/var/lib/misc

The localstatedir directive above changes the location of the locate database to be in /var/lib/misc, which is FHS-compliant.

Compile the package:

make

To test the results, issue: make check.

Now install the package:

make install

Installed programs: bigram, code, find, frcode, locate, updatedb and xargs

bigram was formerly used to produce locate databases.

code was formerly used to produce locate databases. It is the ancestor of frcode.

find searches given directory trees for files matching the specified criteria.

frcode is called by updatedb to compress the list of file names. It uses front-compression, reducing the database size by a factor of 4 to 5.

locate searches through a database of file names, and reports the names that contain a given string or match a given pattern.

updatedb updates the locate database. It scans the entire file system (including other file systems that are currently mounted, unless told not to) and puts every file name it finds in the database.

xargs can be used to apply a given command to a list of files.

Approximate build time:  0.2 SBU
Required disk space:     17 MB

Prepare Gawk for compilation:

./configure --prefix=/usr --libexecdir=/usr/lib

Compile the package:

make

To test the results, issue: make check.

Now install the package:

make install

Installed programs: awk (link to gawk), gawk, gawk-3.1.3, grcat, igawk, pgawk, pgawk-3.1.3 and pwcat

gawk is a program for manipulating text files. It is the GNU implementation of awk.

grcat dumps the group database /etc/group.

igawk gives gawk the ability to include files.

pgawk is the profiling version of gawk.

pwcat dumps the password database /etc/passwd.

Approximate build time:  0.6 SBU
Required disk space:     27 MB

Prepare Ncurses for compilation:

./configure --prefix=/usr --with-shared --without-debug

Compile the package:

make

Install the package:

make install

Give the Ncurses libraries execute permissions:

chmod 755 /usr/lib/*.5.4

Now fix a library that shouldn't be executable:

chmod 644 /usr/lib/libncurses++.a

Move the libraries to the /lib directory, where they're expected to reside:

mv /usr/lib/libncurses.so.5* /lib

Because the libraries have been moved, a few symlinks are pointing to non-existent files. Recreate those symlinks:

ln -sf ../../lib/libncurses.so.5 /usr/lib/libncurses.so
ln -sf libncurses.so /usr/lib/libcurses.so

Installed programs: captoinfo (link to tic), clear, infocmp, infotocap (link to tic), reset (link to tset), tack, tic, toe, tput and tset

Installed libraries: libcurses.[a,so] (link to libncurses.[a,so]), libform.[a,so], libmenu.[a,so], libncurses++.a, libncurses.[a,so], libpanel.[a,so]

captoinfo converts a termcap description into a terminfo description.

clear clears the screen, if this is possible.

infocmp compares or prints out terminfo descriptions.

infotocap converts a terminfo description into a termcap description.

reset reinitializes a terminal to its default values.

tack is the terminfo action checker. It is mainly used to test the correctness of an entry in the terminfo database.

tic is the terminfo entry-description compiler. It translates a terminfo file from source format into the binary format needed for the ncurses library routines. A terminfo file contains information on the capabilities of a certain terminal.

toe lists all available terminal types, for each giving its primary name and its description.

tput makes the values of terminal-dependent capabilities available to the shell. It can also be used to reset or initialize a terminal, or report its long name.

tset can be used to initialize terminals.

libncurses* contains functions to display text in many complicated ways on a terminal screen. A good example of the use of these functions is the menu displayed during the kernel's make menuconfig.

libform* contains functions to implement forms.

libmenu* contains functions to implement menus.

libpanel* contains functions to implement panels.

Approximate build time:  0.4 SBU
Required disk space:     34 MB

If you prefer another editor -- like Emacs, Joe, or Nano -- to Vim, have a look at http://www.linuxfromscratch.org/blfs/view/stable/postlfs/editors.html for suggested installation instructions.

First change the default locations of the vimrc and gvimrc configuration files to /etc.

echo '#define SYS_VIMRC_FILE "/etc/vimrc"' >> src/feature.h
echo '#define SYS_GVIMRC_FILE "/etc/gvimrc"' >> src/feature.h

Now prepare Vim for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, you can issue: make test. However, this test suite outputs a lot of seemingly garbage characters to the screen, and this can wreak havoc with the settings of the current terminal. Therefore the running of the test suite here is strictly optional.

Now install the package:

make install

Many users are used to using vi, instead of vim. To let them execute vim when they habitually enter vi, create a symlink:

ln -s vim /usr/bin/vi

If you are going to install the X Window system on your LFS system, you may want to re-compile Vim after having installed X. Vim comes with a nice GUI version of the editor that requires X and a few other libraries to be installed. For more information read the Vim documentation.

By default, vim runs in vi-incompatible mode. Some people might not like this, but we prefer to run vim in its own mode (else we wouldn't have included it in this book, but the original vi). We've included the setting of "nocompatible" below to high-light the fact that the new behavior is being used. It also reminds those who would change to "compatible" mode that it should appear first because it changes other settings and overrides must come after this setting. Create a default vim configuration file by running the following:

cat > /etc/vimrc << "EOF"
" Begin /etc/vimrc

set nocompatible
set backspace=2
syntax on

" End /etc/vimrc
EOF

The set nocompatible makes vim behave in a more useful way (the default) than the vi-compatible manner. Remove the "no" if you want the old vi behavior. The set backspace=2 allows backspacing over line breaks, autoindents and the start of insert. The syntax on enables vim's semantic coloring.

Installed programs: efm_filter.pl, efm_perl.pl, ex (link to vim), less.sh, mve.awk, pltags.pl, ref, rview (link to vim), rvim (link to vim), shtags.pl, tcltags, vi (link to vim), view (link to vim), vim, vim132, vim2html.pl, vimdiff (link to vim), vimm, vimspell.sh, vimtutor and xxd

efm_filter.pl is a filter for creating an error file that can be read by vim.

efm_perl.pl reformats the error messages of the Perl interpreter for use with the “quickfix” mode of vim.

ex starts vim in ex mode.

less.sh is a script that starts vim with less.vim.

mve.awk processes vim errors.

pltags.pl creates a tags file for perl code, for use by vim.

ref checks the spelling of arguments.

rview is a restricted version of view: no shell commands can be started and view can't be suspended.

rvim is a restricted version of vim: no shell commands can be started and vim can't be suspended.

shtags.pl generates a tag file for perl scripts.

tcltags generates a tag file for TCL code.

view starts vim in read-only mode.

vim is the editor.

vim132 starts vim with the terminal in 132-column mode.

vim2html.pl converts vim documentation to HTML.

vimdiff edits two or three versions of a file with vim and show differences.

vimm enables the DEC locator input model on a remote terminal.

vimspell.sh is a script which spells a file and generates the syntax statements necessary to highlight in vim.

vimtutor teaches you the basic keys and commands of vim.

xxd makes a hex dump of the given file. It can also do the reverse, so it can be used for binary patching.

Approximate build time:  0.1 SBU
Required disk space:     3.0 MB

Prepare M4 for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check.

And install the package:

make install

Installed program: m4

m4 copies the given files while expanding the macros that they contain. These macros are either built-in or user-defined and can take any number of arguments. Besides just doing macro expansion, m4 has built-in functions for including named files, running Unix commands, doing integer arithmetic, manipulating text in various ways, recursion, and so on. The m4 program can be used either as a front-end to a compiler or as a macro processor in its own right.

Approximate build time:  0.6 SBU
Required disk space:     10.6 MB

First fix a minor compilation problem that Bison has with some packages, the patch is back-ported from CVS:

patch -Np1 -i ../bison-1.875-attribute.patch

Now prepare Bison for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check.

Now install the package:

make install

Installed programs: bison and yacc

Installed library: liby.a

bison generates, from a series of rules, a program for analyzing the structure of text files. Bison is a replacement for yacc (Yet Another Compiler Compiler).

yacc is a wrapper for bison, meant for programs that still call yacc instead of bison. It calls bison with the -y option.

liby.a is the Yacc library containing implementations of Yacc-compatible yyerror and main functions. This library is normally not very useful, but POSIX requires it.

Approximate build time:  0.1 SBU
Required disk space:     3.4 MB

Prepare Less for compilation:

./configure --prefix=/usr --bindir=/bin --sysconfdir=/etc

The meaning of the configure option:

Compile the package:

make

Now install it:

make install

Installed programs: less, lessecho and lesskey

less is a file viewer or pager. It displays the contents of the given file, letting you scroll around, find strings, and jump to marks.

lessecho is needed to expand meta-characters, such as * and ?, in filenames on Unix systems.

lesskey is used to specify the key bindings for less.

Approximate build time:  0.5 SBU
Required disk space:     43 MB

Groff expects the environment variable PAGE to contain the default paper size. For those in the United States, the command below is appropriate. If you live elsewhere, you may want to change PAGE=letter to PAGE=A4.

Prepare Groff for compilation:

PAGE=letter ./configure --prefix=/usr

Compile the package:

make

Now install it:

make install

Some documentation programs, such as xman, will not work properly without the following symlinks:

ln -s soelim /usr/bin/zsoelim
ln -s eqn /usr/bin/geqn
ln -s tbl /usr/bin/gtbl

Installed programs: addftinfo, afmtodit, eqn, eqn2graph, geqn (link to eqn), grn, grodvi, groff, groffer, grog, grolbp, grolj4, grops, grotty, gtbl (link to tbl), hpftodit, indxbib, lkbib, lookbib, mmroff, neqn, nroff, pfbtops, pic, pic2graph, post-grohtml, pre-grohtml, refer, soelim, tbl, tfmtodit, troff and zsoelim (link to soelim)

addftinfo reads a troff font file and adds some additional font-metric information that is used by the groff system.

afmtodit creates a font file for use with groff and grops.

eqn compiles descriptions of equations embedded within troff input files into commands that are understood by troff.

eqn2graph converts an EQN equation into a cropped image.

grn is a groff preprocessor for gremlin files.

grodvi is a driver for groff that produces TeX dvi format.

groff is a front-end to the groff document formatting system. Normally it runs the troff program and a post-processor appropriate for the selected device.

groffer displays groff files and man pages on X and tty terminals.

grog reads files and guesses which of the groff options -e, -man, -me, -mm, -ms, -p, -s, and -t are required for printing files, and reports the groff command including those options.

grolbp is a groff driver for Canon CAPSL printers (LBP-4 and LBP-8 series laser printers).

grolj4 is a driver for groff that produces output in PCL5 format suitable for an HP Laserjet 4 printer.

grops translates the output of GNU troff to Postscript.

grotty translates the output of GNU troff into a form suitable for typewriter-like devices.

gtbl is the GNU implementation of tbl.

hpftodit creates a font file for use with groff -Tlj4 from an HP-tagged font metric file.

indxbib makes an inverted index for the bibliographic databases a specified file for use with refer, lookbib, and lkbib.

lkbib searches bibliographic databases for references that contain specified keys and reports any references found.

lookbib prints a prompt on the standard error (unless the standard input is not a terminal), reads from the standard input a line containing a set of keywords, searches the bibliographic databases in a specified file for references containing those keywords, prints any references found on the standard output and repeats this process until the end of input.

mmroff is a simple preprocessor for groff.

neqn formats equations for ASCII (American Standard Code for Information Interchange) output.

nroff is a script that emulates the nroff command using groff.

pfbtops translates a Postscript font in .pfb format to ASCII.

pic compiles descriptions of pictures embedded within troff or TeX input files into commands understood by TeX or troff.

pic2graph converts a PIC diagram into a cropped image.

pre-grohtml translates the output of GNU troff to html.

post-grohtml translates the output of GNU troff to html.

refer copies the contents of a file to the standard output, except that lines between .[ and .] are interpreted as citations, and lines between .R1 and .R2 are interpreted as commands about how citations are to be processed.

soelim reads files and replaces lines of the form .so file by the contents of the mentioned file.

tbl compiles descriptions of tables embedded within troff input files into commands that are understood by troff.

tfmtodit creates a font file for use with groff -Tdvi.

troff is highly compatible with Unix troff. Usually it should be invoked using the groff command, which will also run preprocessors and post-processors in the appropriate order and with the appropriate options.

zsoelim is the GNU implementation of soelim.

Approximate build time:  0.2 SBU
Required disk space:     5.2 MB

Prepare Sed for compilation:

./configure --prefix=/usr --bindir=/bin

Compile the package:

make

To test the results, issue: make check.

Now install the package:

make install

Installed program: sed

sed is used to filter and transform text files in a single pass.

Approximate build time:  0.1 SBU
Required disk space:     3.4 MB

Prepare Flex for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make bigcheck.

Now install the package:

make install

There are some packages that expect to find the lex library in /usr/lib. Create a symlink to account for this:

ln -s libfl.a /usr/lib/libl.a

A few programs don't know about flex yet and try to run its predecessor lex. To support those programs, create a wrapper script named lex that calls flex in lex emulation mode:

cat > /usr/bin/lex << "EOF"
#!/bin/sh
# Begin /usr/bin/lex

exec /usr/bin/flex -l "$@"

# End /usr/bin/lex
EOF
chmod 755 /usr/bin/lex

Installed programs: flex, flex++ (link to flex) and lex

Installed library: libfl.a

flex is a tool for generating programs that recognize patterns in text. Pattern recognition is useful in many applications. From a set of rules on what to look for, flex makes a program that looks for those patterns. The reason to use flex is that it is much easier to specify the rules for a pattern-finding program than to write the program.

flex++ invokes a version of flex that is used exclusively for C++ scanners.

libfl.a is the flex library.

Approximate build time:  0.5 SBU
Required disk space:     55 MB

Prepare Gettext for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check. This takes a very long time, around 7 SBUs.

Now install the package:

make install

Installed programs: autopoint, config.charset, config.rpath, envsubst, gettext, gettextize, hostname, msgattrib, msgcat, msgcmp, msgcomm, msgconv, msgen, msgexec, msgfilter, msgfmt, msggrep, msginit, msgmerge, msgunfmt, msguniq, ngettext, project-id, team-address, trigger, urlget, user-email and xgettext

Installed libraries: libasprintf[a,so], libgettextlib[a,so], libgettextpo[a,so] and libgettextsrc[a,so]

autopoint copies standard gettext infrastructure files into a source package.

config.charset outputs a system-dependent table of character encoding aliases.

config.rpath outputs a system-dependent set of variables, describing how to set the runtime search path of shared libraries in an executable.

envsubst substitutes environment variables in shell format strings.

gettext translates a natural language message into the user's language, by looking up the translation in a message catalog.

gettextize copies all standard Gettext files into the given top-level directory of a package, to begin inter-nationalizing it.

hostname displays a network hostname in various forms.

msgattrib filters the messages of a translation catalog according to their attributes and manipulates the attributes.

msgcat concatenates and merges the given .po files.

msgcmp compares two .po files to check that both contain the same set of msgid strings.

msgcomm finds the messages that are common to to the given .po files.

msgconv converts a translation catalog to a different character encoding.

msgen creates an English translation catalog.

msgexec applies a command to all translations of a translation catalog.

msgfilter applies a filter to all translations of a translation catalog.

msgfmt generates a binary message catalog from from a translation catalog.

msggrep extracts all messages of a translation catalog that match a given pattern or belong to some given source files.

msginit creates a new .po file, initializing the meta information with values from the user's environment.

msgmerge combines two raw translations into a single file.

msgunfmt decompiles a binary message catalog into raw translation text.

msguniq unifies duplicate translations in a translation catalog.

ngettext displays native language translations of a textual message whose grammatical form depends on a number.

xgettext extracts the translatable message lines from the given source files, to make the first translation template.

libasprintf defines the autosprintf class, which makes C formatted output routines usable in C++ programs, for use with the <string> strings and the <iostream> streams.

libgettextlib is a private library containing common routines used by the various gettext programs. They're not meant for general use.

libgettextpo is used to write specialized programs that process PO files. This library is used when the standard applications shipped with gettext won't suffice (such as msgcomm, msgcmp, msgattrib and msgen).

libgettextsrc is a private library containing common routines used by the various gettext programs. They're not meant for general use.

Approximate build time:  0.1 SBU
Required disk space:     9.4 MB

If you don't know what to answer to all the questions asked during the make config phase below, then just accept the defaults. This will be just fine in the majority of cases. What you're asked here is a bunch of questions about which network protocols you've enabled in your kernel. The default answers will enable the tools from this package to work with the most common protocols: TCP, PPP, and several others. You still need to actually enable these protocols in the kernel -- what you do here is merely telling the package to include support for those protocols in its programs, but it's up to the kernel to make the protocols available.

First fix a small syntax problem in the sources of the mii-tool program:

patch -Np1 -i ../net-tools-1.60-miitool-gcc33-1.patch

Now prepare Net-tools for compilation (if you intend to accept the defaults, you can skip all the questions by running yes "" | make config instead):

make config

Compile the package:

make

Now install it:

make update

Installed programs: arp, dnsdomainname (link to hostname), domainname (link to hostname), hostname, ifconfig, nameif, netstat, nisdomainname (link to hostname), plipconfig, rarp, route, slattach and ypdomainname (link to hostname)

arp is used to manipulate the kernel's ARP cache, usually to add or delete an entry, or to dump the entire cache.

dnsdomainname reports the system's DNS (Domain Name Server) domain name.

domainname reports or sets the system's NIS/YP domain name.

hostname reports or sets the name of the current host system.

ifconfig is the main utility for configuring network interfaces.

nameif names network interfaces based on MAC addresses.

netstat is used to report network connections, routing tables, and interface statistics..

nisdomainname does the same as domainname.

plipconfig is used to fine tune the PLIP device parameters, to improve its performance.

rarp is used to manipulate the kernel's RARP table.

route is used to manipulate the IP routing table.

slattach attaches a network interface to a serial line. This allows you to use normal terminal lines for point-to-point links to other computers.

ypdomainname does the same as domainname.

Approximate build time:  0.2 SBU
Required disk space:     11 MB

We are not going to install all the programs that come with Inetutils. However, the Inetutils build system will insist on installing all the man pages anyway. The following patch will correct this situation:

patch -Np1 -i ../inetutils-1.4.2-no_server_man_pages-1.patch

Now prepare Inetutils for compilation:

./configure --prefix=/usr --libexecdir=/usr/sbin \
    --sysconfdir=/etc --localstatedir=/var \
    --disable-logger --disable-syslogd \
    --disable-whois --disable-servers

The meaning of the configure options:

Compile the package:

make

Install it:

make install

Move the ping program to its FHS-compliant place:

mv /usr/bin/ping /bin

Installed programs: ftp, ping, rcp, rlogin, rsh, talk, telnet and tftp

ftp is the ARPANET file transfer program.

ping sends echo-request packets and reports how long the replies take.

rcp does remote file copy.

rlogin does remote login.

rsh runs a remote shell.

talk is used to chat up another user.

telnet is an interface to the TELNET protocol.

tftp is a trivial file transfer program.

Approximate build time:  2.9 SBU
Required disk space:     143 MB

If you want full control over the way Perl is set up, you can run the interactive Configure script and hand-pick the way this package is built. If you think you can live with the (sensible) defaults it auto-detects, then prepare Perl for compilation with:

./configure.gnu --prefix=/usr -Dpager="/bin/less -isR"

The meaning of the configure option:

Compile the package:

make

If you wish to run the test suite, you first have to create a basic /etc/hosts file, which is needed by a couple of tests to resolve the name localhost:

echo "127.0.0.1 localhost $(hostname)" > /etc/hosts

Now run the tests, if you wish:

make test

Finally, install the package:

make install

Installed programs: a2p, c2ph, dprofpp, enc2xs, find2perl, h2ph, h2xs, libnetcfg, perl, perl5.8.4 (link to perl), perlbug, perlcc, perldoc, perlivp, piconv, pl2pm, pod2html, pod2latex, pod2man, pod2text, pod2usage, podchecker, podselect, psed (link to s2p), pstruct (link to c2ph), s2p, splain and xsubpp

Installed libraries: (too many to name)

a2p translates awk to perl.

c2ph dumps C structures as generated from "cc -g -S" stabs.

dprofpp displays perl profile data.

en2cxs builds a Perl extension for the Encode module, from either Unicode Character Mappings or Tcl Encoding Files.

find2perl translates find commands to perl.

h2ph converts .h C header files to .ph Perl header files.

h2xs converts .h C header files to Perl extensions.

libnetcfg can be used to configure the libnet.

perl combines some of the best features of C, sed, awk and sh into a single swiss-army language.

perlbug is used to generate bug reports about Perl or the modules that come with it, and mail them.

perlcc generates executables from Perl programs.

perldoc displays a piece of documentation in pod format that is embedded in the perl installation tree or in a perl script.

perlivp is the Perl Installation Verification Procedure. It can be used to verify that Perl and its libraries have been installed correctly.

piconv is a Perl version of the character encoding converter iconv.

pl2pm is a rough tool for converting Perl4 .pl files to Perl5 .pm modules.

pod2html converts files from pod format to HTML format.

pod2latex converts files from pod format to LaTeX format.

pod2man converts pod data to formatted *roff input.

pod2text converts pod data to formatted ASCII text.

pod2usage prints usage messages from embedded pod docs in files.

podchecker checks the syntax of pod format documentation files.

podselect displays selected sections of pod documentation.

psed is a Perl version of the stream editor sed.

pstruct dumps C structures as generated from "cc -g -S" stabs.

s2p translates sed to perl.

splain is used to force verbose warning diagnostics in perl.

xsubpp converts Perl XS code into C code.

Approximate build time:  0.2 SBU
Required disk space:     17 MB

Prepare Texinfo for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check.

Install the package:

make install

Optionally install the components belonging in a TeX installation:

make TEXMF=/usr/share/texmf install-tex

The meaning of the make parameter:

The Info documentation system uses a plain text file to hold its list of menu entries. The file is located at /usr/share/info/dir. Unfortunately, due to occasional problems in the Makefiles of various packages, it can sometimes get out of step with the Info manuals actually installed on the system. If ever you need to recreate the /usr/share/info/dir file, the following optional commands will accomplish the task:

cd /usr/share/info
rm dir
for f in *
do install-info $f dir 2>/dev/null
done

Installed programs: info, infokey, install-info, makeinfo, texi2dvi and texindex

info is used to read Info documents. Info documents are a bit like man pages, but often go much deeper than just explaining all the flags. Compare for example man tar and info tar.

infokey compiles a source file containing Info customizations into a binary format.

install-info is used to install Info files. It updates entries in the Info index file.

makeinfo translates the given Texinfo source documents into various other formats: Info files, plain text, or HTML.

texi2dvi is used to format the given Texinfo document into a device-independent file that can be printed.

texindex is used to sort Texinfo index files.

Approximate build time:  0.5 SBU
Required disk space:     7.7 MB

Prepare Autoconf for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check. This takes a long time, about 2 SBUs.

Install the package:

make install

Installed programs: autoconf, autoheader, autom4te, autoreconf, autoscan, autoupdate and ifnames

autoconf is a tool for producing shell scripts that automatically configure software source code packages to adapt to many kinds of Unix-like systems. The configuration scripts it produces are independent -- running them does not require the autoconf program.

autoheader is a tool for creating template files of C #define statements for configure to use.

autom4te is a wrapper for the M4 macro processor.

autoreconf comes in handy when there are a lot of autoconf-generated configure scripts around. The program runs autoconf and autoheader repeatedly (where appropriate) to remake the autoconf configure scripts and configuration header templates in a given directory tree.

autoscan can help to create a configure.in file for a software package. It examines the source files in a directory tree, searching them for common portability problems and creates a configure.scan file that serves as as a preliminary configure.in for the package.

autoupdate modifies a configure.in file that still calls autoconf macros by their old names to use the current macro names.

ifnames can be helpful when writing a configure.in for a software package. It prints the identifiers that the package uses in C preprocessor conditionals. If a package has already been set up to have some portability, this program can help to determine what configure needs to check. It can fill in some gaps in a configure.in file generated by autoscan.

Approximate build time:  0.2 SBU
Required disk space:     6.8 MB

Prepare Automake for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check. This takes a long time, about 5 SBUs.

Install the package:

make install

Installed programs: acinstall, aclocal, aclocal-1.8, automake, automake-1.8, compile, config.guess, config.sub, depcomp, elisp-comp, install-sh, mdate-sh, missing, mkinstalldirs, py-compile, symlink-tree, ylwrap

acinstall is a script that installs aclocal-style M4 files.

aclocal generates aclocal.m4 files based on the contents of configure.in files.

automake is a tool for automatically generating Makefile.in's from files called Makefile.am. To create all the Makefile.in files for a package, run this program in the top-level directory. By scanning the configure.ins it automatically finds each appropriate Makefile.am and generate the corresponding Makefile.in.

compile is a wrapper for compilers.

config.guess is a script that attempts to guess the canonical triplet for the given build, host, or target architecture.

config.sub is a configuration validation subroutine script.

depcomp is a script for compiling a program so that not only the desired output is generated, but also dependency information.

elisp-comp byte-compiles Emacs Lisp code.

install-sh is a script that installs a program, a script, or a datafile.

mdate-sh is a script that prints the modification time of a file or directory.

missing is a script acting as a common stub for missing GNU programs during an installation.

mkinstalldirs is a script that creates a directory tree.

py-compile compiles a Python program.

symlink-tree is a script to create a symlink tree of a directory tree.

ylwrap is a wrapper for lex and yacc.

Approximate build time:  1.2 SBU
Required disk space:     27 MB

Bash has a number of bugs in it that cause it to not behave the way it is expected at times. Fix this behavior with the following patch:

patch -Np1 -i ../bash-2.05b-2.patch

Now prepare Bash for compilation:

./configure --prefix=/usr --bindir=/bin

Compile the package:

make

To test the results, issue: make tests.

Install the package:

make install

Now run the newly compiled bash program (replacing the one you are currently executing):

exec /bin/bash --login +h

Note that the parameters used make it an interactive login instance (so /etc/profile is read, if it exists, and the first found ~/.bash_profile, ~/.bash_login or and ~/.profile) and continue to disable hashing so that new programs are found as they become available.

Installed programs: bash, sh (link to bash) and bashbug

bash is a widely-used command interpreter. It performs many kinds of expansions and substitutions on a given command line before executing it, thus making this interpreter a powerful tool.

bashbug is a shell script to help the user compose and mail bug reports concerning bash in a standard format.

sh is a symlink to the bash program. When invoked as sh, bash tries to mimic the startup behavior of historical versions of sh as closely as possible, while conforming to the POSIX standard as well.

Approximate build time:  0.1 SBU
Required disk space:     6.3 MB

Prepare File for compilation:

./configure --prefix=/usr

Compile the package:

make

Now install it:

make install

Installed program: file

Installed library: libmagic.[a,so]

file tries to classify each given file. It does this by performing several tests: file system tests, magic number tests, and language tests. The first test that succeeds determines the result.

libmagic contains routines for magic number recognition, used by the file program.

Approximate build time:  1.5 SBU
Required disk space:     20 MB

Prepare Libtool for compilation:

./configure --prefix=/usr

Compile the package:

make

To test the results, issue: make check.

Install the package:

make install

Installed programs: libtool and libtoolize

Installed libraries: libltdl.[a,so].

libtool provides generalized library-building support services.

libtoolize provides a standard way to add libtool support to a package.

libltdl hides the various difficulties of dlopening libraries.

Approximate build time:  0.1 SBU
Required disk space:     3.0 MB

Prepare Bzip2 for compilation with:

make -f Makefile-libbz2_so
make clean

The -f flag will cause Bzip2 to be built using a different Makefile file, in this case the Makefile-libbz2_so file, which creates a dynamic libbz2.so library and links the Bzip2 utilities against it.

Compile the package:

make

If you are reinstalling Bzip2, you need to do rm -f /usr/bin/bz* first, otherwise the following make install will fail.

Install the programs:

make install

Now install the shared bzip2 binary into the /bin directory, then make some necessary symbolic links, and clean up:

cp bzip2-shared /bin/bzip2
cp -a libbz2.so* /lib
ln -s ../../lib/libbz2.so.1.0 /usr/lib/libbz2.so
rm /usr/bin/{bunzip2,bzcat,bzip2}
mv /usr/bin/{bzip2recover,bzless,bzmore} /bin
ln -s bzip2 /bin/bunzip2
ln -s bzip2 /bin/bzcat

Installed programs: bunzip2 (link to bzip2), bzcat (link to bzip2), bzcmp, bzdiff, bzegrep, bzfgrep, bzgrep, bzip2, bzip2recover, bzless and bzmore

Installed libraries: libbz2.a, libbz2.so (link to libbz2.so.1.0), libbz2.so.1.0 (link to libbz2.so.1.0.2) and libbz2.so.1.0.2

bunzip2 decompresses bzipped files.

bzcat decompresses to standard output.

bzcmp runs cmp on bzipped files.

bzdiff runs diff on bzipped files.

bzgrep and friends run grep on bzipped files.

bzip2 compresses files using the Burrows-Wheeler block sorting text compression algorithm with Huffman coding. The compression rate is generally considerably better than that achieved by more conventional compressors using LZ77/LZ78, like gzip.

bzip2recover tries to recover data from damaged bzip2 files.

bzless runs less on bzipped files.

bzmore runs more on bzipped files.

libbz2* is the library implementing lossless, block-sorting data compression, using the Burrows-Wheeler algorithm.

Approximate build time:  0.1 SBU
Required disk space:     7.5 MB

Prepare Diffutils for compilation:

./configure --prefix=/usr

Compile the package:

make

Install it:

make install

Installed programs: cmp, diff, diff3 and sdiff

cmp compares two files and reports whether or in which bytes they differ.

diff compares two files or directories and reports which lines in the files differ.

diff3 compares three files line by line.

sdiff merges two files and interactively outputs the results.

Approximate build time:  0.1 SBU
Required disk space:     3.1 MB

Ed normally uses the mktemp function to create temporary files in /tmp, but this function contains a vulnerability (see the section on Temporary Files in http://en.tldp.org/HOWTO/Secure-Programs-HOWTO/avoid-race.html). Apply the following patch to make Ed use mkstemp instead, a secure way to create temporary files:

patch -Np1 -i ../ed-0.2-mkstemp.patch

Now prepare Ed for compilation:

./configure --prefix=/usr --exec-prefix=""

The meaning of the configure option:

Compile the package:

make

To test the results, issue: make check.

Install the package:

make install

Installed programs: ed and red (link to ed)

ed is a line-oriented text editor. It can be used to create, display, modify and otherwise manipulate text files.

red is a restricted ed -- it can only edit files in the current directory and cannot execute shell commands.

Approximate build time:  0.1 SBU
Required disk space:     12 MB

By default some of Kbd's utilities (setlogcons, setvesablank and getunimap) are not installed. First enable the compilation of these utilities:

patch -Np1 -i ../kbd-1.12-more-programs-1.patch

Now prepare Kbd for compilation:

./configure

Compile the package:

make

Now install it:

make install

Few things are more annoying than using Linux while a wrong keymap for your keyboard is loaded. If you have a standard US keyboard, however, you can skip this section, as the US keymap is the default as long as you don't change it.

To change the default keymap, create the /usr/share/kbd/keymaps/defkeymap.map.gz symlink by running the following command:

ln -s path/to/keymap /usr/share/kbd/keymaps/defkeymap.map.gz

Of course, replace path/to/keymap with the path and name of your keyboard's map file. For example, if you have a Dutch keyboard, you would use /usr/share/kbd/keymaps/i386/qwerty/nl.map.gz.

Another way to set your keyboard's layout is to compile the keymap into the kernel. This ensures that your keyboard will always work as expected, even when you boot into maintenance mode (by passing `init=/bin/sh' to the kernel), as then the bootscript that normally sets up your keymap isn't run.

When in Chapter 8 you're ready to compile the kernel, run the following command to patch the current default keymap into the source (you will have to repeat this command whenever you unpack a new kernel):

loadkeys -m /usr/share/kbd/keymaps/defkeymap.map.gz > \
    [unpacked sources dir]/linux-2.4.26/drivers/char/defkeymap.c

Installed programs: chvt, deallocvt, dumpkeys, fgconsole, getkeycodes, getunimap, kbd_mode, kbdrate, loadkeys, loadunimap, mapscrn, openvt, psfaddtable (link to psfxtable), psfgettable (link to psfxtable), psfstriptable (link to psfxtable), psfxtable, resizecons, setfont, setkeycodes, setleds, setlogcons, setmetamode, setvesablank, showconsolefont, showkey, unicode_start and unicode_stop

chvt changes the foreground virtual terminal.

deallocvt deallocates unused virtual terminals.

dumpkeys dumps the keyboard translation tables.

fgconsole prints the number of the active virtual terminal.

getkeycodes prints the kernel scancode-to-keycode mapping table.

getunimap prints the currently used unimap.

kbd_mode reports or sets the keyboard mode.

kbdrate sets the keyboard repeat and delay rates.

loadkeys loads the keyboard translation tables.

loadunimap loads the kernel unicode-to-font mapping table.

mapscrn is an obsolete program that used to load a user-defined output character mapping table into the console driver. This is now done by setfont.

openvt starts a program on a new virtual terminal (VT).

psf* are a set of tools for handling Unicode character tables for console fonts.

resizecons changes the kernel idea of the console size.

setfont lets you change the EGA/VGA fonts on the console.

setkeycodes loads kernel scancode-to-keycode mapping table entries, useful if you have some unusual keys on your keyboard.

setleds sets the keyboard flags and LEDs. Many people find it useful to have "Num Lock" on by default, setleds +num achieves this.

setlogcons sends kernel messages to the console.

setmetamode defines the keyboard meta-key handling.

setvesablank lets you fiddle with the built-in hardware screensaver (no toasters, just a blank screen).

showconsolefont shows the current EGA/VGA console screen font.

showkey reports the scancodes and keycodes and ASCII codes of the keys pressed on the keyboard.

unicode_start puts the keyboard and console in unicode mode.

unicode_stop reverts keyboard and console from unicode mode.

Approximate build time:  0.6 SBU
Required disk space:     48.4 MB

It is recommended to build E2fsprogs outside of the source tree:

mkdir ../e2fsprogs-build
cd ../e2fsprogs-build

Prepare E2fsprogs for compilation:

../e2fsprogs-1.35/configure --prefix=/usr --with-root-prefix="" \
    --enable-elf-shlibs

The meaning of the configure options:

Compile the package:

make

If you to test the results, first make sure an mtab file exists with touch /etc/mtab to prevent some sixty tests from failing, and (if it doesn't already exist) fake the presence of an old pager with ln -s /tools/bin/cat /bin/more to prevent one test from failing, then issue: make check.

Install most of the package:

make install

Also install the shared libraries:

make install-libs

Installed programs: badblocks, blkid, chattr, compile_et, debugfs, dumpe2fs, e2fsck, e2image, e2label, findfs, fsck, fsck.ext2, fsck.ext3, logsave, lsattr, mk_cmds, mke2fs, mkfs.ext2, mkfs.ext3, mklost+found, resize2fs, tune2fs and uuidgen.

Installed libraries: libblkid.[a,so], libcom_err.[a,so], libe2p.[a,so], libext2fs.[a,so], libss.[a,so] and libuuid.[a,so]

badblocks searches a device (usually a disk partition) for bad blocks.

blkid is a command line utility to locate and print block device attributes.

chattr changes the attributes of files on a second extended (ext2) file system, and also ext3 file systems, the journaling version of ext2 file systems.

compile_et is an error table compiler. It converts a table of error-code names and messages into a C source file suitable for use with the com_err library.

debugfs is a file system debugger. It can be used to examine and change the state of an ext2 file system.

dumpe2fs prints the super block and blocks group information for the file system present on a given device.

e2fsck is used to check, and optionally repair, second extended (ext2) file systems, and also ext3 file systems.

e2image is used to save critical ext2 file system data to a file.

e2label will display or change the file system label on the ext2 file system present on a given device.

findfs finds a file system by label or UUID (Universally Unique Identifier).

fsck is used to check, and optionally repair, file systems. By default it checks the file systems listed in /etc/fstab

logsave saves the output of a command in a log file.

lsattr lists the attributes of files on a second extended file system.

mk_cmds converts a table of command names and help messages into a C source file suitable for use with the libss subsystem library.

mke2fs is used to create a second extended file system on the given device.

mklost+found is used to create a lost+found directory on a second extended file system. It pre-allocates disk blocks to this directory to lighten the task of e2fsck.

resize2fs can be used to enlarge or shrink an ext2 file system.

tune2fs is used adjust tunable file system parameters on a second extended file system.

uuidgen creates new UUID. Each new UUID can reasonably be considered unique among all UUIDs created, on the local system and on other systems, in the past and in the future.

libblkid contains routines for device identification and token extraction.

libcom_err is the common error display routine.

libe2p is used by dumpe2fs, chattr, and lsattr.

libext2fs contains routines to enable user-level programs to manipulate an ext2 file system.

libss is used by debugfs.

libuuid contains routines for generating unique identifiers for objects that may be accessible beyond the local system.