← Tornar als articles
Notícies· 18 min de lectura· David Carrero Fernández-Baillo

Rust havia de salvar el nucli, però l'allau de correccions trobades amb IA cau sobre el C de Linux

Munt de tirafons i cargols de cap hexagonal rovellats, barrejats amb volanderes, vistos de prop i amuntegats en totes direccions
Foto: Tom Van Dyck · Pexels

Al maig, a la conferència Rust Week d’Utrecht, Greg Kroah-Hartman va obrir la seva xerrada amb una frase que s’ha repetit molt des d’aleshores: venia a parlar de dades no fiables a Linux «i de com Rust ens salvarà». Sis mesos després, la finestra d’integració de Linux 7.4 ha estat la més gran de la història i una part notable d’aquest volum són correccions petites trobades amb eines d’IA. Gairebé totes toquen codi en C, perquè és el que hi ha al nucli: a Linux 7.3, el C i les seves capçaleres sumen el 98,5 % de les línies de codi font, i Rust, el 0,5 %.

Hem mesurat l’arbre nosaltres mateixos, hem comptat els CVE al repositori del mateix nucli i hem tornat als correus originals per separar el que està confirmat del que s’ha repetit sense font.

L’error que més es repeteix: camins d’error i bloquejos

Kroah-Hartman veu passar els errors de seguretat del nucli des del 2005 i a la xerrada els va resumir sense dramatisme: la majoria són «coses petites», segons les cites recollides per ZDNet. Condicions d’error que no es comproven, bloquejos que no s’alliberen, memòria que no es torna. Com a exemple va posar un error de Xen en què, en un camí d’error, «ens vam oblidar de desbloquejar».

Per a qui no programi al nucli, val la pena explicar-ho una mica. Una funció del nucli sol demanar recursos pel camí: reserva memòria amb kmalloc(), pren un mutex perquè ningú més toqui una estructura, incrementa un comptador de referències. Si tot va bé, al final els torna en ordre. El problema són les sortides anticipades, els camins d’error: si a mig camí alguna cosa falla i la funció fa return sense tornar el que havia agafat, hi ha una fuita de memòria (aquesta memòria ja no la farà servir ningú fins a reiniciar) o, pitjor, un bloqueig oblidat: el mutex queda pres i el següent fil que el demani es queda aturat per sempre. Si en lloc d’oblidar el bloqueig s’accedeix a les dades sense prendre’l, el que apareix és una condició de carrera, dos fils modificant el mateix alhora.

Són errors que un revisor humà detecta malament, perquè el codi correcte i l’incorrecte s’assemblen molt i el camí d’error poques vegades s’executa en proves. Kroah-Hartman ho va dir així a Utrecht: vol que aquestes comprovacions passin «en temps de compilació, no en temps de revisió», per no haver de preguntar a cada pedaç si s’ha comprovat el valor d’error o si s’han pres els bloquejos al lloc correcte. I va donar una xifra que ell mateix va presentar com una estimació: Rust eliminaria amb això «el 60 % dels errors del nucli». Més endavant, parlant d’un tipus Untrusted per marcar les dades que arriben de l’espai d’usuari o del maquinari, va apujar l’aposta amb el que va anomenar una «cita poc científica»: un 80 % dels CVE. Cap de les dues xifres surt d’un estudi publicat, així que cal llegir-les com la intuïció d’algú que ha vist passar molts pedaços, no com una dada.

No és la primera vegada que ho defensa. El febrer del 2025, al fil sobre la política de Rust del nucli, va escriure a la llista que la majoria dels errors («en quantitat, no en gravetat») vénen dels «estúpids casos extrems de C» que en Rust desapareixen: sobreescriptures de memòria, neteja en camins d’error, valors d’error sense comprovar i usos després d’alliberar. Al mateix correu recordava que el nucli té «30 milions de línies de C» que no se n’aniran enlloc.

La mateixa funció, tres vegades

Tres columnes amb la mateixa funció foo_probe: en C amb goto err, un return -ENODEV emmarcat surt sense mutex_unlock ni kfree; en C amb __free(kfree) i guard(mutex) cada return allibera tot sol el bloqueig i la memòria; en Rust, KBox::new i dev.state.lock() retornen un Guard i cada sortida, inclòs l'operador ?, fa unlock i allibera en sortir de l'àmbit
La mateixa funció en C clàssic, en C amb cleanup.h i en Rust: + marca el que s'adquireix, − el que s'allibera a mà i » el que allibera el compilador en tancar l'àmbit · Esquema propio

