1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
<sect1 id="ch01-how">
<title>How things are going to be done</title>
<?dbhtml filename="how.html" dir="chapter01"?>
<para>You are going to build your LFS system by using a previously installed
Linux distribution (such as Debian, Mandrake, Red Hat, or SuSE). This existing
Linux system (the host) will be used as a starting point, because you will need
programs like a compiler, linker and shell to build the new system. Normally
all the required tools are available if you selected <quote>development</quote>
as one of the options when you installed your distribution.</para>
<para>In Chapter 3 you will first create a new Linux native partition and
filesystem, the place where your new LFS system will be compiled and installed.
Then in Chapter 4 you download all the packages and patches required to build
an LFS system, and store them on the new filesystem.</para>
<para>Chapter 5 will then discuss the installation of a number of packages that
will form the basic development suite (or tool-set) which is used to build the
actual system in Chapter 6. Some of these packages are needed to resolve
circular dependencies. For example, to compile a compiler you need a
compiler.</para>
<para>The first thing to be done in Chapter 5 is build a first pass of the
toolchain, which is made up of Binutils and GCC. The programs from these
packages will be linked statically in order for them to be used independently
of the host system. The second thing to do is build Glibc, the C library. Glibc
will be compiled by the toolchain programs we just built in the first
pass.</para>
<para>The third thing to do is build a second pass of the toolchain. This time
the toolchain will be dynamically linked against the newly built Glibc. The
remaining Chapter 5 packages are all built using this second pass toolchain and
dynamically linked against the new host-independent Glibc. When this is done,
the LFS installation process will no longer depend on the host distribution,
with the exception of the running kernel. This is known as <quote>self
contained</quote> and <quote>self hosted</quote>. There is a discussion of the
differences between statically and dynamically linked programs at the beginning
of Chapter 5.</para>
<para>You may be asking yourself <quote>that seems like a lot of work, just to
get away from my host distribution</quote>. Let us take a few minutes to
discuss this question. The work involved in building the packages in Chapter 5
is to ensure that as little information as possible from your host makes it into
your brand new LFS system. When you build the first two packages in Chapter 5,
Binutils and GCC, they will be compiled statically. This means that the
version of the C library on your host distribution will be embedded inside all
the binary programs you just compiled. This has the potential to cause
problems for you down the road. The host's Glibc is usually an unknown
quantity and might even contain bugs or anything else we don't know about
until it is too late. A well known issue is that statically linked binaries
compiled on a Glibc-2.2.x based system that contain calls to the
<emphasis>getpwuid()</emphasis> function crash when run on a Glibc-2.3.x based
system. Seeing as we are about to build a Glibc-2.3.x based system, we need to
shield ourselves from problems of this nature. The procedure employed in
Chapter 5 achieves this goal. With all these things in mind, you can see that
the extra effort to compile Binutils and GCC twice is well worth it.</para>
<para>In Chapter 6 your real LFS system will be built. The chroot (change root)
program is used to enter a virtual environment and start a new shell whose root
directory will be set to the LFS partition. This is very similar to rebooting
and instructing the kernel to mount the LFS partition as the root partition.
The reason that you don't actually reboot, but instead chroot, is that creating
a bootable system requires additional work which isn't necessary just yet.
Another advantage is that chrooting allows you to continue using the host while
LFS is being built. While waiting for package compilation to complete, you can
simply switch to a different VC (Virtual Console) or X desktop and continue
using the computer as you normally would.</para>
<para>When all the software from Chapter 6 is installed, the temporary tools
built in Chapter 5 are removed. In Chapters 7, 8 and 9 the installation will
then be finalized. The bootscripts are set up in Chapter 7, the kernel and
bootloader are set up in Chapter 8, and Chapter 9 has some pointers to help
you after you finish the book. Then, finally, you're ready to reboot your
computer into your new LFS system.</para>
<para>This is the process in a nutshell. Detailed information on the steps you
will take are discussed in the chapters and package descriptions as you
progress through them. If something isn't completely clear now, don't worry,
everything will fall into place soon.</para>
<para>Please read Chapter 2 carefully as it explains a few important things you
should be aware of before you begin to work through Chapters 5 and
beyond.</para>
</sect1>
|
