Den sjätte versionen av patcharna för Linux-kärnan med stöd för språket Rust

Miguel Ojeda, författare till projektet Rust-for-Linux, har föreslagit att Linux-kärnutvecklare överväger att släppa v6-komponenter för att utveckla enhetsdrivrutiner på Rust. Detta är den sjunde revideringen av patcharna med hänsyn till den första versionen, som publicerades utan versionsnummer. Stödet för Rust ses som experimentellt, men har redan inkluderats i linux-next-grenen och är tillräckligt utvecklat för att påbörja arbetet med att skapa abstraktionslager över kärnsystemen samt för att skriva drivrutiner och moduler. Utvecklingen finansieras av Google och organisationen ISRG (Internet Security Research Group), som grundade projektet Let’s Encrypt och främjar HTTPS och utvecklingen av teknologier för att öka internets säkerhet.

I den nya versionen:

• Verktygen och versionen av biblioteket alloc, som har tagits bort från möjliga tillstånd av "panic" vid fel, har uppdaterats till release Rust 1.60, där stödet för läget "maybe_uninit_extra" stabiliserats, vilket används i patcharna för kärnan.
• Möjligheten att köra tester från dokumentationen (tester som samtidigt används som exempel i dokumentationen) har lagts till, genom att vid kompilering omvandla tester bunden till kärnans API till KUnit-tester som körs under uppstarten av kärnan.
• Krav har antagits enligt vilka tester inte får leda till varningar från lintern Clippy, precis som koden för kärnan på Rust.
• En initial implementation av modulen "net" med nätverksfunktioner har föreslagits. För Rust-kod finns tillgång till sådana nätverksstrukturer i kärnan som "Namespace" (baserad på kärnstrukturen "struct net"), SkBuff (struct sk_buff), TcpListener, TcpStream (struct socket), Ipv4Addr (struct in_addr), SocketAddrV4 (struct sockaddr_in) och deras motsvarigheter för IPv6.
• Initialt stöd för asynkron programmering (async) har implementerats i form av modulen kasync. Till exempel kan kod för att manipulera TCP-sockets i asynkront läge skapas: async fn echo_server(stream: TcpStream) -> Result { let mut buf = [0u8; 1024]; loop { let n = stream.read(&mut buf).await?; if n == 0 { return Ok(()); } stream.write_all(&buf[..n]).await?; } }
• Modulen net::filter för manipulering av nätverkspaketfilter har lagts till. Ett exempel rust_netfilter.rs med implementering av ett filter på Rust har lagts till.
• Implementeringen av en enkel mutex smutex::Mutex har lagts till, utan behov av pinning.
• En NoWaitLock-låsning har lagts till, som aldrig leder till att vänta på frigöring, och om en annan tråd tar den, ger ett felmeddelande vid försök att erhålla låsningen istället för att stoppen anroparen.
• En RawSpinLock-låsning har lagts till, som motsvarar raw_spinlock_t i kärnan, tillämpad på sektioner som inte kan befinna sig i vänteläge.
• Typen ARef har lagts till för referenser till objektet, där refcounting-mekanismen tillämpas (always-refcounted).
• I backend rustc_codegen_gcc, som möjliggör användning av libgccjit-biblioteket från GCC-projektet som kodgenerator i rustc för att stödja tillgängliga arkitekturer och optimeringar i GCC, har möjligheten för bootstrapping av rustc implementerats. Bootstrapping innebär möjligheten att använda en GCC-baserad kodgenerator i rustc för att bygga själva rustc-kompilatorn. Dessutom har nylanseringen av GCC 12.1 inkluderat korrigeringar i libgccjit, som är nödvändiga för korrekt drift av rustc_codegen_gcc. Förberedelser pågår för att möjliggöra installation av rustc_codegen_gcc via rustup-verktyget.
• Det noteras framsteg i utvecklingen av GCC-frontenden gccrs med implementeringen av en Rust-kompilator baserad på GCC. För närvarande arbetar två utvecklare med gccrs i fullt arbetsläge.

Vi påminner om att de föreslagna förändringarna ger möjlighet att använda Rust som ett andra språk för utveckling av drivrutiner och moduler för kärnan. Stödet för Rust presenteras som ett alternativ, inte aktiverat som standard och inte som en obligatorisk byggberoende för kärnan. Användningen av Rust för utveckling av drivrutiner kommer att möjliggöra skapandet av säkrare och högre kvalitetsdrivrutiner med minimala insatser, utan problem som att referera till minnesområden efter att de har frigjorts, dereferera nullpekare och överskridning av buffertgränser.

Säker minneshantering säkerställs i Rust vid kompilering genom kontroll av referenser, spårning av ägande av objekt och beaktande av objektens livstid (synlighet), samt genom utvärdering av korrekt tillgång till minnet under kodens körning. Rust tillhandahåller också verktyg för skydd mot heltalsöverflöden, kräver obligatorisk initialisering av variabelvärden innan användning, hanterar fel bättre i standardbiblioteket, tillämpar konceptet av oföränderliga (immutable) referenser och variabler som standard och erbjuder stark statisk typning för att minimera logiska fel.

Källa: opennet.ru