Linux From Scratch XXXI: Configurando el arranque y, por fin, arrancando

En el artículo anterior, hemos compilado un kernel para Linux From Scratch. El siguiente paso es arrancar con él. Eso es lo que vamos a hacer en este artículo. Lo primero es crear algunos ficheros de configuración que necesitamos y luego instalaremos el gestor de arranque.

ATENCIÓN: Algunos de los comandos que aparecen en este post sirven para modificar el arranque de nuestra máquino y, si no se hacen bien, pueden provocar que la máquina deje de funcionar. No me hago responsable de las consecuencias que puedan tener en vuestro equipo. Cada uno debería saber cómo funciona su sistema y lo que puede y no puede hacer con él. En mi máquina han funcionado todos los comandos que pongo aquí. En la vuestra, tendréis que pensaroslo bien.

Creando el fstab

El primer fichero que vamos a crear es el fstab. Este fichero contiene una lista de todas las particiones que se van a montar durante el arranque junto con los parámetros necesarios para montarlas. También puede contener otras particiones para montar más tarde, sistemas de ficheros de red, etc. Aquí es importante reemplazar /dev/sdc3 por la partición en la estáis instalando LFS y /dev/sdc2 por la que estáis usando como swap.

[~/lfs]$ sudo lfs
root:/# cat > /etc/fstab << "EOF"
> # Begin /etc/fstab
> 
> # file system  mount-point  type     options             dump  fsck
> #                                                              order
> 
> /dev/sdc3      /            ext3     defaults            1     1
> /dev/sdc2      swap         swap     pri=1               0     0
> proc           /proc        proc     nosuid,noexec,nodev 0     0
> sysfs          /sys         sysfs    nosuid,noexec,nodev 0     0
> devpts         /dev/pts     devpts   gid=5,mode=620      0     0
> tmpfs          /run         tmpfs    defaults            0     0
> devtmpfs       /dev         devtmpfs mode=0755,nosuid    0     0
> 
> # End /etc/fstab
> EOF

Configurando los módulos

Para dejar listo el kernel falta una última cosa. Si hemos compilado el kernel con soporte para USB, hay que crear un fichero de configuración para indicar en qué orden se deben cargar los módulos. El módulo ehci_hcd debe cargar siempre antes que ohci_hcd y uhci_hcd para evitar problemas. Esto se hace creando un fichero en /etc/modprobe.d.

root:/# install -v -m755 -d /etc/modprobe.d
root:/# cat > /etc/modprobe.d/usb.conf << "EOF"
> # Begin /etc/modprobe.d/usb.conf
> 
> install ohci_hcd /sbin/modprobe ehci_hcd ; /sbin/modprobe -i ohci_hcd ; true
> install uhci_hcd /sbin/modprobe ehci_hcd ; /sbin/modprobe -i uhci_hcd ; true
> 
> # End /etc/modprobe.d/usb.conf
> EOF

Indicando la versión del sistema

Otra cosa que podemos hacer es crear dos ficheros para indicar la versión de LFS que tenemos instalada. Esto es opcional, pero es útil para recordar cuál es la versión y lo usan algunas herramientas, como os-prober, para identificar el sistema operativo que hay instalado en una partición.

root:/# echo 7.2 > /etc/lfs-release
root:/# cat > /etc/lsb-release << "EOF"
> DISTRIB_ID="Linux From Scratch"
> DISTRIB_RELEASE="7.2"
> DISTRIB_CODENAME="hexborg"
> DISTRIB_DESCRIPTION="Linux From Scratch"
> EOF

En DISTRIB_CODENAME se puede indicar un nombre clave para la versión que nosotros nos inventemos. Vale cualquier cosa. Yo he puesto mi nick. Podéis poner lo que queráis.

El fichero lfs-release es específico de Linux From Scratch, pero lsb-release es un fichero que debería existir para cumplir el estándar LSB.

Preparando la cuenta de root

Cuando vayamos a arrancar con nuestro Linux From Scratch y queramos entrar en sesión, tendremos que tener una cuenta que podamos usar para ello. De momento la cuenta de root nos servirá, aunque es bueno crear una cuenta de usuario en cuanto hayamos arrancado. Lo que vamos a hacer por ahora es ponerle contraseña a la cuenta de root para que se pueda utilizar.

root:/# pwconv
root:/# grpconv
root:/# passwd root

Los dos primeros comandos son para crear los ficheros shadow y gshadow que necesita el sistema shadow para funcionar. Tenía que haberlo hecho cuando instalé shadow, pero se me olvidó. 🙂

Configurando el arranque

