Historia del kernel Linux: decisiones que aún importan
Recorre Linux desde 0.01 hasta 7.x y explica cómo la GPL, el debate del microkernel, Git y el modelo LTS siguen afectando a los servidores.
Historia breve del kernel de Linux
La historia del kernel de Linux abarca desde la versión 0.01, publicada en septiembre de 1991, hasta la serie 7.x, que actualmente arranca en servidores. La lista de versiones es la parte menos interesante. Un número reducido de decisiones definió su estructura, y cada una todavía tiene consecuencias en una máquina que alquile esta tarde. El motivo por el que en 1991 hacía falta un kernel nuevo pertenece a la historia más amplia de Unix, las licencias de AT&T y el litigio que paralizó BSD.
Las fechas y los números de versión proceden de kernel.org y del historial de versiones que publica. Estado actual a 13 de noviembre de 2026: la versión 7.0 llegó el 12 de abril de 2026, la 7.1 el 14 de junio de 2026, la 7.2 a mediados de agosto de 2026 y la 7.3 el 18 de octubre de 2026. kernel.org muestra 7.4-rc2 como versión principal y 7.3.4 como versión estable actual. La rama 7.2 llegó al final de su vida útil con 7.2.15 el 1 de noviembre de 2026.
Por qué sigue siendo importante la elección de la GPL en 1992
La versión 0.01 se publicó el 17 de septiembre de 1991 con una licencia que Torvalds había escrito personalmente. Exigía distribuir el código fuente y añadía una línea aún más importante: "No puede distribuir esto a cambio de una tarifa, ni siquiera por los costes de 'gestión'". En 1991, el software se distribuía en disquetes, y copiar y enviar disquetes costaba dinero. Esa cláusula hacía imposible una distribución comercial de Linux.
La cambió. El paso a la GNU General Public License (GPL) se anunció en las notas de la versión 0.12 en enero de 1992 y entró en vigor el 1 de febrero de 1992. La versión 0.95, en marzo de 1992, fue la primera publicada bajo esa licencia. Todo negocio construido posteriormente sobre Linux depende de ese cambio.
El kernel está sujeto únicamente a la versión 2 de la GPL y nunca pasó a la versión 3. Torvalds se negó en 2007, principalmente por la regla contra la tivoización de GPLv3. Esta regla exige proporcionar la información necesaria para instalar versiones modificadas del código cubierto que se distribuya con un dispositivo de consumo, salvo que ni el proveedor ni terceros puedan instalar código modificado, como ocurre con el código instalado en ROM. Consideraba que el hardware bloqueado era una decisión comercial del fabricante. En 2017, los desarrolladores del kernel publicaron el Kernel Enforcement Statement, que adopta de todos modos un elemento de GPLv3: quien recibe un primer aviso de infracción por parte del titular de los derechos de autor y la corrige en un plazo de 30 días recupera su licencia de forma permanente, en lugar de perderla con la primera infracción.
En un servidor se derivan dos consecuencias. El binario del kernel que arranca incluye el derecho a obtener el código fuente correspondiente, por lo que nadie puede entregarle un kernel de Linux que no pueda inspeccionar o recompilar. Además, el aviso de derechos de autor del kernel indica que la licencia no cubre los programas de usuario que utilizan los servicios del kernel mediante llamadas normales al sistema. Por eso las bases de datos propietarias y los agentes de monitorización se distribuyen para Linux sin infringir la licencia. Una licencia permisiva genera una presión opuesta, y conviene entender esta diferencia antes de elegir una plataforma: consulte Linux y FreeBSD como plataformas de servidor.
Por qué el kernel monolítico se impuso en la práctica
El 29 de enero de 1992, Andrew Tanenbaum publicó un mensaje titulado "LINUX is obsolete" en el grupo de noticias comp.os.minix. Hizo dos afirmaciones. Los kernels monolíticos, en los que los controladores y los sistemas de archivos se ejecutan dentro de un único espacio de direcciones privilegiado, eran un diseño de la década de 1970, mientras que los microkernels, en los que esas partes se ejecutan como procesos normales, eran el futuro. Además, Linux estaba ligado al Intel 386, por lo que nunca sería portable.
La afirmación sobre la portabilidad se respondió mediante ports. Cuando se lanzó la versión 1.2 en marzo de 1995, todavía estaban en curso los ports para DEC Alpha, MIPS, SPARC y la familia Motorola 68000. La versión 2.0, publicada en junio de 1996, fue la primera release estable compatible con Alpha de 64 bits además del 386, y a principios de 1997 SPARC ya se había incorporado como port integrado.
La afirmación sobre el diseño se respondió con un compromiso. Linux nunca se convirtió en un microkernel. Incorporó módulos de kernel cargables: archivos objeto que se insertan en un kernel en ejecución y se vuelven a retirar, de modo que un controlador se distribuye por separado del binario del kernel.
lsmod | head
modinfo virtio_net | head -5lsmod muestra lo que está cargado en este momento. modinfo muestra el archivo del que procede el módulo y los parámetros que acepta. En un servidor virtual, gran parte de la pila de almacenamiento y red está formada por módulos. Por eso una sola imagen del kernel arranca en hardware que nunca ha visto. El kernel sólo anuncia el hardware nuevo. Después, un daemon de user space decide qué módulo cargar y qué nombre asignar al dispositivo. Así, la gestión de dispositivos pasó a formar parte del sistema init. Esto también explica en parte por qué systemd se volvió difícil de evitar.
Los módulos aportaron esa flexibilidad sin asumir el coste del diseño de microkernel. Aislar un controlador en su propio proceso implica pagar el coste de un cambio de contexto y de un mensaje en cada llamada. En 1992, ese coste era elevado.
El coste que Linux conserva es el que debe tenerse en cuenta: un módulo se ejecuta con privilegios completos del kernel. Por tanto, un módulo defectuoso puede dejar fuera de servicio toda la máquina, en lugar de un solo proceso. El problema se hace evidente con los módulos externos al árbol principal. Un controlador de un proveedor que no forma parte del kernel mainline debe recompilarse para cada kernel nuevo. Eso es lo que hace DKMS durante una actualización. Si esa compilación falla, el dispositivo simplemente no está disponible después del reinicio.
Por qué SMP tardó quince años en completarse
Linux 2.0, en junio de 1996, fue el primer kernel estable compatible con el multiprocesamiento simétrico (SMP), es decir, con más de una CPU ejecutando un kernel. La primera implementación usaba un único bloqueo, el big kernel lock (BKL), por lo que sólo un procesador podía estar dentro del código del kernel en cada momento. Por tanto, una segunda CPU ayudaba a una carga de trabajo que calculaba en user space, pero ayudaba muy poco a una carga de trabajo compuesta por llamadas al sistema, porque estas quedaban en cola detrás del mismo bloqueo.
Eliminar ese bloqueo tardó quince años. Los usuarios restantes se convirtieron a bloqueos de grano fino, en gran medida gracias a Arnd Bergmann, y el BKL se eliminó en 2.6.39, publicado el 18 de mayo de 2011. El scheduler avanzó en la misma escala temporal: el scheduler O(1) en 2.6.0, el Completely Fair Scheduler (CFS) desde 2.6.23 en 2007 y EEVDF, que sustituyó a CFS en 6.6 en octubre de 2023.
Ese trabajo explica por qué un plan de 4 vCPU resulta normal actualmente. También señala un límite que conviene conocer. En un servidor virtual compartido, el kernel programa tus hilos y el hypervisor programa tu kernel. Ejecuta top y lee el campo %st. El steal time es el tiempo de CPU que tu kernel estaba listo para utilizar y que el host asignó a otro guest, por lo que ningún ajuste dentro de tu kernel puede recuperarlo.
Por qué la serie 2.6 cambió la forma de compilar el kernel
Antes de 2.6, los números de versión se dividían en pares. Un segundo número par indicaba una serie estable (2.4); uno impar indicaba desarrollo (2.5). 2.4 se publicó el 4 de enero de 2001 y 2.6 el 17 de diciembre de 2003, por lo que los usuarios esperaron casi tres años hasta la siguiente serie estable. Las distribuciones no podían esperar y aplicaban backports. Dos proveedores que distribuían "2.4" podían entregar kernels con miles de parches de diferencia.
La separación se abandonó después de 2.6. Ahora mainline abre una ventana de integración de unas dos semanas, incorpora trabajo nuevo, ejecuta release candidates hasta que el desarrollo se estabiliza y publica una versión cada 9 o 10 semanas, según la cadencia que kernel.org sigue documentando. La otra mitad del modelo llegó el 4 de marzo de 2005 con la primera versión del stable tree: una actualización que sólo incluía correcciones para 2.6.11, mantenida por Greg Kroah-Hartman y Chris Wright. El stable tree acepta correcciones y rechaza funcionalidades.
Un efecto secundario fue que el número de versión dejó de ser una garantía. 3.0, 4.0, 5.0 y 7.0 no son reescrituras. Torvalds aumenta el primer número cuando el segundo crece lo suficiente como para molestarlo; por eso 7.0 siguió a 6.19 en abril de 2026. Para un servidor, lo importante es qué rama sigue la distribución y si esa rama todavía recibe correcciones.
Cómo la ruptura con BitKeeper dio lugar a git en abril de 2005
Desde febrero de 2002, el kernel se desarrollaba en BitKeeper, un sistema propietario de control de versiones distribuido de la empresa BitMover, de Larry McVoy, a partir de la serie 2.5. BitMover concedió a los desarrolladores del kernel una licencia gratuita con condiciones: no podían trabajar en una herramienta de control de versiones competidora ni aplicar ingeniería inversa a BitKeeper. A muchos desarrolladores no les gustaba crear un kernel libre con una herramienta cuyo código no podían leer.
La ruptura se produjo en abril de 2005, después de que Andrew Tridgell demostrara un programa que se comunicaba con repositorios de BitKeeper. BitMover consideró que eso era ingeniería inversa y retiró la licencia gratuita. El kernel perdió su sistema de control de versiones en mitad de un ciclo de desarrollo.
El trabajo en git comenzó en abril de 2005. Torvalds anunció la ruptura con BitKeeper el 6 de abril. El 7 de abril, git ya se gestionaba a sí mismo, lo que significa que su propio historial ya se almacenaba en git. Torvalds anunció la primera fusión correcta con git el 17 de abril. En junio de 2005, git gestionó el lanzamiento de 2.6.12. Poco después, Torvalds dejó el mantenimiento en manos de Junio Hamano y volvió al kernel.
El diseño surgió directamente del problema: miles de colaboradores y mantenedores que extraen cambios unos de otros a través de una red en la que nadie confía. Cada objeto recibe como nombre el hash de su contenido, por lo que cambiar un solo byte del historial antiguo cambia el nombre de cada commit posterior. Por eso, un clon es una prueba y no una afirmación. Cada pipeline de despliegue, cada repositorio de configuración, el host de código al que suben cambios la mayoría de los equipos y el servidor git que puede ejecutar usted mismo surgieron de una disputa sobre licencias relacionada con un kernel.
Lo que promete el modelo LTS y lo que no
Mainline no es lo que se ejecuta. Una versión mainline queda sustituida entre 9 y 10 semanas después. El árbol estable incorpora correcciones hasta la siguiente versión mainline, salvo que una rama se mantenga como longterm. Las ramas longterm, normalmente denominadas LTS, incorporan correcciones durante años y son las que utilizan muchas distribuciones como base.
2.6.32, publicada en diciembre de 2009, es donde el modelo demostró su eficacia. RHEL 6, Debian 6, SUSE Linux Enterprise 11 SP1 y Ubuntu 10.04 LTS la incluyeron, y la rama se mantuvo hasta marzo de 2016, más de seis años después de su aparición. Red Hat fue aún más lejos y mantuvo su kernel basado en 2.6.32 con sus propios backports hasta que RHEL 6 salió de su fase de mantenimiento en 2020. Además, todavía vende correcciones de seguridad seleccionadas y correcciones urgentes de errores para RHEL 6 mediante un complemento Long-Life de pago, con contratos anuales que llegan hasta finales de 2030. Reproducir gratis esa década de soporte es el motivo de que existiera CentOS y de que Rocky Linux y AlmaLinux lo sustituyeran.
La promesa ha cambiado más de una vez. Primero fueron dos años y después seis años para algunas ramas. En 2023, los mantenedores de stable redujeron de nuevo el valor predeterminado a dos años, porque adaptar correcciones a árboles antiguos consume tiempo de los mantenedores y las ramas antiguas reciben pocas pruebas reales. El 25 de febrero de 2026, Greg Kroah-Hartman volvió a publicar proyecciones más largas, después de hablar con las empresas que dependen de esas ramas, pero los nuevos kernels longterm todavía suelen comenzar con una fecha de fin de vida proyectada a dos años.
Los datos de este gráfico
[
{
"kernel": "5.10",
"released": "2020-12-13",
"eol_projected": "Dec 2026",
"maintained_for": 6.0
},
{
"kernel": "5.15",
"released": "2021-10-31",
"eol_projected": "Dec 2026",
"maintained_for": 5.1
},
{
"kernel": "6.1",
"released": "2022-12-11",
"eol_projected": "Dec 2027",
"maintained_for": 5.0
},
{
"kernel": "6.6",
"released": "2023-10-29",
"eol_projected": "Dec 2027",
"maintained_for": 4.2
},
{
"kernel": "6.12",
"released": "2024-11-17",
"eol_projected": "Dec 2028",
"maintained_for": 4.1
},
{
"kernel": "6.18",
"released": "2025-11-30",
"eol_projected": "Dec 2028",
"maintained_for": 3.1
}
]kernel.org muestra 6 ramas longterm a fecha de octubre de 2026. La más antigua, 5.10, habrá incorporado correcciones durante 6.0 años cuando llegue a su fin en Dec 2026. La más reciente, 6.18, tiene previsto mantenerse hasta Dec 2028, lo que representa 3.1 años de correcciones.
Interprete esas fechas como proyecciones, no como un contrato. Las proyecciones de 6.6 y 6.12 se ampliaron en febrero de 2026, y una rama que nadie utilice puede eliminarse en su lugar. Normalmente, su distribución toma la decisión por usted: Debian 13 incluye 6.12 y Ubuntu 26.04 LTS incluye 7.0. Esa diferencia es el contenido práctico de la cuestión de LTS frente a una versión intermedia en un servidor, y es lo que realmente cambia por debajo cuando actualiza Ubuntu 24.04 a 26.04.
De aquí se deriva una trampa. uname -r en Ubuntu 24.04 muestra algo parecido a 6.8.0-51-generic. Eso es una base upstream más los backports propios de la distribución, por lo que el número indica dónde comenzó la rama y no qué correcciones contiene. Los escáneres que evalúan un kernel por su cadena de versión generan alertas falsas contra los kernels de las distribuciones exactamente por este motivo.
De qué está discutiendo el kernel ahora mismo
Hay dos debates abiertos, y ambos tratan sobre quién debe hacer el trabajo.
Rust se incorporó como infraestructura en la versión 6.1, en diciembre de 2022. En la versión 7.0 se eliminó la etiqueta experimental, por lo que los lenguajes principales del kernel son C, ensamblador y Rust. La compilación con un compilador Rust estable ya era compatible en la versión 6.1: su Makefile establece RUSTC_BOOTSTRAP=1 para habilitar funciones inestables en compiladores estables. El debate trata sobre el mantenimiento. Un mantenedor de C que cambia una interfaz puede romper enlaces de Rust que no revisa, y la discusión gira en torno a quién debe repararlos.
El segundo debate trata sobre las contribuciones generadas con IA. Sasha Levin propuso una política en julio de 2025, después de que un volumen creciente de parches asistidos por máquinas llegara a las listas. El documento se incorporó el 6 de enero de 2026 y ahora forma parte de la documentación del propio proceso del kernel en docs.kernel.org/process/coding-assistants.html. Un agente de IA no debe añadir una etiqueta Signed-off-by, porque esa línea certifica el Developer Certificate of Origin (DCO) y sólo una persona puede certificarlo. La documentación actual del kernel ya no exige una etiqueta Assisted-by y, en su lugar, remite a los colaboradores a las directrices sobre contenido generado por herramientas. Aun así, se espera que los colaboradores expliquen el uso de herramientas en las cartas de presentación y los registros de cambios. El código generado debe ser compatible con GPL-2.0-only. La persona que envía el parche lo revisa y asume la responsabilidad correspondiente.
La presión que motiva la política es el tiempo de revisión. Generar un parche lleva segundos, mientras que revisarlo puede ocupar toda la tarde de un mantenedor. Una etiqueta no corrige ese desequilibrio. La aprobación humana conserva la procedencia: el historial sigue registrando quién firmó cada cambio, que es precisamente la propiedad que el DCO se creó para proteger en 2004.
Qué significa este historial para el servidor que alquila
- La licencia permite leer y reconstruir el kernel que arranca el proveedor, y explica por qué el software propietario sigue ejecutándose en él.
- El diseño monolítico explica por qué un error en un controlador puede apagar toda la máquina, y por qué un módulo externo al árbol debe reconstruirse con cada actualización del kernel.
- El modelo de versiones explica por qué el número de versión aporta poca información, mientras que la rama y su fecha de fin de vida útil indican casi todo.
- El tipo de virtualización determina qué puede hacer: en KVM arranca su propio kernel y carga módulos, mientras que en la virtualización basada en contenedores, que comparte el kernel del host,
uname -rmuestra la versión del host, y el permiso para usarmodprobeo cambiar sysctls depende de los privilegios y la configuración que conceda el host.
FAQ
¿Por qué el kernel de Linux sigue bajo GPLv2 y no bajo GPLv3?
Torvalds descartó GPLv3 en 2007, principalmente por su requisito contra la tivoización. Este requisito exige proporcionar la información necesaria para instalar versiones modificadas del código cubierto cuando este se distribuye con un dispositivo de consumo, salvo que ni el proveedor ni terceros puedan instalar código modificado, como ocurre con el código instalado en ROM. Considera que el hardware bloqueado forma parte del negocio del fabricante. Además, relicenciarlo es prácticamente imposible, porque los derechos de autor del kernel pertenecen a miles de colaboradores y no existe un acuerdo de cesión al que recurrir. El kernel se distribuye únicamente bajo GPL-2.0-only, por lo que el código ofrecido únicamente bajo GPLv3 no se puede integrar.
¿El kernel de Linux es monolítico o es un microkernel?
Es monolítico y admite módulos cargables. Los controladores y los sistemas de archivos se ejecutan dentro del espacio de direcciones del kernel, y lsmod muestra cuáles están cargados en ese momento. El resultado ofrece velocidad, por un lado, y un mayor alcance de los fallos, por otro: un módulo defectuoso puede provocar un panic en toda la máquina, mientras que un microkernel perdería un solo proceso. Esta diferencia se ha reducido desde 1992 gracias a los sistemas de archivos FUSE en el espacio de usuario y a los programas eBPF que el kernel verifica antes de ejecutarlos.
¿Cuál es la diferencia entre los kernels mainline, stable y longterm?
Mainline es el árbol de Torvalds. Se publica cada 9 a 10 semanas y las nuevas funciones llegan primero allí. Stable toma una versión mainline y recibe correcciones de errores hasta la siguiente versión mainline, salvo que la rama se mantenga como longterm. Las ramas longterm siguen recibiendo correcciones durante años y muchas distribuciones basan sus kernels en ellas. kernel.org muestra las ramas longterm actuales y la fecha prevista de fin de vida de cada una.
¿El kernel de Linux acepta código escrito por una IA?
Sí, conforme a una política adoptada en enero de 2026. La documentación actual del kernel ya no exige una etiqueta Assisted-by. Se espera que los colaboradores expliquen el origen del contenido generado por herramientas en las cartas de presentación y los changelogs. Un agente de IA no debe añadir una línea Signed-off-by, y el código generado debe ser compatible con GPL-2.0-only. La persona que presenta el cambio firma el envío. Esto significa que revisó el parche y asume la responsabilidad correspondiente conforme al Developer Certificate of Origin.
¿Qué versión del kernel debería ejecutar en un servidor?
En casi todos los casos, la que mantenga su distribución. El kernel de una distribución es una rama upstream con correcciones incorporadas desde versiones posteriores y las pruebas del proveedor. Es la versión que dan por supuesta las imágenes de su proveedor y sus acuerdos de soporte. Compile un kernel mainline más reciente cuando necesite un controlador o una función concretos. Antes de adoptarlo, compruebe la fecha de fin de vida de la rama a la que va a migrar.