Rust în kernelul Linux nu mai este doar o idee experimentală discutată pe liste de dezvoltare. Infrastructura există în sursele oficiale ale kernelului, are documentație proprie și include exemple reale în directorul samples/rust/. Pentru utilizatorii avansați, partea importantă nu este „să scrii Rust” în general, ci să folosești exact mecanismele kernelului: Kconfig, kbuild, LLVM, bindgen și opțiunile oficiale de configurare.
Primul lucru de reținut este că Rust în kernel nu folosește modelul clasic de aplicație Rust cu Cargo. Lucrezi în arborele kernelului, cu regulile kernelului. Asta înseamnă că modulul este controlat prin Kconfig, construit prin kbuild și legat de configurația exactă a kernelului pe care îl compilezi.
Ce îți trebuie înainte să începi
Documentația oficială recomandă un toolchain recent și, în prezent, cea mai bine susținută cale este compilarea cu LLVM. Ai nevoie de rustc, rust-src, bindgen, rustfmt, clippy și componentele LLVM/libclang. Pe distribuțiile recente, multe dintre acestea există deja în pachetele oficiale.
Pe Debian 13, Testing sau Sid, documentația kernelului indică pachetele rustc, rust-src, bindgen, rustfmt și rust-clippy. Pe Fedora, pachetele echivalente sunt rust, rust-src, bindgen-cli, rustfmt și clippy. Pe Arch Linux, combinația uzuală este rust, rust-src și rust-bindgen.
Dacă folosești rustup, intri în directorul surselor kernelului și setezi toolchain-ul pentru acel proiect, nu global pentru tot sistemul:
rustup override set stable
rustup component add rust-src
Această abordare este utilă pentru că nu îți modifică mediul Rust din alte proiecte. Totuși, kernelul poate cere versiuni sau combinații precise, iar verificarea reală se face din arborele kernelului, nu din presupuneri.
Verificarea oficială: rustavailable
După ce ai sursele kernelului și pachetele instalate, pasul corect este verificarea cu ținta oficială:
make LLVM=1 rustavailable
Această comandă folosește aceeași logică prin care Kconfig decide dacă opțiunea RUST_IS_AVAILABLE poate fi activată. Dacă lipsește ceva, mesajul ar trebui să explice ce componentă nu este găsită sau nu este potrivită: rustc, rust-src, bindgen, libclang ori altă unealtă necesară.
Este mai bine să rezolvi aici problema decât să încerci direct compilarea. Dacă rustavailable nu trece, opțiunea CONFIG_RUST poate să nu apară deloc în meniul de configurare.
Activarea suportului Rust în kernel
Următorul pas este configurarea kernelului:
make LLVM=1 menuconfig
În meniul General setup trebuie activat Rust support, adică CONFIG_RUST. Opțiunea apare numai dacă toolchain-ul este acceptat. Apoi, pentru primul test practic, mergi la:
Kernel hacking -> Sample kernel code -> Rust samples
Acolo poți activa un modul simplu, de exemplu Minimal, ca modul încărcabil. În Kconfig, exemplul se numește SAMPLE_RUST_MINIMAL, iar modulul rezultat este rust_minimal. Acesta este un început bun pentru că nu încearcă să facă prea mult: demonstrează structura unui modul Rust, inițializarea, mesajele de kernel log și curățarea la ieșire.
Construirea primului modul
După configurare, construirea se face tot prin infrastructura kernelului:
make LLVM=1
Pentru dezvoltare, poți lucra mai concentrat pe zona de exemple, dar ideea rămâne aceeași: modulul este parte din arborele kernelului și este controlat de configurația kernelului. Fișierul samples/rust/Makefile leagă opțiunile Kconfig de obiectele construite, de exemplu CONFIG_SAMPLE_RUST_MINIMAL produce rust_minimal.o.
Exemplul oficial rust_minimal.rs definește modulul prin macro-ul module!, include nume, autori, descriere, licență GPL și parametri de modul. La inițializare, scrie mesaje în logul kernelului și creează o structură Rust. La eliminare, implementează Drop și afișează mesajul de ieșire. Pentru un prim modul, acesta este exact genul de exemplu pe care vrei să îl studiezi: mic, oficial și integrat corect.
Dacă modulul a fost construit ca .ko, testarea se face doar pe un sistem potrivit pentru dezvoltare, ideal într-o mașină virtuală, nu pe un server de producție. Încărcarea modulelor de kernel poate bloca sistemul dacă modulul are probleme, iar Rust nu elimină riscurile normale ale dezvoltării la nivel de kernel.
Ce nu trebuie presupus
Rust nu transformă automat codul de kernel în cod „sigur” în sens absolut. Ajută la reducerea unor clase de erori de memorie, dar modulul rulează tot în spațiul kernelului. O greșeală aici poate afecta întregul sistem. De asemenea, nu toate subsistemele kernelului au aceleași abstracții Rust disponibile, iar suportul depinde de arhitectură, configurație și versiunea kernelului.
Pentru un dezvoltator Linux avansat, traseul sănătos este simplu: pornești de la documentația oficială, rulezi rustavailable, activezi CONFIG_RUST, construiești exemplele din samples/rust/ și abia apoi scrii propriul cod. Așa eviți tutorialele depășite, comenzile neverificate și combinațiile fragile de toolchain.
Rust în Linux Kernel este deja suficient de matur pentru explorare serioasă, dar trebuie tratat ca orice dezvoltare de kernel: disciplinat, verificat și testat într-un mediu controlat.
