Skip to content

Latest commit

 

History

History
467 lines (318 loc) · 9 KB

slides.md

File metadata and controls

467 lines (318 loc) · 9 KB
Raw

Rust im Linux Kernel

Logo Rust For Linux

Alexander Böhm

Chemnitzer Linux Tage, 11.03.2023

Zu mir

  • Kein Kernel-Entwickler
    kleine Anpassungen & Experimente
  • Python, Java, C/C++
  • 2017 zaghafte Versuche mit Rust
  • Seit 1.5y täglich Rust

Sprachverteilung

C 98.5%, Assembly 0.8%

Quelle: https://github.com/torvalds/linux, (Datum 4.3.23)

Neben C & Assembler

  • Vereinzelte Projekte mit C++ und Ada
  • Out-Of-Tree Entwicklungen
  • 2006 Diskussion über C++:
    Absage von diversen Kernel Maintainern

Gründe gegen C++

  • Komplexität Objekt-Orientierung
  • Behandlung Sprachfunktionen?
    Exceptions, Constructor, ...
  • Unzureichende Kompilerunterstützung
  • Strittige Kompatiblität mit C
  • Notwendige Kernel-Infrastruktur

Sicherheitsaspekte

Liste von CVEs

Quelle: cve.mitre.org, linux kernel (Datum 4.3.23)

Kernel Developer zu Rust

Rust for Linux

Miguel Ojeda, Wedson Almeida Filho, Alex Gaynor:

We believe Rust offers key improvements over C in this domain.

Asahi Linux

Asahi Lina (M1 DRM Developer):

Rust is truly magical! [...] It really guides you towards not just safe but good design.

Rust

Geschichte

  • Entstanden bei Mozilla 2009:
    C/C++ zwar schnell, aber fehleranfällig
  • Einfache & sichere Parallelisierung
  • LLVM-Kompiler
    1. stabiles Release 2015
  • systemnahe Entwicklungen

Eigenschaften

  • Strenge Typisierung
  • Hohe Speichersicherheit
  • Keine Garbage Collection
  • Zero-Cost Abstraction
  • Vergleichbare C/C++-Leistung
  • Anbindung zu C

Konzepte

Wordcloud mit Konzepten

Verbesserungen

  • Beispiel: Use after free

C

// Rufe Funktion `do_something(-1)`
void* do_something(int value) {
    // Alloziiere Puffer
    void* buf = malloc(1024);
    if (value < 0) {
        free(buf);
        // Bug: return NULL vergessen
    }
    // Schreibe in Puffer
    memcpy(buf, &value, sizeof(value));
    // Gebe Pointer zurück
    return buf;
}

GCC kompiliert ohne Fehler/Warnungen

Rust

fn do_something(value: i32) -> Vec<u8> {
    // Alloziiere Puffer auf veränderlicher Variable
    let mut buf = Vec::with_capacity(1024);
    if value < 0 {
        // Gebe explizit Speicher frei
        drop(buf);
    }
    // Schreibe in Puffer
    buf.copy_from_slice(&value.to_be_bytes());
    // Gebe Pointer zurück
    return buf;
}

Kompilerfehler

error[E0382]: borrow of moved value: `buf`
 --> src/main.rs:6:5
2 |     let mut buf = Vec::with_capacity(1024);
  |         ------- move occurs because `buf` has type ...
3 |     if value < 0 {
4 |         drop(buf);
  |              --- value moved here
5 |     }
6 |     buf.copy_from_slice(&value.to_be_bytes());
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |     value borrowed here after move

Lösung erfordert Umbau

fn do_something(value: i32) -> Option<Vec<u8>> {
    let mut buf = Vec::with_capacity(1024);
    if value < 0 {
        // Gebe `buf` frei, da Scope verlassen wird
        None
    } else {
        buf.copy_from_slice(&value.to_be_bytes());
        // Übergebe Ownership von `buf` als Rückgabe
        Some(buf)
    }
}

Weg in den Kernel