Éste es el último paso que necesitamos para arrancar por fin con nuestro LFS. Si estamos instalando LFS en una partición de un disco duro en la que ya hay otro linux instalado, una opción es configurar el arranque de ese linux para que pueda arrancar también LFS. Esto es más seguro, ya que no nos arriesgamos a dejar el sistema sin arranque. Si estamos usando grub, lo normal es que con lanzar un comando como “update-grub” detecte nuestro LFS y lo configure, aunque esto depende de la distro.

En mi caso, como estoy instalando en un USB, voy a instalar el gestor de aranque entero. De todos modos, siempre es buena idea contar con un LiveCD o LiveUSB por si estropeamos algo y tenemos que arrancar desde él para arreglarlo.

El libro indica una forma de crear un LiveCD usando un comando que se puede compilar siguiendo las instrucciones de Beyond Linux From Scratch. Yo creo que no merece la pena. Cualquier LiveCD de cualquier distro os puede servir para esto. Aseguráos de tener uno listo por si acaso.

El libro usa grub para arrancar. Por supuesto, es posible usar otros gestores de arranque. A mi siempre me da problemas grub y acabo usando syslinux. Este caso no ha sido una excepción, así que voy a contar la forma de configurar el arranque con los dos gestores.

Con grub

Ya habíamos compilado e instalado grub anteriormente, así que sólo falta instalarlo en el MBR y crear el fichero de configuración. Tenéis que reemplazar sdc por el nombre del dispositivo en el que estáis instalando y sdc3 por la partición raíz. Además hay que cambiar la linea set root para que apunte también a la partición raíz en la que estáis instalando LFS.

root:/# grub-install /dev/sdc
root:/# cat > /boot/grub/grub.cfg << "EOF"
> # Begin /boot/grub/grub.cfg
> set default=0
> set timeout=5
> 
> insmod ext2
> set root=(hd0,3)
> 
> menuentry "GNU/Linux, Linux 3.5.2-lfs-7.2" {
>         linux   /boot/vmlinuz-3.5.2-lfs-7.2 root=/dev/sdc3 ro
> }
> EOF
root:/# exit

No se debe usar grub-mkconfig ya que no está recomendado en LFS y puede destruir la configuración de grub. Este comando crea el fichero de configuración a partir de una serie de scripts que están en /etc/grub.d y que Linux From Scratch no utiliza, así que hay que editar el grub.cfg a mano en lugar de usar ese comando.

En mi caso, es curioso ver que la partición root que hay que poner en el grub es (hd0,3) mientras que en el kernel es /dev/sdc3. Lo normal es que (hd0,3) sea sda3 y que sdc3 sea (hd2,3). No sé por qué es esto, quizás por el USB. No creo que en un disco duro pase lo mismo.

Si estáis instalando LFS en un disco duro en vez de en un USB, recordad que la nomenclatura que usa grub es hd0 para sda, hd1 para sdb y así sucesivamente. El número que aparece detrás de la coma corresponde al número de la partición dentro de ese disco duro y normalmente coincide con el que linux le da al nombre del dispositivo. En caso de que esto os dé problemas tenéis que tantear. Syslinux no tiene este problema.

Con syslinux

Personalmente me gusta más syslinux porque me parece más sencillo no sólo de configurar, sino en cuanto a su diseño y su funcionamiento. Aunque tiene menos posibilidades que grub, ya tiene todo lo que necesito y da menos problemas, así que es el que acabo usando.

Como no hemos compilado syslinux porque el libro no lo usa, eso es lo primero que tenemos que hacer, así que empezamos descargando el código fuente. Estos comandos tenemos que lanzarlos desde nuestra máquina real, no desde el chroot. La idea es montar la partición de LFS y descargar el código fuente de syslinux en el directorio sources para poder compilarlo después desde el chroot.

[~/lfs]$ sudo mkdir /mnt/lfs
[~/lfs]$ sudo mount /dev/sdc3 /mnt/lfs
[~/lfs]$ cd /mnt/lfs/sources/
[/mnt/lfs/sources]$ wget https://www.kernel.org/pub/linux/utils/boot/syslinux/syslinux-5.01.tar.xz
[/mnt/lfs/sources]$ cd -
[~/lfs]$ sudo umount /mnt/lfs
[~/lfs]$ sudo rmdir /mnt/lfs

Una vez tenemos el código fuente, usamos los scripts como siempre para compilar y generar el paquete. Lo primero es descomprimir el código fuente.

[~/lfs]$ sudo lfs syslinux-5.01
root:/# cd sources/
root:/sources# tar xvf syslinux-5.01.tar.xz
root:/sources# cd syslinux-5.01

Ahora hay que compilarlo. El código fuente viene con documentación que puede ser interesante leer, ya que trae las instrucciones de compilación. Según estas instrucciones, no se recompila el cargador ldlinux.asm, sólo los programas de instalación, por eso se usa make installer.

root:/sources/syslinux-5.01# make clear
root:/sources/syslinux-5.01# make installer
root:/sources/syslinux-5.01# make install

