Cómo comprobar si un módulo del kernel está cargado en Linux

Introducción

En este laboratorio, aprenderás cómo verificar el estado de los módulos del kernel en Linux. Explorarás tres métodos esenciales: listar los módulos actualmente cargados utilizando lsmod, comprobar si un módulo se puede cargar y sus dependencias sin cargarlo realmente utilizando modprobe --dry-run y ver información detallada sobre un módulo específico con modinfo. Estas técnicas son cruciales para entender qué componentes del kernel están activos y gestionar las dependencias de los módulos en tu sistema.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL linux(("Linux")) -.-> linux/SystemInformationandMonitoringGroup(["System Information and Monitoring"]) linux(("Linux")) -.-> linux/PackagesandSoftwaresGroup(["Packages and Softwares"]) linux(("Linux")) -.-> linux/BasicSystemCommandsGroup(["Basic System Commands"]) linux(("Linux")) -.-> linux/BasicFileOperationsGroup(["Basic File Operations"]) linux/BasicSystemCommandsGroup -.-> linux/echo("Text Display") linux/BasicFileOperationsGroup -.-> linux/ls("Content Listing") linux/SystemInformationandMonitoringGroup -.-> linux/ps("Process Displaying") linux/SystemInformationandMonitoringGroup -.-> linux/service("Service Managing") linux/PackagesandSoftwaresGroup -.-> linux/software("Linux Software") subgraph Lab Skills linux/echo -.-> lab-558721{{"Cómo comprobar si un módulo del kernel está cargado en Linux"}} linux/ls -.-> lab-558721{{"Cómo comprobar si un módulo del kernel está cargado en Linux"}} linux/ps -.-> lab-558721{{"Cómo comprobar si un módulo del kernel está cargado en Linux"}} linux/service -.-> lab-558721{{"Cómo comprobar si un módulo del kernel está cargado en Linux"}} linux/software -.-> lab-558721{{"Cómo comprobar si un módulo del kernel está cargado en Linux"}} end

Listar módulos cargados con lsmod

En este paso, aprenderás cómo listar los módulos del kernel actualmente cargados utilizando el comando lsmod.

El kernel de Linux es el núcleo del sistema operativo. Gestiona los recursos del sistema y proporciona un puente entre el hardware y el software. Los módulos del kernel son fragmentos de código que se pueden cargar y descargar en el kernel a demanda. Extienden la funcionalidad del kernel sin necesidad de reiniciar el sistema. Esto es especialmente útil para agregar soporte para nuevos dispositivos de hardware o sistemas de archivos.

Para ver qué módulos están actualmente cargados en el kernel, abre tu terminal y escribe el siguiente comando:

lsmod

Presiona Enter.

Verás una lista de módulos, su tamaño y cuántos otros módulos los están utilizando. La salida se verá algo así (la lista exacta variará según el sistema y los controladores cargados):

Module                  Size  Used by
fuse                  143360  3
snd_seq_midi           20480  0
snd_seq_midi_event     16384  1 snd_seq_midi
snd_rawmidi            40960  1 snd_seq_midi
snd_seq                77824  3 snd_seq_midi,snd_seq_midi_event,snd_rawmidi
snd_seq_device         16384  3 snd_seq,snd_seq_midi,snd_rawmidi
... (many more lines)

Desglosemos las columnas:

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 que están utilizando actualmente este módulo. Si este número es 0, el módulo no está siendo utilizado actualmente por ningún otro módulo.

Este comando es esencial para entender qué controladores y componentes del kernel están activos en tu sistema.

Ahora, intenta ejecutar el comando lsmod en tu terminal.

Haz clic en Continuar para pasar al siguiente paso.

Verificar el estado de un módulo con modprobe --dry-run

En este paso, aprenderás cómo utilizar el comando modprobe con la opción --dry-run para verificar si un módulo se puede cargar y qué otros módulos dependen de él, sin cargarlo realmente.

El comando modprobe se utiliza para agregar o eliminar módulos del kernel de Linux. Es más sofisticado que los comandos más antiguos insmod y rmmod porque entiende las dependencias de los módulos. Cuando intentas cargar un módulo con modprobe, cargará automáticamente cualquier otro módulo que el módulo solicitado requiera.