Die Anfänge

  • 2012 LLVM Linux und Clang-Support
  • 2020 Linux Plumbers Conference:
    Vorschlag zum In-Tree Support von Rust

Die Idee

Rust Module Design

Quelle: Rust for Linux, Miguel Ojeda, Wedson Almeida Filho (März 2022)

6.1 LTS Kernel

  • Mitte Dezember 2022
  • Minimales Kernelmodul
  • Infrastruktur

Rust Crate Infrastruktur

Quelle: Rust for Linux, Miguel Ojeda, Wedson Almeida Filho (März 2022)

6.2er Kernel

  • Mitte Feburar 2023
  • String-Behandlung
  • Formater
  • VTables-Unterstützung

Aktuelle Entwicklungen

  • netfilter
  • Moduleparameter
  • Dateisystemanbindung
  • TCP-Server
  • Einfache Treiber (Char/Misc Device)
  • Asynchronous Resource Counter
  • Synchronisationsprimitive (Mutex, Semaphore)

Erstes Kernelmodul

Vorbereitung

  • Rust Abhängigkeiten
rustup override set 1.62.0
rustup component add rust-src
cargo install --locked --version 0.56.0 bindgen
  • LLVM/Clang Abhängigkeiten
apt-get install -y clang-11 lld-11 llvm-11

⚠️ Starke Versionsbhängigkeit ⚠️

  • Meist abgestimmt auf konkrete Rust-Version
*** Rust compiler 'rustc' is too new.
    This may or may not work.
***   Your version:     1.67.1
***   Expected version: 1.62.0
  • Führt teilweise zu Fehlern
error: the feature `core_ffi_c` has been stable since 1.64.0
       and no longer requires an attribute to enable

Rust Support aktivieren

General Setup -> Rust Support

Beispiele aktivieren

Kernel hacking -> Sample kernel code -> Rust samples

Modul definieren

// SPDX-License-Identifier: GPL-2.0
//! Rust module for CLT 2023
use kernel::prelude::*;

module! {
    type: RustCltModule,
    name: "rust_clt_module",
    author: "Alexander Böhm",
    description: "Rust Module for CLT 2023",
    license: "GPL v2",
}

struct RustCltModule { name: &'static CStr }

Initialisierung implementieren

impl kernel::Module for RustCltModule {
    fn init(
        name: &'static CStr,
        _module: &'static ThisModule
    ) -> Result<Self> {
        pr_info!("Hello CLT 2023 from kernel module {name}!");
        Ok(Self { name })
    }
}

Unloading implementieren

impl Drop for RustCltModule {
    fn drop(&mut self) {
        pr_info!("Goodbye from kernel module {}!",
                 self.name);
    }
}

Kernel bauen

make LLVM=1 bzImage modules

Modul ausprobieren

[    1.023889] rust_clt_module: Hello CLT 2023 from kernel 
               module rust_clt_module!
[    1.025889] rust_clt_module: Goodbye from kernel module
               rust_clt_module!

Aussicht & TODOs

Kernel

  • Keine Reimplementierung
  • Weitere Abstraktionen für Subsysteme
  • Testing
  • Tooling & Infrastruktur
  • Offene Fragen bzgl. Distribution
  • Weitere Architekturen (aarch64)

Aussichtsreiche Module

Für Rust

  • Abstimmung
  • Eigene Primitive (bspw. Arc)
  • Kompiler-Anpassung

GCCRS

  • Frontend für GCC
  • Erste experimentele Version
    für GCC 13.1
  • 2023: Test Suite v1.49 bestehen
  • Kein Borrow-Checker
  • Ermöglicht mehr Architekturen
  • Zugriff auf GCC-Tooling

Fazit

  • Rust ist im Kernel angelangt
  • Schnelle Entwicklung
  • Potentiale für sicheren Code
  • Zahlreiche offene Themen



Folien & Beispiele: https://github.com/aboehm/CLT2023-rust-im-linux-kernel

Quellen/Referenzen