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

- **Publicat el:** 2026-11-17
- **Categoria:** Notícies
- **Pàgina original:** https://linuxgratis.com/ca/articles/linux-7-4-rust-c-ia-correccions

Greg Kroah-Hartman diu que Rust evitaria bona part dels errors del nucli, però a Linux 7.3 el 98,5 % de les línies continuen sent C. Hem mesurat l'arbre, comptat els CVE i escrit la mateixa funció en C clàssic, en C amb guard()/__free() i en Rust per explicar per què els pedaços generats amb IA acaben en C i què suposa per a qui revisa i per a qui fa servir Linux.

---

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

<figure>
  <img src="/articles/linux-7-4-rust-c-ia/tres-versiones-c-guard-rust.webp" alt="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" loading="lazy" decoding="async">
  <figcaption>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</figcaption>
</figure>


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:

```c
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í:

```c
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:

```rust
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

<figure>
  <img src="/articles/linux-7-4-rust-c-ia/linux-7-3-lineas-wc.webp" alt="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 %" loading="lazy" decoding="async">
  <figcaption>Recompte de línies físiques (amb comentaris i línies en blanc) per extensió a Linux 7.3 · Captura propia</figcaption>
</figure>


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()

<figure>
  <img src="/articles/linux-7-4-rust-c-ia/linux-7-3-guard-free.webp" alt="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" loading="lazy" decoding="async">
  <figcaption>Fitxers .c del nucli que ja fan servir les macros de cleanup.h a Linux 7.3, sense comptar tools/ ni samples/ · Captura propia</figcaption>
</figure>


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

<figure>
  <img src="/articles/linux-7-4-rust-c-ia/vulns-cve-2026-meses.webp" alt="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" loading="lazy" decoding="async">
  <figcaption>CVE del nucli publicats per mes el 2026, segons la data en què cada registre va entrar a vulns.git · Captura propia</figcaption>
</figure>


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](/ca/articles/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](/ca/articles/cve-kernel-linux-allau-cna)). 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](/ca/articles/ia-mantenidors-nucli-stoakes-git-votacio).

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

<figure>
  <img src="/articles/linux-7-4-rust-c-ia/linux-7-4-ventana-rust.webp" alt="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" loading="lazy" decoding="async">
  <figcaption>Commits de la finestra d'integració de 7.4 que toquen Rust i arquitectures amb HAVE_RUST a Linux 7.3 · Captura propia</figcaption>
</figure>


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](/ca/articles/linux-7-4-risc-v) i les versions del nucli amb les dates de suport són a la [fitxa de Linux](/ca/linux-kernel).

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»](https://www.youtube.com/watch?v=Nzmj7K0FNRY) de Greg Kroah-Hartman a Rust Week 2026 (vídeo de RustNL) i [crònica de ZDNet](https://www.zdnet.com/article/rust-will-save-linux-from-ai-says-greg-kroah-hartman/) amb les seves cites; [correu de Kroah-Hartman a «Rust kernel policy»](https://lore.kernel.org/all/2025021954-flaccid-pucker-f7d9@gregkh/) (19-febr-2025) i [resposta de Linus Torvalds](https://lore.kernel.org/all/CAHk-=wgLbz1Bm8QhmJ4dJGSmTuV5w_R0Gwvg5kHrYr4Ko9dUHQ@mail.gmail.com/) (20-febr-2025); [include/linux/cleanup.h](https://github.com/torvalds/linux/blob/v7.3/include/linux/cleanup.h), [rust/kernel/sync/lock.rs](https://github.com/torvalds/linux/blob/v7.3/rust/kernel/sync/lock.rs) i [Documentation/rust/arch-support.rst](https://docs.kernel.org/rust/arch-support.html) a Linux 7.3; [commit «rust: conclude the Rust experiment»](https://github.com/torvalds/linux/commit/9fa7153c31a3e5fe578b83d23bc9f185fde115da); [merge «rust-7.4»](https://github.com/torvalds/linux/commit/12d5fc96ebbb3b948861805b32a4c3a96105ccd9); anuncis de [Linux 7.3-rc6](https://lore.kernel.org/all/CAHk-=wgYMaZik+wZYTE1bv7x5OUNsorG0WU16gFSZpX4TomMbQ@mail.gmail.com/), [Linux 7.3](https://lore.kernel.org/all/CAHk-=wgwnBm2zDdRM7u016NVHkv9KqbZW7AZ=8wZrqGyv_V+5A@mail.gmail.com/) i [Linux 7.4-rc2](https://lore.kernel.org/all/CAHk-=wgAHC=GJMQm7DM0iJgUCsaMpYJ1zO2FW_+FQLcGzfYZzg@mail.gmail.com/); [política d'LLM per a drivers/staging](https://lore.kernel.org/all/2026080354-skater-urgent-31b2@gregkh/) (3-ag-2026); [missatge de Lorenzo Stoakes](https://lore.kernel.org/all/atI_TSQXzAQFWBfx@gremlin/) (16-oct-2026) i [resposta de Torvalds](https://lore.kernel.org/all/CAHk-=whTs09_ozN+e09GU68N1wPP56MUzDjrg9rnKxQUa0A_4Q@mail.gmail.com/) (13-oct-2026) al fil «docs: remove Assisted-by references»; [Kroah-Hartman sobre 7.3 com a LTS](https://lore.kernel.org/all/2026110241-yarn-tweak-084d@gregkh/) (2-nov-2026); [repositori vulns.git](https://git.kernel.org/pub/scm/linux/security/vulns.git/) del CNA del nucli (recompte propi a 17-nov-2026); [estat de gccrs a Rust for Linux](https://rust-for-linux.com/gccrs). Recomptes de línies propis sobre les etiquetes v6.1 i v7.3 de l'[arbre de Torvalds](https://github.com/torvalds/linux).
