Rust (Programmiersprache) - Versionsgeschichte

--: Herausstellen, dass sich die Aussagen und Quellen ausdrücklich auf den Linuxkernel beziehen

2025-04-09T08:30:05Z

Herausstellen, dass sich die Aussagen und Quellen ausdrücklich auf den Linuxkernel beziehen

← Nächstältere Version		Version vom 9. April 2025, 10:30 Uhr
Zeile 245:		Zeile 245:
	Der Linuxkernel enthält {{FormatNum\|25000\|de}} Zeilen Rustcode bei {{FormatNum\|34000000\|de}} Zeilen C-Code, Rust macht somit erst 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf \|titel=Rust and Linux \|datum=2025-04-01 \|abruf=2025-04-09}}</ref>		Der Linuxkernel enthält {{FormatNum\|25000\|de}} Zeilen Rustcode bei {{FormatNum\|34000000\|de}} Zeilen C-Code, Rust macht somit erst 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf \|titel=Rust and Linux \|datum=2025-04-01 \|abruf=2025-04-09}}</ref>

	Für ~~Entwickler~~ bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>		Für Kernelentwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

	Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ \|titel=Rust kernel policy \|abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Compilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler.<ref name=":2" />		Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ \|titel=Rust kernel policy \|abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Compilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler im Linuxkernel.<ref name=":2" />

	Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>		Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>

--: /* Linux Kernel */ LoC in Rust/C, Details zur Fehlerprävention durch Rust

2025-04-09T08:17:50Z

Linux Kernel: LoC in Rust/C, Details zur Fehlerprävention durch Rust

