Linux From Scrach (Parte 1 - Preparación del sistema)

Linux From Scratch o LFS, es un tipo de instalación del sistema operativo GNU/Linux y el nombre de un libro escrito por Gerard Beekmans junto a otros.

El libro es una colección de documentos que indican los pasos para desarrollar un sistema GNU/Linux desde cero, a partir del código fuente.

Definición obtenida de la Wikipedia. 

Todos los pasos se han seguido con una máquina virtual (en mi caso Oracle VM VirtualBox, no hay ningún problema que yo sepa por usar cualquier otra).
Y como distribución GNU/Linux como base para compilar todos los paquetes, he usado Debian.

NOTA: No intento plagiar el manual que por cierto, está en inglés. Sino que es una interpretación muy libre y adaptada a mi forma de entenderlo. 
Espero no cometer ningún error garrafal, y deseo que os guste y sirva de algo.


Actualizamos la lista de paquetes:

sudo apt update

Ahora actualizamos el sistema:

sudo apt upgrade

Instalamos los paquetes necesarios en el sistema para poder comenzar a compilar los paquetes necesarios:

sudo apt install bash binutils bison bzip2 coreutils diffutils findutils gawk gcc grep gzip m4 make patch perl sed tar texinfo libc6-dev

Ahora tenemos que asegurarnos de tener un enlace correcto a bash:

rm /bin/sh
ln -s /bin/bash /bin/sh

Creamos el siguiente archivo y lo ejecutamos para comprobar que tenemos los archivos necesarios en el sistema para poder empezar a descargar y compilar:

cat > version-check.sh << "EOF"
#!/bin/bash
# Simple script to list version numbers of critical development tools
export LC_ALL=C
bash --version | head -n1 | cut -d" " -f2-4
MYSH=$(readlink -f /bin/sh)
echo "/bin/sh -> $MYSH"
echo $MYSH | grep -q bash || echo "ERROR: /bin/sh does not point to bash"
unset MYSH

echo -n "Binutils: "; ld --version | head -n1 | cut -d" " -f3-
bison --version | head -n1

if [ -h /usr/bin/yacc ]; then
echo "/usr/bin/yacc -> `readlink -f /usr/bin/yacc`";
elif [ -x /usr/bin/yacc ]; then
echo yacc is `/usr/bin/yacc --version | head -n1`
else
echo "yacc not found"
fi

bzip2 --version 2>&1 < /dev/null | head -n1 | cut -d" " -f1,6-
echo -n "Coreutils: "; chown --version | head -n1 | cut -d")" -f2
diff --version | head -n1
find --version | head -n1
gawk --version | head -n1

if [ -h /usr/bin/awk ]; then
echo "/usr/bin/awk -> `readlink -f /usr/bin/awk`";
elif [ -x /usr/bin/awk ]; then
echo awk is `/usr/bin/awk --version | head -n1`
else
echo "awk not found"
fi

gcc --version | head -n1
g++ --version | head -n1
ldd --version | head -n1 | cut -d" " -f2- # glibc version
grep --version | head -n1
gzip --version | head -n1
cat /proc/version
m4 --version | head -n1
make --version | head -n1
patch --version | head -n1
echo Perl `perl -V:version`
sed --version | head -n1
tar --version | head -n1
makeinfo --version | head -n1
xz --version | head -n1

echo 'int main(){}' > dummy.c && g++ -o dummy dummy.c
if [ -x dummy ]
then echo "g++ compilation OK";
else echo "g++ compilation failed"; fi
rm -f dummy.c dummy
EOF

bash version-check.sh

Debería aparecer algo como esto:

bash, version 4.4.12(1)-release
/bin/sh -> /bin/bash
Binutils: (GNU Binutils for Debian) 2.28
bison (GNU Bison) 3.0.4
/usr/bin/yacc -> /usr/bin/bison.yacc
bzip2, Version 1.0.6, 6-Sept-2010.
Coreutils: 8.26
diff (GNU diffutils) 3.5
find (GNU findutils) 4.7.0-git
GNU Awk 4.1.4, API: 1.1 (GNU MPFR 3.1.5, GNU MP 6.1.2)
/usr/bin/awk -> /usr/bin/gawk
gcc (Debian 6.3.0-18+deb9u1) 6.3.0 20170516
g++ (Debian 6.3.0-18+deb9u1) 6.3.0 20170516
(Debian GLIBC 2.24-11+deb9u3) 2.24
grep (GNU grep) 2.27
gzip 1.6
Linux version 4.9.0-6-amd64 (debian-kernel@lists.debian.org) (gcc version 6.3.0 20170516 (Debian 6.3.0-18+deb9u1) ) #1 SMP Debian 4.9.88-1+deb9u1 (2018-05-07)
m4 (GNU M4) 1.4.18
GNU Make 4.1
GNU patch 2.7.5
Perl version='5.24.1';
sed (GNU sed) 4.4
tar (GNU tar) 1.29
texi2any (GNU texinfo) 6.3
xz (XZ Utils) 5.2.2
g++ compilation OK

