Linux Hardware-Kommunikation

KAPITEL 02 · HARDWARE

Linux Hardware-Kommunikation

Wie Linux mit Hardware kommuniziert – vom Kernel über Treiber und Device Files bis zu User Space und Anwendungen. Der komplette Datenfluss verstehen.

Kernel & Treiber Device Files Syscalls Berechtigungen

Inhaltsverzeichnis

Schnellübersicht

Auf dieser Seite lernst du, wie Linux mit Hardware kommuniziert:

  • Kommunikationsfluss: Hardware → Kernel → Driver → User Space → Software
  • Kernel Space vs. User Space: Die zwei Welten von Linux
  • Device Treiber: Wie Hardware angesprochen wird
  • Device Files: Alles ist eine Datei (/dev)
  • Syscalls: Systemaufrufe zwischen User und Kernel
  • Berechtigungen: Zugriffsrechte auf Hardware
  • Udev: Dynamisches Gerätemanagement
  • Praxis: Befehle zur Hardware-Abfrage

1. Wie kommuniziert Linux mit Hardware?

Das Linux Hardware-Modell

Linux behandelt Hardware als Dateien. Jedes Hardware-Gerät wird durch eine spezielle Datei im /dev-Verzeichnis repräsentiert. Programme können auf Hardware zugreifen, indem sie diese Dateien öffnen, lesen und schreiben – genau wie bei normalen Dateien.

Der Linux-Kernel vermittelt zwischen Anwendungen und Hardware. Er enthält Treiber (Kernel Module), die die spezifische Hardware ansteuern. Der udev Device Manager erstellt automatisch Device Files, wenn Hardware erkannt wird.

Das Prinzip "Everything is a file": In Unix/Linux wird alles als Datei behandelt – auch Hardware-Geräte, Prozesse (/proc) und Kernel-Parameter (/sys). Dies ermöglicht eine einheitliche und elegante Schnittstelle.

Warum dieses Modell?

  • Einheitliche Schnittstelle: Programme müssen nicht für jedes Gerät speziellen Code schreiben
  • Einfache Berechtigungen: Standard-Dateiberechtigungen (rwx) gelten auch für Hardware
  • Flexibilität: Neue Geräte können einfach hinzugefügt werden
  • Skripting: Hardware-Zugriff mit Standard-Tools (cat, dd, echo)

2. Der komplette Kommunikationsfluss

Wenn ein User eine Aktion ausführt (z.B. eine Datei öffnen, drucken, Netzwerk nutzen), durchläuft die Anfrage mehrere Ebenen:

Datenfluss: Von der Hardware bis zum User

Hardware (Eingabe)

Tastatur, Maus, Festplatte, Netzwerk, GPU

Interrupts / DMA
Linux Kernel

Verwaltet Hardware, Prozesse, Speicher, Sicherheit

Ring 0
Device Treiber

Übersetzt Kernel-Befehle in Hardware-spezifische Anweisungen

Kernel Module
Virtual File System (VFS)

Abstraktion: Alles ist eine Datei (/dev/sda, /dev/tty)

/dev, /sys, /proc
User Space (Systemdienste)

Udev, systemd, D-Bus – Gerätemanagement und Events

Ring 3
Anwendungen

Browser, Editor, Terminal – nutzen Hardware über APIs

libc, POSIX
User (Ausgabe)

Sieht Ergebnis auf Monitor, hört Audio, bekommt Feedback

GUI / CLI

Beispiel: Tastatureingabe

  1. User drückt Taste 'A' auf der Tastatur
  2. Hardware sendet Interrupt an CPU
  3. Kernel empfängt Interrupt, ruft Keyboard-Treiber auf
  4. Treiber liest Scan-Code, übersetzt zu 'A'
  5. VFS schreibt 'A' in /dev/input/event0
  6. User Space (X11/Wayland) liest Event
  7. Anwendung (z.B. Editor) zeigt 'A' an
  8. User sieht 'A' auf dem Monitor

