LFS System Packages

This is the marathon chapter — some fifty packages compiled inside the chroot by the toolchain you built, installing the real system's libraries, utilities, and compilers. Where chapter 4 cross-compiled the scaffolding, chapter 5 builds natively — the temporary toolchain producing the final toolchain and everything around it. The pattern never changes: extract, configure, make, test, install, delete the tree. What changes is the scale — and the discipline the scale demands.

The shape of the marathon

The book's chapter 8 is a long procession. Grouped by role, it runs roughly:

• Compression + archive — zstd, xz, bzip2, gzip, tar
• Foundation libraries — zlib, ncurses (real install), readline, libffi, expat, libxml2, libxcrypt
• Build machinery — m4, bison, flex, autoconf, automake, libtool, pkgconf, check, libtasn1
• The toolchain, natively — binutils, gmp, mpfr, mpc, isl, gcc — the real ones this time
• Core userland — attr/acl, shadow (login/passwd/su), bash, coreutils, diffutils, findutils, gawk, grep, sed, procps-ng, psmisc, util-linux, e2fsprogs, file, inetutils, less, iproute2, kbd, kmod, patch, vim
• Scripting — perl, python, wheel/setuptools, ninja, meson, texinfo, gettext
• System plumbing — elfutils, libelf, libpipeline, man-db, man-pages, groff, sysklogd, sysvinit, eudev (dbus lives in the Systemd edition / BLFS — the SysV book omits it)
• Security — openssl, libcap, markupsafe/jinja2 adjacents, gperf, libseccomp

Each is the same liturgy with its own flags and fix-ups — fifty variations on a theme you've already played fifteen times.

The ritual, refined

cd /sources                 # inside chroot — no $LFS prefix anymore
tar -xf xz-*.tar.xz
cd xz-*/
./configure --prefix=/usr    \
            --disable-static \
            --docdir=/usr/share/doc/xz-<ver>
make
make check                   # run the testsuite where the book says to
make install
cd .. && rm -rf xz-*/

The refinements inside the chroot: --prefix=/usr without DESTDIR — you're really installing now; --disable-static avoids shipping static libraries where shared ones serve; make check runs testsuites the book flags as skippable-only-at-your-peril. A failing testsuite inside the chroot is a real failure — unlike the temp stage, these packages are the finished product.

The three packages that matter most

GCC (native) — the final compiler, all languages, threads, libstdc++ complete. After it, the cc→gcc link is permanent, and the toolchain you just built replaces the one that built it — the build pulls itself up by its own bootstraps.

Binutils (native) — the linker the finished system will use.

Shadow — the login/password suite: useradd, passwd, su, login itself. Its install turns /etc/passwd from the chapter-4 placeholder into a real account database, and includes the crypto bindings (via libxcrypt) that make passwd hash properly.

The toolchain verification — the second proof of life

After binutils+gcc install, the book's toolchain check verifies the real compiler:

echo 'int main(){}' > dummy.c
cc dummy.c -v -Wl,--verbose &> dummy.log
readelf -l a.out | grep ': /lib'
# correct: [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
# (or /lib/ld-linux.so.2 on 32-bit)
grep -E -o '/usr/lib.*/S?crt[1in].*succeeded' dummy.log   # crt files found
grep 'SEARCH.*/usr/lib' dummy.log | sed 's|; |\n|g'        # search paths right
grep found dummy.log                                      # right libstdc++
rm -v dummy.c a.out dummy.log

This is chapter 5's readelf moment — the native toolchain proving it looks inward, not at the host.

The marathon's pacing

Fifty packages take most of a day even on modern hardware. Pace and hygiene:

• Re-extract every tarball fresh — leftover configure caches from earlier passes are a classic poisoner
• Delete the tree after install — disk and confusion both
• make check where the book asks — a test failure now is a bug found cheap; skip it and the bug resurfaces at boot
• Read the "Contents" + "Short Descriptions" per package — you should know what you installed; that's the whole point of LFS
• Log everything — the journal from chapter 2 pays off when package 47 misbehaves

The testsuite grammar — when check matters

make check          # where the book asks — the tests
make -k check       # continue through failures — see them all
make check 2>&1 | tee check.log    # keep the record

The book marks which testsuites are safe to skip and which to run — Glibc's is expensive-but-optional on a temp toolchain, mandatory-ish on the native build; gcc's catches miscompiles early; coreutils' and util-linux's are the ones that bite. A documented-expected failure (locale-dependent tests under LC_ALL=POSIX, known-broken upstream tests) may pass; an unexpected one is a real bug.

The strip/cleanup — the final shrink

Late in the chapter the book cleans up — and the way it strips matters:

