Todo sobre el kernel en Gentoo

larryEsta 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

 

gentoo_wallpaper-36186

Anuncios

conectar a internet por wifi desde consola (wpa supplicant + DHCPCD)

fundamentos GNU/Linux fun-gnu


Siempre instalo GNU/Linux desde una conexión ethernet. Es más simple, rápido y lo único que hago es activar DHCP y este le asignará automáticamente una IP a la interfaz de red.

Más adelante, si instalo Gnome, este instala NetworkManager y la conexión wifi se convierte en algo banal.

El otro día, tras una nueva instalación de Gentoo, me negué a instalar Gnome, hice una minimalista instalación con i3, personalizada, simple, hermosa, rápida y perfecta. Y así mismo me negué a instalar NetworkManager.

Así que me dije, es el momento de conectar a internet por wifi desde la consola o un terminal.

Esto se puede hacer de diferentes formas, pero la que describo es muy sencilla y pensada para que tu ordenador se conecte automáticamente siempre a TU wifi, sin hacer nada ni preguntarte nada. No está pensada para cambiar de conexión wifi, eso se hace de otra manera que algún día contaré.

Vamos allá:

Se instala el paquete “wpa supplicant”:

sudo apt install wpasupplicant
sudo pacman -S wpa_supplicant
sudo emerge wpa_supplicant

Para Debian, Arch y Gentoo, respectivamente.

En un terminal se utiliza wpa_passphrase para generar los datos de conexión adecuados:

wpa_passphrase nombre-de-tu-wifi frase-contraseña

lo que genera algo así adaptado a tus datos:

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

network={
ssid=”nombre-de-tu-wifi
#psk=”frase-contraseña
psk=f5d1c49e15e679bebe385c37648d4141bc5c9297796a8a185d7bc5ac62f954e3
}

*************************************************************
editamos el archivo wpa_supplicant.conf

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Y copiamos el resultado de wpa_passphrase más la autorización de wpa_supplicant para el grupo wheel.

O sea, algo similar a todo esto:

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

# Allow users in the ‘wheel’ group to control wpa_supplicant
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=wheel

# Make this file writable for wpa_gui
update_config=1

network={
ssid=”nombre-de-tu-wifi”
#psk=”frase-contraseña”
psk=f5d1c49e15e679bebe385c37648d4141bc5c9297796a8a185d7bc5ac62f954e3
}

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

Lógicamente, tu usuario debe pertenecer el grupo wheel (el mismo de sudo).

Miras si estás en el grupo wheel:

groups pepito

Si no perteneces a wheel te añades así:

sudo usermod -a -G wheel pepito

Y ya casi está. Para que DHCP le asigne una IP al arranque hace falta que DHCPCD arranque al inicio:

Le decimos a Systemd que inicie DHCPDC en cada arranque del sistema.

sudo systemctl enable dhcpcd

No es necesario añadir wpa_supplicant al inicio, pues DHCPDC buscará automáticamente si hay un fichero /etc/wpa_supplicant/wpa_supplicant.conf válido, y si lo hay conectará la interfaz wifi a esa red con esa contraseña.

Y ya está, rebootea, arranca y comprueba con ifconfig que la interfaz wifi tiene asignada una IP.

Este es el resultado de mi ifconfig:

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

enp3s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 10.0.0.8 netmask 255.255.255.0 broadcast 10.0.0.255
inet6 fdf4:8e92:3d68:8400:2f2e:90d9:4dd8:faea prefixlen 64 scopeid 0x0<global>
inet6 fe80::4641:ce9d:3f9f:4268 prefixlen 64 scopeid 0x20<link>
ether 74:d0:2b:1e:3a:1d txqueuelen 1000 (Ethernet)
RX packets 9590 bytes 7058517 (6.7 MiB)
RX errors 0 dropped 1 overruns 0 frame 0
TX packets 8932 bytes 1072214 (1.0 MiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
device interrupt 19
wlp2s0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 10.0.0.3 netmask 255.255.255.0 broadcast 10.0.0.255
inet6 fdf4:8e92:3d68:8400:51b6:4f49:48df:7e88 prefixlen 64 scopeid 0x0<global>
inet6 fe80::a79b:2de:a75f:c590 prefixlen 64 scopeid 0x20<link>
ether 48:d2:24:75:4b:c7 txqueuelen 1000 (Ethernet)
RX packets 154 bytes 37043 (36.1 KiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 14 bytes 1820 (1.7 KiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

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

DHCPCD le ha asignado la IP 10.0.0.8 a la interfaz de red ethernet (enp3s0) y
la IP 10.0.0.3 a la interfaz de red wifi (wlp2s0).

Por lo que tendré siempre conexión a mi wifi y, por tanto a internet, aunque desenchufe el cable de red  ;-P

He probado esto en Gentoo y en Arch y funciona sin problema, y de la misma forma debería funcionar en cualquier otra distro LINUX.

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

fundamentos GNU/Linux fun-gnu


kernel-linux34En 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)