La opción --dry-run es muy útil para realizar pruebas. Le dice a modprobe que realice el proceso de resolver dependencias y verificar si el módulo se puede cargar, pero no cargará realmente el módulo en el kernel. Esto te permite ver si hay algún problema o dependencias faltantes antes de realizar cambios en el sistema en ejecución.

Intentemos verificar el estado de un módulo común, por ejemplo, el módulo fuse, que se utiliza a menudo para sistemas de archivos en el espacio de usuario.

Escribe el siguiente comando en tu terminal:

modprobe --dry-run fuse

Presiona Enter.

Si el módulo fuse y sus dependencias están disponibles, es posible que veas una salida similar a esta:

modprobe: INFO: could not insert 'fuse': File exists

Esta salida indica que el módulo fuse probablemente ya está cargado (como se vio en el paso anterior de lsmod), y modprobe está informando que no puede insertarlo de nuevo porque ya existe. La opción --dry-run sigue realizando la comprobación de dependencias incluso si el módulo ya está cargado.

Si el módulo no estuviera cargado y se pudiera cargar, la salida podría estar vacía o indicar los módulos que se cargarían. Si hubiera problemas, modprobe los reportaría aquí.

Utilizar --dry-run es una forma segura de probar la carga de módulos sin afectar el estado de tu sistema.

Ahora, intenta ejecutar tú mismo el comando modprobe --dry-run fuse.

Haz clic en Continuar para continuar.

Ver detalles de un módulo con modinfo

En este paso, aprenderás cómo obtener información detallada sobre un módulo específico del kernel utilizando el comando modinfo.

Mientras que lsmod te muestra qué módulos están cargados, modinfo proporciona muchos más detalles sobre un archivo de módulo, ya sea que esté cargado o no. Esta información incluye el autor del módulo, su descripción, la licencia, los parámetros y las dependencias.

Utilicemos modinfo para inspeccionar nuevamente el módulo fuse.

Escribe el siguiente comando en tu terminal:

modinfo fuse

Presiona Enter.

Verás una salida exhaustiva sobre el módulo fuse, similar a esta:

filename:       /lib/modules/5.15.0-113-generic/kernel/fs/fuse/fuse.ko
license:        GPL
description:    Filesystem in Userspace
author:         Miklos Szeredi <[email protected]>
alias:          devname:fuse
alias:          char-major-10-229
alias:          fs-fuse
depends:
retpoline:      Y
intree:         Y
name:           fuse
vermagic:       5.15.0-113-generic SMP mod_unload modversions
sig_id:         PKCS#7
signer:         Ubuntu Kernel Module Signing Authority
sig_key:        ...
sig_hashalgo:   sha512
signature:      ...
parm:           max_user_bgreq:Maximum number of pending background requests (uint)
parm:           max_user_cong_req:Maximum number of pending congested background requests (uint)
parm:           max_user_inline_write:Maximum size of inline write data (uint)

Veamos algunos de los campos clave:

filename: La ruta al archivo del módulo en el sistema de archivos.
license: La licencia bajo la cual se distribuye el módulo (por ejemplo, GPL).
description: Una breve descripción de lo que hace el módulo.
author: El o los autores del módulo.
depends: Una lista de otros módulos de los que depende este módulo.
parm: Información sobre los parámetros que se pueden pasar al módulo cuando se carga para modificar su comportamiento.

modinfo es una herramienta invaluable para solucionar problemas relacionados con los módulos o simplemente para aprender más sobre los componentes de tu kernel de Linux.

Ahora, intenta ejecutar tú mismo el comando modinfo fuse para ver los detalles del módulo fuse.

Haz clic en Continuar para finalizar este laboratorio.

Resumen

En este laboratorio, aprendiste cómo verificar el estado de los módulos del kernel en Linux. Comenzaste utilizando el comando lsmod para listar todos los módulos del kernel actualmente cargados, comprendiendo las columnas de la salida que muestran el nombre del módulo, su tamaño y el recuento de usos.

Luego, exploraste el comando modprobe con la opción --dry-run para simular la carga de un módulo e identificar sus dependencias sin cargarlo realmente. Finalmente, aprendiste cómo utilizar el comando modinfo para ver información detallada sobre un módulo específico del kernel, incluyendo su descripción, autor, licencia y parámetros. Estos comandos son herramientas fundamentales para administrar y solucionar problemas de los módulos del kernel en un sistema Linux.