Ahora creamos una particion para descargar, configurar, compilar e instalar los paquetes necesarios:
sudo mkfs -v -t ext4 /dev/sda2NOTA: En mi caso, es sda2 (que es la segunda partición de mi disco duro, que previamente tenía liberada con 50 Gigas).

Ahora crearemos una variable con el valor del path donde crearemos los directorios y archivos que descargaremos:

export LFS=/mnt/lfs

Comprobamos que se ha realizado correctamente, ya que es muy importante para mas adelante:

echo $LFS

Nos mostrará lo siguiente:

/mnt/lfs

Si nos ha salido el mensaje anterior, lo guardaremos en nuestro archivo .bashprofile por si reiniciamos o cerramos la terminal:

nano .bashprofile

Escribiremos esta linea tal cual:

export LFS=/mnt/lfs

Pulsaremos la convinacion de teclas "Ctrl + O" para guardar, y luego la tecla "INTRO" de nuestro teclado para aceptar.
Y lo mismo pero para el usuario ROOT.

sudo nano /root/.bashprofile

Hasta ahora hemos añadido la variable LFS con el valor /mnt/lfs en el .bashprofile, pero si por algún motivo no usamos un entorno gráfico, el archivo a modificar, sería el .bashrc (yo recomendaría hacerlo).

Creamos el punto de montaje y montamos el sistema de archivos LFS ejecutando la siguientes líneas:

sudo mkdir -pv $LFS

mkdir: se ha creado el directorio '/mnt/lfs' < - - Este es el mensaje que nos responde si lo ha realizado correctamente.

sudo mount -v -t ext4 /dev/sda2 $LFS

mount: /dev/sda2 montado en /mnt/lfs. < - - Este es el mensaje que nos responde si lo ha realizado correctamente.
En teoría no tendríamos que reiniciar el equipo, pero por si acaso, añadiremos unas líneas en /etc/fstab, para que al iniciar, la partición se monte automáticamente.

sudo nano /etc/fstab

Y esta es la línea que añadiriamos.

/dev/sda2 /mnt/lfs ext4 defaults 1 1

(Recuerda que sda2 es la partición que hemos creado anteriormente).

Ahora empezamos a crear los directorios necesarias en nuestra nueva partición:

sudo mkdir -v $LFS/sources

Nos mostrará el siguiente mensaje de respuesta: mkdir: se ha creado el directorio '/mnt/lfs/sources'
Y le damos permisos de escritura, y "sticky" (que permite abrir y modificar a todos los usuarios, pero solo el usuario que haya creado los archivos o directorios puede borrarlos).

sudo chmod -v a+wt $LFS/sources

Ahora vamos a descargar un archivo que contiene la lista de paquetes necesarios para crear nuestro sistema:

sudo wget http://www.linuxfromscratch.org/lfs/view/development/wget-list

Y con esta línea hacemos que el equipo nos descargue todos los paquetes que indica el archivo wget-list que acabamos de descargar:

wget --input-file=wget-list --continue --directory-prefix=$LFS/sources

Tambíen sería ideal realizar la verificación de suma (MD5).
Descargamos el archivo de verificación de suma de los paquetes:

wget http://www.linuxfromscratch.org/lfs/view/development/md5sums

Cambiamos de directorio:

pushd $LFS/sources

Y realizamos la verificación se suma de los paquetes (así comprobaremos que se han descargado correctamente, y que están todos).

md5sum -c md5sums
popd

Estos seis últimas instrucciones pueden ser mas o menos lentas,
dependiendo de la velocidad y calidad de conexión a la Internet,
y del equipo informático que tengamos.
PACIENCIA (son unos 392 Megabytes)

Creamos un directorio que es requerido mas adelante, y le añadimos un enlace simbólico para que cuando hayamos hecho chroot (virtualizado el sistema) no se nos vuelvan locas las compilaciones:

sudo mkdir -v $LFS/tools
sudo ln -sv $LFS/tools /

Vamos a crear nuestro grupo LFS:

groupadd lfs

Y ahora creamos el usuario LFS, con acceso shell por defecto a bash:

useradd -s /bin/bash -g lfs -m -k /dev/null lfs

Le indicamos que le queremos dar una contraseña (nos la pedirá dos veces, para asegurarse):

passwd lfs

Establecemos LFS como el usuario propietario del directorio tools:

sudo chown -v -R lfs $LFS/tools

Hacemos lo respectivo con el directorio sources:

sudo chown -v -R lfs $LFS/sources

Si no ha habido ningún error, ya podremos cambiar de usuario (nos pedirá la contraseña que hemos creado anteriormente):

su - lfs

Para la proxima publicación, realizaremos la configuración del entorno.