← Nächstältere Version		Version vom 9. April 2025, 10:17 Uhr
Zeile 243:		Zeile 243:

	==== Linux Kernel ====		==== Linux Kernel ====
			Der Linuxkernel enthält {{FormatNum\|25000\|de}} Zeilen Rustcode bei {{FormatNum\|34000000\|de}} Zeilen C-Code, Rust macht somit erst 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf \|titel=Rust and Linux \|datum=2025-04-01 \|abruf=2025-04-09}}</ref>

			Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

			Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ \|titel=Rust kernel policy \|abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Compilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler.<ref name=":2" />

	Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>		Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>

	Erst mit den folgenden Kerneln wurden Module und mehrere Updates der [[Toolchain]] gemacht, um dem produktiven Einsatz näher zu kommen und zukünftig näher an der aktuellen Entwicklung von Rust zu sein.<ref>{{Internetquelle \|url=https://www.phoronix.com/news/Rust-For-Linux-6.5 \|titel=Linux 6.5 Upgrading The Rust Toolchain, New Modules Added \|sprache=en \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|url=https://www.phoronix.com/news/Linux-6.7-Rust \|titel=Rust WQ Abstractions, Rust Toolchain Upgrade & Android Kernel Builds For Linux 6.7 \|sprache=en \|abruf=2023-11-04}}</ref>		Erst mit den folgenden Kerneln wurden Module und mehrere Updates der [[Toolchain]] gemacht, um dem produktiven Einsatz näher zu kommen und zukünftig näher an der aktuellen Entwicklung von Rust zu sein.<ref>{{Internetquelle \|url=https://www.phoronix.com/news/Rust-For-Linux-6.5 \|titel=Linux 6.5 Upgrading The Rust Toolchain, New Modules Added \|sprache=en \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|url=https://www.phoronix.com/news/Linux-6.7-Rust \|titel=Rust WQ Abstractions, Rust Toolchain Upgrade & Android Kernel Builds For Linux 6.7 \|sprache=en \|abruf=2023-11-04}}</ref>

	In ~~einem~~ ~~Interview mit~~ Rust~~-für-Linux-Betreuer~~ ~~Miguel~~ ~~Ojeda~~ ~~wird~~ ~~berichtet,~~ ~~dass rund 70 % der Sicherheitslücken~~ auf ~~Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind~~, ~~die~~ ~~sich~~ ~~zukünftig~~ ~~mit~~ ~~Rust~~ ~~vermeiden~~ ~~ließen.~~ ~~Für~~ ~~Entwickler~~ ~~bietet~~ ~~Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu~~ C.<ref>{{Internetquelle ~~\|autor=heise online~~ \|url=https://www.heise.de/~~hintergrund~~/~~Drei~~-~~Fragen~~-~~und~~-~~Antworten~~-~~Was~~-~~die~~-~~Rust~~-~~Zukunft-fuer-Linux~~-~~bringt~~-~~7531986~~.html \|titel=~~Drei Fragen und Antworten: Was die~~ Rust-~~Zukunft~~ ~~für~~ Linux ~~bringt~~ \|datum=~~2023~~-03-06 \|sprache=de \|abruf=~~2023~~-11-04}}</ref>		Die Umstellung auf Rust warf aber auch diverse Diskussionen auf, in deren Folge im Jahr 2025 langjährige Kernel-Maintainer das Projekt verlassen haben.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|autor=Thorsten Leemhuis \|werk=heise.de \|datum=2025-02-21 \|sprache=de \|abruf=2025-02-21}}</ref>

	Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, in deren Folge langjährige Kernel-Maintainer das Projekt verlassen haben.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|autor=Thorsten Leemhuis \|werk=heise.de \|datum=2025-02-21 \|sprache=de \|abruf=2025-02-21}}</ref>

	== Literatur ==		== Literatur ==

PaulBommel: /* Sprachdesign */ traut als code formatiert, wie vorher

2025-03-11T07:45:51Z

Sprachdesign: traut als code formatiert, wie vorher

← Nächstältere Version		Version vom 11. März 2025, 09:45 Uhr
Zeile 62:		Zeile 62:
	Rust kennt neben den sogenannten Raw-[[Zeiger (Informatik)\|Pointern]], die Zeigern in C entsprechen und nur in explizit als <code>unsafe</code> markiertem Code dereferenziert werden dürfen, auch noch [[Referenz (Programmierung)\|Referenzen]]. Diese zeigen immer auf gültigen Speicher und dürfen niemals den Wert [[Zeiger (Informatik)#Nullzeiger\|null]] annehmen. Es werden zwei verschiedene Arten von Referenzen unterschieden: gemeinsame Referenzen (''shared references''), eingeleitet durch <code>&</code>, und veränderbare Referenzen (''mutable references''), eingeleitet durch <code>&mut</code>. Der Rust-Compiler garantiert [[Statische Code-Analyse\|statisch]], dass keine Referenz das von ihr referenzierte Objekt [[Variable (Programmierung)#Lebensdauer von Variablen\|„überlebt“]], dass das referenzierte Objekt nicht verändert wird, während eine Referenz (egal ob gemeinsam oder veränderbar) existiert, und dass eine veränderbare Referenz – wenn eine solche existiert – stets die einzige Referenz auf ein Objekt ist, sodass Veränderungen am Objekt vorgenommen werden können, ohne dabei Referenzen zum selben Objekt an anderen Stellen im Code oder sogar in anderen [[Thread (Informatik)\|Threads]] ungültig zu machen.		Rust kennt neben den sogenannten Raw-[[Zeiger (Informatik)\|Pointern]], die Zeigern in C entsprechen und nur in explizit als <code>unsafe</code> markiertem Code dereferenziert werden dürfen, auch noch [[Referenz (Programmierung)\|Referenzen]]. Diese zeigen immer auf gültigen Speicher und dürfen niemals den Wert [[Zeiger (Informatik)#Nullzeiger\|null]] annehmen. Es werden zwei verschiedene Arten von Referenzen unterschieden: gemeinsame Referenzen (''shared references''), eingeleitet durch <code>&</code>, und veränderbare Referenzen (''mutable references''), eingeleitet durch <code>&mut</code>. Der Rust-Compiler garantiert [[Statische Code-Analyse\|statisch]], dass keine Referenz das von ihr referenzierte Objekt [[Variable (Programmierung)#Lebensdauer von Variablen\|„überlebt“]], dass das referenzierte Objekt nicht verändert wird, während eine Referenz (egal ob gemeinsam oder veränderbar) existiert, und dass eine veränderbare Referenz – wenn eine solche existiert – stets die einzige Referenz auf ein Objekt ist, sodass Veränderungen am Objekt vorgenommen werden können, ohne dabei Referenzen zum selben Objekt an anderen Stellen im Code oder sogar in anderen [[Thread (Informatik)\|Threads]] ungültig zu machen.

	Das Erstellen von Referenzen wird auch als ''Borrowing'' (Ausleihen) bezeichnet und bildet zusammen mit dem Konzept der ''Ownership'' (Besitz) die Grundlage für die sichere Speicherverwaltung ohne Garbage Collection. ''Ownership'' bedeutet hier, dass jedes Objekt im Speicher im Besitz derjenigen Variable ist, der es bei der Erstellung zugewiesen wird. Am Ende der [[Variable (Programmierung)#Lebensdauer von Variablen\|Lebensdauer]] dieser Variable wird der Speicher automatisch freigegeben. Für die meisten komplexeren Datentypen verwendet Rust die sogenannte ''Move''-Semantik, sodass bei Zuweisung eines Objektes zu einer anderen Variablen das Objekt „verschoben“ wird, und ein Zugriff auf die alte Variable daraufhin nicht mehr möglich ist. Auch beim Übergeben von Objekten als [[Wertparameter]] an Funktionen (''call by value'') werden solche Objekte in die Funktion „hineingeschoben“ und sind von außen nicht mehr zugreifbar, wenn sie nicht wieder von der Funktion zurückgegeben werden. [[Datentyp#Elementare Datentypen\|Primitive Datentypen]] im engeren Sinne verwenden keine ''Move''-Semantik, sondern die sonst übliche ''Copy''-Semantik (Zuweisungen erstellen eine Kopie). Dies gilt nicht für folgende Datentypen, die in Rust als primitiv gelten: veränderbare Referenzen (''mutable references'')<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1 \|titel=Trait-Implementierungen für Referenzen \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, manche [[Closure (Funktion)\|Closures]]<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/marker/trait.Copy.html#additional-implementors \|titel=Der „Copy“-Trait \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, str<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.str.html \|titel=Der „str“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|abruf=2023-08-07}}</ref> und manche Arrays<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.array.html \|titel=Der „array“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref> und manche Tupel<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.tuple.html \|titel=Der „tuple“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>. Bei benutzerdefinierten Datentypen kann mittels des ''Copy''-Traits selbst entschieden werden, ob ''Move''- oder ''Copy''-Semantik verwendet werden soll.		Das Erstellen von Referenzen wird auch als ''Borrowing'' (Ausleihen) bezeichnet und bildet zusammen mit dem Konzept der ''Ownership'' (Besitz) die Grundlage für die sichere Speicherverwaltung ohne Garbage Collection. ''Ownership'' bedeutet hier, dass jedes Objekt im Speicher im Besitz derjenigen Variable ist, der es bei der Erstellung zugewiesen wird. Am Ende der [[Variable (Programmierung)#Lebensdauer von Variablen\|Lebensdauer]] dieser Variable wird der Speicher automatisch freigegeben. Für die meisten komplexeren Datentypen verwendet Rust die sogenannte ''Move''-Semantik, sodass bei Zuweisung eines Objektes zu einer anderen Variablen das Objekt „verschoben“ wird, und ein Zugriff auf die alte Variable daraufhin nicht mehr möglich ist. Auch beim Übergeben von Objekten als [[Wertparameter]] an Funktionen (''call by value'') werden solche Objekte in die Funktion „hineingeschoben“ und sind von außen nicht mehr zugreifbar, wenn sie nicht wieder von der Funktion zurückgegeben werden. [[Datentyp#Elementare Datentypen\|Primitive Datentypen]] im engeren Sinne verwenden keine ''Move''-Semantik, sondern die sonst übliche ''Copy''-Semantik (Zuweisungen erstellen eine Kopie). Dies gilt nicht für folgende Datentypen, die in Rust als primitiv gelten: veränderbare Referenzen (''mutable references'')<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1 \|titel=Trait-Implementierungen für Referenzen \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, manche [[Closure (Funktion)\|Closures]]<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/marker/trait.Copy.html#additional-implementors \|titel=Der „Copy“-Trait \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, str<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.str.html \|titel=Der „str“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|abruf=2023-08-07}}</ref> und manche Arrays<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.array.html \|titel=Der „array“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref> und manche Tupel<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.tuple.html \|titel=Der „tuple“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>. Bei benutzerdefinierten Datentypen kann mittels des <code>Copy</code>-Traits selbst entschieden werden, ob ''Move''- oder ''Copy''-Semantik verwendet werden soll.

	Zur dynamischen Speicherverwaltung stehen die [[Intelligenter Zeiger\|Smart-Pointer-Typen]] <code>Box</code>, <code>Rc</code> und der Hilfstyp <code>RefCell</code> zur Verfügung, welche einerseits dem System Ownership-Borrowing-Lifetime-Move unterworfen sind, dieses System andererseits auf die Laufzeitdynamik übertragen. Der Typ <code>Box<T></code> beschreibt einen besitzenden Zeiger auf einen Wert vom Typ <code>T</code> im dynamisch allozierten Speicher. Der Typ <code>Rc<T></code> beschreibt über [[Referenzzählung]] einen gemeinschaftlichen Besitz auf einen unveränderlichen Wert. Ein unveränderlicher Wert kann jedoch veränderliche innere Daten vom Typ <code>RefCell<T></code> besitzen, wobei jeweils ein Referenzzähler für einen Zugriff analog zu <code>&</code> und <code>&mut</code> das sichere dynamische Borrowing durch Prüfung zur Laufzeit ermöglicht.		Zur dynamischen Speicherverwaltung stehen die [[Intelligenter Zeiger\|Smart-Pointer-Typen]] <code>Box</code>, <code>Rc</code> und der Hilfstyp <code>RefCell</code> zur Verfügung, welche einerseits dem System Ownership-Borrowing-Lifetime-Move unterworfen sind, dieses System andererseits auf die Laufzeitdynamik übertragen. Der Typ <code>Box<T></code> beschreibt einen besitzenden Zeiger auf einen Wert vom Typ <code>T</code> im dynamisch allozierten Speicher. Der Typ <code>Rc<T></code> beschreibt über [[Referenzzählung]] einen gemeinschaftlichen Besitz auf einen unveränderlichen Wert. Ein unveränderlicher Wert kann jedoch veränderliche innere Daten vom Typ <code>RefCell<T></code> besitzen, wobei jeweils ein Referenzzähler für einen Zugriff analog zu <code>&</code> und <code>&mut</code> das sichere dynamische Borrowing durch Prüfung zur Laufzeit ermöglicht.

Qcomp: mE unnötige Details: der belegte Satz, dass in Folge der Diskussion lagjährige Maintainer das Projekt verlasssen haben, genügt, um wen es sich handelt, steht im EN (Personalwechsel im Linux-kernel oder bei Asahi Linux sind nicht für Rust relevant)

2025-03-05T11:37:48Z

mE unnötige Details: der belegte Satz, dass in Folge der Diskussion lagjährige Maintainer das Projekt verlasssen haben, genügt, um wen es sich handelt, steht im EN (Personalwechsel im Linux-kernel oder bei Asahi Linux sind nicht für Rust relevant)

← Nächstältere Version		Version vom 5. März 2025, 13:37 Uhr
Zeile 249:		Zeile 249:
	In einem Interview mit Rust-für-Linux-Betreuer Miguel Ojeda wird berichtet, dass rund 70 % der Sicherheitslücken auf Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind, die sich zukünftig mit Rust vermeiden ließen. Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>		In einem Interview mit Rust-für-Linux-Betreuer Miguel Ojeda wird berichtet, dass rund 70 % der Sicherheitslücken auf Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind, die sich zukünftig mit Rust vermeiden ließen. Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

	Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, ~~die~~ ~~bis~~ ~~zum~~ ~~Verlassen langjähriger~~ Kernel-Maintainer ~~von dem~~ Projekt ~~führt~~.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>		Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, in deren Folge langjährige Kernel-Maintainer das Projekt verlassen haben.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|autor=Thorsten Leemhuis \|werk=heise.de \|datum=2025-02-21 \|sprache=de \|abruf=2025-02-21}}</ref>

	So verließ der Gründer von Asahi-Linux (eine Linux-Distribution, die Linux auf den neuen, von Apple entwickelten M-Chips verfügbar macht) das Projekt.
	Auch Christoph Hellwig ist als maßgeblicher Linux-Entwickler zurückgetreten.

	== Literatur ==		== Literatur ==

2A02:8071:57B0:A1E0:B82:2343:FDD1:34F4: /* Linux Kernel */ substant. Verben werden groß geschrieben

2025-03-01T13:04:50Z

Linux Kernel: substant. Verben werden groß geschrieben

← Nächstältere Version		Version vom 1. März 2025, 15:04 Uhr
Zeile 249:		Zeile 249:
	In einem Interview mit Rust-für-Linux-Betreuer Miguel Ojeda wird berichtet, dass rund 70 % der Sicherheitslücken auf Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind, die sich zukünftig mit Rust vermeiden ließen. Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>		In einem Interview mit Rust-für-Linux-Betreuer Miguel Ojeda wird berichtet, dass rund 70 % der Sicherheitslücken auf Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind, die sich zukünftig mit Rust vermeiden ließen. Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

	Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum ~~verlassen~~ langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>		Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum Verlassen langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>

	So verließ der Gründer von Asahi-Linux (eine Linux-Distribution, die Linux auf den neuen, von Apple entwickelten M-Chips verfügbar macht) das Projekt.		So verließ der Gründer von Asahi-Linux (eine Linux-Distribution, die Linux auf den neuen, von Apple entwickelten M-Chips verfügbar macht) das Projekt.

87.78.175.55: /* Linux Kernel */

2025-02-21T22:45:03Z

Linux Kernel

← Nächstältere Version		Version vom 22. Februar 2025, 00:45 Uhr
Zeile 250:		Zeile 250:

	Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum verlassen langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>		Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum verlassen langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>

	So verließ der Gründer von Asahi-Linux (eine Linux-Distribution, die Linux auf den neuen, von Apple entwickelten M-Chips verfügbar macht) das Projekt.		So verließ der Gründer von Asahi-Linux (eine Linux-Distribution, die Linux auf den neuen, von Apple entwickelten M-Chips verfügbar macht) das Projekt.
	Auch Christoph Hellwig ist als maßgeblicher Linux-Entwickler zurückgetreten.		Auch Christoph Hellwig ist als maßgeblicher Linux-Entwickler zurückgetreten.

87.78.175.55: /* Linux Kernel */

2025-02-21T22:43:51Z

Linux Kernel

← Nächstältere Version		Version vom 22. Februar 2025, 00:43 Uhr
Zeile 250:		Zeile 250:

	Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum verlassen langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>		Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum verlassen langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>
			So verließ der Gründer von Asahi-Linux (eine Linux-Distribution, die Linux auf den neuen, von Apple entwickelten M-Chips verfügbar macht) das Projekt.
			Auch Christoph Hellwig ist als maßgeblicher Linux-Entwickler zurückgetreten.

	== Literatur ==		== Literatur ==

87.78.175.55: /* Linux Kernel */

2025-02-21T22:39:02Z

Linux Kernel

← Nächstältere Version		Version vom 22. Februar 2025, 00:39 Uhr
Zeile 248:		Zeile 248:

	In einem Interview mit Rust-für-Linux-Betreuer Miguel Ojeda wird berichtet, dass rund 70 % der Sicherheitslücken auf Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind, die sich zukünftig mit Rust vermeiden ließen. Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>		In einem Interview mit Rust-für-Linux-Betreuer Miguel Ojeda wird berichtet, dass rund 70 % der Sicherheitslücken auf Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind, die sich zukünftig mit Rust vermeiden ließen. Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

			Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, die bis zum verlassen langjähriger Kernel-Maintainer von dem Projekt führt.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|sprache=de \|abruf=2025-02-21}}</ref>

	== Literatur ==		== Literatur ==

Joschi71: /* Syntax, Sprachkonstrukte */ Komma statt Punkt, sonst hat der folgende Satz kein Verb.

2025-02-02T19:51:44Z

Syntax, Sprachkonstrukte: Komma statt Punkt, sonst hat der folgende Satz kein Verb.

← Nächstältere Version		Version vom 2. Februar 2025, 21:51 Uhr
Zeile 39:		Zeile 39:
	Syntaktisch ist die Sprache an [[C (Programmiersprache)\|C]] angelehnt. Mehrere aufeinanderfolgende Anweisungen werden durch ein [[Semikolon]] getrennt, Blöcke stehen in geschweiften Klammern. In vielen Details weicht die [[Syntax]] allerdings davon ab. So werden beispielsweise keine Klammern um die Bedingungen von <code>if</code>- und <code>while</code>-Statements benötigt, stattdessen aber geschweifte Klammern um den dahinterstehenden Block erzwungen, auch wenn dort nur eine Anweisung steht. Das Schlüsselwort <code>for</code> leitet in Rust immer eine [[Foreach-Schleife]] ein, die das Iterieren über beliebige (auch benutzerdefinierte) Container und Objekte ermöglicht. Anstelle des <code>switch</code>-Statements gibt es die wesentlich mächtigeren <code>match</code>-Ausdrücke, die nicht nur mit Zahlen und Zeichenketten umgehen können, sondern [[Pattern Matching]] auf beliebig verschachtelten Strukturen durchführen können.		Syntaktisch ist die Sprache an [[C (Programmiersprache)\|C]] angelehnt. Mehrere aufeinanderfolgende Anweisungen werden durch ein [[Semikolon]] getrennt, Blöcke stehen in geschweiften Klammern. In vielen Details weicht die [[Syntax]] allerdings davon ab. So werden beispielsweise keine Klammern um die Bedingungen von <code>if</code>- und <code>while</code>-Statements benötigt, stattdessen aber geschweifte Klammern um den dahinterstehenden Block erzwungen, auch wenn dort nur eine Anweisung steht. Das Schlüsselwort <code>for</code> leitet in Rust immer eine [[Foreach-Schleife]] ein, die das Iterieren über beliebige (auch benutzerdefinierte) Container und Objekte ermöglicht. Anstelle des <code>switch</code>-Statements gibt es die wesentlich mächtigeren <code>match</code>-Ausdrücke, die nicht nur mit Zahlen und Zeichenketten umgehen können, sondern [[Pattern Matching]] auf beliebig verschachtelten Strukturen durchführen können.

	Variablen werden normalerweise klein (<code>snake_case</code>) geschrieben, außer wenn es sich um Konstanten handelt. Bei Konstanten schreibt man jeden Buchstaben groß und trennt jedes Wort mit einem Unterstrich (<code>SCREAMING_SNAKE_CASE</code>).<ref>{{Internetquelle\| url=https://rust-lang.github.io/rfcs/0430-finalizing-naming-conventions.html\| titel=0430-finalizing-naming-conventions - The Rust RFC Book\| abruf=2024-09-08\| datum=2014-11-02}}</ref> Datentypen mit Ausnahme der primitiven mit großem Anfangsbuchstaben (<code>PascalCase</code>). Typparameter von generischen Typen und Funktionen stehen in spitzen Klammern. Zwei Doppelpunkte drücken aus, dass der Bezeichner auf der rechten Seite aus dem Namensraum des Bezeichners auf der linken Seite entstammen soll. Die Bindung eines Bezeichners <code>x</code> an einen Wert wird		Variablen werden normalerweise klein (<code>snake_case</code>) geschrieben, außer wenn es sich um Konstanten handelt. Bei Konstanten schreibt man jeden Buchstaben groß und trennt jedes Wort mit einem Unterstrich (<code>SCREAMING_SNAKE_CASE</code>),<ref>{{Internetquelle\| url=https://rust-lang.github.io/rfcs/0430-finalizing-naming-conventions.html\| titel=0430-finalizing-naming-conventions - The Rust RFC Book\| abruf=2024-09-08\| datum=2014-11-02}}</ref> Datentypen mit Ausnahme der primitiven mit großem Anfangsbuchstaben (<code>PascalCase</code>). Typparameter von generischen Typen und Funktionen stehen in spitzen Klammern. Zwei Doppelpunkte drücken aus, dass der Bezeichner auf der rechten Seite aus dem Namensraum des Bezeichners auf der linken Seite entstammen soll. Die Bindung eines Bezeichners <code>x</code> an einen Wert wird

	<syntaxhighlight lang="Rust">let x: Typ = Wert;</syntaxhighlight>		<syntaxhighlight lang="Rust">let x: Typ = Wert;</syntaxhighlight>

WolfgangRieger: /* Einzelnachweise */ s. Wikipedia:Spaltensatz

2025-02-02T16:22:04Z

Einzelnachweise: s. Wikipedia:Spaltensatz

← Nächstältere Version		Version vom 2. Februar 2025, 18:22 Uhr
Zeile 259:		Zeile 259:

	== Einzelnachweise ==		== Einzelnachweise ==
	<references ~~responsive~~ />		<references />

	{{Normdaten\|TYP=s\|GND=1078438080}}		{{Normdaten\|TYP=s\|GND=1078438080}}

← Nächstältere Version		Version vom 9. April 2025, 10:30 Uhr
Zeile 245:		Zeile 245:
	Der Linuxkernel enthält {{FormatNum\|25000\|de}} Zeilen Rustcode bei {{FormatNum\|34000000\|de}} Zeilen C-Code, Rust macht somit erst 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf \|titel=Rust and Linux \|datum=2025-04-01 \|abruf=2025-04-09}}</ref>		Der Linuxkernel enthält {{FormatNum\|25000\|de}} Zeilen Rustcode bei {{FormatNum\|34000000\|de}} Zeilen C-Code, Rust macht somit erst 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf \|titel=Rust and Linux \|datum=2025-04-01 \|abruf=2025-04-09}}</ref>

	Für ~~Entwickler~~ bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>		Für Kernelentwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

	Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ \|titel=Rust kernel policy \|abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Compilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler.<ref name=":2" />		Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ \|titel=Rust kernel policy \|abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Compilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler im Linuxkernel.<ref name=":2" />

	Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>		Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>