Amb codi s’entén millor. Aquest és un exemple simplificat, escrit per a aquest article, d’una funció que reserva un búfer, pren un mutex, inicialitza un dispositiu i el registra. Primer, en C clàssic, amb el patró goto err que es fa servir des de fa dècades:

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;		/* ERROR: 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;
}

Les dues línies marcades són l’error típic: algú hi afegeix una comprovació nova mesos després, escriu un return directe en lloc de goto err_unlock i la funció surt amb el mutex pres i el búfer perdut. El compilador no es queixa, i si fd->dead gairebé mai no és cert, les proves tampoc.

Des del 2023 el nucli té una altra manera d’escriure-ho. Peter Zijlstra va afegir include/linux/cleanup.h, que es recolza en l’atribut cleanup de GCC i Clang: s’associa una funció de neteja a una variable local i el compilador la crida tota sola quan la variable surt del seu àmbit, surti la funció per on surti. La documentació del mateix fitxer ho justifica al primer paràgraf: el patró «goto error» és «conegut per introduir fuites de recursos subtils». Amb aquestes macros, la mateixa funció queda així:

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 i kfree automàtics */

	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);	/* èxit: no alliberar */
	return 0;
}

__free(kfree) crida kfree() en sortir de l’àmbit, guard(mutex) crida mutex_unlock() i no_free_ptr() «desarma» la neteja quan el búfer ha de sobreviure a la funció. Com que les netejes s’executen en ordre invers a la declaració, primer s’allibera el bloqueig i després la memòria. Tot això és a Linux 7.3 tal com es veu: DEFINE_FREE(kfree, ...) es defineix al mateix cleanup.h i el guard de mutex a include/linux/mutex.h. La documentació avisa d’una regla important: no barrejar goto i aquestes macros a la mateixa funció, perquè un salt pot creuar àmbits de manera inesperada.

En Rust la idea és la mateixa, però la imposa el llenguatge. El crate kernel de l’arbre defineix Mutex<T>, i el seu mètode lock() retorna un Guard que implementa Drop: quan el Guard desapareix, el bloqueig s’allibera. Amb la memòria passa igual, KBox allibera en sortir de l’àmbit tret que la seva propietat s’hagi mogut a un altre lloc:

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 i alliberar buf
    }

    hw_init(&mut st, &buf)?;         // `?` també surt amb Drop
    register(&mut st, &buf)?;

    st.buf = Some(buf);              // es mou: ja no s'allibera aquí
    Ok(())
}                                    // Drop del Guard: unlock

La diferència de fons és en el que no es veu. En C, el mutex i les dades que protegeix són coses separades: res no impedeix llegir fd->dead sense haver pres fd->lock. En Rust, el camp dead viu dins del Mutex<State> i l’única manera d’arribar-hi és cridar lock(). Kroah-Hartman ho va explicar a la xerrada: no pots escriure codi que accedeixi a aquests valors sense el bloqueig, «el compilador no t’ho deixa fer». Rust no evita tots els errors (ell mateix va citar un error de memòria al codi Rust que dibuixa el codi QR dels panics), però sí aquesta classe concreta.

El que hem mesurat a l’arbre

Terminal en un clon de Linux v7.3: git describe retorna v7.3 i un bucle amb git ls-files i wc -l compta 37383 fitxers .c amb 26733180 línies, 27189 .h amb 10968186, 1348 .S amb 374671 i 496 .rs amb 191669; total 38267706 línies, C+h 98,52 %, assemblador 0,98 % i Rust 0,50 %
Recompte de línies físiques (amb comentaris i línies en blanc) per extensió a Linux 7.3 · Captura propia

Per no refiar-nos de xifres de segona mà, vam descarregar les etiquetes v7.3 (publicada el 18 d’octubre del 2026) i v6.1 (desembre del 2022, la primera amb Rust) de l’arbre de Linus Torvalds i vam comptar amb git ls-files i wc -l. El criteri: fitxers .c, .h, .S (assemblador) i .rs, comptant línies físiques, és a dir, amb comentaris i línies en blanc incloses.

Linux 7.3 Fitxers Línies Quota
C (.c) 37.383 26.733.180 69,86 %
Capçaleres (.h) 27.189 10.968.186 28,66 %
Assemblador (.S) 1.348 374.671 0,98 %
Rust (.rs) 496 191.669 0,50 %