rm -rf /tmp/{*,.*}                     # build residue
find /usr/lib /usr/libexec -name \*.la -delete    # dead libtool files
find /usr -depth -name \( -name \*.o -o -name \*.a \) \
    ! -name \*libc_nonshared.a -delete           # dead object archives

You cannot strip in place. The binaries and libraries currently running — the bash you're typing in, the glibc it's linked against — are mmap'd; strip rewriting them in place fails or corrupts. The book's procedure copies each to /tmp, strips the copy, installs it back:

# the book's shape — strip via /tmp, never in place:
save_usrlib="$(cd /usr/lib; ls ld-linux* libc.so.6 libstdc++.so* libm.so.6 ...)"
for LIB in $save_usrlib; do
    objcopy --only-keep-debug --compress-debug-sections=zstd $LIB $LIB.dbg
    strip --strip-unneeded /tmp/$LIB          # strip the COPY
    objcopy --add-gnu-debuglink=$LIB.dbg /tmp/$LIB
    install -vm755 /tmp/$LIB /usr/lib          # install back atomically
done
# same dance for the running binaries: bash find strip get /tmp-copied first

Then the scaffolding comes down:

rm -rf /tools    # the temporary toolchain — its job is done

.la files bake absolute build paths; .a archives are dead weight once shared libs exist; --strip-unneeded drops the debug fat (with the .dbg files preserving debuggability via gnu-debuglink). /tools removal at the end of chapter 8 is the symbolic end of the build's dependency on its own scaffolding — everything after comes from the native toolchain.

The packages in detail — what each earns its place for

The marathon's cast, grouped by role:

• The compressors — zlib (the base lib everything links), bzip2, xz, zstd — every tarball and every lib decompresses through these
• The foundation libs — ncurses (terminfo + curses for every TUI), readline (the line-editing every REPL uses), libffi (foreign-function calls), expat/libxml2 (XML parsing), libxcrypt (the password-hash lib shadow needs)
• The build machinery — m4 → bison/flex (parser generators) → autoconf/automake (configure generators) → libtool → pkgconf — the packages that build packages
• The toolchain, final — binutils (real linker), gcc (all languages) — the system now compiles itself (gdb, the debugger, is BLFS — not part of the base build)
• The userland — attr/acl (extended attributes), libcap (capabilities), shadow (accounts), bash (the shell), coreutils/diffutils/findutils/gawk/grep/sed (the vocabulary), procps-ng (ps/top), psmisc (killall/fuser), util-linux (mount/fdisk/dmesg/lsblk — the plumbing), e2fsprogs (ext4 tools), file, less, iproute2 (ip/ss), kbd (console), kmod (module tools), inetutils, groff (man-page formatting), man-db + man-pages (the manuals), vim
• Scripting + build — perl (everything ancient needs it), python (meson's engine + half the world's glue), wheel/setuptools, ninja + meson (the modern build pair), texinfo, gettext (i18n), markupsafe/jinja2 (meson deps)
• Crypto + plumbing — openssl (TLS + the crypto lib), libtasn1/p11-kit (certificate machinery), elfutils/libelf (ELF tooling), libpipeline (man-db's pipes), libseccomp (syscall filters), eudev (device manager), sysklogd (logging), sysvinit (PID 1 itself)

The ordering is topological — each package's deps built earlier; the book's sequence is the dependency graph linearized.

The testsuite discipline

make check runs where the book flags it — the failing tests are information: which host assumption leaked, which dependency landed wrong. Some failures are documented as expected (locale-dependent tests under LC_ALL=POSIX); the book marks them. The rule: a testsuite failure you understand may be skipped; one you don't is a bug in waiting.

The Iana-Etc / man-pages / man-db trio

Three quiet packages make the system human: iana-etc supplies /etc/services and /etc/protocols (the name↔number maps every network tool leans on); man-pages gives you documentation for the kernel interfaces you built against; man-db makes man work. Skipping them gives a system that functions but can't be questioned.

Where this chapter goes wrong

Exercises

1. Pick any package; write its configure line before reading the book's — compare.
2. Find three packages whose make check is explicitly skippable — and three where it isn't. Why the difference?
3. ldd three freshly-built binaries — prove they link the chroot's glibc, not the host's.
4. Track your build times — which package burned the most SBUs? (Usually gcc.)
5. Explain why /etc/services matters — find a tool that consults it.

Timeline

References

• linuxfromscratch.org — chapter 8: installing basic system software; stripping; cleaning
• Hosted mirror: /dist/books/ — the official LFS book mirrored on this site (v10.0–13.1, SysV + systemd editions; CC BY-NC-SA 2.0 / MIT, hosted verbatim with attribution)
• Each package's own documentation — the book's flags come from upstream

See also

• LFS Preparation · LFS Cross-Toolchain · LFS Temporary System · Linux