Entwicklung / Systemprogrammierung / Übersicht

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

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: as, ld, objdump, gdb
• Inline-Assembler: Integration in C/C++/Rust
• Praktische Beispiele: x86-64, ARM, RISC-V

Compiler

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

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

C Praxis-Handbuch

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

C++ Praxis-Handbuch

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

Rust Praxis-Handbuch

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

Rust, C++ & C Integration

Interoperabilität zwischen den Sprachen auf Linux.

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

Linux Praxis-Handbuch

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

Shell & Bash Praxis-Handbuch

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

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).

Linux-Systemprogrammierung

Niedrigstufige Programmierung mit Linux-spezifischen Features.

• System Calls: syscall(), write(), read(), open()
• Process Management: fork(), exec(), wait()
• File I/O: Dateioperationen mit open(), mmap()
• Signals: signal(), sigaction()
• Threads: pthread in C, std::thread in Rust
• Memory Management: malloc(), mmap(), brk()
• 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

# 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

Kompilieren & Ausführen:

as --64 hello.s -o hello.o
ld hello.o -o hello
./hello

2. C-Programm disassemblieren

# 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

3. Rust mit C integrieren

// Datei: lib.rs
#[no_mangle]
pub extern "C" fn rust_add(a: i32, b: i32) -> i32 {
    a + b
}

C-Programm, das Rust aufruft:

// Datei: call_rust.c
extern int rust_add(int, int);

int main() {
    return rust_add(5, 7); // 12
}

Kompilieren:

# Rust-Bibliothek kompilieren
cargo build --release

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

📚 Lernpfad

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

• Coding – Allgemeine Programmierkonzepte
• Tools – Nützliche Werkzeuge für Entwickler
• Server – Server-Administration und -Optimierung

📖 Ressourcen

Bücher

• Programming from the Ground Up – Assembler-Tutorial
• The Rust Programming Language – Offizielles Rust-Buch
• Linux Kernel Development – Kernel-Programmierung

Online-Kurse

• Nand2Tetris – Baue einen Computer von Grund auf
• Rust by Example – Rust-Praxisbeispiele
• Linux Insides – Linux-Kernel-Internals

Tools

• Godbolt Compiler Explorer – ASM-Output vergleichen
• Rust Playground – Rust online testen
• GDB Debugger – Debugging-Werkzeug

---

Letzte Aktualisierung: Vorlage:Git revision date localized()