← Volver a artículos
Noticias· 18 min de lectura· David Carrero Fernández-Baillo

Rust iba a salvar el kernel, pero la avalancha de arreglos de IA cae sobre el C de Linux

Montón de tirafondos y tornillos de cabeza hexagonal oxidados, mezclados con arandelas, vistos de cerca y amontonados en todas direcciones
Foto: Tom Van Dyck · Pexels

En mayo, en la conferencia Rust Week de Utrecht, Greg Kroah-Hartman abrió su charla con una frase que se ha repetido mucho desde entonces: venía a hablar de datos no fiables en Linux «y de cómo Rust nos va a salvar». Seis meses después, la ventana de integración de Linux 7.4 ha sido la más grande de la historia y una parte llamativa de ese volumen son arreglos pequeños encontrados con herramientas de IA. Casi todos tocan código en C, porque es lo que hay en el kernel: en Linux 7.3, el C y sus cabeceras suman el 98,5 % de las líneas de código fuente, y Rust, el 0,5 %.

Hemos medido el árbol nosotros mismos, contado los CVE en el repositorio del propio kernel y revisado los correos originales para separar lo que está confirmado de lo que se ha repetido sin fuente.

El fallo que más se repite: rutas de error y cerrojos

Kroah-Hartman lleva desde 2005 viendo pasar los fallos de seguridad del kernel y en su charla los resumió sin dramatismo: la mayoría son «cosas pequeñas», según las citas recogidas por ZDNet. Condiciones de error que no se comprueban, cerrojos que no se liberan, memoria que se queda sin liberar. Como ejemplo puso un fallo de Xen en el que, en una ruta de error, «se nos olvidó desbloquear».

Para quien no programe en el kernel, conviene explicarlo un poco. Una función del kernel suele pedir recursos por el camino: reserva memoria con kmalloc(), toma un mutex para que nadie más toque una estructura, incrementa un contador de referencias. Si todo va bien, al final los devuelve en orden. El problema está en las salidas anticipadas, las rutas de error: si a mitad de camino algo falla y la función hace return sin devolver lo que había cogido, se produce una fuga de memoria (esa memoria ya no la usará nadie hasta reiniciar) o, peor, un cerrojo olvidado: el mutex queda tomado y el siguiente hilo que lo pida se queda bloqueado para siempre. Si en vez de olvidar el cerrojo se accede a los datos sin tomarlo, lo que aparece es una carrera, dos hilos modificando lo mismo a la vez.

Son fallos que un revisor humano detecta mal, porque el código correcto y el incorrecto se parecen mucho y la ruta de error rara vez se ejecuta en pruebas. Kroah-Hartman lo dijo así en Utrecht: quiere que estas comprobaciones ocurran «en tiempo de compilación, no en tiempo de revisión», para no tener que preguntar en cada parche si se comprobó el valor de error o si se tomaron los cerrojos en el sitio correcto. Y lanzó una cifra que él mismo presentó como estimación: Rust eliminaría con eso «el 60 % de los fallos del kernel». Más adelante, al hablar de un tipo Untrusted para marcar los datos que llegan del espacio de usuario o del hardware, subió la apuesta con lo que llamó una «cita poco científica»: un 80 % de los CVE. Ninguna de las dos cifras sale de un estudio publicado, así que hay que leerlas como la intuición de alguien que ha visto pasar muchos parches, no como un dato.

La idea no es nueva en su boca. En febrero de 2025, en el hilo sobre la política de Rust del kernel, escribió en la lista que la mayoría de los fallos («en cantidad, no en gravedad») vienen de «los estúpidos casos extremos de C» que en Rust desaparecen: sobrescrituras de memoria, limpieza en rutas de error, valores de error sin comprobar y usos después de liberar. En el mismo correo recordaba que el kernel tiene «30 millones de líneas de C» que no se van a ir a ninguna parte.

La misma función, tres veces

Tres columnas con la misma función foo_probe: en C con goto err, un return -ENODEV recuadrado sale sin mutex_unlock ni kfree; en C con __free(kfree) y guard(mutex) cada return libera por sí solo el cerrojo y la memoria; en Rust, KBox::new y dev.state.lock() devuelven un Guard y cada salida, incluido el operador ?, hace unlock y libera al salir del ámbito
La misma función en C clásico, en C con cleanup.h y en Rust: + marca lo que se adquiere, − lo que se libera a mano y » lo que libera el compilador al cerrar el ámbito · Esquema propio