C i capçaleres sumen el 98,52 %. Si es compten només línies de codi, sense comentaris ni línies en blanc (ho vam fer amb cloc), el repartiment gairebé no canvia: 98,8 % per a C i capçaleres, 0,79 % per a l’assemblador i 0,42 % per a Rust, amb 120.019 línies de codi Rust. Kroah-Hartman va parlar al maig de 36 milions de línies de C i 113.000 de Rust, cosa que encaixa amb les nostres xifres de 7.3.

Un parell de comparacions que surten del mateix recompte:

  • Rust ha passat de 29 fitxers i 10.359 línies a 6.1 a 496 fitxers i 191.669 línies a 7.3. Creix de pressa, però des de molt avall, i bona part són bindings per poder cridar el C existent.
  • L’assemblador està estancat: 375.330 línies físiques a 6.1 davant de 374.671 a 7.3. En línies de codi sense comentaris és al revés, 225.827 davant de 226.541. Pràcticament pla en quatre anys.

El C també aprèn: guard() i __free()

Terminal a Linux v7.3: git grep troba 2375 fitxers .c, de 33429 fora de tools i samples, que fan servir guard, scoped_guard, scoped_cond_guard o __free; el desglossament d'aparicions dona 7061 guard, 2410 scoped_guard, 1702 __free i 61 scoped_cond_guard
Fitxers .c del nucli que ja fan servir les macros de cleanup.h a Linux 7.3, sense comptar tools/ ni samples/ · Captura propia

L’altra via per atacar el mateix problema és portar al C la neteja automàtica sense canviar de llenguatge, i aquest camí s’ha estès força més de pressa que Rust. Al nucli pròpiament dit, 2.375 dels 33.429 fitxers .c (un 7,1 %) ja fan servir guard(), scoped_guard() o __free(), amb 11.234 aparicions: 7.061 guard(), 2.410 scoped_guard(), 1.702 __free() i 61 scoped_cond_guard(). Vam deixar fora tools/ i samples/, que són codi d’espai d’usuari amb funcions pròpies amb aquests noms; si es compten, en surten 2.502 de 37.383. Gairebé sis de cada deu d’aquests fitxers són a drivers/, i a 6.1, amb cleanup.h encara per arribar, no n’hi havia cap.

Kroah-Hartman va reconèixer a Utrecht d’on ve la idea: «Això li ho vam robar a Rust. Gràcies». I va afegir que, encara que Rust desaparegués demà, el C del nucli ja és més net per haver-ne copiat les idees.

Per què l’allau cau sobre el C

Terminal al repositori vulns.git del CNA del nucli a 17 de novembre de 2026: git log i awk compten per mes els CVE publicats que continuen vigents, 246 al gener, 220 al febrer, 178 al març, 377 a l'abril i 1027 al maig ressaltats, 513 al juny, 835 al juliol, 1643 a l'agost, 2107 al setembre, 1051 a l'octubre i 88 al novembre
CVE del nucli publicats per mes el 2026, segons la data en què cada registre va entrar a vulns.git · Captura propia

Que les correccions generades amb IA toquin C no té cap misteri: és on hi ha el codi, i sobretot el codi vell de controladors que ningú no ha revisat a fons en anys. Les eines d’anàlisi amb models de llenguatge són bones trobant justament el tipus d’error descrit més amunt, un camí d’error que no allibera alguna cosa, i cada troballa es converteix en un pedaç de poques línies.

Les dades ho reflecteixen. Torvalds, en publicar Linux 7.3-rc6 el 4 d’octubre, va escriure que el nombre de commits era normal «per a la nova normalitat de la IA, amb moltes correccions petites de gestió de camins d’error». Un mes després, la finestra de 7.4 es va tancar l’1 de novembre amb gairebé 20.000 commits, la més gran registrada; ho vam explicar a Linux 7.4-rc1. La rc2, del 8 de novembre, també va ser gran.

En seguretat passa el mateix, perquè el nucli assigna un CVE a gairebé cada correcció que arriba a una versió estable (ho vam explicar a l’allau de CVE del nucli). Comptant al repositori vulns.git del CNA del nucli la data en què va entrar cada registre que continua publicat, a 17 de novembre:

Mes del 2026 CVE publicats
Març 178
Abril 377
Maig 1.027
Juny 513
Juliol 835
Agost 1.643
Setembre 2.107
Octubre 1.051

D’abril a maig gairebé es triplica, i és just el període del qual va parlar Kroah-Hartman a Utrecht, quan va dir que venia d’«un mes o dos molt llargs» a la llista de seguretat.

Hi ha un subsistema on el nucli ha posat fre. El 3 d’agost, Kroah-Hartman va enviar a la llista un correu titulat «LLM policy for drivers/staging/ going forward». drivers/staging és el racó del nucli pensat perquè la gent nova aprengui amb neteges fàcils, i fer servir un LLM per fer-les, va escriure, va contra el sentit que existeixi. Des d’aleshores rebutja els pedaços d’aquest directori generats amb LLM, amb una excepció: una correcció de seguretat trobada amb IA s’accepta si l’autor l’ha provada al maquinari real del controlador i explica com. La seva justificació és un avís útil per a tothom: fins i tot amb les millors eines, diu, «almenys 1/3» del que generen «és directament erroni o perjudicial».

Qui revisa tot això

Cada pedaç de tres línies costa poc d’escriure i el mateix de revisar que sempre, i aquí hi ha el coll d’ampolla. Kroah-Hartman va parlar a Utrecht de més de 5.000 desenvolupadors i uns 700 mantenidors, i de com el nucli optimitza perquè el codi sigui fàcil de revisar: si un pedaç fa servir guard(), el revisor veu d’una ullada que el bloqueig s’allibera.

El 16 d’octubre, Lorenzo Stoakes, de la gestió de memòria, va escriure a la llista workflows que la càrrega de revisió, ja insostenible, s’ha «duplicat o triplicat» amb l’onada de pedaços de baixa qualitat generats amb IA, i que treballa tardes i caps de setmana fins a l’esgotament. Al novembre va deixar de revisar fora de les àrees que manté, com vam explicar a IA i mantenidors del nucli.

Torvalds no comparteix el to. Tres dies abans, en aquell mateix fil, havia respost a un altre desenvolupador que no entén «aquest concepte idiota de “no facis servir IA per a X”» i, amb la seva ironia habitual, va proposar prohibir també els compiladors i els editors de text. La seva posició és que l’eina és igual i el que compta és el resultat. El problema pràctic és que aquest resultat l’ha de mirar algú.

Rust ja no és un experiment, però no reescriu res

El desembre del 2025, després de la Maintainers Summit, Miguel Ojeda va treure de la documentació la secció que presentava Rust com a experiment. El commit ho resumeix en una frase: l’experiment s’ha acabat, «Rust ha vingut per quedar-se». Això no vol dir que s’hagi de reescriure el nucli. Kroah-Hartman ho va deixar clar a Utrecht quan l’hi van preguntar: res de reescriptures tret que siguis el mantenidor del fitxer, Rust per al que és nou i el C existent, tranquil. L’excepció coneguda és Binder, el mecanisme de comunicació entre processos d’Android, que té versió en C i en Rust alhora i els responsables del qual pensen esborrar la de C quan la de Rust estigui a l’altura.

Les regles del joc es van fixar el febrer del 2025, quan un mantenidor va intentar bloquejar un controlador en Rust que feia servir la seva API. Torvalds li va respondre a la llista que aquell canvi no tocava el seu codi i que un mantenidor mana en el seu codi, però no en qui fa servir el resultat ni com. Ningú no està obligat a acceptar Rust al seu subsistema, va venir a dir, però qui decideix ignorar-lo tampoc no té veu sobre el codi Rust que fa servir les seves interfícies en C.

Rust a 7.4: quant n’entra i on compila

Terminal a l'arbre de Torvalds: entre v7.3 i v7.4-rc1 hi ha 19780 commits, 18591 sense merges, i 256 toquen fitxers .rs o el directori rust/, un 1,38 %; git grep sobre v7.3 mostra HAVE_RUST a arm, arm64, loongarch, powerpc, riscv, s390, um i x86, de 21 directoris a arch
Commits de la finestra d'integració de 7.4 que toquen Rust i arquitectures amb HAVE_RUST a Linux 7.3 · Captura propia