← Nächstältere Version		Version vom 9. April 2025, 10:17 Uhr
Zeile 243:		Zeile 243:

	==== Linux Kernel ====		==== Linux Kernel ====
			Der Linuxkernel enthält {{FormatNum\|25000\|de}} Zeilen Rustcode bei {{FormatNum\|34000000\|de}} Zeilen C-Code, Rust macht somit erst 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf \|titel=Rust and Linux \|datum=2025-04-01 \|abruf=2025-04-09}}</ref>

			Für Entwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle \|autor=heise online \|url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html \|titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt \|datum=2023-03-06 \|sprache=de \|abruf=2023-11-04}}</ref>

			Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle \|autor=[[Greg Kroah-Hartman]] \|url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ \|titel=Rust kernel policy \|abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Compilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler.<ref name=":2" />

	Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>		Mit dem [[Linux (Kernel)\|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle \|autor=heise online \|url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html \|titel=Linux 6.1 als nächster Langzeit-Kernel erschienen \|datum=2022-12-13 \|sprache=de \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|autor=Ferdinand Thommes \|url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ \|titel=Linux 6.1 mit initialem Rust-Code freigegeben \|hrsg= \|datum=2022-12-12 \|sprache=de \|abruf=2023-05-10}}</ref>

	Erst mit den folgenden Kerneln wurden Module und mehrere Updates der [[Toolchain]] gemacht, um dem produktiven Einsatz näher zu kommen und zukünftig näher an der aktuellen Entwicklung von Rust zu sein.<ref>{{Internetquelle \|url=https://www.phoronix.com/news/Rust-For-Linux-6.5 \|titel=Linux 6.5 Upgrading The Rust Toolchain, New Modules Added \|sprache=en \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|url=https://www.phoronix.com/news/Linux-6.7-Rust \|titel=Rust WQ Abstractions, Rust Toolchain Upgrade & Android Kernel Builds For Linux 6.7 \|sprache=en \|abruf=2023-11-04}}</ref>		Erst mit den folgenden Kerneln wurden Module und mehrere Updates der [[Toolchain]] gemacht, um dem produktiven Einsatz näher zu kommen und zukünftig näher an der aktuellen Entwicklung von Rust zu sein.<ref>{{Internetquelle \|url=https://www.phoronix.com/news/Rust-For-Linux-6.5 \|titel=Linux 6.5 Upgrading The Rust Toolchain, New Modules Added \|sprache=en \|abruf=2023-11-04}}</ref><ref>{{Internetquelle \|url=https://www.phoronix.com/news/Linux-6.7-Rust \|titel=Rust WQ Abstractions, Rust Toolchain Upgrade & Android Kernel Builds For Linux 6.7 \|sprache=en \|abruf=2023-11-04}}</ref>

	In ~~einem~~ ~~Interview mit~~ Rust~~-für-Linux-Betreuer~~ ~~Miguel~~ ~~Ojeda~~ ~~wird~~ ~~berichtet,~~ ~~dass rund 70 % der Sicherheitslücken~~ auf ~~Speichersicherheitsprobleme der C-Codebasis zurückzuführen sind~~, ~~die~~ ~~sich~~ ~~zukünftig~~ ~~mit~~ ~~Rust~~ ~~vermeiden~~ ~~ließen.~~ ~~Für~~ ~~Entwickler~~ ~~bietet~~ ~~Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu~~ C.<ref>{{Internetquelle ~~\|autor=heise online~~ \|url=https://www.heise.de/~~hintergrund~~/~~Drei~~-~~Fragen~~-~~und~~-~~Antworten~~-~~Was~~-~~die~~-~~Rust~~-~~Zukunft-fuer-Linux~~-~~bringt~~-~~7531986~~.html \|titel=~~Drei Fragen und Antworten: Was die~~ Rust-~~Zukunft~~ ~~für~~ Linux ~~bringt~~ \|datum=~~2023~~-03-06 \|sprache=de \|abruf=~~2023~~-11-04}}</ref>		Die Umstellung auf Rust warf aber auch diverse Diskussionen auf, in deren Folge im Jahr 2025 langjährige Kernel-Maintainer das Projekt verlassen haben.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|autor=Thorsten Leemhuis \|werk=heise.de \|datum=2025-02-21 \|sprache=de \|abruf=2025-02-21}}</ref>

	Aktuell (Anfang 2025) wirft die Umstellung auf Rust aber auch diverse Diskussionen auf, in deren Folge langjährige Kernel-Maintainer das Projekt verlassen haben.<ref>{{Internetquelle \|url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html \|titel=Der Rust-DMA-Streit beim Linux-Kernel \|autor=Thorsten Leemhuis \|werk=heise.de \|datum=2025-02-21 \|sprache=de \|abruf=2025-02-21}}</ref>

	== Literatur ==		== Literatur ==

← Nächstältere Version		Version vom 11. März 2025, 09:45 Uhr
Zeile 62:		Zeile 62:
	Rust kennt neben den sogenannten Raw-[[Zeiger (Informatik)\|Pointern]], die Zeigern in C entsprechen und nur in explizit als <code>unsafe</code> markiertem Code dereferenziert werden dürfen, auch noch [[Referenz (Programmierung)\|Referenzen]]. Diese zeigen immer auf gültigen Speicher und dürfen niemals den Wert [[Zeiger (Informatik)#Nullzeiger\|null]] annehmen. Es werden zwei verschiedene Arten von Referenzen unterschieden: gemeinsame Referenzen (''shared references''), eingeleitet durch <code>&</code>, und veränderbare Referenzen (''mutable references''), eingeleitet durch <code>&mut</code>. Der Rust-Compiler garantiert [[Statische Code-Analyse\|statisch]], dass keine Referenz das von ihr referenzierte Objekt [[Variable (Programmierung)#Lebensdauer von Variablen\|„überlebt“]], dass das referenzierte Objekt nicht verändert wird, während eine Referenz (egal ob gemeinsam oder veränderbar) existiert, und dass eine veränderbare Referenz – wenn eine solche existiert – stets die einzige Referenz auf ein Objekt ist, sodass Veränderungen am Objekt vorgenommen werden können, ohne dabei Referenzen zum selben Objekt an anderen Stellen im Code oder sogar in anderen [[Thread (Informatik)\|Threads]] ungültig zu machen.		Rust kennt neben den sogenannten Raw-[[Zeiger (Informatik)\|Pointern]], die Zeigern in C entsprechen und nur in explizit als <code>unsafe</code> markiertem Code dereferenziert werden dürfen, auch noch [[Referenz (Programmierung)\|Referenzen]]. Diese zeigen immer auf gültigen Speicher und dürfen niemals den Wert [[Zeiger (Informatik)#Nullzeiger\|null]] annehmen. Es werden zwei verschiedene Arten von Referenzen unterschieden: gemeinsame Referenzen (''shared references''), eingeleitet durch <code>&</code>, und veränderbare Referenzen (''mutable references''), eingeleitet durch <code>&mut</code>. Der Rust-Compiler garantiert [[Statische Code-Analyse\|statisch]], dass keine Referenz das von ihr referenzierte Objekt [[Variable (Programmierung)#Lebensdauer von Variablen\|„überlebt“]], dass das referenzierte Objekt nicht verändert wird, während eine Referenz (egal ob gemeinsam oder veränderbar) existiert, und dass eine veränderbare Referenz – wenn eine solche existiert – stets die einzige Referenz auf ein Objekt ist, sodass Veränderungen am Objekt vorgenommen werden können, ohne dabei Referenzen zum selben Objekt an anderen Stellen im Code oder sogar in anderen [[Thread (Informatik)\|Threads]] ungültig zu machen.

	Das Erstellen von Referenzen wird auch als ''Borrowing'' (Ausleihen) bezeichnet und bildet zusammen mit dem Konzept der ''Ownership'' (Besitz) die Grundlage für die sichere Speicherverwaltung ohne Garbage Collection. ''Ownership'' bedeutet hier, dass jedes Objekt im Speicher im Besitz derjenigen Variable ist, der es bei der Erstellung zugewiesen wird. Am Ende der [[Variable (Programmierung)#Lebensdauer von Variablen\|Lebensdauer]] dieser Variable wird der Speicher automatisch freigegeben. Für die meisten komplexeren Datentypen verwendet Rust die sogenannte ''Move''-Semantik, sodass bei Zuweisung eines Objektes zu einer anderen Variablen das Objekt „verschoben“ wird, und ein Zugriff auf die alte Variable daraufhin nicht mehr möglich ist. Auch beim Übergeben von Objekten als [[Wertparameter]] an Funktionen (''call by value'') werden solche Objekte in die Funktion „hineingeschoben“ und sind von außen nicht mehr zugreifbar, wenn sie nicht wieder von der Funktion zurückgegeben werden. [[Datentyp#Elementare Datentypen\|Primitive Datentypen]] im engeren Sinne verwenden keine ''Move''-Semantik, sondern die sonst übliche ''Copy''-Semantik (Zuweisungen erstellen eine Kopie). Dies gilt nicht für folgende Datentypen, die in Rust als primitiv gelten: veränderbare Referenzen (''mutable references'')<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1 \|titel=Trait-Implementierungen für Referenzen \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, manche [[Closure (Funktion)\|Closures]]<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/marker/trait.Copy.html#additional-implementors \|titel=Der „Copy“-Trait \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, str<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.str.html \|titel=Der „str“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|abruf=2023-08-07}}</ref> und manche Arrays<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.array.html \|titel=Der „array“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref> und manche Tupel<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.tuple.html \|titel=Der „tuple“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>. Bei benutzerdefinierten Datentypen kann mittels des ''Copy''-Traits selbst entschieden werden, ob ''Move''- oder ''Copy''-Semantik verwendet werden soll.		Das Erstellen von Referenzen wird auch als ''Borrowing'' (Ausleihen) bezeichnet und bildet zusammen mit dem Konzept der ''Ownership'' (Besitz) die Grundlage für die sichere Speicherverwaltung ohne Garbage Collection. ''Ownership'' bedeutet hier, dass jedes Objekt im Speicher im Besitz derjenigen Variable ist, der es bei der Erstellung zugewiesen wird. Am Ende der [[Variable (Programmierung)#Lebensdauer von Variablen\|Lebensdauer]] dieser Variable wird der Speicher automatisch freigegeben. Für die meisten komplexeren Datentypen verwendet Rust die sogenannte ''Move''-Semantik, sodass bei Zuweisung eines Objektes zu einer anderen Variablen das Objekt „verschoben“ wird, und ein Zugriff auf die alte Variable daraufhin nicht mehr möglich ist. Auch beim Übergeben von Objekten als [[Wertparameter]] an Funktionen (''call by value'') werden solche Objekte in die Funktion „hineingeschoben“ und sind von außen nicht mehr zugreifbar, wenn sie nicht wieder von der Funktion zurückgegeben werden. [[Datentyp#Elementare Datentypen\|Primitive Datentypen]] im engeren Sinne verwenden keine ''Move''-Semantik, sondern die sonst übliche ''Copy''-Semantik (Zuweisungen erstellen eine Kopie). Dies gilt nicht für folgende Datentypen, die in Rust als primitiv gelten: veränderbare Referenzen (''mutable references'')<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1 \|titel=Trait-Implementierungen für Referenzen \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, manche [[Closure (Funktion)\|Closures]]<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/marker/trait.Copy.html#additional-implementors \|titel=Der „Copy“-Trait \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>, str<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.str.html \|titel=Der „str“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|abruf=2023-08-07}}</ref> und manche Arrays<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.array.html \|titel=Der „array“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref> und manche Tupel<ref>{{Internetquelle \|url=https://doc.rust-lang.org/std/primitive.tuple.html \|titel=Der „tuple“-Datentyp \|werk=Dokumentation der Rust-Standardbibliothek \|sprache=en \|abruf=2023-08-07}}</ref>. Bei benutzerdefinierten Datentypen kann mittels des <code>Copy</code>-Traits selbst entschieden werden, ob ''Move''- oder ''Copy''-Semantik verwendet werden soll.

	Zur dynamischen Speicherverwaltung stehen die [[Intelligenter Zeiger\|Smart-Pointer-Typen]] <code>Box</code>, <code>Rc</code> und der Hilfstyp <code>RefCell</code> zur Verfügung, welche einerseits dem System Ownership-Borrowing-Lifetime-Move unterworfen sind, dieses System andererseits auf die Laufzeitdynamik übertragen. Der Typ <code>Box<T></code> beschreibt einen besitzenden Zeiger auf einen Wert vom Typ <code>T</code> im dynamisch allozierten Speicher. Der Typ <code>Rc<T></code> beschreibt über [[Referenzzählung]] einen gemeinschaftlichen Besitz auf einen unveränderlichen Wert. Ein unveränderlicher Wert kann jedoch veränderliche innere Daten vom Typ <code>RefCell<T></code> besitzen, wobei jeweils ein Referenzzähler für einen Zugriff analog zu <code>&</code> und <code>&mut</code> das sichere dynamische Borrowing durch Prüfung zur Laufzeit ermöglicht.		Zur dynamischen Speicherverwaltung stehen die [[Intelligenter Zeiger\|Smart-Pointer-Typen]] <code>Box</code>, <code>Rc</code> und der Hilfstyp <code>RefCell</code> zur Verfügung, welche einerseits dem System Ownership-Borrowing-Lifetime-Move unterworfen sind, dieses System andererseits auf die Laufzeitdynamik übertragen. Der Typ <code>Box<T></code> beschreibt einen besitzenden Zeiger auf einen Wert vom Typ <code>T</code> im dynamisch allozierten Speicher. Der Typ <code>Rc<T></code> beschreibt über [[Referenzzählung]] einen gemeinschaftlichen Besitz auf einen unveränderlichen Wert. Ein unveränderlicher Wert kann jedoch veränderliche innere Daten vom Typ <code>RefCell<T></code> besitzen, wobei jeweils ein Referenzzähler für einen Zugriff analog zu <code>&</code> und <code>&mut</code> das sichere dynamische Borrowing durch Prüfung zur Laufzeit ermöglicht.