Setup installation

docs/api-reference.md

@@ -0,0 +1,479 @@
+# USB-SSD Management System - API Reference
+
+## Übersicht
+
+Diese Referenz dokumentiert alle verfügbaren Scripts, Parameter und Optionen des USB-SSD Management Systems. Alle Scripts unterstützen die `--help` Option für detaillierte Informationen.
+
+## Script-Übersicht
+
+| Script | Zweck | Hauptfunktionen |
+|--------|-------|-----------------|
+| `ssd-detect.sh` | Hardware-Erkennung | USB-C SSD Identifikation, NTFS-Erkennung |
+| `ssd-mount-manager.sh` | Mount-Management | Mounting, Unmounting, Status-Überwachung |
+| `ssd-test-suite.sh` | Qualitätssicherung | 11 Test-Kategorien, Performance-Benchmarks |
+| `ssd-safe-eject.sh` | Sichere Entfernung | Buffer-Flush, Prozess-Detection, Hardware-Eject |
+
+## ssd-detect.sh
+
+### Syntax
+```bash
+ssd-detect.sh [OPTIONS] [COMMAND]
+```
+
+### Befehle
+| Befehl | Beschreibung |
+|--------|--------------|
+| `detect` | Standard-Erkennung (Default) |
+| `list` | Alle erkannten SSDs auflisten |
+| `monitor` | Kontinuierliche Überwachung |
+| `info` | Detaillierte Device-Informationen |
+
+### Optionen
+| Option | Kurz | Typ | Beschreibung | Default |
+|--------|------|-----|--------------|---------|
+| `--device` | `-d` | String | Spezifisches Device prüfen | Auto-detect |
+| `--ntfs-only` | `-n` | Flag | Nur NTFS-Partitionen anzeigen | false |
+| `--output` | `-o` | String | Output-Format (text/json/xml) | text |
+| `--verbose` | `-v` | Flag | Detaillierte Ausgabe | false |
+| `--debug` | | Flag | Debug-Modus aktivieren | false |
+| `--monitor` | `-m` | Flag | Kontinuierliche Überwachung | false |
+| `--interval` | `-i` | Integer | Monitor-Intervall (Sekunden) | 5 |
+| `--timeout` | `-t` | Integer | Detection-Timeout (Sekunden) | 30 |
+| `--hardware-info` | | Flag | Hardware-Details anzeigen | false |
+| `--performance-info` | | Flag | Performance-Informationen | false |
+
+### Beispiele
+```bash
+# Standard-Erkennung
+ssd-detect.sh
+
+# Spezifisches Device prüfen
+ssd-detect.sh --device /dev/sdb1
+
+# JSON-Output für Automation
+ssd-detect.sh --output json
+
+# Kontinuierliche Überwachung
+ssd-detect.sh --monitor --interval 10
+
+# Debug-Modus
+ssd-detect.sh --debug --verbose
+```
+
+### Exit-Codes
+| Code | Bedeutung |
+|------|-----------|
+| 0 | Erfolg - SSD erkannt |
+| 1 | Allgemeiner Fehler |
+| 2 | Keine SSD gefunden |
+| 3 | NTFS nicht unterstützt |
+| 4 | Timeout erreicht |
+| 5 | Permission denied |
+
+### Environment Variables
+```bash
+export SSD_DETECT_TIMEOUT=30        # Detection-Timeout
+export SSD_LOG_LEVEL=INFO           # Log-Level
+export SSD_SUPPORTED_FS="ntfs,exfat" # Unterstützte Dateisysteme
+export SSD_DEBUG=false              # Debug-Modus
+```
+
+## ssd-mount-manager.sh
+
+### Syntax
+```bash
+ssd-mount-manager.sh [OPTIONS] COMMAND
+```
+
+### Befehle
+| Befehl | Beschreibung |
+|--------|--------------|
+| `mount` | SSD mounten |
+| `unmount` | SSD unmounten |
+| `remount` | SSD neu mounten |
+| `status` | Mount-Status anzeigen |
+| `diagnose` | Mount-Probleme diagnostizieren |
+| `cleanup` | Mount-Point bereinigen |
+| `recover` | Recovery-Modus |
+| `metrics` | Performance-Metriken |
+
+### Optionen
+| Option | Kurz | Typ | Beschreibung | Default |
+|--------|------|-----|--------------|---------|
+| `--device` | `-d` | String | Spezifisches Device | Auto-detect |
+| `--mountpoint` | `-m` | String | Mount-Point Pfad | /mnt/ssd-storage |
+| `--options` | `-o` | String | Mount-Optionen | uid=1000,gid=1000 |
+| `--readonly` | `-r` | Flag | Read-Only Mount | false |
+| `--readwrite` | `-w` | Flag | Read-Write Mount | true |
+| `--smb-ready` | | Flag | SMB-optimierte Optionen | false |
+| `--fsck` | | Flag | Filesystem-Check vor Mount | false |
+| `--timeout` | `-t` | Integer | Mount-Timeout (Sekunden) | 30 |
+| `--force` | `-f` | Flag | Force-Mount | false |
+| `--verbose` | `-v` | Flag | Detaillierte Ausgabe | false |
+| `--json` | | Flag | JSON-Output | false |
+
+### Beispiele
+```bash
+# Standard-Mount
+ssd-mount-manager.sh mount
+
+# Custom Mount-Point
+ssd-mount-manager.sh mount --mountpoint /custom/path
+
+# Read-Only Mount
+ssd-mount-manager.sh mount --readonly
+
+# SMB-optimiertes Mounting
+ssd-mount-manager.sh mount --smb-ready
+
+# Status prüfen
+ssd-mount-manager.sh status --json
+
+# Diagnose
+ssd-mount-manager.sh diagnose
+```
+
+### Exit-Codes
+| Code | Bedeutung |
+|------|-----------|
+| 0 | Erfolg |
+| 1 | Allgemeiner Fehler |
+| 2 | Device nicht gefunden |
+| 3 | Mount fehlgeschlagen |
+| 4 | Unmount fehlgeschlagen |
+| 5 | Permission denied |
+| 6 | Timeout erreicht |
+
+### Environment Variables
+```bash
+export SSD_MOUNT_POINT="/mnt/ssd-storage"     # Standard Mount-Point
+export SSD_MOUNT_OPTIONS="uid=1000,gid=1000"  # Standard Mount-Optionen
+export SSD_MOUNT_TIMEOUT=30                   # Mount-Timeout
+export SSD_AUTO_MOUNT=true                    # Auto-Mount aktivieren
+export SSD_SMB_READY=false                    # SMB-Optimierungen
+```
+
+## ssd-test-suite.sh
+
+### Syntax
+```bash
+ssd-test-suite.sh [OPTIONS] [TESTS]
+```
+
+### Test-IDs
+| Test-ID | Name | Kategorie | Dauer |
+|---------|------|-----------|-------|
+| `T01` | Hardware Detection | Hardware | 5s |
+| `T02` | NTFS Filesystem | Hardware | 10s |
+| `T03` | Mount Stability | Hardware | 30s |
+| `T04` | Read Performance | Performance | 60s |
+| `T05` | Write Performance | Performance | 60s |
+| `T06` | File Operations | Performance | 45s |
+| `T07` | Permission System | Integration | 15s |
+| `T08` | SMB Readiness | Integration | 30s |
+| `T09` | Capacity Verification | Integration | 20s |
+| `T10` | Error Handling | Security | 25s |
+| `T11` | Security Scan | Security | 40s |
+
+### Befehle
+| Befehl | Beschreibung |
+|--------|--------------|
+| `all` | Alle Tests ausführen |
+| `quick` | Nur kritische Tests (T01,T02,T03,T08) |
+| `T01-T11` | Spezifische Tests |
+| `hardware` | Hardware-Tests (T01-T03) |
+| `performance` | Performance-Tests (T04-T06) |
+| `integration` | Integration-Tests (T07-T09) |
+| `security` | Security-Tests (T10-T11) |
+
+### Optionen
+| Option | Kurz | Typ | Beschreibung | Default |
+|--------|------|-----|--------------|---------|
+| `--category` | `-c` | String | Test-Kategorie | all |
+| `--output` | `-o` | String | Output-Format (text/json/xml/csv) | text |
+| `--benchmark` | `-b` | Flag | Benchmark-Modus | false |
+| `--detailed` | | Flag | Detaillierte Ergebnisse | false |
+| `--continuous` | | Flag | Kontinuierliche Tests | false |
+| `--interval` | `-i` | Integer | Test-Intervall (Sekunden) | 3600 |
+| `--timeout` | `-t` | Integer | Test-Timeout (Sekunden) | 300 |
+| `--size` | `-s` | String | Test-Daten Größe | 100MB |
+| `--iterations` | | Integer | Test-Wiederholungen | 3 |
+| `--compare` | | String | Baseline-Datei für Vergleich | - |
+| `--trend` | | Flag | Trend-Analyse | false |
+| `--prometheus-metrics` | | Flag | Prometheus-Metriken | false |
+
+### Beispiele
+```bash
+# Alle Tests
+ssd-test-suite.sh all
+
+# Schnelle Tests
+ssd-test-suite.sh --quick
+
+# Performance-Tests mit Benchmark
+ssd-test-suite.sh performance --benchmark
+
+# Kontinuierliche Tests
+ssd-test-suite.sh --continuous --interval 1800
+
+# JSON-Output
+ssd-test-suite.sh all --output json
+
+# Spezifische Tests
+ssd-test-suite.sh T01 T04 T08
+```
+
+### Exit-Codes
+| Code | Bedeutung |
+|------|-----------|
+| 0 | Alle Tests erfolgreich |
+| 1 | Ein oder mehrere Tests fehlgeschlagen |
+| 2 | Kritischer Test fehlgeschlagen |
+| 3 | Performance unter Threshold |
+| 4 | Timeout erreicht |
+| 5 | Permission denied |
+
+### Environment Variables
+```bash
+export SSD_TEST_TIMEOUT=300                    # Test-Timeout
+export SSD_TEST_SIZE=100                       # Test-Daten Größe (MB)
+export SSD_TEST_ITERATIONS=3                   # Test-Wiederholungen
+export SSD_BENCHMARK_MODE=false                # Benchmark-Modus
+export SSD_PERFORMANCE_THRESHOLD_READ="50MB/s" # Read-Performance Threshold
+export SSD_PERFORMANCE_THRESHOLD_WRITE="30MB/s" # Write-Performance Threshold
+```
+
+## ssd-safe-eject.sh
+
+### Syntax
+```bash
+ssd-safe-eject.sh [OPTIONS]
+```
+
+### Optionen
+| Option | Kurz | Typ | Beschreibung | Default |
+|--------|------|-----|--------------|---------|
+| `--device` | `-d` | String | Spezifisches Device | Auto-detect |
+| `--force` | `-f` | Flag | Force-Eject | false |
+| `--show-processes` | | Flag | Blockierende Prozesse anzeigen | false |
+| `--kill-processes` | | Flag | Prozesse automatisch beenden | false |
+| `--unmount-only` | | Flag | Nur Unmount (kein Hardware-Eject) | false |
+| `--timeout` | `-t` | Integer | Buffer-Flush Timeout (Sekunden) | 60 |
+| `--process-timeout` | | Integer | Prozess-Kill Timeout (Sekunden) | 10 |
+| `--verbose` | `-v` | Flag | Detaillierte Ausgabe | false |
+| `--dry-run` | | Flag | Simulation (keine Änderungen) | false |
+| `--monitor-buffers` | | Flag | Buffer-Status überwachen | false |
+| `--hardware-reset` | | Flag | Hardware-Reset nach Eject | false |
+
+### Beispiele
+```bash
+# Standard Safe-Eject
+ssd-safe-eject.sh
+
+# Mit Prozess-Übersicht
+ssd-safe-eject.sh --show-processes
+
+# Force-Eject
+ssd-safe-eject.sh --force --kill-processes
+
+# Nur Unmount
+ssd-safe-eject.sh --unmount-only
+
+# Dry-Run
+ssd-safe-eject.sh --dry-run --verbose
+```
+
+### Exit-Codes
+| Code | Bedeutung |
+|------|-----------|
+| 0 | Erfolgreicher Eject |
+| 1 | Allgemeiner Fehler |
+| 2 | Device nicht gefunden |
+| 3 | Unmount fehlgeschlagen |
+| 4 | Prozesse blockieren |
+| 5 | Hardware-Eject fehlgeschlagen |
+| 6 | Timeout erreicht |
+
+### Environment Variables
+```bash
+export SSD_EJECT_TIMEOUT=60           # Buffer-Flush Timeout
+export SSD_PROCESS_TIMEOUT=10         # Prozess-Kill Timeout
+export SSD_HARDWARE_EJECT=true        # Hardware-Eject aktivieren
+export SSD_KILL_PROCESSES=false       # Automatisches Prozess-Killing
+export SSD_MONITOR_BUFFERS=true       # Buffer-Monitoring
+```
+
+## Globale Environment Variables
+
+### Logging-Konfiguration
+```bash
+export SSD_LOG_LEVEL=INFO             # Log-Level (DEBUG,INFO,WARN,ERROR)
+export SSD_LOG_FILE="/var/log/ssd-management.log" # Log-Datei
+export SSD_USE_SYSLOG=true            # Syslog-Integration
+export SSD_DEBUG=false                # Debug-Modus
+export SSD_VERBOSE=false              # Verbose-Output
+```
+
+### System-Konfiguration
+```bash
+export SSD_CONFIG_DIR="/etc/ssd-management"      # Konfigurationsverzeichnis
+export SSD_CACHE_DIR="/var/cache/ssd-management" # Cache-Verzeichnis
+export SSD_LOCK_DIR="/var/lock/ssd-management"   # Lock-Verzeichnis
+export SSD_PID_FILE="/var/run/ssd-management.pid" # PID-Datei
+```
+
+### Performance-Konfiguration
+```bash
+export SSD_MAX_PARALLEL_OPS=1         # Maximale parallele Operationen
+export SSD_IO_SCHEDULER="mq-deadline" # I/O-Scheduler
+export SSD_READ_AHEAD_KB=1024         # Read-Ahead Buffer
+export SSD_CACHE_MODE="strict"        # Cache-Modus
+```
+
+## Konfigurationsdateien
+
+### Haupt-Konfiguration
+```ini
+# /etc/ssd-management/config.conf
+[global]
+debug = false
+verbose = false
+log_level = INFO
+
+[mount]
+default_mount_point = /mnt/ssd-storage
+ntfs_options = uid=1000,gid=1000,umask=022,windows_names
+auto_mount = true
+smb_ready = false
+
+[testing]
+quick_tests = T01,T02,T03,T08
+performance_threshold_read = 50MB/s
+performance_threshold_write = 30MB/s
+benchmark_enabled = false
+
+[security]
+require_sudo = true
+audit_logging = true
+process_detection = true
+buffer_monitoring = true
+```
+
+### Logging-Konfiguration
+```ini
+# /etc/ssd-management/logging.conf
+[loggers]
+keys = root,ssd
+
+[handlers]
+keys = fileHandler,syslogHandler
+
+[formatters]
+keys = detailedFormatter
+
+[logger_root]
+level = INFO
+handlers = fileHandler
+
+[logger_ssd]
+level = DEBUG
+handlers = fileHandler,syslogHandler
+qualname = ssd
+propagate = 0
+
+[handler_fileHandler]
+class = FileHandler
+level = DEBUG
+formatter = detailedFormatter
+args = ('/var/log/ssd-management.log',)
+
+[handler_syslogHandler]
+class = handlers.SysLogHandler
+level = INFO
+formatter = detailedFormatter
+args = (('localhost', handlers.SYSLOG_UDP_PORT), handlers.SysLogHandler.LOG_USER)
+
+[formatter_detailedFormatter]
+format = %(asctime)s - %(name)s - %(levelname)s - %(message)s
+```
+
+## Return-Codes Übersicht
+
+### Allgemeine Codes (0-9)
+| Code | Bedeutung |
+|------|-----------|
+| 0 | Erfolg |
+| 1 | Allgemeiner Fehler |
+| 2 | Ungültige Parameter |
+| 3 | Permission denied |
+| 4 | Timeout erreicht |
+| 5 | Resource nicht verfügbar |
+
+### Hardware-Codes (10-19)
+| Code | Bedeutung |
+|------|-----------|
+| 10 | Device nicht gefunden |
+| 11 | USB-Fehler |
+| 12 | Hardware-Fehler |
+| 13 | Filesystem nicht unterstützt |
+| 14 | Partition-Fehler |
+
+### Mount-Codes (20-29)
+| Code | Bedeutung |
+|------|-----------|
+| 20 | Mount fehlgeschlagen |
+| 21 | Unmount fehlgeschlagen |
+| 22 | Mount-Point nicht verfügbar |
+| 23 | Filesystem-Fehler |
+| 24 | Permission-Fehler |
+
+### Test-Codes (30-39)
+| Code | Bedeutung |
+|------|-----------|
+| 30 | Test fehlgeschlagen |
+| 31 | Performance unter Threshold |
+| 32 | Kritischer Test fehlgeschlagen |
+| 33 | Test-Timeout |
+| 34 | Test-Daten korrupt |
+
+## JSON-Output Format
+
+### Standard-Response
+```json
+{
+  "timestamp": "2025-08-07T19:10:00Z",
+  "script": "ssd-detect.sh",
+  "version": "0.1.0",
+  "status": "success",
+  "exit_code": 0,
+  "data": {
+    // Script-spezifische Daten
+  },
+  "errors": [],
+  "warnings": []
+}
+```
+
+### Error-Response
+```json
+{
+  "timestamp": "2025-08-07T19:10:00Z",
+  "script": "ssd-mount-manager.sh",
+  "version": "0.1.0",
+  "status": "error",
+  "exit_code": 20,
+  "data": null,
+  "errors": [
+    {
+      "code": "MOUNT_FAILED",
+      "message": "Failed to mount /dev/sdb1",
+      "details": "Permission denied"
+    }
+  ],
+  "warnings": []
+}
+```
+
+---
+
+**💡 Tipp**: Verwenden Sie `script-name.sh --help` für die aktuellste Dokumentation und alle verfügbaren Optionen.

docs/installation-guide.md

