Diff — LFS: Preparing the Build

| chapter = Linux Handbook, chapter 2 — the host, the partition, the sources, the staging ground

| needs = A running glibc-based Linux host · ~30 GB free · ~90 source tarballs · a weekend

**Linux From Scratch** begins before a single package compiles — with a host system, a dedicated partition, ninety source tarballs verified by checksum, and a build user wearing a sterilized environment. This chapter is the setup the LFS book assumes and newcomers most often fumble — plus the traps nobody warns you about: the musl-libc host that can't work, the bash-hash cache that poisons toolchains, the `/tools` symlink that is the build's escape hatch from its own host. Get this right and the build is stamina; get it wrong and nothing after it works.

You cannot compile an operating system without an operating system. The Linux you're building needs a **host** — an already-running Linux with a working compiler, core utilities, and disk space — to compile against, and against which the new system's early pieces link. The host isn't cheating; it's how all software births. Cross-compilation's whole art is the careful severance of host influence — chapter 13 (the cross-toolchain) is where that severance is engineered. This chapter supplies the host.

We use **Slackware or Slint** as the host throughout this handbook — its installer teaches partitioning by asking you to do it, its pkgtools leave the machinery visible, and it arrives with a complete development environment (gcc, make, binutils) already aboard. Any modern Linux works; the checks below tell you if yours qualifies.

### The trap nobody warns about: your host's libc

**The host must run glibc.** LFS builds against GNU libc's headers and toolchain assumptions — an Alpine/musl or other non-glibc host will fail obscurely and early, in ways that look like compiler bugs but are actually libc mismatches. Check first:

```sh

ldd --version | head -1       # "ldd (GNU libc) 2.xx" = good; musl = wrong host

```

Docker images based on `alpine`, musl-based distros, and BusyBox-only environments are disqualified as hosts — fine as *targets* of curiosity, wrong as LFS mothers. WSL works for practicing tools but is a trap for the real build — no real partitions, no loop devices by default; the workaround (a loop-mounted disk *image* inside WSL) is documented below.

gawk --version | head -1              # >= 4.0.1 — gawk specifically, NOT mawk

texinfo: makeinfo --version | head -1 # the one everyone forgets

Every check must pass — the build's earliest packages lean on all of them. Slackware ships a clean pass out of the box; on Debian-family hosts `apt install build-essential gawk bison texinfo` closes the usual gaps. Two subtleties: **gawk** is required, not mawk (Debian defaults to mawk — install gawk explicitly), and **texinfo's `makeinfo`** is the classic missing package — several builds fail silently without it, weeks of confusion for a one-package fix.

The new system gets its own home — a dedicated partition it will fill. Before carving, one architectural decision: **BIOS/MBR or UEFI/GPT**. UEFI hosts want GPT (`gdisk`) and eventually an EFI System Partition; BIOS-era hosts take MBR (`fdisk`) and a simpler boot. For a VM you choose when creating the machine — this handbook covers both, with the GPT path primary.

# carve it — gdisk on GPT, fdisk on MBR

gdisk /dev/sda          # new partition ~30G, type 8300 (Linux filesystem)

# UEFI builders add a small ESP: ~300M, type EF00, FAT32

# format the LFS partition

# and the ESP if UEFI: mkfs.vfat /dev/sda1

**Why ext4 and not something exotic**: the build writes hundreds of thousands of small files — ext4's journaling and tooling (`e2fsprogs`, which you build *inside* LFS) are the boring, correct choice. Btrfs/XFS work but add variables nobody needs on a first build.

**A swap partition helps** if your host is lean — an existing swap can be shared: `swapon /dev/sda2`. On a VM, a second virtual disk is cleanest — zero risk to the host's own disk.

### The no-partition path: a loop-mounted image file

No spare partition? Build inside a **disk image file** — the WSL workaround and the safest experiment:

```sh

dd if=/dev/zero of=lfs.img bs=1G count=32 status=progress   # 32 GB sparse-able image

mkfs.ext4 lfs.img

mkdir -pv /mnt/lfs

mount -o loop lfs.img /mnt/lfs

```

The whole LFS system lives in one file — backup it with `cp`, snapshot with `cp --reflink` on CoW filesystems, delete when done. Slightly slower than a real partition; infinitely safer.