Una vez compilado salimos del chroot para generar el paquete y lo instalamos como siempre.

root:/sources/syslinux-5.01# exit
[~/lfs]$ sudo lfsinst syslinux-5.01.txz

Ahora ya podemos entrar en el chroot sin especificar nombre de paquete para terminar de configurarlo. Syslinux no es un único gestor de arranque, sino un conjunto de gestores de arranque cada uno de ellos adecuado para arrancar desde un tipo de dispositivo distinto. Existen SYSLINUX, EXTLINUX, PXELINUX e ISOLINUX. El que sirve para el sistema de ficheros ext3 es EXTLINUX, así que ese es el que vamos a instalar.

[~/lfs]$ sudo lfs
root:/# mkdir -p /boot/extlinux
root:/# extlinux --install /boot/extlinux
root:/# cat /usr/share/syslinux/mbr.bin > /dev/sdc

El último comando es peligroso. Aseguráos de que no os equivocáis en la ruta del fichero mbr.bin ni en el nombre del dispositivo. Sirve para instalar un MBR compatible con syslinux de manera que sea capaz de cargar la partición en la que está instalado.

Ahora vamos a crear el fichero de configuración. Como véis es más sencillo que el de grub, pero recordad poner el nombre del dispositivo correcto en vez de sdc3.

root:/# cat > /boot/extlinux/extlinux.conf << "EOF"
> PROMPT 1
> TIMEOUT 50
> DEFAULT lfs
> 
> LABEL lfs
>     LINUX ../vmlinuz-3.5.2-lfs-7.2
>     APPEND root=/dev/sdc3 ro
> EOF

Un último paso que puede ser necesario es marcar la partición como arrancable. Syslinux necesita esto para localizar la partición en la que está instalado. Podemos hacerlo con fdisk.

root:/# fdisk /dev/sdc
Command (m for help): a
Partition number (1-4): 3
Command (m for help): w
root:/# exit

Como siempre, tenemos que poner el nombre del dispositivo correcto. El 3 que ponemos cuando nos pregunta el número de la partición es el que va detrás del nombre de dispositivo.

Arrancando el sistema

Una vez hecho esto, ya podemos arrancar con nuestro Linux From Scratch. Si estáis usando syslinux, en el prompt que os aparece basta con pulsar enter o escribir “lfs“. He de reconocer que he tenido que compilar el kernel varias veces y que todavía no he conseguido hacerlo funcionar desde el USB, pero por lo menos desde el disco duro… ¡Funcionaaaa!! 🙂

Todavía no se ha terminado todo, ya que creo que hay que hacer algún ajuste más después de arrancar, aunque el libro no trae nada más. Otra cosa que quiero hacer es añadirle algún gestor de paquetes decente. Además hay mucho software que instalarle por ahí, incluyendo un entorno gráfico. Y también se le pueden hacer mejoras en la seguridad. O sea que todavía van a haber más artículos sobre Linux From Scratch.

EOF

Anuncios

6 pensamientos en “Linux From Scratch XXXI: Configurando el arranque y, por fin, arrancando

  1. Raul

    Igualmente, a nuestro equipo de trabajo nos funciono a todos, hemos logrado arrancar nuestro propio LFS. Hemos optado por instalarlo en una partición de nuestro disco duro y utilizamos el grub2, como mencionaste con sudo update-grub lo reconoció y listo. A nosotros tampoco nos funciono en discos externos ni llaves USB, estamos parece al día con todo hasta con tus inconvenientes. Adelante, te seguimos.

    1. hexborg Autor de la entrada

      Excelente. Da gusto ver que lo que uno escribe es útil para alguien más. Con lo que he estado investigando ya tengo una idea de por qué no ha funcionado en el USB. Con un poco de suerte creo que puedo conseguirlo. El truco parece que está en crear un initrd.

      Ánimo para todo el equipo y gracias por comentar. 🙂

    1. hexborg Autor de la entrada

      Eso es interesante. Por lo que veo, usando el loopback device se puede hacer algo parecido a un initrd pero de otra manera. Muchas gracias por el aporte. Probaré primero con un initrd, pero lo tendré en cuenta.

      Un saludo.

  2. Luweeds (@Luweeds)

    La serie de LFS que estas haciendo es brutal, aún no tengo tiempo para ponerla en práctica, pero espero hacerlo muy pronto(verano). Es uno de los trabajos que más me gustan de los blogs que leo. Muchas gracias por todo el trabajo y también te animo a seguir.

    1. hexborg Autor de la entrada

      Muchas gracias a ti por seguirme y por comentar. Te animo igualmente a que lo hagas. Es mucho más fácil de lo que la mayoría de la gente piensa. Sólo hay que tener unas cuantas ideas claras y seguir las instrucciones. 🙂

      Saludos.

Los comentarios están cerrados.