Administración de módulos del kernel en Linux

Introducción

En esta práctica de laboratorio, aprenderás las técnicas fundamentales para administrar los módulos del kernel en un entorno Linux. Explorarás cómo listar los módulos cargados actualmente para visualizar los componentes activos del sistema e inspeccionarás módulos individuales para comprender sus detalles, como su propósito, dependencias y otros parámetros.

A partir de estas habilidades de inspección, practicarás la descarga y carga dinámica de módulos desde el kernel en ejecución. Finalmente, aprenderás a configurar el sistema para que cargue un módulo del kernel específico de forma automática durante el arranque, garantizando que las funcionalidades esenciales estén disponibles sin intervención manual tras un reinicio.

Listar e inspeccionar módulos del kernel con lsmod y modinfo

En este paso, aprenderás a listar los módulos del kernel cargados actualmente y a inspeccionar sus detalles. El kernel de Linux es modular, lo que significa que partes de su funcionalidad pueden cargarse o descargarse según sea necesario. Estas partes cargables dinámicamente se denominan módulos del kernel y, a menudo, corresponden a controladores de dispositivos (drivers), controladores de sistemas de archivos o llamadas al sistema.

Primero, veamos el estado de todos los módulos del kernel cargados actualmente en el kernel de tu sistema. El comando lsmod proporciona una lista limpia y legible. Dado que la lista puede ser bastante larga, canalizaremos su salida a la utilidad less para facilitar la navegación.

Ejecuta el siguiente comando en tu terminal:

lsmod | less

Verás una lista de módulos. La salida se organiza en tres columnas: Module, Size y Used by.

• Module: El nombre del módulo del kernel.
• Size: El tamaño del módulo en bytes.
• Used by: El número de otros módulos o procesos que utilizan actualmente este módulo, seguido de una lista de los módulos dependientes.

Tu salida se verá similar a esta:

Module                  Size  Used by
nls_iso8859_1          16384  1
nls_cp437              20480  1
vfat                   20480  1
fat                    69632  1 vfat
...

Puedes desplazarte por la lista usando las teclas de flecha. Presiona q para salir del visor less y regresar al símbolo del sistema.

Ahora que sabes cómo listar módulos, obtengamos información detallada sobre uno específico. El comando modinfo muestra varios detalles sobre un módulo del kernel, como su nombre de archivo, licencia, descripción, autor y dependencias.

Inspeccionemos el módulo parport, que está relacionado con el puerto paralelo.

modinfo parport

El comando mostrará información detallada sobre el módulo parport.

filename:       /lib/modules/x.x.x-xx-generic/kernel/drivers/parport/parport.ko
license:        GPL
description:    Parallel port driver
author:         Philip Blundell, Tim Waugh, Grant Grundler
srcversion:     <some_version_string>
depends:
retpoline:      Y
intree:         Y
vermagic:       x.x.x-xx-generic SMP mod_unload
sig_id:         ...
signer:         ...
sig_key:        ...
sig_hashalgo:   ...
signature:      ...

Esta salida te indica la ubicación exacta del archivo del módulo (archivo .ko), su licencia, una breve descripción y más. Observa que el campo depends está vacío, lo que indica que este módulo no tiene dependencias.

Los módulos a menudo dependen de otros módulos. El comando depmod crea una lista de dependencias de módulos analizando los módulos en /lib/modules/$(uname -r). Esto permite que el sistema cargue automáticamente los módulos requeridos. Generemos este archivo de dependencias. Este comando requiere privilegios de superusuario, por lo que usaremos sudo.

sudo depmod

Normalmente, este comando no produce ninguna salida si se completa con éxito. Crea o actualiza un archivo llamado modules.dep en el directorio de módulos del kernel. La parte $(uname -r) de la ruta es una sustitución de comando que inserta la versión actual de tu kernel.

Ahora, veamos el archivo de dependencias que acabas de generar.

less /lib/modules/$(uname -r)/modules.dep

Este archivo contiene una lista de módulos y sus dependencias, que es utilizada por las herramientas que gestionan módulos automáticamente. Puedes presionar q para salir de less.

Descargar un módulo del kernel con rmmod

En este paso, aprenderás a descargar un módulo del kernel que está en ejecución utilizando el comando rmmod. Descargar módulos puede ser útil para solucionar problemas de hardware, liberar memoria del sistema o cuando un módulo ya no es necesario. Es importante tener en cuenta que solo puedes descargar módulos que no estén siendo utilizados actualmente por el sistema u otros módulos.

Continuemos con el módulo joydev, que proporciona soporte para joysticks. Primero, verifiquemos si este módulo está cargado. Podemos usar lsmod combinado con grep para filtrar la salida.

lsmod | grep joydev

Si el módulo está cargado, verás una salida similar a esta. El tamaño exacto puede variar.

joydev                 24576  0

