--- title: "Gestionar módulos del kernel Linux en Ubuntu 24.04" description: "Carga, descarga y configura módulos del kernel en Ubuntu 24.04 con modprobe, fija parámetros, bloquea drivers y compila un módulo externo con DKMS." category: "Internos de Linux" language: es source: https://cubepath.com/es/docs/internos-de-linux/gestion-de-modulos-del-kernel-linux updated: 2026-09-25 --- # Gestionar módulos del kernel Linux en Ubuntu 24.04 Los módulos del kernel son piezas de código, normalmente drivers o soporte para sistemas de archivos y protocolos de red, que se cargan y descargan en el kernel en marcha sin reiniciar. En este tutorial aprenderás a consultar los módulos cargados, a cargarlos y descargarlos con `modprobe`, a fijar sus parámetros, a cargarlos en el arranque, a bloquear los que no quieres y a compilar un módulo externo con DKMS para que se reconstruya solo con cada kernel nuevo, todo en Ubuntu 24.04. ## Requisitos previos Para seguir esta guía necesitas: - Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. Los comandos `lsmod`, `modinfo` y `modprobe` son iguales en Debian 12 y Rocky Linux 9; cambian los paquetes de DKMS y el comando para regenerar el initramfs (`dracut -f` en Rocky). - Un usuario no root con privilegios `sudo`. - Acceso a la consola del servidor (la consola VNC del panel en un VPS) por si un cambio en los módulos de red o de disco impide acceder por SSH. ## Paso 1: Consultar los módulos cargados `lsmod` lista los módulos cargados en este momento: ```bash lsmod | head -5 ``` ```output Module Size Used by tls 155648 0 xt_conntrack 12288 2 nf_conntrack 196608 1 xt_conntrack ip6t_REJECT 12288 1 ``` La columna `Used by` indica cuántas referencias tiene el módulo y qué otros módulos dependen de él. No podrás descargar un módulo mientras ese contador sea mayor que 0. Para ver la información de un módulo concreto, su archivo, licencia, dependencias y parámetros, usa `modinfo`: ```bash modinfo dummy ``` ```output filename: /lib/modules/6.8.0-45-generic/kernel/drivers/net/dummy.ko.zst alias: rtnl-link-dummy description: Dummy netdevice driver which discards all packets sent to it license: GPL depends: intree: Y name: dummy parm: numdummies:Number of dummy pseudo devices (int) ``` Los módulos de Ubuntu 24.04 están comprimidos (`.ko.zst`) en `/lib/modules/$(uname -r)/`. Algunas funciones no son módulos sino que están compiladas dentro del kernel; `modinfo` también las encuentra, y la lista completa está en `modules.builtin`: ```bash grep -c . /lib/modules/$(uname -r)/modules.builtin ``` Un módulo integrado no aparece en `lsmod` y no se puede descargar. ## Paso 2: Cargar y descargar módulos con modprobe Usa siempre `modprobe` en lugar de `insmod` y `rmmod`: resuelve dependencias automáticamente y aplica la configuración de `/etc/modprobe.d/`. Como ejemplo usarás `dummy`, un driver de interfaces de red virtuales que no afecta a nada. Cárgalo: ```bash sudo modprobe dummy ``` Comprueba que está cargado y que ha creado una interfaz: ```bash lsmod | grep dummy ip link show type dummy ``` ```output dummy 12288 0 5: dummy0: mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000 link/ether 3e:91:7c:08:5a:d2 brd ff:ff:ff:ff:ff:ff ``` Para ver qué haría `modprobe` sin ejecutarlo, incluidas las dependencias que cargaría, usa `--show-depends`: ```bash modprobe --show-depends nf_nat ``` Descarga el módulo: ```bash sudo modprobe -r dummy ``` Si el módulo está en uso, `modprobe -r` falla con `Module ... is in use`. Detén primero el servicio o elimina el dispositivo que lo utiliza. ## Paso 3: Pasar parámetros a un módulo Muchos módulos aceptan parámetros. `modinfo -p` los lista: ```bash modinfo -p dummy ``` ```output numdummies:Number of dummy pseudo devices (int) ``` ### Parámetros al cargar Puedes pasarlos directamente a `modprobe`: ```bash sudo modprobe dummy numdummies=3 ip -br link show type dummy ``` ```output dummy0 DOWN 3e:91:7c:08:5a:d2 dummy1 DOWN a6:12:4f:9e:03:77 dummy2 DOWN d2:5b:81:6c:e4:19 ``` Los parámetros solo se leen al cargar el módulo, así que para cambiarlos hay que descargarlo y volver a cargarlo: ```bash sudo modprobe -r dummy ``` ### Parámetros persistentes Para que se apliquen siempre que se cargue el módulo, crea un archivo en `/etc/modprobe.d/` (debe terminar en `.conf`): ```bash sudo nano /etc/modprobe.d/dummy.conf ``` ```ini options dummy numdummies=2 ``` Carga el módulo sin parámetros y comprueba que se ha usado el valor del archivo: ```bash sudo modprobe dummy ip -br link show type dummy ``` Deberías ver `dummy0` y `dummy1`. Muchos módulos publican el valor activo de sus parámetros en `/sys/module//parameters/`; `dummy` no lo hace, por eso aquí se comprueba por su efecto. ## Paso 4: Cargar módulos en el arranque El kernel carga automáticamente la mayoría de drivers cuando detecta el hardware correspondiente. Para los que no se cargan solos (por ejemplo, `br_netfilter` que necesitan Kubernetes y otros entornos de contenedores), añádelos a un archivo en `/etc/modules-load.d/`, un módulo por línea: ```bash sudo nano /etc/modules-load.d/custom.conf ``` ```text br_netfilter dummy ``` El servicio `systemd-modules-load` lee estos archivos en cada arranque. Aplícalo ahora sin reiniciar: ```bash sudo systemctl restart systemd-modules-load.service lsmod | grep -E 'br_netfilter|dummy' ``` Cuando termines las pruebas, quita `dummy` de este archivo y borra `/etc/modprobe.d/dummy.conf` para no crear interfaces innecesarias en cada arranque. Si falla, revisa sus mensajes: ```bash journalctl -b -u systemd-modules-load.service ``` ## Paso 5: Bloquear un módulo A veces quieres impedir que se cargue un módulo: un driver que da problemas, un protocolo que no usas o un dispositivo que no existe. Como ejemplo, en máquinas virtuales a menudo se carga `floppy` sin que haya disquetera. La directiva `blacklist` impide la carga automática por detección de hardware, pero no que otro módulo o un usuario lo cargue explícitamente. Para bloquearlo del todo, añade también una regla `install` que lo sustituya por `/bin/false`: ```bash sudo nano /etc/modprobe.d/blacklist-floppy.conf ``` ```ini blacklist floppy install floppy /bin/false ``` Si el módulo está incluido en el initramfs, se cargaría antes de leer esta configuración. Regenera el initramfs para que incluya el archivo: ```bash sudo update-initramfs -u ``` Descárgalo si está cargado y comprueba que ya no se puede cargar: ```bash sudo modprobe -r floppy sudo modprobe floppy ``` El segundo comando debe fallar con un error `Error running install command '/bin/false' for module floppy`, y `lsmod | grep floppy` no debe devolver nada. Para deshacer el bloqueo, borra el archivo y vuelve a ejecutar `sudo update-initramfs -u`. > Advertencia: no bloquees módulos de disco (`virtio_blk`, `virtio_scsi`, `nvme`...) ni de red (`virtio_net`...). El servidor dejaría de arrancar o de tener red, y solo podrías arreglarlo desde la consola o un sistema de rescate. ## Paso 6: Compilar un módulo externo con DKMS Los módulos que no vienen con el kernel (algunos drivers de hardware, VirtualBox, ZFS de terceros...) deben compilarse para cada versión del kernel. DKMS automatiza esto: registra el código fuente y lo recompila e instala cada vez que se instala un kernel nuevo. ### Instalar DKMS Instala DKMS, las herramientas de compilación y las cabeceras del kernel en uso: ```bash sudo apt update sudo apt install dkms build-essential linux-headers-$(uname -r) ``` Instala también el metapaquete de cabeceras para que se actualicen junto con el kernel; sin ellas, DKMS no puede compilar para un kernel nuevo: ```bash sudo apt install linux-headers-generic ``` ### Crear un módulo de ejemplo DKMS espera el código en `/usr/src/-`. Crea un módulo mínimo llamado `hello`: ```bash sudo mkdir -p /usr/src/hello-1.0 sudo nano /usr/src/hello-1.0/hello.c ``` ```c #include #include MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Ejemplo de modulo gestionado con DKMS"); MODULE_VERSION("1.0"); static int __init hello_init(void) { pr_info("hello: modulo cargado\n"); return 0; } static void __exit hello_exit(void) { pr_info("hello: modulo descargado\n"); } module_init(hello_init); module_exit(hello_exit); ``` Crea el `Makefile` que usa el sistema de compilación del kernel: ```bash sudo nano /usr/src/hello-1.0/Makefile ``` ```makefile obj-m := hello.o ``` Y el archivo `dkms.conf`, que describe el módulo a DKMS: ```bash sudo nano /usr/src/hello-1.0/dkms.conf ``` ```ini PACKAGE_NAME="hello" PACKAGE_VERSION="1.0" BUILT_MODULE_NAME[0]="hello" DEST_MODULE_LOCATION[0]="/updates/dkms" MAKE[0]="make -C ${kernel_source_dir} M=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build" CLEAN="make -C ${kernel_source_dir} M=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build clean" AUTOINSTALL="yes" ``` `AUTOINSTALL="yes"` hace que DKMS lo recompile automáticamente al instalar un kernel nuevo. ### Registrar, compilar e instalar ```bash sudo dkms add -m hello -v 1.0 sudo dkms build -m hello -v 1.0 sudo dkms install -m hello -v 1.0 ``` Comprueba el estado: ```bash dkms status ``` ```output hello/1.0, 6.8.0-45-generic, x86_64: installed ``` Carga el módulo y revisa su mensaje en el log del kernel: ```bash sudo modprobe hello sudo dmesg | tail -n 2 ``` ```output [ 8123.402117] hello: loading out-of-tree module taints kernel. [ 8123.402391] hello: modulo cargado ``` El aviso de `taints kernel` es normal para cualquier módulo externo. ### Mantenimiento Para eliminar el módulo de todos los kernels y de DKMS: ```bash sudo modprobe -r hello sudo dkms remove hello/1.0 --all ``` Tras una actualización del kernel, `dkms status` debería mostrar el módulo como `installed` también para la nueva versión. Si no, revisa el log de compilación que DKMS indica en su mensaje de error. ## Solución de problemas **`modprobe: FATAL: Module xxx not found in directory /lib/modules/...`.** El módulo no existe para el kernel en uso. En Ubuntu, algunos drivers están en el paquete `linux-modules-extra-$(uname -r)`; en imágenes cloud que usan otras variantes de kernel pueden no estar disponibles. **`modprobe: ERROR: could not insert 'xxx': Key was rejected by service`.** Secure Boot está activo y el módulo no está firmado con una clave de confianza. Ubuntu firma los módulos DKMS con una clave MOK propia; debes registrarla con `sudo mokutil --import /var/lib/shim-signed/mok/MOK.der` y confirmar el registro desde la consola en el siguiente arranque. **`dkms build` falla con `Kernel headers ... cannot be found`.** Faltan las cabeceras de ese kernel. Instala `linux-headers-` para la versión que indica el error. **El módulo bloqueado sigue cargándose tras reiniciar.** Se carga desde el initramfs. Ejecuta `sudo update-initramfs -u` y reinicia. ## Conclusión Ahora sabes consultar, cargar y descargar módulos con `modprobe`, fijar sus parámetros, cargarlos en el arranque, bloquearlos y mantener un módulo externo con DKMS a través de las actualizaciones del kernel. Como siguientes pasos, puedes revisar los mensajes que generan los drivers con `dmesg`, explorar `/sys/module/` para ver los parámetros activos o ajustar el kernel en tiempo real con `sysctl`.