imported>Thorsten Klöhn: Import aus Zensical-Doku (Wissen Ahrensburg)

2026-07-20T17:39:58Z

Import aus Zensical-Doku (Wissen Ahrensburg)

Neue Seite

= Systemprogrammierung – Übersicht =

Willkommen im Bereich '''Systemprogrammierung'''! Hier findest du umfassende Dokumentation zu niedrigstufiger Programmierung, Assembler, Compilern und der Integration von '''Rust, C++ und C''' auf '''Linux'''.


== 📌 Themenbereiche ==


=== [[Entwicklung / Systemprogrammierung / Assembler / Grundlagen|Assembler (ASM)]] ===

Die niedrigste Abstraktionsebene: Direkte Steuerung der CPU durch Maschinenbefehle.

* '''Grundlagen''': Register, Instruktionen, Speicheradressierung
* '''Syntax''': AT&T vs. Intel-Syntax
* '''System Calls''': Interaktion mit dem Linux-Kernel
* '''Tools''': <code>as</code>, <code>ld</code>, <code>objdump</code>, <code>gdb</code>
* '''Inline-Assembler''': Integration in C/C++/Rust
* '''Praktische Beispiele''': x86-64, ARM, RISC-V


=== [[Entwicklung / Systemprogrammierung / Compiler|Compiler]] ===

Wie Hochsprachen (C, C++, Rust) in Maschinencode übersetzt werden.

* '''Phasen''': Preprocessing → Kompilieren → Assemblieren → Linken
* '''GCC vs. Clang vs. Rustc''': Vergleich der Compiler
* '''Optimierungen''': <code>-O1</code>, <code>-O2</code>, <code>-O3</code>, <code>-Os</code>
* '''Debug-Symbole''': <code>-g</code> und Debugging mit <code>gdb</code>
* '''Cross-Compiling''': Für andere Architekturen kompilieren
* '''Statische vs. Dynamische Bibliotheken''': <code>.a</code> vs. <code>.so</code>


=== [[Entwicklung / Systemprogrammierung / Rust & C/C++ / C Praxis-Handbuch|C Praxis-Handbuch]] ===

Umfassendes Handbuch zur C-Systemprogrammierung, Pointer-Mechanik, Speicherverwaltung (malloc/free), Structs, Makefiles, GDB & Valgrind.


=== [[Entwicklung / Systemprogrammierung / Rust & C/C++ / C++ Praxis-Handbuch|C++ Praxis-Handbuch]] ===

Handbuch zu Modern C++, Smart Pointers (RAII), Rule of 0/3/5, Templates, Concepts, STL Ranges & CMake.


=== [[Entwicklung / Systemprogrammierung / Rust & C/C++ / Rust Praxis-Handbuch|Rust Praxis-Handbuch]] ===

Das umfassende Handbuch zu Rust-Sprachkonzepten, Ownership, Lifetimes, Tokio Async und dem Rust-Ökosystem.


=== [[Entwicklung / Systemprogrammierung / Rust & C/C++ / Rust, C & C++ Integration|Rust, C++ & C Integration]] ===

Interoperabilität zwischen den Sprachen auf Linux.

* '''C-ABI''': Die stabile Schnittstelle für Sprachübergreifenden Code
* '''Rust ↔ C''': <code>extern "C"</code>, <code>#[no_mangle]</code>, <code>bindgen</code>, <code>cbindgen</code>
* '''C++ ↔ C''': <code>extern "C"</code> für ABI-Kompatibilität
* '''Rust ↔ C++''': Über C-Wrapper oder <code>cpp!</code>-Macro
* '''Inline-Assembler''': <code>asm!</code> in Rust, <code>__asm__</code> in C/C++
* '''Praktische Beispiele''': Bibliotheken teilen, Funktionen aufrufen


=== [[Entwicklung / Systemprogrammierung / Linux / Linux Praxis-Handbuch|Linux Praxis-Handbuch]] ===

Umfassendes Handbuch zur Linux-Administration, FHS, Rechteverwaltung, Textverarbeitung (grep/awk/sed), LVM, systemd, Netzwerk & Bash-Scripting.


=== [[Entwicklung / Systemprogrammierung / Linux / Shell & Bash Praxis-Handbuch|Shell & Bash Praxis-Handbuch]] ===

Praxis-Handbuch zu I/O-Redirection, Textverarbeitungs-Pipelines, Arrays, defensiver Fehlerbehandlung (set -euo pipefail), Traps & Cron-Jobs.


=== [[Entwicklung / Systemprogrammierung / Spiele-Entwicklung / Game Development Praxis-Handbuch|Game Development Praxis-Handbuch]] ===

Umfassendes Handbuch zu Game Engines, 3D-Mathematik (Quaternions), Physik-Simulationspipelines (SAT/GJK), Shaders (HLSL/GLSL), PBR-Rendering & Game-AI (Behavior Trees).


=== [[Entwicklung / Systemprogrammierung / Linux / Linux-Systemprogrammierung|Linux-Systemprogrammierung]] ===

Niedrigstufige Programmierung mit Linux-spezifischen Features.