3. Kernel Space vs. User Space

Linux trennt strikt zwischen Kernel Space (privilegierter Modus) und User Space (eingeschränkter Modus). Diese Trennung schützt das System vor Abstürzen und Sicherheitslücken.

Kernel Space

Ring 0 · Privilegierter Modus
  • Direkter Hardware-Zugriff
  • Speicherverwaltung
  • Prozess-Scheduling
  • Device Treiber
  • Dateisystem-Implementierung
  • Netzwerk-Stack
  • Interrupt-Handling
  • System Calls bereitstellen
  • Absturz = Kernel Panic

User Space

Ring 3 · Eingeschränkter Modus
  • Anwendungen (Browser, Editor)
  • Shell / Terminal
  • Systemdienste (systemd)
  • Bibliotheken (libc)
  • GUI-Server (X11, Wayland)
  • Kein direkter Hardware-Zugriff
  • Muss Syscalls nutzen
  • Isoliert von anderen Prozessen
  • Absturz = nur App crasht

Wie kommt man von User zu Kernel?

Über System Calls (Syscalls)! Wenn eine Anwendung Hardware nutzen will (z.B. Datei lesen), ruft sie eine Funktion der C-Bibliothek (libc) auf, die einen Syscall an den Kernel sendet. Der Kernel prüft Berechtigungen, führt die Operation aus und gibt das Ergebnis zurück.

Beispiel: open("/dev/sda", O_RDONLY) → Syscall → Kernel prüft Rechte → Treiber liest von Festplatte → Daten zurück an User Space

4. Device Treiber (Gerätetreiber)

Treiber sind Software-Module im Kernel, die die Kommunikation zwischen Kernel und spezifischer Hardware ermöglichen. Jeder Treiber kennt die Befehle seiner Hardware.

Block Device Treiber

Für Geräte mit wahlfreiem Zugriff in Blöcken (Festplatten, SSDs, USB-Sticks).

/dev/sda, /dev/nvme0n1
Treiber: ext4, btrfs, xfs

Character Device Treiber

Für Geräte mit Zeichenstrom (Tastatur, Maus, Terminal, Soundkarte).

/dev/tty, /dev/input/mouse0
Treiber: usbhid, snd_hda_intel

Network Device Treiber

Für Netzwerkschnittstellen (Ethernet, WLAN). Keine Device Files, sondern Interfaces.

eth0, wlan0, lo
Treiber: e1000e, iwlwifi

Platform Device Treiber

Für interne Hardware (CPU, RAM, Chipsatz). Oft fest im Kernel kompiliert.

CPU-Treiber, ACPI, PCIe
Treiber: intel_pstate, acpi

Treiber-Arten in Linux

  • Im Kernel kompiliert: Fest integriert, immer verfügbar (z.B. ext4, TCP/IP)
  • Kernel Module (.ko): Nachladbar bei Bedarf (z.B. WLAN-Treiber)
  • Out-of-Tree: Von Herstellern, nicht im offiziellen Kernel
  • Userspace-Treiber: Laufen im User Space (z.B. über libusb)

5. Device Files – Alles ist eine Datei

Ein fundamentales Linux-Prinzip: Alles ist eine Datei. Hardware wird als Dateien im /dev-Verzeichnis dargestellt. Programme können Hardware wie normale Dateien lesen/schreiben.

Device Files in der Praxis

