br/lpic-sim
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rein damit

Browse Source
This commit is contained in:
Björn Runden committed 2026-10-30 10:11:43 +01:00
1 parent 7f6b8ebe07
commit 07dbc01c92
38 files changed
+5632 -5
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

simulator/data/lpic1_101/exam.json
+73
View File
@@ -0,0 +1,73 @@
{
"meta": {
"file": "exam.json",
"brief": "Prüfungsdefinition LPIC-1 101-500: Eckdaten, Topics, Objectives mit Gewichtung",
"author": "Björn Runden <br@runden.de>",
"owner": "Björn Runden <br@runden.de>",
"assist": "KI-unterstützt (Claude Opus 5.5), geprüft von Björn Runden <br@runden.de>",
"version": "0.1.0 (29.10.2026)"
},
"exam": {
"id": "lpic1-101",
"level": "LPIC-1",
"title": "LPIC-1 Prüfung 101",
"code": "101-500",
"lang": "de",
"order": 101,
"objectives_version": "5.0",
"objectives_source": "https://www.lpi.org/de/exam-101-102-objectives/",
"objectives_retrieved": "2026-10-29",
"questions": 60,
"duration_min": 90,
"pass_percent": 65
},
"topics": [
{
"id": "101",
"title": "Systemarchitektur",
"objectives": [
{ "id": "101.1", "title": "Hardwareeinstellungen ermitteln und konfigurieren", "weight": 2 },
{ "id": "101.2", "title": "Das System starten", "weight": 3 },
{ "id": "101.3", "title": "Runlevel wechseln und das System anhalten oder neu starten", "weight": 3 }
]
},
{
"id": "102",
"title": "Linux-Installation und -Paketverwaltung",
"objectives": [
{ "id": "102.1", "title": "Festplattenaufteilung planen", "weight": 2 },
{ "id": "102.2", "title": "Einen Bootmanager installieren", "weight": 2 },
{ "id": "102.3", "title": "Shared Libraries verwalten", "weight": 1 },
{ "id": "102.4", "title": "Debian-Paketverwaltung verwenden", "weight": 3 },
{ "id": "102.5", "title": "RPM und YUM-Paketverwaltung verwenden", "weight": 3 },
{ "id": "102.6", "title": "Linux als Virtualisierungs-Gast", "weight": 1 }
]
},
{
"id": "103",
"title": "GNU- und Unix-Befehle",
"objectives": [
{ "id": "103.1", "title": "Auf der Befehlszeile arbeiten", "weight": 4 },
{ "id": "103.2", "title": "Textströme mit Filtern verarbeiten", "weight": 2 },
{ "id": "103.3", "title": "Grundlegende Dateiverwaltung", "weight": 4 },
{ "id": "103.4", "title": "Ströme, Pipes und Umleitungen verwenden", "weight": 4 },
{ "id": "103.5", "title": "Prozesse erzeugen, überwachen und beenden", "weight": 4 },
{ "id": "103.6", "title": "Prozess-Ausführungsprioritäten ändern", "weight": 2 },
{ "id": "103.7", "title": "Textdateien mit regulären Ausdrücken durchsuchen", "weight": 3 },
{ "id": "103.8", "title": "Grundlegendes Editieren von Dateien", "weight": 3 }
]
},
{
"id": "104",
"title": "Geräte, Linux-Dateisysteme, Filesystem Hierarchy Standard",
"objectives": [
{ "id": "104.1", "title": "Partitionen und Dateisysteme anlegen", "weight": 2 },
{ "id": "104.2", "title": "Die Integrität von Dateisystemen sichern", "weight": 2 },
{ "id": "104.3", "title": "Das Mounten und Unmounten von Dateisystemen steuern", "weight": 3 },
{ "id": "104.5", "title": "Dateizugriffsrechte und -eigentümerschaft verwalten", "weight": 3 },
{ "id": "104.6", "title": "Symbolische und Hardlinks anlegen und ändern", "weight": 2 },
{ "id": "104.7", "title": "Systemdateien finden und Dateien am richtigen Ort platzieren", "weight": 2 }
]
}
]
}
simulator/data/lpic1_101/questions_101.json
+173
View File
@@ -0,0 +1,173 @@
{
"$schema": "../schema/questions.schema.json",
"format": "lpic-sim-questions",
"meta": {
"file": "questions_101.json",
"brief": "Fragen zu Topic 101 Systemarchitektur (LPIC-1 101-500, Objectives 5.0)",
"author": "Björn Runden <br@runden.de>",
"owner": "Björn Runden <br@runden.de>",
"assist": "KI-unterstützt (Claude Opus 5.5), geprüft von Björn Runden <br@runden.de>",
"version": "0.1.0 (29.10.2026)"
},
"exam": "lpic1-101",
"questions": [
{
"id": "101.1-001",
"objective": "101.1",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl listet alle aktuell geladenen Kernelmodule auf?",
"options": [
{ "id": "a", "text": "`lsmod`", "correct": true, "explanation": "`lsmod` formatiert den Inhalt von `/proc/modules`: Modulname, Größe und Nutzer." },
{ "id": "b", "text": "`modinfo`", "correct": false, "explanation": "`modinfo` zeigt Informationen zu einem bestimmten Modul (Autor, Parameter, Datei), listet aber nicht die geladenen Module." },
{ "id": "c", "text": "`lspci -k`", "correct": false, "explanation": "`lspci -k` zeigt nur zu PCI-Geräten den verwendeten Treiber, nicht alle geladenen Module." },
{ "id": "d", "text": "`depmod -a`", "correct": false, "explanation": "`depmod` erzeugt die Abhängigkeitsdatei `modules.dep`, es listet nichts auf." },
{ "id": "e", "text": "`insmod -l`", "correct": false, "explanation": "`insmod` lädt eine einzelne Moduldatei ohne Abhängigkeiten; eine Listen-Option gibt es nicht." }
],
"explanation": "Geladene Module stehen in `/proc/modules`; `lsmod` ist die lesbare Darstellung davon.",
"references": ["man 8 lsmod", "/proc/modules"]
},
{
"id": "101.1-002",
"objective": "101.1",
"type": "multi",
"difficulty": 1,
"question": "Welche Verzeichnisse sind Einhängepunkte virtueller Dateisysteme, über die der Kernel zur Laufzeit Informationen über Prozesse, Hardware und Treiber bereitstellt?",
"options": [
{ "id": "a", "text": "`/proc`", "correct": true, "explanation": "procfs: Prozessinformationen und Kernel-Daten wie `/proc/cpuinfo`, `/proc/interrupts`." },
{ "id": "b", "text": "`/sys`", "correct": true, "explanation": "sysfs: Geräte, Treiber und Busse als Verzeichnisbaum; Grundlage für udev." },
{ "id": "c", "text": "`/boot`", "correct": false, "explanation": "`/boot` ist ein normales Dateisystem mit Kernel, initramfs und Bootloader-Dateien." },
{ "id": "d", "text": "`/etc`", "correct": false, "explanation": "`/etc` enthält statische Konfigurationsdateien auf der Festplatte." },
{ "id": "e", "text": "`/var/lib`", "correct": false, "explanation": "`/var/lib` enthält dauerhafte Zustandsdaten von Programmen, keine Kernel-Schnittstelle." }
],
"explanation": "procfs (`/proc`) und sysfs (`/sys`) existieren nur im Speicher und werden vom Kernel beim Lesen erzeugt. Werkzeuge wie `lspci`, `lsusb` und udev lesen dort.",
"references": ["man 5 proc", "man 5 sysfs"]
},
{
"id": "101.1-003",
"objective": "101.1",
"type": "fill",
"difficulty": 1,
"question": "Mit welchem Befehl (nur der Befehlsname) lädt man ein Kernelmodul **mitsamt seinen Abhängigkeiten**?",
"answers": ["modprobe"],
"explanation": "`modprobe` löst Abhängigkeiten über `modules.dep` auf und lädt sie mit; `modprobe -r` entlädt. `insmod` lädt dagegen nur genau die angegebene Datei.",
"references": ["man 8 modprobe"]
},
{
"id": "101.2-001",
"objective": "101.2",
"type": "single",
"difficulty": 1,
"question": "Ein Administrator möchte die Meldungen des Kernel-Ring-Buffers (z. B. Hardware-Erkennung beim Start) ansehen. Welcher Befehl gibt diesen Puffer aus?",
"options": [
{ "id": "a", "text": "`dmesg`", "correct": true, "explanation": "`dmesg` liest den Kernel-Ring-Buffer und gibt ihn aus." },
{ "id": "b", "text": "`uname -a`", "correct": false, "explanation": "`uname -a` zeigt Kernelname, Version, Architektur – keine Meldungen." },
{ "id": "c", "text": "`lsmod`", "correct": false, "explanation": "`lsmod` listet geladene Module, nicht die Kernel-Meldungen." },
{ "id": "d", "text": "`cat /proc/cmdline`", "correct": false, "explanation": "`/proc/cmdline` enthält nur die Kernel-Parameter des letzten Starts." },
{ "id": "e", "text": "`last -x`", "correct": false, "explanation": "`last -x` zeigt Anmeldungen sowie Shutdown-/Runlevel-Einträge aus `wtmp`, nicht den Ring-Buffer." }
],
"explanation": "Der Ring-Buffer hat eine feste Größe; ältere Meldungen werden überschrieben. Bei systemd sind Kernel-Meldungen zusätzlich mit `journalctl -k` im Journal abrufbar.",
"references": ["man 1 dmesg"]
},
{
"id": "101.2-002",
"objective": "101.2",
"type": "fill",
"difficulty": 2,
"question": "In welcher Datei (vollständiger Pfad) kann man nachlesen, mit welchen Parametern der laufende Kernel gestartet wurde?",
"answers": ["/proc/cmdline"],
"explanation": "`/proc/cmdline` enthält die vom Bootloader übergebene Kernel-Befehlszeile, z. B. `root=…`, `ro`, `quiet`.",
"references": ["man 5 proc"]
},
{
"id": "101.2-003",
"objective": "101.2",
"type": "single",
"difficulty": 2,
"question": "In welcher Reihenfolge laufen die Phasen beim Start eines BIOS-Systems mit GRUB 2 und systemd ab?",
"options": [
{ "id": "a", "text": "Firmware (POST) → Bootloader → Kernel mit initramfs → systemd", "correct": true, "explanation": "Die Firmware prüft die Hardware und startet den Bootloader, der Kernel und initramfs lädt; der Kernel startet zuletzt den ersten Prozess." },
{ "id": "b", "text": "Bootloader → Firmware (POST) → Kernel mit initramfs → systemd", "correct": false, "explanation": "Der Bootloader wird erst von der Firmware gestartet, kann also nicht vor ihr laufen." },
{ "id": "c", "text": "Firmware (POST) → Kernel mit initramfs → Bootloader → systemd", "correct": false, "explanation": "Der Bootloader lädt den Kernel – er läuft daher vor dem Kernel." },
{ "id": "d", "text": "Firmware (POST) → Bootloader → systemd → Kernel mit initramfs", "correct": false, "explanation": "systemd ist ein Userspace-Prozess und wird vom Kernel gestartet, nicht umgekehrt." },
{ "id": "e", "text": "Firmware (POST) → initramfs → Bootloader → Kernel → systemd", "correct": false, "explanation": "Die initramfs wird vom Bootloader gemeinsam mit dem Kernel geladen und erst vom Kernel benutzt." }
],
"explanation": "Ablauf: Firmware (BIOS/UEFI) → Bootloader (GRUB 2) → Kernel + initramfs (Treiber, Root-Dateisystem einhängen) → init-Prozess mit PID 1 (systemd oder SysV-init).",
"references": ["man 7 bootup"]
},
{
"id": "101.2-004",
"objective": "101.2",
"type": "multi",
"difficulty": 2,
"question": "Welche Aussagen zur initramfs treffen zu?",
"options": [
{ "id": "a", "text": "Sie enthält Treiber und Werkzeuge, die nötig sind, um das eigentliche Root-Dateisystem einzuhängen.", "correct": true, "explanation": "Typisch sind Module für Storage-Controller, LVM, RAID oder Verschlüsselung." },
{ "id": "b", "text": "Sie wird vom Bootloader zusammen mit dem Kernel in den Arbeitsspeicher geladen.", "correct": true, "explanation": "GRUB lädt Kernel und initramfs (Eintrag `initrd`) gemeinsam." },
{ "id": "c", "text": "Sie ersetzt den Kernel, wenn dieser beschädigt ist.", "correct": false, "explanation": "Die initramfs ist ein Dateisystem-Abbild, kein Ersatzkernel." },
{ "id": "d", "text": "Sie wird nur bei UEFI-Systemen verwendet.", "correct": false, "explanation": "Die initramfs ist unabhängig von der Firmware; sie wird bei BIOS und UEFI genutzt." },
{ "id": "e", "text": "Sie ist unter `/sys/initramfs` dauerhaft eingehängt.", "correct": false, "explanation": "Nach dem Wechsel auf das echte Root-Dateisystem wird die initramfs verworfen; ihr Abbild liegt meist in `/boot`." }
],
"explanation": "Die initramfs ist ein (meist komprimiertes cpio-)Abbild eines kleinen Root-Dateisystems. Sie überbrückt die Zeit, bis der Kernel das echte Root-Dateisystem einhängen kann.",
"references": ["man 8 dracut", "man 8 update-initramfs"]
},
{
"id": "101.3-001",
"objective": "101.3",
"type": "single",
"difficulty": 1,
"question": "Welches systemd-Target entspricht dem SysV-Runlevel 3 (Mehrbenutzerbetrieb mit Netzwerk, ohne grafische Oberfläche)?",
"options": [
{ "id": "a", "text": "`multi-user.target`", "correct": true, "explanation": "`multi-user.target` entspricht den Runlevels 2–4." },
{ "id": "b", "text": "`graphical.target`", "correct": false, "explanation": "`graphical.target` entspricht Runlevel 5 (mit grafischer Anmeldung)." },
{ "id": "c", "text": "`rescue.target`", "correct": false, "explanation": "`rescue.target` entspricht Runlevel 1 (Einzelbenutzer)." },
{ "id": "d", "text": "`emergency.target`", "correct": false, "explanation": "`emergency.target` startet nur eine Notfall-Shell, Root meist nur lesend eingehängt." },
{ "id": "e", "text": "`network.target`", "correct": false, "explanation": "`network.target` ist ein Synchronisationspunkt für Netzwerkdienste, kein Systemzustand wie ein Runlevel." }
],
"explanation": "Zuordnung: 0 → `poweroff.target`, 1 → `rescue.target`, 2–4 → `multi-user.target`, 5 → `graphical.target`, 6 → `reboot.target`.",
"references": ["man 7 systemd.special", "man 1 systemctl"]
},
{
"id": "101.3-002",
"objective": "101.3",
"type": "fill",
"difficulty": 2,
"question": "Geben Sie den vollständigen Befehl ein, mit dem bei systemd das Standard-Target dauerhaft auf `graphical.target` gesetzt wird.",
"answers": ["systemctl set-default graphical.target", "systemctl set-default graphical"],
"explanation": "`systemctl set-default` setzt den Symlink `default.target`; wirksam beim nächsten Start. `systemctl get-default` zeigt das aktuelle Standard-Target.",
"references": ["man 1 systemctl"]
},
{
"id": "101.3-003",
"objective": "101.3",
"type": "single",
"difficulty": 1,
"question": "Das System soll in 10 Minuten heruntergefahren werden; angemeldete Benutzer sollen die Nachricht „Wartung“ erhalten. Welcher Befehl leistet das?",
"options": [
{ "id": "a", "text": "`shutdown -h +10 \"Wartung\"`", "correct": true, "explanation": "`-h` hält/schaltet aus, `+10` bedeutet in 10 Minuten, der Text geht per wall an alle Terminals." },
{ "id": "b", "text": "`shutdown -c +10 \"Wartung\"`", "correct": false, "explanation": "`-c` bricht einen geplanten Shutdown ab." },
{ "id": "c", "text": "`shutdown -r now +10 \"Wartung\"`", "correct": false, "explanation": "`now` und `+10` widersprechen sich; `-r` würde zudem neu starten." },
{ "id": "d", "text": "`halt -t 10 \"Wartung\"`", "correct": false, "explanation": "`halt` kennt keine Zeitplanung mit Nachricht; es hält das System sofort an." },
{ "id": "e", "text": "`wall -h +10 \"Wartung\"`", "correct": false, "explanation": "`wall` sendet nur eine Nachricht, fährt aber nichts herunter." }
],
"explanation": "Zeitangabe bei `shutdown`: `now`, `+m` (Minuten) oder `hh:mm`. `-h`/`-P` ausschalten, `-r` Neustart, `-c` abbrechen.",
"references": ["man 8 shutdown"]
},
{
"id": "101.3-004",
"objective": "101.3",
"type": "multi",
"difficulty": 2,
"question": "Mit welchen Befehlen wechselt ein laufendes System **sofort** in den Einzelbenutzer-/Rettungsmodus?",
"options": [
{ "id": "a", "text": "`systemctl isolate rescue.target`", "correct": true, "explanation": "`isolate` startet das Target und beendet alle Units, die nicht dazugehören." },
{ "id": "b", "text": "`telinit 1`", "correct": true, "explanation": "`telinit 1` (bzw. `init 1`) wechselt in Runlevel 1; unter systemd wird das auf `rescue.target` abgebildet." },
{ "id": "c", "text": "`systemctl set-default rescue.target`", "correct": false, "explanation": "Ändert nur das Standard-Target für den nächsten Start." },
{ "id": "d", "text": "`runlevel 1`", "correct": false, "explanation": "`runlevel` zeigt nur den vorherigen und aktuellen Runlevel an; es nimmt keinen Wechsel vor." },
{ "id": "e", "text": "`systemctl reload rescue.target`", "correct": false, "explanation": "`reload` lässt laufende Dienste ihre Konfiguration neu lesen; ein Targetwechsel ist das nicht." }
],
"explanation": "Sofortiger Wechsel: `systemctl isolate <target>` bzw. klassisch `telinit <n>`/`init <n>`. Dauerhaft für den Start: `systemctl set-default`.",
"references": ["man 1 systemctl", "man 8 telinit"]
}
]
}
simulator/data/lpic1_101/questions_102.json
+317
View File
@@ -0,0 +1,317 @@
{
"$schema": "../schema/questions.schema.json",
"format": "lpic-sim-questions",
"meta": {
"file": "questions_102.json",
"brief": "Fragen zu Topic 102 Linux-Installation und Paketverwaltung (LPIC-1 101-500, Objectives 5.0)",
"author": "Björn Runden <br@runden.de>",
"owner": "Björn Runden <br@runden.de>",
"assist": "KI-unterstützt (Claude Opus 5.5), geprüft von Björn Runden <br@runden.de>",
"version": "0.1.0 (29.10.2026)"
},
"exam": "lpic1-101",
"questions": [
{
"id": "102.1-001",
"objective": "102.1",
"type": "single",
"difficulty": 1,
"question": "Welches Verzeichnis legt man typischerweise auf eine eigene Partition, damit wachsende Protokoll- und Spool-Dateien das Root-Dateisystem nicht füllen?",
"options": [
{ "id": "a", "text": "`/var`", "correct": true, "explanation": "`/var` enthält variable Daten wie Logs, Spool und Caches, die unkontrolliert wachsen können." },
{ "id": "b", "text": "`/etc`", "correct": false, "explanation": "`/etc` wird schon früh beim Start gebraucht und muss auf dem Root-Dateisystem liegen; es wächst kaum." },
{ "id": "c", "text": "`/bin`", "correct": false, "explanation": "`/bin` enthält grundlegende Programme, die beim Start verfügbar sein müssen." },
{ "id": "d", "text": "`/sbin`", "correct": false, "explanation": "`/sbin` enthält Systemprogramme für Start und Reparatur und gehört auf das Root-Dateisystem." },
{ "id": "e", "text": "`/lib`", "correct": false, "explanation": "`/lib` enthält Bibliotheken und Module, die für den Start nötig sind." }
],
"explanation": "Kandidaten für eigene Partitionen: `/var`, `/home`, `/tmp`, ggf. `/boot` und `/opt`. Was zum Start nötig ist (`/etc`, `/bin`, `/sbin`, `/lib`, `/dev`), bleibt auf dem Root-Dateisystem.",
"references": ["man 7 hier"]
},
{
"id": "102.1-002",
"objective": "102.1",
"type": "multi",
"difficulty": 2,
"question": "Welche Aussagen zum Logical Volume Manager (LVM) treffen zu?",
"options": [
{ "id": "a", "text": "Logical Volumes werden aus dem Speicher einer Volume Group zugeteilt.", "correct": true, "explanation": "Hierarchie: Physical Volume → Volume Group → Logical Volume." },
{ "id": "b", "text": "Eine Volume Group kann mehrere Physical Volumes umfassen.", "correct": true, "explanation": "Mehrere Platten/Partitionen lassen sich zu einer Volume Group zusammenfassen und mit `vgextend` erweitern." },
{ "id": "c", "text": "Ein Physical Volume kann immer nur genau ein Logical Volume aufnehmen.", "correct": false, "explanation": "Die Extents eines Physical Volumes können auf beliebig viele Logical Volumes verteilt sein." },
{ "id": "d", "text": "LVM setzt zwingend eine GPT-Partitionstabelle voraus.", "correct": false, "explanation": "LVM funktioniert mit MBR, GPT oder auch ganzen Platten ohne Partitionstabelle." },
{ "id": "e", "text": "Logical Volumes können nur vergrößert werden, wenn das System neu gestartet wird.", "correct": false, "explanation": "`lvextend` vergrößert im laufenden Betrieb; viele Dateisysteme lassen sich anschließend online wachsen." }
],
"explanation": "LVM entkoppelt Dateisysteme von physischen Partitionen: `pvcreate` → `vgcreate` → `lvcreate`. Vorteil: flexible Größenänderung und Snapshots.",
"references": ["man 8 lvm"]
},
{
"id": "102.1-003",
"objective": "102.1",
"type": "single",
"difficulty": 1,
"question": "Mit welchem Dateisystem muss die EFI-Systempartition (ESP) eines UEFI-Systems formatiert sein?",
"options": [
{ "id": "a", "text": "FAT (üblich FAT32)", "correct": true, "explanation": "Die UEFI-Spezifikation verlangt ein FAT-Dateisystem, damit die Firmware die Bootloader-Dateien lesen kann." },
{ "id": "b", "text": "ext4", "correct": false, "explanation": "ext4 kann die Firmware in der Regel nicht lesen; es eignet sich für `/` oder `/boot`." },
{ "id": "c", "text": "XFS", "correct": false, "explanation": "XFS wird von UEFI-Firmware nicht unterstützt." },
{ "id": "d", "text": "swap", "correct": false, "explanation": "swap ist Auslagerungsspeicher, kein Dateisystem für Dateien." },
{ "id": "e", "text": "Btrfs", "correct": false, "explanation": "Btrfs kann die Firmware nicht lesen." }
],
"explanation": "Die ESP (meist eingehängt unter `/boot/efi`) enthält die `.efi`-Bootloader und ist FAT-formatiert.",
"references": ["UEFI-Spezifikation, Abschnitt EFI System Partition"]
},
{
"id": "102.2-001",
"objective": "102.2",
"type": "single",
"difficulty": 1,
"question": "Auf einem Debian-System wurde `/etc/default/grub` geändert (z. B. `GRUB_TIMEOUT`). Welcher Befehl übernimmt die Änderung in die GRUB-2-Konfiguration?",
"options": [
{ "id": "a", "text": "`update-grub`", "correct": true, "explanation": "`update-grub` ist unter Debian ein Wrapper für `grub-mkconfig -o /boot/grub/grub.cfg`." },
{ "id": "b", "text": "`grub-mkconfig`", "correct": false, "explanation": "Ohne `-o <datei>` gibt `grub-mkconfig` die Konfiguration nur auf stdout aus und schreibt nichts." },
{ "id": "c", "text": "`grub-install /etc/default/grub`", "correct": false, "explanation": "`grub-install` installiert den Bootloader auf ein Gerät; es erwartet ein Gerät, keine Konfigurationsdatei." },
{ "id": "d", "text": "`systemctl restart grub`", "correct": false, "explanation": "GRUB ist kein Dienst; es läuft nur beim Start, vor dem Kernel." },
{ "id": "e", "text": "`lilo`", "correct": false, "explanation": "`lilo` gehört zum veralteten Bootloader LILO und wertet `/etc/lilo.conf` aus." }
],
"explanation": "GRUB 2: Einstellungen in `/etc/default/grub` und `/etc/grub.d/`, daraus erzeugt `grub-mkconfig` die Datei `grub.cfg`, die man nicht von Hand bearbeitet.",
"references": ["man 8 grub-mkconfig", "info grub"]
},
{
"id": "102.2-002",
"objective": "102.2",
"type": "fill",
"difficulty": 2,
"question": "Geben Sie den vollständigen Befehl ein, der die GRUB-2-Konfiguration neu erzeugt und direkt nach `/boot/grub/grub.cfg` schreibt (ohne den Debian-Wrapper `update-grub`).",
"answers": ["grub-mkconfig -o /boot/grub/grub.cfg", "grub-mkconfig --output=/boot/grub/grub.cfg", "grub2-mkconfig -o /boot/grub2/grub.cfg"],
"explanation": "`grub-mkconfig -o` schreibt die erzeugte Konfiguration in die Datei. Distributionen der Red-Hat-Familie heißen das Werkzeug `grub2-mkconfig` und nutzen `/boot/grub2/grub.cfg`.",
"references": ["man 8 grub-mkconfig"]
},
{
"id": "102.2-003",
"objective": "102.2",
"type": "single",
"difficulty": 2,
"question": "Wie heißt die Menü-Konfigurationsdatei von GRUB Legacy (Version 0.9x) üblicherweise?",
"options": [
{ "id": "a", "text": "`/boot/grub/menu.lst`", "correct": true, "explanation": "GRUB Legacy liest `menu.lst` (bei Red Hat auch `grub.conf`) direkt beim Start." },
{ "id": "b", "text": "`/boot/grub/grub.cfg`", "correct": false, "explanation": "`grub.cfg` ist die generierte Konfiguration von GRUB 2." },
{ "id": "c", "text": "`/etc/default/grub`", "correct": false, "explanation": "`/etc/default/grub` enthält die Einstellungen, aus denen GRUB 2 seine `grub.cfg` erzeugt." },
{ "id": "d", "text": "`/etc/lilo.conf`", "correct": false, "explanation": "Das ist die Konfiguration des Bootloaders LILO." },
{ "id": "e", "text": "`/boot/efi/grub.ini`", "correct": false, "explanation": "Eine solche Datei gibt es bei GRUB nicht." }
],
"explanation": "Unterschied: GRUB Legacy wird direkt über `menu.lst` konfiguriert (Partitionen ab `(hd0,0)` gezählt), GRUB 2 über generierte `grub.cfg` (Partitionen ab 1, z. B. `(hd0,1)`).",
"references": ["info grub"]
},
{
"id": "102.3-001",
"objective": "102.3",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl zeigt an, welche Shared Libraries ein Programm wie `/usr/bin/ssh` benötigt?",
"options": [
{ "id": "a", "text": "`ldd /usr/bin/ssh`", "correct": true, "explanation": "`ldd` listet die benötigten Bibliotheken und den Pfad, über den sie aufgelöst werden." },
{ "id": "b", "text": "`ldconfig /usr/bin/ssh`", "correct": false, "explanation": "`ldconfig` aktualisiert Links und den Cache `/etc/ld.so.cache`; es analysiert keine Programme." },
{ "id": "c", "text": "`ldconfig -p`", "correct": false, "explanation": "`ldconfig -p` zeigt alle Bibliotheken im Cache, nicht die eines bestimmten Programms." },
{ "id": "d", "text": "`ld /usr/bin/ssh`", "correct": false, "explanation": "`ld` ist der Linker zum Bauen von Programmen." },
{ "id": "e", "text": "`lsmod /usr/bin/ssh`", "correct": false, "explanation": "`lsmod` listet Kernelmodule, keine Bibliotheken." }
],
"explanation": "Der dynamische Linker (`ld-linux.so`) lädt beim Start die Bibliotheken. Er sucht über `LD_LIBRARY_PATH`, den Cache `/etc/ld.so.cache` und die Standardpfade.",
"references": ["man 1 ldd", "man 8 ld.so"]
},
{
"id": "102.3-002",
"objective": "102.3",
"type": "multi",
"difficulty": 2,
"question": "Eine Bibliothek wurde nach `/opt/app/lib` installiert und soll **dauerhaft für alle Programme** gefunden werden. Welche Schritte sind nötig?",
"options": [
{ "id": "a", "text": "Den Pfad in eine Datei unter `/etc/ld.so.conf.d/` eintragen", "correct": true, "explanation": "`/etc/ld.so.conf` bindet die Dateien aus `ld.so.conf.d/` ein; dort stehen zusätzliche Suchpfade." },
{ "id": "b", "text": "`ldconfig` ausführen", "correct": true, "explanation": "`ldconfig` liest die Pfade ein und erzeugt den Cache `/etc/ld.so.cache` neu." },
{ "id": "c", "text": "`ldd /opt/app/lib` ausführen", "correct": false, "explanation": "`ldd` zeigt nur Abhängigkeiten eines Programms an und ändert nichts." },
{ "id": "d", "text": "`LD_LIBRARY_PATH` in `/etc/ld.so.conf` setzen", "correct": false, "explanation": "In `ld.so.conf` stehen Pfade, keine Variablenzuweisungen. `LD_LIBRARY_PATH` ist eine Umgebungsvariable der Shell." },
{ "id": "e", "text": "Die Bibliothek nach `/proc/lib` kopieren", "correct": false, "explanation": "`/proc` ist ein virtuelles Dateisystem; dorthin kann man nichts dauerhaft kopieren." }
],
"explanation": "Dauerhaft: Pfad in `/etc/ld.so.conf(.d)` und `ldconfig`. Nur vorübergehend, für eine Sitzung oder einen Aufruf: `export LD_LIBRARY_PATH=/opt/app/lib`.",
"references": ["man 8 ldconfig"]
},
{
"id": "102.4-001",
"objective": "102.4",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl listet alle Dateien auf, die das **installierte** Debian-Paket `openssh-server` auf dem System abgelegt hat?",
"options": [
{ "id": "a", "text": "`dpkg -L openssh-server`", "correct": true, "explanation": "`-L` (`--listfiles`) listet die Dateien eines installierten Pakets." },
{ "id": "b", "text": "`dpkg -l openssh-server`", "correct": false, "explanation": "`-l` zeigt nur Status, Version und Beschreibung in Kurzform." },
{ "id": "c", "text": "`dpkg -S openssh-server`", "correct": false, "explanation": "`-S` sucht, zu welchem Paket ein Dateiname gehört." },
{ "id": "d", "text": "`dpkg -c openssh-server`", "correct": false, "explanation": "`-c` listet den Inhalt einer `.deb`-Datei, nicht eines installierten Pakets." },
{ "id": "e", "text": "`dpkg -s openssh-server`", "correct": false, "explanation": "`-s` zeigt Status und Metadaten, aber keine Dateiliste." }
],
"explanation": "Merkhilfe: `-L` Liste der Dateien, `-l` Liste der Pakete, `-S` Suche nach Datei, `-s` Status, `-c` Inhalt einer .deb, `-I` Info zu einer .deb.",
"references": ["man 1 dpkg"]
},
{
"id": "102.4-002",
"objective": "102.4",
"type": "fill",
"difficulty": 2,
"question": "Mit welchem dpkg-Aufruf (Befehl und Option, **ohne** Dateinamen) findet man heraus, zu welchem installierten Paket die Datei `/usr/bin/ls` gehört?",
"answers": ["dpkg -S", "dpkg --search"],
"explanation": "`dpkg -S /usr/bin/ls` liefert z. B. `coreutils: /usr/bin/ls`. Für nicht installierte Pakete hilft `apt-file search`.",
"references": ["man 1 dpkg"]
},
{
"id": "102.4-003",
"objective": "102.4",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl lädt nur die aktuellen Paketlisten aus den konfigurierten Quellen, ohne Pakete zu installieren oder zu aktualisieren?",
"options": [
{ "id": "a", "text": "`apt-get update`", "correct": true, "explanation": "`update` aktualisiert den Paketindex aus `/etc/apt/sources.list(.d)`." },
{ "id": "b", "text": "`apt-get upgrade`", "correct": false, "explanation": "`upgrade` installiert neuere Versionen bereits installierter Pakete." },
{ "id": "c", "text": "`apt-get dist-upgrade`", "correct": false, "explanation": "`dist-upgrade` aktualisiert Pakete und darf dabei auch Pakete hinzufügen oder entfernen." },
{ "id": "d", "text": "`apt-cache update`", "correct": false, "explanation": "`apt-cache` fragt nur den Cache ab; einen Unterbefehl `update` gibt es nicht." },
{ "id": "e", "text": "`apt-get check`", "correct": false, "explanation": "`check` prüft auf defekte Abhängigkeiten und lädt nichts herunter." }
],
"explanation": "Typische Reihenfolge: `apt-get update` (Listen), dann `apt-get upgrade` (Pakete). Paketquellen stehen in `/etc/apt/sources.list` und `/etc/apt/sources.list.d/`.",
"references": ["man 8 apt-get"]
},
{
"id": "102.4-004",
"objective": "102.4",
"type": "multi",
"difficulty": 2,
"question": "Mit welchen Befehlen wird ein Paket **einschließlich seiner Konfigurationsdateien** entfernt?",
"options": [
{ "id": "a", "text": "`apt-get purge paket`", "correct": true, "explanation": "`purge` entfernt das Paket und seine Konfigurationsdateien." },
{ "id": "b", "text": "`dpkg -P paket`", "correct": true, "explanation": "`-P` (`--purge`) entfernt alles einschließlich Konfiguration." },
{ "id": "c", "text": "`dpkg -r paket`", "correct": false, "explanation": "`-r` (`--remove`) lässt die Konfigurationsdateien stehen (Status `rc`)." },
{ "id": "d", "text": "`apt-get remove paket`", "correct": false, "explanation": "`remove` entspricht `dpkg -r`: Konfigurationsdateien bleiben erhalten." },
{ "id": "e", "text": "`apt-get autoremove paket`", "correct": false, "explanation": "`autoremove` entfernt automatisch installierte, nicht mehr benötigte Abhängigkeiten; Konfigurationen bleiben." }
],
"explanation": "Pakete im Zustand `rc` (removed, config-files) zeigt `dpkg -l`. Sie lassen sich nachträglich mit `dpkg -P` vollständig entfernen.",
"references": ["man 1 dpkg", "man 8 apt-get"]
},
{
"id": "102.4-005",
"objective": "102.4",
"type": "single",
"difficulty": 2,
"question": "Bei der Installation eines Pakets wurden debconf-Fragen beantwortet. Wie lassen sich diese Fragen **erneut** stellen und die Konfiguration neu erzeugen?",
"options": [
{ "id": "a", "text": "`dpkg-reconfigure paket`", "correct": true, "explanation": "`dpkg-reconfigure` stellt die debconf-Fragen erneut und konfiguriert das Paket neu." },
{ "id": "b", "text": "`dpkg --configure paket`", "correct": false, "explanation": "`--configure` schließt die Konfiguration entpackter Pakete ab; bereits beantwortete Fragen werden nicht erneut gestellt." },
{ "id": "c", "text": "`apt-get install --reinstall paket`", "correct": false, "explanation": "Die Antworten liegen in der debconf-Datenbank und werden bei der Neuinstallation wiederverwendet." },
{ "id": "d", "text": "`apt-cache policy paket`", "correct": false, "explanation": "`policy` zeigt installierte und verfügbare Versionen sowie die Prioritäten der Quellen." },
{ "id": "e", "text": "`debconf-show paket`", "correct": false, "explanation": "`debconf-show` zeigt die gespeicherten Antworten nur an." }
],
"explanation": "debconf speichert Antworten dauerhaft. Typisches Beispiel: `dpkg-reconfigure tzdata` oder `dpkg-reconfigure locales`.",
"references": ["man 8 dpkg-reconfigure"]
},
{
"id": "102.5-001",
"objective": "102.5",
"type": "single",
"difficulty": 1,
"question": "Welcher rpm-Befehl ermittelt, zu welchem installierten Paket die Datei `/etc/ssh/sshd_config` gehört?",
"options": [
{ "id": "a", "text": "`rpm -qf /etc/ssh/sshd_config`", "correct": true, "explanation": "`-q` Abfrage, `-f` (file): Paket, dem die Datei gehört." },
{ "id": "b", "text": "`rpm -ql /etc/ssh/sshd_config`", "correct": false, "explanation": "`-ql` listet die Dateien eines Pakets; es erwartet einen Paketnamen." },
{ "id": "c", "text": "`rpm -qi /etc/ssh/sshd_config`", "correct": false, "explanation": "`-qi` zeigt Informationen zu einem Paket; es erwartet einen Paketnamen." },
{ "id": "d", "text": "`rpm -V /etc/ssh/sshd_config`", "correct": false, "explanation": "`-V` prüft installierte Pakete auf Änderungen gegenüber der RPM-Datenbank." },
{ "id": "e", "text": "`rpm -qa /etc/ssh/sshd_config`", "correct": false, "explanation": "`-qa` listet alle installierten Pakete (das Argument wird als Muster gelesen, nicht als Datei)." }
],
"explanation": "Abfragen beginnen mit `-q`: `-qa` alle, `-qi` Info, `-ql` Dateien, `-qf` Besitzer einer Datei, `-qc` Konfigurationsdateien, `-qR` Abhängigkeiten, `-qp` für eine .rpm-Datei.",
"references": ["man 8 rpm"]
},
{
"id": "102.5-002",
"objective": "102.5",
"type": "fill",
"difficulty": 1,
"question": "Geben Sie den rpm-Befehl ein, der alle Dateien des installierten Pakets `bash` auflistet.",
"answers": ["rpm -ql bash", "rpm -q -l bash", "rpm -q --list bash", "rpm --query --list bash"],
"explanation": "`-q` (query) mit `-l` (list). Für eine noch nicht installierte Datei: `rpm -qlp paket.rpm`.",
"references": ["man 8 rpm"]
},
{
"id": "102.5-003",
"objective": "102.5",
"type": "single",
"difficulty": 2,
"question": "Welcher rpm-Aufruf aktualisiert ein Paket aus einer .rpm-Datei – und installiert es, falls es noch nicht vorhanden ist?",
"options": [
{ "id": "a", "text": "`rpm -Uvh paket.rpm`", "correct": true, "explanation": "`-U` (upgrade) aktualisiert oder installiert; `-v` ausführlich, `-h` Fortschrittsbalken." },
{ "id": "b", "text": "`rpm -Fvh paket.rpm`", "correct": false, "explanation": "`-F` (freshen) aktualisiert nur, wenn das Paket bereits installiert ist." },
{ "id": "c", "text": "`rpm -ivh paket.rpm`", "correct": false, "explanation": "`-i` installiert neu; bei installierter älterer Version entsteht ein Konflikt (Ausnahme: z. B. Kernel parallel)." },
{ "id": "d", "text": "`rpm -e paket.rpm`", "correct": false, "explanation": "`-e` (erase) entfernt ein Paket." },
{ "id": "e", "text": "`rpm -Vp paket.rpm`", "correct": false, "explanation": "`-V` prüft, es installiert nichts." }
],
"explanation": "rpm löst keine Abhängigkeiten aus Repositories auf – dafür gibt es `dnf`/`yum` bzw. `zypper`.",
"references": ["man 8 rpm"]
},
{
"id": "102.5-004",
"objective": "102.5",
"type": "multi",
"difficulty": 1,
"question": "Welche Werkzeuge installieren RPM-Pakete aus Repositories und lösen dabei Abhängigkeiten automatisch auf?",
"options": [
{ "id": "a", "text": "`dnf`", "correct": true, "explanation": "Nachfolger von yum, Standard bei Fedora und RHEL ab Version 8." },
{ "id": "b", "text": "`yum`", "correct": true, "explanation": "Klassisches Frontend der Red-Hat-Familie; Repos in `/etc/yum.repos.d/`." },
{ "id": "c", "text": "`zypper`", "correct": true, "explanation": "Paketverwaltung von openSUSE/SLES, ebenfalls auf RPM-Basis." },
{ "id": "d", "text": "`rpm2cpio`", "correct": false, "explanation": "`rpm2cpio` wandelt ein RPM in ein cpio-Archiv um, installiert aber nichts." },
{ "id": "e", "text": "`dpkg`", "correct": false, "explanation": "`dpkg` verwaltet Debian-Pakete und löst keine Abhängigkeiten aus Repositories auf." }
],
"explanation": "rpm ist die Basisschicht, `dnf`/`yum`/`zypper` sind die Frontends mit Repository- und Abhängigkeitsverwaltung (vergleichbar mit dpkg und apt).",
"references": ["man 8 dnf", "man 8 zypper"]
},
{
"id": "102.5-005",
"objective": "102.5",
"type": "single",
"difficulty": 2,
"question": "Wie entpackt man die Dateien aus `paket.rpm` in das aktuelle Verzeichnis, **ohne** das Paket zu installieren?",
"options": [
{ "id": "a", "text": "`rpm2cpio paket.rpm | cpio -idmv`", "correct": true, "explanation": "`rpm2cpio` gibt den Inhalt als cpio-Strom aus, `cpio -i` entpackt (`-d` Verzeichnisse anlegen, `-m` Zeiten erhalten)." },
{ "id": "b", "text": "`rpm -x paket.rpm`", "correct": false, "explanation": "rpm hat keine Option `-x` zum Entpacken." },
{ "id": "c", "text": "`cpio -i < paket.rpm`", "correct": false, "explanation": "Eine RPM-Datei hat einen eigenen Header vor dem Archiv; cpio kann sie nicht direkt lesen." },
{ "id": "d", "text": "`tar xf paket.rpm`", "correct": false, "explanation": "RPM ist kein tar-Archiv." },
{ "id": "e", "text": "`rpm -qlp paket.rpm`", "correct": false, "explanation": "Das listet nur die enthaltenen Dateien auf, entpackt aber nichts." }
],
"explanation": "Nützlich, um einzelne Dateien (z. B. eine Original-Konfiguration) aus einem Paket zu holen.",
"references": ["man 8 rpm2cpio", "man 1 cpio"]
},
{
"id": "102.6-001",
"objective": "102.6",
"type": "multi",
"difficulty": 2,
"question": "Eine Linux-VM wird aus einer Vorlage geklont. Was sollte auf jedem Klon **neu erzeugt** werden, weil es eindeutig sein muss?",
"options": [
{ "id": "a", "text": "Die D-Bus-/systemd-Maschinen-ID in `/etc/machine-id`", "correct": true, "explanation": "Die Machine-ID identifiziert das System (u. a. Journal, DHCP-Client-ID) und darf nicht doppelt vorkommen." },
{ "id": "b", "text": "Die SSH-Host-Schlüssel unter `/etc/ssh/ssh_host_*`", "correct": true, "explanation": "Gleiche Host-Schlüssel auf mehreren Systemen untergraben die Server-Authentifizierung." },
{ "id": "c", "text": "Den Kernel unter `/boot`", "correct": false, "explanation": "Der Kernel ist nicht systemspezifisch und kann identisch bleiben." },
{ "id": "d", "text": "Die Datei `/etc/services`", "correct": false, "explanation": "`/etc/services` ordnet Portnummern Dienstnamen zu und ist überall gleich." },
{ "id": "e", "text": "Die Shared Libraries unter `/usr/lib`", "correct": false, "explanation": "Bibliotheken sind Programmdateien und nicht systemspezifisch." }
],
"explanation": "Vorlagen werden vorher \"generalisiert\": Machine-ID leeren, SSH-Host-Schlüssel löschen, ggf. Hostname und MAC-gebundene Netzkonfiguration zurücksetzen. cloud-init oder ein Erststart-Skript erzeugt sie neu.",
"references": ["man 5 machine-id", "man 8 ssh-keygen"]
},
{
"id": "102.6-002",
"objective": "102.6",
"type": "single",
"difficulty": 1,
"question": "Welches Werkzeug richtet Cloud-Instanzen beim ersten Start anhand von Metadaten des Anbieters ein (Hostname, Benutzer, SSH-Schlüssel, Pakete)?",
"options": [
{ "id": "a", "text": "cloud-init", "correct": true, "explanation": "cloud-init liest Meta- und User-Data (z. B. `#cloud-config` in YAML) und konfiguriert das System beim ersten Start." },
{ "id": "b", "text": "Kickstart", "correct": false, "explanation": "Kickstart ist eine Antwortdatei für die automatisierte Installation mit Anaconda, nicht für den Start einer fertigen Instanz." },
{ "id": "c", "text": "`virt-install`", "correct": false, "explanation": "`virt-install` legt auf dem Host neue libvirt-VMs an; im Gast konfiguriert es nichts." },
{ "id": "d", "text": "`dmidecode`", "correct": false, "explanation": "`dmidecode` liest Hardware-Informationen (DMI/SMBIOS) aus." },
{ "id": "e", "text": "`qemu-img`", "correct": false, "explanation": "`qemu-img` erstellt und konvertiert Abbilder virtueller Festplatten." }
],
"explanation": "Begriffe aus 102.6: Virtuelle Maschine, Linux-Container, Anwendungs-Container, Gasttreiber, SSH-Host-Schlüssel, D-Bus-Machine-ID, cloud-init.",
"references": ["https://cloudinit.readthedocs.io/"]
}
]
}
simulator/data/lpic1_101/questions_103.json
+582
View File
@@ -0,0 +1,582 @@
{
"$schema": "../schema/questions.schema.json",
"format": "lpic-sim-questions",
"meta": {
"file": "questions_103.json",
"brief": "Fragen zu Topic 103 GNU- und Unix-Befehle (LPIC-1 101-500, Objectives 5.0)",
"author": "Björn Runden <br@runden.de>",
"owner": "Björn Runden <br@runden.de>",
"assist": "KI-unterstützt (Claude Opus 5.5), geprüft von Björn Runden <br@runden.de>",
"version": "0.1.0 (29.10.2026)"
},
"exam": "lpic1-101",
"questions": [
{
"id": "103.1-001",
"objective": "103.1",
"type": "single",
"difficulty": 1,
"question": "Eine Shell-Variable `PROJEKT` soll auch in Programmen sichtbar sein, die aus der aktuellen Shell gestartet werden. Welcher Befehl leistet das?",
"options": [
{ "id": "a", "text": "`export PROJEKT`", "correct": true, "explanation": "`export` übernimmt die Variable in die Umgebung, die an Kindprozesse vererbt wird." },
{ "id": "b", "text": "`set PROJEKT`", "correct": false, "explanation": "`set` setzt Shell-Optionen bzw. Positionsparameter; es exportiert keine Variable." },
{ "id": "c", "text": "`env PROJEKT`", "correct": false, "explanation": "`env` würde versuchen, ein Programm namens `PROJEKT` mit der aktuellen Umgebung zu starten." },
{ "id": "d", "text": "`local PROJEKT`", "correct": false, "explanation": "`local` erzeugt eine lokale Variable innerhalb einer Shell-Funktion." },
{ "id": "e", "text": "`declare -r PROJEKT`", "correct": false, "explanation": "`declare -r` macht die Variable schreibgeschützt, exportiert sie aber nicht (das wäre `declare -x`)." }
],
"explanation": "Shell-Variablen gelten nur in der aktuellen Shell, Umgebungsvariablen werden vererbt. Anzeige: `set` (alle Shell-Variablen und Funktionen), `env`/`printenv` (nur Umgebung).",
"references": ["man 1 bash (Abschnitt ENVIRONMENT)"]
},
{
"id": "103.1-002",
"objective": "103.1",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl gibt den Text `$HOME` **wörtlich** aus, also ohne ihn durch den Pfad des Home-Verzeichnisses zu ersetzen?",
"options": [
{ "id": "a", "text": "`echo '$HOME'`", "correct": true, "explanation": "In einfachen Anführungszeichen findet keinerlei Ersetzung statt." },
{ "id": "b", "text": "`echo \"$HOME\"`", "correct": false, "explanation": "In doppelten Anführungszeichen werden Variablen ersetzt; nur die Worttrennung unterbleibt." },
{ "id": "c", "text": "`echo $HOME`", "correct": false, "explanation": "Ohne Quoting wird die Variable ersetzt." },
{ "id": "d", "text": "`echo ${HOME}`", "correct": false, "explanation": "`${…}` ist die ausführliche Schreibweise der Variablenersetzung." },
{ "id": "e", "text": "`echo $(HOME)`", "correct": false, "explanation": "`$(…)` ist Befehlsersetzung: Die Shell versucht, einen Befehl `HOME` auszuführen." }
],
"explanation": "Quoting: `'…'` alles wörtlich, `\"…\"` Variablen und Befehlsersetzung aktiv, `\\` maskiert ein einzelnes Zeichen (z. B. `echo \\$HOME`).",
"references": ["man 1 bash (Abschnitt QUOTING)"]
},
{
"id": "103.1-003",
"objective": "103.1",
"type": "fill",
"difficulty": 2,
"question": "Welches Shell-Builtin zeigt an, ob `ls` ein Alias, eine Funktion, ein Builtin oder ein Programm im `PATH` ist? (nur der Befehlsname)",
"answers": ["type"],
"explanation": "`type ls` liefert z. B. `ls is aliased to 'ls --color=auto'`. `which` sucht dagegen nur Programme im `PATH` und kennt keine Aliase oder Builtins.",
"references": ["help type"]
},
{
"id": "103.1-004",
"objective": "103.1",
"type": "multi",
"difficulty": 2,
"question": "Welche Aussagen zur Bash-History treffen zu?",
"options": [
{ "id": "a", "text": "`!!` führt den zuletzt eingegebenen Befehl erneut aus.", "correct": true, "explanation": "History-Expansion: `!!` steht für den vorherigen Befehl, z. B. `sudo !!`." },
{ "id": "b", "text": "Die History wird standardmäßig in `~/.bash_history` gespeichert.", "correct": true, "explanation": "Die Datei legt `HISTFILE` fest; Standard ist `~/.bash_history`." },
{ "id": "c", "text": "`history -c` löscht die Datei `~/.bash_history` sofort.", "correct": false, "explanation": "`history -c` leert nur die History im Speicher der laufenden Shell." },
{ "id": "d", "text": "`HISTSIZE` legt die maximale Zeilenzahl der History-Datei fest.", "correct": false, "explanation": "`HISTSIZE` gilt für die History im Speicher, `HISTFILESIZE` für die Datei." },
{ "id": "e", "text": "`!42` zeigt Befehl Nummer 42 an, ohne ihn auszuführen.", "correct": false, "explanation": "`!42` führt den Befehl aus. Nur anzeigen: `!42:p`." }
],
"explanation": "Weitere Expansionen: `!$` letztes Argument, `!str` letzter Befehl, der mit `str` beginnt. Strg+R sucht rückwärts in der History.",
"references": ["man 1 bash (Abschnitt HISTORY EXPANSION)"]
},
{
"id": "103.1-005",
"objective": "103.1",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl gibt **nur** die Release-Version des laufenden Kernels aus (z. B. `6.1.0-18-amd64`)?",
"options": [
{ "id": "a", "text": "`uname -r`", "correct": true, "explanation": "`-r` (kernel release) gibt genau die Release-Bezeichnung aus." },
{ "id": "b", "text": "`uname -a`", "correct": false, "explanation": "`-a` gibt alle Informationen aus: Name, Host, Release, Version, Architektur …" },
{ "id": "c", "text": "`uname -m`", "correct": false, "explanation": "`-m` zeigt die Hardware-Architektur, z. B. `x86_64`." },
{ "id": "d", "text": "`uname -n`", "correct": false, "explanation": "`-n` zeigt den Hostnamen (nodename)." },
{ "id": "e", "text": "`uname -s`", "correct": false, "explanation": "`-s` zeigt den Kernelnamen, also `Linux`." }
],
"explanation": "`uname -r` wird oft in Pfaden genutzt, z. B. `/lib/modules/$(uname -r)/`.",
"references": ["man 1 uname"]
},
{
"id": "103.1-006",
"objective": "103.1",
"type": "single",
"difficulty": 2,
"question": "Wie entfernt man die Variable `TMPDIR` **vollständig** aus der aktuellen Shell?",
"options": [
{ "id": "a", "text": "`unset TMPDIR`", "correct": true, "explanation": "`unset` löscht die Variable; danach ist sie weder gesetzt noch exportiert." },
{ "id": "b", "text": "`TMPDIR=\"\"`", "correct": false, "explanation": "Die Variable bleibt gesetzt, nur ihr Wert ist leer." },
{ "id": "c", "text": "`export -n TMPDIR`", "correct": false, "explanation": "`export -n` nimmt nur das Export-Attribut weg; die Shell-Variable bleibt bestehen." },
{ "id": "d", "text": "`env -u TMPDIR`", "correct": false, "explanation": "`env -u` entfernt die Variable nur aus der Umgebung des damit gestarteten Befehls." },
{ "id": "e", "text": "`set -u TMPDIR`", "correct": false, "explanation": "`set -u` lässt die Shell bei Zugriff auf ungesetzte Variablen einen Fehler melden; `TMPDIR` wird dabei zum Positionsparameter." }
],
"explanation": "Unterschied gesetzt/leer: `${VAR-x}` liefert `x` nur, wenn `VAR` ungesetzt ist, `${VAR:-x}` auch bei leerem Wert.",
"references": ["help unset"]
},
{
"id": "103.2-001",
"objective": "103.2",
"type": "single",
"difficulty": 1,
"question": "Welche Befehlskette gibt genau die Zeilen 11 bis 20 einer Datei aus?",
"options": [
{ "id": "a", "text": "`head -n 20 datei | tail -n 10`", "correct": true, "explanation": "Erst die ersten 20 Zeilen, davon die letzten 10 – also 11 bis 20." },
{ "id": "b", "text": "`tail -n 20 datei | head -n 10`", "correct": false, "explanation": "Das liefert die ersten 10 der letzten 20 Zeilen der Datei." },
{ "id": "c", "text": "`sed -n '10,20p' datei`", "correct": false, "explanation": "Gibt Zeilen 10 bis 20 aus, also 11 Zeilen." },
{ "id": "d", "text": "`head -n 11-20 datei`", "correct": false, "explanation": "`head` kennt keine Bereichsangabe." },
{ "id": "e", "text": "`cut -c 11-20 datei`", "correct": false, "explanation": "`cut -c` wählt Zeichen 11 bis 20 jeder Zeile, keine Zeilen." }
],
"explanation": "Alternativ `sed -n '11,20p' datei`. `tail -n +11` gibt alles ab Zeile 11 aus.",
"references": ["man 1 head", "man 1 tail"]
},
{
"id": "103.2-002",
"objective": "103.2",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl gibt nur die Benutzernamen (das erste Feld) aus `/etc/passwd` aus?",
"options": [
{ "id": "a", "text": "`cut -d: -f1 /etc/passwd`", "correct": true, "explanation": "`-d:` setzt den Doppelpunkt als Trenner, `-f1` wählt das erste Feld." },
{ "id": "b", "text": "`cut -f1 /etc/passwd`", "correct": false, "explanation": "Ohne `-d` trennt `cut` an Tabulatoren; die Zeilen werden ganz ausgegeben." },
{ "id": "c", "text": "`sort -t: -k1 /etc/passwd`", "correct": false, "explanation": "Das sortiert nach dem ersten Feld, gibt aber vollständige Zeilen aus." },
{ "id": "d", "text": "`tr ':' ' ' < /etc/passwd`", "correct": false, "explanation": "`tr` ersetzt nur die Doppelpunkte durch Leerzeichen." },
{ "id": "e", "text": "`paste -d: /etc/passwd`", "correct": false, "explanation": "`paste` fügt Zeilen mehrerer Dateien nebeneinander; mit einer Datei gibt es sie unverändert aus." }
],
"explanation": "Gleichwertig: `awk -F: '{print $1}' /etc/passwd`.",
"references": ["man 1 cut"]
},
{
"id": "103.2-003",
"objective": "103.2",
"type": "single",
"difficulty": 2,
"question": "In einer unsortierten Datei sollen alle Zeilen mit der Anzahl ihres Vorkommens ausgegeben werden. Welche Befehlskette ist korrekt?",
"options": [
{ "id": "a", "text": "`sort datei | uniq -c`", "correct": true, "explanation": "`uniq` fasst nur benachbarte gleiche Zeilen zusammen; daher vorher sortieren." },
{ "id": "b", "text": "`uniq -c datei`", "correct": false, "explanation": "Ohne Sortierung werden gleiche, aber nicht benachbarte Zeilen getrennt gezählt." },
{ "id": "c", "text": "`sort -u datei | wc -l`", "correct": false, "explanation": "Das zählt nur die Anzahl verschiedener Zeilen." },
{ "id": "d", "text": "`uniq -d datei | sort`", "correct": false, "explanation": "`uniq -d` zeigt nur benachbarte doppelte Zeilen, ohne Zählung." },
{ "id": "e", "text": "`cat -n datei | uniq`", "correct": false, "explanation": "Durch die Zeilennummern sind alle Zeilen verschieden; nichts wird zusammengefasst." }
],
"explanation": "Häufigste Zeilen zuerst: `sort datei | uniq -c | sort -nr`.",
"references": ["man 1 uniq", "man 1 sort"]
},
{
"id": "103.3-001",
"objective": "103.3",
"type": "single",
"difficulty": 1,
"question": "Ein Verzeichnis soll rekursiv kopiert werden; Rechte, Eigentümer, Zeitstempel und symbolische Links sollen erhalten bleiben. Welcher Befehl ist geeignet?",
"options": [
{ "id": "a", "text": "`cp -a quelle ziel`", "correct": true, "explanation": "`-a` (archive) entspricht `-dR --preserve=all`: rekursiv, Links als Links, alle Attribute." },
{ "id": "b", "text": "`cp -r quelle ziel`", "correct": false, "explanation": "`-r` kopiert rekursiv, übernimmt aber Eigentümer und Zeitstempel nicht." },
{ "id": "c", "text": "`cp -p quelle ziel`", "correct": false, "explanation": "`-p` erhält Attribute, kopiert aber Verzeichnisse nicht rekursiv." },
{ "id": "d", "text": "`cp -l quelle ziel`", "correct": false, "explanation": "`-l` legt Hardlinks statt Kopien an." },
{ "id": "e", "text": "`mv -a quelle ziel`", "correct": false, "explanation": "`mv` verschiebt und kennt keine Option `-a`." }
],
"explanation": "Eigentümer kann nur root übernehmen; als normaler Benutzer gehören Kopien dem Kopierenden.",
"references": ["man 1 cp"]
},
{
"id": "103.3-002",
"objective": "103.3",
"type": "fill",
"difficulty": 2,
"question": "Geben Sie den `find`-Befehl ein, der unterhalb von `/var` alle Dateien findet, die **größer als 100 MiB** sind.",
"answers": ["find /var -size +100M", "find /var -type f -size +100M", "find /var -size +100M -type f"],
"explanation": "`-size +100M`: größer als 100 MiB (`k`, `M`, `G` als Einheiten). `-size -100M` wäre kleiner. `-type f` beschränkt auf reguläre Dateien.",
"references": ["man 1 find"]
},
{
"id": "103.3-003",
"objective": "103.3",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl erstellt ein gzip-komprimiertes tar-Archiv `backup.tar.gz` von `/etc`?",
"options": [
{ "id": "a", "text": "`tar -czf backup.tar.gz /etc`", "correct": true, "explanation": "`c` create, `z` gzip, `f` Archivdatei." },
{ "id": "b", "text": "`tar -xzf backup.tar.gz /etc`", "correct": false, "explanation": "`x` entpackt – hier würde nur `/etc` aus dem Archiv extrahiert." },
{ "id": "c", "text": "`tar -cjf backup.tar.gz /etc`", "correct": false, "explanation": "`j` komprimiert mit bzip2; der Name `.gz` wäre irreführend." },
{ "id": "d", "text": "`tar -tzf backup.tar.gz /etc`", "correct": false, "explanation": "`t` listet den Inhalt eines vorhandenen Archivs." },
{ "id": "e", "text": "`gzip -r /etc > backup.tar.gz`", "correct": false, "explanation": "`gzip -r` komprimiert jede Datei in `/etc` einzeln an Ort und Stelle; es entsteht kein Archiv." }
],
"explanation": "Kompression bei tar: `z` gzip, `j` bzip2, `J` xz. Modi: `c` erstellen, `x` entpacken, `t` auflisten.",
"references": ["man 1 tar"]
},
{
"id": "103.3-004",
"objective": "103.3",
"type": "multi",
"difficulty": 2,
"question": "Welche Dateinamen passen auf das Shell-Muster `d?t[0-9]*`?",
"options": [
{ "id": "a", "text": "`dat1`", "correct": true, "explanation": "`d`, beliebiges Zeichen `a`, `t`, Ziffer `1`, danach nichts (`*` darf leer sein)." },
{ "id": "b", "text": "`dot42.txt`", "correct": true, "explanation": "`d`, `o`, `t`, Ziffer `4`, Rest `2.txt` passt auf `*`." },
{ "id": "c", "text": "`dt1`", "correct": false, "explanation": "`?` verlangt genau ein Zeichen zwischen `d` und `t`." },
{ "id": "d", "text": "`data1`", "correct": false, "explanation": "Das vierte Zeichen `a` ist keine Ziffer." },
{ "id": "e", "text": "`Dat1`", "correct": false, "explanation": "Globbing unterscheidet Groß- und Kleinschreibung; `D` ist nicht `d`." }
],
"explanation": "Globbing: `*` beliebig viele Zeichen (auch keine), `?` genau ein Zeichen, `[…]` ein Zeichen aus der Menge, `[!…]` ein Zeichen nicht aus der Menge.",
"references": ["man 7 glob"]
},
{
"id": "103.3-005",
"objective": "103.3",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl ermittelt den Typ einer Datei anhand ihres Inhalts (z. B. „ELF 64-bit executable“ oder „gzip compressed data“)?",
"options": [
{ "id": "a", "text": "`file`", "correct": true, "explanation": "`file` vergleicht den Inhalt mit Signaturen (Magic Numbers)." },
{ "id": "b", "text": "`stat`", "correct": false, "explanation": "`stat` zeigt Metadaten aus dem Inode (Größe, Rechte, Zeiten), nicht den Inhaltstyp." },
{ "id": "c", "text": "`type`", "correct": false, "explanation": "`type` bestimmt, wie die Shell einen Befehlsnamen auflöst." },
{ "id": "d", "text": "`ls -l`", "correct": false, "explanation": "`ls -l` zeigt nur den Dateityp im Sinne von Datei/Verzeichnis/Link usw." },
{ "id": "e", "text": "`which`", "correct": false, "explanation": "`which` sucht ein Programm im `PATH`." }
],
"explanation": "Unter Linux bestimmt nicht die Endung den Typ, sondern der Inhalt; `file` wertet dazu die magic-Datenbank aus.",
"references": ["man 1 file"]
},
{
"id": "103.3-006",
"objective": "103.3",
"type": "single",
"difficulty": 2,
"question": "Der Master Boot Record (erster Sektor, 512 Byte) von `/dev/sda` soll in die Datei `mbr.img` gesichert werden. Welcher Befehl ist korrekt?",
"options": [
{ "id": "a", "text": "`dd if=/dev/sda of=mbr.img bs=512 count=1`", "correct": true, "explanation": "`if` Quelle, `of` Ziel, ein Block zu 512 Byte." },
{ "id": "b", "text": "`dd if=mbr.img of=/dev/sda bs=512 count=1`", "correct": false, "explanation": "Quelle und Ziel sind vertauscht – das würde den MBR mit der Datei überschreiben." },
{ "id": "c", "text": "`dd if=/dev/sda of=mbr.img bs=512 skip=1 count=1`", "correct": false, "explanation": "`skip=1` überspringt den ersten Block der Quelle – kopiert würde der zweite Sektor, nicht der MBR." },
{ "id": "d", "text": "`dd if=/dev/sda1 of=mbr.img bs=512 count=1`", "correct": false, "explanation": "`/dev/sda1` ist die erste Partition; der MBR liegt am Anfang der ganzen Platte." },
{ "id": "e", "text": "`cp /dev/sda mbr.img`", "correct": false, "explanation": "Das würde die gesamte Platte kopieren, nicht nur den ersten Sektor." }
],
"explanation": "Der MBR enthält Bootloader-Code (446 Byte), Partitionstabelle (64 Byte) und Signatur (2 Byte).",
"references": ["man 1 dd"]
},
{
"id": "103.4-001",
"objective": "103.4",
"type": "single",
"difficulty": 2,
"question": "Standardausgabe **und** Fehlerausgabe eines Befehls sollen in dieselbe Datei geschrieben werden. Welche Schreibweise ist korrekt?",
"options": [
{ "id": "a", "text": "`befehl > log.txt 2>&1`", "correct": true, "explanation": "Erst stdout in die Datei, dann stderr auf das (bereits umgelenkte) stdout." },
{ "id": "b", "text": "`befehl 2>&1 > log.txt`", "correct": false, "explanation": "Reihenfolge: stderr wird auf das ursprüngliche stdout (Terminal) gelegt, erst danach stdout in die Datei." },
{ "id": "c", "text": "`befehl 2> log.txt`", "correct": false, "explanation": "Nur die Fehlerausgabe landet in der Datei." },
{ "id": "d", "text": "`befehl | log.txt`", "correct": false, "explanation": "Die Pipe erwartet einen Befehl; `log.txt` würde als Programm gesucht." },
{ "id": "e", "text": "`befehl >> log.txt 1>&2`", "correct": false, "explanation": "`1>&2` lenkt stdout anschließend wieder auf stderr (Terminal) um; die Datei bleibt leer." }
],
"explanation": "Umleitungen werden von links nach rechts ausgewertet. Bash-Kurzform: `befehl &> log.txt`.",
"references": ["man 1 bash (Abschnitt REDIRECTION)"]
},
{
"id": "103.4-002",
"objective": "103.4",
"type": "fill",
"difficulty": 1,
"question": "Welche Umleitung (nur die Umleitung, ohne Befehl) verwirft die **Fehlerausgabe** eines Befehls?",
"answers": ["2>/dev/null", "2> /dev/null"],
"explanation": "Dateideskriptor 2 ist stderr; `/dev/null` verwirft alles, was hineingeschrieben wird.",
"references": ["man 4 null"]
},
{
"id": "103.4-003",
"objective": "103.4",
"type": "single",
"difficulty": 1,
"question": "Die Ausgabe eines Befehls soll auf dem Bildschirm erscheinen **und** gleichzeitig in `ausgabe.txt` gespeichert werden. Wie geht das?",
"options": [
{ "id": "a", "text": "`befehl | tee ausgabe.txt`", "correct": true, "explanation": "`tee` kopiert stdin nach stdout und zusätzlich in die Datei(en); `-a` hängt an." },
{ "id": "b", "text": "`befehl > ausgabe.txt | cat`", "correct": false, "explanation": "stdout geht vollständig in die Datei; an `cat` kommt nichts an." },
{ "id": "c", "text": "`befehl >> ausgabe.txt`", "correct": false, "explanation": "Hängt nur an die Datei an; auf dem Bildschirm erscheint nichts." },
{ "id": "d", "text": "`befehl | cat > ausgabe.txt`", "correct": false, "explanation": "Die Ausgabe landet nur in der Datei." },
{ "id": "e", "text": "`befehl 2>&1 ausgabe.txt`", "correct": false, "explanation": "`ausgabe.txt` würde als Argument an den Befehl übergeben." }
],
"explanation": "`tee` ist wie ein T-Stück in der Pipe. Mit `sudo tee datei` schreibt man z. B. als root in geschützte Dateien.",
"references": ["man 1 tee"]
},
{
"id": "103.4-004",
"objective": "103.4",
"type": "single",
"difficulty": 2,
"question": "Alle von `find` gefundenen `*.tmp`-Dateien sollen gelöscht werden, indem ihre Namen als **Argumente** an `rm` übergeben werden. Welche Befehlszeile tut das?",
"options": [
{ "id": "a", "text": "`find . -name '*.tmp' | xargs rm`", "correct": true, "explanation": "`xargs` liest Namen von stdin und hängt sie als Argumente an `rm`." },
{ "id": "b", "text": "`find . -name '*.tmp' | rm`", "correct": false, "explanation": "`rm` liest keine Dateinamen von stdin; es meldet fehlende Operanden." },
{ "id": "c", "text": "`find . -name '*.tmp' > rm`", "correct": false, "explanation": "Das schreibt die Liste in eine Datei namens `rm`." },
{ "id": "d", "text": "`find . -name '*.tmp' | tee rm`", "correct": false, "explanation": "`tee` schreibt die Liste in die Datei `rm` und auf den Bildschirm." },
{ "id": "e", "text": "`rm < find . -name '*.tmp'`", "correct": false, "explanation": "`<` erwartet eine Datei als Eingabe, keinen Befehl." }
],
"explanation": "Bei Namen mit Leerzeichen: `find … -print0 | xargs -0 rm`. Alternativ ohne Pipe: `find . -name '*.tmp' -delete` oder `-exec rm {} +`.",
"references": ["man 1 xargs"]
},
{
"id": "103.4-005",
"objective": "103.4",
"type": "multi",
"difficulty": 1,
"question": "Welche Aussagen zu Umleitungen und Pipes treffen zu?",
"options": [
{ "id": "a", "text": "`>>` hängt die Standardausgabe an eine Datei an.", "correct": true, "explanation": "Existiert die Datei nicht, wird sie angelegt." },
{ "id": "b", "text": "`<` liest die Standardeingabe aus einer Datei.", "correct": true, "explanation": "Beispiel: `sort < liste.txt`." },
{ "id": "c", "text": "`2>&1` leitet die Standardausgabe auf die Fehlerausgabe um.", "correct": false, "explanation": "Umgekehrt: stderr (2) wird dorthin geleitet, wohin stdout (1) gerade zeigt." },
{ "id": "d", "text": "`|` verbindet die Fehlerausgabe mit der Eingabe des nächsten Befehls.", "correct": false, "explanation": "Die Pipe verbindet stdout mit stdin; stderr nur mit `|&` bzw. `2>&1 |`." },
{ "id": "e", "text": "`>` hängt an, wenn die Datei bereits existiert.", "correct": false, "explanation": "`>` überschreibt (kürzt die Datei auf 0); nur `>>` hängt an." }
],
"explanation": "Dateideskriptoren: 0 stdin, 1 stdout, 2 stderr. `set -o noclobber` verhindert versehentliches Überschreiben mit `>`.",
"references": ["man 1 bash (Abschnitt REDIRECTION)"]
},
{
"id": "103.4-006",
"objective": "103.4",
"type": "single",
"difficulty": 1,
"question": "Mit welcher Schreibweise setzt die Bash die **Ausgabe** eines Befehls in die Kommandozeile ein, z. B. in `echo \"Heute ist …\"`?",
"options": [
{ "id": "a", "text": "`$(date +%A)`", "correct": true, "explanation": "Befehlsersetzung: Die Ausgabe von `date +%A` ersetzt den Ausdruck." },
{ "id": "b", "text": "`${date +%A}`", "correct": false, "explanation": "`${…}` ist Parameter-/Variablenersetzung und hier ein Syntaxfehler." },
{ "id": "c", "text": "`$((date +%A))`", "correct": false, "explanation": "`$((…))` ist arithmetische Expansion." },
{ "id": "d", "text": "`'date +%A'`", "correct": false, "explanation": "Einfache Anführungszeichen ergeben den Text wörtlich." },
{ "id": "e", "text": "`<(date +%A)`", "correct": false, "explanation": "Prozessersetzung liefert einen Dateinamen (z. B. `/dev/fd/63`), nicht den Text." }
],
"explanation": "Ältere, gleichwertige Schreibweise mit Backticks (Gravis-Zeichen). `$(…)` ist besser lesbar und verschachtelbar.",
"references": ["man 1 bash (Abschnitt Command Substitution)"]
},
{
"id": "103.5-001",
"objective": "103.5",
"type": "single",
"difficulty": 1,
"question": "Welches Signal kann ein Prozess weder abfangen noch ignorieren?",
"options": [
{ "id": "a", "text": "SIGKILL (9)", "correct": true, "explanation": "SIGKILL beendet den Prozess unmittelbar durch den Kernel; es gibt keinen Handler." },
{ "id": "b", "text": "SIGTERM (15)", "correct": false, "explanation": "SIGTERM ist die höfliche Aufforderung zum Beenden und kann abgefangen werden." },
{ "id": "c", "text": "SIGHUP (1)", "correct": false, "explanation": "SIGHUP wird oft abgefangen, z. B. um Konfiguration neu zu laden." },
{ "id": "d", "text": "SIGINT (2)", "correct": false, "explanation": "SIGINT (Strg+C) kann abgefangen werden." },
{ "id": "e", "text": "SIGUSR1 (10)", "correct": false, "explanation": "Benutzerdefiniertes Signal, das Programme frei abfangen." }
],
"explanation": "Neben SIGKILL kann auch SIGSTOP nicht abgefangen werden. Liste aller Signale: `kill -l`.",
"references": ["man 7 signal"]
},
{
"id": "103.5-002",
"objective": "103.5",
"type": "fill",
"difficulty": 1,
"question": "Welches Signal sendet `kill <PID>`, wenn kein Signal angegeben wird? (Name oder Nummer)",
"answers": ["SIGTERM", "TERM", "15"],
"case_sensitive": false,
"explanation": "Standard ist SIGTERM (15). Erst wenn ein Prozess darauf nicht reagiert, nimmt man SIGKILL (`kill -9`).",
"references": ["man 1 kill"]
},
{
"id": "103.5-003",
"objective": "103.5",
"type": "single",
"difficulty": 1,
"question": "Ein Skript soll weiterlaufen, nachdem sich der Benutzer abgemeldet hat. Welche Befehlszeile ist dafür gedacht?",
"options": [
{ "id": "a", "text": "`nohup ./skript.sh &`", "correct": true, "explanation": "`nohup` ignoriert SIGHUP und leitet die Ausgabe nach `nohup.out` um; `&` startet im Hintergrund." },
{ "id": "b", "text": "`./skript.sh &`", "correct": false, "explanation": "Hintergrundjobs können beim Abmelden SIGHUP erhalten und beendet werden." },
{ "id": "c", "text": "`bg ./skript.sh`", "correct": false, "explanation": "`bg` setzt einen gestoppten Job fort und erwartet eine Jobnummer, keinen Befehl." },
{ "id": "d", "text": "`nice ./skript.sh`", "correct": false, "explanation": "`nice` ändert nur die Priorität." },
{ "id": "e", "text": "`jobs ./skript.sh`", "correct": false, "explanation": "`jobs` listet Jobs der aktuellen Shell." }
],
"explanation": "Alternativen: `disown` für laufende Jobs, oder Terminal-Multiplexer wie `screen`/`tmux`, von denen man sich trennen und später wieder verbinden kann.",
"references": ["man 1 nohup"]
},
{
"id": "103.5-004",
"objective": "103.5",
"type": "single",
"difficulty": 1,
"question": "`jobs` zeigt drei Jobs. Wie holt man Job Nummer 2 in den Vordergrund?",
"options": [
{ "id": "a", "text": "`fg %2`", "correct": true, "explanation": "`fg` holt den angegebenen Job in den Vordergrund; `%2` ist die Jobspezifikation." },
{ "id": "b", "text": "`bg %2`", "correct": false, "explanation": "`bg` setzt einen gestoppten Job im Hintergrund fort." },
{ "id": "c", "text": "`jobs %2`", "correct": false, "explanation": "Zeigt nur den Status von Job 2." },
{ "id": "d", "text": "`kill -CONT %2`", "correct": false, "explanation": "Setzt den Job fort, er bleibt aber im Hintergrund." },
{ "id": "e", "text": "`wait %2`", "correct": false, "explanation": "`wait` wartet auf das Ende des Jobs, ohne ihn in den Vordergrund zu holen." }
],
"explanation": "Strg+Z stoppt den Vordergrundjob, `bg` lässt ihn im Hintergrund weiterlaufen, `fg` holt ihn zurück.",
"references": ["help fg", "help jobs"]
},
{
"id": "103.5-005",
"objective": "103.5",
"type": "multi",
"difficulty": 2,
"question": "Mit welchen Befehlen ermittelt man die Prozess-ID(s) laufender `sshd`-Prozesse anhand des Namens?",
"options": [
{ "id": "a", "text": "`pgrep sshd`", "correct": true, "explanation": "`pgrep` gibt die PIDs aller Prozesse aus, deren Name auf das Muster passt." },
{ "id": "b", "text": "`pidof sshd`", "correct": true, "explanation": "`pidof` gibt die PIDs eines Programms mit genau diesem Namen aus." },
{ "id": "c", "text": "`pkill sshd`", "correct": false, "explanation": "`pkill` sendet ein Signal (Standard SIGTERM) an die Prozesse – Vorsicht!" },
{ "id": "d", "text": "`ps -p sshd`", "correct": false, "explanation": "`-p` erwartet eine PID-Liste, keinen Namen (richtig wäre `ps -C sshd`)." },
{ "id": "e", "text": "`top -n sshd`", "correct": false, "explanation": "`-n` legt bei `top` die Anzahl der Durchläufe fest." }
],
"explanation": "Auch üblich: `ps aux | grep sshd`. `pgrep -a` zeigt zusätzlich die Befehlszeile, `pgrep -u` filtert nach Benutzer.",
"references": ["man 1 pgrep", "man 8 pidof"]
},
{
"id": "103.5-006",
"objective": "103.5",
"type": "single",
"difficulty": 1,
"question": "Welcher Befehl zeigt kompakt die Laufzeit des Systems, die Anzahl angemeldeter Benutzer und die Load Average der letzten 1, 5 und 15 Minuten?",
"options": [
{ "id": "a", "text": "`uptime`", "correct": true, "explanation": "`uptime` gibt genau diese Zeile aus (Werte aus `/proc/uptime` und `/proc/loadavg`)." },
{ "id": "b", "text": "`free`", "correct": false, "explanation": "`free` zeigt Arbeitsspeicher und Swap." },
{ "id": "c", "text": "`vmstat`", "correct": false, "explanation": "`vmstat` zeigt Prozess-, Speicher-, I/O- und CPU-Statistiken, aber keine Load Average." },
{ "id": "d", "text": "`ps aux`", "correct": false, "explanation": "`ps aux` listet Prozesse." },
{ "id": "e", "text": "`watch`", "correct": false, "explanation": "`watch` führt einen Befehl wiederholt aus und zeigt seine Ausgabe." }
],
"explanation": "Die Load Average ist die mittlere Zahl laufender bzw. auf CPU oder I/O wartender Prozesse. Sie steht auch in der ersten Zeile von `top` und `w`.",
"references": ["man 1 uptime"]
},
{
"id": "103.6-001",
"objective": "103.6",
"type": "single",
"difficulty": 1,
"question": "In welchem Bereich liegen Nice-Werte unter Linux, und welcher Wert bedeutet die **höchste** Priorität?",
"options": [
{ "id": "a", "text": "−20 bis 19; −20 ist die höchste Priorität", "correct": true, "explanation": "Je niedriger der Nice-Wert, desto „unfreundlicher“ ist der Prozess, also desto mehr CPU-Zeit bekommt er." },
{ "id": "b", "text": "−20 bis 19; 19 ist die höchste Priorität", "correct": false, "explanation": "19 ist die niedrigste Priorität." },
{ "id": "c", "text": "0 bis 39; 39 ist die höchste Priorität", "correct": false, "explanation": "Nice-Werte sind vorzeichenbehaftet und reichen von −20 bis 19." },
{ "id": "d", "text": "1 bis 99; 99 ist die höchste Priorität", "correct": false, "explanation": "1–99 ist der Bereich der Echtzeitprioritäten, keine Nice-Werte." },
{ "id": "e", "text": "−19 bis 20; 0 ist die höchste Priorität", "correct": false, "explanation": "Falscher Bereich; 0 ist der Standardwert." }
],
"explanation": "Standard ist 0. `nice` ohne `-n` startet mit +10. In `ps -l` erscheint der Wert in Spalte NI, in `top` als NI.",
"references": ["man 1 nice"]
},
{
"id": "103.6-002",
"objective": "103.6",
"type": "fill",
"difficulty": 2,
"question": "Geben Sie den Befehl ein, der den Nice-Wert des laufenden Prozesses mit der PID 1234 auf 10 setzt.",
"answers": ["renice -n 10 -p 1234", "renice 10 1234", "renice -n 10 1234", "renice 10 -p 1234", "renice +10 1234", "renice +10 -p 1234", "renice -n +10 -p 1234"],
"explanation": "`renice` ändert laufende Prozesse (`-p` PID, `-u` Benutzer, `-g` Prozessgruppe); `nice` gilt nur beim Starten.",
"references": ["man 1 renice"]
},
{
"id": "103.6-003",
"objective": "103.6",
"type": "multi",
"difficulty": 2,
"question": "Was darf ein **normaler Benutzer** (ohne besondere Limits) standardmäßig?",
"options": [
{ "id": "a", "text": "Ein Programm mit Nice-Wert 10 starten", "correct": true, "explanation": "Positive Nice-Werte (niedrigere Priorität) darf jeder setzen: `nice -n 10 programm`." },
{ "id": "b", "text": "Den Nice-Wert eines eigenen laufenden Prozesses erhöhen", "correct": true, "explanation": "Die eigene Priorität senken ist erlaubt: `renice -n 15 -p <PID>`." },
{ "id": "c", "text": "Ein Programm mit Nice-Wert −5 starten", "correct": false, "explanation": "Negative Nice-Werte erfordern root (bzw. CAP_SYS_NICE)." },
{ "id": "d", "text": "Den Nice-Wert eines Prozesses eines anderen Benutzers ändern", "correct": false, "explanation": "Nur eigene Prozesse; fremde nur als root." },
{ "id": "e", "text": "Den Nice-Wert eines eigenen Prozesses wieder unter den bisherigen Wert senken", "correct": false, "explanation": "Die Priorität wieder anheben darf standardmäßig nur root (Ausnahme: über `RLIMIT_NICE` erlaubte Bereiche)." }
],
"explanation": "Grundregel: Jeder darf seine Prozesse „netter“ machen, nur root darf Priorität erhöhen.",
"references": ["man 1 renice", "man 2 setpriority"]
},
{
"id": "103.7-001",
"objective": "103.7",
"type": "single",
"difficulty": 1,
"question": "Welche grep-Option gibt alle Zeilen aus, die **nicht** auf das Muster passen?",
"options": [
{ "id": "a", "text": "`-v`", "correct": true, "explanation": "`-v` (`--invert-match`) kehrt die Auswahl um." },
{ "id": "b", "text": "`-i`", "correct": false, "explanation": "`-i` ignoriert Groß-/Kleinschreibung." },
{ "id": "c", "text": "`-c`", "correct": false, "explanation": "`-c` gibt nur die Anzahl passender Zeilen aus." },
{ "id": "d", "text": "`-l`", "correct": false, "explanation": "`-l` gibt nur die Namen der Dateien mit Treffern aus." },
{ "id": "e", "text": "`-n`", "correct": false, "explanation": "`-n` stellt die Zeilennummer voran." }
],
"explanation": "Wichtige Optionen: `-E` erweiterte RE, `-F` feste Zeichenkette, `-r` rekursiv, `-w` ganzes Wort, `-o` nur den Treffer.",
"references": ["man 1 grep"]
},
{
"id": "103.7-002",
"objective": "103.7",
"type": "single",
"difficulty": 2,
"question": "Welcher Befehl gibt eine Konfigurationsdatei **ohne** Kommentarzeilen (beginnen mit `#`) und **ohne** Leerzeilen aus?",
"options": [
{ "id": "a", "text": "`grep -Ev '^(#|$)' datei`", "correct": true, "explanation": "Das Muster passt auf Zeilen, die mit `#` beginnen oder leer sind; `-v` kehrt um." },
{ "id": "b", "text": "`grep -v '#' datei`", "correct": false, "explanation": "Entfernt auch Zeilen mit `#` in der Mitte und lässt Leerzeilen stehen." },
{ "id": "c", "text": "`grep -E '^#|^$' datei`", "correct": false, "explanation": "Gibt nur Kommentar- und Leerzeilen aus." },
{ "id": "d", "text": "`grep -v '^#$' datei`", "correct": false, "explanation": "Entfernt nur Zeilen, die ausschließlich aus `#` bestehen." },
{ "id": "e", "text": "`grep -cv '^#' datei`", "correct": false, "explanation": "`-c` gibt nur eine Anzahl aus." }
],
"explanation": "Anker: `^` Zeilenanfang, `$` Zeilenende; `^$` ist eine leere Zeile. `|` (Alternative) und `( )` erfordern ERE (`-E`) oder in BRE `\\|` und `\\( \\)`.",
"references": ["man 7 regex", "man 1 grep"]
},
{
"id": "103.7-003",
"objective": "103.7",
"type": "fill",
"difficulty": 2,
"question": "Geben Sie den sed-Befehl ein, der in der Datei `datei` **jedes** Vorkommen von `foo` durch `bar` ersetzt und das Ergebnis auf stdout ausgibt.",
"answers": ["sed 's/foo/bar/g' datei", "sed \"s/foo/bar/g\" datei", "sed s/foo/bar/g datei", "sed -e 's/foo/bar/g' datei", "sed -e \"s/foo/bar/g\" datei"],
"explanation": "`s/alt/neu/` ersetzt das erste Vorkommen je Zeile, das Flag `g` alle. Mit `-i` wird die Datei selbst geändert.",
"references": ["man 1 sed"]
},
{
"id": "103.7-004",
"objective": "103.7",
"type": "multi",
"difficulty": 2,
"question": "Welche Aussagen zu regulären Ausdrücken (grep) treffen zu?",
"options": [
{ "id": "a", "text": "`.` passt auf genau ein beliebiges Zeichen.", "correct": true, "explanation": "Für einen wörtlichen Punkt: `\\.`." },
{ "id": "b", "text": "`*` bedeutet: das vorherige Element null- oder mehrmals.", "correct": true, "explanation": "`a*` passt auch auf die leere Zeichenkette; anders als beim Shell-Globbing." },
{ "id": "c", "text": "In Basic RE (grep ohne `-E`) bedeutet `+` „ein- oder mehrmals“.", "correct": false, "explanation": "In BRE ist `+` ein normales Zeichen; GNU grep versteht dort `\\+`. Mit `-E` ist `+` ein Quantor." },
{ "id": "d", "text": "`$` verankert am Zeilenanfang.", "correct": false, "explanation": "`$` ist das Zeilenende, `^` der Zeilenanfang." },
{ "id": "e", "text": "`[^a-z]` passt auf einen Kleinbuchstaben.", "correct": false, "explanation": "`^` am Anfang einer Klammer negiert: ein Zeichen, das **kein** Kleinbuchstabe ist." }
],
"explanation": "ERE-Zusätze: `+`, `?`, `{n,m}`, `|`, `( )`. Zeichenklassen: `[[:digit:]]`, `[[:space:]]`, `[[:alpha:]]`.",
"references": ["man 7 regex"]
},
{
"id": "103.8-001",
"objective": "103.8",
"type": "single",
"difficulty": 1,
"question": "Mit welcher Eingabe im Befehlsmodus von vi speichert man die Datei und beendet den Editor?",
"options": [
{ "id": "a", "text": "`:wq`", "correct": true, "explanation": "`:w` schreibt, `:q` beendet. Gleichwertig: `:x` und `ZZ`." },
{ "id": "b", "text": "`:q!`", "correct": false, "explanation": "Beendet ohne zu speichern und verwirft Änderungen." },
{ "id": "c", "text": "`:w`", "correct": false, "explanation": "Speichert nur, vi bleibt offen." },
{ "id": "d", "text": "`ZQ`", "correct": false, "explanation": "`ZQ` entspricht `:q!`, also beenden ohne Speichern." },
{ "id": "e", "text": "`:e!`", "correct": false, "explanation": "Lädt die Datei neu und verwirft ungespeicherte Änderungen." }
],
"explanation": "Mit Esc kommt man aus dem Einfügemodus in den Befehlsmodus. Doppelpunkt-Befehle sind Ex-Befehle.",
"references": ["man 1 vim", ":help ZZ"]
},
{
"id": "103.8-002",
"objective": "103.8",
"type": "fill",
"difficulty": 1,
"question": "Welche Tastenfolge löscht in vi im Befehlsmodus die **aktuelle Zeile** (und legt sie in den Puffer)?",
"answers": ["dd"],
"explanation": "`dd` löscht die Zeile, `5dd` fünf Zeilen, `yy` kopiert, `p` fügt ein, `u` macht rückgängig.",
"references": [":help dd"]
},
{
"id": "103.8-003",
"objective": "103.8",
"type": "single",
"difficulty": 1,
"question": "Wie sucht man in vi im Befehlsmodus **vorwärts** nach dem Wort `Port`?",
"options": [
{ "id": "a", "text": "`/Port`", "correct": true, "explanation": "`/` sucht vorwärts; `n` springt zum nächsten, `N` zum vorherigen Treffer." },
{ "id": "b", "text": "`?Port`", "correct": false, "explanation": "`?` sucht rückwärts." },
{ "id": "c", "text": "`:s/Port`", "correct": false, "explanation": "`:s` ist das Ersetzen in der aktuellen Zeile." },
{ "id": "d", "text": "`fPort`", "correct": false, "explanation": "`f` springt zum nächsten Vorkommen eines einzelnen Zeichens in der aktuellen Zeile (hier `P`)." },
{ "id": "e", "text": "`nPort`", "correct": false, "explanation": "`n` wiederholt die letzte Suche; die folgenden Zeichen würden als weitere Befehle gelesen." }
],
"explanation": "Suchen und ersetzen in der ganzen Datei: `:%s/alt/neu/g`.",
"references": [":help /", ":help n"]
},
{
"id": "103.8-004",
"objective": "103.8",
"type": "multi",
"difficulty": 1,
"question": "Welche Tasten wechseln in vi aus dem Befehlsmodus in den **Einfügemodus**?",
"options": [
{ "id": "a", "text": "`i`", "correct": true, "explanation": "Einfügen vor dem Cursor." },
{ "id": "b", "text": "`o`", "correct": true, "explanation": "Öffnet eine neue Zeile unterhalb und wechselt in den Einfügemodus." },
{ "id": "c", "text": "`x`", "correct": false, "explanation": "Löscht das Zeichen unter dem Cursor; man bleibt im Befehlsmodus." },
{ "id": "d", "text": "`p`", "correct": false, "explanation": "Fügt den Pufferinhalt ein (paste); man bleibt im Befehlsmodus." },
{ "id": "e", "text": "`u`", "correct": false, "explanation": "Macht die letzte Änderung rückgängig." }
],
"explanation": "Einfügemodus auch mit `a`/`A` (nach Cursor/Zeilenende), `I` (Zeilenanfang), `O` (neue Zeile oberhalb). Der Standard-Editor wird über `EDITOR`/`VISUAL` festgelegt.",
"references": [":help insert"]
}
]
}
simulator/data/lpic1_101/questions_104.json
+327
View File
@@ -0,0 +1,327 @@
{
"$schema": "../schema/questions.schema.json",
"format": "lpic-sim-questions",
"meta": {
"file": "questions_104.json",
"brief": "Fragen zu Topic 104 Geräte, Linux-Dateisysteme, FHS (LPIC-1 101-500, Objectives 5.0)",
"author": "Björn Runden <br@runden.de>",
"owner": "Björn Runden <br@runden.de>",
"assist": "KI-unterstützt (Claude Opus 5.5), geprüft von Björn Runden <br@runden.de>",
"version": "0.1.0 (29.10.2026)"
},
"exam": "lpic1-101",
"questions": [
{
"id": "104.1-001",
"objective": "104.1",
"type": "single",
"difficulty": 1,
"question": "Auf der ersten Partition der zweiten Festplatte (`/dev/sdb1`) soll ein ext4-Dateisystem angelegt werden. Welcher Befehl ist korrekt?",
"options": [
{ "id": "a", "text": "`mkfs.ext4 /dev/sdb1`", "correct": true, "explanation": "`mkfs.ext4` (gleichwertig `mkfs -t ext4` oder `mke2fs -t ext4`) legt das Dateisystem an." },
{ "id": "b", "text": "`mkfs.ext4 /dev/sdb`", "correct": false, "explanation": "Das würde die ganze Platte ohne Partitionstabelle formatieren, nicht die erste Partition." },
{ "id": "c", "text": "`mount -t ext4 /dev/sdb1`", "correct": false, "explanation": "`mount` hängt ein vorhandenes Dateisystem ein, es legt keines an." },
{ "id": "d", "text": "`fdisk -t ext4 /dev/sdb1`", "correct": false, "explanation": "`fdisk` bearbeitet Partitionstabellen, legt aber keine Dateisysteme an." },
{ "id": "e", "text": "`tune2fs -j /dev/sdb1`", "correct": false, "explanation": "`tune2fs -j` fügt einem bestehenden ext2 ein Journal hinzu." }
],
"explanation": "Reihenfolge: partitionieren (`fdisk`, `gdisk`, `parted`), Dateisystem anlegen (`mkfs.*`), einhängen (`mount`), dauerhaft in `/etc/fstab`.",
"references": ["man 8 mkfs", "man 8 mke2fs"]
},
{
"id": "104.1-002",
"objective": "104.1",
"type": "fill",
"difficulty": 1,
"question": "Die Partition `/dev/sdc2` soll als Swap-Bereich vorbereitet (initialisiert) werden. Geben Sie den vollständigen Befehl ein.",
"answers": ["mkswap /dev/sdc2"],
"explanation": "`mkswap` schreibt die Swap-Signatur; aktiviert wird mit `swapon /dev/sdc2`, dauerhaft über einen fstab-Eintrag vom Typ `swap`.",
"references": ["man 8 mkswap", "man 8 swapon"]
},
{
"id": "104.1-003",
"objective": "104.1",
"type": "multi",
"difficulty": 2,
"question": "Welche Werkzeuge können GPT-Partitionstabellen anlegen und bearbeiten?",
"options": [
{ "id": "a", "text": "`gdisk`", "correct": true, "explanation": "`gdisk` ist ein fdisk-ähnliches Werkzeug speziell für GPT." },
{ "id": "b", "text": "`parted`", "correct": true, "explanation": "`parted` unterstützt MBR (msdos) und GPT und kann auch skriptgesteuert arbeiten." },
{ "id": "c", "text": "`fdisk` (aktuelles util-linux)", "correct": true, "explanation": "Aktuelle `fdisk`-Versionen aus util-linux unterstützen GPT (Befehl `g` legt eine leere GPT an)." },
{ "id": "d", "text": "`blkid`", "correct": false, "explanation": "`blkid` zeigt nur Attribute wie UUID, LABEL und TYPE an." },
{ "id": "e", "text": "`mkswap`", "correct": false, "explanation": "`mkswap` initialisiert einen Swap-Bereich, partitioniert aber nicht." }
],
"explanation": "MBR: höchstens 4 primäre Partitionen (bzw. 3 primäre und eine erweiterte), max. 2 TiB. GPT: standardmäßig 128 Partitionen, sehr große Platten, Sicherungskopie der Tabelle am Plattenende.",
"references": ["man 8 gdisk", "man 8 parted", "man 8 fdisk"]
},
{
"id": "104.2-001",
"objective": "104.2",
"type": "single",
"difficulty": 1,
"question": "Was ist zu beachten, bevor man ein ext4-Dateisystem mit `fsck` prüft und repariert?",
"options": [
{ "id": "a", "text": "Das Dateisystem darf nicht (oder höchstens nur lesend) eingehängt sein.", "correct": true, "explanation": "Eine Reparatur an einem schreibend eingehängten Dateisystem kann es zerstören." },
{ "id": "b", "text": "Das Dateisystem muss schreibend eingehängt sein.", "correct": false, "explanation": "Genau das sollte man vermeiden." },
{ "id": "c", "text": "`fsck` funktioniert nur mit XFS.", "correct": false, "explanation": "`fsck` ist ein Frontend und ruft für ext4 `e2fsck` auf; für XFS ist es gerade nicht zuständig." },
{ "id": "d", "text": "Vorher muss `mkfs` ausgeführt werden.", "correct": false, "explanation": "`mkfs` würde ein neues, leeres Dateisystem anlegen und alle Daten verlieren." },
{ "id": "e", "text": "`fsck` darf nur auf Swap-Partitionen angewendet werden.", "correct": false, "explanation": "Swap enthält kein Dateisystem und wird nicht mit `fsck` geprüft." }
],
"explanation": "Die Root-Partition prüft man daher beim Start (sechstes Feld in `/etc/fstab`) oder aus einem Rettungssystem. `tune2fs` stellt die automatische Prüfung nach Anzahl Mounts/Zeit ein.",
"references": ["man 8 fsck", "man 8 e2fsck"]
},
{
"id": "104.2-002",
"objective": "104.2",
"type": "single",
"difficulty": 2,
"question": "Welches Werkzeug repariert ein beschädigtes **XFS**-Dateisystem?",
"options": [
{ "id": "a", "text": "`xfs_repair`", "correct": true, "explanation": "`xfs_repair` prüft und repariert XFS; mit `-n` nur prüfen, ohne zu ändern." },
{ "id": "b", "text": "`xfs_fsr`", "correct": false, "explanation": "`xfs_fsr` defragmentiert ein eingehängtes XFS." },
{ "id": "c", "text": "`fsck.xfs`", "correct": false, "explanation": "`fsck.xfs` tut absichtlich nichts und verweist auf `xfs_repair`; XFS prüft sich beim Mounten über das Journal." },
{ "id": "d", "text": "`e2fsck`", "correct": false, "explanation": "`e2fsck` ist für ext2/3/4." },
{ "id": "e", "text": "`xfs_info`", "correct": false, "explanation": "`xfs_info` zeigt nur die Geometrie eines XFS an." }
],
"explanation": "Weitere XFS-Werkzeuge: `xfs_db` (Debugger), `xfs_growfs` (vergrößern). ext-Werkzeuge: `e2fsck`, `tune2fs`, `dumpe2fs`, `debugfs`.",
"references": ["man 8 xfs_repair"]
},
{
"id": "104.2-003",
"objective": "104.2",
"type": "multi",
"difficulty": 1,
"question": "Welche Befehle helfen, den **Speicherplatz** auf Dateisystemen zu überwachen?",
"options": [
{ "id": "a", "text": "`df -h`", "correct": true, "explanation": "Belegter und freier Platz je eingehängtem Dateisystem; `df -i` zeigt die Inodes." },
{ "id": "b", "text": "`du -sh /var/log`", "correct": true, "explanation": "Summe des belegten Platzes eines Verzeichnisbaums." },
{ "id": "c", "text": "`free -h`", "correct": false, "explanation": "`free` zeigt Arbeitsspeicher und Swap, keinen Plattenplatz." },
{ "id": "d", "text": "`blkid`", "correct": false, "explanation": "`blkid` zeigt UUID, Label und Typ, keine Belegung." },
{ "id": "e", "text": "`mount`", "correct": false, "explanation": "`mount` ohne Argumente listet eingehängte Dateisysteme mit Optionen, ohne Belegung." }
],
"explanation": "Ein Dateisystem kann auch „voll“ sein, wenn noch Platz frei ist, aber keine Inodes mehr – dann hilft `df -i`.",
"references": ["man 1 df", "man 1 du"]
},
{
"id": "104.3-001",
"objective": "104.3",
"type": "single",
"difficulty": 1,
"question": "In welcher Reihenfolge stehen die sechs Felder eines Eintrags in `/etc/fstab`?",
"options": [
{ "id": "a", "text": "Gerät · Einhängepunkt · Dateisystemtyp · Optionen · dump · fsck-Reihenfolge", "correct": true, "explanation": "Beispiel: `UUID=… /home ext4 defaults 0 2`." },
{ "id": "b", "text": "Einhängepunkt · Gerät · Dateisystemtyp · Optionen · dump · fsck-Reihenfolge", "correct": false, "explanation": "Das Gerät steht zuerst, danach der Einhängepunkt." },
{ "id": "c", "text": "Gerät · Dateisystemtyp · Einhängepunkt · Optionen · dump · fsck-Reihenfolge", "correct": false, "explanation": "Der Einhängepunkt kommt vor dem Typ." },
{ "id": "d", "text": "Gerät · Einhängepunkt · Optionen · Dateisystemtyp · fsck-Reihenfolge · dump", "correct": false, "explanation": "Typ vor Optionen; dump (5.) vor fsck-Reihenfolge (6.)." },
{ "id": "e", "text": "Gerät · Einhängepunkt · Dateisystemtyp · Benutzer · Optionen · fsck-Reihenfolge", "correct": false, "explanation": "Ein Benutzerfeld gibt es nicht; `user`/`users` sind Optionen im vierten Feld." }
],
"explanation": "Sechstes Feld: 0 = nicht prüfen, 1 = Root-Dateisystem, 2 = andere Dateisysteme. systemd erzeugt aus fstab automatisch `.mount`-Units.",
"references": ["man 5 fstab"]
},
{
"id": "104.3-002",
"objective": "104.3",
"type": "fill",
"difficulty": 1,
"question": "Mit welchem Befehl (mit Option) hängt man alle in `/etc/fstab` eingetragenen Dateisysteme ein, die noch nicht eingehängt sind (außer denen mit `noauto`)?",
"answers": ["mount -a", "mount --all"],
"explanation": "`mount -a` eignet sich auch zum Testen eines neuen fstab-Eintrags vor dem nächsten Neustart.",
"references": ["man 8 mount"]
},
{
"id": "104.3-003",
"objective": "104.3",
"type": "single",
"difficulty": 2,
"question": "Welche Zeile ist ein gültiger `/etc/fstab`-Eintrag, der ein Dateisystem anhand seiner UUID nach `/data` einhängt?",
"options": [
{ "id": "a", "text": "`UUID=3f1c9a2e-77b0-4d6e-9c55-2b8e1d0a4f10 /data ext4 defaults 0 2`", "correct": true, "explanation": "Alle sechs Felder in der richtigen Reihenfolge; `UUID=` ist eine gültige Gerätekennung." },
{ "id": "b", "text": "`/data UUID=3f1c9a2e-77b0-4d6e-9c55-2b8e1d0a4f10 ext4 defaults 0 2`", "correct": false, "explanation": "Gerät und Einhängepunkt sind vertauscht." },
{ "id": "c", "text": "`UUID:3f1c9a2e-77b0-4d6e-9c55-2b8e1d0a4f10 /data ext4 defaults 0 2`", "correct": false, "explanation": "Die Schreibweise ist `UUID=` mit Gleichheitszeichen." },
{ "id": "d", "text": "`UUID=3f1c9a2e-77b0-4d6e-9c55-2b8e1d0a4f10 /data defaults ext4 0 2`", "correct": false, "explanation": "Typ und Optionen sind vertauscht." },
{ "id": "e", "text": "`/dev/disk/by-label/3f1c9a2e-77b0-4d6e-9c55-2b8e1d0a4f10 /data ext4 defaults 0 2`", "correct": false, "explanation": "`by-label` enthält Labels, keine UUIDs; der Pfad wäre `/dev/disk/by-uuid/…`." }
],
"explanation": "UUIDs und Labels sind stabil, Gerätenamen wie `/dev/sdb1` können sich beim Hinzufügen von Platten ändern. Auch `LABEL=…` ist erlaubt.",
"references": ["man 5 fstab"]
},
{
"id": "104.3-004",
"objective": "104.3",
"type": "multi",
"difficulty": 1,
"question": "Mit welchen Befehlen kann man die UUID des Dateisystems auf `/dev/sdb1` anzeigen?",
"options": [
{ "id": "a", "text": "`blkid /dev/sdb1`", "correct": true, "explanation": "`blkid` zeigt UUID, TYPE und ggf. LABEL." },
{ "id": "b", "text": "`lsblk -f /dev/sdb1`", "correct": true, "explanation": "`-f` ergänzt die Spalten FSTYPE, LABEL und UUID." },
{ "id": "c", "text": "`mount -U /dev/sdb1`", "correct": false, "explanation": "`mount -U <uuid>` hängt anhand einer UUID ein, zeigt aber keine an." },
{ "id": "d", "text": "`df -u /dev/sdb1`", "correct": false, "explanation": "`df` hat keine Option zur UUID-Anzeige." },
{ "id": "e", "text": "`swapon -s`", "correct": false, "explanation": "`swapon -s` listet aktive Swap-Bereiche." }
],
"explanation": "Die UUIDs stehen auch als Symlinks unter `/dev/disk/by-uuid/`.",
"references": ["man 8 blkid", "man 8 lsblk"]
},
{
"id": "104.5-001",
"objective": "104.5",
"type": "single",
"difficulty": 1,
"question": "Welche Rechte hat eine Datei nach `chmod 750 datei`?",
"options": [
{ "id": "a", "text": "`rwxr-x---`", "correct": true, "explanation": "7 = rwx (Eigentümer), 5 = r-x (Gruppe), 0 = --- (andere)." },
{ "id": "b", "text": "`rwxrw----`", "correct": false, "explanation": "Das wäre 760." },
{ "id": "c", "text": "`rw-r-x---`", "correct": false, "explanation": "Das wäre 650." },
{ "id": "d", "text": "`rwxr-xr-x`", "correct": false, "explanation": "Das wäre 755." },
{ "id": "e", "text": "`r-xrwx---`", "correct": false, "explanation": "Das wäre 570." }
],
"explanation": "Wertigkeit: r = 4, w = 2, x = 1, je Stelle für Eigentümer, Gruppe, andere addiert.",
"references": ["man 1 chmod"]
},
{
"id": "104.5-002",
"objective": "104.5",
"type": "fill",
"difficulty": 1,
"question": "Welcher oktale Modus (drei Ziffern) entspricht den Rechten `rw-r--r--`?",
"answers": ["644", "0644"],
"explanation": "rw- = 4+2 = 6, r-- = 4, r-- = 4. Typisch für normale Dateien; Verzeichnisse haben meist 755.",
"references": ["man 1 chmod"]
},
{
"id": "104.5-003",
"objective": "104.5",
"type": "single",
"difficulty": 2,
"question": "Welche Wirkung hat das SUID-Bit auf eine ausführbare Datei (z. B. `/usr/bin/passwd`)?",
"options": [
{ "id": "a", "text": "Das Programm läuft mit den Rechten des Datei-Eigentümers statt mit denen des Aufrufers.", "correct": true, "explanation": "Deshalb kann `passwd` (Eigentümer root) `/etc/shadow` ändern." },
{ "id": "b", "text": "Neue Dateien im Verzeichnis erben die Gruppe des Verzeichnisses.", "correct": false, "explanation": "Das ist die Wirkung des SGID-Bits auf ein Verzeichnis." },
{ "id": "c", "text": "Nur der Eigentümer darf Dateien im Verzeichnis löschen.", "correct": false, "explanation": "Das ist das Sticky-Bit auf Verzeichnissen, z. B. `/tmp`." },
{ "id": "d", "text": "Die Datei kann nicht mehr geändert oder gelöscht werden.", "correct": false, "explanation": "Das beschreibt das immutable-Attribut (`chattr +i`)." },
{ "id": "e", "text": "Das Programm darf nur von root ausgeführt werden.", "correct": false, "explanation": "Ausführen dürfen alle mit x-Recht; SUID ändert die effektive Benutzer-ID." }
],
"explanation": "Setzen: `chmod u+s datei` oder oktal 4xxx (SGID 2xxx, Sticky 1xxx). In `ls -l` erscheint `s` statt `x` beim Eigentümer.",
"references": ["man 1 chmod", "man 7 credentials"]
},
{
"id": "104.5-004",
"objective": "104.5",
"type": "single",
"difficulty": 2,
"question": "Die umask ist `027`. Welche Rechte erhält eine neu angelegte **reguläre Datei** (z. B. mit `touch`)?",
"options": [
{ "id": "a", "text": "`640` (`rw-r-----`)", "correct": true, "explanation": "Dateien starten mit 666; davon werden 027 maskiert → 640." },
{ "id": "b", "text": "`750` (`rwxr-x---`)", "correct": false, "explanation": "Das erhält ein neues **Verzeichnis** (777 − 027)." },
{ "id": "c", "text": "`027` (`----w-rwx`)", "correct": false, "explanation": "Die umask gibt an, was entfernt wird, nicht die Rechte selbst." },
{ "id": "d", "text": "`751` (`rwxr-x--x`)", "correct": false, "explanation": "Das passt weder zu Dateien noch zu Verzeichnissen mit dieser umask." },
{ "id": "e", "text": "`600` (`rw-------`)", "correct": false, "explanation": "Das ergäbe die umask 077." }
],
"explanation": "Programme erzeugen Dateien üblicherweise mit 666 und Verzeichnisse mit 777; die umask entfernt Bits. Anzeigen/Setzen mit `umask`, symbolisch mit `umask -S`.",
"references": ["help umask"]
},
{
"id": "104.5-005",
"objective": "104.5",
"type": "multi",
"difficulty": 1,
"question": "Mit welchen Befehlen ändert man die **Gruppe** der Datei `bericht.txt` auf `team`?",
"options": [
{ "id": "a", "text": "`chgrp team bericht.txt`", "correct": true, "explanation": "`chgrp` ändert nur die Gruppe." },
{ "id": "b", "text": "`chown :team bericht.txt`", "correct": true, "explanation": "Bei `chown` ändert die Form `:gruppe` nur die Gruppe (auch `.gruppe` wird noch akzeptiert)." },
{ "id": "c", "text": "`chmod g=team bericht.txt`", "correct": false, "explanation": "`chmod g=` setzt Rechte der Gruppe; `team` ist keine gültige Rechteangabe." },
{ "id": "d", "text": "`newgrp team bericht.txt`", "correct": false, "explanation": "`newgrp` startet eine Shell mit anderer primärer Gruppe; es ändert keine Datei." },
{ "id": "e", "text": "`usermod -g team bericht.txt`", "correct": false, "explanation": "`usermod -g` ändert die primäre Gruppe eines Benutzers." }
],
"explanation": "`chown benutzer:gruppe datei` ändert beides; `-R` arbeitet rekursiv. Normale Benutzer dürfen nur auf Gruppen wechseln, in denen sie Mitglied sind.",
"references": ["man 1 chgrp", "man 1 chown"]
},
{
"id": "104.6-001",
"objective": "104.6",
"type": "single",
"difficulty": 1,
"question": "Es soll ein symbolischer Link `aktuell` angelegt werden, der auf `release-2.4` zeigt. Welcher Befehl ist korrekt?",
"options": [
{ "id": "a", "text": "`ln -s release-2.4 aktuell`", "correct": true, "explanation": "Reihenfolge wie bei `cp`: erst Ziel (Original), dann der Name des Links." },
{ "id": "b", "text": "`ln -s aktuell release-2.4`", "correct": false, "explanation": "Vertauscht: Das legt `release-2.4` als Link auf `aktuell` an (bzw. scheitert, wenn es existiert)." },
{ "id": "c", "text": "`ln release-2.4 aktuell`", "correct": false, "explanation": "Ohne `-s` entsteht ein Hardlink; für Verzeichnisse ist das nicht erlaubt." },
{ "id": "d", "text": "`link -s release-2.4 aktuell`", "correct": false, "explanation": "`link` legt nur Hardlinks an und kennt kein `-s`." },
{ "id": "e", "text": "`mklink aktuell release-2.4`", "correct": false, "explanation": "`mklink` ist ein Windows-Befehl." }
],
"explanation": "Ein bestehenden Link umsetzen: `ln -sfn neues-ziel aktuell`.",
"references": ["man 1 ln"]
},
{
"id": "104.6-002",
"objective": "104.6",
"type": "multi",
"difficulty": 2,
"question": "Welche Aussagen über **Hardlinks** treffen zu?",
"options": [
{ "id": "a", "text": "Alle Hardlinks einer Datei verweisen auf denselben Inode.", "correct": true, "explanation": "Ein Hardlink ist nur ein weiterer Verzeichniseintrag für denselben Inode." },
{ "id": "b", "text": "Hardlinks können nicht über Dateisystemgrenzen hinweg angelegt werden.", "correct": true, "explanation": "Inode-Nummern sind nur innerhalb eines Dateisystems eindeutig." },
{ "id": "c", "text": "Normale Benutzer können Hardlinks auf Verzeichnisse anlegen.", "correct": false, "explanation": "Hardlinks auf Verzeichnisse sind nicht erlaubt (Schleifen im Baum)." },
{ "id": "d", "text": "Wird die ursprüngliche Datei gelöscht, ist der Hardlink defekt.", "correct": false, "explanation": "Die Daten bleiben, bis der Linkzähler 0 erreicht; defekt werden nur Symlinks." },
{ "id": "e", "text": "Ein Hardlink hat eigene, vom Original unabhängige Zugriffsrechte.", "correct": false, "explanation": "Rechte stehen im Inode und gelten für alle Namen gemeinsam." }
],
"explanation": "Der Linkzähler steht in `ls -l` in der zweiten Spalte. Symlinks haben einen eigenen Inode und enthalten den Pfad zum Ziel.",
"references": ["man 1 ln", "man 7 inode"]
},
{
"id": "104.6-003",
"objective": "104.6",
"type": "fill",
"difficulty": 1,
"question": "Welcher Befehl mit Option zeigt beim Auflisten eines Verzeichnisses die **Inode-Nummern** der Dateien an?",
"answers": ["ls -i", "ls --inode", "ls -li", "ls -il"],
"explanation": "Gleiche Inode-Nummer = Hardlinks derselben Datei. Alternativ zeigt `stat datei` den Inode einer einzelnen Datei.",
"references": ["man 1 ls"]
},
{
"id": "104.7-001",
"objective": "104.7",
"type": "single",
"difficulty": 1,
"question": "Wo gehören laut Filesystem Hierarchy Standard (FHS) die Protokolldateien des Systems hin?",
"options": [
{ "id": "a", "text": "`/var/log`", "correct": true, "explanation": "`/var` enthält variable Daten; `/var/log` die Protokolle." },
{ "id": "b", "text": "`/usr/log`", "correct": false, "explanation": "`/usr` ist für weitgehend statische, teilbare Daten gedacht und kann nur lesend eingehängt sein." },
{ "id": "c", "text": "`/etc/log`", "correct": false, "explanation": "`/etc` ist für hostspezifische Konfiguration gedacht." },
{ "id": "d", "text": "`/opt/log`", "correct": false, "explanation": "`/opt` ist für zusätzliche Softwarepakete gedacht; variable Daten solcher Pakete gehören nach `/var/opt`." },
{ "id": "e", "text": "`/srv/log`", "correct": false, "explanation": "`/srv` enthält Daten, die das System als Dienst ausliefert (z. B. Web, FTP)." }
],
"explanation": "Weitere FHS-Orte: `/var/spool` (Warteschlangen), `/var/cache`, `/var/lib` (Zustandsdaten), `/tmp` (temporär), `/usr/local` (lokal installierte Software).",
"references": ["man 7 hier", "https://refspecs.linuxfoundation.org/fhs.shtml"]
},
{
"id": "104.7-002",
"objective": "104.7",
"type": "single",
"difficulty": 1,
"question": "`locate` findet eine soeben angelegte Datei nicht. Was ist zu tun?",
"options": [
{ "id": "a", "text": "Die Datenbank mit `updatedb` aktualisieren", "correct": true, "explanation": "`locate` durchsucht eine Datenbank, die meist täglich per Cron/Timer mit `updatedb` erneuert wird." },
{ "id": "b", "text": "`hash -r` ausführen", "correct": false, "explanation": "`hash -r` leert die Tabelle der Programmpfade der Shell." },
{ "id": "c", "text": "`ldconfig` ausführen", "correct": false, "explanation": "`ldconfig` aktualisiert den Cache der Shared Libraries." },
{ "id": "d", "text": "`mandb` ausführen", "correct": false, "explanation": "`mandb` aktualisiert den Index der Manpages." },
{ "id": "e", "text": "`whereis -u` ausführen", "correct": false, "explanation": "`whereis -u` sucht nach „ungewöhnlichen“ Einträgen; mit der locate-Datenbank hat es nichts zu tun." }
],
"explanation": "Welche Pfade `updatedb` auslässt, steht in `/etc/updatedb.conf` (z. B. `PRUNEPATHS`, `PRUNEFS`). `find` durchsucht dagegen live das Dateisystem.",
"references": ["man 8 updatedb", "man 5 updatedb.conf"]
},
{
"id": "104.7-003",
"objective": "104.7",
"type": "multi",
"difficulty": 1,
"question": "Mit welchen Befehlen findet man heraus, wo das **Programm** `ls` im Dateisystem liegt?",
"options": [
{ "id": "a", "text": "`which ls`", "correct": true, "explanation": "`which` durchsucht den `PATH` und gibt den ersten Treffer aus." },
{ "id": "b", "text": "`whereis ls`", "correct": true, "explanation": "`whereis` zeigt Programm, Quellen und Manpages zu einem Befehl." },
{ "id": "c", "text": "`whatis ls`", "correct": false, "explanation": "`whatis` zeigt die Kurzbeschreibung aus der Manpage." },
{ "id": "d", "text": "`file ls`", "correct": false, "explanation": "`file` bestimmt den Typ einer Datei; `ls` würde im aktuellen Verzeichnis gesucht." },
{ "id": "e", "text": "`stat ls`", "correct": false, "explanation": "`stat` zeigt Inode-Daten einer Datei `ls` im aktuellen Verzeichnis." }
],
"explanation": "Für Shell-Aliase und Builtins hilft `type`; für beliebige Dateien `find` (live) oder `locate` (Datenbank).",
"references": ["man 1 which", "man 1 whereis"]
}
]
}