Maximilian.pottgiesser: Die Seite wurde neu angelegt: „

 # Linux Architektur – Userspace, Kernel Space & Hardware  ``` ╔════════════════════════════…“

2026-02-12T09:16:43Z

Die Seite wurde neu angelegt: „<pre> # Linux Architektur – Userspace, Kernel Space & Hardware ``` ╔════════════════════════════…“

Neue Seite

<pre>
# Linux Architektur – Userspace, Kernel Space & Hardware

```
╔════════════════════════════════════════════════════════════════════════════╗
║ ║
║ USERSPACE ║
║ (Ring 3 – unprivilegiert) ║
║ ║
║ Alles was der Benutzer sieht und womit er arbeitet. ║
║ Programme hier haben KEINEN direkten Zugriff auf Hardware. ║
║ Jeder Zugriff muss über den Kernel laufen. ║
║ ║
║ ┌─────────────────────────────────────────────────────────────────┐ ║
║ │ Benutzer-Anwendungen │ ║
║ │ │ ║
║ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────────┐ │ ║
║ │ │ Firefox │ │ Apache │ │ Terminal │ │ Datenbank (MariaDB)│ │ ║
║ │ └──────────┘ └──────────┘ └──────────┘ └───────────────────┘ │ ║
║ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────────┐ │ ║
║ │ │ SSH- │ │ Python- │ │ systemd │ │ Monitoring │ │ ║
║ │ │ Server │ │ Skript │ │ (init) │ │ (Zabbix Agent) │ │ ║
║ │ └──────────┘ └──────────┘ └──────────┘ └───────────────────┘ │ ║
║ └─────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ┌─────────────────────────────────┼───────────────────────────────┐ ║
║ │ System-Bibliotheken │ (z.B. glibc) │ ║
║ │ │ │ ║
║ │ Übersetzen Programmaufrufe │ │ ║
║ │ in System Calls │ │ ║
║ │ │ │ ║
║ │ Beispiel: │ │ ║
║ │ fopen("datei.txt") ──────► open() System Call │ ║
║ │ printf("Hallo") ──────► write() System Call │ ║
║ │ malloc(1024) ──────► brk()/mmap() System Call │ ║
║ └─────────────────────────────────┼───────────────────────────────┘ ║
║ │ ║
║ │ System Calls ║
║ │ (die EINZIGE Tür zum Kernel) ║
║ ▼ ║
╠══════════════════════════════════════════════════════════════════════════╗ ║
║░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░║ ║
║░░░░░░░░░░░░░░░░░░░░░ SYSTEM CALL INTERFACE ░░░░░░░░░░░░░░░░░░░░░░░░░░░║ ║
║░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░║ ║
║░░ open() · read() · write() · close() · fork() · exec() · ioctl() ░░║ ║
║░░ socket() · bind() · connect() · mmap() · mount() · kill() · ... ░░║ ║
║░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░║ ║
╠══════════════════════════════════════════════════════════════════════════╝ ║
║ │ ║
║ ▼ ║
║ KERNEL SPACE ║
║ (Ring 0 – privilegiert) ║
║ ║
║ Vollständiger Zugriff auf Hardware. ║
║ Verwaltet ALLE Ressourcen und teilt sie den Prozessen zu. ║
║ Ein Fehler hier = kompletter Systemabsturz (Kernel Panic) ║
║ ║
║ ┌─────────────────────────────────────────────────────────────────┐ ║
║ │ │ ║
║ │ ┌─────────────────────┐ ┌──────────────────────────────┐ │ ║
║ │ │ Prozessverwaltung │ │ Speicherverwaltung │ │ ║
║ │ │ │ │ │ │ ║
║ │ │ • Scheduler │ │ • Virtueller Speicher │ │ ║
║ │ │ (wer darf wann │ │ (jeder Prozess glaubt, │ │ ║
║ │ │ auf die CPU?) │ │ er hat eigenen RAM) │ │ ║
║ │ │ • Prozess-Isolation│ │ • Page Tables │ │ ║
║ │ │ • Threads │ │ • Swap-Verwaltung │ │ ║
║ │ └─────────────────────┘ └──────────────────────────────┘ │ ║
║ │ │ ║
║ │ ┌─────────────────────┐ ┌──────────────────────────────┐ │ ║
║ │ │ Netzwerk-Stack │ │ Dateisystem-Schicht (VFS) │ │ ║
║ │ │ │ │ │ │ ║
║ │ │ • TCP/IP │ │ • ext4, XFS, ZFS, Btrfs │ │ ║
║ │ │ • Firewall │ │ • Berechtigungen │ │ ║
║ │ │ (nftables) │ │ • Journaling │ │ ║
║ │ │ • Routing │ │ • I/O Scheduling │ │ ║
║ │ │ • Namespaces │ │ • Mount-Verwaltung │ │ ║
║ │ └─────────────────────┘ └──────────────────────────────┘ │ ║
║ │ │ ║
║ │ ┌─────────────────────┐ ┌──────────────────────────────┐ │ ║
║ │ │ Sicherheit │ │ Kernel-Module │ │ ║
║ │ │ │ │ │ │ ║
║ │ │ • Berechtigungen │ │ • Ladbare Treiber │ │ ║
║ │ │ • SELinux/AppArmor │ │ • Dateisystem-Module │ │ ║
║ │ │ • Namespaces │ │ • Netzwerk-Module │ │ ║
║ │ │ • cgroups │ │ • Krypto-Module │ │ ║
║ │ └─────────────────────┘ └──────────────────────────────┘ │ ║
║ │ │ ║
║ └─────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ┌─────────────────────────────────┼───────────────────────────────┐ ║
║ │ Gerätetreiber │ │ ║
║ │ │ │ ║
║ │ Übersetzen generische Kernel- │ │ ║
║ │ Befehle in hardwarespezifische │ │ ║
║ │ Kommandos │ │ ║
║ │ │ │ ║
║ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────────┐ │ ║
║ │ │ NIC- │ │ SATA/ │ │ GPU- │ │ USB-Treiber │ │ ║
║ │ │ Treiber │ │ NVMe │ │ Treiber │ │ │ │ ║
║ │ └──────────┘ └──────────┘ └──────────┘ └───────────────────┘ │ ║
║ └─────────────────────────────────┼───────────────────────────────┘ ║
║ │ ║
╠════════════════════════════════════╪══════════════════════════════════════╣
║ ▼ ║
║ HARDWARE ║
║ ║
║ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ║
║ │ │ │ │ │ │ │ │ │ │ ║
║ │ CPU │ │ RAM │ │ NIC │ │ NVMe/ │ │ GPU │ ║
║ │ │ │ │ │ │ │ HDD │ │ │ ║
║ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ ║
║ ║
╚════════════════════════════════════════════════════════════════════════════╝

═══════════════════════════════════════════════════════════════════════════════
WAS PASSIERT BEI EINEM DATEIZUGRIFF?
═══════════════════════════════════════════════════════════════════════════════

Beispiel: Ein Python-Skript will eine Datei lesen

┌─────────────────────────────────────────────────────────────────────────┐
│ USERSPACE │
│ │
│ 1. Python-Skript: f = open("/etc/hostname", "r") │
│ │ │
│ ▼ │
│ 2. glibc übersetzt das in einen System Call: open() │
│ │ │
├─────────┼───────────────────────────────────────────────────────────────┤
│ │ ← Grenze: Wechsel von Ring 3 → Ring 0 (Context Switch) │
├─────────┼───────────────────────────────────────────────────────────────┤
│ KERNEL │ │
│ ▼ │
│ 3. System Call Interface empfängt open() │
│ │ │
│ ▼ │
│ 4. VFS (Virtual Filesystem) bestimmt: ext4 zuständig │
│ │ │
│ ▼ │
│ 5. ext4-Treiber ermittelt die physischen Blöcke │
│ │ │
│ ▼ │
│ 6. I/O-Scheduler reiht den Leseauftrag ein │
│ │ │
│ ▼ │
│ 7. Gerätetreiber (z.B. NVMe) sendet Kommando an Hardware │
│ │ │
├─────────┼───────────────────────────────────────────────────────────────┤
│ HARDWARE│ │
│ ▼ │
│ 8. NVMe-SSD liest die Daten und gibt sie zurück │
│ │ │
├─────────┼───────────────────────────────────────────────────────────────┤
│ KERNEL │ │
│ ▼ │
│ 9. Daten landen im Kernel-Buffer (Page Cache) │
│ │ │
│ ▼ │
│ 10. Kernel kopiert Daten in den Userspace-Speicher des Prozesses │
│ │ │
├─────────┼───────────────────────────────────────────────────────────────┤
│ │ ← Rückwechsel: Ring 0 → Ring 3 │
├─────────┼───────────────────────────────────────────────────────────────┤
│ USERSPACE │
│ ▼ │
│ 11. Python-Skript kann die Daten jetzt lesen: f.read() │
│ │
└─────────────────────────────────────────────────────────────────────────┘

═══════════════════════════════════════════════════════════════════════════════
WARUM DIESE TRENNUNG?
═══════════════════════════════════════════════════════════════════════════════

┌──────────────────────────────┐ ┌──────────────────────────────┐
│ OHNE Trennung │ │ MIT Trennung │
│ │ │ │
│ Jedes Programm kann: │ │ Programme müssen: │
│ │ │ │
│ • direkt auf RAM zugreifen │ │ • den Kernel FRAGEN │
│ • Festplatte beschreiben │ │ • der Kernel PRÜFT │
│ • Netzwerkkarte steuern │ │ • der Kernel VERMITTELT │
│ • andere Programme killen │ │ │
│ │ │ Vorteile: │
│ Ergebnis: │ │ ✓ Stabilität (ein Absturz │
│ ✗ Ein Fehler in Firefox │ │ in Firefox betrifft nur │
│ kann das ganze System │ │ Firefox) │
│ zerstören │ │ ✓ Sicherheit (Prozesse │
│ ✗ Keine Sicherheit │ │ können sich nicht │
│ ✗ Keine Stabilität │ │ gegenseitig manipulieren)│
│ │ │ ✓ Fairness (Kernel teilt │
│ (→ MS-DOS, Windows 95/98) │ │ Ressourcen gerecht auf) │
│ │ │ │
│ │ │ (→ Linux, moderne Windows) │
└──────────────────────────────┘ └──────────────────────────────┘

═══════════════════════════════════════════════════════════════════════════════
CPU PROTECTION RINGS
═══════════════════════════════════════════════════════════════════════════════

┌─────────────────────────────────┐
│ │
│ Ring 3: Userspace │
│ Anwendungen, Dienste │
│ (eingeschränkte Rechte) │
│ │
│ ┌─────────────────────┐ │
│ │ │ │
│ │ Ring 2: (unused) │ │
│ │ │ │
│ │ ┌─────────────┐ │ │
│ │ │ │ │ │
│ │ │ Ring 1: │ │ │
│ │ │ (unused) │ │ │
│ │ │ │ │ │
│ │ │ ┌───────┐ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │Ring 0 │ │ │ │
│ │ │ │Kernel │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ └───────┘ │ │ │
│ │ │ │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────┘ │
│ │
└─────────────────────────────────┘

Ring 0 = höchste Privilegien (Kernel)
Ring 3 = niedrigste Privilegien (Userspace)
Ring 1+2 = von Linux nicht genutzt

Bei Virtualisierung:
Ring -1 (VMX root) = Hypervisor
Ring 0 = Gast-Kernel
Ring 3 = Gast-Anwendungen
</pre>

Userspace - Versionsgeschichte

Maximilian.pottgiesser: Die Seite wurde neu angelegt: „
# Linux Architektur – Userspace, Kernel Space & Hardware ``` ╔════════════════════════════…“