Per a 7.4, Torvalds va integrar els canvis de Rust d’Ojeda el 21 d’octubre: actualització del crate zerocopy, proves KUnit generades a partir dels doctests, mòduls nous mem i ratelimit al crate kernel i altres millores d’infraestructura. En el conjunt de la finestra, sense comptar els merges, 256 dels 18.591 commits (un 1,4 %) van tocar algun fitxer .rs o el directori rust/. D’aquests 256, 75 són del controlador nova-core per a GPU NVIDIA, signats en bona part per enginyers de NVIDIA com John Hubbard, Joel Fernandes o Alistair Popple; l’autor amb més commits és Gary Guo, amb 75.

Rust no compila a tot arreu. A Linux 7.3, 8 dels 21 directoris d’arch/ activen HAVE_RUST: x86 (només 64 bits), arm64 i arm (ARMv7 little endian), riscv (64 bits i amb LLVM), loongarch, powerpc, s390 i um (User-Mode Linux). La taula de Documentation/rust/arch-support.rst en recull set; PowerPC apareix al seu Kconfig però no en aquesta taula. El que queda fora són arquitectures antigues o de nínxol, com alpha, m68k, parisc, sparc o sh, que en C continuen funcionant.

El motiu és el compilador. rustc genera codi amb LLVM, i LLVM no té backend per a totes les arquitectures que suporta GCC. Hi ha dos camins per cobrir el forat: gccrs, un frontend de Rust escrit des de zero dins de GCC, i rustc_codegen_gcc, que fa servir GCC com a backend de rustc. Cap dels dos no compila avui el nucli de manera utilitzable; els desenvolupadors de gccrs van reconèixer a la RustConf de setembre que encara no poden. Mentre això no canviï, cap component imprescindible del nucli es pot escriure només en Rust, i això limita fins on pot arribar.

Què canvia per a qui fa servir Linux

A curt termini, poca cosa que es noti. Linux 7.3 serà la propera versió LTS tret de sorpreses. Kroah-Hartman ho va escriure el 2 de novembre en resposta a l’anunci de 7.4-rc1, i va afegir que, si la gent intentava «forçar» canvis a 7.4 perquè fos la LTS, aquesta seria la millor raó perquè no ho fos. És la candidata natural per a les distribucions amb suport llarg que surtin el 2027, i és un nucli amb el 0,5 % de Rust i milers de correccions de camins d’error ja integrades. Amb les LTS, la recomanació del mateix nucli no canvia: actualitzar amb les versions estables completes de la distribució en lloc de perseguir CVE solts.

El Rust que arribi a la teva màquina ho farà sobretot a través de controladors nous: Binder als Android que l’activin, el controlador Nova per a GPU NVIDIA o el de la GPU d’Apple Silicon que fa servir Asahi Linux. Si la teva distribució compila el nucli amb Rust activat, ja el portes; si no, no passa res, perquè el nucli funciona igual sense. El que porta 7.4 per a RISC-V ho vam repassar a Linux 7.4 i RISC-V i les versions del nucli amb les dates de suport són a la fitxa de Linux.

El que sí que afecta tothom és el ritme. Mentre la IA continuï trobant errors en C més de pressa del que la gent pot revisar-ne les correccions, el nucli dependrà de dues coses: que guard() i __free() es continuïn estenent pel codi vell i que els pocs mantenidors que revisen no es cremin pel camí.

Fonts: xerrada «Untrusted data in Linux — How Rust is going to save us» de Greg Kroah-Hartman a Rust Week 2026 (vídeo de RustNL) i crònica de ZDNet amb les seves cites; correu de Kroah-Hartman a «Rust kernel policy» (19-febr-2025) i resposta de Linus Torvalds (20-febr-2025); include/linux/cleanup.h, rust/kernel/sync/lock.rs i Documentation/rust/arch-support.rst a Linux 7.3; commit «rust: conclude the Rust experiment»; merge «rust-7.4»; anuncis de Linux 7.3-rc6, Linux 7.3 i Linux 7.4-rc2; política d’LLM per a drivers/staging (3-ag-2026); missatge de Lorenzo Stoakes (16-oct-2026) i resposta de Torvalds (13-oct-2026) al fil «docs: remove Assisted-by references»; Kroah-Hartman sobre 7.3 com a LTS (2-nov-2026); repositori vulns.git del CNA del nucli (recompte propi a 17-nov-2026); estat de gccrs a Rust for Linux. Recomptes de línies propis sobre les etiquetes v6.1 i v7.3 de l’arbre de Torvalds.