Lo más fácil es verlo con código. Este es un ejemplo simplificado, escrito para este artículo, de una función que reserva un búfer, toma un mutex, inicializa un dispositivo y lo registra. Primero, en C clásico, con el patrón goto err que se usa desde hace décadas:

static int foo_probe(struct foo_dev *fd)
{
	struct foo_buf *buf;
	int ret;

	buf = kzalloc(sizeof(*buf), GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	mutex_lock(&fd->lock);
	if (fd->dead)
		return -ENODEV;		/* FALLO: ni unlock ni kfree */

	ret = foo_hw_init(fd, buf);
	if (ret)
		goto err_unlock;

	ret = foo_register(fd, buf);
	if (ret)
		goto err_unlock;

	fd->buf = buf;
	mutex_unlock(&fd->lock);
	return 0;

err_unlock:
	mutex_unlock(&fd->lock);
	kfree(buf);
	return ret;
}

Las dos líneas marcadas son el fallo típico: alguien añade una comprobación nueva meses después, escribe un return directo en vez de goto err_unlock y la función sale con el mutex tomado y el búfer perdido. El compilador no protesta, y si fd->dead casi nunca es cierto, las pruebas tampoco.

Desde 2023 el kernel tiene otra forma de escribirlo. Peter Zijlstra añadió include/linux/cleanup.h, que se apoya en el atributo cleanup de GCC y Clang: se asocia una función de limpieza a una variable local y el compilador la llama sola cuando la variable sale de su ámbito, salga la función por donde salga. La documentación del propio fichero lo justifica en su primer párrafo: el patrón «goto error» es «conocido por introducir fugas de recursos sutiles». Con esas macros, la misma función queda así:

static int foo_probe(struct foo_dev *fd)
{
	struct foo_buf *buf __free(kfree) =
		kzalloc(sizeof(*buf), GFP_KERNEL);
	int ret;

	if (!buf)
		return -ENOMEM;

	guard(mutex)(&fd->lock);
	if (fd->dead)
		return -ENODEV;		/* unlock y kfree automáticos */

	ret = foo_hw_init(fd, buf);
	if (ret)
		return ret;

	ret = foo_register(fd, buf);
	if (ret)
		return ret;

	fd->buf = no_free_ptr(buf);	/* éxito: no liberar */
	return 0;
}

__free(kfree) llama a kfree() al salir del ámbito, guard(mutex) llama a mutex_unlock() y no_free_ptr() «desarma» la limpieza cuando el búfer debe sobrevivir a la función. Como las limpiezas se ejecutan en orden inverso a la declaración, primero se suelta el cerrojo y luego se libera la memoria. Todo esto está en cleanup.h de Linux 7.3 tal cual: DEFINE_FREE(kfree, ...) se define en ese mismo fichero y el guard de mutex en include/linux/mutex.h. La documentación avisa de una regla importante: no mezclar goto y estas macros en la misma función, porque un salto puede cruzar ámbitos de forma inesperada.

En Rust, la idea es la misma pero la impone el lenguaje. El crate kernel del árbol define Mutex<T>, y su método lock() devuelve un Guard que implementa Drop: cuando el Guard desaparece, el cerrojo se suelta. Con la memoria pasa igual, KBox libera al salir del ámbito salvo que su propiedad se haya movido a otro sitio:

fn probe(dev: &FooDev) -> Result {
    let buf = KBox::new(FooBuf::new(), GFP_KERNEL)?;

    let mut st = dev.state.lock();   // Guard<'_, State, MutexBackend>
    if st.dead {
        return Err(ENODEV);          // Drop: unlock y liberar buf
    }

    hw_init(&mut st, &buf)?;         // `?` sale con Drop igual
    register(&mut st, &buf)?;

    st.buf = Some(buf);              // se mueve: ya no se libera aquí
    Ok(())
}                                    // Drop del Guard: unlock

La diferencia de fondo está en lo que no se ve. En C, el mutex y los datos que protege son cosas separadas: nada impide leer fd->dead sin haber tomado fd->lock. En Rust, el campo dead vive dentro del Mutex<State> y la única forma de llegar a él es llamar a lock(). Kroah-Hartman lo explicó así en su charla: no puedes escribir código que acceda a esos valores sin el cerrojo, «el compilador no te deja». Rust no evita todos los errores (él mismo citó un fallo de memoria en el código Rust que pinta el código QR de los panics), pero sí esta clase concreta.

Lo que hemos medido en el árbol

Terminal en un clon de Linux v7.3: git describe devuelve v7.3 y un bucle con git ls-files y wc -l cuenta 37383 ficheros .c con 26733180 líneas, 27189 .h con 10968186, 1348 .S con 374671 y 496 .rs con 191669; total 38267706 líneas, C+h 98,52 %, ensamblador 0,98 % y Rust 0,50 %
Recuento de líneas físicas (con comentarios y blancos) por extensión en Linux 7.3 · Captura propia

Para no fiarnos de cifras de segunda mano, descargamos las etiquetas v7.3 (publicada el 18 de octubre de 2026) y v6.1 (diciembre de 2022, la primera con Rust) del árbol de Linus Torvalds y contamos con git ls-files y wc -l. El criterio: ficheros .c, .h, .S (ensamblador) y .rs, contando líneas físicas, es decir, con comentarios y líneas en blanco incluidos.

Linux 7.3 Ficheros Líneas Cuota
C (.c) 37.383 26.733.180 69,86 %
Cabeceras (.h) 27.189 10.968.186 28,66 %
Ensamblador (.S) 1.348 374.671 0,98 %
Rust (.rs) 496 191.669 0,50 %

C y cabeceras suman el 98,52 %. Si se cuentan solo líneas de código, sin comentarios ni blancos (lo hicimos con cloc), el reparto apenas cambia: 98,8 % para C y cabeceras, 0,79 % para ensamblador y 0,42 % para Rust, con 120.019 líneas de código Rust. Kroah-Hartman habló en mayo de 36 millones de líneas de C y 113.000 de Rust; nuestras cifras de 7.3 son coherentes con eso.

Otras comparaciones salen del mismo recuento:

  • Rust ha pasado de 29 ficheros y 10.359 líneas en 6.1 a 496 ficheros y 191.669 líneas en 7.3. Crece rápido, pero desde muy abajo, y buena parte son bindings para poder llamar al C existente.
  • El ensamblador está estancado: 375.330 líneas físicas en 6.1 frente a 374.671 en 7.3. En líneas de código sin comentarios es al revés, 225.827 frente a 226.541. Prácticamente plano en cuatro años.

C también aprende: guard() y __free()

Terminal en Linux v7.3: git grep encuentra 2375 ficheros .c, de 33429 fuera de tools y samples, que usan guard, scoped_guard, scoped_cond_guard o __free; el desglose de apariciones da 7061 guard, 2410 scoped_guard, 1702 __free y 61 scoped_cond_guard
Ficheros .c del kernel que ya usan las macros de cleanup.h en Linux 7.3, sin contar tools/ ni samples/ · Captura propia

La otra vía para atacar el mismo problema es llevar a C la limpieza automática sin cambiar de lenguaje, y ese camino se ha extendido bastante más deprisa que Rust. En el kernel propiamente dicho, 2.375 de los 33.429 ficheros .c (un 7,1 %) usan ya guard(), scoped_guard() o __free(), con 11.234 apariciones: 7.061 guard(), 2.410 scoped_guard(), 1.702 __free() y 61 scoped_cond_guard(). Excluimos tools/ y samples/, que son código de espacio de usuario y tienen funciones propias con esos nombres; si se cuentan, salen 2.502 de 37.383. Casi seis de cada diez de esos ficheros están en drivers/, y en 6.1, con cleanup.h aún por llegar, no había ninguno.

Kroah-Hartman reconoció en Utrecht de dónde viene la idea: «Esto se lo robamos a Rust. Gracias». Y añadió que, aunque Rust desapareciera mañana, el C del kernel ya está más limpio por haber copiado sus ideas.

Por qué la avalancha cae sobre C

Terminal en el repositorio vulns.git del CNA del kernel a 17 de noviembre de 2026: git log y awk cuentan por mes los CVE publicados que siguen vigentes, 246 en enero, 220 en febrero, 178 en marzo, 377 en abril y 1027 en mayo resaltados, 513 en junio, 835 en julio, 1643 en agosto, 2107 en septiembre, 1051 en octubre y 88 en noviembre
CVE del kernel publicados por mes en 2026, según la fecha en que cada registro entró en vulns.git · Captura propia

Que los arreglos generados con IA toquen C no tiene nada de misterioso: es donde está el código, y en particular el código viejo de controladores que nadie ha revisado a fondo en años. Las herramientas de análisis con modelos de lenguaje son buenas encontrando justo el tipo de fallo descrito arriba, una ruta de error que no libera algo, y cada hallazgo se convierte en un parche de pocas líneas.

Los datos lo reflejan. Torvalds, al publicar Linux 7.3-rc6 el 4 de octubre, escribió que el número de commits era normal «para la nueva normalidad de la IA, con muchos arreglos pequeños de manejo de rutas de error». Un mes después, la ventana de 7.4 se cerró el 1 de noviembre con casi 20.000 commits, la mayor registrada; lo contamos en Linux 7.4-rc1. La rc2, del 8 de noviembre, fue también grande.

En seguridad pasa lo mismo, porque el kernel asigna un CVE a casi cada corrección que llega a un estable (lo explicamos en la avalancha de CVE del kernel). Contando en el repositorio vulns.git del CNA del kernel la fecha en que entró cada registro que sigue publicado, a 17 de noviembre:

Mes de 2026 CVE publicados
Marzo 178
Abril 377
Mayo 1.027
Junio 513
Julio 835
Agosto 1.643
Septiembre 2.107
Octubre 1.051

De abril a mayo casi se triplica, y es justo el periodo del que habló Kroah-Hartman en Utrecht, cuando dijo venir de «un mes o dos muy largos» en la lista de seguridad.

Hay un subsistema donde el kernel ha puesto freno. El 3 de agosto, Kroah-Hartman envió a la lista un correo titulado «LLM policy for drivers/staging/ going forward». drivers/staging es el rincón del kernel pensado para que la gente nueva aprenda con limpiezas fáciles, y usar un LLM para hacerlas, escribió, va contra el sentido de que exista. Desde entonces rechaza los parches de ese directorio generados con LLM, con una excepción: un arreglo de seguridad encontrado con IA se acepta si el autor lo ha probado en el hardware real del controlador y explica cómo. Su justificación es una advertencia útil para cualquiera: incluso con las mejores herramientas, dice, «al menos 1/3» de lo que generan «es directamente erróneo o dañino».

Quién revisa todo esto

Cada parche de tres líneas cuesta poco de escribir y lo mismo de revisar que siempre. Ahí está el cuello de botella. Kroah-Hartman habló en Utrecht de más de 5.000 desarrolladores y unos 700 mantenedores, y de que el kernel optimiza para que el código sea fácil de revisar: si un parche usa guard(), el revisor ve de un vistazo que el cerrojo se suelta.

El 16 de octubre, Lorenzo Stoakes, de la gestión de memoria, escribió en la lista workflows que la carga de revisión, ya insostenible, se ha «duplicado o triplicado» con la ola de parches basura generados con IA, y que trabaja tardes y fines de semana al borde del agotamiento. En noviembre dejó de revisar fuera de las áreas que mantiene, como contamos en IA y mantenedores del kernel.

Torvalds no comparte el tono. Tres días antes, en ese mismo hilo, había respondido a otro desarrollador que no entiende «este concepto idiota de “no uses IA para X”» y, con su ironía habitual, propuso prohibir también los compiladores y los editores de texto. Su postura es que la herramienta da igual y lo que cuenta es el resultado. El problema práctico es que ese resultado lo tiene que mirar alguien.

Rust ya no es un experimento, pero no reescribe nada

En diciembre de 2025, tras la Maintainers Summit, Miguel Ojeda quitó de la documentación la sección que presentaba Rust como experimento. El commit lo resume en una frase: el experimento ha terminado, «Rust ha venido para quedarse». Eso no significa que se vaya a reescribir el kernel. Kroah-Hartman lo dejó claro en Utrecht cuando le preguntaron: nada de reescrituras salvo que seas el mantenedor del fichero, Rust para lo nuevo y el C existente, tranquilo. La excepción conocida es Binder, el mecanismo de comunicación entre procesos de Android, que tiene versión en C y en Rust a la vez y cuyos responsables piensan borrar la de C cuando la de Rust esté a la par.

Las reglas del juego se fijaron en febrero de 2025, cuando un mantenedor intentó bloquear un controlador en Rust que usaba su API. Torvalds le respondió en la lista que aquel cambio no tocaba su código y que un mantenedor manda en su código, pero no en quién usa el resultado ni cómo. Nadie está obligado a aceptar Rust en su subsistema, vino a decir, pero quien decide ignorarlo tampoco tiene voz sobre el código Rust que usa sus interfaces en C.

Rust en 7.4: cuánto entra y dónde compila

Terminal en el árbol de Torvalds: entre v7.3 y v7.4-rc1 hay 19780 commits, 18591 sin merges, y 256 de ellos tocan ficheros .rs o el directorio rust/, un 1,38 %; git grep sobre v7.3 muestra HAVE_RUST en arm, arm64, loongarch, powerpc, riscv, s390, um y x86, de 21 directorios en arch
Commits de la ventana de integración de 7.4 que tocan Rust y arquitecturas con HAVE_RUST en Linux 7.3 · Captura propia

Para 7.4, Torvalds integró los cambios de Rust de Ojeda el 21 de octubre: actualización del crate zerocopy, pruebas KUnit generadas desde los doctests, nuevos módulos mem y ratelimit en el crate kernel y otras mejoras de infraestructura. En el conjunto de la ventana, sin contar merges, 256 de los 18.591 commits (un 1,4 %) tocaron algún fichero .rs o el directorio rust/. De esos 256, 75 son del controlador nova-core para GPU NVIDIA, firmados en buena parte por ingenieros de NVIDIA como John Hubbard, Joel Fernandes o Alistair Popple; el autor con más commits es Gary Guo, con 75.

Rust no compila en todas partes. En Linux 7.3, 8 de los 21 directorios de arch/ activan HAVE_RUST: x86 (solo 64 bits), arm64 y arm (ARMv7 little endian), riscv (64 bits y con LLVM), loongarch, powerpc, s390 y um (User-Mode Linux). La tabla de Documentation/rust/arch-support.rst recoge siete; PowerPC aparece en su Kconfig pero no en esa tabla. Lo que queda fuera son arquitecturas antiguas o de nicho, como alpha, m68k, parisc, sparc o sh, que en C siguen funcionando.

El motivo es el compilador. rustc genera código con LLVM, y LLVM no tiene backend para todas las arquitecturas que soporta GCC. Hay dos caminos para cubrir el hueco: gccrs, un frontend de Rust escrito desde cero dentro de GCC, y rustc_codegen_gcc, que usa GCC como backend de rustc. Ninguno compila hoy el kernel de forma utilizable; los desarrolladores de gccrs reconocieron en la RustConf de septiembre que aún no pueden. Mientras eso no cambie, ningún componente imprescindible del kernel puede escribirse solo en Rust, y eso limita a dónde puede llegar.

Qué cambia para quien usa Linux

A corto plazo, poco que se note. Linux 7.3 será la próxima versión LTS salvo sorpresa. Kroah-Hartman lo escribió el 2 de noviembre en respuesta al anuncio de 7.4-rc1, y añadió que, si la gente intentaba «forzar» cambios en 7.4 para que fuera la LTS, esa sería la mejor razón para que no lo fuera. Es la candidata natural para las distribuciones con soporte largo que salgan en 2027, y es un kernel con el 0,5 % de Rust y miles de arreglos de rutas de error ya integrados. Con los LTS, la recomendación del propio kernel no cambia: actualizar con las versiones estables completas de la distribución en vez de perseguir CVE sueltos.

El Rust que llegue a tu máquina lo hará sobre todo a través de controladores nuevos: Binder en los Android que lo activen, el controlador Nova para GPU NVIDIA o el de la GPU de Apple Silicon que usa Asahi Linux. Si tu distribución compila el kernel con Rust habilitado, ya lo llevas; si no, no pasa nada, porque el kernel funciona igual sin él. Lo de RISC-V en 7.4 lo repasamos en Linux 7.4 y RISC-V y las versiones del kernel con sus fechas de soporte están en la ficha de Linux.

Lo que sí afecta a todos es el ritmo. Mientras la IA siga encontrando fallos en C más rápido de lo que la gente puede revisarlos, el kernel dependerá de dos cosas: de que guard() y __free() sigan extendiéndose por el código viejo y de que los pocos mantenedores que revisan no se quemen por el camino.

Fuentes: charla «Untrusted data in Linux — How Rust is going to save us» de Greg Kroah-Hartman en Rust Week 2026 (vídeo de RustNL) y crónica de ZDNet con sus citas; correo de Kroah-Hartman en «Rust kernel policy» (19-feb-2025) y respuesta de Linus Torvalds (20-feb-2025); include/linux/cleanup.h, rust/kernel/sync/lock.rs y Documentation/rust/arch-support.rst en Linux 7.3; commit «rust: conclude the Rust experiment»; merge «rust-7.4»; anuncios de Linux 7.3-rc6, Linux 7.3 y Linux 7.4-rc2; política de LLM para drivers/staging (3-ago-2026); mensaje de Lorenzo Stoakes (16-oct-2026) y respuesta de Torvalds (13-oct-2026) en el hilo «docs: remove Assisted-by references»; Kroah-Hartman sobre 7.3 como LTS (2-nov-2026); repositorio vulns.git del CNA del kernel (recuento propio a 17-nov-2026); estado de gccrs en Rust for Linux. Recuentos de líneas propios sobre las etiquetas v6.1 y v7.3 del árbol de Torvalds.