Todo sobre el kernel en Gentoo

Esta entrada pretende ser un resumen de todo lo más importante sobre el kernel en Gentoo.
Se trata de tener una guía accesible en un sólo lugar cuando se nos haya olvidado algo sobre la abundante documentación sobre el núcleo (y otros núcleos alternativos) que hay en el Handbook oficial de Gentoo.

Empecemos:
¿Cómo se llama el paquete del kernel oficial en Gentoo?

gentoo-sources

nombre completo:  sys-kernel/gentoo-sources

***********************

Ver qué versión del kernel se está corriendo:

uname -rm

***********************

¿Dónde están los ebuilds disponibles de los kernels del árbol de Portage?

/usr/portage/sys-kernel/*.*

y las versiones disponibles del kernel oficial:

/usr/portage/sys-kernel/gentoo-sources/

***********************

¿Cómo saber qué versiones tengo disponibles para instalar con Portage desde consola?

equery m gentoo-sources

Esto nos dará todo un listado de las versiones que hay así como para qué arquitecturas están disponibles.

Podría hacer lo mismo para otros tipos de kernels, como los «vanilla», por ejemplo:

equery m vanilla-sources

***********************

Instalar la última versión estable disponible oficial del kernel:

primero actualizamos el árbol de Portage:

sudo emerge --sync

y luego:

sudo emerge -a gentoo-sources

Esto siempre instalará la última versión estable del kernel oficial, si deseamos que por defecto se instale siempre la última versión de la rama testing (más moderna) hay que añadir a nuestro archivo

/etc/portage/package.accept_keywords

las líneas:

# KERNEL LINUX TESTING
sys-kernel/gentoo-sources ~amd64

***********************

¿Cómo instalar un kernel concreto más antiguo en Portage?

miramos los kernels disponibles:

equery m gentoo-sources

e instalamos el que queramos de la siguiente manera:

sudo emerge -a =sys-kernel/gentoo-sources-3.10.100

en este caso instalamos la versión 100 de la rama del kernel 3.10 (LTS). Obsérvese que para que funcione hay que poner un signo igual (=) antes del nombre y ruta del kernel, pues si no, Portage no nos dejará.

***********************

Todo gentucito sabe que Portage no «instala» realmente el kernel, sino que se limita a descargar sus fuentes para permitirnos instalarlo de facto a nosotros. Digamos que Portage «emerge» un kernel, pero luego hay que configurarlo, compilarlo, instalarlo e integrarlo en el gestor de arranque (normalmente grub2).

Algunas cosas sobre esto:

¿Dónde están las fuentes de los kernels disponibles emergidos por Portage?

en

/usr/src/

están ahí, cada uno en su directorio con su número de versión.

Además hay un enlace simbólico llamado «linux» (/urs/src/linux/) que enlaza normalmente al último kernel compilado e instalado:

podemos ver desde línea de comandos las fuentes de kernel disponibles así:

eselect kernel list

lo cual nos lista los kernels disponibles. Observemos que uno de ellos al final tiene un asterisco (*) lo que indica a cual apunta el enlace simbólico /usr/src/linux/

Este enlace simbólico es importante, pues al instalar un nuevo kernel emergido con Portage, debemos hacerlo apuntar al nuevo kernel que nos interese configurar, compilar e instalar. Se hace así:

sudo eselect kernel set 2

(suponiendo que sea al kernel número 2 el que vamos a instalar). Lo cual cambia la ruta del enlace simbólico /urs/src/linux/ al nuevo (y por lo tanto también el asterisco ante un «eselect kernel list».

***********************

¿Cómo se instala un nuevo kernel?

su
cd /usr/src/linux/
make menuconfig
make
make modules_install
make install

(sudo emerge -a genkernel)
(genkernel –install initramfs)

estos dos pasos entre paréntesis no son necesarios si no queremos/necesitamos «initramfs»

grub-mkconfig -o /boot/grub/grub.cfg
exit
sudo reboot

Lógicamente esta parte es más complicada y por eso se explicó en su propia entrada:

Construcción y compilación manual del kernel en Gentoo (make menuconfig)

***********************

¿Dónde se guarda el fichero de configuración del kernel que hemos compilado?

siempre se encuentra en /usr/src/linux/.config (y en el directorio de cada kernel específico)

y normalmente también en /boot/config-4.4.5-gentoo (en este ejemplo el de mi versión 4.4.5)

Si al configurar el kernel hemos habilitado:

File systems —>
Pseudo filesystems —>
<*> /proc file system support

también podremos encontrar la configuración del kernel en:

/proc/config.gz

En los últimos tiempos, cuando actualizas a un nuevo kernel, Gentoo suele recuperar la configuración del anterior, con lo que no hay que activar cada vez todos los módulos de tarjeta gráfica, wifi, etc. Esto sólo será necesario si hay alguna nueva funcionalidad del kernel o se quiere cambiar algún parámetro de configuración.

***********************

¿Cómo eliminar kernels antiguos?

Se puede hacer con –depclean y con eclean-kernel, pero yo prefiero hacerlo de una manera manual, pues es más seguro.

Imaginemos que queremos eliminar un kernel antiguo que tenemos instalado, por ejemplo el linux-4.3.5-gentoo

Lo primero lo «sumergimos» 🙂 de Portage, así:

sudo emerge -Ca sys-kernel/gentoo-sources-4.3.5

de esta manera ya no está instalado «a efectos de Portage» pero hay que eliminarlo manualmente del sistema:

Primero eliminamos sus fuentes así:

sudo rm -r /usr/src/linux-4.3.5-gentoo

Segundo, eliminamos sus módulos del directorio pertinente, así:

sudo rm -r /lib/modules/4.3.5-gentoo

Tercero, eliminamos todos los archivos de esa versión del kernel en nuestro directorio /boot/ así:

sudo rm /boot/vmlinuz-4.3.5-gentoo
sudo rm /boot/System.map-4.3.5-gentoo
sudo rm /boot/config-4.3.5-gentoo

y finalmente, no nos olvidemos de actualizar grub2 para borrar la entrada del kernel eliminado:

sudo grub-mkconfig -o /boot/grub/grub.cfg

Y ya podemos rebootear tras la limpieza.

***********************

Y un pequeño truco/consejo para terminar.

Para que no se esté actualizando el kernel en cada actualización del sistema, pues a mí me gusta hacer todos los lunes un:

sudo emerge --sync && sudo emerge -uaDN --with-bdeps=y world

con lo que tengo cada semana el sistema actualizado, se puede fijar una versión del kernel  para que no se actualice hasta la siguiente que tú desees. Yo tengo la costumbre de sólo actualizar de una versión que termine en 5 hasta la siguiente que termine en 5. Por ejemplo, ahora tengo la 4.4.5 y no actualizaré hasta la 4.5.5 (así me garantizo cinco subversiones y correcciones de errores en cada nueva versión del kernel. Para esto, lo que hago es enmascarar el kernel en el directorio package.mask, por lo que creo un archivo de texto dentro:

/etc/portage/package.mask/gentoo-sources

y le agrego lo siguiente:

# NO ACTUALIZAR EL KERNEL HASTA:
<sys-kernel/gentoo-sources-4.5.5

como veis lo que he hecho es decirle a Portage que toda versión menor de la 4.5.5 está enmascarada, y por lo tanto no puede actualizarla. Así, me puedo olvidar del kernel hasta que se actualice a esa versión. Cuando esto ocurra, editaré este fichero cambiando sólo 4.5.5 por 4.6.5, o si es el caso por 5.0.5. o la que yo desee. Y ya está.

Chulo, ¿verdad?

***********************

Pues espero que esta sea una guía para tener delante cuando se necesite consultar las cosas básicas sobre el kernel en Gentoo.

Puede interesarte además:

Manual de genkernel en Gentoo (construcción automática del kernel)

y:

Manual-guía (casi) fácil para instalar GENTOO paso a paso

 

Anuncio publicitario

el kernel linux y el initramfs en el directorio /boot/

fundamentos GNU/Linux

---

En este artículo sólo pretendo hacer una descripción básica del contenido del famoso directorio /boot/ que todo sistema GNU/Linux contiene en la raíz. Tradicionalmente este directorio se montaba en su propia partición, de hecho así se sigue haciendo por tradición en distros como Arch o Gentoo, pero hoy en día esto ya no suele ser necesario. La causa era la limitación de que el núcleo Linux estuviese en una partición con un sistema de archivos ext2, por lo que si la raíz estaba en ext3 o ext4, no arrancaría. Esto ya está superado y la decisión de asignarle su propia partición o no a /boot/ queda al gusto del usuario.

¿Qué dos cosas básicas tiene que haber en /boot/?

1. el kernel o núcleo Linux (vmlinuz o zImage)
2. un ramdisk en formato intramfs o initrd.

El kernel linux, es un archivo comprimido que suele llamarse vmlinuz o zImage (por convención, aunque el nombre no importa) y que contiene el núcleo Linux propiamente dicho en formato binario (ejecutable) en formatos tales como ELF, COFF y a.out. El tamaño del kernel es variable, pues dependerá entre otras cosas del tipo y nivel de compresión y de la cantidad de drivers y parches que sean incorporados directamente en él (no como módulos externos). El kernel ahora suele estar comprimido mediante bzip2 (bz) y antes solía hacerse mediante gzip (z). Cuando se compila el kernel desde el directorio de las fuentes, con el famoso comando make, el archivo se guarda normalmente en:

/usr/src/directorio-de-fuentes/arch/x86/boot/bzImage

ese bzImage es el nuevo kernel compilado, realmente tan sólo hay que copiarlo en nuestro directorio /boot/ y ya tendremos listo el nuevo núcleo para arrancar. Se suele renombrar para que sepamos de qué versión de trata, así por ejemplo haríamos:

sudo cp /arch/x86/boot/bzImage /boot/vmlinuz-3.17.2

El archivo initramfs «initial ram file system», sistema de archivos ram inicial (ramdisk), es un archivo cpio comprimido normalmente en formato gzip que contiene un pequeño sistema de archivos que se cargará en la memoria RAM en el proceso de arranque del núcleo. El kernel lo montará, como una pequeña raíz, pues la necesita para completar algunas tareas relacionadas con módulos y controladores de dispositivos antes de poder arrancar el verdadero sistema de archivos raíz instalado en el disco duro e invocar al proceso init. Más antiguo que initramfs es initrd «disco RAM inicial», aún ampliamente usado, y cuya función es la misma a pesar de ciertas diferencias técnicas y de funcionamiento.

Recordemos que al compilar el kernel (make menuconfig) decidimos qué controladores se integrarán dentro de kernel mismo (en el bzImage) y cuales irán fuera en forma de módulos, que puedan ser invocados desde éste si son necesarios. Pues estos módulos se integrarán precisamente en la imagen initramfs (o initrd) para que estén a disposición del kernel en el proceso de arranque del núcleo.

La creación tradicional del ramdisk initrd se hacía mediante el comando mkinitrd pero hoy en día generalmente ha sido sustituido por la creación de un initramfs mediante el comando mkinitramfs.

En Archlinux, por ejemplo, el encargado de crear el initramfs es mkinitcpio que es un script de bash utilizado para generar un ramdisk inicial initramfs de última generación.

Más información en la wiki de Arch:

https://wiki.archlinux.org/index.php/Mkinitcpio_%28Espa%C3%B1ol%29

En Gentoo, se utiliza un conjunto de scripts equivalentes, genkernel, que vale tanto para automatizar la configuración, compilación e instalación del kernel mismo, como para crear el ramdisk inicial.

genkernel --install ramdisk (crea un ramdisk en formato initrd)

genkernel --install initramfs (crean un ramdisk en formato initramfs)

Este último es el recomendado en Gentoo.

Más información en la wiki de Gentoo:

https://wiki.gentoo.org/wiki/Genkernel/es

Nota.- no olvidemos nunca que tras compilar e instalar kernels (y ramdisks) nuevos, siempre habrá que actualizar GRUB para poder arrancar con ellos (sudo grub-mkconfig -o /boot/grub/grub.cfg)

construcción y compilación manual del kernel en Gentoo (make menuconfig)

La compilación manual es la recomendada en Gentoo, tanto por su versatilidad como por su sorprendente simplicidad, sí, has leído bien, simplicidad. Que todo es difícil en Gentoo es un falso mito. Gentoo no es difícil, sino complejo, pero esa complejidad tan sólo es pureza y riqueza de posibilidades, no dificultad.

Vamos allá:

descargamos un paquete de fuentes de kernel, podemos usar alguno de los que están en Portage o cualquier otro. Hay que tener en cuenta que conviene usar fuentes que incluyan los parches para Gentoo. Como ejemplo podemos buscar kernels en Portage así:

emerge -s sources

lo que encontrará fuentes del núcleo linux; en este ejemplo vamos a instalar las fuentes oficiales de Gentoo:

sys-kernel/gentoo-sources

las emergemos de Portage:

sudo emerge -a gentoo-sources

Hay que tener en cuenta que por defecto si emergemos «gentoo-sources» Portage descargará la última versión del kernel que haya. Si queremos instalar un kernel determinado más antiguo de los que hay aquí /usr/portage/sys-kernel/gentoo-sources tenemos que emergerlo llamándolo específicamente a él anteponiendo un signo igual (=), así:

sudo emerge -a =sys-kernel/gentoo-sources-3.14.39

de esta manera emergemos específicamente la versión 39 del kernel 3.14 (LTS).

Portage no instala el nuevo kernel, sino que se limita a crear su directorio de fuentes en:

/usr/src/linux-3.16.5-gentoo/

podemos comprobar que están ahí.

Lo primero es hacer que el enlace simbólico /usr/src/linux apunte a las nuevas fuentes, esto es necesario pues como luego usaremos el comando genkernel para instalar el «initramfs» se necesita que apunte a las fuentes correctas.

eselect kernel list

sudo eselect kernel set 1 (o el número que sea)

entramos en el directorio de la fuentes, en nuestro caso:

/usr/src/linux-3.16.5-gentoo/

abrimos una terminal y nos hacemos root

su

make menuconfig

ahora se nos muestra el menú para determinar las opciones que queremos que compile nuestro kernel, las opciones que trae por defecto suelen funcionar, pero como es lógico conviene comprobar que compile el kernel para nuestra tarjeta de red ethernet, para la tarjeta wifi, para la tarjeta gráfica y para la tarjeta de sonido y ALSA.

Podemos encontrar información sobre nuestros dispositivos de hardware con:

sudo lspci -k (encontraremos nuestros dispositivos de red, Ethernet y Wireless)

sudo lspci | grep -i audio (nuestra tarjeta de sonido)

sudo lspci | grep -i VGA (la tarjeta gráfica)

las opciones principales están en «Device Drivers», podemos seleccionarlas con «Y» (se marca con un asterisco) lo cual supone que se compilará dentro del kernel, o si la seleccionamos con «M» (se marca con una letra M) se instalará como módulo. Sobre la famosa cuestión de si es mejor instalar los controladores dentro del kernel o como módulos hay mucha polémica. Cada opción tiene sus ventajas. Yo suelo integrar dentro del núcleo los principales, tarjeta gráfica, tarjeta ethernet, tarjeta wifi y sonido. Eso no hace mucho más grande el kernel y, así evito problemas de que sean cargados o no al inicio, evitando que tengan que ser reconocidos por udev, etc.  Pero en esto, para gustos hay colores.

**********************************************

MAKE MENUCONFIG

Tarjeta Ethernet:

> Device Drivers > Network device support > Ethernet driver support >

Tarjeta Wifi:

> Device Drivers > Network device support > Wireless LAN >

Tarjeta Gráfica:

> Device Drivers > Graphics support >

Tarjeta de Sonido:

> Device Drivers > Sound card support > Advanced Linux Sound Architecture>

Web-Cam:

> Device Drivers —>
<M> Multimedia support —>
[*] Cameras/video grabbers support
[*] Media USB Adapters —>
<M> USB Video Class (UVC)
[*] UVC input events device support (NEW)

Pantalla Táctil (touchscreen):

> Device Drivers > HID support > Special HID drivers —>
<*> HID Multitouch panels

**********************************************
Nótese que en el menuconfig se accede a los distintos apartados selecionándolo y haciendo enter, y se retrocede un paso con cada «exit». Al hacer «exit» desde la página principal se sale de menuconfig. Ya hemos dicho que para entrar sólo hace falta «make menuconfig» en la carpeta de las fuentes del kernel.
Una vez que hemos seleccionado nuestras opciones se guardan (Save) en el archivo .config ese archivo será el que compile después el comando «make». Yo personalmente suelo guardar primero una copia con otro nombre, por ejemplo .config-01 para tener un control de las versiones compiladas, y después lo vuelvo a guardar como .config, pues ese será el que siempre se compile, y así no sobreescribo las configuraciones previas si hago sucesivas compilaciones.

Salimos de menuconfig con «exit» (hacemos exit las veces necesarias).

Volvemos a estar en la terminal y ya sólo nos resta empezar la compilación propiamente dicha, con el comando estándar «make»:

make

ahora toca esperar, pues dependiendo del microprocesador, así como de la cantidad de opciones a compilar, puede tardar entre unos 20-30 minutos en ordenadores modernos y más de una hora en equipos antiguos.

Nos tomamos un café.

Cuando termine de compilar hacemos:

make modules_install

para instalar los controladores que hemos activado como módulos, que se copiarán en el directorio /lib/modules

después:

make install

lo cual instalará el nuevo kernel en /boot/

Instalamos genkernel si no está instalado:

sudo emerge -a genkernel

y luego instalamos en /boot/ el «initramfs» mediante genkernel.

genkernel --install initramfs

Ya está, sólo nos queda actualizar GRUB2 para poder arrancar con el nuevo kernel:

grub-mkconfig -o /boot/grub/grub.cfg

exit

reboot

Al arrancar el equipo elegimos en el menú de GRUB el nuevo kernel y lo probamos.
Si todo va bien, ya tenemos nuestro nuevo kernel personalizado y compilado por nosotros, si alguna cosa no funciona, puede que no hayamos compilado sus drivers en el kernel, por lo que habría que activarlos en nuestro archivo .config (make menuconfig) y recompilar.

Depurar, compilar y recompilar en Gentoo, constituye unos de sus placeres viciosos y gozosos.