User:Invakid404/CLFS

CLFS with musl

This page covers the steps of getting a working CLFS "temporary environment" with musl instead of glibc and latest everything.

Setting up the environment (Chapter 2)

Instead of creating a partition, we'll build everything in a directory in our home. Let's assign it to a variable called `CLFS` and create it:

user $ export CLFS=$HOME/clfs
user $ mkdir -v "${CLFS}"
mkdir: created directory '/home/invakid404/clfs'

We'll also need to create three subdirectories in our CLFS directory:

• cross-tools: this is where the cross compiler will go
• tools: this is where the so-called "temporary system" will go
• sources: this is where we'll download and build all packages

user $ mkdir -v "${CLFS}"/cross-tools
mkdir: created directory '/home/invakid404/clfs/cross-tools'
user $ mkdir -v "${CLFS}"/tools
mkdir: created directory '/home/invakid404/clfs/tools'
user $ mkdir -v "${CLFS}"/sources
mkdir: created directory '/home/invakid404/clfs/sources'

Let's also define some build-related environment variables:

• CLFS_HOST: the target triple of the host machine; modified to contain "cross" to handle the case where we're cross-compiling for the same target
• CLFS_TARGET: the target triple of the target architecture
• CLFS_ARCH: the name of the target architecture; used specifically when installing Linux kernel headers
• CLFS_CFLAGS: extra flags we'll pass to the GCC cross compiler
• MAKEFLAGS: flags we want to pass to GNU make by default

The host variable is straightforward:

user $ export CLFS_HOST=$(echo ${MACHTYPE}

The target, arch, and CFLAGS depend on the target architecture you're going for. Here's a table of all currently tested architectures and their respective build variables:

Build variables per architecture

Architecture	CLFS_TARGET	CLFS_ARCH	CLFS_CFLAGS
x86_64	x86_64-unknown-linux-musl	x86_64	-m64
aarch64	aarch64-unknown-linux-musl	arm64

The rest of this page will assume aarch64, but the steps should be analogous for all listed architectures:

user $ export CLFS_TARGET="aarch64-unknown-linux-musl"
user $ export CLFS_ARCH="arm64"
user $ export CLFS_CFLAGS=""

For the makeflags, we'll tell GNU make to run as many jobs in parallel as we have threads to speed up the compilation:

user $ export MAKEFLAGS="-j$(nproc) -l$(nproc)"

Note that one can put these exports in a file and source them every time one restarts their session to avoid having to setting them manually each and every time. The same applies for all convenience environment variables we'll define later on.

Building the cross compiler (Chapter 3)

To get a cross compiler going, we'll need to do the following steps:

• Install the Linux headers for the target architecture
• Build binutils for the target architecture
• Build a static version of GCC without a standard library
• Build musl with the static version of GCC
• Build GCC again, now with musl as the standard library

Note that the official CLFS guide suggests building things like GMP, MPFR, and MPC separately, but we'll extract those in the GCC source directory and leave it up to the GCC makefile to do the heavy-lifting for us for simplicity. We'll also skip over ISL since it's not required and not too interesting for us at this stage.

Linux headers

First things first, let's fetch the Linux kernel sources. Throughout the rest of this page, we'll be putting the versions of packages in environment variables for convenience like so:

user $ export LINUX_VERSION="5.16.10"

Let's cd into the sources directory and download Linux:

user $ cd "${CLFS}"/sources
user $ wget https://cdn.kernel.org/pub/linux/kernel/v$(echo "${LINUX_VERSION}"

Now, let's install the Linux headers for our target architecture. We'll install those in the tools directory to use in the temporary environment as well:

user $ pushd linux-"${LINUX_VERSION}"
user $ make mrproper
user $ make ARCH=${CLFS_ARCH} INSTALL_HDR_PATH=${CLFS}/tools headers_install
user $ popd

Binutils

Let's fetch and extract the binutils sources:

user $ export BINUTILS_VERSION="2.38"
user $ wget https://ftp.gnu.org/gnu/binutils/binutils-"${BINUTILS_VERSION}".tar.xz
user $ tar xvf binutils-"${BINUTILS_VERSION}".tar.xz
user $ pushd binutils-"${BINUTILS_VERSION}"

Now, let's configure binutils. The options we'll use are explained here. The only deviation we'll make is we'll prepend the prefix and lib path with the CLFS directory (this will be a reoccurring trend in this page since we aren't creating the symlinks in /) and we'll skip over some flags that aren't 100% necessary:

user $ AR=ar AS=as ../binutils-${BINUTILS_VERSION}/configure \
  --prefix=${CLFS}/cross-tools \
  --host=${CLFS_HOST} \
  --target=${CLFS_TARGET} \
  --with-sysroot=${CLFS} \
  --with-lib-path=${CLFS}/tools/lib \
  --disable-nls \
  --disable-static \
  --enable-64-bit-bfd \
  --disable-multilib \
  --disable-werror

We're now ready to build and install it:

user $ make
user $ make install
user $ popd