* '''System Calls''': <code>syscall()</code>, <code>write()</code>, <code>read()</code>, <code>open()</code>
* '''Process Management''': <code>fork()</code>, <code>exec()</code>, <code>wait()</code>
* '''File I/O''': Dateioperationen mit <code>open()</code>, <code>mmap()</code>
* '''Signals''': <code>signal()</code>, <code>sigaction()</code>
* '''Threads''': <code>pthread</code> in C, <code>std::thread</code> in Rust
* '''Memory Management''': <code>malloc()</code>, <code>mmap()</code>, <code>brk()</code>
* '''Kernel-Module''': Einführung in Kernel-Programmierung


== 🎯 Für wen ist dieser Bereich? ==

* '''Entwickler''', die niedrigstufige Programmierung lernen möchten
* '''Systemarchitekten''', die Performance-Optimierungen benötigen
* '''Embedded-Entwickler''', die mit Hardware interagieren
* '''Sicherheitsforscher''', die Binaries analysieren
* '''Compiler-Enthusiasten''', die verstehen wollen, wie Code übersetzt wird


== 🚀 Quick Start ==


=== 1. Erstes Assembler-Programm ===

<syntaxhighlight lang="bash"># Datei: hello.s (x86-64 AT&T-Syntax)
.section .data
msg: .ascii "Hello, Linux ASM!\n"
len = . - msg

.section .text
.global _start
_start:
mov $1, %rax # sys_write
mov $1, %rdi # stdout
mov $msg, %rsi # buffer
mov $len, %rdx # length
syscall

mov $60, %rax # sys_exit
xor %rdi, %rdi # status 0
syscall</syntaxhighlight>
'''Kompilieren & Ausführen:'''

<syntaxhighlight lang="bash">as --64 hello.s -o hello.o
ld hello.o -o hello
./hello</syntaxhighlight>

=== 2. C-Programm disassemblieren ===

<syntaxhighlight lang="bash"># Datei: test.c
echo 'int main() { return 42; }' > test.c

# Kompilieren mit ASM-Output
gcc -S test.c -o test.s

# oder direkt disassemblieren
gcc -c test.c -o test.o
objdump -d test.o</syntaxhighlight>

=== 3. Rust mit C integrieren ===

<syntaxhighlight lang="rust">// Datei: lib.rs
#[no_mangle]
pub extern "C" fn rust_add(a: i32, b: i32) -> i32 {
a + b
}</syntaxhighlight>
'''C-Programm, das Rust aufruft:'''

<syntaxhighlight lang="c">// Datei: call_rust.c
extern int rust_add(int, int);

int main() {
return rust_add(5, 7); // 12
}</syntaxhighlight>
'''Kompilieren:'''

<syntaxhighlight lang="bash"># Rust-Bibliothek kompilieren
cargo build --release

# C-Programm mit Rust-Bibliothek linkengcc call_rust.c -L./target/release -l<crate_name> -o program</syntaxhighlight>

== 📚 Lernpfad ==

{| class="wikitable"
|-
! Stufe
! Thema
! Dauer
|-
| '''Anfänger'''
| Assembler-Grundlagen
| 1-2 Wochen
|-
| '''Fortgeschritten'''
| Compiler-Phasen & Optimierungen
| 2-3 Wochen
|-
| '''Experte'''
| Sprachübergreifende Integration
| 1-2 Wochen
|-
| '''Master'''
| Linux-Kernel-Programmierung
| 4+ Wochen
|}


== 🔗 Verwandte Bereiche ==

* [[KI & Automatisierung / KI-Coding / Übersicht|Coding]] – Allgemeine Programmierkonzepte
* [[Wissen / Tools / Übersicht|Tools]] – Nützliche Werkzeuge für Entwickler
* [[Entwicklung / Server & Infrastruktur / Übersicht|Server]] – Server-Administration und -Optimierung


== 📖 Ressourcen ==


=== Bücher ===

* [https://savannah.gnu.org/projects/pgubook/ Programming from the Ground Up] – Assembler-Tutorial
* [https://doc.rust-lang.org/book/ The Rust Programming Language] – Offizielles Rust-Buch
* [https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468 Linux Kernel Development] – Kernel-Programmierung


=== Online-Kurse ===

* [https://www.nand2tetris.org/ Nand2Tetris] – Baue einen Computer von Grund auf
* [https://doc.rust-lang.org/rust-by-example/ Rust by Example] – Rust-Praxisbeispiele
* [https://0xax.gitbooks.io/linux-insides/content/ Linux Insides] – Linux-Kernel-Internals


=== Tools ===

* [https://godbolt.org/ Godbolt Compiler Explorer] – ASM-Output vergleichen
* [https://play.rust-lang.org/ Rust Playground] – Rust online testen
* [https://www.gnu.org/software/gdb/ GDB Debugger] – Debugging-Werkzeug

-----

''Letzte Aktualisierung: {{ git_revision_date_localized() }}''

Entwicklung / Systemprogrammierung / Übersicht - Versionsgeschichte

imported>Thorsten Klöhn: Import aus Zensical-Doku (Wissen Ahrensburg)