Kernel: Windows, Linux y Tipos

Modos de Funcionamiento del Sistema (UNIX/Linux)

Los sistemas operativos operan en dos modos de ejecución diferenciados por el nivel de privilegio:

┌─────────────────────────────────────────────┐
│              ESPACIO DE USUARIO             │  ← Modo Usuario
│   Aplicaciones, procesos, shell, libs...    │
├─────────────────────────────────────────────┤
│         INTERFAZ (Llamadas al sistema)      │  ← syscalls
├─────────────────────────────────────────────┤
│              ESPACIO DE KERNEL              │  ← Modo Kernel
│  Gestión memoria, CPU, E/S, planificador... │
└─────────────────────────────────────────────┘
             HARDWARE FÍSICO

Las aplicaciones pasan de modo usuario a modo kernel mediante llamadas al sistema (syscalls).

Tipos de Kernel

Representación visual por tamaño del núcleo

MICROKERNEL    │▓│           → Solo: IPC, scheduling, memoria básica
MONOLÍTICO     │▓▓▓▓▓▓▓▓▓│  → Todo: drivers, FS, red, memoria...
HÍBRIDO        │▓▓▓▓▓▓│     → Núcleo + servicios externos selectivos
MODULAR        │▓▓▓▓▓[mod]│ → Núcleo + módulos cargables en caliente

Kernel Windows

Planificador Distribuido de Windows ⚠️

Windows no usa un planificador centralizado. Su modelo es distribuido:

CPU 0 → [Planificador propio] → Cola de hilos local
CPU 1 → [Planificador propio] → Cola de hilos local
CPU 2 → [Planificador propio] → Cola de hilos local
CPU N → [Planificador propio] → Cola de hilos local

• Cada CPU gestiona su propia cola de ejecución
• No existe un único hilo que decida todo
• Mejora el rendimiento en sistemas multiprocesador (SMP)
• La unidad básica de planificación es el hilo (thread), no el proceso

Kernel Linux

Planificador CFS (Completely Fair Scheduler) ⚠️

      [CFS - Planificador centralizado]
              ↓         ↓         ↓
           CPU 0      CPU 1      CPU 2

• Objetivo: distribuir el tiempo de CPU de forma equitativa entre procesos
• Usa un árbol Red-Black para ordenar procesos por tiempo de ejecución virtual
• Es el planificador por defecto desde Linux 2.6.23
• Soporta múltiples CPUs pero la lógica de decisión es centralizada

Comparativa Windows vs Linux vs otros SO

Windows vs Linux — Diferencias clave

Resumen en 3 puntos

1. Modos de ejecución: Todo SO con base UNIX/Linux opera en dos modos: modo usuario (privilegio bajo, sin acceso directo al hardware) y modo kernel (privilegio total). El paso entre ambos se realiza mediante llamadas al sistema (syscalls).

2. Tipos de kernel: Existen cinco tipos principales — monolítico (todo integrado, muy rápido), monolítico modular (flexible con módulos cargables, usado en Linux), microkernel (solo lo esencial, más seguro pero lento), híbrido (equilibrio entre ambos, usado en Windows y macOS) y exokernel (experimental). Linux es monolítico modular; Windows es híbrido.

3. Planificación: La diferencia clave entre Windows y Linux reside en el planificador — Windows usa un modelo distribuido (cada CPU tiene el suyo), mientras que Linux usa CFS centralizado (Completely Fair Scheduler) que garantiza equidad en el reparto de CPU entre todos los procesos.

Módulos del kernel en Linux: insmod y modprobe

Los módulos del kernel son fragmentos de código que se pueden cargar y descargar del kernel de Linux bajo demanda, sin necesidad de reiniciar el sistema. Permiten añadir funcionalidad (drivers, sistemas de archivos, protocolos de red, etc.) de forma dinámica.

Para gestionarlos, las dos herramientas más comunes son insmod y modprobe.

1. insmod (Insert Module)

insmod es la herramienta más básica para insertar un módulo en el kernel. Carga el archivo .ko (kernel object) que se le indique, tal cual, sin resolver dependencias.

Sintaxis

insmod <ruta_al_modulo.ko> [parametros]

Ejemplos

Cargar un módulo indicando la ruta completa:

sudo insmod /lib/modules/$(uname -r)/kernel/drivers/net/dummy.ko

Cargar un módulo pasándole parámetros:

sudo insmod ./mi_modulo.ko debug=1 nombre="prueba"

Características

• Requiere la ruta absoluta o relativa al archivo .ko.
• No resuelve dependencias: si el módulo necesita otro, fallará con un error de símbolos no resueltos (unknown symbol).
• No consulta /etc/modprobe.d/ ni los alias del sistema.
• Útil durante el desarrollo de módulos propios, cuando aún no están instalados en /lib/modules/.

Limitaciones

insmod: ERROR: could not insert module foo.ko: Unknown symbol in module

Este error típico aparece cuando el módulo depende de otros que no están cargados. En ese caso, hay que usar modprobe.

2. modprobe (Module Probe)

modprobe es la herramienta recomendada y de alto nivel para cargar y descargar módulos. Internamente usa insmod, pero añade inteligencia: resuelve dependencias, consulta configuración y trabaja por nombre de módulo.

