Saltar al contenido
wandres.dev
Iniciar sesión

Kernel de Linux

El corazón del sistema operativo: Kbuild, módulos, drivers, RCU, memoria del kernel, depuración y el nuevo Rust como lenguaje central.

58 unidades · 247 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología del kernel de Linuxhechoen curso
  2. 01

    Nivel 1

    2 temas
    1. 01Qué es un kernelhechoen curso
    2. 02Del encendido a la shell: el arranquehechoen curso
  3. 02

    Nivel 2

    2 temas
    1. 01El C del kernel: otro lenguajehechoen curso
    2. 02container_of y las macros del kernelhechoen curso
  4. 03

    Nivel 3

    2 temas
    1. 01El árbol de fuentes del kernelhechoen curso
    2. 02Git para entender el kernelhechoen curso
  5. 04

    Nivel 4

    2 temas
    1. 01Kconfig: configurar el kernelhechoen curso
    2. 02Escribir tu propia entrada Kconfighechoen curso
  6. 05

    Nivel 5

    2 temas
    1. 01Kbuild: compilar el kernelhechoen curso
    2. 02Kbuild por dentro: obj-y y obj-mhechoen curso
  7. 06

    Nivel 6

    2 temas
    1. 01Un entorno de kernel seguro con QEMUhechoen curso
    2. 02Depurar el kernel con gdb sobre QEMUhechoen curso
  8. 07

    Nivel 7

    2 temas
    1. 01Tu primer módulo del kernelhechoen curso
    2. 02El ciclo de vida de un módulohechoen curso
  9. 08

    Nivel 8

    2 temas
    1. 01Parámetros de módulohechoen curso
    2. 02Exponer datos: procfs, sysfs y debugfshechoen curso
  10. 09

    Nivel 9

    2 temas
    1. 01El estilo de código del kernelhechoen curso
    2. 02checkpatch y las herramientas de revisiónhechoen curso
  11. 10

    Nivel 10

    2 temas
    1. 01Listas enlazadas del kernelhechoen curso
    2. 02Árboles, hashes y otras estructurashechoen curso
  12. 11

    Nivel 11

    2 temas
    1. 01Errores: ERR_PTR y el patrón gotohechoen curso
    2. 02Códigos de error y su propagaciónhechoen curso
  13. 12

    Nivel 12

    2 temas
    1. 01La frontera usuario↔kernelhechoen curso
    2. 02Permisos, capabilities y el contextohechoen curso
  14. 13

    Nivel 13

    2 temas
    1. 01Char devices: registrar un dispositivohechoen curso
    2. 02Implementar read, write y openhechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01Por qué el kernel es concurrente por defectohechoen curso
    2. 02Condiciones de carrera reales: el contadorhechoen curso
    3. 03Operaciones atómicas: atomic_thechoen curso
    4. 04Atómicos avanzados: CAS y bitshechoen curso
    5. 05Contadores de referencia: refcount_t y krefhechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01Qué es un spinlock y por qué existehechoen curso
    2. 02La sección crítica: nunca duermas con el lock cogidohechoen curso
    3. 03spin_lock_irqsave y spin_lock_bh: compartir con interrupcioneshechoen curso
    4. 04Variantes: rwlock, trylock y el coste bajo contenciónhechoen curso
    5. 05Deadlocks de spinlocks y las reglas de orohechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01Contexto que puede dormir vs atómicohechoen curso
    2. 02El mutex: el lock por defecto que duermehechoen curso
    3. 03Semáforos: el abuelo que aún sabe contarhechoen curso
    4. 04Read-write semaphores: muchos leen, uno escribehechoen curso
    5. 05Completions y colas de espera: aguardar un eventohechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01El problema que resuelve RCUhechoen curso
    2. 02RCU conceptual: publicar, suscribir y grace periodshechoen curso
    3. 03El lado lector: rcu_read_lock, rcu_dereference y sus reglashechoen curso
    4. 04El lado escritor: publicar, synchronize_rcu, call_rcu y listas RCUhechoen curso
    5. 05Flavors de RCU y cuándo no usarlahechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01El reordenamiento: el orden que escribes no es el que se ejecutahechoen curso
    2. 02Barreras de compilador: barrier(), READ_ONCE y WRITE_ONCEhechoen curso
    3. 03Barreras de CPU: smp_mb, smp_rmb, smp_wmb y el emparejamientohechoen curso
    4. 04Semántica acquire/release: publicar y consumir datoshechoen curso
    5. 05Herramientas especializadas: variables per-CPU y seqlockshechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01Los tres rostros del deadlockhechoen curso
    2. 02lockdep: probar que no puede haber deadlockhechoen curso
    3. 03Leer un informe de lockdephechoen curso
    4. 04Anotaciones: subclases y clases de lockhechoen curso
    5. 05KCSAN: cazar data races realeshechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01La memoria física: struct page y el PFNhechoen curso
    2. 02El buddy allocator: bloques, fusión y fragmentaciónhechoen curso
    3. 03La API de páginas: alloc_pages y sus hermanashechoen curso
    4. 04Los flags GFP a fondo: dormir o no dormirhechoen curso
    5. 05Zonas y watermarks: dónde vive la RAM y cuándo se reclamahechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01Por qué un slab: objetos pequeños sobre el buddyhechoen curso
    2. 02kmalloc por dentro: caches de tamaños y alineaciónhechoen curso
    3. 03SLUB por dentro: struct slab, freelist y caché por-CPUhechoen curso
    4. 04Tu propia caché de objetos: kmem_cache_createhechoen curso
    5. 05Depurar la memoria slab: redzones, poison y kmemleakhechoen curso
  23. 22

    Nivel 22

    5 temas
    1. 01Contiguo en RAM o contiguo a la vista: kmalloc frente a vmallochechoen curso
    2. 02vmalloc, vfree y vzalloc: cuándo usarlo y qué cuestahechoen curso
    3. 03El mapa del espacio de direcciones del kernel en x86-64hechoen curso
    4. 04ioremap y MMIO: mapear registros de dispositivo al kernelhechoen curso
    5. 05Mapeos temporales: kmap_local_page y el fantasma de la high memoryhechoen curso
  24. 23

    Nivel 23

    5 temas
    1. 01El espacio de direcciones: mm_struct, VMAs y el maple treehechoen curso
    2. 02mmap desde userspace: del syscall al page cachehechoen curso
    3. 03Page faults: handle_mm_fault, demand paging y copy-on-writehechoen curso
    4. 04Implementar .mmap en un driver: remap_pfn_range y .faulthechoen curso
    5. 05Tipos de mapeo: anónimo, fichero, privado, compartido y hugepageshechoen curso
  25. 24

    Nivel 24

    5 temas
    1. 01El page cache: por qué la segunda lectura es gratishechoen curso
    2. 02struct address_space: la cache de cada archivohechoen curso
    3. 03read y write por el cache: búsqueda y readaheadhechoen curso
    4. 04Writeback: páginas sucias, dirty_ratio y durabilidadhechoen curso
    5. 05O_DIRECT: saltarse el cache y su vínculo con io_uringhechoen curso
  26. 25

    Nivel 25

    5 temas
    1. 01Cuando falta memoria: qué es el reclaimhechoen curso
    2. 02Las listas LRU y MGLRU: elegir a quién expulsarhechoen curso
    3. 03kswapd frente a reclaim directo: quién paga la deudahechoen curso
    4. 04El swap y swappiness: expulsar lo que no tiene hogarhechoen curso
    5. 05El OOM killer y memcg: matar para seguir vivohechoen curso
  27. 26

    Nivel 26

    5 temas
    1. 01NUMA: nodos, distancias y el descriptor por nodohechoen curso
    2. 02Políticas de asignación NUMA: local, bind e interleavehechoen curso
    3. 03Variables per-CPU: una copia por núcleo, cero sincronizaciónhechoen curso
    4. 04Contadores y estructuras per-CPU: sumar al leerhechoen curso
    5. 05Localidad de caché y NUMA: medir y diseñar para escalarhechoen curso
  28. 27

    Nivel 27

    5 temas
    1. 01Qué es DMA: el dispositivo lee la RAM sin la CPUhechoen curso
    2. 02La DMA API: memoria coherente frente a streaminghechoen curso
    3. 03Direcciones y coherencia: virtual, física y de bushechoen curso
    4. 04El IOMMU: la MMU de los dispositivos que protege la RAMhechoen curso
    5. 05Scatter-gather y la máscara de DMAhechoen curso
  29. 28

    Nivel 28

    5 temas
    1. 01El problema que resuelve el device modelhechoen curso
    2. 02kobject, kset y sysfs: la infraestructura basehechoen curso
    3. 03La tríada del modelo: bus_type, device_driver y devicehechoen curso
    4. 04El emparejamiento driver-dispositivo: match, probe y removehechoen curso
    5. 05uevents y udev: del kobject al nodo en /devhechoen curso
  30. 29

    Nivel 29

    5 temas
    1. 01Platform devices: el hardware que no sabe presentarsehechoen curso
    2. 02Escribir un platform driver: probe, remove y recursoshechoen curso
    3. 03El Device Tree: describir el hardware que no se descubrehechoen curso
    4. 04El emparejamiento por compatible: cómo el nodo encuentra su driverhechoen curso
    5. 05Consumir el Device Tree desde el driver: propiedades, MMIO, IRQ, GPIO y clockshechoen curso
  31. 30

    Nivel 30

    5 temas
    1. 01El bus PCI/PCIe: topología, enumeración y el BDFhechoen curso
    2. 02El espacio de configuración y los BARshechoen curso
    3. 03Escribir un driver PCI: struct pci_driver y el probehechoen curso
    4. 04Interrupciones PCI: de las líneas legacy a MSI/MSI-Xhechoen curso
    5. 05DMA en PCI: bus mastering, la máscara y el camino a la RAMhechoen curso
  32. 31

    Nivel 31

    5 temas
    1. 01La arquitectura USB: un bus con un solo amohechoen curso
    2. 02Descriptores USB y la enumeraciónhechoen curso
    3. 03Escribir un driver USB: usb_driver, probe y disconnecthechoen curso
    4. 04URBs: la unidad de transferencia asíncronahechoen curso
    5. 05Los cuatro tipos de transferencia USBhechoen curso
  33. 32

    Nivel 32

    5 temas
    1. 01I2C y SPI: los dos buses seriales del mundo embebidohechoen curso
    2. 02Un driver I2C: de la cadena compatible a la trama en el bushechoen curso
    3. 03Un driver SPI: spi_message, spi_sync y los modos de relojhechoen curso
    4. 04regmap: un único acceso a registros sobre I2C, SPI o MMIOhechoen curso
    5. 05regmap avanzado: caché, campos de bits y depuración por debugfshechoen curso
  34. 33

    Nivel 33

    5 temas
    1. 01GPIO con descriptores: controlar un pin sin números mágicoshechoen curso
    2. 02GPIO como entrada, salida e interrupción, y desde el device treehechoen curso
    3. 03El subsistema IIO: por qué los sensores tienen su propio mundohechoen curso
    4. 04Un driver IIO: iio_dev, canales y read_rawhechoen curso
    5. 05Triggers y buffers IIO: muestreo continuo con marca de tiempohechoen curso
  35. 34

    Nivel 34

    5 temas
    1. 01El ciclo de una interrupción: registrar y atenderhechoen curso
    2. 02Top half y bottom half: el arte de diferirhechoen curso
    3. 03Threaded IRQ: la mitad inferior que sí puede dormirhechoen curso
    4. 04softirqs y tasklets: diferir sin dormirhechoen curso
    5. 05Workqueues: diferir a contexto de procesohechoen curso
  36. 35

    Nivel 35

    5 temas
    1. 01La E/S de bloques y por qué necesita una capa enterahechoen curso
    2. 02struct bio: la unidad de E/S de bloqueshechoen curso
    3. 03blk-mq: la arquitectura multi-colahechoen curso
    4. 04El camino de una petición: de submit_bio al completadohechoen curso
    5. 05Registrar un dispositivo de bloques: gendisk y add_diskhechoen curso
  37. 36

    Nivel 36

    5 temas
    1. 01Por qué planificar la E/S de bloqueshechoen curso
    2. 02Los schedulers de blk-mq: none, mq-deadline, BFQ y Kyberhechoen curso
    3. 03Escribir un block driver con blk-mq: tag set, gendisk y opshechoen curso
    4. 04El corazón del driver: queue_rq, recorrer el bio y completarhechoen curso
    5. 05NVMe y el futuro: colas paralelas, blk-mq y el camino a io_uringhechoen curso
  38. 37

    Nivel 37

    5 temas
    1. 01El Virtual File System: una interfaz para todos los discoshechoen curso
    2. 02super_block e inode: el montaje y el archivohechoen curso
    3. 03struct dentry: la caché que hace veloz al path lookuphechoen curso
    4. 04struct file y file_operations: el archivo abiertohechoen curso
    5. 05El camino de open y read: de la ruta al datohechoen curso
  39. 38

    Nivel 38

    5 temas
    1. 01Las cuatro tablas: qué implementa un sistema de archivoshechoen curso
    2. 02Registrar y montar: file_system_type y la fábrica de superbloqueshechoen curso
    3. 03libfs: la biblioteca para sistemas de archivos en memoriahechoen curso
    4. 04Un sistema de archivos mínimo en memoria, de cabo a rabohechoen curso
    5. 05FUSE: un sistema de archivos en el espacio de usuariohechoen curso
  40. 39

    Nivel 39

    5 temas
    1. 01El problema C10k: un hilo para miles de conexioneshechoen curso
    2. 02select y poll: readiness que no escalahechoen curso
    3. 03epoll: la multiplexación O(1) de Linuxhechoen curso
    4. 04epoll a fondo: level-triggered contra edge-triggeredhechoen curso
    5. 05La familia de fds de eventos: eventfd, signalfd, timerfdhechoen curso
  41. 40

    Nivel 40

    5 temas
    1. 01La revolución de io_uring: de readiness a completionhechoen curso
    2. 02Las dos colas en anillo: memoria compartida entre kernel y usuariohechoen curso
    3. 03El ciclo de vida de una operación: del SQE al CQEhechoen curso
    4. 04io_uring frente a epoll, en serio: batching, completado universal y cifrashechoen curso
    5. 05liburing: la librería que hace io_uring usablehechoen curso
  42. 41

    Nivel 41

    5 temas
    1. 01Buffers y descriptores registrados: pagar el peaje una sola vezhechoen curso
    2. 02Sondeo sin syscalls: SQPOLL e IOPOLLhechoen curso
    3. 03Cadenas, drains y multishot: dependencias dentro del ringhechoen curso
    4. 04io_uring en la red: por qué puede batir a epollhechoen curso
    5. 05El futuro de la E/S: io_uring, eBPF, zero-copy y seguridadhechoen curso
  43. 42

    Nivel 42

    5 temas
    1. 01El coste de copiar: por qué cada byte importahechoen curso
    2. 02mmap en un driver: exponer memoria sin copiarhechoen curso
    3. 03sendfile y splice: empalmar descriptores en el kernelhechoen curso
    4. 04DMA-BUF: compartir buffers entre dispositivoshechoen curso
    5. 05Zero-copy en red: MSG_ZEROCOPY e io_uringhechoen curso
  44. 43

    Nivel 43

    5 temas
    1. 01El viaje de un paquete: de la NIC al socket y vueltahechoen curso
    2. 02struct sk_buff: el paquete hecho estructurahechoen curso
    3. 03struct net_device: una interfaz de red hecha objetohechoen curso
    4. 04Las capas por dentro: de netif_receive_skb al sockethechoen curso
    5. 05netfilter y nftables: los ganchos donde nace el cortafuegoshechoen curso
  45. 44

    Nivel 44

    5 temas
    1. 01NAPI: sobrevivir a un millón de paquetes por segundohechoen curso
    2. 02Sockets por dentro: struct socket contra struct sockhechoen curso
    3. 03El camino de send y recv: del socket al cable y de vueltahechoen curso
    4. 04XDP: un programa eBPF antes de que exista el paquetehechoen curso
    5. 05XDP en producción: firewalls DDoS, balanceadores y observabilidadhechoen curso
  46. 45

    Nivel 45

    5 temas
    1. 01jiffies, HZ y el tick: el latido del kernelhechoen curso
    2. 02clocksource y clockevents: abstraer el hardware del tiempohechoen curso
    3. 03Timers de baja resolución: struct timer_listhechoen curso
    4. 04hrtimers: temporizadores de alta resoluciónhechoen curso
    5. 05NO_HZ y delays: silenciar el tick y esperar bienhechoen curso
  47. 46

    Nivel 46

    5 temas
    1. 01Qué hace el planificador: tareas, estados y runqueueshechoen curso
    2. 02El context switch: schedule, context_switch y su costehechoen curso
    3. 03CFS y su sucesor EEVDF: tiempo virtual, equidad y latenciahechoen curso
    4. 04Prioridades y clases: nice, pesos y sched_classhechoen curso
    5. 05Preempción: voluntaria, total, PREEMPT_RT y la perezosahechoen curso
  48. 47

    Nivel 47

    5 temas
    1. 01SMP: una cola de ejecución por núcleo y el arte de reequilibrarhechoen curso
    2. 02Afinidad de CPU y aislamiento de núcleos: latencia predecible por diseñohechoen curso
    3. 03Tiempo real: SCHED_FIFO, SCHED_RR y SCHED_DEADLINEhechoen curso
    4. 04cgroups: agrupar procesos para gobernar sus recursoshechoen curso
    5. 05cgroups v2 en la práctica: cpu.max, memory.max e io.maxhechoen curso
  49. 48

    Nivel 48

    5 temas
    1. 01Observabilidad del kernel: ver sin detener ni recompilarhechoen curso
    2. 02ftrace: el tracer integrado, function y function_graphhechoen curso
    3. 03Tracepoints: puntos de traza estáticos en el kernelhechoen curso
    4. 04La interfaz: tracefs y trace-cmdhechoen curso
    5. 05Eventos, filtros y latency tracershechoen curso
  50. 49

    Nivel 49

    5 temas
    1. 01kprobes: instrumentar cualquier instrucción en calientehechoen curso
    2. 02kretprobes: interceptar el retorno, y el eje estático-dinámicohechoen curso
    3. 03perf: el perfilador todo-en-unohechoen curso
    4. 04perf events: contadores de hardware y muestreo estadísticohechoen curso
    5. 05Flame graphs: el perfil de CPU de un vistazohechoen curso
  51. 50

    Nivel 50

    5 temas
    1. 01Qué es eBPF: una máquina virtual dentro del kernelhechoen curso
    2. 02El verifier: demostrar que el código ajeno es segurohechoen curso
    3. 03Tipos de programa y hooks: dónde se engancha eBPFhechoen curso
    4. 04Los mapas: estado compartido entre kernel y usuariohechoen curso
    5. 05El ecosistema: bpftrace, libbpf, CO-RE y el mundo realhechoen curso
  52. 51

    Nivel 51

    5 temas
    1. 01KASAN: shadow memory y la caza de la corrupciónhechoen curso
    2. 02KCSAN y KMSAN: carreras y memoria no inicializadahechoen curso
    3. 03kmemleak: cazar fugas de memoria del kernelhechoen curso
    4. 04Leer un oops y un panic del kernelhechoen curso
    5. 05Depuración post-mortem: kdump, crash y drgnhechoen curso
  53. 52

    Nivel 52

    5 temas
    1. 01Namespaces: aislar la vista del sistemahechoen curso
    2. 02Un contenedor a mano: namespaces mas cgroupshechoen curso
    3. 03seccomp: filtrar las syscalls de un procesohechoen curso
    4. 04El modelo de seguridad: capabilities y minimo privilegiohechoen curso
    5. 05LSM: el framework de politicas de seguridadhechoen curso
  54. 53

    Nivel 53

    5 temas
    1. 01Qué es la virtualización: hipervisores y la extensión del hardwarehechoen curso
    2. 02KVM: cómo Linux se vuelve hipervisorhechoen curso
    3. 03La API de KVM: /dev/kvm y el diálogo con QEMUhechoen curso
    4. 04virtio: el invitado que sabe que está virtualizadohechoen curso
    5. 05Contenedores frente a máquinas virtuales: aislamiento contra pesohechoen curso
  55. 54

    Nivel 54

    5 temas
    1. 01Por qué Rust en el kernel: matar la clase de bug dominantehechoen curso
    2. 02Cómo conviven Rust y C: bindings, FFI y el crate kernelhechoen curso
    3. 03Las abstracciones seguras: encapsular el unsafe una sola vezhechoen curso
    4. 04Ownership y RAII en el kernel: la muerte del goto de limpiezahechoen curso
    5. 05El estado de Rust en el kernel 2026: la transformación en marchahechoen curso
  56. 55

    Nivel 55

    5 temas
    1. 01La estructura de un módulo del kernel en Rusthechoen curso
    2. 02Un misc device en Rust: registrar y operar con seguridadhechoen curso
    3. 03Manejo de errores en el kernel: Result, el operador ? y por qué no hay panichechoen curso
    4. 04Concurrencia segura: Mutex, SpinLock, Arc y el muro de Send/Synchechoen curso
    5. 05Un driver completo en Rust: de probe a Drophechoen curso
  57. 56

    Nivel 56

    5 temas
    1. 01Preparar el parche: un cambio, un commit, un porquéhechoen curso
    2. 02A quién enviar y cómo: get_maintainer.pl y git send-emailhechoen curso
    3. 03El proceso de revisión: iterar con paciencia hasta la v-finalhechoen curso
    4. 04Los tags obligatorios: Signed-off-by, Fixes y Cc stablehechoen curso
    5. 05Tu primer parche: por dónde empezar y qué no hacerhechoen curso
  58. 57

    Nivel 57

    5 temas
    1. 01Ser mantenedor: revisar, aplicar y enviar hacia arribahechoen curso
    2. 02El ciclo de release: de la merge window a tu distrohechoen curso
    3. 03La regla sagrada: no romper el espacio de usuariohechoen curso
    4. 04Los grandes retos del kernel en 2026hechoen curso
    5. 05Tu camino desde aquíhechoen curso