# Alle Device Files auflisten
$ ls -la /dev/ | head -20
brw-rw---- 1 root disk 8, 0 Jan 15 10:00 sda
brw-rw---- 1 root disk 259, 0 Jan 15 10:00 nvme0n1
crw-rw-rw- 1 root tty 5, 0 Jan 15 10:00 tty
crw-rw---- 1 root video 29, 0 Jan 15 10:00 fb0
crw-rw-rw- 1 root root 1, 3 Jan 15 10:00 null
crw-rw-rw- 1 root root 1, 8 Jan 15 10:00 random
# Erste Buchstaben bedeuten Gerätetyp:
b = Block Device (Festplatte, SSD)
c = Character Device (Tastatur, Terminal)
p = Pipe (FIFO)
s = Socket (Netzwerk)
# Von Festplatte lesen (als Datei!)
$ sudo dd if=/dev/sda of=backup.img bs=4M count=1
1+0 records in
1+0 records out
4194304 bytes (4.2 MB) copied
# Zufallszahlen aus Hardware-RNG
$ head -c 16 /dev/urandom | xxd
00000000: a3f2 8b1c 7d4e 9e2f 5c8a 3b7e 1d6f 4c2a

Wichtige Device Files

  • /dev/null: "Schwarzes Loch" – alles wird verworfen
  • /dev/zero: Liefert unendlich viele Nullen
  • /dev/random: Echte Zufallszahlen (blockiert bei wenig Entropie)
  • /dev/urandom: Pseudo-Zufallszahlen (blockiert nicht)
  • /dev/tty: Aktuelles Terminal
  • /dev/sda, /dev/nvme0n1: Festplatten/SSDs
  • /dev/input/event*: Tastatur, Maus, Touchpad
  • /dev/fb0: Framebuffer (Grafikausgabe)
  • /dev/snd/*: Soundkarten

6. System Calls (Syscalls)

Syscalls sind die Schnittstelle zwischen User Space und Kernel Space. Anwendungen nutzen sie, um Kernel-Funktionen aufzurufen.

Syscall Funktion Beispiel Beschreibung
open() Datei/Device öffnen open("/dev/sda", O_RDONLY) Öffnet Device File mit Rechten
read() Daten lesen read(fd, buffer, 1024) Liest Bytes aus Datei/Device
write() Daten schreiben write(fd, "Hello", 5) Schreibt Bytes in Datei/Device
ioctl() Device-spezifische Steuerung ioctl(fd, CDROMEJECT) CD auswerfen, Volume einstellen
mmap() Speicher abbilden mmap(fd, ...) Device in Speicher mappen (GPU)
close() Datei/Device schließen close(fd) Gibt Resource frei
fork() Prozess klonen fork() Erzeugt Kindprozess
exec() Programm ausführen exec("/bin/ls") Startet neues Programm

Syscalls beobachten mit strace

Mit strace kannst du alle Syscalls eines Programms sehen:

$ strace ls /dev/sda 2>&1 | grep -E "open|read|close"
openat(AT_FDCWD, "/dev/sda", O_RDONLY) = 3
read(3, "\0\0\0\0\0\0\0\0", 512) = 512
close(3) = 0

7. Berechtigungen und Zugriffsrechte

Linux schützt Hardware durch Dateiberechtigungen. Nur berechtigte User/Gruppen können auf Devices zugreifen.

Berechtigungen am Beispiel /dev/sda

$ ls -la /dev/sda
brw-rw---- 1 root disk 8, 0 Jan 15 10:00 /dev/sda
Typ
b
Block Device
Owner (root)
rw-
Lesen + Schreiben
Group (disk)
rw-
Lesen + Schreiben
Others
---
Kein Zugriff

Wer darf was?

  • root: Immer voller Zugriff auf alle Devices
  • Gruppe disk: User in dieser Gruppe dürfen Festplatten lesen/schreiben
  • Normaler User: Kein Zugriff auf /dev/sda (Sicherheit!)
  • sudo: Temporär root-Rechte für einzelne Befehle

User zu Gruppe hinzufügen

Um einem User Zugriff auf ein Device zu geben, füge ihn zur entsprechenden Gruppe hinzu:

# User zur Gruppe 'disk' hinzufügen
$ sudo usermod -aG disk username
# Oder für USB-Devices:
$ sudo usermod -aG plugdev username
# Für Sound:
$ sudo usermod -aG audio username
# Für Video/GPU:
$ sudo usermod -aG video username

8. Udev – Dynamisches Gerätemanagement

Udev ist der Device Manager von Linux. Er erstellt automatisch Device Files, wenn Hardware erkannt wird, und entfernt sie beim Abstecken.

Geräte-Erkennung

Wenn Hardware angeschlossen wird, sendet der Kernel ein Event an udev. Udev erstellt dann automatisch das passende Device File in /dev.

Regeln

Udev-Regeln (/etc/udev/rules.d/) definieren, wie Geräte benannt werden und welche Berechtigungen sie bekommen.

Symlinks

Udev erstellt stabile Symlinks wie /dev/disk/by-uuid/ oder /dev/input/by-id/ für zuverlässige Ansprache.

Events

Programme können auf Hardware-Events reagieren (z.B. automatisch mounten bei USB-Stick).

Udev in der Praxis

# Alle verbundenen USB-Geräte anzeigen
$ lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub
Bus 002 Device 003: ID 046d:c52b Logitech, Inc. Unifying Receiver
# PCI-Geräte anzeigen (Grafikkarte, Netzwerk, etc.)
$ lspci
00:00.0 Host bridge: Intel Corporation Device
01:00.0 VGA compatible controller: NVIDIA Corporation
03:00.0 Ethernet controller: Intel Corporation
# Kernel-Ringbuffer (Hardware-Events)
$ dmesg | tail -20
[ 123.456] usb 1-2: new high-speed USB device
[ 123.567] usb 1-2: Product: USB Flash Drive
[ 123.678] sd 2:0:0:0: [sdb] Attached SCSI disk
# Udev-Regeln anzeigen
$ ls /etc/udev/rules.d/
70-persistent-net.rules
99-usb-serial.rules
99-zte-usb.rules

9. Sysfs und Procfs – Kernel-Informationen

Linux stellt Kernel-Informationen und Hardware-Status als Dateisysteme dar. Diese können gelesen (und manchmal geschrieben) werden.

/sys (Sysfs)

Enthält Informationen über Hardware-Geräte, Treiber und Kernel-Objekte. Hier siehst du die Hardware-Hierarchie.

/sys/class/net/ → Netzwerk-Interfaces
/sys/block/ → Block Devices
/sys/devices/ → Alle Geräte

/proc (Procfs)

Enthält Informationen über Prozesse und Kernel-Status. Dynamisch generiert, keine echten Dateien.

/proc/cpuinfo → CPU-Details
/proc/meminfo → Speicher-Info
/proc/devices → Alle Devices

/dev/shm

Shared Memory – temporärer Speicher im RAM für Inter-Prozess-Kommunikation. Sehr schnell.

/dev/shm/ → Temporäre Dateien
Nutzt RAM, nicht Festplatte
Wird beim Boot geleert

/run und /var/run

Enthält Runtime-Daten wie PID-Files, Sockets und Status-Informationen von Diensten.

/run/udev/ → Udev-Daten
/run/systemd/ → Systemd-Status
Socket-Files für IPC

Hardware-Informationen abfragen

# CPU-Informationen
$ cat /proc/cpuinfo | grep "model name" | head -1
model name : Intel(R) Core(TM) i7-10700K CPU @ 3.80GHz
# Speicher-Informationen
$ cat /proc/meminfo | head -5
MemTotal: 16384000 kB
MemFree: 8192000 kB
MemAvailable: 12288000 kB
Buffers: 512000 kB
Cached: 4096000 kB
# Alle Block Devices
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 465.8G 0 disk
├─sda1 8:1 0 512M 0 part /boot/efi
└─sda2 8:2 0 465.3G 0 part /
nvme0n1 259:0 0 931.5G 0 disk
└─nvme0n1p1 259:1 0 931.5G 0 part /data

10. Praxis: Hardware abfragen und verwalten

Die wichtigsten Befehle zur Hardware-Abfrage und -Verwaltung in Linux:

Essentielle Hardware-Befehle

# Alle Hardware-Details (umfangreich)
$ sudo lshw -short
H/W path Device Class Description
====================================================
system Computer
/0 bus Motherboard
/0/0 memory 16GiB System Memory
/0/1 processor Intel Core i7
/0/100/1 display NVIDIA GeForce RTX 3080
/0/100/1f.2 storage Intel SSD
# USB-Geräte detailliert
$ lsusb -v | grep -E "iManufacturer|iProduct" | head -10
iManufacturer 1 Logitech
iProduct 2 USB Receiver
iManufacturer 1 Kingston
iProduct 2 DataTraveler 3.0
# Festplatten und Partitionen
$ sudo fdisk -l
Disk /dev/sda: 465.76 GiB, 500107862016 bytes
Device Start End Sectors Size Type
/dev/sda1 2048 1050623 1048576 512M EFI System
/dev/sda2 1050624 976773167 975722544 465.3G Linux filesystem
# Kernel-Module (Treiber) anzeigen
$ lsmod | head -10
Module Size Used by
nvidia 30146560 45
iwlwifi 311296 0
btusb 61440 0
ext4 917504 2
# Treiber für spezifisches Gerät finden
$ lspci -k | grep -A 3 "VGA"
01:00.0 VGA compatible controller: NVIDIA Corporation
Subsystem: ASUSTeK Computer Inc.
Kernel driver in use: nvidia
Kernel modules: nouveau, nvidia_drm, nvidia
# Hardware-Temperatur überwachen
$ sensors
coretemp-isa-0000
Package id 0: +45.0°C (high = +80.0°C, crit = +100.0°C)
Core 0: +42.0°C (high = +80.0°C, crit = +100.0°C)
Core 1: +43.0°C (high = +80.0°C, crit = +100.0°C)

Die wichtigsten Befehle im Überblick

  • lshw: Detaillierte Hardware-Liste
  • lspci: PCI-Geräte (Grafik, Netzwerk, etc.)
  • lsusb: USB-Geräte
  • lsblk: Block Devices (Festplatten)
  • lsmod: Geladene Kernel-Module (Treiber)
  • dmesg: Kernel-Ringbuffer (Hardware-Events)
  • hwinfo: Umfangreiche Hardware-Info
  • inxi: System-Informationen (oft installiert)
  • sensors: Temperaturen und Spannungen
  • udevadm: Udev-Verwaltung und Debugging

11. FAQ – Häufige Fragen & Antworten

Häufige Fragen zur Linux Hardware-Kommunikation

Was ist der Unterschied zwischen /dev, /sys und /proc?

Drei wichtige virtuelle Dateisysteme in Linux:

  • /dev (Device Files): Repräsentiert Hardware-Geräte als Dateien. Ermöglicht Zugriff auf Hardware über Standard-Dateioperationen.
  • /sys (sysfs): Exportiert Kernel-Objekte und deren Attribute. Bietet strukturierte Sicht auf Hardware-Hierarchie und Konfiguration.
  • /proc (procfs): Bietet Echtzeit-Informationen über Prozesse und Kernel-Parameter. Dynamisch, keine echten Dateien auf Disk.
Warum werden Kernel Module dynamisch geladen?

Dynamisch ladbare Kernel Module bieten mehrere Vorteile:

  • Speichereffizienz: Nur benötigte Treiber werden geladen
  • Flexibilität: Treiber können zur Laufzeit hinzugefügt/entfernt werden
  • Kein Neustart nötig: Neue Hardware kann ohne Reboot genutzt werden
  • Modularität: Kernel bleibt schlank, Erweiterungen separat
Wie erkenne ich, welcher Treiber für ein Gerät geladen ist?

Mehrere Möglichkeiten:

  • lspci -k: Zeigt PCI-Geräte mit geladenem Kernel-Treiber
  • lsusb -v: Detaillierte USB-Geräte-Info
  • /sys/bus/pci/devices/[DEVICE]/driver: Symlink zum Treiber
  • lshw -C display: Zeigt Grafikkarte mit Treiber
Was ist udev und warum wird es benötigt?

udev ist der Device Manager des Linux-Kernels. Er:

  • Erstellt automatisch Device Files in /dev, wenn Hardware erkannt wird
  • Lädt passende Kernel Module für neue Geräte
  • Verwaltet Geräte-Berechtigungen und Symlinks
  • Führt benutzerdefinierte Aktionen aus (udev-Regeln)

Ohne udev müsste man Geräte manuell konfigurieren – bei Hotplug-Geräten (USB) unmöglich.

Wie kann ich ein Kernel Module dauerhaft laden?

Zwei Möglichkeiten:

  • /etc/modules: Modul-Namen in diese Datei eintragen (einfachste Methode)
  • /etc/modules-load.d/*.conf: Konfigurationsdatei erstellen (empfohlen)

Beispiel (/etc/modules-load.d/custom.conf):

# Custom modules to load at boot e1000e i915
Was bedeutet "Everything is a file" in Linux?

Dieses Unix-Prinzip bedeutet, dass fast alles als Datei behandelt wird:

  • Hardware-Geräte: /dev/sda, /dev/tty0
  • Prozesse: /proc/[PID]/
  • Kernel-Parameter: /proc/sys/, /sys/
  • Sockets: /var/run/docker.sock

Vorteil: Einheitliche Schnittstelle – Programme können mit Standard-Operationen (open, read, write) auf alles zugreifen.

Wie debugge ich Hardware-Probleme unter Linux?

Schritt-für-Schritt-Anleitung:

  • 1. dmesg prüfen: dmesg | tail -50 → Zeigt Kernel-Meldungen
  • 2. Gerät identifizieren: lspci oder lsusb
  • 3. Treiber prüfen: lspci -k → Zeigt geladenen Treiber
  • 4. Module prüfen: lsmod | grep [treiber]
  • 5. Logs analysieren: journalctl -b → System-Logs seit Boot
Was sind Major und Minor Numbers?

Jede Device-Datei hat zwei Nummern:

  • Major Number: Identifiziert den Treiber (z.B. 8 für SCSI/SATA-Disks, 13 für Maus)
  • Minor Number: Identifiziert das spezifische Gerät innerhalb des Treibers (z.B. 0 für /dev/sda, 16 für /dev/sdb)

Der Kernel nutzt diese Nummern, um zu wissen, welcher Treiber für welches Gerät zuständig ist.

Zusammenfassung

Die wichtigsten Punkte

  • Kommunikationsfluss: Hardware → Kernel → Treiber → VFS → User Space → Anwendung → User
  • Kernel Space (Ring 0): Privilegierter Modus, direkter Hardware-Zugriff
  • User Space (Ring 3): Eingeschränkter Modus, nutzt Syscalls
  • Device Treiber: Übersetzen Kernel-Befehle in Hardware-Anweisungen
  • Device Files: Hardware als Dateien in /dev (Block, Character, Network)
  • Syscalls: Schnittstelle zwischen User und Kernel (open, read, write, ioctl)
  • Berechtigungen: Schützen Hardware vor unbefugtem Zugriff
  • Udev: Erstellt automatisch Device Files bei Hardware-Erkennung
  • Sysfs/Procfs: Kernel-Informationen als Dateisysteme (/sys, /proc)
  • Befehle: lshw, lspci, lsusb, lsblk, lsmod, dmesg, sensors

Weiterführende Themen

Hardware-Komponenten

Alle PC-Komponenten im Überblick – CPU, GPU, Storage, Netzteil.

Zu Hardware-Komponenten
Linux Grundlagen

Linux-Betriebssystem, Terminal-Befehle, Dateisysteme und Prozessmanagement.

Zu Linux Grundlagen
Computer-Architektur

Von-Neumann, CPU-Aufbau, Pipeline, Bussysteme – theoretische Grundlagen.

Zur Computer-Architektur
Linux Sicherheit

Berechtigungen, SELinux, AppArmor, Firewall und Systemhärtung.

Zur IT-Sicherheit