Sintaxis

modprobe [opciones] <nombre_modulo> [parametros]

Ejemplos

Cargar un módulo por nombre (sin extensión ni ruta):

sudo modprobe dummy

Descargar un módulo:

sudo modprobe -r dummy

Cargar pasando parámetros:

sudo modprobe usbcore autosuspend=2

Ver qué haría sin ejecutarlo realmente (modo simulación):

modprobe --dry-run --verbose dummy

Mostrar las dependencias de un módulo:

modprobe --show-depends ext4

Características

• Trabaja con nombres de módulo, no rutas (busca en /lib/modules/$(uname -r)/).
• Resuelve dependencias automáticamente usando el archivo modules.dep (generado por depmod).
• Consulta los archivos de configuración en /etc/modprobe.d/ y /usr/lib/modprobe.d/, donde se pueden definir alias, opciones por defecto, listas negras (blacklist), etc.
• Permite descargar módulos junto con sus dependencias no usadas (-r).

Opciones útiles

3. Diferencias clave entre insmod y modprobe

4. Comandos relacionados

• lsmod — Lista los módulos actualmente cargados en el kernel. En realidad es prácticamente un wrapper que formatea el contenido del archivo virtual /proc/modules:

lsmod
cat /proc/modules   # misma información, formato crudo

• rmmod — Descarga un módulo (sin tocar dependencias):

sudo rmmod dummy

• modinfo — Muestra información sobre un módulo (autor, licencia, parámetros aceptados, dependencias, etc.):

modinfo ext4

• depmod — Regenera el archivo de dependencias modules.dep. Se ejecuta normalmente al instalar un nuevo kernel o módulo:

sudo depmod -a

5. ¿De dónde saca cada comando la información?

El kernel mantiene en memoria la lista de módulos cargados. El espacio de usuario accede a esos datos a través de archivos virtuales expuestos por procfs y sysfs, además de archivos en disco para metadatos y configuración.

Resumen por comando

Archivos virtuales del kernel

• /proc/modules — Lista en texto plano de los módulos cargados, su tamaño, el contador de uso, qué módulos dependen de ellos, su estado y su dirección de memoria. Es lo que lee lsmod.

$ cat /proc/modules
ext4 933888 1 - Live 0xffffffffc0a00000
mbcache 16384 1 ext4, Live 0xffffffffc09f0000
...

• /sys/module/ — Interfaz más rica vía sysfs. Cada módulo cargado tiene su propio directorio con subdirectorios como parameters/, sections/, refcnt, etc. Útil para inspeccionar parámetros en caliente:

ls /sys/module/
cat /sys/module/usbcore/parameters/autosuspend

Archivos en disco usados por modprobe

• /lib/modules/$(uname -r)/ — Directorio donde viven los .ko del kernel actual.
• /lib/modules/$(uname -r)/modules.dep — Mapa de dependencias generado por depmod. Sin este archivo, modprobe no sabría qué cargar antes de qué.
• /lib/modules/$(uname -r)/modules.alias — Alias (incluyendo los basados en IDs de hardware PCI/USB) para que modprobe resuelva nombres alternativos.
• /etc/modprobe.d/*.conf y /usr/lib/modprobe.d/*.conf — Configuración: alias, opciones por defecto, blacklists.
• /etc/modules-load.d/*.conf — Módulos a cargar al arranque (lo procesa systemd-modules-load.service).

Idea clave

• lsmod y rmmod preguntan al kernel (vía /proc/modules) qué hay cargado en este instante.
• modprobe consulta tanto el disco (para saber qué puede cargar y con qué dependencias/configuración) como /proc/modules (para saber qué hay ya cargado y evitar duplicados).
• insmod y modinfo trabajan directamente sobre el archivo .ko, sin consultar el estado del kernel.

6. Configuración persistente

Para que los módulos se carguen automáticamente al arrancar, se pueden añadir a:

• /etc/modules-load.d/*.conf — Un nombre de módulo por línea.
• /etc/modprobe.d/*.conf — Para definir alias, opciones o listas negras.

Ejemplo: cargar dummy al inicio

/etc/modules-load.d/dummy.conf:

dummy

Ejemplo: bloquear un módulo (blacklist)

/etc/modprobe.d/blacklist-nouveau.conf:

blacklist nouveau
options nouveau modeset=0

Ejemplo: opciones por defecto para un módulo

/etc/modprobe.d/usbcore.conf:

options usbcore autosuspend=2

7. Flujo típico de trabajo

1. Ver qué módulos están cargados:

lsmod

2. Buscar información de un módulo:

modinfo nombre_modulo

3. Cargarlo:

sudo modprobe nombre_modulo

4. Descargarlo si ya no se necesita:

sudo modprobe -r nombre_modulo

8. Conclusión

• Usa modprobe en el 99% de los casos: es seguro, resuelve dependencias y respeta la configuración del sistema.
• Usa insmod solo cuando estás desarrollando un módulo propio o trabajando con un .ko que no está instalado en /lib/modules/.
• Recuerda siempre ejecutar depmod -a tras instalar un nuevo módulo en el sistema, para que modprobe pueda encontrarlo por nombre.r nombre.