El corazón del sistema operativo: Kbuild, módulos, drivers, RCU, memoria del kernel, depuración y el nuevo Rust como lenguaje central.
Cada nivel construye sobre el anterior. Sin saltos, sin huecos.
La visión aérea del kernel: subsistemas, cómo se relacionan, y el mapa mental de todo lo que vas a dominar.
El rol del kernel, espacio usuario vs kernel, la cadena de arranque y por qué Linux domina.
GNU C, freestanding, sin libc, y el arsenal de macros (container_of) que define el kernel.
Navegar millones de líneas: estructura de directorios y usar git para entender el porqué.
El sistema de configuración, escribir tus propias entradas Kconfig, y depends on vs select.
El sistema de build del kernel y el Makefile de tu módulo out-of-tree.
Montar un entorno seguro con QEMU y depurar el kernel en vivo con gdb.
module_init/exit, printk, y las herramientas del ciclo de vida de un módulo.
Exponer y controlar tu módulo como archivos: procfs, sysfs y debugfs.
El estilo estricto del kernel y las herramientas (checkpatch, sparse) que lo verifican.
Las listas intrusivas, árboles rojo-negro, hashes y xarray que el kernel usa por todas partes.
ERR_PTR, el patrón goto de limpieza en cascada, y elegir bien los códigos de error.
copy_to/from_user, por qué nunca confiar en el usuario, y el sistema de capabilities.
Registrar un char device y darle vida con open, read, write e ioctl.
Por qué el kernel es concurrente por defecto, y las operaciones atómicas.
La sincronización que no duerme: spinlocks, irqsave, y las reglas de oro.
Mutex, semáforos, rwsem y completions: sincronización en contexto que puede dormir.
Lecturas sin bloqueo que escalan a miles de núcleos: grace periods, flavors y listas RCU.
per-CPU, seqlocks, el modelo de memoria del kernel y las barreras (smp_mb, acquire/release).
Cómo el kernel detecta deadlocks automáticamente y cómo depurar problemas de sincronización.
El asignador de páginas (buddy system), las órdenes de páginas y los flags GFP.
kmalloc/kfree por dentro: el slab allocator, slub, y crear tus propios caches (kmem_cache).
vmalloc vs kmalloc, y el mapa del espacio de direcciones virtual del kernel.
Cómo el kernel gestiona la memoria virtual de los procesos: VMA, page faults y demand paging.
Cómo el kernel cachea archivos en memoria y realiza la E/S a través del page cache.
Cómo el kernel recupera memoria bajo presión: LRU, kswapd, swap y el OOM killer.
Memoria no uniforme (NUMA), localidad, y estructuras de datos por CPU.
DMA coherente y streaming, direcciones de bus, y el IOMMU que protege la memoria.
El modelo de dispositivos unificado: kobject, sysfs, y la tríada bus/class/driver.
Dispositivos sin bus de descubrimiento: platform drivers, device tree y el ciclo probe/remove.
El bus PCI/PCIe a fondo: espacio de configuración, BARs, e interrupciones MSI/MSI-X.
La pila USB: endpoints, URBs, y escribir un driver USB.
Los buses de dispositivos embebidos (I2C, SPI) y la abstracción regmap para registros.
Control de pines (GPIO), el subsistema de sensores (IIO), y mapear interrupciones de dispositivo.
Manejar interrupciones, el trabajo diferido (softirq, tasklet, workqueue) y threaded IRQ.
La capa de bloques: bio, request queues, y la arquitectura multi-cola blk-mq.
Los planificadores de E/S (mq-deadline, BFQ, Kyber) y escribir un driver de bloques.
El Virtual File System por dentro: sus cuatro objetos y cómo abstrae cualquier sistema de archivos.
Registrar un sistema de archivos y construir uno mínimo en memoria con libfs.
La E/S basada en readiness: select, poll, y epoll a fondo (el motor de la red de alto rendimiento).
La interfaz de E/S asíncrona por anillos: submission/completion queues y el modelo de completado.
Buffers y descriptores registrados, modos de sondeo, multishot y liburing.
Exponer memoria de dispositivo a userspace con mmap y técnicas de copia cero.
El corazón del networking: sk_buff, net_device, y el viaje de un paquete por el kernel.
La recepción eficiente (NAPI), la API de sockets por dentro, y el fast path con XDP/eBPF.
Cómo el kernel mide y programa el tiempo: jiffies, hrtimers, clocksource y el modo tickless.
El planificador moderno EEVDF, el task_struct, y la mecánica del cambio de contexto.
Balanceo de carga entre núcleos, scheduling de tiempo real y deadline, y control de recursos con cgroups.
El function tracer, los tracepoints estáticos, y la infraestructura de trazado del kernel.
Instrumentar cualquier función en caliente con kprobes, y perfilar el kernel con perf.
Ejecutar programas seguros dentro del kernel: el verifier, los mapas, y sus mil usos.
Los sanitizers del kernel (KASAN, KCSAN, KMSAN), kmemleak, y depurar oops y panics.
La base de los contenedores (namespaces, cgroups) y los módulos de seguridad (seccomp, LSM/SELinux).
Cómo el kernel es un hipervisor: KVM, y los drivers paravirtualizados virtio.
Por qué Rust entró en el kernel, cómo conviven Rust y C, y las abstracciones seguras.
Escribir un driver completo en Rust for Linux, aprovechando su seguridad de memoria.
Preparar y enviar un parche: git format-patch, send-email, las listas y la revisión.
El rol de mantenedor, sostener un subsistema, y hacia dónde va el kernel.
GNU C freestanding, sin libc, con su propio universo de APIs y reglas.
Configurar y compilar el kernel, y escribir módulos cargables (LKM).
file_operations, el device model y hablar con el hardware.
Spinlocks, mutexes, RCU y las barreras de memoria que escalan a miles de núcleos.
kmalloc, el slab allocator, páginas y memoria física.
IRQ handlers, softirqs, tasklets, workqueues y el planificador.
ftrace, KASAN, lockdep, kgdb: cazar bugs en el corazón del sistema.
El nuevo lenguaje central del kernel: drivers seguros en Rust.
Empieza por los fundamentos y sube nivel a nivel hasta el dominio total.
Comenzar el camino →