# verify every tarball against its checksum BEFORE building

**Check every checksum before building.** A corrupt tarball discovered three chapters in is a weekend lost; `md5sum -c` catches it now. Where upstream ships GPG signatures, `gpg --verify` them too — the sources become the system's DNA. `--continue` resumes partial downloads — the ~90-package fetch survives dropped connections. For bulk downloads `aria2c -i wget-list` parallelizes across mirrors; `wget` is the book's way and everywhere.

### The offline angle nobody plans for

Download *all* tarballs before starting, and keep `$LFS/sources` — mid-build network failures are common, and an LFS build with a dead network stalls forever waiting on a tarball. `rsync -a $LFS/sources/ backups/lfs-sources/` once at the start is a two-minute insurance policy.

That symlink is subtle and load-bearing — worth understanding before you make it. The cross-toolchain's early binaries are compiled with paths baked in as `/tools/...`. On the host, `/tools` resolves to `$LFS/tools` through this symlink. Later, inside the chroot — where `$LFS` *is* the root — `/tools` resolves to the *same* directory, same absolute path, no rewriting. It's how the build escapes its host's filesystem while still being built by it — a one-line filesystem judo move that makes the entire chroot transition seamless.

Build as a dedicated user, never root — one mis-typed `make install` as root overwrites your *host's* `/usr` and the host dies mid-build. This has happened to everyone who skipped the warning.

Two details nobody thinks of: `-s /bin/bash` *must* be explicit — on Debian-family hosts new users default to dash, and dash is not bash (the builds require bash); `-k /dev/null` gives lfs an empty skeleton directory so no host dotfiles leak into its environment. And the UID you create now will own files inside the finished system until the book's cleanup stages normalize ownership — a small oddity you'll see in `ls -l` output later.

### The sterile environment

Login as `su - lfs` (the `-` matters — a full login shell) and write the two files that make every build correct:

`env -i` gives lfs a *sterile* environment — every login respawns bash with only HOME, TERM, and PS1: no inherited host variables, no leaked `LD_LIBRARY_PATH`, no distro-local `CFLAGS` quietly poisoning cross-compilation. `TERM` is kept so your terminal still renders correctly.

Each line earns its place, and three of them defend against specific ghosts:

- **`set +h`** — bash caches binary locations in a hash table (`hash` shows it). Mid-build, your fresh `$LFS/tools/bin/gcc` replaces the host's gcc — but a hashed bash would keep running the *old* one. `set +h` forces PATH re-resolution every call. This single line prevents a class of "my new toolchain isn't being used" bugs that look like curses.

- **`LC_ALL=POSIX`** — builds that sort, grep, and awk differently under different locales produce *different systems*. POSIX locale makes every build byte-reproducible — the difference between a toolchain that works and one whose configure probes disagree with themselves.

- **`LFS_TGT`** — the GNU target triplet (`x86_64-lfs-linux-gnu`) naming your new system's architecture-vendor-OS — every `--target=$LFS_TGT` in the cross-toolchain builds *for* it; it's how `gcc` learns it is building a foreign system's compiler.

- **`MAKEFLAGS='-j$(nproc)'`** — parallel builds across every core. Hours become minutes — with one honest caveat: a handful of old packages have racy Makefiles; if a build fails weirdly with `-j`, retry serial before debugging anything else.

id                          # you are lfs — NOT root

| Configure can't find libc | Host is musl-based — wrong host entirely |

| lfs's shell behaves oddly | Defaulted to dash — `-s /bin/bash` required |

| A package fails only with `-j` | Racy Makefile — retry `make` serial |

| `makeinfo` missing mid-build | texinfo — the forgotten requirement |

1. Run the full version-check roster on your host; note every version that would disqualify it — and check `ldd --version` for the glibc trap.

3. Build the loop-image variant (`lfs.img`) alongside the partition — understand both paths.

4. Download five real upstream tarballs into `$LFS/sources`; `md5sum -c` them; then corrupt one deliberately and watch the check catch it.

5. As `lfs`, deliberately break `$PATH` — then explain why `set +h` exists.

6. Time a trivial `./configure && make` and compute your SBU intuition.

| Host | Verified a glibc-based Linux with dev tools |