El 0 en la columna Used by indica que el módulo está cargado pero no está siendo utilizado actualmente por ningún proceso u otro módulo. Esto lo convierte en un candidato seguro para su eliminación. Si este número fuera mayor que cero, rmmod probablemente fallaría, evitando que descargues un módulo del que depende el sistema.

Ahora, eliminemos el módulo joydev. Dado que esta acción modifica el kernel en ejecución, requiere privilegios de root, que obtendremos usando sudo.

sudo rmmod joydev

El comando rmmod generalmente no produce ninguna salida si tiene éxito. Para confirmar que el módulo se ha descargado correctamente, podemos ejecutar el mismo comando lsmod | grep joydev nuevamente.

lsmod | grep joydev

Esta vez, el comando no debería producir ninguna salida. Este silencio es la confirmación de que el módulo joydev ya no está cargado en el kernel.

Cargar un módulo del kernel con insmod

En este paso, aprenderás a cargar manualmente un módulo en el kernel en ejecución utilizando el comando insmod. Esta es la contraparte de rmmod. Aunque los sistemas modernos suelen utilizar una herramienta más avanzada llamada modprobe (que gestiona automáticamente las dependencias), comprender insmod es fundamental para aprender cómo funcionan los módulos del kernel.

En el paso anterior, descargaste el módulo joydev. Ahora, lo cargaremos de nuevo. El comando insmod requiere que proporciones la ruta completa al archivo de objeto del módulo, que tiene una extensión .ko (Kernel Object).

El directorio estándar para los módulos del kernel es /lib/modules/$(uname -r)/kernel/, donde $(uname -r) se expande a tu versión actual del kernel. El módulo joydev se encuentra típicamente en el subdirectorio drivers/input/.

Carguemos el módulo joydev usando su ruta completa. Esta operación requiere privilegios de root.

sudo insmod /lib/modules/$(uname -r)/kernel/drivers/input/joydev.ko

Al igual que rmmod, insmod no producirá ninguna salida si tiene éxito.

Para confirmar que el módulo ha sido cargado, puedes usar el comando lsmod | grep joydev nuevamente.

lsmod | grep joydev

Después de ejecutar el comando, deberías ver el módulo joydev listado en la salida, confirmando que se ha vuelto a cargar correctamente en el kernel.

joydev                 24576  0

Configurar un módulo del kernel para que se cargue automáticamente al arrancar

En este paso, aprenderás cómo asegurarte de que un módulo del kernel se cargue automáticamente cada vez que se inicie el sistema. Cargar módulos manualmente con insmod es temporal y no persiste después de un reinicio. Para que el cambio sea permanente, debes configurar el sistema para que cargue el módulo durante el proceso de arranque.

En los sistemas Linux modernos que utilizan systemd, la forma estándar de cargar automáticamente módulos del kernel al arrancar es agregando un archivo de configuración al directorio /etc/modules-load.d/. Se leerá cualquier archivo en este directorio con la extensión .conf, y el sistema intentará cargar cada módulo listado en su interior, uno por línea.

Configuremos el módulo joydev para que se cargue automáticamente. Crearemos un archivo llamado joydev.conf dentro de /etc/modules-load.d/ y le añadiremos la palabra joydev. Podemos hacer esto en un solo comando usando echo y tee con sudo.

echo joydev | sudo tee /etc/modules-load.d/joydev.conf

Este comando funciona de la siguiente manera:

• echo joydev imprime el texto 'joydev'.
• La tubería | envía este texto como entrada al siguiente comando.
• sudo tee /etc/modules-load.d/joydev.conf recibe el texto. El comando tee escribe la entrada que recibe en el archivo especificado (/etc/modules-load.d/joydev.conf) y también la muestra en pantalla. Usamos sudo porque este directorio está protegido y requiere privilegios de root para escribir en él.

Deberías ver la siguiente salida, que es el contenido que se está escribiendo en el archivo:

joydev

Para confirmar que el archivo se creó correctamente, puedes mostrar su contenido usando el comando cat:

cat /etc/modules-load.d/joydev.conf

La salida debería ser el nombre del módulo que acabas de agregar:

joydev

Ahora, cada vez que el sistema arranque, cargará automáticamente el módulo joydev. Has configurado con éxito una carga de módulo persistente.

Resumen

En esta práctica de laboratorio, aprendiste las operaciones fundamentales para administrar los módulos del kernel en un entorno Linux. Practicaste cómo listar todos los módulos cargados actualmente mediante el comando lsmod e inspeccionaste información detallada sobre un módulo específico, como su nombre de archivo y descripción, con el comando modinfo.

También adquiriste experiencia práctica en la alteración dinámica del kernel al descargar un módulo con rmmod y cargar uno con insmod. Finalmente, aprendiste a configurar un módulo para que se cargue automáticamente al arrancar, asegurando que los controladores o funcionalidades necesarios estén disponibles después de un reinicio del sistema. Estas habilidades son esenciales para administrar eficazmente los controladores de dispositivos y las características del kernel.