@@ -0,0 +1,439 @@
+# USB-SSD Management System - Detaillierte Installation
+
+## Übersicht
+
+Diese Anleitung führt Sie Schritt-für-Schritt durch die Installation des USB-SSD Management Systems auf Ubuntu/Linux-Servern. Das System ist speziell für KMU-Infrastrukturen optimiert und bietet professionelle Verwaltung wechselbarer USB-C SSDs.
+
+## Systemanforderungen
+
+### Mindestanforderungen
+- **Betriebssystem**: Ubuntu 20.04+ / Debian 11+ / CentOS 8+ / RHEL 8+
+- **Hardware**: USB-C Port, mindestens 1GB freier Speicher
+- **Berechtigungen**: `sudo` Zugriff für Installation
+- **Netzwerk**: Internetverbindung für Package-Downloads
+
+### Empfohlene Konfiguration
+- **RAM**: 4GB+ für Performance-Tests
+- **CPU**: 2+ Cores für parallele Operationen
+- **Storage**: 10GB+ freier Speicher für Logs und Caches
+- **USB**: USB 3.0+ für optimale Performance
+
+### Unterstützte Distributionen
+| Distribution | Version | Status | Notizen |
+|--------------|---------|--------|---------|
+| Ubuntu | 20.04+ | ✅ Vollständig | Empfohlen für Produktionsumgebungen |
+| Debian | 11+ | ✅ Vollständig | Stabile Alternative zu Ubuntu |
+| CentOS | 8+ | ✅ Vollständig | Enterprise-Umgebungen |
+| RHEL | 8+ | ✅ Vollständig | Enterprise-Support verfügbar |
+| Fedora | 35+ | ⚠️ Beta | Community-Support |
+| Arch Linux | Rolling | ⚠️ Beta | Für erfahrene Benutzer |
+
+## Vor der Installation
+
+### 1. System-Update
+```bash
+# Ubuntu/Debian
+sudo apt update && sudo apt upgrade -y
+
+# CentOS/RHEL
+sudo yum update -y
+
+# Fedora
+sudo dnf update -y
+```
+
+### 2. Git installieren
+```bash
+# Ubuntu/Debian
+sudo apt install git -y
+
+# CentOS/RHEL
+sudo yum install git -y
+
+# Fedora
+sudo dnf install git -y
+```
+
+### 3. System-Informationen sammeln
+```bash
+# Betriebssystem-Version
+lsb_release -a
+
+# Verfügbarer Speicher
+df -h
+
+# USB-Ports identifizieren
+lsusb
+
+# Aktuelle Benutzer-Gruppen
+groups $USER
+```
+
+## Installation
+
+### Schritt 1: Repository klonen
+```bash
+# In Home-Verzeichnis wechseln
+cd ~
+
+# Repository klonen
+git clone https://git.gitcover.de/KMU/usb-ssd.git
+
+# In Projekt-Verzeichnis wechseln
+cd usb-ssd
+
+# Repository-Struktur prüfen
+ls -la
+```
+
+### Schritt 2: Installations-Script ausführen
+```bash
+# Standard-Installation (empfohlen)
+sudo ./scripts/installation/install.sh
+
+# Installation mit Verbose-Output
+sudo ./scripts/installation/install.sh --verbose
+
+# Interaktive Installation mit Benutzer-Eingaben
+sudo ./scripts/installation/install.sh --interactive
+```
+
+### Schritt 3: Installation verifizieren
+```bash
+# Installierte Scripts prüfen
+ls -la /usr/local/bin/ssd-*
+
+# Systemd-Services prüfen
+sudo systemctl status ssd-detection.service
+
+# Udev-Rules prüfen
+ls -la /etc/udev/rules.d/99-ssd-*
+
+# Benutzer-Berechtigungen prüfen
+groups $USER
+```
+
+## Erweiterte Installationsoptionen
+
+### Custom-Installation
+```bash
+# Installation in Custom-Verzeichnis
+sudo ./scripts/installation/install.sh --prefix /opt/ssd-tools
+
+# Nur bestimmte Komponenten installieren
+sudo ./scripts/installation/install.sh --components "detection,management"
+
+# Installation ohne Systemd-Services
+sudo ./scripts/installation/install.sh --no-systemd
+
+# Installation mit Custom-Konfiguration
+sudo ./scripts/installation/install.sh --config /path/to/custom.conf
+```
+
+### Benutzer-spezifische Installation
+```bash
+# Installation nur für aktuellen Benutzer (ohne sudo)
+./scripts/installation/install.sh --user-install
+
+# Scripts werden installiert nach:
+# ~/.local/bin/ssd-*
+# ~/.config/ssd-management/
+```
+
+### Entwicklungs-Installation
+```bash
+# Installation mit Debug-Modus
+sudo ./scripts/installation/install.sh --debug --verbose
+
+# Installation mit Entwicklungs-Tools
+sudo ./scripts/installation/install.sh --dev-tools
+
+# Symlinks statt Kopien (für Entwicklung)
+sudo ./scripts/installation/install.sh --symlink
+```
+
+## Post-Installation Konfiguration
+
+### 1. Benutzer-Berechtigungen
+```bash
+# Aktuellen Benutzer zu ssd-users Gruppe hinzufügen
+sudo usermod -a -G ssd-users $USER
+
+# Disk-Gruppe für Hardware-Zugriff
+sudo usermod -a -G disk $USER
+
+# Neue Gruppen-Mitgliedschaft aktivieren
+newgrp ssd-users
+
+# Berechtigungen prüfen
+groups
+```
+
+### 2. Systemd-Services konfigurieren
+```bash
+# Services aktivieren
+sudo systemctl enable ssd-detection.service
+sudo systemctl enable ssd-automount.service
+
+# Services starten
+sudo systemctl start ssd-detection.service
+sudo systemctl start ssd-automount.service
+
+# Status prüfen
+sudo systemctl status ssd-detection.service
+sudo systemctl status ssd-automount.service
+```
+
+### 3. Udev-Rules aktivieren
+```bash
+# Udev-Rules neu laden
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+
+# Test mit angeschlossener USB-SSD
+sudo udevadm test /sys/block/sdb
+```
+
+### 4. Logging konfigurieren
+```bash
+# Log-Verzeichnisse erstellen
+sudo mkdir -p /var/log/ssd-management
+
+# Log-Rotation aktivieren
+sudo systemctl enable logrotate.timer
+
+# Erste Logs prüfen
+sudo tail -f /var/log/ssd-detection.log
+```
+
+## Erste Verwendung
+
+### 1. USB-C SSD anschließen
+```bash
+# SSD anschließen und erkennen lassen
+# Automatische Erkennung durch udev-rules
+
+# Manuelle Erkennung
+ssd-detect.sh
+
+# Erkannte Geräte anzeigen
+lsblk | grep -E "sd[b-z]"
+```
+
+### 2. Erste Mount-Operation
+```bash
+# Automatisches Mounting
+ssd-mount-manager.sh mount
+
+# Mount-Status prüfen
+ssd-mount-manager.sh status
+
+# Mount-Point prüfen
+ls -la /mnt/ssd-storage/
+```
+
+### 3. Test-Suite ausführen
+```bash
+# Schnelle Tests
+ssd-test-suite.sh --quick
+
+# Vollständige Tests
+ssd-test-suite.sh all
+
+# Performance-Benchmark
+ssd-test-suite.sh --benchmark
+```
+
+### 4. Sichere Entfernung
+```bash
+# Safe-Eject ausführen
+ssd-safe-eject.sh
+
+# Status nach Eject prüfen
+ssd-mount-manager.sh status
+```
+
+## Konfiguration anpassen
+
+### 1. Haupt-Konfigurationsdatei
+```bash
+# Konfigurationsdatei bearbeiten
+sudo nano /etc/ssd-management/config.conf
+
+# Beispiel-Konfiguration:
+SSD_MOUNT_POINT="/mnt/ssd-storage"
+SSD_LOG_LEVEL="INFO"
+SSD_AUTO_MOUNT="true"
+SSD_SMB_READY="true"
+```
+
+### 2. Mount-Optionen anpassen
+```bash
+# NTFS-Mount-Optionen
+SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022,windows_names"
+
+# Performance-Optimierungen
+SSD_MOUNT_OPTIONS="$SSD_MOUNT_OPTIONS,big_writes,cache=strict"
+```
+
+### 3. Logging-Level anpassen
+```bash
+# Debug-Logging aktivieren
+export SSD_LOG_LEVEL=DEBUG
+
+# Syslog-Integration
+export SSD_USE_SYSLOG=true
+
+# Log-Datei-Pfad
+export SSD_LOG_FILE="/var/log/ssd-management.log"
+```
+
+## Troubleshooting
+
+### Häufige Installations-Probleme
+
+#### Problem: "Permission denied"
+```bash
+# Lösung: Installation mit sudo ausführen
+sudo ./scripts/installation/install.sh
+
+# Benutzer-Berechtigungen prüfen
+sudo -l
+```
+
+#### Problem: "Package not found"
+```bash
+# Lösung: Repository-Updates durchführen
+sudo apt update  # Ubuntu/Debian
+sudo yum update  # CentOS/RHEL
+
+# EPEL-Repository aktivieren (CentOS/RHEL)
+sudo yum install epel-release
+```
+
+#### Problem: "Systemd service failed"
+```bash
+# Service-Status prüfen
+sudo systemctl status ssd-detection.service
+
+# Service-Logs anzeigen
+sudo journalctl -u ssd-detection.service
+
+# Service neu starten
+sudo systemctl restart ssd-detection.service
+```
+
+#### Problem: "USB device not detected"
+```bash
+# USB-Geräte auflisten
+lsusb
+
+# Block-Geräte anzeigen
+lsblk
+
+# Udev-Events überwachen
+sudo udevadm monitor
+
+# NTFS-Support prüfen
+sudo modprobe ntfs
+```
+
+### Diagnose-Tools
+
+#### System-Diagnose
+```bash
+# Installations-Status prüfen
+./scripts/installation/install.sh --status
+
+# Abhängigkeiten validieren
+./scripts/installation/install.sh --check-dependencies
+
+# Konfiguration testen
+./scripts/installation/install.sh --validate
+```
+
+#### Hardware-Diagnose
+```bash
+# USB-Controller prüfen
+lspci | grep -i usb
+
+# Kernel-Module prüfen
+lsmod | grep -E "(usb|ntfs)"
+
+# Hardware-Logs prüfen
+dmesg | grep -i usb
+```
+
+## Deinstallation
+
+### Vollständige Deinstallation
+```bash
+# Deinstallations-Script ausführen
+sudo ./scripts/installation/uninstall.sh
+
+# Manuelle Bereinigung (falls nötig)
+sudo rm -rf /usr/local/bin/ssd-*
+sudo rm -rf /etc/ssd-management/
+sudo rm -f /etc/systemd/system/ssd-*.service
+sudo rm -f /etc/udev/rules.d/99-ssd-*.rules
+```
+
+### Konfiguration beibehalten
+```bash
+# Nur Scripts entfernen
+sudo ./scripts/installation/uninstall.sh --keep-config
+
+# Logs beibehalten
+sudo ./scripts/installation/uninstall.sh --keep-logs
+```
+
+## Upgrade-Prozess
+
+### Standard-Upgrade
+```bash
+# Repository aktualisieren
+cd ~/usb-ssd
+git pull origin main
+
+# Upgrade ausführen
+sudo ./scripts/installation/install.sh --upgrade
+
+# Services neu starten
+sudo systemctl restart ssd-detection.service ssd-automount.service
+```
+
+### Backup vor Upgrade
+```bash
+# Konfiguration sichern
+sudo cp -r /etc/ssd-management /etc/ssd-management.backup.$(date +%Y%m%d)
+
+# Scripts sichern
+sudo mkdir -p /tmp/ssd-backup
+sudo cp /usr/local/bin/ssd-* /tmp/ssd-backup/
+```
+
+## Support und Hilfe
+
+### Community-Support
+- **Issues**: [Repository Issues](https://git.gitcover.de/KMU/usb-ssd/issues)
+- **Discussions**: Repository-Discussions
+- **Wiki**: [Repository Wiki](https://git.gitcover.de/KMU/usb-ssd/wiki)
+
+### Logs für Support
+```bash
+# System-Informationen sammeln
+sudo ./scripts/installation/install.sh --system-info > system-info.txt
+
+# Logs sammeln
+sudo tar -czf ssd-logs.tar.gz /var/log/ssd-*.log
+
+# Konfiguration anonymisieren
+sudo cp /etc/ssd-management/config.conf config-anonymized.conf
+```
+
+### Enterprise-Support
+Für professionellen Support und Custom-Entwicklungen kontaktieren Sie die GitCover® Organization.
+
+---
+
+**⚠️ Wichtiger Hinweis**: Diese Installation manipuliert System-Konfigurationen und Hardware-Zugriffe. Führen Sie die Installation nur auf Systemen durch, auf denen Sie vollständige administrative Rechte haben und verstehen die Auswirkungen der Änderungen.

docs/troubleshooting.md

@@ -0,0 +1,660 @@
+# USB-SSD Management System - Troubleshooting
+
+## Übersicht
+
+Diese Anleitung hilft bei der Diagnose und Lösung häufiger Probleme mit dem USB-SSD Management System. Die Probleme sind nach Kategorien sortiert und enthalten detaillierte Lösungsschritte.
+
+## Allgemeine Diagnose-Tools
+
+### System-Informationen sammeln
+```bash
+# System-Status prüfen
+./scripts/installation/install.sh --status
+
+# Hardware-Informationen
+lsusb -v | grep -A 10 "Mass Storage"
+lsblk -f
+dmesg | grep -i usb | tail -20
+
+# Service-Status
+sudo systemctl status ssd-detection.service
+sudo systemctl status ssd-automount.service
+
+# Log-Analyse
+tail -50 /var/log/ssd-management.log
+journalctl -u ssd-detection.service --since "1 hour ago"
+```
+
+### Debug-Modus aktivieren
+```bash
+# Environment-Variables setzen
+export SSD_DEBUG=true
+export SSD_VERBOSE=true
+export SSD_LOG_LEVEL=DEBUG
+
+# Scripts mit Debug-Output ausführen
+ssd-detect.sh --debug --verbose
+ssd-mount-manager.sh diagnose
+ssd-test-suite.sh --debug
+```
+
+## Hardware-Probleme
+
+### Problem: USB-C SSD wird nicht erkannt
+
+#### Symptome
+- `lsusb` zeigt das Gerät nicht an
+- Keine Kernel-Messages beim Anschließen
+- `ssd-detect.sh` findet keine Geräte
+
+#### Diagnose
+```bash
+# USB-Controller prüfen
+lspci | grep -i usb
+
+# USB-Geräte auflisten
+lsusb -t
+
+# Kernel-Messages überwachen
+sudo dmesg -w
+# SSD anschließen und Messages beobachten
+
+# USB-Module prüfen
+lsmod | grep -E "(usb|storage)"
+```
+
+#### Lösungsansätze
+```bash
+# 1. USB-Module neu laden
+sudo modprobe -r usb_storage
+sudo modprobe usb_storage
+
+# 2. USB-Controller zurücksetzen
+echo '1-1' | sudo tee /sys/bus/usb/drivers/usb/unbind
+echo '1-1' | sudo tee /sys/bus/usb/drivers/usb/bind
+
+# 3. Udev-Rules neu laden
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+
+# 4. Anderen USB-Port testen
+# SSD an verschiedenen Ports testen
+
+# 5. Power-Management prüfen
+echo 'on' | sudo tee /sys/bus/usb/devices/*/power/control
+```
+
+### Problem: SSD wird erkannt aber nicht als Block-Device
+
+#### Symptome
+- `lsusb` zeigt das Gerät an
+- `lsblk` zeigt kein entsprechendes Device
+- Kernel-Messages zeigen Fehler
+
+#### Diagnose
+```bash
+# Block-Devices auflisten
+lsblk -a
+
+# SCSI-Devices prüfen
+cat /proc/scsi/scsi
+
+# Device-Mapper prüfen
+sudo dmsetup ls
+
+# Partition-Tabelle prüfen
+sudo fdisk -l | grep -A 10 "Disk /dev/sd"
+```
+
+#### Lösungsansätze
+```bash
+# 1. SCSI-Bus neu scannen
+echo "- - -" | sudo tee /sys/class/scsi_host/host*/scan
+
+# 2. Partition-Tabelle reparieren
+sudo parted /dev/sdb print
+sudo parted /dev/sdb mklabel msdos  # Nur wenn nötig!
+
+# 3. Device-Permissions prüfen
+ls -la /dev/sd*
+sudo chmod 660 /dev/sdb*
+
+# 4. Storage-Module neu laden
+sudo modprobe -r usb_storage
+sudo modprobe usb_storage quirks=VENDOR:PRODUCT:u
+```
+
+## Dateisystem-Probleme
+
+### Problem: NTFS-Dateisystem wird nicht unterstützt
+
+#### Symptome
+- Mount schlägt mit "unknown filesystem type 'ntfs'" fehl
+- `ssd-detect.sh` erkennt Filesystem nicht
+- NTFS-Tools nicht verfügbar
+
+#### Diagnose
+```bash
+# NTFS-Support prüfen
+cat /proc/filesystems | grep ntfs
+which ntfs-3g
+dpkg -l | grep ntfs
+
+# Kernel-Module prüfen
+lsmod | grep ntfs
+modinfo ntfs
+```
+
+#### Lösungsansätze
+```bash
+# 1. NTFS-3G installieren
+# Ubuntu/Debian
+sudo apt update
+sudo apt install ntfs-3g
+
+# CentOS/RHEL
+sudo yum install ntfs-3g
+
+# 2. NTFS-Modul laden
+sudo modprobe ntfs
+
+# 3. Fuse-Support prüfen
+sudo modprobe fuse
+ls -la /dev/fuse
+
+# 4. Alternative: exFAT verwenden
+sudo apt install exfat-fuse exfat-utils
+```
+
+### Problem: Filesystem-Korruption
+
+#### Symptome
+- Mount schlägt mit I/O-Fehlern fehl
+- Dateien sind nicht lesbar
+- `ssd-test-suite.sh` zeigt Filesystem-Fehler
+
+#### Diagnose
+```bash
+# Filesystem-Check
+sudo fsck.ntfs -f /dev/sdb1
+sudo ntfsfix /dev/sdb1
+
+# SMART-Daten prüfen
+sudo smartctl -a /dev/sdb
+
+# Bad-Blocks testen
+sudo badblocks -v /dev/sdb1
+```
+
+#### Lösungsansätze
+```bash
+# 1. Read-Only Mount versuchen
+sudo mount -t ntfs -o ro /dev/sdb1 /mnt/ssd-storage
+
+# 2. Filesystem reparieren
+sudo ntfsfix /dev/sdb1
+sudo fsck.ntfs -f /dev/sdb1
+
+# 3. Daten retten
+sudo ddrescue /dev/sdb1 /backup/ssd-image.img /backup/ssd-mapfile
+
+# 4. Neu formatieren (Datenverlust!)
+sudo mkfs.ntfs -f /dev/sdb1
+```
+
+## Mount-Probleme
+
+### Problem: Mount schlägt fehl
+
+#### Symptome
+- `ssd-mount-manager.sh mount` gibt Fehler zurück
+- Mount-Point ist nicht verfügbar
+- Permission-Denied Fehler
+
+#### Diagnose
+```bash
+# Mount-Diagnose
+ssd-mount-manager.sh diagnose
+
+# Aktuelle Mounts prüfen
+mount | grep ssd
+findmnt /mnt/ssd-storage
+
+# Mount-Point Status
+ls -la /mnt/ssd-storage
+stat /mnt/ssd-storage
+
+# Berechtigungen prüfen
+groups $USER
+id $USER
+```
+
+#### Lösungsansätze
+```bash
+# 1. Mount-Point bereinigen
+ssd-mount-manager.sh cleanup
+sudo umount -f /mnt/ssd-storage
+sudo rmdir /mnt/ssd-storage
+sudo mkdir -p /mnt/ssd-storage
+
+# 2. Berechtigungen korrigieren
+sudo chown root:root /mnt/ssd-storage
+sudo chmod 755 /mnt/ssd-storage
+
+# 3. Manueller Mount-Test
+sudo mount -t ntfs /dev/sdb1 /mnt/ssd-storage
+sudo mount -t ntfs -o uid=1000,gid=1000 /dev/sdb1 /mnt/ssd-storage
+
+# 4. Recovery-Modus
+ssd-mount-manager.sh recover
+```
+
+### Problem: Mount hängt oder ist langsam
+
+#### Symptome
+- Mount-Operation dauert sehr lange
+- System reagiert nicht während Mount
+- Hohe I/O-Wait Zeiten
+
+#### Diagnose
+```bash
+# I/O-Status prüfen
+iostat -x 1
+iotop
+
+# Mount-Optionen prüfen
+mount | grep ssd-storage
+
+# USB-Performance prüfen
+sudo hdparm -t /dev/sdb1
+sudo dd if=/dev/sdb1 of=/dev/null bs=1M count=100
+```
+
+#### Lösungsansätze
+```bash
+# 1. Mount-Optionen optimieren
+sudo mount -t ntfs -o big_writes,cache=strict /dev/sdb1 /mnt/ssd-storage
+
+# 2. USB-Performance tunen
+echo mq-deadline | sudo tee /sys/block/sdb/queue/scheduler
+echo 1024 | sudo tee /sys/block/sdb/queue/read_ahead_kb
+
+# 3. Timeout erhöhen
+export SSD_MOUNT_TIMEOUT=120
+ssd-mount-manager.sh mount
+
+# 4. Alternative Mount-Methode
+sudo mount.ntfs-3g /dev/sdb1 /mnt/ssd-storage -o uid=1000,gid=1000
+```
+
+## Service-Probleme
+
+### Problem: Systemd-Services starten nicht
+
+#### Symptome
+- `systemctl start ssd-detection.service` schlägt fehl
+- Services sind im "failed" Status
+- Boot-Prozess hängt bei SSD-Services
+
+#### Diagnose
+```bash
+# Service-Status detailliert
+sudo systemctl status ssd-detection.service -l
+sudo systemctl status ssd-automount.service -l
+
+# Service-Logs
+sudo journalctl -u ssd-detection.service --no-pager
+sudo journalctl -u ssd-automount.service --since "1 hour ago"
+
+# Service-Konfiguration prüfen
+sudo systemctl cat ssd-detection.service
+sudo systemd-analyze verify /etc/systemd/system/ssd-detection.service
+```
+
+#### Lösungsansätze
+```bash
+# 1. Services neu laden
+sudo systemctl daemon-reload
+sudo systemctl reset-failed ssd-detection.service
+
+# 2. Service-Konfiguration reparieren
+sudo systemctl edit ssd-detection.service
+# [Service]
+# Restart=on-failure
+# RestartSec=5
+
+# 3. Dependencies prüfen
+sudo systemctl list-dependencies ssd-detection.service
+
+# 4. Service manuell testen
+sudo /usr/local/bin/ssd-detect.sh --monitor
+```
+
+### Problem: Udev-Rules funktionieren nicht
+
+#### Symptome
+- Automatische Erkennung funktioniert nicht
+- USB-Events lösen keine Scripts aus
+- Manuelle Erkennung funktioniert
+
+#### Diagnose
+```bash
+# Udev-Rules prüfen
+ls -la /etc/udev/rules.d/99-ssd-*
+cat /etc/udev/rules.d/99-ssd-automount.rules
+
+# Udev-Events testen
+sudo udevadm monitor --environment --udev
+# SSD anschließen und Events beobachten
+
+# Rule-Syntax testen
+sudo udevadm test /sys/block/sdb
+```
+
+#### Lösungsansätze
+```bash
+# 1. Rules neu laden
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+
+# 2. Rule-Syntax korrigieren
+sudo nano /etc/udev/rules.d/99-ssd-automount.rules
+# Korrekte Syntax:
+# SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="add", RUN+="/usr/local/bin/ssd-detect.sh --device %k"
+
+# 3. Permissions prüfen
+sudo chmod 644 /etc/udev/rules.d/99-ssd-automount.rules
+
+# 4. Udev-Service neu starten
+sudo systemctl restart systemd-udevd
+```
+
+## Performance-Probleme
+
+### Problem: Langsame SSD-Performance
+
+#### Symptome
+- `ssd-test-suite.sh` zeigt schlechte Performance
+- Datei-Operationen sind langsam
+- Benchmark-Werte unter Erwartung
+
+#### Diagnose
+```bash
+# Performance-Benchmark
+ssd-test-suite.sh --benchmark --detailed
+
+# Hardware-Performance testen
+sudo hdparm -t /dev/sdb1
+sudo dd if=/dev/zero of=/mnt/ssd-storage/testfile bs=1M count=1000
+
+# USB-Geschwindigkeit prüfen
+lsusb -t
+cat /sys/bus/usb/devices/*/speed
+```
+
+#### Lösungsansätze
+```bash
+# 1. USB 3.0+ Port verwenden
+# SSD an USB 3.0+ Port anschließen
+
+# 2. Mount-Optionen optimieren
+sudo mount -o remount,big_writes,cache=strict /mnt/ssd-storage
+
+# 3. I/O-Scheduler optimieren
+echo mq-deadline | sudo tee /sys/block/sdb/queue/scheduler
+
+# 4. Read-Ahead tunen
+echo 2048 | sudo tee /sys/block/sdb/queue/read_ahead_kb
+
+# 5. SSD-Health prüfen
+sudo smartctl -a /dev/sdb
+```
+
+### Problem: Hohe CPU-Last bei SSD-Operationen
+
+#### Symptome
+- Hohe CPU-Auslastung während Mount/Unmount
+- System reagiert langsam bei SSD-Zugriff
+- `top` zeigt hohe System-CPU
+
+#### Diagnose
+```bash
+# CPU-Usage überwachen
+top -p $(pgrep -f ssd-)
+htop
+
+# I/O-Wait analysieren
+iostat -x 1 10
+
+# Prozess-Analyse
+sudo strace -p $(pgrep -f ssd-mount-manager)
+```
+
+#### Lösungsansätze
+```bash
+# 1. Nice-Level anpassen
+sudo renice -n 10 $(pgrep -f ssd-)
+
+# 2. I/O-Priorität setzen
+sudo ionice -c 3 -p $(pgrep -f ssd-)
+
+# 3. Concurrent-Operations reduzieren
+export SSD_MAX_PARALLEL_OPS=1
+
+# 4. Caching optimieren
+echo 1 | sudo tee /proc/sys/vm/drop_caches
+```
+
+## Eject-Probleme
+
+### Problem: Safe-Eject schlägt fehl
+
+#### Symptome
+- `ssd-safe-eject.sh` gibt Fehler zurück
+- "Device is busy" Meldungen
+- Unmount schlägt fehl
+
+#### Diagnose
+```bash
+# Blockierende Prozesse finden
+ssd-safe-eject.sh --show-processes
+lsof /mnt/ssd-storage
+fuser -v /mnt/ssd-storage
+
+# Mount-Status prüfen
+mount | grep ssd-storage
+findmnt /mnt/ssd-storage
+
+# Buffer-Status prüfen
+cat /proc/meminfo | grep -E "(Dirty|Writeback)"
+```
+
+#### Lösungsansätze
+```bash
+# 1. Prozesse beenden
+ssd-safe-eject.sh --kill-processes
+sudo fuser -km /mnt/ssd-storage
+
+# 2. Buffer-Flush erzwingen
+sync
+echo 3 | sudo tee /proc/sys/vm/drop_caches
+
+# 3. Force-Unmount
+sudo umount -f /mnt/ssd-storage
+sudo umount -l /mnt/ssd-storage  # Lazy unmount
+
+# 4. Hardware-Reset
+echo 1 | sudo tee /sys/block/sdb/device/delete
+```
+
+### Problem: Hardware-Eject funktioniert nicht
+
+#### Symptome
+- Unmount erfolgreich, aber LED blinkt weiter
+- SSD kann nicht physisch entfernt werden
+- `eject` Befehl schlägt fehl
+
+#### Diagnose
+```bash
+# Eject-Fähigkeiten prüfen
+sudo hdparm -I /dev/sdb | grep -i removable
+cat /sys/block/sdb/removable
+
+# SCSI-Eject testen
+sudo sg_start --eject /dev/sdb
+```
+
+#### Lösungsansätze
+```bash
+# 1. Standard-Eject
+sudo eject /dev/sdb
+
+# 2. SCSI-Eject
+sudo sg_start --stop --eject /dev/sdb
+
+# 3. USB-Device entfernen
+echo 1 | sudo tee /sys/block/sdb/device/delete
+
+# 4. Power-Management
+echo auto | sudo tee /sys/block/sdb/device/power/control
+```
+
+## Logging-Probleme
+
+### Problem: Logs werden nicht erstellt
+
+#### Symptome
+- Log-Dateien sind leer oder existieren nicht
+- Keine Einträge in Systemd-Journal
+- Debug-Output wird nicht angezeigt
+
+#### Diagnose
+```bash
+# Log-Verzeichnisse prüfen
+ls -la /var/log/ssd-*
+ls -la /var/log/syslog
+
+# Berechtigungen prüfen
+stat /var/log/ssd-management.log
+sudo -u ssd-user touch /var/log/test.log
+
+# Syslog-Konfiguration
+cat /etc/rsyslog.d/50-ssd-management.conf
+sudo systemctl status rsyslog
+```
+
+#### Lösungsansätze
+```bash
+# 1. Log-Verzeichnisse erstellen
+sudo mkdir -p /var/log/ssd-management
+sudo chown syslog:adm /var/log/ssd-management
+
+# 2. Berechtigungen korrigieren
+sudo chmod 644 /var/log/ssd-*.log
+sudo chown syslog:adm /var/log/ssd-*.log
+
+# 3. Syslog neu starten
+sudo systemctl restart rsyslog
+
+# 4. Manuelle Log-Tests
+logger -t ssd-test "Test message"
+tail -f /var/log/syslog | grep ssd-test
+```
+
+## Erweiterte Diagnose
+
+### Vollständige System-Diagnose
+```bash
+#!/bin/bash
+# system-diagnosis.sh
+
+echo "=== USB-SSD System Diagnosis ==="
+echo "Date: $(date)"
+echo "User: $(whoami)"
+echo
+
+echo "=== System Information ==="
+uname -a
+lsb_release -a 2>/dev/null || cat /etc/os-release
+echo
+
+echo "=== Hardware Information ==="
+lsusb -v | grep -A 10 "Mass Storage"
+lsblk -f
+lspci | grep -i usb
+echo
+
+echo "=== Service Status ==="
+systemctl status ssd-detection.service --no-pager
+systemctl status ssd-automount.service --no-pager
+echo
+
+echo "=== Mount Status ==="
+mount | grep ssd
+findmnt /mnt/ssd-storage
+echo
+
+echo "=== Log Analysis ==="
+tail -20 /var/log/ssd-management.log
+journalctl -u ssd-detection.service --since "1 hour ago" --no-pager
+echo
+
+echo "=== Performance Test ==="
+if [ -b /dev/sdb1 ]; then
+    sudo hdparm -t /dev/sdb1
+fi
+echo
+
+echo "=== Configuration ==="
+cat /etc/ssd-management/config.conf 2>/dev/null || echo "No config file found"
+echo
+
+echo "=== Diagnosis Complete ==="
+```
+
+### Log-Sammlung für Support
+```bash
+#!/bin/bash
+# collect-logs.sh
+
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+LOGDIR="/tmp/ssd-logs-$TIMESTAMP"
+
+mkdir -p "$LOGDIR"
+
+# System-Logs
+cp /var/log/ssd-*.log "$LOGDIR/" 2>/dev/null
+journalctl -u ssd-detection.service > "$LOGDIR/systemd-detection.log"
+journalctl -u ssd-automount.service > "$LOGDIR/systemd-automount.log"
+
+# Konfiguration
+cp -r /etc/ssd-management/ "$LOGDIR/config/" 2>/dev/null
+cp /etc/udev/rules.d/99-ssd-*.rules "$LOGDIR/" 2>/dev/null
+
+# System-Informationen
+./system-diagnosis.sh > "$LOGDIR/diagnosis.txt"
+
+# Archiv erstellen
+tar -czf "ssd-logs-$TIMESTAMP.tar.gz" -C /tmp "ssd-logs-$TIMESTAMP"
+echo "Logs collected in: ssd-logs-$TIMESTAMP.tar.gz"
+```
+
+## Support-Kontakt
+
+### Vor Support-Anfrage
+1. **Diagnose durchführen**: `system-diagnosis.sh` ausführen
+2. **Logs sammeln**: `collect-logs.sh` verwenden
+3. **Reproduzierbarkeit**: Problem-Schritte dokumentieren
+4. **System-Details**: Hardware und Software-Versionen angeben
+
+### Community-Support
+- **Issues**: [Repository Issues](https://git.gitcover.de/KMU/usb-ssd/issues)
+- **Discussions**: Repository-Discussions für allgemeine Fragen
+- **Wiki**: [Repository Wiki](https://git.gitcover.de/KMU/usb-ssd/wiki)
+
+### Enterprise-Support
+Für professionellen Support und Custom-Entwicklungen kontaktieren Sie die GitCover® Organization.
+
+---
+
+**⚠️ Wichtiger Hinweis**: Bei kritischen Produktionsproblemen immer zuerst Backups erstellen und in einer Testumgebung reproduzieren, bevor Lösungsschritte angewendet werden.

docs/usage-guide.md

@@ -0,0 +1,570 @@
+# USB-SSD Management System - Nutzungshandbuch
+
+## Übersicht
+
+Dieses Handbuch beschreibt die detaillierte Nutzung aller Funktionen des USB-SSD Management Systems. Es richtet sich an System-Administratoren, DevOps-Engineers und Entwickler in KMU-Umgebungen.
+
+## Grundlegende Konzepte
+
+### Konstanter Mount-Point
+Das System verwendet einen konstanten logischen Mount-Point (`/mnt/ssd-storage`), unabhängig von der physischen SSD:
+- **Vorteil**: Anwendungen können immer denselben Pfad verwenden
+- **Flexibilität**: SSDs können gewechselt werden ohne Anpassung der Konfiguration
+- **SMB-Integration**: Freigaben bleiben konstant verfügbar
+
+### UUID-basierte Identifikation
+Alle Operationen basieren auf UUID-Identifikation statt Device-Namen:
+- **Stabilität**: Unabhängig von USB-Port-Wechseln
+- **Sicherheit**: Eindeutige Identifikation verhindert Verwechslungen
+- **Logging**: Nachverfolgbare Audit-Trails
+
+## Täglicher Workflow
+
+### 1. SSD anschließen und erkennen
+```bash
+# USB-C SSD anschließen
+# Automatische Erkennung durch udev-rules
+
+# Manuelle Erkennung (falls nötig)
+ssd-detect.sh
+
+# Erkannte SSDs anzeigen
+ssd-detect.sh --list
+
+# Detaillierte Informationen
+ssd-detect.sh --verbose
+```
+
+### 2. SSD mounten
+```bash
+# Automatisches Mounting
+ssd-mount-manager.sh mount
+
+# Spezifische SSD mounten
+ssd-mount-manager.sh mount --device /dev/sdb1
+
+# Read-Only Mount für Prüfungen
+ssd-mount-manager.sh mount --readonly
+
+# Mount-Status prüfen
+ssd-mount-manager.sh status
+```
+
+### 3. Mit SSD arbeiten
+```bash
+# Verfügbaren Speicher prüfen
+df -h /mnt/ssd-storage
+
+# Dateien kopieren
+cp -r /home/user/documents/ /mnt/ssd-storage/backup/
+
+# Berechtigungen prüfen
+ls -la /mnt/ssd-storage/
+
+# SMB-Freigabe testen (falls konfiguriert)
+smbclient //localhost/ssd-storage -U $USER
+```
+
+### 4. SSD sicher entfernen
+```bash
+# Sichere Entfernung
+ssd-safe-eject.sh
+
+# Mit Prozess-Übersicht
+ssd-safe-eject.sh --show-processes
+
+# Force-Eject bei hängenden Prozessen
+ssd-safe-eject.sh --force
+
+# Status nach Entfernung prüfen
+ssd-mount-manager.sh status
+```
+
+## Erweiterte Funktionen
+
+### SSD-Erkennung (ssd-detect.sh)
+
+#### Grundlegende Verwendung
+```bash
+# Alle USB-Storage-Geräte erkennen
+ssd-detect.sh
+
+# Nur NTFS-Partitionen
+ssd-detect.sh --ntfs-only
+
+# JSON-Output für Automation
+ssd-detect.sh --output json
+
+# Kontinuierliche Überwachung
+ssd-detect.sh --monitor --interval 5
+```
+
+#### Erweiterte Optionen
+```bash
+# Spezifisches Device prüfen
+ssd-detect.sh --device /dev/sdb1
+
+# Hardware-Details anzeigen
+ssd-detect.sh --hardware-info
+
+# Performance-Informationen
+ssd-detect.sh --performance-info
+
+# Debug-Modus
+ssd-detect.sh --debug --verbose
+```
+
+#### Output-Beispiele
+```bash
+# Standard-Output
+[INFO] USB-C SSD detected: /dev/sdb1
+[INFO] Filesystem: NTFS
+[INFO] UUID: 1234-5678-9ABC-DEF0
+[INFO] Size: 500GB
+[INFO] Label: BACKUP_SSD
+[SUCCESS] Device ready for mounting
+
+# JSON-Output
+{
+  "device": "/dev/sdb1",
+  "filesystem": "ntfs",
+  "uuid": "1234-5678-9ABC-DEF0",
+  "size": "500GB",
+  "label": "BACKUP_SSD",
+  "status": "ready",
+  "usb_version": "3.0",
+  "speed": "5Gbps"
+}
+```
+
+### Mount-Management (ssd-mount-manager.sh)
+
+#### Mount-Operationen
+```bash
+# Standard-Mount
+ssd-mount-manager.sh mount
+
+# Custom Mount-Point
+ssd-mount-manager.sh mount --mountpoint /custom/path
+
+# Spezifische Mount-Optionen
+ssd-mount-manager.sh mount --options "uid=1000,gid=1000,umask=022"
+
+# SMB-optimiertes Mounting
+ssd-mount-manager.sh mount --smb-ready
+```
+
+#### Status und Monitoring
+```bash
+# Aktueller Status
+ssd-mount-manager.sh status
+
+# Detaillierte Informationen
+ssd-mount-manager.sh status --detailed
+
+# JSON-Output für Monitoring
+ssd-mount-manager.sh status --json
+
+# Performance-Metriken
+ssd-mount-manager.sh metrics
+```
+
+#### Troubleshooting
+```bash
+# Mount-Probleme diagnostizieren
+ssd-mount-manager.sh diagnose
+
+# Mount-Point bereinigen
+ssd-mount-manager.sh cleanup
+
+# Recovery-Modus
+ssd-mount-manager.sh recover
+
+# Filesystem-Check vor Mount
+ssd-mount-manager.sh mount --fsck
+```
+
+### Test-Suite (ssd-test-suite.sh)
+
+#### Grundlegende Tests
+```bash
+# Alle Tests ausführen
+ssd-test-suite.sh all
+
+# Schnelle Tests (nur kritische)
+ssd-test-suite.sh --quick
+
+# Spezifischen Test ausführen
+ssd-test-suite.sh T01  # Hardware Detection
+ssd-test-suite.sh T04  # Read Performance
+ssd-test-suite.sh T08  # SMB Readiness
+```
+
+#### Test-Kategorien
+```bash
+# Hardware-Tests
+ssd-test-suite.sh --category hardware
+
+# Performance-Tests
+ssd-test-suite.sh --category performance
+
+# Integration-Tests
+ssd-test-suite.sh --category integration
+
+# Security-Tests
+ssd-test-suite.sh --category security
+```
+
+#### Benchmark-Modus
+```bash
+# Performance-Benchmark
+ssd-test-suite.sh --benchmark
+
+# Detaillierte Performance-Analyse
+ssd-test-suite.sh --benchmark --detailed
+
+# Vergleich mit Baseline
+ssd-test-suite.sh --benchmark --compare baseline.json
+
+# Kontinuierliche Performance-Überwachung
+ssd-test-suite.sh --benchmark --continuous --interval 3600
+```
+
+### Sichere Entfernung (ssd-safe-eject.sh)
+
+#### Standard-Eject
+```bash
+# Sichere Entfernung
+ssd-safe-eject.sh
+
+# Mit Verbose-Output
+ssd-safe-eject.sh --verbose
+
+# Dry-Run (Simulation)
+ssd-safe-eject.sh --dry-run
+```
+
+#### Erweiterte Eject-Optionen
+```bash
+# Aktive Prozesse anzeigen
+ssd-safe-eject.sh --show-processes
+
+# Prozesse automatisch beenden
+ssd-safe-eject.sh --kill-processes
+
+# Force-Eject bei Problemen
+ssd-safe-eject.sh --force
+
+# Nur Unmount (ohne Hardware-Eject)
+ssd-safe-eject.sh --unmount-only
+```
+
+#### Timeout-Konfiguration
+```bash
+# Custom Buffer-Flush Timeout
+ssd-safe-eject.sh --timeout 120
+
+# Prozess-Kill Timeout
+ssd-safe-eject.sh --process-timeout 30
+
+# Hardware-Eject Timeout
+ssd-safe-eject.sh --eject-timeout 10
+```
+
+## Use Cases und Workflows
+
+### 1. KMU-Backup-System
+```bash
+#!/bin/bash
+# Tägliches Backup-Script
+
+# SSD mounten
+ssd-mount-manager.sh mount || exit 1
+
+# Backup durchführen
+rsync -av --delete /important/data/ /mnt/ssd-storage/backup/
+
+# Backup verifizieren
+if [ $? -eq 0 ]; then
+    echo "Backup erfolgreich"
+    # Optional: Test-Suite ausführen
+    ssd-test-suite.sh --quick
+else
+    echo "Backup fehlgeschlagen"
+    exit 1
+fi
+
+# SSD sicher entfernen
+ssd-safe-eject.sh
+```
+
+### 2. Entwicklungsumgebung
+```bash
+#!/bin/bash
+# Projekt-SSD wechseln
+
+# Aktuelle SSD sicher entfernen
+ssd-safe-eject.sh
+
+echo "Bitte neue Projekt-SSD anschließen..."
+read -p "Drücken Sie Enter wenn bereit..."
+
+# Neue SSD erkennen und mounten
+ssd-detect.sh
+ssd-mount-manager.sh mount
+
+# Projekt-Verzeichnis wechseln
+cd /mnt/ssd-storage/project-alpha/
+
+echo "Entwicklungsumgebung bereit"
+```
+
+### 3. Media-Server Erweiterung
+```bash
+#!/bin/bash
+# Neue Media-Library hinzufügen
+
+# SSD mounten
+ssd-mount-manager.sh mount --smb-ready
+
+# Qualitätsprüfung
+ssd-test-suite.sh all
+
+# Media-Verzeichnis erstellen
+mkdir -p /mnt/ssd-storage/media/videos
+mkdir -p /mnt/ssd-storage/media/music
+
+# Berechtigungen für Media-Server setzen
+chown -R mediaserver:mediaserver /mnt/ssd-storage/media/
+chmod -R 755 /mnt/ssd-storage/media/
+
+# SMB-Freigabe neu laden (falls konfiguriert)
+sudo systemctl reload smbd
+
+echo "Media-Library bereit"
+```
+
+### 4. Sichere Datenübertragung
+```bash
+#!/bin/bash
+# Verschlüsselte Datenübertragung
+
+# SSD read-only mounten für Prüfung
+ssd-mount-manager.sh mount --readonly
+
+# Datenintegrität prüfen
+ssd-test-suite.sh T02 T06  # Filesystem + File Operations
+
+# Read-Write remount
+ssd-mount-manager.sh remount --readwrite
+
+# Verschlüsselte Daten entschlüsseln
+gpg --decrypt /mnt/ssd-storage/encrypted.gpg > /tmp/decrypted.txt
+
+# Verarbeitung...
+process_data.sh /tmp/decrypted.txt
+
+# Temporäre Dateien sicher löschen
+shred -vfz -n 3 /tmp/decrypted.txt
+
+# SSD sicher entfernen
+ssd-safe-eject.sh
+```
+
+## Konfiguration und Anpassung
+
+### Environment Variables
+```bash
+# Mount-Konfiguration
+export SSD_MOUNT_POINT="/mnt/ssd-storage"
+export SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022"
+export SSD_MOUNT_TIMEOUT=30
+
+# Logging-Konfiguration
+export SSD_LOG_LEVEL=INFO
+export SSD_LOG_FILE="/var/log/ssd-management.log"
+export SSD_USE_SYSLOG=true
+
+# Test-Konfiguration
+export SSD_TEST_TIMEOUT=300
+export SSD_TEST_SIZE=100
+export SSD_BENCHMARK_MODE=false
+
+# Eject-Konfiguration
+export SSD_EJECT_TIMEOUT=60
+export SSD_PROCESS_TIMEOUT=10
+export SSD_HARDWARE_EJECT=true
+```
+
+### Konfigurationsdatei
+```bash
+# /etc/ssd-management/config.conf
+[mount]
+default_mount_point = /mnt/ssd-storage
+ntfs_options = uid=1000,gid=1000,umask=022,windows_names
+auto_mount = true
+smb_ready = true
+
+[logging]
+log_level = INFO
+log_file = /var/log/ssd-management.log
+use_syslog = true
+rotate_logs = true
+
+[testing]
+quick_tests = T01,T02,T03,T08
+performance_threshold_read = 50MB/s
+performance_threshold_write = 30MB/s
+benchmark_enabled = false
+
+[security]
+require_sudo = true
+audit_logging = true
+process_detection = true
+buffer_monitoring = true
+```
+
+## Monitoring und Logging
+
+### Log-Analyse
+```bash
+# Aktuelle Logs anzeigen
+tail -f /var/log/ssd-management.log
+
+# Fehler-Logs filtern
+grep ERROR /var/log/ssd-management.log
+
+# Performance-Logs analysieren
+grep PERFORMANCE /var/log/ssd-management.log | tail -20
+
+# Audit-Trail anzeigen
+grep AUDIT /var/log/ssd-management.log
+```
+
+### Systemd-Journal
+```bash
+# Service-Logs anzeigen
+journalctl -u ssd-detection.service -f
+
+# Fehler-Logs der letzten Stunde
+journalctl -u ssd-automount.service --since "1 hour ago" -p err
+
+# Boot-Logs für SSD-Services
+journalctl -b -u ssd-detection.service
+```
+
+### Performance-Monitoring
+```bash
+# Aktuelle Performance-Metriken
+ssd-mount-manager.sh metrics
+
+# Performance-Trend (letzte 24h)
+ssd-test-suite.sh --benchmark --trend --hours 24
+
+# Prometheus-Metriken exportieren
+ssd-test-suite.sh --prometheus-metrics > /var/lib/prometheus/ssd-metrics.prom
+```
+
+## Troubleshooting
+
+### Häufige Probleme und Lösungen
+
+#### Problem: SSD wird nicht erkannt
+```bash
+# Diagnose
+lsusb                    # USB-Geräte auflisten
+lsblk                    # Block-Geräte anzeigen
+dmesg | tail -20         # Kernel-Messages prüfen
+
+# Lösungsansätze
+sudo udevadm trigger     # Udev-Events neu auslösen
+sudo modprobe ntfs       # NTFS-Modul laden
+ssd-detect.sh --debug   # Debug-Modus
+```
+
+#### Problem: Mount schlägt fehl
+```bash
+# Diagnose
+ssd-mount-manager.sh diagnose
+sudo fsck.ntfs /dev/sdb1  # Filesystem prüfen
+mount | grep ssd-storage  # Aktuelle Mounts prüfen
+
+# Lösungsansätze
+ssd-mount-manager.sh cleanup    # Mount-Point bereinigen
+ssd-mount-manager.sh recover    # Recovery-Modus
+sudo umount -f /mnt/ssd-storage # Force-Unmount
+```
+
+#### Problem: Eject hängt
+```bash
+# Diagnose
+ssd-safe-eject.sh --show-processes  # Blockierende Prozesse
+lsof /mnt/ssd-storage               # Offene Dateien
+fuser -v /mnt/ssd-storage           # Prozess-Details
+
+# Lösungsansätze
+ssd-safe-eject.sh --kill-processes  # Prozesse beenden
+ssd-safe-eject.sh --force          # Force-Eject
+sudo fuser -km /mnt/ssd-storage     # Alle Prozesse killen
+```
+
+### Debug-Modi
+```bash
+# Alle Scripts mit Debug-Output
+export SSD_DEBUG=true
+export SSD_VERBOSE=true
+
+# Trace-Modus für Scripts
+bash -x ssd-detect.sh
+
+# Systemd-Service Debug
+sudo systemctl edit ssd-detection.service
+# [Service]
+# Environment=SSD_DEBUG=true
+```
+
+## Best Practices
+
+### Produktionsumgebung
+1. **Regelmäßige Tests**: Tägliche Quick-Tests, wöchentliche Full-Tests
+2. **Monitoring**: Performance-Metriken überwachen, Alerts konfigurieren
+3. **Backup**: Konfiguration und Logs regelmäßig sichern
+4. **Updates**: System und Scripts aktuell halten
+5. **Dokumentation**: Änderungen und Konfigurationen dokumentieren
+
+### Sicherheit
+1. **Berechtigungen**: Minimale Berechtigungen verwenden
+2. **Audit-Logs**: Alle Operationen protokollieren
+3. **Verschlüsselung**: Sensible Daten verschlüsselt übertragen
+4. **Access-Control**: Zugriff auf autorisierte Benutzer beschränken
+5. **Regular-Scans**: Regelmäßige Security-Tests durchführen
+
+### Performance
+1. **USB 3.0+**: Moderne USB-Standards verwenden
+2. **SSD-Qualität**: Hochwertige SSDs für kritische Anwendungen
+3. **Mount-Optionen**: Performance-optimierte NTFS-Optionen
+4. **Caching**: Angemessene Cache-Konfiguration
+5. **Monitoring**: Performance-Degradation frühzeitig erkennen
+
+---
+
+**💡 Tipp**: Nutzen Sie die `--help` Option bei allen Scripts für detaillierte Informationen zu verfügbaren Parametern und Optionen.
+
+## Anhang
+
+### Script-Referenz
+- `ssd-detect.sh` - Hardware-Erkennung und Device-Identifikation
+- `ssd-mount-manager.sh` - Mount-Lifecycle Management
+- `ssd-test-suite.sh` - Qualitätssicherung und Performance-Tests
+- `ssd-safe-eject.sh` - Sichere Hardware-Entfernung
+
+### Wichtige Pfade
+- `/mnt/ssd-storage/` - Standard Mount-Point
+- `/etc/ssd-management/` - Konfigurationsdateien
+- `/var/log/ssd-*.log` - Log-Dateien
+- `/usr/local/bin/ssd-*` - Installierte Scripts
+
+### Support-Ressourcen
+- [Installation Guide](installation-guide.md) - Detaillierte Installation
+- [Troubleshooting](troubleshooting.md) - Problemlösungen
+- [API Reference](api-reference.md) - Script-Parameter Referenz

examples/smb-configuration/setup-smb.sh

@@ -0,0 +1,490 @@
+#!/bin/bash
+# USB-SSD Management System - SMB Setup Script
+# Automatische Konfiguration von Samba für USB-C SSD Freigaben
+#
+# Verwendung:
+# sudo ./setup-smb.sh [OPTIONS]
+#
+# Optionen:
+# --install-samba    Samba-Pakete installieren
+# --configure-users  Benutzer und Gruppen konfigurieren
+# --setup-shares     Freigaben konfigurieren
+# --enable-services  Services aktivieren und starten
+# --all              Alle Schritte ausführen
+
+set -euo pipefail
+
+# ============================================================================
+# Konfiguration
+# ============================================================================
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SMB_CONF="/etc/samba/smb.conf"
+SMB_CONF_BACKUP="/etc/samba/smb.conf.backup.$(date +%Y%m%d_%H%M%S)"
+SSD_MOUNT_POINT="/mnt/ssd-storage"
+LOG_FILE="/var/log/ssd-smb-setup.log"
+
+# Farben für Output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# ============================================================================
+# Logging-Funktionen
+# ============================================================================
+
+log() {
+    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}" | tee -a "$LOG_FILE"
+}
+
+warn() {
+    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}" | tee -a "$LOG_FILE"
+}
+
+error() {
+    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}" | tee -a "$LOG_FILE"
+    exit 1
+}
+
+info() {
+    echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] INFO: $1${NC}" | tee -a "$LOG_FILE"
+}
+
+# ============================================================================
+# Hilfsfunktionen
+# ============================================================================
+
+check_root() {
+    if [[ $EUID -ne 0 ]]; then
+        error "Dieses Script muss als root ausgeführt werden (sudo)"
+    fi
+}
+
+check_mount_point() {
+    if [[ ! -d "$SSD_MOUNT_POINT" ]]; then
+        warn "Mount-Point $SSD_MOUNT_POINT existiert nicht - wird erstellt"
+        mkdir -p "$SSD_MOUNT_POINT"
+        chmod 755 "$SSD_MOUNT_POINT"
+    fi
+}
+
+detect_os() {
+    if [[ -f /etc/os-release ]]; then
+        . /etc/os-release
+        OS=$ID
+        VERSION=$VERSION_ID
+    else
+        error "Betriebssystem konnte nicht erkannt werden"
+    fi
+    
+    log "Erkanntes OS: $OS $VERSION"
+}
+
+# ============================================================================
+# Samba-Installation
+# ============================================================================
+
+install_samba() {
+    log "Installiere Samba-Pakete..."
+    
+    case "$OS" in
+        ubuntu|debian)
+            apt update
+            apt install -y samba samba-common-bin smbclient cifs-utils
+            ;;
+        centos|rhel|fedora)
+            if command -v dnf &> /dev/null; then
+                dnf install -y samba samba-common samba-client cifs-utils
+            else
+                yum install -y samba samba-common samba-client cifs-utils
+            fi
+            ;;
+        *)
+            error "Nicht unterstütztes Betriebssystem: $OS"
+            ;;
+    esac
+    
+    log "Samba-Installation abgeschlossen"
+}
+
+# ============================================================================
+# Benutzer und Gruppen
+# ============================================================================
+
+configure_users() {
+    log "Konfiguriere Benutzer und Gruppen..."
+    
+    # Gruppen erstellen
+    local groups=(
+        "ssd-users:Benutzer mit SSD-Zugriff"
+        "ssd-admins:SSD-Administratoren"
+        "ssd-readonly:Nur-Lese-Zugriff auf SSD"
+        "backup-users:Backup-Benutzer"
+        "backup-admins:Backup-Administratoren"
+        "media-users:Media-Benutzer"
+        "developers:Entwickler"
+        "dev-leads:Entwicklungsleiter"
+        "archive-admins:Archiv-Administratoren"
+    )
+    
+    for group_info in "${groups[@]}"; do
+        local group_name="${group_info%%:*}"
+        local group_desc="${group_info##*:}"
+        
+        if ! getent group "$group_name" &>/dev/null; then
+            groupadd "$group_name"
+            log "Gruppe erstellt: $group_name ($group_desc)"
+        else
+            info "Gruppe existiert bereits: $group_name"
+        fi
+    done
+    
+    # Standard-Benutzer zu ssd-users hinzufügen
+    if [[ -n "${SUDO_USER:-}" ]]; then
+        usermod -a -G ssd-users "$SUDO_USER"
+        log "Benutzer $SUDO_USER zu ssd-users hinzugefügt"
+    fi
+    
+    # Service-Benutzer erstellen
+    if ! id "ssd-service" &>/dev/null; then
+        useradd -r -s /bin/false -d /var/lib/ssd-service -c "SSD Service User" ssd-service
+        usermod -a -G ssd-users ssd-service
+        log "Service-Benutzer ssd-service erstellt"
+    fi
+    
+    log "Benutzer- und Gruppen-Konfiguration abgeschlossen"
+}
+
+# ============================================================================
+# Verzeichnis-Struktur
+# ============================================================================
+
+setup_directories() {
+    log "Erstelle Verzeichnis-Struktur..."
+    
+    local directories=(
+        "$SSD_MOUNT_POINT"
+        "$SSD_MOUNT_POINT/backup"
+        "$SSD_MOUNT_POINT/archive"
+        "$SSD_MOUNT_POINT/media"
+        "$SSD_MOUNT_POINT/development"
+        "$SSD_MOUNT_POINT/temp"
+        "$SSD_MOUNT_POINT/home"
+    )
+    
+    for dir in "${directories[@]}"; do
+        if [[ ! -d "$dir" ]]; then
+            mkdir -p "$dir"
+            log "Verzeichnis erstellt: $dir"
+        fi
+    done
+    
+    # Berechtigungen setzen
+    chown -R root:ssd-users "$SSD_MOUNT_POINT"
+    chmod -R 775 "$SSD_MOUNT_POINT"
+    
+    # Spezielle Berechtigungen
+    chmod 755 "$SSD_MOUNT_POINT/backup"
+    chown root:backup-users "$SSD_MOUNT_POINT/backup"
+    
+    chmod 755 "$SSD_MOUNT_POINT/archive"
+    chown root:archive-admins "$SSD_MOUNT_POINT/archive"
+    
+    chmod 777 "$SSD_MOUNT_POINT/temp"
+    
+    log "Verzeichnis-Struktur konfiguriert"
+}
+
+# ============================================================================
+# SMB-Konfiguration
+# ============================================================================
+
+backup_smb_config() {
+    if [[ -f "$SMB_CONF" ]]; then
+        cp "$SMB_CONF" "$SMB_CONF_BACKUP"
+        log "SMB-Konfiguration gesichert: $SMB_CONF_BACKUP"
+    fi
+}
+
+setup_smb_config() {
+    log "Konfiguriere Samba..."
+    
+    backup_smb_config
+    
+    # Neue Konfiguration kopieren
+    if [[ -f "$SCRIPT_DIR/smb.conf.example" ]]; then
+        cp "$SCRIPT_DIR/smb.conf.example" "$SMB_CONF"
+        log "SMB-Konfiguration installiert"
+    else
+        error "SMB-Konfigurationsdatei nicht gefunden: $SCRIPT_DIR/smb.conf.example"
+    fi
+    
+    # Mount-Point in Konfiguration anpassen
+    sed -i "s|/mnt/ssd-storage|$SSD_MOUNT_POINT|g" "$SMB_CONF"
+    
+    # Konfiguration validieren
+    if testparm -s "$SMB_CONF" &>/dev/null; then
+        log "SMB-Konfiguration ist gültig"
+    else
+        error "SMB-Konfiguration ist ungültig"
+    fi
+    
+    log "SMB-Konfiguration abgeschlossen"
+}
+
+# ============================================================================
+# Service-Konfiguration
+# ============================================================================
+
+enable_services() {
+    log "Aktiviere und starte Services..."
+    
+    local services=("smbd" "nmbd")
+    
+    for service in "${services[@]}"; do
+        systemctl enable "$service"
+        systemctl restart "$service"
+        
+        if systemctl is-active --quiet "$service"; then
+            log "Service $service ist aktiv"
+        else
+            error "Service $service konnte nicht gestartet werden"
+        fi
+    done
+    
+    # Firewall-Konfiguration (falls UFW aktiv)
+    if command -v ufw &> /dev/null && ufw status | grep -q "Status: active"; then
+        ufw allow samba
+        log "Firewall-Regel für Samba hinzugefügt"
+    fi
+    
+    log "Service-Konfiguration abgeschlossen"
+}
+
+# ============================================================================
+# Benutzer-Setup
+# ============================================================================
+
+setup_samba_users() {
+    log "Konfiguriere Samba-Benutzer..."
+    
+    # Aktueller Benutzer (falls vorhanden)
+    if [[ -n "${SUDO_USER:-}" ]]; then
+        echo "Samba-Passwort für Benutzer $SUDO_USER setzen:"
+        smbpasswd -a "$SUDO_USER"
+        smbpasswd -e "$SUDO_USER"
+        log "Samba-Benutzer $SUDO_USER konfiguriert"
+    fi
+    
+    # Service-Benutzer (ohne Passwort-Login)
+    smbpasswd -a ssd-service -n
+    smbpasswd -d ssd-service
+    
+    log "Samba-Benutzer-Konfiguration abgeschlossen"
+}
+
+# ============================================================================
+# Tests und Validierung
+# ============================================================================
+
+test_smb_config() {
+    log "Teste SMB-Konfiguration..."
+    
+    # Konfiguration testen
+    if ! testparm -s &>/dev/null; then
+        error "SMB-Konfiguration ist ungültig"
+    fi
+    
+    # Services testen
+    for service in smbd nmbd; do
+        if ! systemctl is-active --quiet "$service"; then
+            error "Service $service ist nicht aktiv"
+        fi
+    done
+    
+    # Freigaben testen
+    if ! smbclient -L localhost -N &>/dev/null; then
+        warn "SMB-Freigaben sind nicht erreichbar"
+    else
+        log "SMB-Freigaben sind erreichbar"
+    fi
+    
+    log "SMB-Tests abgeschlossen"
+}
+
+# ============================================================================
+# Cleanup und Wartung
+# ============================================================================
+
+setup_maintenance() {
+    log "Konfiguriere Wartungs-Scripts..."
+    
+    # Temp-Verzeichnis Cleanup
+    cat > /etc/cron.daily/ssd-temp-cleanup << 'EOF'
+#!/bin/bash
+# Bereinige temporäre SSD-Dateien (älter als 7 Tage)
+find /mnt/ssd-storage/temp -type f -mtime +7 -delete 2>/dev/null || true
+find /mnt/ssd-storage/temp -type d -empty -delete 2>/dev/null || true
+EOF
+    
+    chmod +x /etc/cron.daily/ssd-temp-cleanup
+    
+    # Log-Rotation für SMB-Logs
+    cat > /etc/logrotate.d/ssd-smb << 'EOF'
+/var/log/samba/*.log {
+    daily
+    rotate 30
+    compress
+    delaycompress
+    missingok
+    notifempty
+    create 644 root root
+    postrotate
+        systemctl reload smbd nmbd 2>/dev/null || true
+    endscript
+}
+EOF
+    
+    log "Wartungs-Scripts konfiguriert"
+}
+
+# ============================================================================
+# Hauptfunktionen
+# ============================================================================
+
+show_usage() {
+    cat << EOF
+USB-SSD SMB Setup Script
+
+Verwendung: $0 [OPTIONEN]
+
+Optionen:
+    --install-samba     Samba-Pakete installieren
+    --configure-users   Benutzer und Gruppen konfigurieren
+    --setup-shares      Freigaben konfigurieren
+    --enable-services   Services aktivieren und starten
+    --all              Alle Schritte ausführen
+    --help             Diese Hilfe anzeigen
+
+Beispiele:
+    $0 --all                    # Vollständige Installation
+    $0 --install-samba          # Nur Samba installieren
+    $0 --configure-users        # Nur Benutzer konfigurieren
+    $0 --setup-shares           # Nur Freigaben konfigurieren
+
+EOF
+}
+
+main() {
+    local install_samba=false
+    local configure_users=false
+    local setup_shares=false
+    local enable_services=false
+    local all_steps=false
+    
+    # Parameter parsen
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --install-samba)
+                install_samba=true
+                shift
+                ;;
+            --configure-users)
+                configure_users=true
+                shift
+                ;;
+            --setup-shares)
+                setup_shares=true
+                shift
+                ;;
+            --enable-services)
+                enable_services=true
+                shift
+                ;;
+            --all)
+                all_steps=true
+                shift
+                ;;
+            --help)
+                show_usage
+                exit 0
+                ;;
+            *)
+                error "Unbekannte Option: $1"
+                ;;
+        esac
+    done
+    
+    # Wenn keine spezifischen Optionen, zeige Hilfe
+    if [[ "$install_samba" == false && "$configure_users" == false && "$setup_shares" == false && "$enable_services" == false && "$all_steps" == false ]]; then
+        show_usage
+        exit 1
+    fi
+    
+    # Root-Berechtigung prüfen
+    check_root
+    
+    # OS erkennen
+    detect_os
+    
+    # Mount-Point prüfen
+    check_mount_point
+    
+    # Log-Datei initialisieren
+    mkdir -p "$(dirname "$LOG_FILE")"
+    touch "$LOG_FILE"
+    
+    log "USB-SSD SMB Setup gestartet"
+    
+    # Schritte ausführen
+    if [[ "$all_steps" == true || "$install_samba" == true ]]; then
+        install_samba
+    fi
+    
+    if [[ "$all_steps" == true || "$configure_users" == true ]]; then
+        configure_users
+        setup_directories
+    fi
+    
+    if [[ "$all_steps" == true || "$setup_shares" == true ]]; then
+        setup_smb_config
+        setup_samba_users
+        setup_maintenance
+    fi
+    
+    if [[ "$all_steps" == true || "$enable_services" == true ]]; then
+        enable_services
+        test_smb_config
+    fi
+    
+    log "USB-SSD SMB Setup abgeschlossen"
+    
+    # Zusammenfassung
+    cat << EOF
+
+${GREEN}=== Setup-Zusammenfassung ===${NC}
+
+SMB-Freigaben:
+  - //$(hostname)/ssd-storage    (Haupt-Freigabe)
+  - //$(hostname)/ssd-backup     (Backup-Speicher)
+  - //$(hostname)/ssd-archive    (Archiv, Read-Only)
+  - //$(hostname)/ssd-media      (Media-Dateien)
+  - //$(hostname)/ssd-dev        (Entwicklung)
+  - //$(hostname)/ssd-temp       (Temporäre Dateien)
+
+Nächste Schritte:
+  1. USB-SSD anschließen und mounten: ssd-mount-manager.sh mount
+  2. SMB-Freigaben testen: smbclient -L localhost -U $USER
+  3. Von Windows: \\\\$(hostname)\\ssd-storage
+
+Log-Datei: $LOG_FILE
+Konfiguration: $SMB_CONF
+Backup: $SMB_CONF_BACKUP
+
+EOF
+}
+
+# Script ausführen
+main "$@"

examples/smb-configuration/smb.conf.example

@@ -0,0 +1,338 @@
+# USB-SSD Management System - SMB Configuration Example
+# Optimierte Samba-Konfiguration für USB-C SSD Freigaben
+#
+# Installation:
+# sudo cp smb.conf.example /etc/samba/smb.conf
+# sudo systemctl restart smbd nmbd
+# sudo smbpasswd -a $USER
+
+# ============================================================================
+# Global Configuration
+# ============================================================================
+
+[global]
+    # Server-Identifikation
+    workgroup = WORKGROUP
+    server string = USB-SSD File Server
+    netbios name = SSD-SERVER
+    
+    # Protokoll-Versionen (SMB2/3 für bessere Performance)
+    server min protocol = SMB2
+    server max protocol = SMB3
+    client min protocol = SMB2
+    client max protocol = SMB3
+    
+    # Security-Konfiguration
+    security = user
+    map to guest = bad user
+    guest account = nobody
+    
+    # Logging
+    log file = /var/log/samba/log.%m
+    log level = 1
+    max log size = 1000
+    
+    # Performance-Optimierungen
+    socket options = TCP_NODELAY IPTOS_LOWDELAY SO_RCVBUF=131072 SO_SNDBUF=131072
+    read raw = yes
+    write raw = yes
+    max xmit = 65535
+    dead time = 15
+    getwd cache = yes
+    
+    # Unicode und Charset
+    unix charset = UTF-8
+    display charset = UTF-8
+    dos charset = CP850
+    
+    # Erweiterte Attribute für NTFS-Kompatibilität
+    ea support = yes
+    store dos attributes = yes
+    map archive = no
+    map hidden = no
+    map read only = no
+    map system = no
+    
+    # Locking-Optimierungen
+    kernel oplocks = no
+    level2 oplocks = yes
+    oplocks = yes
+    
+    # Name-Resolution
+    name resolve order = lmhosts wins bcast host
+    dns proxy = no
+    
+    # Printing (deaktiviert für SSD-Server)
+    load printers = no
+    printing = bsd
+    printcap name = /dev/null
+    disable spoolss = yes
+
+# ============================================================================
+# USB-SSD Storage Share
+# ============================================================================
+
+[ssd-storage]
+    # Basis-Konfiguration
+    comment = USB-C SSD Storage
+    path = /mnt/ssd-storage
+    browseable = yes
+    writable = yes
+    guest ok = no
+    
+    # Benutzer-Zugriff
+    valid users = @ssd-users, @disk
+    admin users = @ssd-admins
+    write list = @ssd-users
+    read list = @ssd-users, @ssd-readonly
+    
+    # Permissions
+    create mask = 0664
+    directory mask = 0775
+    force create mode = 0664
+    force directory mode = 0775
+    force user = ssd-user
+    force group = ssd-users
+    
+    # Performance-Optimierungen für USB-SSD
+    strict allocate = yes
+    allocation roundup size = 1048576
+    read raw = yes
+    write raw = yes
+    
+    # NTFS-Kompatibilität
+    store dos attributes = yes
+    map archive = no
+    map hidden = no
+    map read only = no
+    map system = no
+    
+    # Erweiterte Attribute
+    ea support = yes
+    acl allow execute always = yes
+    
+    # Locking für Multi-User Zugriff
+    oplocks = yes
+    level2 oplocks = yes
+    kernel oplocks = no
+    locking = yes
+    strict locking = no
+    
+    # Veto-Dateien (Systemdateien ausschließen)
+    veto files = /._*/.DS_Store/Thumbs.db/desktop.ini/
+    delete veto files = yes
+    
+    # Recycle-Bin (optional)
+    # vfs objects = recycle
+    # recycle:repository = .recycle
+    # recycle:keeptree = yes
+    # recycle:versions = yes
+
+# ============================================================================
+# Backup-spezifische Freigabe
+# ============================================================================
+
+[ssd-backup]
+    comment = USB-SSD Backup Storage
+    path = /mnt/ssd-storage/backup
+    browseable = yes
+    writable = yes
+    guest ok = no
+    
+    # Nur Backup-Benutzer
+    valid users = @backup-users
+    admin users = @backup-admins
+    write list = @backup-users
+    
+    # Restriktive Permissions
+    create mask = 0640
+    directory mask = 0750
+    force create mode = 0640
+    force directory mode = 0750
+    
+    # Backup-optimierte Einstellungen
+    strict allocate = yes
+    sync always = yes
+    strict sync = yes
+    
+    # Audit-Logging
+    full_audit:prefix = %u|%I|%S
+    full_audit:success = open opendir write unlink mkdir rmdir rename
+    full_audit:failure = all
+    vfs objects = full_audit
+
+# ============================================================================
+# Read-Only Archive Share
+# ============================================================================
+
+[ssd-archive]
+    comment = USB-SSD Archive (Read-Only)
+    path = /mnt/ssd-storage/archive
+    browseable = yes
+    writable = no
+    guest ok = yes
+    
+    # Read-Only Zugriff
+    read only = yes
+    write list = @archive-admins
+    
+    # Optimiert für große Dateien
+    read raw = yes
+    large readwrite = yes
+    
+    # Caching für bessere Performance
+    kernel share modes = yes
+    posix locking = no
+
+# ============================================================================
+# Media-Server Integration
+# ============================================================================
+
+[ssd-media]
+    comment = USB-SSD Media Storage
+    path = /mnt/ssd-storage/media
+    browseable = yes
+    writable = yes
+    guest ok = yes
+    
+    # Media-optimierte Einstellungen
+    valid users = @media-users, guest
+    write list = @media-admins
+    
+    # Große Dateien optimiert
+    read raw = yes
+    write raw = yes
+    large readwrite = yes
+    
+    # Media-spezifische Veto-Files
+    veto files = /._*/.DS_Store/Thumbs.db/.@__thumb/
+    delete veto files = yes
+    
+    # Streaming-Optimierungen
+    strict allocate = no
+    allocation roundup size = 4096
+    
+    # DLNA/UPnP Kompatibilität
+    store dos attributes = no
+    map archive = no
+    map hidden = no
+
+# ============================================================================
+# Development Share
+# ============================================================================
+
+[ssd-dev]
+    comment = USB-SSD Development Storage
+    path = /mnt/ssd-storage/development
+    browseable = yes
+    writable = yes
+    guest ok = no
+    
+    # Entwickler-Zugriff
+    valid users = @developers
+    admin users = @dev-leads
+    write list = @developers
+    
+    # Entwickler-freundliche Permissions
+    create mask = 0664
+    directory mask = 0775
+    force create mode = 0664
+    force directory mode = 0775
+    
+    # Git-Repository Unterstützung
+    store dos attributes = no
+    map archive = no
+    map hidden = no
+    map read only = no
+    map system = no
+    
+    # Symlink-Unterstützung
+    follow symlinks = yes
+    wide links = no
+    unix extensions = yes
+    
+    # Case-Sensitivity für Entwicklung
+    case sensitive = auto
+    default case = lower
+    preserve case = yes
+    short preserve case = yes
+
+# ============================================================================
+# Temporäre Freigabe
+# ============================================================================
+
+[ssd-temp]
+    comment = USB-SSD Temporary Storage
+    path = /mnt/ssd-storage/temp
+    browseable = yes
+    writable = yes
+    guest ok = yes
+    
+    # Temporärer Zugriff
+    valid users = @ssd-users, guest
+    
+    # Temporäre Dateien
+    create mask = 0666
+    directory mask = 0777
+    
+    # Automatische Bereinigung (via Cron)
+    # 0 2 * * * find /mnt/ssd-storage/temp -type f -mtime +7 -delete
+    
+    # Keine Attribute speichern
+    store dos attributes = no
+    ea support = no
+
+# ============================================================================
+# Administrative Freigabe
+# ============================================================================
+
+[ssd-admin]
+    comment = USB-SSD Administrative Access
+    path = /mnt/ssd-storage
+    browseable = no
+    writable = yes
+    guest ok = no
+    
+    # Nur Administratoren
+    valid users = @ssd-admins
+    admin users = @ssd-admins
+    
+    # Vollzugriff
+    create mask = 0664
+    directory mask = 0775
+    
+    # Audit-Logging für Admin-Zugriffe
+    full_audit:prefix = ADMIN|%u|%I|%S
+    full_audit:success = all
+    full_audit:failure = all
+    vfs objects = full_audit
+    
+    # Erweiterte Funktionen
+    ea support = yes
+    acl allow execute always = yes
+    nt acl support = yes
+
+# ============================================================================
+# Homes-Integration (optional)
+# ============================================================================
+
+[homes]
+    comment = Home Directories on USB-SSD
+    browseable = no
+    writable = yes
+    guest ok = no
+    
+    # Benutzer-spezifische Pfade
+    path = /mnt/ssd-storage/home/%S
+    valid users = %S
+    
+    # Standard-Permissions
+    create mask = 0600
+    directory mask = 0700
+    
+    # Privacy-Einstellungen
+    hide dot files = yes
+    hide files = /desktop.ini/thumbs.db/
+    
+    # Quota-Unterstützung (falls aktiviert)
+    # preexec = /usr/local/bin/setup-user-quota.sh %S

examples/systemd-services/README.md

@@ -0,0 +1,287 @@
+# Systemd Service Templates
+
+## Übersicht
+
+Diese Verzeichnis enthält Systemd-Service-Templates für die automatische Integration des USB-SSD Management Systems in die Linux-Systemd-Infrastruktur.
+
+## Verfügbare Services
+
+### `ssd-detection.service`
+**Zweck**: Kontinuierliche USB-C SSD Erkennung und Überwachung
+
+**Funktionen**:
+- Automatische Erkennung neu angeschlossener SSDs
+- Kontinuierliche Überwachung im 5-Sekunden-Intervall
+- Integration mit udev-Events
+- Systemd-Journal Logging
+- Automatischer Restart bei Fehlern
+
+**Installation**:
+```bash
+sudo cp ssd-detection.service /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable ssd-detection.service
+sudo systemctl start ssd-detection.service
+```
+
+### `ssd-automount.service`
+**Zweck**: Automatisches Mounting erkannter SSDs
+
+**Funktionen**:
+- Automatisches Mounting auf `/mnt/ssd-storage`
+- Abhängigkeit von `ssd-detection.service`
+- Graceful Shutdown mit Safe-Eject
+- Remount-Funktionalität
+- PID-File Management
+
+**Installation**:
+```bash
+sudo cp ssd-automount.service /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable ssd-automount.service
+sudo systemctl start ssd-automount.service
+```
+
+### `ssd-mount@.service`
+**Zweck**: Template-Service für spezifische Device-Mounting
+
+**Funktionen**:
+- Template-basiertes Mounting für spezifische Devices
+- Device-Binding mit `BindsTo=`
+- Oneshot-Service mit `RemainAfterExit=yes`
+- Automatisches Cleanup bei Device-Entfernung
+
+**Verwendung**:
+```bash
+# Service für spezifisches Device starten
+sudo systemctl start ssd-mount@sdb1.service
+
+# Service für spezifisches Device aktivieren
+sudo systemctl enable ssd-mount@sdb1.service
+
+# Status prüfen
+sudo systemctl status ssd-mount@sdb1.service
+```
+
+## Service-Konfiguration
+
+### Anpassung der Services
+
+#### Environment-Variables
+```bash
+# Service-Konfiguration bearbeiten
+sudo systemctl edit ssd-detection.service
+
+# Beispiel-Konfiguration:
+[Service]
+Environment=SSD_LOG_LEVEL=DEBUG
+Environment=SSD_MONITOR_INTERVAL=10
+Environment=SSD_USE_SYSLOG=true
+```
+
+#### Mount-Point anpassen
+```bash
+# Automount-Service anpassen
+sudo systemctl edit ssd-automount.service
+
+[Service]
+Environment=SSD_MOUNT_POINT=/custom/mount/point
+```
+
+#### Security-Einstellungen
+```bash
+# Zusätzliche Security-Optionen
+sudo systemctl edit ssd-detection.service
+
+[Service]
+# Zusätzliche Device-Zugriffe
+DeviceAllow=/dev/nvme* rw
+DeviceAllow=/dev/mmcblk* rw
+
+# Zusätzliche Pfad-Zugriffe
+ReadWritePaths=/custom/path
+```
+
+## Service-Management
+
+### Standard-Operationen
+```bash
+# Services aktivieren
+sudo systemctl enable ssd-detection.service ssd-automount.service
+
+# Services starten
+sudo systemctl start ssd-detection.service ssd-automount.service
+
+# Status prüfen
+sudo systemctl status ssd-detection.service
+sudo systemctl status ssd-automount.service
+
+# Services stoppen
+sudo systemctl stop ssd-detection.service ssd-automount.service
+
+# Services deaktivieren
+sudo systemctl disable ssd-detection.service ssd-automount.service
+```
+
+### Logs und Monitoring
+```bash
+# Service-Logs anzeigen
+sudo journalctl -u ssd-detection.service -f
+sudo journalctl -u ssd-automount.service --since "1 hour ago"
+
+# Alle SSD-Services
+sudo journalctl -u "ssd-*" --since today
+
+# Service-Status überwachen
+watch -n 5 'systemctl status ssd-detection.service ssd-automount.service'
+```
+
+### Troubleshooting
+```bash
+# Service-Konfiguration validieren
+sudo systemd-analyze verify /etc/systemd/system/ssd-detection.service
+
+# Service-Dependencies anzeigen
+sudo systemctl list-dependencies ssd-automount.service
+
+# Failed-Services anzeigen
+sudo systemctl --failed | grep ssd
+
+# Service neu starten
+sudo systemctl restart ssd-detection.service
+```
+
+## Erweiterte Konfiguration
+
+### Custom-Service erstellen
+```bash
+# Basis-Template kopieren
+sudo cp ssd-detection.service /etc/systemd/system/ssd-custom.service
+
+# Service anpassen
+sudo nano /etc/systemd/system/ssd-custom.service
+
+# Service aktivieren
+sudo systemctl daemon-reload
+sudo systemctl enable ssd-custom.service
+```
+
+### Multi-Device Support
+```bash
+# Template-Service für mehrere Devices
+sudo systemctl enable ssd-mount@sdb1.service
+sudo systemctl enable ssd-mount@sdc1.service
+sudo systemctl enable ssd-mount@sdd1.service
+
+# Alle Template-Services starten
+sudo systemctl start ssd-mount@*.service
+```
+
+### Timer-basierte Services
+```bash
+# Timer für regelmäßige Tests erstellen
+sudo nano /etc/systemd/system/ssd-test.service
+sudo nano /etc/systemd/system/ssd-test.timer
+
+# Timer aktivieren
+sudo systemctl enable ssd-test.timer
+sudo systemctl start ssd-test.timer
+```
+
+## Security-Konfiguration
+
+### Hardening-Optionen
+```ini
+[Service]
+# Zusätzliche Security-Features
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictRealtime=true
+RestrictSUIDSGID=true
+LockPersonality=true
+MemoryDenyWriteExecute=true
+RestrictNamespaces=true
+```
+
+### Capability-Management
+```ini
+[Service]
+# Minimale Capabilities
+CapabilityBoundingSet=CAP_SYS_ADMIN CAP_DAC_OVERRIDE
+AmbientCapabilities=CAP_SYS_ADMIN CAP_DAC_OVERRIDE
+```
+
+### User/Group-Konfiguration
+```bash
+# Dedicated Service-User erstellen
+sudo useradd -r -s /bin/false ssd-service
+sudo usermod -a -G disk ssd-service
+
+# Service-Konfiguration anpassen
+[Service]
+User=ssd-service
+Group=disk
+```
+
+## Integration mit anderen Services
+
+### SMB-Integration
+```ini
+[Unit]
+# SMB-Service nach SSD-Mount starten
+Before=smbd.service
+PartOf=smbd.service
+
+[Service]
+# SMB-Reload nach Mount
+ExecStartPost=/bin/systemctl reload-or-restart smbd.service
+```
+
+### Backup-Integration
+```ini
+[Unit]
+# Backup-Service nach SSD-Mount starten
+Before=backup.service
+
+[Service]
+# Backup-Trigger nach Mount
+ExecStartPost=/usr/local/bin/trigger-backup.sh
+```
+
+### Monitoring-Integration
+```ini
+[Service]
+# Prometheus-Metriken exportieren
+ExecStartPost=/usr/local/bin/export-ssd-metrics.sh
+```
+
+## Best Practices
+
+### Produktionsumgebung
+1. **Immer `systemctl daemon-reload`** nach Service-Änderungen
+2. **Service-Dependencies** korrekt konfigurieren
+3. **Logging-Level** für Produktion auf INFO setzen
+4. **Security-Features** aktivieren
+5. **Monitoring** für Service-Status einrichten
+
+### Entwicklungsumgebung
+1. **Debug-Logging** aktivieren
+2. **Manual-Start** für Tests verwenden
+3. **Service-Isolation** für Entwicklung
+4. **Frequent-Reload** für Änderungen
+
+### Monitoring und Alerting
+1. **Systemd-Status** überwachen
+2. **Service-Logs** analysieren
+3. **Performance-Metriken** sammeln
+4. **Failure-Alerts** konfigurieren
+
+## Changelog
+
+### Version 0.1.0
+- Basis-Service Templates
+- Security-Hardening
+- Multi-Device Support
+- Integration-Beispiele
+- Comprehensive Documentation

examples/systemd-services/ssd-automount.service

@@ -0,0 +1,45 @@
+[Unit]
+Description=Automatic SSD Mounting Service
+Documentation=https://git.gitcover.de/KMU/usb-ssd
+After=ssd-detection.service
+Requires=ssd-detection.service
+BindsTo=ssd-detection.service
+
+[Service]
+Type=forking
+User=root
+Group=root
+ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --auto-mount
+ExecStop=/usr/local/bin/ssd-safe-eject.sh --all
+ExecReload=/usr/local/bin/ssd-mount-manager.sh remount
+PIDFile=/var/run/ssd-automount.pid
+Restart=on-failure
+RestartSec=10
+TimeoutStartSec=60
+TimeoutStopSec=30
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=ssd-automount
+
+# Security
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/var/log /var/run /mnt /media
+PrivateTmp=true
+PrivateDevices=false
+DevicePolicy=closed
+DeviceAllow=/dev/sd* rw
+DeviceAllow=/dev/disk/by-uuid/* rw
+
+# Environment
+Environment=SSD_LOG_LEVEL=INFO
+Environment=SSD_USE_SYSLOG=true
+Environment=SSD_AUTO_MOUNT=true
+Environment=SSD_MOUNT_POINT=/mnt/ssd-storage
+
+[Install]
+WantedBy=multi-user.target
+Also=ssd-detection.service

examples/systemd-services/ssd-detection.service

@@ -0,0 +1,42 @@
+[Unit]
+Description=USB-C SSD Detection Service
+Documentation=https://git.gitcover.de/KMU/usb-ssd
+After=local-fs.target
+Wants=systemd-udevd.service
+After=systemd-udevd.service
+
+[Service]
+Type=simple
+User=root
+Group=root
+ExecStart=/usr/local/bin/ssd-detect.sh --monitor --interval 5
+ExecReload=/bin/kill -HUP $MAINPID
+Restart=on-failure
+RestartSec=5
+TimeoutStartSec=30
+TimeoutStopSec=10
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=ssd-detection
+
+# Security
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/var/log /var/run /mnt
+PrivateTmp=true
+PrivateDevices=false
+DevicePolicy=closed
+DeviceAllow=/dev/sd* rw
+DeviceAllow=/dev/disk/by-uuid/* rw
+
+# Environment
+Environment=SSD_LOG_LEVEL=INFO
+Environment=SSD_USE_SYSLOG=true
+Environment=SSD_MONITOR_INTERVAL=5
+
+[Install]
+WantedBy=multi-user.target
+Alias=ssd-detect.service

examples/systemd-services/ssd-mount@.service

@@ -0,0 +1,38 @@
+[Unit]
+Description=SSD Mount Manager for %i
+Documentation=https://git.gitcover.de/KMU/usb-ssd
+After=local-fs.target
+BindsTo=dev-%i.device
+After=dev-%i.device
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+User=root
+Group=root
+ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%i
+ExecStop=/usr/local/bin/ssd-safe-eject.sh --device /dev/%i
+TimeoutStartSec=30
+TimeoutStopSec=15
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=ssd-mount
+
+# Security
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/var/log /var/run /mnt
+PrivateTmp=true
+PrivateDevices=false
+DevicePolicy=closed
+DeviceAllow=/dev/%i rw
+
+# Environment
+Environment=SSD_LOG_LEVEL=INFO
+Environment=SSD_USE_SYSLOG=true
+
+[Install]
+WantedBy=multi-user.target

examples/udev-rules/99-ssd-automount.rules

@@ -0,0 +1,158 @@
+# USB-SSD Management System - Udev Rules
+# Automatische Erkennung und Mounting von USB-C SSDs
+# 
+# Installation:
+# sudo cp 99-ssd-automount.rules /etc/udev/rules.d/
+# sudo udevadm control --reload-rules
+# sudo udevadm trigger
+
+# ============================================================================
+# USB Storage Device Detection
+# ============================================================================
+
+# USB Mass Storage Devices - Automatische Erkennung
+SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --udev-mode"
+
+# USB Storage Devices - Entfernung
+SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="remove", \
+    RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k --udev-mode"
+
+# ============================================================================
+# NTFS Filesystem Detection
+# ============================================================================
+
+# NTFS Partitionen - Automatisches Mounting
+SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", ACTION=="add", \
+    ATTRS{removable}=="1", \
+    RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount"
+
+# exFAT Partitionen - Alternative Unterstützung
+SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="exfat", ENV{ID_BUS}=="usb", ACTION=="add", \
+    ATTRS{removable}=="1", \
+    RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount"
+
+# ============================================================================
+# Device Permissions und Ownership
+# ============================================================================
+
+# USB Storage Devices - Berechtigungen setzen
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    GROUP="disk", MODE="0660"
+
+# Device-Nodes für SSD-Management Gruppe
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{ID_FS_TYPE}=="ntfs|exfat", \
+    GROUP="ssd-users", MODE="0664"
+
+# ============================================================================
+# Symlink Creation
+# ============================================================================
+
+# Persistente Symlinks basierend auf UUID
+SUBSYSTEM=="block", ENV{ID_FS_UUID}!="", ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", \
+    SYMLINK+="disk/by-ssd-uuid/$env{ID_FS_UUID}"
+
+# Symlinks basierend auf Label
+SUBSYSTEM=="block", ENV{ID_FS_LABEL}!="", ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", \
+    SYMLINK+="disk/by-ssd-label/$env{ID_FS_LABEL}"
+
+# ============================================================================
+# Spezifische Vendor/Product Rules
+# ============================================================================
+
+# Samsung USB-C SSDs
+SUBSYSTEM=="block", ATTRS{idVendor}=="04e8", ATTRS{idProduct}=="61f*", \
+    ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor samsung"
+
+# SanDisk USB-C SSDs
+SUBSYSTEM=="block", ATTRS{idVendor}=="0781", ATTRS{idProduct}=="55*", \
+    ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor sandisk"
+
+# Generic USB 3.0+ Storage
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{bcdUSB}=="0300|0310|0320", \
+    ATTRS{removable}=="1", ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --usb3-mode"
+
+# ============================================================================
+# Environment Variables für Scripts
+# ============================================================================
+
+# Udev-Modus für alle SSD-Scripts
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{SSD_UDEV_MODE}="true", \
+    ENV{SSD_LOG_LEVEL}="INFO", \
+    ENV{SSD_USE_SYSLOG}="true"
+
+# Device-Informationen für Scripts
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{SSD_DEVICE_PATH}="/dev/%k", \
+    ENV{SSD_DEVICE_UUID}="$env{ID_FS_UUID}", \
+    ENV{SSD_DEVICE_LABEL}="$env{ID_FS_LABEL}", \
+    ENV{SSD_DEVICE_TYPE}="$env{ID_FS_TYPE}"
+
+# ============================================================================
+# Systemd Service Integration
+# ============================================================================
+
+# Systemd-Service für spezifische Devices starten
+SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", ACTION=="add", \
+    TAG+="systemd", ENV{SYSTEMD_WANTS}="ssd-mount@%k.service"
+
+# Systemd-Service bei Device-Entfernung stoppen
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/bin/systemctl stop ssd-mount@%k.service"
+
+# ============================================================================
+# Logging und Debugging
+# ============================================================================
+
+# Debug-Informationen loggen (nur bei Debug-Modus)
+# SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+#     RUN+="/usr/bin/logger -t udev-ssd 'Device %k: Action=%E{ACTION}, Type=%E{ID_FS_TYPE}, UUID=%E{ID_FS_UUID}'"
+
+# ============================================================================
+# Sicherheits-Rules
+# ============================================================================
+
+# Nur autorisierte Benutzer können auf SSD-Devices zugreifen
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{ID_FS_TYPE}=="ntfs|exfat", \
+    TEST!="/etc/ssd-management/authorized_users", \
+    GROUP="root", MODE="0600"
+
+# Blacklist für bekannte problematische Devices
+SUBSYSTEM=="block", ATTRS{idVendor}=="0000", ATTRS{idProduct}=="0000", \
+    ENV{UDISKS_IGNORE}="1"
+
+# ============================================================================
+# Performance-Optimierungen
+# ============================================================================
+
+# I/O-Scheduler für USB-SSDs optimieren
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ATTR{queue/scheduler}="mq-deadline"
+
+# Read-Ahead für USB-SSDs optimieren
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ATTR{queue/read_ahead_kb}="1024"
+
+# ============================================================================
+# Cleanup und Maintenance
+# ============================================================================
+
+# Alte Mount-Points bereinigen bei Device-Entfernung
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/usr/local/bin/ssd-mount-manager.sh cleanup --device %k"
+
+# Temporäre Dateien bereinigen
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/bin/rm -f /tmp/ssd-%k-*"

examples/udev-rules/README.md

@@ -0,0 +1,343 @@
+# Udev Rules für USB-SSD Management
+
+## Übersicht
+
+Diese Udev-Rules ermöglichen die automatische Erkennung und Verarbeitung von USB-C SSDs auf Linux-Systemen. Sie integrieren sich nahtlos mit dem USB-SSD Management System und bieten Hardware-Event-basierte Automatisierung.
+
+## Verfügbare Rules
+
+### `99-ssd-automount.rules`
+**Zweck**: Umfassende Udev-Rules für automatische SSD-Erkennung und -Management
+
+**Hauptfunktionen**:
+- Automatische USB Storage Device Erkennung
+- NTFS/exFAT Filesystem Detection
+- Device-Permissions und Ownership Management
+- Persistente Symlink-Erstellung
+- Systemd-Service Integration
+- Performance-Optimierungen
+- Security-Features
+
+## Installation
+
+### Standard-Installation
+```bash
+# Rules-Datei kopieren
+sudo cp 99-ssd-automount.rules /etc/udev/rules.d/
+
+# Udev-Rules neu laden
+sudo udevadm control --reload-rules
+
+# Bestehende Devices neu triggern
+sudo udevadm trigger
+
+# Installation verifizieren
+ls -la /etc/udev/rules.d/99-ssd-*
+```
+
+### Test der Installation
+```bash
+# USB-SSD anschließen und Events überwachen
+sudo udevadm monitor --environment --udev
+
+# Spezifisches Device testen
+sudo udevadm test /sys/block/sdb
+
+# Rule-Syntax validieren
+sudo udevadm test --action=add /sys/block/sdb
+```
+
+## Rule-Kategorien
+
+### 1. USB Storage Device Detection
+```bash
+# Automatische Erkennung bei USB-Device-Anschluss
+SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --udev-mode"
+
+# Automatische Behandlung bei Device-Entfernung
+SUBSYSTEM=="block", ATTRS{removable}=="1", ENV{ID_BUS}=="usb", ACTION=="remove", \
+    RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k --udev-mode"
+```
+
+### 2. Filesystem-spezifische Rules
+```bash
+# NTFS-Partitionen automatisch mounten
+SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", ACTION=="add", \
+    ATTRS{removable}=="1", \
+    RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount"
+
+# exFAT-Support
+SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="exfat", ENV{ID_BUS}=="usb", ACTION=="add", \
+    ATTRS{removable}=="1", \
+    RUN+="/usr/local/bin/ssd-mount-manager.sh mount --device /dev/%k --auto-mount"
+```
+
+### 3. Device-Permissions
+```bash
+# Basis-Berechtigungen für USB Storage
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    GROUP="disk", MODE="0660"
+
+# Erweiterte Berechtigungen für SSD-Management
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{ID_FS_TYPE}=="ntfs|exfat", \
+    GROUP="ssd-users", MODE="0664"
+```
+
+### 4. Symlink-Management
+```bash
+# UUID-basierte Symlinks
+SUBSYSTEM=="block", ENV{ID_FS_UUID}!="", ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", \
+    SYMLINK+="disk/by-ssd-uuid/$env{ID_FS_UUID}"
+
+# Label-basierte Symlinks
+SUBSYSTEM=="block", ENV{ID_FS_LABEL}!="", ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", \
+    SYMLINK+="disk/by-ssd-label/$env{ID_FS_LABEL}"
+```
+
+## Vendor-spezifische Rules
+
+### Samsung USB-C SSDs
+```bash
+# Samsung-spezifische Erkennung
+SUBSYSTEM=="block", ATTRS{idVendor}=="04e8", ATTRS{idProduct}=="61f*", \
+    ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor samsung"
+```
+
+### SanDisk USB-C SSDs
+```bash
+# SanDisk-spezifische Erkennung
+SUBSYSTEM=="block", ATTRS{idVendor}=="0781", ATTRS{idProduct}=="55*", \
+    ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --vendor sandisk"
+```
+
+### Generic USB 3.0+ Storage
+```bash
+# USB 3.0+ Devices
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{bcdUSB}=="0300|0310|0320", \
+    ATTRS{removable}=="1", ACTION=="add", \
+    RUN+="/usr/local/bin/ssd-detect.sh --device %k --usb3-mode"
+```
+
+## Systemd-Integration
+
+### Service-Aktivierung
+```bash
+# Systemd-Service für spezifische Devices
+SUBSYSTEM=="block", ENV{ID_FS_TYPE}=="ntfs", ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", ACTION=="add", \
+    TAG+="systemd", ENV{SYSTEMD_WANTS}="ssd-mount@%k.service"
+
+# Service-Deaktivierung bei Entfernung
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/bin/systemctl stop ssd-mount@%k.service"
+```
+
+## Performance-Optimierungen
+
+### I/O-Scheduler
+```bash
+# Optimaler I/O-Scheduler für USB-SSDs
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ATTR{queue/scheduler}="mq-deadline"
+```
+
+### Read-Ahead Tuning
+```bash
+# Read-Ahead Buffer optimieren
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ATTR{queue/read_ahead_kb}="1024"
+```
+
+## Security-Features
+
+### Autorisierte Benutzer
+```bash
+# Zugriff nur für autorisierte Benutzer
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{ID_FS_TYPE}=="ntfs|exfat", \
+    TEST!="/etc/ssd-management/authorized_users", \
+    GROUP="root", MODE="0600"
+```
+
+### Device-Blacklist
+```bash
+# Problematische Devices ignorieren
+SUBSYSTEM=="block", ATTRS{idVendor}=="0000", ATTRS{idProduct}=="0000", \
+    ENV{UDISKS_IGNORE}="1"
+```
+
+## Environment-Variables
+
+### Script-Konfiguration
+```bash
+# Udev-Modus für alle SSD-Scripts
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{SSD_UDEV_MODE}="true", \
+    ENV{SSD_LOG_LEVEL}="INFO", \
+    ENV{SSD_USE_SYSLOG}="true"
+```
+
+### Device-Informationen
+```bash
+# Device-Details für Scripts
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{SSD_DEVICE_PATH}="/dev/%k", \
+    ENV{SSD_DEVICE_UUID}="$env{ID_FS_UUID}", \
+    ENV{SSD_DEVICE_LABEL}="$env{ID_FS_LABEL}", \
+    ENV{SSD_DEVICE_TYPE}="$env{ID_FS_TYPE}"
+```
+
+## Debugging und Troubleshooting
+
+### Debug-Modus aktivieren
+```bash
+# Debug-Logging aktivieren (auskommentiert in Produktion)
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    RUN+="/usr/bin/logger -t udev-ssd 'Device %k: Action=%E{ACTION}, Type=%E{ID_FS_TYPE}, UUID=%E{ID_FS_UUID}'"
+```
+
+### Event-Monitoring
+```bash
+# Udev-Events in Echtzeit überwachen
+sudo udevadm monitor --environment --udev
+
+# Spezifische Events filtern
+sudo udevadm monitor --subsystem-match=block --property-match=ID_BUS=usb
+
+# Event-Details anzeigen
+sudo udevadm info --query=all --name=/dev/sdb1
+```
+
+### Rule-Testing
+```bash
+# Rule-Syntax testen
+sudo udevadm test /sys/block/sdb
+
+# Spezifische Action testen
+sudo udevadm test --action=add /sys/block/sdb
+
+# Rule-Matching prüfen
+sudo udevadm test --action=add /sys/block/sdb 2>&1 | grep "RUN"
+```
+
+## Custom-Rules erstellen
+
+### Basis-Template
+```bash
+# Custom-Rule Template
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ENV{ID_FS_TYPE}=="ntfs", \
+    ATTRS{idVendor}=="YOUR_VENDOR", \
+    ACTION=="add", \
+    RUN+="/path/to/your/script.sh --device %k"
+```
+
+### Erweiterte Matching-Kriterien
+```bash
+# Mehrere Kriterien kombinieren
+SUBSYSTEM=="block", \
+    ENV{ID_BUS}=="usb", \
+    ATTRS{removable}=="1", \
+    ENV{ID_FS_TYPE}=="ntfs", \
+    ENV{ID_FS_LABEL}=="BACKUP*", \
+    ATTRS{size}=="976773168", \
+    ACTION=="add", \
+    RUN+="/usr/local/bin/backup-ssd-handler.sh --device %k"
+```
+
+## Maintenance und Cleanup
+
+### Automatische Bereinigung
+```bash
+# Mount-Points bereinigen
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/usr/local/bin/ssd-mount-manager.sh cleanup --device %k"
+
+# Temporäre Dateien entfernen
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/bin/rm -f /tmp/ssd-%k-*"
+```
+
+### Log-Rotation
+```bash
+# Log-Dateien rotieren
+SUBSYSTEM=="block", ENV{ID_BUS}=="usb", ATTRS{removable}=="1", \
+    ACTION=="remove", \
+    RUN+="/usr/sbin/logrotate -f /etc/logrotate.d/ssd-management"
+```
+
+## Best Practices
+
+### Produktionsumgebung
+1. **Minimale Rules**: Nur notwendige Rules aktivieren
+2. **Performance**: I/O-Optimierungen für kritische Systeme
+3. **Security**: Strenge Berechtigungen und Autorisierung
+4. **Logging**: Produktions-geeignetes Log-Level
+5. **Testing**: Umfassende Tests vor Deployment
+
+### Entwicklungsumgebung
+1. **Debug-Logging**: Erweiterte Logging-Rules aktivieren
+2. **Flexible-Matching**: Weniger restriktive Matching-Kriterien
+3. **Rapid-Testing**: Schnelle Rule-Reload-Zyklen
+4. **Monitoring**: Kontinuierliche Event-Überwachung
+
+### Sicherheit
+1. **Principle of Least Privilege**: Minimale Berechtigungen
+2. **Device-Validation**: Nur vertrauenswürdige Devices
+3. **Audit-Logging**: Vollständige Event-Protokollierung
+4. **Access-Control**: Benutzer-basierte Zugriffskontrolle
+
+## Troubleshooting
+
+### Häufige Probleme
+
+#### Rules werden nicht ausgeführt
+```bash
+# Rules-Syntax prüfen
+sudo udevadm test /sys/block/sdb
+
+# Rules neu laden
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+
+# Permissions prüfen
+ls -la /etc/udev/rules.d/99-ssd-*
+```
+
+#### Scripts werden nicht gefunden
+```bash
+# Script-Pfade prüfen
+which ssd-detect.sh
+ls -la /usr/local/bin/ssd-*
+
+# Permissions prüfen
+ls -la /usr/local/bin/ssd-detect.sh
+```
+
+#### Device-Matching funktioniert nicht
+```bash
+# Device-Eigenschaften anzeigen
+sudo udevadm info --query=all --name=/dev/sdb1
+
+# Matching-Kriterien testen
+sudo udevadm test --action=add /sys/block/sdb1
+```
+
+## Changelog
+
+### Version 0.1.0
+- Umfassende USB-SSD Detection Rules
+- Systemd-Service Integration
+- Performance-Optimierungen
+- Security-Features
+- Vendor-spezifische Rules
+- Debugging und Troubleshooting Support

scripts/installation/README.md

@@ -0,0 +1,372 @@
+# Installation Module
+
+## Übersicht
+
+Das Installation Module bietet eine vollautomatische Master-Installation für das USB-SSD Management System. Es konfiguriert alle Abhängigkeiten, erstellt System-Services und richtet die komplette Infrastruktur für den produktiven Einsatz ein.
+
+## Hauptkomponenten
+
+### `install.sh`
+**Zweck**: Master-Installation mit vollständiger System-Konfiguration
+
+**Installationsschritte**:
+- System-Abhängigkeiten installieren
+- Scripts in System-Pfade kopieren
+- Systemd-Services konfigurieren
+- Udev-Rules einrichten
+- Benutzer-Berechtigungen setzen
+- Logging-Infrastruktur aufbauen
+
+## Installation
+
+### Schnell-Installation
+```bash
+# Repository klonen
+git clone https://git.gitcover.de/KMU/usb-ssd.git
+cd usb-ssd
+
+# Master-Installation ausführen
+sudo ./scripts/installation/install.sh
+```
+
+### Erweiterte Installation
+```bash
+# Installation mit Custom-Konfiguration
+sudo ./scripts/installation/install.sh --config /path/to/config.conf
+
+# Installation ohne Systemd-Services
+sudo ./scripts/installation/install.sh --no-systemd
+
+# Installation mit Debug-Modus
+sudo ./scripts/installation/install.sh --debug --verbose
+```
+
+### Interaktive Installation
+```bash
+# Schritt-für-Schritt Installation mit Benutzer-Eingaben
+sudo ./scripts/installation/install.sh --interactive
+
+# Nur bestimmte Komponenten installieren
+sudo ./scripts/installation/install.sh --components "detection,management"
+```
+
+## Installationsoptionen
+
+### Standard-Installation
+```bash
+# Vollständige Installation (empfohlen)
+sudo ./install.sh
+
+# Installiert:
+# - Alle System-Abhängigkeiten
+# - Scripts nach /usr/local/bin/
+# - Systemd-Services
+# - Udev-Rules
+# - Log-Rotation
+# - Bash-Completion
+```
+
+### Custom-Installation
+```bash
+# Spezifische Installationspfade
+sudo ./install.sh --prefix /opt/ssd-tools
+
+# Custom-Konfiguration
+sudo ./install.sh --config-dir /etc/ssd-management
+
+# Benutzer-spezifische Installation
+./install.sh --user-install
+```
+
+### Komponenten-basierte Installation
+```bash
+# Nur Detection-Module
+sudo ./install.sh --component detection
+
+# Nur Management-Module
+sudo ./install.sh --component management
+
+# Nur Testing-Module
+sudo ./install.sh --component testing
+
+# Mehrere Komponenten
+sudo ./install.sh --components "detection,management,testing"
+```
+
+## System-Abhängigkeiten
+
+### Automatisch installierte Packages
+
+#### Ubuntu/Debian
+```bash
+# Core-Packages
+ntfs-3g          # NTFS-Dateisystem Support
+util-linux       # Mount/Unmount Utilities
+parted           # Partitionstabellen-Management
+bc               # Berechnungen in Scripts
+eject            # Hardware-Eject Funktionalität
+
+# Optional-Packages
+smartmontools    # SSD-Health Monitoring
+hdparm          # Hardware-Parameter Tuning
+fio             # Performance-Testing
+samba-common    # SMB-Integration
+```
+
+#### CentOS/RHEL
+```bash
+# Core-Packages
+ntfs-3g
+util-linux
+parted
+bc
+eject
+
+# EPEL-Repository für zusätzliche Tools
+sudo yum install epel-release
+```
+
+### Manuelle Abhängigkeits-Installation
+```bash
+# Ubuntu/Debian
+sudo apt update
+sudo apt install ntfs-3g util-linux parted bc eject smartmontools hdparm fio
+
+# CentOS/RHEL
+sudo yum install ntfs-3g util-linux parted bc eject smartmontools hdparm fio
+
+# Arch Linux
+sudo pacman -S ntfs-3g util-linux parted bc eject smartmontools hdparm fio
+```
+
+## Systemd-Integration
+
+### Installierte Services
+
+#### `ssd-detection.service`
+```ini
+[Unit]
+Description=USB-C SSD Detection Service
+After=local-fs.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/bin/ssd-detect.sh --monitor
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+```
+
+#### `ssd-automount.service`
+```ini
+[Unit]
+Description=Automatic SSD Mounting
+After=ssd-detection.service
+
+[Service]
+Type=forking
+ExecStart=/usr/local/bin/ssd-mount-manager.sh --auto-mount
+ExecStop=/usr/local/bin/ssd-safe-eject.sh --all
+
+[Install]
+WantedBy=multi-user.target
+```
+
+### Service-Management
+```bash
+# Services aktivieren
+sudo systemctl enable ssd-detection.service
+sudo systemctl enable ssd-automount.service
+
+# Services starten
+sudo systemctl start ssd-detection.service
+sudo systemctl start ssd-automount.service
+
+# Status prüfen
+sudo systemctl status ssd-detection.service
+```
+
+## Udev-Rules
+
+### Automatische USB-Erkennung
+```bash
+# /etc/udev/rules.d/99-ssd-automount.rules
+SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="add", RUN+="/usr/local/bin/ssd-detect.sh --device %k"
+SUBSYSTEM=="block", ATTRS{removable}=="1", ACTION=="remove", RUN+="/usr/local/bin/ssd-safe-eject.sh --device %k"
+```
+
+### Udev-Rules aktivieren
+```bash
+# Rules neu laden
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+
+# Test der Rules
+sudo udevadm test /sys/block/sdb
+```
+
+## Benutzer-Berechtigungen
+
+### Gruppe-Konfiguration
+```bash
+# SSD-Management Gruppe erstellen
+sudo groupadd ssd-users
+
+# Benutzer zur Gruppe hinzufügen
+sudo usermod -a -G ssd-users $USER
+
+# Disk-Gruppe für Hardware-Zugriff
+sudo usermod -a -G disk $USER
+```
+
+### Sudo-Konfiguration
+```bash
+# /etc/sudoers.d/ssd-management
+%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-mount-manager.sh
+%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-safe-eject.sh
+%ssd-users ALL=(ALL) NOPASSWD: /usr/local/bin/ssd-detect.sh
+```
+
+## Logging-Konfiguration
+
+### Log-Rotation
+```bash
+# /etc/logrotate.d/ssd-management
+/var/log/ssd-*.log {
+    daily
+    rotate 30
+    compress
+    delaycompress
+    missingok
+    notifempty
+    create 644 root root
+}
+```
+
+### Syslog-Integration
+```bash
+# /etc/rsyslog.d/50-ssd-management.conf
+:programname, isequal, "ssd-detect" /var/log/ssd-detection.log
+:programname, isequal, "ssd-mount" /var/log/ssd-management.log
+:programname, isequal, "ssd-test" /var/log/ssd-testing.log
+& stop
+```
+
+## Bash-Completion
+
+### Auto-Completion aktivieren
+```bash
+# /etc/bash_completion.d/ssd-tools
+_ssd_detect() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    opts="--verbose --ntfs-only --device --output --monitor --debug"
+    
+    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    return 0
+}
+complete -F _ssd_detect ssd-detect.sh
+```
+
+## Deinstallation
+
+### Vollständige Deinstallation
+```bash
+# Deinstallations-Script ausführen
+sudo ./scripts/installation/uninstall.sh
+
+# Manuelle Deinstallation
+sudo systemctl stop ssd-detection.service ssd-automount.service
+sudo systemctl disable ssd-detection.service ssd-automount.service
+sudo rm /etc/systemd/system/ssd-*.service
+sudo rm /usr/local/bin/ssd-*
+sudo rm /etc/udev/rules.d/99-ssd-automount.rules
+```
+
+### Konfiguration beibehalten
+```bash
+# Nur Scripts entfernen, Konfiguration behalten
+sudo ./scripts/installation/uninstall.sh --keep-config
+```
+
+## Upgrade-Prozess
+
+### In-Place Upgrade
+```bash
+# Repository aktualisieren
+git pull origin main
+
+# Upgrade ausführen
+sudo ./scripts/installation/install.sh --upgrade
+
+# Services neu starten
+sudo systemctl restart ssd-detection.service
+```
+
+### Backup vor Upgrade
+```bash
+# Konfiguration sichern
+sudo cp -r /etc/ssd-management /etc/ssd-management.backup
+
+# Scripts sichern
+sudo cp /usr/local/bin/ssd-* /tmp/ssd-backup/
+```
+
+## Troubleshooting
+
+### Installations-Probleme
+```bash
+# Installation mit Debug-Output
+sudo ./install.sh --debug --verbose
+
+# Abhängigkeits-Probleme prüfen
+./install.sh --check-dependencies
+
+# Berechtigungs-Probleme
+sudo ./install.sh --fix-permissions
+```
+
+### Häufige Probleme
+1. **Permission denied**: Installation mit `sudo` ausführen
+2. **Package not found**: Repository-Updates durchführen
+3. **Service failed**: Systemd-Logs prüfen (`journalctl -u ssd-detection.service`)
+
+### Diagnose-Tools
+```bash
+# System-Diagnose
+./install.sh --diagnose
+
+# Installations-Status prüfen
+./install.sh --status
+
+# Konfiguration validieren
+./install.sh --validate
+```
+
+## Best Practices
+
+### Produktionsumgebung
+1. **Vollständige Installation** mit allen Komponenten
+2. **Systemd-Services aktivieren** für automatisches Management
+3. **Log-Rotation konfigurieren** für Langzeit-Betrieb
+4. **Monitoring einrichten** für Service-Überwachung
+5. **Backup-Strategie** für Konfigurationsdateien
+
+### Entwicklungsumgebung
+1. **Komponenten-basierte Installation** für spezifische Tests
+2. **Debug-Modus aktivieren** für Entwicklung
+3. **User-Installation** für isolierte Tests
+4. **Häufige Upgrades** für aktuelle Features
+
+## Changelog
+
+### Version 0.1.0
+- Master-Installation Script
+- Systemd-Service Integration
+- Udev-Rules Konfiguration
+- Benutzer-Berechtigungen Setup
+- Logging-Infrastruktur
+- Bash-Completion Support

scripts/ssd-detection/README.md

@@ -0,0 +1,170 @@
+# SSD Detection Module
+
+## Übersicht
+
+Das SSD Detection Module ist verantwortlich für die automatische Erkennung und Identifikation von USB-C SSDs im System. Es bietet robuste Hardware-Erkennung mit NTFS-Partition-Support.
+
+## Hauptkomponenten
+
+### `ssd-detect.sh`
+**Zweck**: Automatische USB-C SSD Identifikation und NTFS-Partition Erkennung
+
+**Hauptfunktionen**:
+- Erkennung neu angeschlossener USB-Storage-Devices
+- NTFS-Dateisystem Validierung
+- UUID-basierte Geräte-Identifikation
+- Hardware-Kompatibilitätsprüfung
+- Logging aller Erkennungsvorgänge
+
+## Verwendung
+
+### Grundlegende Erkennung
+```bash
+# Automatische SSD-Erkennung
+./ssd-detect.sh
+
+# Verbose-Modus mit detailliertem Output
+./ssd-detect.sh --verbose
+
+# Nur NTFS-Partitionen anzeigen
+./ssd-detect.sh --ntfs-only
+```
+
+### Erweiterte Optionen
+```bash
+# Spezifisches Device prüfen
+./ssd-detect.sh --device /dev/sdb1
+
+# JSON-Output für Automation
+./ssd-detect.sh --output json
+
+# Kontinuierliche Überwachung
+./ssd-detect.sh --monitor
+```
+
+## Ausgabe-Format
+
+### Standard-Output
+```
+[INFO] USB-C SSD detected: /dev/sdb1
+[INFO] Filesystem: NTFS
+[INFO] UUID: 1234-5678-9ABC-DEF0
+[INFO] Size: 500GB
+[INFO] Label: BACKUP_SSD
+[SUCCESS] Device ready for mounting
+```
+
+### JSON-Output
+```json
+{
+  "device": "/dev/sdb1",
+  "filesystem": "ntfs",
+  "uuid": "1234-5678-9ABC-DEF0",
+  "size": "500GB",
+  "label": "BACKUP_SSD",
+  "status": "ready"
+}
+```
+
+## Konfiguration
+
+### Environment Variables
+```bash
+# Standardmäßige Erkennungszeit (Sekunden)
+export SSD_DETECT_TIMEOUT=30
+
+# Log-Level (DEBUG, INFO, WARN, ERROR)
+export SSD_LOG_LEVEL=INFO
+
+# Unterstützte Dateisysteme
+export SSD_SUPPORTED_FS="ntfs,exfat,ext4"
+```
+
+## Fehlerbehandlung
+
+### Häufige Probleme
+1. **Keine SSD erkannt**: USB-Verbindung prüfen, Device-Permissions kontrollieren
+2. **NTFS nicht unterstützt**: `ntfs-3g` Package installieren
+3. **Permission denied**: Script mit `sudo` ausführen
+
+### Debug-Modus
+```bash
+# Erweiterte Diagnose
+./ssd-detect.sh --debug
+
+# System-Logs prüfen
+journalctl -f | grep ssd-detect
+```
+
+## Integration
+
+### Systemd-Service
+```bash
+# Automatische Erkennung bei Boot
+sudo systemctl enable ssd-detect.service
+```
+
+### Udev-Rules
+```bash
+# Automatische Erkennung bei USB-Events
+# Siehe examples/udev-rules/
+```
+
+## Abhängigkeiten
+
+### Erforderliche Packages
+- `util-linux` - Device-Management
+- `ntfs-3g` - NTFS-Support
+- `parted` - Partitionstabellen
+- `udev` - Hardware-Events
+
+### Installation
+```bash
+# Ubuntu/Debian
+sudo apt install util-linux ntfs-3g parted udev
+
+# CentOS/RHEL
+sudo yum install util-linux ntfs-3g parted systemd-udev
+```
+
+## Sicherheit
+
+### Best Practices
+- Immer UUID-basierte Identifikation verwenden
+- Device-Permissions vor Zugriff prüfen
+- Logging für Audit-Trails aktivieren
+- Read-Only Modus für kritische Prüfungen
+
+### Berechtigungen
+```bash
+# Minimale Berechtigungen für Detection
+sudo usermod -a -G disk $USER
+```
+
+## Entwicklung
+
+### Testing
+```bash
+# Unit-Tests ausführen
+./test-ssd-detect.sh
+
+# Integration-Tests
+./test-ssd-detect-integration.sh
+```
+
+### Debugging
+```bash
+# Trace-Modus
+bash -x ./ssd-detect.sh
+
+# Profiling
+time ./ssd-detect.sh --benchmark
+```
+
+## Changelog
+
+### Version 0.1.0
+- Initiale Implementierung
+- NTFS-Support
+- UUID-basierte Erkennung
+- JSON-Output Format

scripts/ssd-detection/ssd-safe-eject.sh

@@ -0,0 +1,334 @@
+#!/bin/bash
+# ssd-safe-eject.sh - Safe Eject Extension für USB-C SSDs
+# Zweck: Sichere Entfernung von USB-C SSDs mit vollständigem Sync und Hardware-Eject
+
+set -e
+
+# Konfiguration
+MOUNT_POINT="/mnt/ssd-storage"
+LOG_FILE="/var/log/ssd-mount.log"
+
+# Farben für Ausgabe
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging-Funktion
+log_message() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - SAFE-EJECT: $1" | sudo tee -a "$LOG_FILE"
+    echo -e "${BLUE}[SAFE-EJECT]${NC} $1"
+}
+
+log_success() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" | sudo tee -a "$LOG_FILE"
+    echo -e "${GREEN}[✓]${NC} $1"
+}
+
+log_warning() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" | sudo tee -a "$LOG_FILE"
+    echo -e "${YELLOW}[!]${NC} $1"
+}
+
+log_error() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" | sudo tee -a "$LOG_FILE"
+    echo -e "${RED}[✗]${NC} $1"
+}
+
+# Schritt 1: Pre-Eject Validierung
+validate_pre_eject() {
+    log_message "Validiere Pre-Eject Status..."
+    
+    if ! mountpoint -q "$MOUNT_POINT"; then
+        log_warning "Keine SSD auf $MOUNT_POINT gemountet"
+        return 1
+    fi
+    
+    mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+    log_success "Gemountetes Device identifiziert: $mounted_device"
+    
+    # Prüfe ob Device USB-Device ist
+    device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
+    if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
+        log_success "USB-Device bestätigt: $device_base"
+        echo "$mounted_device"
+        return 0
+    else
+        log_error "Device ist kein USB-Device - Safe-Eject nicht anwendbar"
+        return 1
+    fi
+}
+
+# Schritt 2: Aktive Prozesse prüfen
+check_active_processes() {
+    local device="$1"
+    log_message "Prüfe aktive Prozesse auf $MOUNT_POINT..."
+    
+    # Prozesse finden die das Mount-Point verwenden
+    active_processes=$(lsof "$MOUNT_POINT" 2>/dev/null || true)
+    
+    if [ -n "$active_processes" ]; then
+        log_warning "Aktive Prozesse gefunden:"
+        echo "$active_processes"
+        echo ""
+        echo "Prozesse beenden? (y/n/s für skip)"
+        read -r response
+        
+        case "$response" in
+            "y"|"Y")
+                log_message "Beende Prozesse..."
+                lsof -t "$MOUNT_POINT" 2>/dev/null | xargs -r sudo kill -TERM
+                sleep 2
+                # Prüfe erneut
+                remaining=$(lsof "$MOUNT_POINT" 2>/dev/null || true)
+                if [ -n "$remaining" ]; then
+                    log_warning "Einige Prozesse laufen noch - Force Kill..."
+                    lsof -t "$MOUNT_POINT" 2>/dev/null | xargs -r sudo kill -KILL
+                fi
+                log_success "Prozesse beendet"
+                ;;
+            "s"|"S")
+                log_warning "Prozesse werden nicht beendet - Fortfahren auf eigene Gefahr"
+                ;;
+            *)
+                log_message "Safe-Eject abgebrochen"
+                return 1
+                ;;
+        esac
+    else
+        log_success "Keine aktiven Prozesse gefunden"
+    fi
+    
+    return 0
+}
+
+# Schritt 3: Vollständiger Daten-Sync
+perform_full_sync() {
+    log_message "Führe vollständigen Daten-Sync durch..."
+    
+    # Globaler Sync
+    log_message "Globaler Sync..."
+    sync
+    
+    # Warte auf Dirty Pages Flush
+    log_message "Warte auf Buffer-Flush..."
+    local timeout=30
+    local count=0
+    
+    while [ $count -lt $timeout ]; do
+        dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
+        writeback_pages=$(cat /proc/meminfo | grep "Writeback:" | awk '{print $2}')
+        
+        if [ "$dirty_pages" -le 4 ] && [ "$writeback_pages" -le 4 ]; then
+            log_success "Buffer-Flush abgeschlossen (Dirty: ${dirty_pages}kB, Writeback: ${writeback_pages}kB)"
+            break
+        fi
+        
+        if [ $((count % 5)) -eq 0 ]; then
+            log_message "Warte auf Buffer-Flush... (Dirty: ${dirty_pages}kB, Writeback: ${writeback_pages}kB)"
+        fi
+        
+        sleep 1
+        count=$((count + 1))
+    done
+    
+    if [ $count -ge $timeout ]; then
+        log_warning "Buffer-Flush Timeout erreicht - Fortfahren..."
+    fi
+    
+    # Finaler Sync
+    log_message "Finaler Sync..."
+    sync
+    sleep 2
+    
+    log_success "Vollständiger Sync abgeschlossen"
+}
+
+# Schritt 4: Filesystem Unmount
+perform_unmount() {
+    local device="$1"
+    log_message "Unmounte Dateisystem: $device"
+    
+    # Lazy Unmount falls normal unmount fehlschlägt
+    if ! sudo umount "$MOUNT_POINT" 2>/dev/null; then
+        log_warning "Normaler Unmount fehlgeschlagen - versuche Lazy Unmount..."
+        
+        if sudo umount -l "$MOUNT_POINT" 2>/dev/null; then
+            log_success "Lazy Unmount erfolgreich"
+        else
+            log_error "Unmount fehlgeschlagen"
+            return 1
+        fi
+    else
+        log_success "Unmount erfolgreich"
+    fi
+    
+    # Verifikation
+    if mountpoint -q "$MOUNT_POINT"; then
+        log_error "Mount-Point noch aktiv nach Unmount"
+        return 1
+    else
+        log_success "Mount-Point erfolgreich getrennt"
+        return 0
+    fi
+}
+
+# Schritt 5: Hardware-Eject
+perform_hardware_eject() {
+    local device="$1"
+    local device_base=$(echo "$device" | sed 's/[0-9]*$//')
+    
+    log_message "Hardware-Eject für Device: $device_base"
+    
+    # Prüfe ob eject verfügbar ist
+    if ! command -v eject >/dev/null; then
+        log_warning "eject Befehl nicht verfügbar - installiere eject..."
+        sudo apt update && sudo apt install -y eject
+    fi
+    
+    # Hardware-Eject durchführen
+    if sudo eject "$device_base" 2>/dev/null; then
+        log_success "Hardware-Eject erfolgreich: $device_base"
+    else
+        log_warning "Hardware-Eject fehlgeschlagen - möglicherweise nicht unterstützt"
+        
+        # Alternative: USB-Device über sysfs deaktivieren
+        usb_device=$(udevadm info --query=path --name="$device_base" 2>/dev/null | sed 's|/block/.*||')
+        if [ -n "$usb_device" ]; then
+            log_message "Versuche USB-Device Deaktivierung über sysfs..."
+            if echo 1 | sudo tee "/sys$usb_device/remove" >/dev/null 2>&1; then
+                log_success "USB-Device über sysfs deaktiviert"
+            else
+                log_warning "USB-Device Deaktivierung fehlgeschlagen"
+            fi
+        fi
+    fi
+}
+
+# Schritt 6: Post-Eject Validierung
+validate_post_eject() {
+    local device="$1"
+    local device_base=$(echo "$device" | sed 's/[0-9]*$//')
+    
+    log_message "Post-Eject Validierung..."
+    
+    # Prüfe ob Mount-Point noch aktiv
+    if mountpoint -q "$MOUNT_POINT"; then
+        log_error "Mount-Point noch aktiv - Safe-Eject unvollständig"
+        return 1
+    fi
+    
+    # Prüfe ob Device noch sichtbar
+    sleep 3  # Kurze Wartezeit für System-Update
+    
+    if [ -b "$device_base" ]; then
+        log_warning "Device noch im System sichtbar: $device_base"
+        log_message "Device kann möglicherweise manuell entfernt werden"
+    else
+        log_success "Device nicht mehr im System sichtbar"
+    fi
+    
+    log_success "Post-Eject Validierung abgeschlossen"
+    return 0
+}
+
+# Safe-Eject Status anzeigen
+show_eject_status() {
+    echo ""
+    echo "=== Safe-Eject Status ==="
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
+        
+        echo "✓ Gemountetes Device: $mounted_device"
+        echo "✓ Hardware Device: $device_base"
+        
+        # USB-Status prüfen
+        if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
+            echo "✓ USB-Device: Ja"
+            echo "✓ Safe-Eject: Verfügbar"
+        else
+            echo "✗ USB-Device: Nein"
+            echo "✗ Safe-Eject: Nicht verfügbar"
+        fi
+        
+        # Aktive Prozesse prüfen
+        active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
+        if [ "$active_count" -gt 0 ]; then
+            echo "! Aktive Prozesse: $active_count"
+        else
+            echo "✓ Aktive Prozesse: Keine"
+        fi
+        
+    else
+        echo "✗ Kein Device gemountet"
+        echo "✗ Safe-Eject: Nicht erforderlich"
+    fi
+    echo ""
+}
+
+# Hauptfunktion Safe-Eject
+safe_eject_main() {
+    echo "=== USB-C SSD Safe-Eject ==="
+    echo "Version: 1.0"
+    echo ""
+    
+    # Pre-Validierung
+    device=$(validate_pre_eject)
+    if [ $? -ne 0 ]; then
+        return 1
+    fi
+    
+    echo "=== Safe-Eject Prozess gestartet für: $device ==="
+    echo ""
+    
+    # Aktive Prozesse prüfen
+    if ! check_active_processes "$device"; then
+        return 1
+    fi
+    
+    # Vollständiger Sync
+    perform_full_sync
+    
+    # Unmount
+    if ! perform_unmount "$device"; then
+        return 1
+    fi
+    
+    # Hardware-Eject
+    perform_hardware_eject "$device"
+    
+    # Post-Validierung
+    validate_post_eject "$device"
+    
+    echo ""
+    echo "=== Safe-Eject abgeschlossen ==="
+    echo "USB-C SSD kann jetzt sicher entfernt werden."
+    echo ""
+    
+    return 0
+}
+
+# Hauptfunktion
+main() {
+    case "${1:-eject}" in
+        "eject")
+            safe_eject_main
+            ;;
+        "status")
+            show_eject_status
+            ;;
+        *)
+            echo "Verwendung: $0 {eject|status}"
+            echo ""
+            echo "Befehle:"
+            echo "  eject   - Sichere SSD-Entfernung durchführen"
+            echo "  status  - Safe-Eject Status anzeigen"
+            ;;
+    esac
+}
+
+# Script ausführen
+main "$@"

scripts/ssd-management/README.md

@@ -0,0 +1,264 @@
+# SSD Management Module
+
+## Übersicht
+
+Das SSD Management Module verwaltet den kompletten Lifecycle von USB-C SSDs - von Mount-Operationen bis zur sicheren Entfernung. Es bietet flexibles Mounting mit konstantem Mount-Point und umfassende Sicherheitsfeatures.
+
+## Hauptkomponenten
+
+### `ssd-mount-manager.sh`
+**Zweck**: Flexibles Mount-Lifecycle Management mit konstantem Mount-Point
+
+**Hauptfunktionen**:
+- Automatisches Mounting auf `/mnt/ssd-storage`
+- NTFS-Kompatibilität mit optimierten Mount-Optionen
+- UUID-basierte Geräte-Zuordnung
+- Mount-Status Überwachung
+- Fehlerbehandlung und Recovery
+
+### `ssd-safe-eject.sh`
+**Zweck**: Sichere Hardware-Entfernung mit Datenintegritäts-Schutz
+
+**Hauptfunktionen**:
+- Buffer-Flush Überwachung
+- Prozess-Detection vor Eject
+- Hardware-Eject Funktionalität
+- Cleanup von Mount-Points
+- Audit-Logging
+
+## Verwendung
+
+### Mount-Manager
+
+#### Grundlegende Mount-Operationen
+```bash
+# Automatisches Mounting der erkannten SSD
+./ssd-mount-manager.sh mount
+
+# Spezifische SSD mounten
+./ssd-mount-manager.sh mount --device /dev/sdb1
+
+# Read-Only Mount für kritische Prüfungen
+./ssd-mount-manager.sh mount --readonly
+
+# Mount-Status prüfen
+./ssd-mount-manager.sh status
+```
+
+#### Erweiterte Mount-Optionen
+```bash
+# Custom Mount-Point
+./ssd-mount-manager.sh mount --mountpoint /custom/path
+
+# Spezifische NTFS-Optionen
+./ssd-mount-manager.sh mount --options "uid=1000,gid=1000,umask=022"
+
+# Automatisches Remounting
+./ssd-mount-manager.sh remount
+```
+
+### Safe-Eject
+
+#### Sichere Entfernung
+```bash
+# Standard Safe-Eject
+./ssd-safe-eject.sh
+
+# Force-Eject (bei hängenden Prozessen)
+./ssd-safe-eject.sh --force
+
+# Eject mit Prozess-Übersicht
+./ssd-safe-eject.sh --show-processes
+
+# Nur Unmount (ohne Hardware-Eject)
+./ssd-safe-eject.sh --unmount-only
+```
+
+#### Erweiterte Eject-Optionen
+```bash
+# Timeout für Buffer-Flush
+./ssd-safe-eject.sh --timeout 60
+
+# Verbose-Modus
+./ssd-safe-eject.sh --verbose
+
+# Dry-Run (Simulation)
+./ssd-safe-eject.sh --dry-run
+```
+
+## Konfiguration
+
+### Mount-Manager Konfiguration
+```bash
+# Standard Mount-Point
+export SSD_MOUNT_POINT="/mnt/ssd-storage"
+
+# Standard NTFS-Optionen
+export SSD_MOUNT_OPTIONS="uid=1000,gid=1000,umask=022,windows_names"
+
+# Timeout für Mount-Operationen
+export SSD_MOUNT_TIMEOUT=30
+```
+
+### Safe-Eject Konfiguration
+```bash
+# Buffer-Flush Timeout
+export SSD_EJECT_TIMEOUT=60
+
+# Prozess-Kill Timeout
+export SSD_PROCESS_TIMEOUT=10
+
+# Hardware-Eject aktivieren
+export SSD_HARDWARE_EJECT=true
+```
+
+## Mount-Point Management
+
+### Konstanter Mount-Point
+Das System verwendet einen konstanten logischen Mount-Point (`/mnt/ssd-storage`), unabhängig von der physischen SSD:
+
+```bash
+# Immer derselbe Pfad, verschiedene SSDs
+/mnt/ssd-storage/  # SSD A
+/mnt/ssd-storage/  # SSD B (nach Wechsel)
+/mnt/ssd-storage/  # SSD C (nach Wechsel)
+```
+
+### SMB-Freigabe Vorbereitung
+```bash
+# Optimierte Berechtigungen für SMB
+./ssd-mount-manager.sh mount --smb-ready
+
+# Automatische SMB-Konfiguration
+./ssd-mount-manager.sh mount --configure-smb
+```
+
+## Sicherheitsfeatures
+
+### Prozess-Detection
+```bash
+# Aktive Prozesse vor Eject anzeigen
+lsof /mnt/ssd-storage
+
+# Automatische Prozess-Beendigung
+./ssd-safe-eject.sh --kill-processes
+```
+
+### Buffer-Flush Überwachung
+```bash
+# Manueller Sync vor Eject
+sync && echo 3 > /proc/sys/vm/drop_caches
+
+# Automatische Buffer-Überwachung
+./ssd-safe-eject.sh --monitor-buffers
+```
+
+### Datenintegritäts-Prüfung
+```bash
+# Filesystem-Check vor Mount
+./ssd-mount-manager.sh mount --fsck
+
+# Readonly-Test vor produktivem Mount
+./ssd-mount-manager.sh test-mount
+```
+
+## Fehlerbehandlung
+
+### Mount-Fehler
+```bash
+# Häufige Mount-Probleme diagnostizieren
+./ssd-mount-manager.sh diagnose
+
+# Mount-Point Cleanup
+./ssd-mount-manager.sh cleanup
+
+# Recovery-Modus
+./ssd-mount-manager.sh recover
+```
+
+### Eject-Fehler
+```bash
+# Hängende Prozesse identifizieren
+./ssd-safe-eject.sh --list-blocking-processes
+
+# Force-Unmount
+./ssd-safe-eject.sh --force-unmount
+
+# Hardware-Reset
+./ssd-safe-eject.sh --hardware-reset
+```
+
+## Logging und Monitoring
+
+### Log-Konfiguration
+```bash
+# Log-Level setzen
+export SSD_LOG_LEVEL=INFO
+
+# Log-Datei konfigurieren
+export SSD_LOG_FILE="/var/log/ssd-management.log"
+
+# Syslog-Integration
+export SSD_USE_SYSLOG=true
+```
+
+### Monitoring-Integration
+```bash
+# Prometheus-Metriken
+./ssd-mount-manager.sh --metrics
+
+# Status-JSON für Monitoring
+./ssd-mount-manager.sh status --json
+```
+
+## Systemd-Integration
+
+### Service-Templates
+```bash
+# Mount-Service aktivieren
+sudo systemctl enable ssd-mount@.service
+
+# Auto-Mount bei USB-Events
+sudo systemctl enable ssd-automount.service
+```
+
+### Service-Konfiguration
+```ini
+# /etc/systemd/system/ssd-mount@.service
+[Unit]
+Description=SSD Mount Manager for %i
+After=local-fs.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/bin/ssd-mount-manager.sh mount --device %i
+ExecStop=/usr/local/bin/ssd-safe-eject.sh --device %i
+RemainAfterExit=yes
+
+[Install]
+WantedBy=multi-user.target
+```
+
+## Best Practices
+
+### Produktionsumgebung
+1. **Immer Safe-Eject verwenden** statt direkter `umount`
+2. **Mount-Status überwachen** vor kritischen Operationen
+3. **Logs regelmäßig prüfen** für Anomalien
+4. **Backup vor Mount-Operationen** bei kritischen Daten
+5. **Systemd-Services nutzen** für automatisches Management
+
+### Entwicklungsumgebung
+1. **Dry-Run Modus** für Tests verwenden
+2. **Verbose-Logging** für Debugging aktivieren
+3. **Recovery-Scripte** bereithalten
+4. **Test-SSDs** für Entwicklung verwenden
+
+## Changelog
+
+### Version 0.1.0
+- Initiale Implementierung
+- Mount-Manager mit konstantem Mount-Point
+- Safe-Eject mit Prozess-Detection
+- NTFS-Optimierungen
+- Systemd-Integration

scripts/ssd-management/ssd-mount-manager.sh

@@ -0,0 +1,347 @@
+#!/bin/bash
+# ssd-mount-manager.sh - USB-C SSD Mount Management
+# Zweck: Flexibles Mounting verschiedener SSDs auf konstanten Mount-Point
+
+set -e
+
+# Konfiguration
+MOUNT_POINT="/mnt/ssd-storage"
+CONFIG_FILE="/etc/ssd-mount.conf"
+LOG_FILE="/var/log/ssd-mount.log"
+
+# Logging-Funktion
+log_message() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | sudo tee -a "$LOG_FILE"
+    echo "$1"
+}
+
+# Konfigurationsdatei erstellen
+create_config() {
+    log_message "Erstelle Konfigurationsdatei..."
+    sudo tee "$CONFIG_FILE" > /dev/null << EOF
+# SSD Mount Manager Konfiguration
+# Erstellt: $(date)
+
+# Standard Mount-Point
+MOUNT_POINT="$MOUNT_POINT"
+
+# Standard Mount-Optionen für NTFS
+MOUNT_OPTIONS="defaults,uid=1000,gid=1000,umask=002,fmask=111,noatime"
+
+# Automatisches Unmounting bei Shutdown
+AUTO_UMOUNT=true
+
+# Backup der letzten gemounteten SSD
+LAST_DEVICE=""
+LAST_UUID=""
+EOF
+    log_message "Konfiguration erstellt: $CONFIG_FILE"
+}
+
+# Konfiguration laden
+load_config() {
+    if [ -f "$CONFIG_FILE" ]; then
+        source "$CONFIG_FILE"
+    else
+        create_config
+        source "$CONFIG_FILE"
+    fi
+}
+
+# Mount-Point vorbereiten
+prepare_mount_point() {
+    log_message "Bereite Mount-Point vor: $MOUNT_POINT"
+    
+    if [ ! -d "$MOUNT_POINT" ]; then
+        sudo mkdir -p "$MOUNT_POINT"
+        log_message "Mount-Point erstellt: $MOUNT_POINT"
+    fi
+    
+    sudo chown root:root "$MOUNT_POINT"
+    sudo chmod 755 "$MOUNT_POINT"
+    log_message "Mount-Point Berechtigungen gesetzt"
+}
+
+# Aktuelle Mounts prüfen
+check_current_mount() {
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        log_message "Aktuell gemountet: $mounted_device auf $MOUNT_POINT"
+        return 0
+    else
+        log_message "Kein Device auf $MOUNT_POINT gemountet"
+        return 1
+    fi
+}
+
+# Device unmounten
+unmount_device() {
+    log_message "Unmounte Device von $MOUNT_POINT..."
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        log_message "Unmounte $mounted_device..."
+        
+        sudo umount "$MOUNT_POINT"
+        log_message "Device erfolgreich unmountet"
+        
+        # Letztes Device in Config speichern
+        update_last_device ""
+    else
+        log_message "Kein Device zum Unmounten gefunden"
+    fi
+}
+
+# Safe-Eject Funktion
+safe_eject_device() {
+    log_message "Starte Safe-Eject Prozess..."
+    
+    # Externes Safe-Eject Script aufrufen
+    if command -v ssd-safe-eject >/dev/null; then
+        ssd-safe-eject eject
+    else
+        # Fallback: Integrierte Safe-Eject Funktionalität
+        perform_integrated_safe_eject
+    fi
+}
+
+# Integrierte Safe-Eject Funktionalität
+perform_integrated_safe_eject() {
+    if ! mountpoint -q "$MOUNT_POINT"; then
+        log_message "Keine SSD gemountet - Safe-Eject nicht erforderlich"
+        return 1
+    fi
+    
+    mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+    device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
+    
+    log_message "Safe-Eject für $mounted_device..."
+    
+    # Vollständiger Sync
+    log_message "Führe Sync durch..."
+    sync
+    sleep 2
+    
+    # Unmount
+    log_message "Unmounte Device..."
+    if sudo umount "$MOUNT_POINT"; then
+        log_success "Unmount erfolgreich"
+    else
+        log_error "Unmount fehlgeschlagen"
+        return 1
+    fi
+    
+    # Hardware-Eject
+    log_message "Hardware-Eject..."
+    if command -v eject >/dev/null; then
+        if sudo eject "$device_base" 2>/dev/null; then
+            log_success "Hardware-Eject erfolgreich"
+        else
+            log_warning "Hardware-Eject fehlgeschlagen"
+        fi
+    else
+        log_warning "eject Befehl nicht verfügbar"
+    fi
+    
+    # Finaler Sync
+    sync
+    
+    log_success "Safe-Eject abgeschlossen - SSD kann entfernt werden"
+    update_last_device ""
+}
+# Device mounten
+mount_device() {
+    local device="$1"
+    
+    if [ -z "$device" ]; then
+        log_message "Fehler: Kein Device angegeben"
+        return 1
+    fi
+    
+    if [ ! -b "$device" ]; then
+        log_message "Fehler: Device $device existiert nicht"
+        return 1
+    fi
+    
+    log_message "Mounte Device: $device"
+    
+    # Prüfe ob bereits etwas gemountet ist
+    if mountpoint -q "$MOUNT_POINT"; then
+        log_message "Mount-Point bereits belegt - unmounte zuerst..."
+        unmount_device
+    fi
+    
+    # Device mounten
+    log_message "Mounte $device auf $MOUNT_POINT mit Optionen: $MOUNT_OPTIONS"
+    sudo mount -t ntfs-3g -o "$MOUNT_OPTIONS" "$device" "$MOUNT_POINT"
+    
+    if [ $? -eq 0 ]; then
+        log_message "Mount erfolgreich: $device auf $MOUNT_POINT"
+        
+        # Device-Info speichern
+        device_uuid=$(sudo blkid -s UUID -o value "$device")
+        update_last_device "$device" "$device_uuid"
+        
+        # Mount-Status anzeigen
+        show_mount_status
+        return 0
+    else
+        log_message "Fehler beim Mounten von $device"
+        return 1
+    fi
+}
+
+# Letztes Device in Config updaten
+update_last_device() {
+    local device="$1"
+    local uuid="$2"
+    
+    sudo sed -i "s|LAST_DEVICE=.*|LAST_DEVICE=\"$device\"|" "$CONFIG_FILE"
+    sudo sed -i "s|LAST_UUID=.*|LAST_UUID=\"$uuid\"|" "$CONFIG_FILE"
+}
+
+# Mount-Status anzeigen
+show_mount_status() {
+    echo ""
+    echo "=== Mount-Status ==="
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        echo "✓ Gemountet: $mounted_device"
+        echo "✓ Mount-Point: $MOUNT_POINT"
+        
+        # Speicherplatz anzeigen
+        df -h "$MOUNT_POINT"
+        echo ""
+        
+        # Device-Details
+        device_uuid=$(sudo blkid -s UUID -o value "$mounted_device")
+        device_label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null || echo "Kein Label")
+        echo "UUID: $device_uuid"
+        echo "Label: $device_label"
+        
+        # Zugriffstest
+        if [ -r "$MOUNT_POINT" ]; then
+            echo "✓ Lesezugriff: OK"
+        else
+            echo "✗ Lesezugriff: Fehler"
+        fi
+        
+        if [ -w "$MOUNT_POINT" ]; then
+            echo "✓ Schreibzugriff: OK"
+        else
+            echo "✗ Schreibzugriff: Fehler"
+        fi
+        
+    else
+        echo "✗ Kein Device gemountet auf $MOUNT_POINT"
+    fi
+    echo ""
+}
+
+# Verfügbare NTFS-Devices auflisten
+list_ntfs_devices() {
+    echo "=== Verfügbare NTFS-Devices ==="
+    lsblk -f | grep ntfs | while IFS= read -r line; do
+        device=$(echo "$line" | awk '{print "/dev/" $1}')
+        uuid=$(echo "$line" | awk '{print $3}')
+        label=$(echo "$line" | awk '{print $4}')
+        size=$(lsblk -o SIZE "$device" 2>/dev/null | tail -1)
+        echo "$device | $size | UUID: $uuid | Label: $label"
+    done
+    echo ""
+}
+
+# Automatisches Device-Detection
+auto_detect_device() {
+    log_message "Automatische Device-Erkennung..."
+    
+    # Suche nach NTFS-Partitionen auf USB-Devices
+    for device in /dev/sd[a-z][0-9]*; do
+        if [ -b "$device" ]; then
+            fstype=$(lsblk -o FSTYPE "$device" 2>/dev/null | tail -1 | xargs)
+            if [ "$fstype" = "ntfs" ]; then
+                size=$(lsblk -b -o SIZE "$device" 2>/dev/null | tail -1)
+                size_gb=$((size / 1024 / 1024 / 1024))
+                
+                # Nur Devices > 100GB berücksichtigen (typisch für SSDs)
+                if [ $size_gb -gt 100 ]; then
+                    log_message "NTFS-SSD gefunden: $device (${size_gb}GB)"
+                    echo "$device"
+                    return 0
+                fi
+            fi
+        fi
+    done
+    
+    log_message "Keine geeignete NTFS-SSD gefunden"
+    return 1
+}
+
+# Hauptfunktion
+main() {
+    echo "=== USB-C SSD Mount Manager ==="
+    echo "Version: 1.0"
+    echo ""
+    
+    load_config
+    prepare_mount_point
+    
+    case "${1:-status}" in
+        "mount")
+            if [ -n "$2" ]; then
+                mount_device "$2"
+            else
+                # Auto-Detection
+                auto_device=$(auto_detect_device)
+                if [ -n "$auto_device" ]; then
+                    echo "Auto-erkanntes Device: $auto_device"
+                    echo "Mounten? (y/n)"
+                    read -r response
+                    if [ "$response" = "y" ] || [ "$response" = "Y" ]; then
+                        mount_device "$auto_device"
+                    fi
+                else
+                    echo "Kein Device auto-erkannt. Verfügbare Devices:"
+                    list_ntfs_devices
+                fi
+            fi
+            ;;
+        "unmount"|"umount")
+            unmount_device
+            ;;
+        "safe-eject"|"eject")
+            safe_eject_device
+            ;;
+        "status")
+            show_mount_status
+            ;;
+        "list")
+            list_ntfs_devices
+            ;;
+        "remount")
+            if check_current_mount; then
+                unmount_device
+                sleep 2
+            fi
+            auto_device=$(auto_detect_device)
+            if [ -n "$auto_device" ]; then
+                mount_device "$auto_device"
+            fi
+            ;;
+        *)
+            echo "Verwendung: $0 {mount [device]|unmount|safe-eject|status|list|remount}"
+            echo ""
+            echo "Befehle:"
+            echo "  mount [device]  - Device mounten (auto-detect wenn kein device)"
+            echo "  unmount         - Device unmounten (einfach)"
+            echo "  safe-eject      - Sichere USB-C SSD Entfernung mit Hardware-Eject"
+            echo "  status          - Mount-Status anzeigen"
+            echo "  list            - Verfügbare NTFS-Devices auflisten"
+            echo "  remount         - Unmount + Auto-detect + Mount"
+            ;;
+    esac
+}
+
+# Script ausführen
+main "$@"

scripts/ssd-testing/README.md

@@ -0,0 +1,349 @@
+# SSD Testing Module
+
+## Übersicht
+
+Das SSD Testing Module bietet umfassende Qualitätssicherung für USB-C SSDs mit 11 spezialisierten Tests, Performance-Messung und SMB-Bereitschaftsprüfung. Es gewährleistet die Zuverlässigkeit und Kompatibilität der Storage-Infrastruktur.
+
+## Hauptkomponenten
+
+### `ssd-test-suite.sh`
+**Zweck**: Umfassende Qualitätssicherung und Performance-Messung
+
+**Test-Kategorien**:
+- **Hardware-Tests**: Connectivity, Power, Temperature
+- **Filesystem-Tests**: NTFS-Integrität, Permissions, Capacity
+- **Performance-Tests**: Read/Write Speed, IOPS, Latency
+- **Integration-Tests**: SMB-Bereitschaft, Mount-Stabilität
+- **Security-Tests**: Access-Control, Encryption-Support
+
+## Test-Suite Übersicht
+
+### Die 11 Kern-Tests
+
+| Test-ID | Name | Zweck | Dauer |
+|---------|------|-------|-------|
+| `T01` | **Hardware Detection** | USB-C Connectivity und Device-Recognition | 5s |
+| `T02` | **NTFS Filesystem** | Dateisystem-Integrität und Kompatibilität | 10s |
+| `T03` | **Mount Stability** | Mount/Unmount Zyklen und Stabilität | 30s |
+| `T04` | **Read Performance** | Sequential und Random Read-Geschwindigkeit | 60s |
+| `T05` | **Write Performance** | Sequential und Random Write-Geschwindigkeit | 60s |
+| `T06` | **File Operations** | Create, Copy, Delete, Rename Operationen | 45s |
+| `T07` | **Permission System** | Linux-Permissions und NTFS-ACLs | 15s |
+| `T08` | **SMB Readiness** | SMB-Freigabe Kompatibilität und Performance | 30s |
+| `T09` | **Capacity Verification** | Verfügbarer Speicher und Fragmentierung | 20s |
+| `T10` | **Error Handling** | Fehlerbehandlung und Recovery-Mechanismen | 25s |
+| `T11` | **Security Scan** | Access-Control und Encryption-Support | 40s |
+
+## Verwendung
+
+### Grundlegende Test-Ausführung
+```bash
+# Alle Tests ausführen
+./ssd-test-suite.sh all
+
+# Spezifischen Test ausführen
+./ssd-test-suite.sh T01
+
+# Test-Kategorie ausführen
+./ssd-test-suite.sh --category hardware
+./ssd-test-suite.sh --category performance
+./ssd-test-suite.sh --category integration
+```
+
+### Erweiterte Test-Optionen
+```bash
+# Schnelle Tests (nur kritische)
+./ssd-test-suite.sh --quick
+
+# Umfassende Tests (alle mit erweiterten Parametern)
+./ssd-test-suite.sh --comprehensive
+
+# Performance-Benchmark
+./ssd-test-suite.sh --benchmark
+
+# Kontinuierliche Tests
+./ssd-test-suite.sh --continuous --interval 300
+```
+
+### Output-Formate
+```bash
+# Standard-Output (Human-readable)
+./ssd-test-suite.sh all
+
+# JSON-Output für Automation
+./ssd-test-suite.sh all --output json
+
+# XML-Report für CI/CD
+./ssd-test-suite.sh all --output xml
+
+# CSV für Datenanalyse
+./ssd-test-suite.sh all --output csv
+```
+
+## Test-Konfiguration
+
+### Environment Variables
+```bash
+# Test-Timeout (Sekunden)
+export SSD_TEST_TIMEOUT=300
+
+# Performance-Test Größe (MB)
+export SSD_TEST_SIZE=100
+
+# Test-Wiederholungen
+export SSD_TEST_ITERATIONS=3
+
+# Benchmark-Modus
+export SSD_BENCHMARK_MODE=true
+```
+
+### Konfigurationsdatei
+```bash
+# /etc/ssd-test/config.conf
+TEST_MOUNT_POINT="/mnt/ssd-storage"
+TEST_DATA_SIZE="100MB"
+PERFORMANCE_THRESHOLD_READ="50MB/s"
+PERFORMANCE_THRESHOLD_WRITE="30MB/s"
+SMB_TEST_ENABLED=true
+SECURITY_SCAN_ENABLED=true
+```
+
+## Test-Details
+
+### Hardware-Tests (T01-T03)
+
+#### T01: Hardware Detection
+```bash
+# Prüft USB-C Connectivity
+- Device-Erkennung im System
+- USB-Version und Geschwindigkeit
+- Power-Management Status
+- Device-Descriptor Validierung
+```
+
+#### T02: NTFS Filesystem
+```bash
+# Validiert NTFS-Kompatibilität
+- Dateisystem-Typ Verifikation
+- NTFS-Version Kompatibilität
+- Journal-Status Prüfung
+- Cluster-Size Optimierung
+```
+
+#### T03: Mount Stability
+```bash
+# Testet Mount/Unmount Zyklen
+- 10x Mount/Unmount Zyklen
+- Concurrent-Access Tests
+- Mount-Option Validierung
+- Recovery nach Fehlern
+```
+
+### Performance-Tests (T04-T06)
+
+#### T04: Read Performance
+```bash
+# Sequential Read Test
+dd if=/mnt/ssd-storage/testfile of=/dev/null bs=1M count=100
+
+# Random Read Test (4K Blocks)
+fio --name=random-read --ioengine=libaio --rw=randread --bs=4k --size=100M
+```
+
+#### T05: Write Performance
+```bash
+# Sequential Write Test
+dd if=/dev/zero of=/mnt/ssd-storage/testfile bs=1M count=100
+
+# Random Write Test (4K Blocks)
+fio --name=random-write --ioengine=libaio --rw=randwrite --bs=4k --size=100M
+```
+
+#### T06: File Operations
+```bash
+# Standard File-Operations
+- 1000 kleine Dateien erstellen (1KB)
+- 100 mittlere Dateien erstellen (1MB)
+- 10 große Dateien erstellen (10MB)
+- Copy, Move, Delete Operationen
+- Symlink und Hardlink Tests
+```
+
+### Integration-Tests (T07-T09)
+
+#### T07: Permission System
+```bash
+# Linux-Permissions testen
+chmod 755 /mnt/ssd-storage/testdir
+chown user:group /mnt/ssd-storage/testfile
+
+# NTFS-ACL Kompatibilität
+setfacl -m u:user:rwx /mnt/ssd-storage/testdir
+```
+
+#### T08: SMB Readiness
+```bash
+# SMB-Kompatibilität prüfen
+- Windows-Filename Kompatibilität
+- Extended Attributes Support
+- Case-Sensitivity Tests
+- Unicode-Filename Support
+- SMB-Performance Simulation
+```
+
+#### T09: Capacity Verification
+```bash
+# Speicher-Analyse
+df -h /mnt/ssd-storage
+du -sh /mnt/ssd-storage/*
+
+# Fragmentierung prüfen
+fsck.ntfs -f /dev/sdb1
+```
+
+### Security-Tests (T10-T11)
+
+#### T10: Error Handling
+```bash
+# Fehlerbehandlung testen
+- Disk-Full Simulation
+- Permission-Denied Scenarios
+- Network-Interruption (bei SMB)
+- Hardware-Disconnect Simulation
+```
+
+#### T11: Security Scan
+```bash
+# Security-Features prüfen
+- Access-Control Lists (ACLs)
+- Encryption-Support Detection
+- Secure-Delete Capabilities
+- Audit-Trail Funktionalität
+```
+
+## Benchmark-Modus
+
+### Performance-Metriken
+```bash
+# Detaillierte Performance-Analyse
+./ssd-test-suite.sh --benchmark --detailed
+
+# Vergleich mit Referenz-Werten
+./ssd-test-suite.sh --benchmark --compare baseline.json
+
+# Performance-Trend Analyse
+./ssd-test-suite.sh --benchmark --trend --days 30
+```
+
+### Benchmark-Output
+```json
+{
+  "device": "/dev/sdb1",
+  "timestamp": "2025-08-07T19:10:00Z",
+  "performance": {
+    "sequential_read": "120 MB/s",
+    "sequential_write": "85 MB/s",
+    "random_read_4k": "15000 IOPS",
+    "random_write_4k": "8000 IOPS",
+    "latency_avg": "2.5ms"
+  },
+  "health": {
+    "temperature": "45°C",
+    "wear_level": "2%",
+    "error_count": 0
+  }
+}
+```
+
+## CI/CD Integration
+
+### Jenkins Pipeline
+```groovy
+pipeline {
+    agent any
+    stages {
+        stage('SSD Tests') {
+            steps {
+                sh './ssd-test-suite.sh all --output xml'
+                publishTestResults testResultsPattern: 'ssd-test-results.xml'
+            }
+        }
+    }
+}
+```
+
+### GitHub Actions
+```yaml
+name: SSD Tests
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Run SSD Tests
+        run: ./ssd-test-suite.sh all --output json
+```
+
+## Monitoring Integration
+
+### Prometheus-Metriken
+```bash
+# Metriken exportieren
+./ssd-test-suite.sh --prometheus-metrics
+
+# Grafana-Dashboard
+# Siehe examples/monitoring/grafana-dashboard.json
+```
+
+### Alerting
+```bash
+# Performance-Alerts
+if [ $READ_SPEED -lt 50 ]; then
+    alert "SSD Read Performance below threshold"
+fi
+
+# Health-Alerts
+if [ $ERROR_COUNT -gt 0 ]; then
+    alert "SSD Errors detected"
+fi
+```
+
+## Troubleshooting
+
+### Häufige Test-Fehler
+1. **T01 Failed**: USB-Verbindung prüfen, Treiber aktualisieren
+2. **T04/T05 Slow**: SSD-Health prüfen, USB-Port wechseln
+3. **T08 Failed**: SMB-Packages installieren, Firewall prüfen
+
+### Debug-Modus
+```bash
+# Erweiterte Diagnose
+./ssd-test-suite.sh all --debug --verbose
+
+# Test-Logs analysieren
+tail -f /var/log/ssd-test.log
+```
+
+## Best Practices
+
+### Produktionsumgebung
+1. **Regelmäßige Tests** (täglich/wöchentlich) einrichten
+2. **Performance-Baselines** etablieren und überwachen
+3. **Test-Ergebnisse archivieren** für Trend-Analyse
+4. **Automatische Alerts** bei Test-Fehlern konfigurieren
+
+### Entwicklungsumgebung
+1. **Quick-Tests** vor Code-Changes ausführen
+2. **Comprehensive-Tests** vor Releases durchführen
+3. **Benchmark-Vergleiche** für Performance-Regression
+4. **Test-Coverage** für alle SSD-Typen sicherstellen
+
+## Changelog
+
+### Version 0.1.0
+- 11 umfassende Test-Kategorien
+- Performance-Benchmark Integration
+- SMB-Bereitschaftsprüfung
+- CI/CD Pipeline Support
+- Prometheus-Metriken Export

scripts/ssd-testing/ssd-test-suite.sh

@@ -0,0 +1,419 @@
+#!/bin/bash
+# ssd-test-suite.sh - USB-C SSD Test Suite
+# Zweck: Umfassende Tests für gemountete SSDs
+
+set -e
+
+# Konfiguration
+MOUNT_POINT="/mnt/ssd-storage"
+TEST_DIR="$MOUNT_POINT/.ssd-tests"
+LOG_FILE="/var/log/ssd-tests.log"
+
+# Farben für Ausgabe
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging und Ausgabe
+log_test() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - TEST: $1" >> "$LOG_FILE"
+    echo -e "${BLUE}[TEST]${NC} $1"
+}
+
+log_success() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - SUCCESS: $1" >> "$LOG_FILE"
+    echo -e "${GREEN}[✓]${NC} $1"
+}
+
+log_warning() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - WARNING: $1" >> "$LOG_FILE"
+    echo -e "${YELLOW}[!]${NC} $1"
+}
+
+log_error() {
+    echo "$(date '+%Y-%m-%d %H:%M:%S') - ERROR: $1" >> "$LOG_FILE"
+    echo -e "${RED}[✗]${NC} $1"
+}
+
+# Test 1: Mount-Status prüfen
+test_mount_status() {
+    log_test "Prüfe Mount-Status..."
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        log_success "SSD ist gemountet: $mounted_device auf $MOUNT_POINT"
+        return 0
+    else
+        log_error "Keine SSD auf $MOUNT_POINT gemountet"
+        return 1
+    fi
+}
+
+# Test 2: Dateisystem-Typ prüfen
+test_filesystem_type() {
+    log_test "Prüfe Dateisystem-Typ..."
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        fs_type=$(lsblk -o FSTYPE "$mounted_device" | tail -1 | xargs)
+        
+        if [ "$fs_type" = "ntfs" ]; then
+            log_success "Dateisystem: NTFS ✓"
+            return 0
+        else
+            log_warning "Dateisystem: $fs_type (erwartet: NTFS)"
+            return 1
+        fi
+    else
+        log_error "Kein gemountetes Device für Filesystem-Test"
+        return 1
+    fi
+}
+
+# Test 3: Lesezugriff prüfen
+test_read_access() {
+    log_test "Prüfe Lesezugriff..."
+    
+    if [ -r "$MOUNT_POINT" ]; then
+        # Versuche Verzeichnis-Listing
+        file_count=$(ls -1 "$MOUNT_POINT" 2>/dev/null | wc -l)
+        log_success "Lesezugriff OK - $file_count Objekte gefunden"
+        return 0
+    else
+        log_error "Kein Lesezugriff auf $MOUNT_POINT"
+        return 1
+    fi
+}
+
+# Test 4: Schreibzugriff prüfen
+test_write_access() {
+    log_test "Prüfe Schreibzugriff..."
+    
+    test_file="$MOUNT_POINT/.write_test_$(date +%s).tmp"
+    
+    if echo "Write test - $(date)" > "$test_file" 2>/dev/null; then
+        if [ -f "$test_file" ]; then
+            content=$(cat "$test_file")
+            rm -f "$test_file"
+            log_success "Schreibzugriff OK"
+            return 0
+        else
+            log_error "Datei konnte nicht erstellt werden"
+            return 1
+        fi
+    else
+        log_error "Kein Schreibzugriff auf $MOUNT_POINT"
+        return 1
+    fi
+}
+
+# Test 5: Verzeichnis-Operationen
+test_directory_operations() {
+    log_test "Prüfe Verzeichnis-Operationen..."
+    
+    # Test-Verzeichnis erstellen
+    if mkdir -p "$TEST_DIR" 2>/dev/null; then
+        log_success "Verzeichnis erstellen: OK"
+        
+        # Test-Unterverzeichnis
+        sub_dir="$TEST_DIR/subdir_$(date +%s)"
+        if mkdir "$sub_dir" 2>/dev/null; then
+            log_success "Unterverzeichnis erstellen: OK"
+            
+            # Verzeichnis löschen
+            if rmdir "$sub_dir" 2>/dev/null; then
+                log_success "Verzeichnis löschen: OK"
+            else
+                log_warning "Verzeichnis löschen: Fehler"
+            fi
+        else
+            log_warning "Unterverzeichnis erstellen: Fehler"
+        fi
+        
+        # Test-Verzeichnis aufräumen
+        rmdir "$TEST_DIR" 2>/dev/null || log_warning "Test-Verzeichnis Cleanup: Fehler"
+        return 0
+    else
+        log_error "Verzeichnis-Operationen: Fehler"
+        return 1
+    fi
+}
+
+# Test 6: Performance-Test (Schreibgeschwindigkeit)
+test_write_performance() {
+    log_test "Prüfe Schreibperformance..."
+    
+    test_file="$MOUNT_POINT/.performance_test_$(date +%s).tmp"
+    
+    # 100MB Test-Datei schreiben
+    start_time=$(date +%s.%N)
+    
+    if dd if=/dev/zero of="$test_file" bs=1M count=100 2>/dev/null; then
+        end_time=$(date +%s.%N)
+        duration=$(echo "$end_time - $start_time" | bc -l 2>/dev/null || echo "0")
+        
+        if [ -f "$test_file" ]; then
+            file_size=$(stat -c%s "$test_file" 2>/dev/null || echo "0")
+            rm -f "$test_file"
+            
+            if command -v bc >/dev/null && [ "$duration" != "0" ]; then
+                speed=$(echo "scale=2; ($file_size / 1024 / 1024) / $duration" | bc -l)
+                log_success "Schreibgeschwindigkeit: ${speed} MB/s"
+            else
+                log_success "Performance-Test abgeschlossen (Zeit: ${duration}s)"
+            fi
+        else
+            log_warning "Performance-Test: Datei nicht erstellt"
+        fi
+        return 0
+    else
+        log_error "Performance-Test: Schreibfehler"
+        return 1
+    fi
+}
+
+# Test 7: Speicherplatz prüfen
+test_disk_space() {
+    log_test "Prüfe Speicherplatz..."
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        space_info=$(df -h "$MOUNT_POINT" | tail -1)
+        total=$(echo "$space_info" | awk '{print $2}')
+        used=$(echo "$space_info" | awk '{print $3}')
+        available=$(echo "$space_info" | awk '{print $4}')
+        usage=$(echo "$space_info" | awk '{print $5}')
+        
+        log_success "Speicherplatz - Total: $total, Belegt: $used, Verfügbar: $available, Auslastung: $usage"
+        
+        # Warnung bei hoher Auslastung
+        usage_percent=$(echo "$usage" | sed 's/%//')
+        if [ "$usage_percent" -gt 90 ]; then
+            log_warning "Hohe Speicherauslastung: $usage"
+        fi
+        
+        return 0
+    else
+        log_error "Speicherplatz-Check: Kein gemountetes Device"
+        return 1
+    fi
+}
+
+# Test 8: NTFS-spezifische Eigenschaften
+test_ntfs_features() {
+    log_test "Prüfe NTFS-Features..."
+    
+    if mountpoint -q "$MOUNT_POINT"; then
+        mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+        
+        # UUID prüfen
+        uuid=$(sudo blkid -s UUID -o value "$mounted_device" 2>/dev/null)
+        if [ -n "$uuid" ]; then
+            log_success "NTFS UUID: $uuid"
+        else
+            log_warning "NTFS UUID nicht ermittelbar"
+        fi
+        
+        # Label prüfen
+        label=$(sudo blkid -s LABEL -o value "$mounted_device" 2>/dev/null)
+        if [ -n "$label" ]; then
+            log_success "NTFS Label: $label"
+        else
+            log_success "NTFS Label: (kein Label gesetzt)"
+        fi
+        
+        # NTFS-spezifische Mount-Optionen prüfen
+        mount_options=$(mount | grep "$MOUNT_POINT" | sed 's/.*(\(.*\)).*/\1/')
+        log_success "Mount-Optionen: $mount_options"
+        
+        return 0
+    else
+        log_error "NTFS-Features: Kein gemountetes Device"
+        return 1
+    fi
+}
+
+# Test 9: SMB-Bereitschaft prüfen
+test_smb_readiness() {
+    log_test "Prüfe SMB-Bereitschaft..."
+    
+    # Benutzer-/Gruppen-Zugriff prüfen
+    user_id=$(id -u)
+    group_id=$(id -g)
+    
+    if [ -r "$MOUNT_POINT" ] && [ -w "$MOUNT_POINT" ]; then
+        log_success "Benutzer-Zugriff (UID: $user_id, GID: $group_id): OK"
+        
+        # Test-Datei für SMB-Zugriff erstellen
+        smb_test_file="$MOUNT_POINT/.smb_test_$(date +%s).txt"
+        if echo "SMB Test - $(date)" > "$smb_test_file" 2>/dev/null; then
+            if [ -f "$smb_test_file" ]; then
+                rm -f "$smb_test_file"
+                log_success "SMB-Test-Datei: OK"
+            fi
+        fi
+        
+        return 0
+    else
+        log_error "SMB-Bereitschaft: Unzureichende Zugriffsrechte"
+        return 1
+    fi
+}
+
+# Test 10: Safe-Eject Bereitschaft prüfen
+test_safe_eject_readiness() {
+    log_test "Prüfe Safe-Eject Bereitschaft..."
+    
+    if ! mountpoint -q "$MOUNT_POINT"; then
+        log_warning "Safe-Eject: Kein Device gemountet"
+        return 1
+    fi
+    
+    mounted_device=$(df "$MOUNT_POINT" | tail -1 | awk '{print $1}')
+    device_base=$(echo "$mounted_device" | sed 's/[0-9]*$//')
+    
+    # USB-Device prüfen
+    if lsblk -o TRAN "$device_base" 2>/dev/null | grep -q usb; then
+        log_success "USB-Device erkannt: Safe-Eject verfügbar"
+        
+        # eject Befehl prüfen
+        if command -v eject >/dev/null; then
+            log_success "eject Befehl: Verfügbar"
+        else
+            log_warning "eject Befehl: Nicht installiert (installierbar mit: sudo apt install eject)"
+        fi
+        
+        # Aktive Prozesse prüfen
+        active_count=$(lsof "$MOUNT_POINT" 2>/dev/null | wc -l)
+        if [ "$active_count" -eq 0 ]; then
+            log_success "Aktive Prozesse: Keine (Safe-Eject bereit)"
+        else
+            log_warning "Aktive Prozesse: $active_count (Safe-Eject mit Vorsicht)"
+        fi
+        
+        # Buffer-Status prüfen
+        dirty_pages=$(cat /proc/meminfo | grep "Dirty:" | awk '{print $2}')
+        if [ "$dirty_pages" -le 100 ]; then
+            log_success "System Buffer: Sauber (${dirty_pages}kB)"
+        else
+            log_warning "System Buffer: Dirty Pages vorhanden (${dirty_pages}kB)"
+        fi
+        
+        return 0
+    else
+        log_warning "Kein USB-Device - Safe-Eject nicht erforderlich"
+        return 1
+    fi
+}
+
+# Test 11: Gesamtsystem-Status
+test_system_status() {
+    log_test "Prüfe Gesamtsystem-Status..."
+    
+    # NTFS-3G prüfen
+    if command -v mount.ntfs-3g >/dev/null; then
+        log_success "NTFS-3G: Installiert"
+    else
+        log_error "NTFS-3G: Nicht installiert"
+    fi
+    
+    # Kernel-Module prüfen
+    if lsmod | grep -q ntfs; then
+        log_success "NTFS Kernel-Modul: Geladen"
+    else
+        log_warning "NTFS Kernel-Modul: Nicht erkannt"
+    fi
+    
+    # System-Load prüfen
+    load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
+    log_success "System Load: $load_avg"
+    
+    return 0
+}
+
+# Alle Tests ausführen
+run_all_tests() {
+    echo "=== USB-C SSD Test Suite ==="
+    echo "Version: 1.0"
+    echo "Zeitstempel: $(date)"
+    echo "Mount-Point: $MOUNT_POINT"
+    echo ""
+    
+    total_tests=11
+    passed_tests=0
+    
+    # Test-Log initialisieren
+    echo "=== Test-Session gestartet: $(date) ===" >> "$LOG_FILE"
+    
+    # Tests ausführen
+    test_mount_status && ((passed_tests++))
+    test_filesystem_type && ((passed_tests++))
+    test_read_access && ((passed_tests++))
+    test_write_access && ((passed_tests++))
+    test_directory_operations && ((passed_tests++))
+    test_write_performance && ((passed_tests++))
+    test_disk_space && ((passed_tests++))
+    test_ntfs_features && ((passed_tests++))
+    test_smb_readiness && ((passed_tests++))
+    test_safe_eject_readiness && ((passed_tests++))
+    test_system_status && ((passed_tests++))
+    
+    echo ""
+    echo "=== Test-Zusammenfassung ==="
+    echo "Tests bestanden: $passed_tests/$total_tests"
+    
+    if [ $passed_tests -eq $total_tests ]; then
+        log_success "Alle Tests bestanden - SSD ist bereit für SMB-Freigabe!"
+        echo "=== ALLE TESTS BESTANDEN ===" >> "$LOG_FILE"
+        return 0
+    else
+        failed_tests=$((total_tests - passed_tests))
+        log_warning "$failed_tests Tests fehlgeschlagen - Überprüfung erforderlich"
+        echo "=== $failed_tests TESTS FEHLGESCHLAGEN ===" >> "$LOG_FILE"
+        return 1
+    fi
+}
+
+# Hauptfunktion
+main() {
+    case "${1:-all}" in
+        "all")
+            run_all_tests
+            ;;
+        "quick")
+            echo "=== Quick Test ==="
+            test_mount_status && test_read_access && test_write_access
+            ;;
+        "mount")
+            test_mount_status
+            ;;
+        "access")
+            test_read_access && test_write_access
+            ;;
+        "performance")
+            test_write_performance
+            ;;
+        "smb")
+            test_smb_readiness
+            ;;
+        "safe-eject"|"eject")
+            test_safe_eject_readiness
+            ;;
+        *)
+            echo "Verwendung: $0 {all|quick|mount|access|performance|smb|safe-eject}"
+            echo ""
+            echo "Tests:"
+            echo "  all         - Alle Tests ausführen (empfohlen)"
+            echo "  quick       - Schnelle Basis-Tests"
+            echo "  mount       - Nur Mount-Status prüfen"
+            echo "  access      - Nur Zugriff prüfen"
+            echo "  performance - Nur Performance-Test"
+            echo "  smb         - Nur SMB-Bereitschaft prüfen"
+            echo "  safe-eject  - Nur Safe-Eject Bereitschaft prüfen"
+            ;;
+    esac
+}
+
+# Script ausführen
+main "$@"